FuelPHP - Modelos e banco de dados

O modelo desempenha um papel importante no framework da web FuelPHP. Ele representa as entidades comerciais do aplicativo. Eles são fornecidos pelos clientes ou buscados no banco de dados de backend, manipulados de acordo com as regras de negócios e persistidos de volta no banco de dados. Vamos aprender sobre os modelos e como eles interagem com o sistema back-end neste capítulo.

Criando um modelo

No FuelPHP, o modelo é simplesmente uma classe PHP simples que estende a classe interna Model. Por padrão, os modelos podem ser prefixados com Model_ semelhante aos controladores e devem ser colocados emfuel/app/classes/model/pasta. Vamos criar um modelo básico de funcionário e estendê-lo à medida que prosseguimos.

fuel / app / classes / model / employee.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Acesse um modelo

Uma vez que um modelo é definido, ele pode ser usado livremente em qualquer controlador apenas incluindo-o no controlador como segue.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Visão geral do banco de dados

FuelPHP fornece sua própria camada de abstração de banco de dados para buscar dados do banco de dados. Ele fornece ferramentas baseadas em ORM tanto básicas quanto avançadas. O kit de ferramentas básico consiste em classes baseadas em DB, DBUtil e Query_Builer. O kit de ferramentas avançado é Orm. O kit de ferramentas Orm é derivado do kit de ferramentas básico e empacotado como um pacote separado.

Configuração de banco de dados

FuelPHP separa as configurações do banco de dados do arquivo de configuração principal e o arquivo é fuel/app/config/db.php. Ele suporta uma configuração separada para cada ambiente. Atualmente, o FuelPHP suporta drivers MySQL, MySQLi e PDO. A configuração de amostra é a seguinte -

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Toolkit baseado em banco de dados

o DB classé a opção mais simples para acessar o banco de dados do aplicativo. Ele fornece opções para construir a consulta do banco de dados, executá-la no banco de dados de destino e, finalmente, buscar o resultado. A classe DB interage com as seguintes classes e fornece uma API de banco de dados abrangente.

  • Database_Connection - Singleton e classe principal para interagir com o banco de dados

  • Database_Query - Base, classe concreta para executar a consulta SQL e buscar o resultado

  • Database_Query_Builder - Base, classe abstrata para construir consulta SQL

  • Database_Query_Builder_Join - Classe para construir junções SQL

  • Database_Query_Builder_Where - Classe abstrata para construir condições de consulta SQL

  • Database_Query_Builder_Select - Classe concreta para construir consulta SQL select

  • Database_Query_Builder_Insert - Classe abstrata para construir consulta de inserção SQL

  • Database_Query_Builder_Update - Classe abstrata para construir consulta de atualização SQL

  • Database_Query_Builder_Delete - Classe abstrata para construir consulta de exclusão SQL

O diagrama a seguir descreve o relacionamento entre as classes e os métodos fornecidos pelas classes.

API DB

Vamos aprender os métodos mais importantes disponíveis na classe DB nesta seção.

instância

  • Purpose- Cria e retorna a nova instância Database_Connection .

  • Parameter -

    • $db - Nome da conexão do banco de dados definido no arquivo de configuração, opcional.

  • Returns- Retorna o objeto Database_Connection

Por exemplo,

$db = DB::instance(); 
$db = DB::instance('test');

inquerir

  • Purpose - Prepare a instrução SQL fornecida e retorna o objeto Database_Query, que pode ser usado para inserir, atualizar, excluir ou buscar os dados do banco de dados.

  • Parameter -

    • $query - Instrução SQL, pode conter marcadores de posição;

    • $type - Tipo SQL, opcional (DB :: SELECT, DB :: INSERT, DB :: UPDATE e DB :: DELETE)

  • Returns- Retorna o objeto Database_Query

Por exemplo,

$query = DB::query('SELECT * FROM 'employees'');

last_query

  • Purpose - Para obter a última consulta executada

  • Parameter - nenhum

  • Returns - Retorna a última consulta executada

Por exemplo,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

selecionar

  • Purpose - Gere a parte selecionada da consulta

  • Parameter -

    • $columns - Lista dos nomes das colunas do banco de dados

  • Returns - Retorna o objeto Database_Query_Builder_Select

Por exemplo,

$query = DB::select();              // Select *
$query = DB::select('id', 'name'); // Select id, name

select_array (DB)

É semelhante ao select, exceto que podemos enviar colunas como array.

$query = DB::select_array(array('id', 'name')); // Select id, name

inserir

  • Purpose - Gere a parte de inserção da consulta

  • Parameter -

    • $table_name - nome da tabela do banco de dados;

    • $columns - matriz de colunas da tabela

  • Returns - Retorna o objeto Database_Query_Builder_Insert

Por exemplo,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

atualizar

  • Purpose - Gere a parte de atualização da consulta

  • Parameter -

    • $table_name - nome da tabela do banco de dados

  • Returns - Retorna o objeto Database_Query_Builder_Update

Por exemplo,

$query = DB::update('employee'); // update `employee`

excluir

  • Purpose - Gere a parte de exclusão da consulta

  • Parameter -

    • $table_name - nome da tabela do banco de dados

  • Returns - Retorna o objeto Database_Query_Builder_Delete

Por exemplo

$query = DB::delete('employee');  // delete from 'employee'

API de consulta

Database_Queryfornece uma opção para definir a conexão do banco de dados, executar a consulta e buscar o resultado como uma matriz ou objeto associativo. Vamos ver os métodos fornecidos pela classe Database_Query.

set_connection

  • Purpose - Para definir o banco de dados (detalhes de conexão do banco de dados) contra o qual executar a consulta

  • Parameter - $ db - nome da conexão do banco de dados

  • Returns- Retorna o objeto Database_Query

Por exemplo,

$query = DB::query('DELETE * FROM employee', DB::DELETE); 
$query->set_connection('2nd-db');

param

  • Purpose - Para definir o valor do parâmetro definido no objeto Consulta

  • Parameter -

    • $param - nome do parâmetro;

    • $value - valor do parâmetro

  • Returns- Retorna o objeto Database_Query

Por exemplo,

// set some variables
$table = 'employee';
$id = 1;
$name = 'Jon';

// don't use
$query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"');

// but use
$query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee');
$query->param('id', $id);
$query->param('name', $name);

Métodos semelhantes

parameters é um objeto semelhante, exceto que fornece a opção de fornecer vários valores de uma vez.

$query->parameters (array( 
   'tablename' => $table, 
   'id' => $id, 
   'name' => $name 
});

ligar

  • Purpose - Para definir uma variável para o parâmetro definido no objeto Consulta

  • Parameter -

    • $param - nome do parâmetro

    • $var - a variável para vincular o parâmetro

  • Returns- Retorna o objeto Database_Query

Por exemplo,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->bind('tablename', $table);  

// update the variable 
$table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compilar

  • Purpose - Para compilar o objeto de consulta definido na consulta SQL

  • Parameter -

    • $db - string de conexão, opcional

  • Returns -

Por exemplo,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);

// compile the query, returns: DELETE * FROM employee 
$sql = $query->compile();

executar

  • Purpose - Executar a consulta definida no objeto Consulta e retornar o resultado

  • Parameter -

    • $db - nome da conexão do banco de dados

  • Returns - Retorna o resultado

Por exemplo,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

  • Purpose - Para definir o tipo de retorno como matriz associativa em vez de objetos

  • Parameter - nenhum

  • Returns - Retorna o objeto atual

Por exemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

como_objeto

  • Purpose - Para definir o tipo de retorno como objeto em vez de matriz associativa

  • Parameter - nenhum

  • Returns - Retorna o objeto atual

Por exemplo,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; 
}  

// have ORM model objects return instead 
$result = $query->as_object('Model_Employee')->execute();

API Query Builder

As classes baseadas no construtor de consulta (Query_Builder) fornecem opções para construir consultas SQL dinamicamente. Possui quatro classes, cada uma para selecionar (Query_Builder_Select) , inserir (Query_Builder_Insert) , atualizar (Query_Builder_Update) e excluir (Query_Builder_Delete) consultas. Essas classes são derivadas da classe Query_Builder_Where (opção para gerar condições), que por sua vez é derivada de Query_Builder , base de todas as classes.

Vejamos os métodos fornecidos pela classe Query_Builder.

selecionar

  • Purpose - Para gerar as colunas de consultas selecionadas.

  • Parameter -

    • $columns - lista de colunas, opcional

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')  // select `name` 
$query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

de

  • Purpose - Para gerar os detalhes da tabela de consultas selecionadas

  • Parameter -

    • $tables - lista de mesas

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee') // select `name` from `employee`

Onde

  • Purpose - Para gerar as condições de selecionar, inserir e atualizar as consultas

  • Parameters -

    • $column - nome da coluna ou array ($ coluna, $ alias);

    • $op - operadores lógicos, =,! =, IN, BETWEEN e LIKE, opcional;

    • $value - valor da coluna

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Métodos semelhantes

Os métodos semelhantes são where_open (), and_where_open (), or_where_open (), where_close () e_where_close (), or_where_close (). Eles são semelhantes aos métodos where (), exceto que adicionam palavras-chave extras e colchetes ao redor das condições. A seguir está um código de amostra.

$query = DB::select('*')->from('employee');  
$query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); 
$query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter');
$query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

Junte-se

  • Purpose - Para gerar as junções de tabelas de consultas selecionadas

  • Parameters -

    • $table - nome da tabela ou array ($ table, $ alias);

    • $type - tipo de junção (LEFT, RIGHT, INNER, etc.,)

  • Returns - Retorna a instância atual

Exemplo

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

em

  • Purpose - Para gerar a condição de junções em consultas selecionadas

  • Parameters -

    • $c1 - nome da tabela ou nome da tabela com alias no array;

    • $op - operador lógico;

    • $c2 - nome da tabela ou nome da tabela com alias na matriz

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')->join('employee_salary') 
$query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Métodos semelhantes

Os métodos relacionados são and_on () e or_on (). Eles são semelhantes a on (), exceto que adicionam palavras-chave extras e colchetes ao redor das junções.

group_by

  • Purpose - Para gerar grupo por consultas

  • Parameter - $columns - Nome da coluna pela qual agrupar o resultado

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')  
$query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

tendo

  • Purpose - Gerar o agrupamento por condições de consultas SQL

  • Parameter - $column - nome da coluna ou array ($ coluna, $ alias); $op - operadores lógicos, =,! =, IN, BETWEEN e LIKE, opcional; $value - valor da coluna

  • Returns - Retorna a instância atual

Exemplo

$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
$query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Métodos semelhantes

Os métodos semelhantes são having_open (), and_having_open (), or_having_open (), having_close (), and_having_close (), or_having_close (). Eles são semelhantes aos métodos having (), exceto que eles adicionam palavras-chave extras e colchetes ao redor das condições.

Redefinir

  • Purpose - Para redefinir a consulta

  • Parameter - nenhum

  • Returns - Retorna a instância atual

Por exemplo,

$query = DB::select('name')->from('employee')  
$query->reset() 
$query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Classe DBUtil

A classe DBUtil fornece uma opção para gerenciar e executar operações de banco de dados de rotina. Alguns dos métodos importantes são os seguintes -

  • set_connection - Define a conexão padrão
DBUtil::set_connection('new_database');
  • create_database - Cria um banco de dados.
DBUtil::create_database('my_database');
  • drop_database - Descarta um banco de dados.
DBUtil::drop_database('my_database');
  • table_exists - Verifica se uma determinada tabela existe.
if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}
  • drop_table - descarta uma tabela.
DBUtil::drop_table('my_table');
  • create_table - Cria uma tabela.
\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Orm Toolkit

FuelPHP fornece camada de banco de dados avançada usando o conceito ORM baseado no popular Active record pattern. O kit de ferramentas está incluído no aplicativo, mas não é configurado por padrão. Ele é empacotado como um pacote e o nome do pacote é orm. Podemos adicionar a seguinte configuração no arquivo de configuração principal,fuel/app/config/config.php para carregar o kit de ferramentas orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Criando Modelos

Orm fornece a classe de modelo base Orm \ Model. Precisamos estender nossos modelos com o modelo orm para usar os recursos ORM. A seguir está um código de amostra.

class Model_Employee extends Orm\Model {}

Configuração

Orm fornece um conjunto de configurações para configurar o modelo para usar os recursos ORM. Eles são os seguintes -

connection- Defina uma propriedade _connection estática no modelo para especificar o nome da conexão.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Defina uma propriedade _table_name estática no modelo para especificar o nome da tabela de back-end.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Defina uma propriedade _primary_key estática no modelo para especificar a chave primária da tabela de back-end.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Defina uma propriedade _properties estática no modelo para especificar as colunas da tabela de back-end. Ele suporta data_type, rótulo, validação, elementos de formulário, etc.

class Model_Employee extends Orm\Model { 
   protected static $_properties = array ( 
      'id',  
      'name' => array ( 
         'data_type' => 'varchar', 
         'label' => 'Employee Name', 
         'validation' => array ( 
            'required',  
            'min_length' => array(3),  
            'max_length' > array(80) 
         ), 
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  

      'age' => array ( 
         'data_type' => 'int', 
         'label' => 'Employee Age', 
         'validation' => array ( 
            'required',  
         ),  
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  
   ); 
}

Conditions- Defina uma propriedade _conditions estática para definir as condições e ordenar por opções.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm fornece sistema de eventos baseado em observador para adicionar comportamento a eventos específicos. Para adicionar um comportamento, primeiro defina uma propriedade _observers no modelo. Em seguida, defina o comportamento como uma classe e defina-o na propriedade _observers junto com os eventos. Se nenhum evento for especificado, o comportamento será invocado para todos os eventos. Podemos especificar comportamentos múltiplos também.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Crio

Depois de configurar o modelo, podemos começar a usar os métodos imediatamente. Orm proporciona uma economia de método para salvar o objeto no banco de dados. Podemos definir os dados usando as propriedades configuradas da seguinte forma -

// option 1 
$new = new Model_Employee(); 
$new->name = 'Jon'; 
$new->save();  

// option 2, use forge instead of new 
$new = Model_Employee::forge();
$new->name = 'Jon'; 
$new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); 
$new = Model_Employee::forge($props); 
$new>save();

Ler

Orm fornece um método, find para obter os dados do banco de dados e vincular ao objeto. O método find funciona dependendo do parâmetro de entrada. Vejamos as diferentes opções -

by primary key - Especificar a chave primária retorna o registro combinando a chave primária da tabela configurada.

$employee = Model_Employee::find(1);

first / last record- Especificar 'primeiro' ou 'último' irá buscar o primeiro registro ou o último registro respectivamente. Podemos passar o pedido por opção também.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Especificar 'all' buscará todos os registros da tabela configurada. Podemos especificar a ordem por opção e também por condições.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Podemos usar a API de consulta do kit de ferramentas de banco de dados básico junto com o modelo para a opção de pesquisa avançada conforme a seguir.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Atualizar

Atualizar o modelo é o mesmo que criar, exceto que em vez de criar um novo modelo, apenas busque o modelo a ser atualizado usando o método find, atualize a propriedade e chame o método save como segue.

$entry = Model_Employee:find(4);
$entry->name = 'Peter'; 
$entry->save();

Excluir

Orm fornece um método de exclusão para excluir o modelo. Basta buscar o objeto e chamar o método delete.

$entry = Model_Employee:find(4); 
$entry->delete();

Exemplo de Trabalho

Vamos criar um exemplo prático neste capítulo para entender o modelo e o banco de dados.

Crie um banco de dados

Crie um novo banco de dados no servidor MySQL, usando o seguinte comando.

create database tutorialspoint_fueldb

Em seguida, crie uma tabela dentro do banco de dados usando o seguinte comando.

create table employee(id int primary key, name varchar(20), age int not null);

Configure o banco de dados

Vamos configurar o banco de dados usando o arquivo de configuração do banco de dados, * fuel / app / config / db.php. Adicione as seguintes alterações para conectar o servidor MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Incluir Pacote ORM

Atualize o arquivo de configuração principal, fuel/app/config/config.php para incluir o pacote ORM adicionando a seguinte configuração.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Agora, ORM está habilitado em seu aplicativo

Criar modelo de funcionário

Crie um novo modelo, Funcionário na pasta do modelo “fuel/app/classes/model”. É definido como segue.

Employee.php

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; 
      protected static $_primary_key = array('id'); 
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Employee Name', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Criar ação

Crie uma nova ação, action_model no controlador de funcionário localizado em fuel/app/classes/controller/employee.php do seguinte modo.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production');  
      
      // orm based query to add new employees 
      $model = new model_employee(); 
      $model->name = "john"; 
      $model->age = 25; 
      $model->save();  
      $model = new model_employee(); 
      $model->name = "peter"; 
      $model->age = 20; 
      $model->save(); 
      
      // orm based query to fetch all employee data 
      $data = array(); 
      $data['emps'] = model_employee::find('all');  
      return response::forge(view::forge('employee/model', $data)); 
   } 
}

Criar vista

Agora, crie um arquivo de visualização model.php localizado em “fuel/app/views/employee”. Adicione as seguintes alterações no arquivo.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Agora, solicite o URL, http://localhost:8080/employee/model e produzirá o seguinte resultado.

Resultado