Share
Kohana is een PHP 5-framework dat het architecturale patroon van de Model View Controller (MVC) gebruikt. Er zijn verschillende redenen waarom u Kohana zou moeten kiezen, maar de belangrijkste zijn veiligheid, gewichtloosheid en eenvoud. In deze tutorial zal ik de belangrijkste functies introduceren, en met een eenvoudige demonstratie laat ik je zien hoeveel tijd Kohana je mogelijk kan besparen.
Kohana is een PHP5-raamwerk dat het architecturale patroon van Model View Controller gebruikt. MVC houdt toepassingslogica bij
los van de presentatie. Dit stelt ons in staat om schonere code te maken en tijd te besparen voor het zoeken naar fouten.
In onbekend met dit patroon:
Kohana was oorspronkelijk een vork van CodeIgniter (CI), een open-sourceproduct van EllisLab. Er zijn veel overeenkomsten tussen CI en Kohana, maar alle code is nieuw of volledig herschreven. Zoals je op de officiële Kohana-website kunt lezen, zijn de belangrijkste functies:
Laten we beginnen. Bezoek de officiële website van Kohana http://kohanaphp.com en klik op het groene vakje in de rechterhoek om de nieuwste versie te downloaden. Alle Kohana-bibliotheken, helpers en views zijn opgenomen in het standaarddownloadpakket, maar u kunt desgewenst extra modules, leveranciershulpprogramma's en talen selecteren. Ten behoeve van deze zelfstudie kan het standaardpakket voldoende zijn. Klik op "Download Kohana!" om met de download te beginnen.
Als je klaar bent met downloaden:
$ config ['site_domein'] = 'localhost / kohana';
Kohana zal in bijna elke omgeving draaien met minimale configuratie. Er zijn een paar minimale serververeisten:
Er zijn ook enkele vereiste uitbreidingen.
Als uw installatie is voltooid, wordt u doorgestuurd naar deze testpagina:
Als een van de tests mislukt, moet u deze corrigeren voordat u verder gaat.
Als alle tests zijn geslaagd, ga dan naar de Kohana-directory en verwijder of hernoem het script install.php. Vernieuwen en u ziet een welkomstpagina zoals deze:
Kohana is klaar om te gaan. Er is geen andere configuratie nodig. Dit kader is geweldig. Is het niet? Laten we wat code bekijken. Volg mij.
Canonical programming tutorials beginnen met het voorbeeld "Hallo wereld". Ik denk in plaats daarvan dat een eenvoudige applicatie je een duidelijk idee kan geven hoe het framework werkt. Dus we zullen een CD-collectiebeheerder bouwen - alleen voor een leuke demonstratie. Voordat we beginnen met coderen, is een korte introductie van het Kohana-bestandssysteem vereist.
Onze applicatie wordt geplaatst in de toepassing map. In deze map zijn er verschillende submappen, maar we hebben het volgende nodig voor ons project:
De resterende submappen zijn niet vereist voor deze zelfstudie, dus ik nodig u uit om meer te leren op de Kohana-website.
De systeem map host de Kohana-kern en de Kohana-hulpmiddelen zoals bibliotheken, helpers en vooraf gedefinieerde configuratiebestanden. In dit project zullen we een aantal bibliotheken en enkele helpers gebruiken - goede hulpmiddelen om je werk te versnellen.
De middelen map is geen vooraf gedefinieerde Kohana-map. Ik heb het gemaakt voor mediabestanden zoals CSS, JS en afbeeldingen. Ik zal je laten zien hoe deze bestanden in het project moeten worden opgenomen.
De modules map is de plaats om herbruikbare verzamelingen gerelateerde bestanden te plaatsen die samen een bepaalde functionaliteit aan een toepassing toevoegen. De authenticatiemodule, aangeboden door het Kohana-team, is een voorbeeld van een module.
Dit is een zeer korte inleiding tot het Kohana-bestandssysteem, maar het is genoeg voor de doeleinden van deze tutorial. Ik wil je niet meer vervelen met theorie.
Ik heb MySQL gekozen als mijn DBMS, maar onthoud dat Kohana ook ondersteuning biedt voor MsSQL, MySQLi, PostgreSQL, PDOSqlite. Maak een database met de naam "cd_collection" of kies de gewenste naam en voer de volgende SQL uit via phpMyAdmin of een tool voor het beheer van MySQL..
Accentsconagua
CREËER TABEL 'albums' ('id' int (11) NOT NULL auto_increment, 'naam' varchar (50) sorteer utf8_bin NOT NULL, 'auteur' varchar (50) sorteer utf8_bin NOT NULL, 'genre_id' int (11) NOT NULL , PRIMARY KEY ('id'), KEY 'genre_id' ('genre_id')) ENGINE = InnoDB DEFAULT CHARSET = utf8 COLLATE = utf8_bin AUTO_INCREMENT = 19; INSERT INTO 'albums' ('id', 'naam', 'auteur', 'genre_id') WAARDEN (2, 'Lijnen, Vines en Trying Times', 'Jonas Brothers', 16), (3, 'The END' , 'The Black Eyed Peas', 16), (4, 'Relapse', 'Eminem', 18), (5, 'Monuments And Melodies', 'Incubus', 1), (6, 'Thriller', 'Michael Jackson ', 16), (7,' Back in Black ',' AC / DC ', 4), (8,' The Dark Side of the Moon ',' Pink Floyd ', 4), (9,' Bat out of Hell ',' Meat Loaf ', 4), (10,' Backstreet Boys ',' Millennium ', 16), (11,' Rumours ',' Fleetwood Mac ', 4), (12,' Come on Over ' , 'Shania Twain', 16), (13, 'Led Zeppelin IV', 'Led Zeppelin', 4), (14, 'Jagged Little Pill', 'Alanis Morissette', 4), (15, 'Sgt. Pepper "s Lonely Hearts Club Band ',' The Beatles ', 16), (16,' Falling into You ',' C√ © line Dion ', 16), (17,' Music Box ',' Mariah Carey ', 16 ), (18, 'Born in the USA', 'Bruce Springsteen', 4); CREATE TABLE 'genres' ('id' int (11) NOT NULL auto_increment, 'name' varchar (50) sorteer utf8_bin NOT NULL, PRIMARY SLEUTEL ('id'), UNIEKE SLEUTEL 'naam' ('naam')) MOTOR = I nnoDB DEFAULT CHARSET = utf8 COLLATE = utf8_bin AUTO_INCREMENT = 22; INSERT INTO 'genres' ('id', 'naam') VALUES (1, 'Alternative Rock'), (2, 'Blues'), (3, 'Classical'), (4, 'Rock'), (5 , 'Country'), (6, 'Dance'), (7, 'Folk'), (8, 'Metal'), (9, 'Hawaiian'), (10, 'Imports'), (11, ' Indie Music '), (12,' Jazz '), (13,' Latin '), (14,' New Age '), (15,' Opera '), (16,' Pop '), (17,' Soul '), (18,' Rap '), (20,' Soundtracks '), (21,' World Music '); ALTER TABLE 'albums' ADD CONSTRAINT 'genre_inter_relational_constraint' FOREIGN KEY ('genre_id') REFERENTIES 'genres' ('id') OP VERWIJDERING CASCADE OP UPDATE CASCADE; Zoals je ziet, maakt de SQL twee tabellen, albums en genres en vult ze met wat gegevens. De laatste SQL-instructie voegt een beperking toe voor de externe sleutel "genre_id".
De databasestructuur is heel eenvoudig en heeft niet veel uitleg nodig.
Nu moet u Kohana vertellen waar uw database zich bevindt en hoe u deze kunt openen. Bewerk het algemene configuratiebestand system / config / database.php als volgt
$ config ['default'] = array ('benchmark' => TRUE, 'persistent' => FALSE, 'connection' => array ('type' => 'mysql', 'user' => 'root', ' pass '=>' root ',' host '=>' localhost ',' port '=> FALSE,' socket '=> FALSE,' database '=>' cd_collection '),' character_set '=>' utf8 ', 'table_prefix' => ", 'object' => TRUE, 'cache' => FALSE, 'escape' => TRUE); Deze code vertelt Kohana om verbinding te maken met een MySQL-database genaamd "cd_collection" op localhost met de gebruikersnaam "root" en het wachtwoord "root". U moet deze instellingen volgens uw databaseserverconfiguratie wijzigen.
Laten we nu onze eerste controller maken. Onthoud deze conventies.
Onthoud ook hoe Kohana zijn URL's structureert en hoe je een controlemechanismemethode kunt noemen; bijvoorbeeld http: //hostnaam/kohana_directory/index.php/controller/function.
Laten we deze eenvoudige controller eens bekijken.
PHP5 OOP is een vereiste. Dus als je niet goed thuis bent, kun je hier meer informatie vinden.
De constructorfunctie, genaamd __construct, initialiseert de klasse en roept de bovenliggende constructor aan.
De indexfunctie is de standaardfunctie, dus deze wordt opgeroepen als we de controller zonder bellen
specificeren van elke functie (bijvoorbeeld http: //localhost/index.php/kohana/album.) Na de naamcontroller
er is geen functie, de standaard indexfunctie wordt aangeroepen.)Gegeven deze basisregels, laten we ons concentreren op onze applicatie. De albumbesturing implementeert alle acties voor
het beheer van de albumsverzameling. Met deze controller kunnen we een nieuw album maken om de albums te tonen die zijn opgeslagen in onze database,
om een album bij te werken en om een album te verwijderen.Laten we de klas als volgt wijzigen.
Maak een bestand met de naam album.php in application / controllers / en plak het volgende.
album_model = nieuw Album_Model; $ this-> genre_model = nieuw Genre_Model; $ this-> list_view = new View ('list'); $ this-> update_view = new View ('update'); $ this-> create_view = new View ('create'); public function index () $ this-> show_albums_list (); private function show_albums_list () $ albums_list = $ this-> album_model-> get_list (); $ This-> list_view-> set ( 'albums_list', $ albums_list); $ This-> list_view-> render (true); openbare functie show_create_editor () $ this-> create_view-> set ('genres_list', $ this-> get_genres_list ()); $ This-> create_view-> render (true); public function show_update_editor ($ id) $ album_data = $ this-> album_model-> lezen ($ id); $ This-> update_view-> set ( 'album_id', $ album_data [0] -> id); $ This-> update_view-> set ( 'name', $ album_data [0] -> naam); $ This-> update_view-> set ( 'auteur', $ album_data [0] -> auteur); $ This-> update_view-> set ( 'genre_id', $ album_data [0] -> genre_id); $ This-> update_view-> set ( 'genres_list', $ this-> get_genres_list ()); $ This-> update_view-> render (true); public function create () $ album_data = array ('name' => $ this-> input-> post ('name'), 'author' => $ this-> input-> post ('auteur'), 'genre_id' => $ this-> input-> post ('genre_id')); $ This-> album_model-> create (album_data $); url :: redirect ( 'album'); public function update () $ album_data = array ('name' => $ this-> input-> post ('name'), 'author' => $ this-> input-> post ('auteur'), 'genre_id' => $ this-> input-> post ('genre_id')); $ This-> album_model->-update ($ this-> input-> post ( 'album_id'), $ album_data); url :: redirect ( 'album'); public function delete ($ id) $ this-> album_model-> verwijderen ($ id); url :: redirect ( 'album'); private function get_genres_list () $ db_genres_list = $ this-> genre_model-> get_list (); $ genres_list = array (); if (sizeof ($ db_genres_list)> = 1) foreach ($ db_genres_list als $ item) $ genres_list [$ item-> id] = $ item-> naam; return $ genres_list;Laat me uitleggen wat deze code doet.
Vijf ledenvariabelen worden bovenaan in de klas gedeclareerd:
privé $ album_model; privé $ genre_model; privé $ list_view; privé $ create_view; privé $ update_view;Deze leden zijn privé omdat ik de zichtbaarheid alleen tot deze klasse wil beperken.
In de construct-methode worden de model- en weergave-objecten gemaakt met behulp van de vijf leden:
$ this-> album_model = nieuw Album_Model; $ this-> genre_model = nieuw Genre_Model; $ this-> list_view = new View ('list'); $ this-> update_view = new View ('update'); $ this-> create_view = new View ('create');Gebruik deze syntaxis om een modelobject te maken:
$ obj_name = nieuw Name_Model;Gebruik deze syntaxis om een weergaveobject te maken:
$ obj_name = nieuwe weergave ('view_filename_without_extension');Nu zijn er twee objecten om toegang te krijgen tot het album- en genrymodel en drie objecten om toegang te krijgen tot de weergaven die nodig zijn om de presentatie weer te geven.
De indexmethode roept de methode show_albums_list aan die alle albums vermeldt die in de database zijn opgeslagen.
$ albums_list = $ this-> album_model-> get_list (); $ This-> list_view-> set ( 'albums_list', $ albums_list); $ This-> list_view-> render (true);In deze methode kunt u zien hoe het model en het weergaveobject worden gebruikt om toegang te krijgen tot relatieve methoden. "get_list" is een modelmethode (we zullen hem later zien) die alle albums retourneert die in de database zijn opgeslagen. Het resultaat wordt opgeslagen in de array "$ albumlijst". Om de resultaatarray van de controller door te geven aan de weergave, wordt de "set" -methode aangeroepen op het view-object. Voor deze methode zijn twee parameters vereist: een nieuwe lege variabele (albumlijst) die gegevens van een bestaande variabele ($ albumlijst) bevat. Nu bevat de nieuwe variabele "albumlijst" de array $ album_lijst (we zullen later zien hoe de inhoud in de weergave wordt getoond). De methode "render", met de parameter TRUE, is nodig om gegevens naar de browser uit te voeren.
De show_create_editor-methode toont de gebruikersinterface om een nieuw album in te voegen.
$ This-> create_view-> set ( 'genres_list', $ this-> get_genres_list ()); $ This-> create_view-> render (true);De lijst met genres wordt doorgegeven aan de weergave.
De show_update_editor-methode toont de gebruikersinterface om een bestaand album bij te werken.
$ album_data = $ this-> album_model-> lezen ($ id); $ This-> update_view-> set ( 'album_id', $ album_data [0] -> id); $ This-> update_view-> set ( 'name', $ album_data [0] -> naam); $ This-> update_view-> set ( 'auteur', $ album_data [0] -> auteur); $ This-> update_view-> set ( 'genre_id', $ album_data [0] -> genre_id); $ This-> update_view-> set ( 'genres_list', $ this-> get_genres_list ()); $ This-> update_view-> render (true);"lezen" is een modelmethode (we zullen het later zien) die gegevens ($ album_data) van het album retourneert met een id gelijk aan $ id. Vervolgens wordt elk afzonderlijk element van het geretourneerde gegevensalbum doorgegeven aan de weergave.
De aanmaakmethode ontvangt gegevens voor een nieuw album uit de weergave en gegevens worden opgeslagen in de database.
$ album_data = array ('name' => $ this-> input-> post ('name'), 'author' => $ this-> input-> post ('auteur'), 'genre_id' => $ this -> input-> post ('genre_id')); $ This-> album_model-> create (album_data $); url :: redirect ( 'album');$ album_data is een array die de POST-gegevens uit de weergave bevat. Om het album op te slaan, wordt de array doorgegeven aan de methode create model. De laatste regel is een aanroep naar een hulpmethode. Helpers zijn eenvoudig functies die u helpen bij de ontwikkeling. De helperklassen worden automatisch geladen door het raamwerk. Helpers worden verklaard als statische methoden van een klasse, dus het is niet nodig om de klasse te instantiëren. In dit geval wordt de methode "redirect" van de helper "url" genoemd en vertelt Kohana om de browser om te leiden naar de albumcontroller. Hiermee wordt een nieuwe invoeging vermeden (bijvoorbeeld op F5 drukken).
"Helpers zijn gewoon functies die je helpen bij de ontwikkeling."
De update- en verwijderingsmethoden werken op dezelfde manier als de bovenstaande methode.
De laatste methode get_genres_list haalt de genreslijst uit het model ($ db_genres_list) en bouwt een nieuwe array ($ genres_list) voor het selectievakje in de views.
$ db_genres_list = $ this-> genre_model-> get_list (); $ genres_list = array (); if (sizeof ($ db_genres_list)> = 1) foreach ($ db_genres_list als $ item) $ genres_list [$ item-> id] = $ item-> naam; return $ genres_list;Stap 8: Maak een projectmodel
Laten we nu modellen maken voor onze webapplicatie. Onthoud deze conventies.
Hier is de modelcode van het album. Maak een bestand met de naam album.php in application / modellen / en plak de onderstaande code erop.
album_table = 'albums'; $ this-> genre_table = 'genres'; openbare functie lezen ($ id) $ this-> db-> where ('id', $ id); $ query = $ this-> db-> get ($ this-> albumtabel); return $ query-> result_array (); public function delete ($ id) $ this-> db-> delete ($ this-> album_tabel, array ('id' => $ id)); update van publieke functie ($ id, $ data) $ this-> db-> update ($ this-> albumtabel, $ data, array ('id' => $ id)); public function create ($ data) $ this-> db-> insert ($ this-> album_tabel, $ gegevens); openbare functie get_list () $ this-> db-> select ('albums.id als id, albums.naam als naam, albums.author als auteur, genres.naam als genre'); $ This-> db-> vanaf ($ this-> album_table); $ This-> db-> doe mee ($ this-> genre_table, 'genres.id', 'albums.genre_id'); $ query = $ this-> db-> get (); return $ query-> result_array (); Alle methoden in de modellen maken gebruik van de syntaxis van de Query-builder. Deze Kohana-tool versnelt de ontwikkelingstijd van databases en vereenvoudigt het maken van query's.
Twee ledenvariabelen worden bovenaan in de klas gedeclareerd:
privé $ album_tabel; privé $ genre_table;
Deze leden zijn privé omdat ik de zichtbaarheid alleen tot deze klasse wil beperken. Dit zijn de containers voor de databasetabelnamen.
De eerste regel in de constructormethode laadt de Kohana-databasebibliotheek in $ this-> db. In de tweede en derde regel worden de twee klassenleden geïnitialiseerd.
bovenliggende :: __ construct (); $ this-> album_table = 'albums'; $ this-> genre_table = 'genres';
De query in de leesmethode haalt albumrecords op met een bepaalde ID ("$ id").
$ this-> db-> where ('id', $ id); $ query = $ this-> db-> get ($ this-> albumtabel); return $ query-> result_array (); De query in de verwijderingsmethode verwijdert de albustabelrij met een bepaalde id ("$ id").
$ this-> db-> delete ($ this-> album_tabel, array ('id' => $ id)); De query in de updatemethode werkt de albustabelrij bij met een bepaalde id ("$ id") met nieuwe waarden uit de array "$ data".
$ this-> db-> update ($ this-> albumtabel, $ data, array ('id' => $ id)); De array "$ data" moet recordnamen bevatten als sleutels van de array en waarde als waarden van de array. De array "$ data" moet dit formulier hebben:
$ data = array ('name' => 'album_name', 'author' => 'author_name', 'genre_id' => 'genre_id'); De query in de methode create voegt een nieuw record in met waarden van de array "$ data".
$ this-> db-> insert ($ this-> album_tabel, $ gegevens);
De array "$ data" moet dit formulier hebben:
$ data = array ('id' => 'album_id', 'naam' => 'albumnaam', 'auteur' => 'auteur_naam', 'genre_id' => 'genre_id'); De query in de methode get_list haalt alle rijen van albums op.
$ this-> db-> select ('albums.id als id, albums.naam als naam, albums.auteur als auteur, genres.naam als genre'); $ This-> db-> vanaf ($ this-> album_table); $ This-> db-> doe mee ($ this-> genre_table, 'genres.id', 'albums.genre_id'); $ query = $ this-> db-> get (); return $ query-> result_array (); Nu, het genremodel. Maak een bestand met de naam genre.php in application / modellen / en plak de code eronder:
genre_table = 'genres'; functie get_list () $ query = $ this-> db-> get ($ this-> genre_table); return $ query-> result_array ();
Dit model is heel eenvoudig, dus ik zal geen tijd meer verspillen om er commentaar op te geven. De modellen en de controller zijn klaar voor gebruik. Laten we nu aan de weergaven werken.
Weergaven zijn bestanden die de presentatielaag voor uw toepassing bevatten. Het doel is om deze informatie gescheiden te houden van uw toepassingslogica voor eenvoudige herbruikbaarheid en schonere code. Voor dit project zijn drie weergaven vereist: een weergave van de albumverzameling, een weergave om een nieuw album te maken en een weergave om een bestaand album te bewerken.
Maak een bestand met de naam list.php in application / views / en plak de volgende code in:
CD-INZAMELING
| CD-verzameling | ||||
| Album naam | Schrijver | Genre | "$ Item-> naam." | "; echo""$ Item-> auteur." | "; echo""$ Item-> genre." | "; echo"" .Html :: anchor ( 'album / delete /'.$ item-> id, html :: imago (' assets / images / delete.png '))." | "; echo"" .Html :: anchor ( 'album / show_update_editor /'.$ item-> id, html :: imago (' assets / images / edit.png '))." | "; echo"";?>
Deze weergave toont een html-pagina met een lijst van alle albums. Deze lijst is gemaakt met de foreach-lus die de informatie in een html-tabel afdrukt. Voor elke albumreeks zijn er twee afbeeldingen: een "rood kruis" en een "pocketboek". Ze koppelen respectievelijk de verwijderingsmethode van de controller en de updatemethode. Beide geven het album-ID door aan de albumcontroller met behulp van een get-verzoek. Boven de lijst bevindt zich een knop om nieuwe albums te maken. In deze code maken we ook gebruik van een html-helper van Kohana die bewerkingen versnelt om html-pagina's te schrijven.
Laten we nu een bestand maken met de naam create.php in application / views /.
CD-INZAMELING
| Maak een nieuw album | ".form :: label ('name', 'Name:')." | "; echo"" .Form :: ingang ( 'name', ")." | "; echo""; echo"
| ".form :: label ('auteur', 'Auteur:')." | "; echo"" .Form :: ingang ( 'auteur', ")." | "; echo"
| ".form :: label ('genre', 'Genre:')." | "; echo"".Form :: dropdown ( 'genre_id', $ genres_list)." | "; echo"
| ".form :: submit ('submit', 'Create album')." | "; echo"|
De laatste maar niet de minste is de updateweergave. Laten we een bestand maken met de naam update.php in application / views /.
CD-INZAMELING
| Update album | ".form :: label ('name', 'Name:')." | "; echo"".form :: input ('name', $ name)." | "; echo""; echo"
| ".form :: label ('auteur', 'Auteur:')." | "; echo"".form :: input ('author', $ author)." | "; echo"
| ".form :: label ('genre', 'Genre:')." | "; echo"".form :: dropdown ('genre_id', $ genres_list, $ genre_id)." | "; echo"
| ".form :: submit ('submit', 'Update album')." | "; echo"|
De eerste is een eenvoudige editor waarmee de gebruiker informatie over een nieuw album kan invoegen.
De velden zoals auteur en naam worden ingevoegd met behulp van een html-invoer en -genre
keuzelijst met invoervak. Zodra de gebruiker op de knop Maken klikt, wordt alle informatie doorgegeven,
als een POST-aanvraag, naar de create / update-methode in de albumcontroller. Wanneer de controller deze gepost ontvangt
variabelen, het roept het model op dat een nieuw album invoegt in de database. De formulieren maken in beide aanzichten gebruik van Kohana-formulierhulp.
Om een beetje stijl aan onze applicatie te geven, maakt u de middelen map in de Kohana-hoofdmap op hetzelfde niveau van de toepassingsmap. Open het nu en maak twee nieuwe mappen: css en afbeeldingen.
In de css map maak een nieuw bestand met de naam style.css en plak dit:
een font-family: Verdana, Geneva, Arial, Helvetica, sans-serif; font-gewicht: normaal; lettergrootte: 12px; kleur: # 00F; vertical-align: text-top; img border: 0; label font-family: Verdana, Geneva, Arial, Helvetica, sans-serif; font-gewicht: normaal; lettergrootte: 12px; invoer border: 1px solid # 000; selecteer width: 185px; table.editor text-align: center; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif; font-gewicht: normaal; font-size: 11px; kleur: #fff; breedte: 280 px; achtergrondkleur: # 666; rand: 0px; border-collapse: collapse; randafstand: 0px; table.editor td.editor_title background-colour: # 666; kleur: #fff; opvulling: 4px; text-align: left; lettertype: vet; lettergrootte: 16px; table.editor td opvulling: 4px; table.list text-align: center; font-family: Verdana, Geneva, Arial, Helvetica, sans-serif; font-gewicht: normaal; font-size: 11px; kleur: #fff; breedte: 280 px; achtergrondkleur: # 666; rand: 0px; border-collapse: collapse; randafstand: 0px; table.list td.item background-color: #CCC; kleur: # 000; opvulling: 4px; text-align: left; border: 1px #fff solid; table.list td.list_title, table.list td.headers background-color: # 666; kleur: #fff; opvulling: 4px; text-align: left; border-bottom: 2px #fff solid; lettertype: vet; table.list td.list_title font-size: 16px; table.list td.headers font-size: 12px;
Kopieer nu de volgende afbeeldingen naar de afbeeldingen map:
Dat is alles. Richt uw browser op http: //localhost/kohana/index.php/album en je zou iets moeten zien dat er zo uitziet:
Als u een nieuw album probeert te maken of een bestaand album wilt bewerken, ziet u iets soortgelijks als dit:
Natuurlijk zijn er enkele verbeteringen nodig voor deze applicatie, maar met een kleine hoeveelheid code, heb je een kleine webapplicatie gemaakt.
Nu weet u hoe u het MVC-patroon met Kohana moet gebruiken en hoe u databankenbibliotheken en helpers kunt gebruiken. Lees de officiële documentatie voor meer informatie.
Dankzij Kohana is code-onderhoud een eenvoudige taak en het toevoegen van nieuwe functies is een makkie. Ik hoop dat je deze tutorial leuk vond. Blijf op de hoogte om meer over Kohana te leren.
