Programmazione Web » rapid application development http://www.programmazione-web.com il Blog open degli sviluppatori del web! Tue, 10 Nov 2009 21:04:43 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 Tutorial con il Framework CodeIgniter http://www.programmazione-web.com/tutorial-con-il-framework-codeigniter.php http://www.programmazione-web.com/tutorial-con-il-framework-codeigniter.php#comments Sun, 09 Mar 2008 18:23:34 +0000 neryo http://www.programmazione-web.com/tutorial-con-il-framework-codeigniter.php Tutorial con il Framework CodeIgniter Perché dovrei usare CodeIgniter?
Come detto in precedenza nell’articolo “Programmare il Web seguendo MVC” ci sono tantissime scelte per sviluppare applicazioni PHP con dei framework che permettono una programmazione di tipo RAD (Rapid Application Development), basta dare un’occhiata a questa lista, ognuno di essi avrá sicuramente vantaggi e svantaggi discutibili. Molti framework offrono ORM (Object-relational Mapping); alcuni sistemi di autenticazione o interfaccie con AJAX. In ogni caso comunque, quello che solitamente si vuole, é un ambiente che permetta di programmare velocemente senza dover affrontare librerie troppo complesse, CodeIgniter sembra permettere questo offrendo comunque molteplici ed utili funzionalità!

Un esempio concreto:
In questo esempio vi introduco una semplice implementazione di un piccolo software utilizzando come base di sviluppo il framework CodeIgniter, costruiremo una semplice “job board”. I Jobs per questo esempio, saranno inseriti manualmente tramite phpmyadmin o direttamente da una shell mysql nella tabella del database chiamata “jobs” creata opportunamente con questa query SQL:

  1. CREATE TABLE `jobs` (
  2. `id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
  3. `title` TEXT NOT NULL,
  4. `company` TEXT NOT NULL,
  5. `description` TEXT NOT NULL
  6. );

Nella semplice applicazione ci saranno sostanzialmente due semplici pagine:

  • La lista di tutti i jobs;
  • Visuale del job in dettaglio;

Configurazione di CodeIgniter

Ovviamente si presuppone che abbiate installato sulla vostra postazione un server PHP e MySQL. Innanzitutto scaricate, CodeIgniter, estraete il contenuto dentro la vostra cartella di root del vostro web server tutti i files contenuti nel pacchetto; Per il test io ho rinominato la cartella in /CodeIgniter, questo perché poi nella configurazione non dovete editare la configurazione del base_url. Aprite il file system/application/config.php nella cartella CodeIgniter estratta. E’ molto semplice capire cosa c’é in questo file perché é ben commentato. Se avete estratto la cartella nella root e l’avete chiamata come sopra non dovete toccare nulla.

  1. $config[‘base_url’]    = "http://127.0.0.1/CodeIgniter/";

Inoltre bisogna configurare l’accesso per permettere al framework di parlare con il database Mysql, quindi aprite system/application/database.php e scorrete finché non trovate le configurazioni del database da settare con le vostre locali.

  1. $db[‘default’][‘hostname’] = "localhost";
  2. $db[‘default’][‘username’] = "root";
  3. $db[‘default’][‘password’] = "";
  4. $db[‘default’][‘database’] = "test";
  5. …

Io per effettuare il test ho creato un database chiamato test sul mio DBMS mysql locale inserendo la tabella jobs.
Possiamo notare come CodeIgniter con questa tipologia di configurazione ci permetta, nel caso lo volessimo, di passare velocemente la configurazione tra differenti server con differenti database. Per maggiori dettagli e implementazioni sulle configurazione fate riferimento al manuale online.

Realizzazione dell’applicazione

Per realizzare la nostra job board implementeremo un controller, un modello e due viste. Il controller gestirá sia la lista principale dei jobs, sia il dettagli del signolo job, con un modello di metodo e per ogni vista. In questo modo, chiaramente verranno distinte le diverse parti della nostra applicazione.

Vi faccio notare come CodeIgniter abbia una convenzione con i nomi dei file: tutti i nomi dei files sono composti da caratteri minuscoli, tutte i nomi delle classi iniziano con una lettera maiuscola e sono poste in file con lo stesso nome piu il nome dell’estensione .php.

Il controller

Il Controller é una classe con alcuni metodi che gestiscono le varie richieste direzionandole opportunamente ove necessario. La classe estende la classe base di CodeIgniter “Controller” fornendo quindi l’accesso a tutte le funzionalitá del framework. Nel controller noi andremo a caricare tutte le risorse di cui avremo bisogno, in particolare un modello e le due viste. Niente verrá caricato di default, questo perché CodeIgniter é stato progettato per essere un framework molto leggero ed essenziale. L’oggetto $this->load consente al sistema di caricare le risorse di cui abbiamo bisogno, qui sotto il codice del controller: system/application/controllers/jobs.php

  1. < ?php
  2.  
  3. class Jobs extends Controller {
  4.  
  5. function index() {
  6.    // This gives us redirect()
  7.     $this->load->helper(‘url’);
  8.     redirect(‘jobs/list_jobs’);
  9. }
  10.  
  11. function list_jobs() {
  12.  
  13. $this->load->database();
  14. $this->load->model(‘jobs_model’);
  15.  
  16. $data[‘jobs’] = $this->jobs_model->get_jobs();
  17.  
  18. // This gives us anchor() – see the view at the end
  19. $this->load->helper(‘url’);
  20. $this->load->view(‘jobs_view’, $data);
  21. }
  22.  
  23. function view_job($id = false) {
  24.  
  25. $this->load->helper(‘url’);
  26.  
  27. if (!$id) redirect(‘jobs/list_jobs’);
  28.  
  29. $this->load->database();
  30. $this->load->model(‘jobs_model’);
  31.  
  32. $data[‘job’] = $this->jobs_model->get_job($id);
  33. $this->load->view(‘job_view’, $data);
  34. }
  35. }

Come potete vedere, il controller é molto semplice, si incarica di prendere i dati dal modello e di inviarli alla vista. Ogni metodo inizia con la chiamata alla routine $this->load->database(), la quale si connetterá al database e preparerá le librerie per interfacciarsi utilizzando i settaggi precedentemente definiti. Questo é l’approcio di CodeIgniter al modello $this->load->model('classname') caricherá il file system/application/models/classname.php inizializzando l’instanza della classe Classname (non cé bisogno di includere altri files). Essa restituirá un riferimento al nuovo oggettto $this->classname. E’ possibile sovrascrivere questo comportamento passando un secondo argomento, che potrá essere usato come proprietá del nome dell’oggetto. Ad esempio, si puo chiamare $this->load->model('someclass', 'data'); e accedere cosí al modello della classe $this->data invece di $this->someclass.

Il modello

Come per il controller il Modello estenderá la classe predefinita “Model”. Una volta che il database sará inizializzato tramite la chiamata a $this->load->database(), avremo accesso completo alla classe dei database di CodeIgniter . Come sappiamo dal controller, nel nostro modello avremo due metodi, uno per recuperare tutti i jobs del database, da noi chiamato get_jobs(), e l’altro per recuperare i dettagli di un job, chiamato get_job($job_id). Non ci sono particolari convenzioni dei nomi per il modello, comunque é tipico usare il nome del controller con in aggiunta _model alla fine. Il manuale di CodeIgniter ha un eccellente guida veloce alle librerie del database, che potete leggere prima di procedere oltre.
Ecco a voi il codice del modello: system/application/models/jobs_model.php

  1. < ?php
  2.  
  3. class Jobs_model extends Model {
  4.  
  5. function get_jobs() {
  6.  
  7.  $query = $this->db->get(‘jobs’);
  8.  
  9.  foreach ($query->result_array() as $row){
  10.   $result[] = $row;
  11.  }
  12.  
  13.  return $result;
  14. }
  15.  
  16. function get_job($job_id) {
  17.  
  18.  $query = $this->db->where(‘id’, $job_id)->get(‘jobs’);
  19.  $result = $query->row_array();
  20.  
  21.  return $result;
  22. }
  23. }

Prendiamoci un attimo per esaminare questo codice che per certi versi é la parte piú complessa di questo tutorial. CodeIgniter ha una classe Active Record che consente agli sviluppatori di accedere ai database in Active Record-style. Si puó scrivere la query SQL e passarla a $this->db->query(), ma ci sono molte casistiche in cui conviene utilizzare la classe Active Record, ricordando che CodeIgniter gestirá automaticamente l’eventuale prefisso delle tabelle che avrete settato nel file di configurazione del database. Un esempio di query di selezione tipo SELECT * FROM table WHERE id='0', utilizzando la classe Active Record:

  1. $this->db->select(‘*’)
  2.          ->from(‘table’)
  3.          ->where(‘id’, ‘0′)
  4.          ->get();

Da notare il metodo get()che alla chiamata interroga la libreria costruendo la query e se non gli vengono date ulteriori informazioni, assume che sia di default una SELECT * FROM ‘table’, eseguendo la query ritornando un oggetto result che é possibile maneggiare con molta facilitá ad esempio applicandogli il metodo result_array() oppure row_array() che é simile solo che restituisce una singola riga.

La vista

Questo é l’ultimo passo, che serve per presentarci l’applicazione. Noi abbiamo preso tutti i dati di cui avevamo bisogno dal database attraverso il modello e li dobbiamo passare attraverso il controllore ad una vista. La nostra vista si chiamerá jobs_view. L’abbiamo deciso quando abbiamo scritto questa riga di codice nel controller:

  1. $this->load->view(‘jobs_view’, $data);

Questa sostanzialmente dice a CodeIgniter di caricare la vista in system/application/views/jobs_view.php, e di recuperare l’array associativo $data e creare una variabile con la vista $data['jobs'] che ci dará accesso alla variabile $jobs. Per verificarlo basta creare un file nel path delle viste chiamandolo jobs_view.php ed insererire la stampa del vettore < ?=print_r($jobs)?>. Il risultato dovrebbe essere qualcosa di questo stampo:

  1. Array
  2. (
  3.     [0] => Array(
  4.             [id] => 1
  5.             [title] => Web Developer
  6.             [company] => Google
  7.             [description] => Develop kick-ass web applications
  8.                              for the mighty Google.
  9.         )
  10.     [1] => Arra (
  11.             [id] => 2
  12.             [title] => Sr. Web Developer
  13.             [company] => Ellis Lab
  14.             [description] => Help the world develop kick-ass web
  15.                              applications with our software.
  16.         )
  17. )

Ora forse, si potrebbe affermare che sarebbero bastati dei semplici mysql_query() e mysql_fetch_array() per fare tutto questo, ma sicuramente se si vorrá poi esterndere l’ applicazione in modo semplice e veloce mantenendone il controllo, e questo é sicuramente uno dei framework adatti per semplificarci notevolmente la vita.

Di seguito il file vista inserendo i dati nel codice html: system/application/views/jobs_view.php

  1.  
  2. <table style="border-collapse: collapse;" border="1">
  3. <thead>
  4. <tr>
  5. <th>Job Title</th>
  6. <th>Company</th>
  7. <th>View</th>
  8. </tr>
  9. </thead>
  10. <tbody>< ?php foreach ($jobs as $job): ?>
  11. <tr>
  12. <td>< ?=$job[‘title’]?></td>
  13. <td>< ?=$job[‘company’]?></td>
  14. <td>< ?=anchor(‘jobs/view_job/’.$job[‘id’], ‘View’)?></td>
  15. </tr>
  16. < ?php endforeach; ?></tbody></table>
  17.  

La vista per un dettaglio di un job: system/application/views/job_view.php

  1.  
  2. <h1>Viewing Job: < ?=$job[‘title’]?></h1>
  3. <strong>< ?=$job[‘company’]?></strong>
  4.  
  5. < ?=$job[‘description’]?>

Ora abbiamo terminato di creare la nostra prima applicazione con il framework MVC CodeIgniter.

Ci basta caricare http://localhost/CodeIgniter/index.php/jobs/list_jobs per vedere il risultato finito!!

Per eventuali dubbi o segnalazioni commentate pure!

Traduzione parziale dell’articolo:
Rapid Development with CodeIgniter del 17-02-2008 » http://www.developertutorials.com
a cura di Valerio Giacomelli (neryo)

]]> http://www.programmazione-web.com/tutorial-con-il-framework-codeigniter.php/feed 5