Criando e Executando Projeto ThinkPHP 8 no ServBay

Este artigo orienta você a usar o ServBay, um poderoso ambiente local de desenvolvimento web, para criar, configurar e executar rapidamente um projeto PHP baseado no framework ThinkPHP 8. O ServBay oferece um ambiente PHP pré-configurado, servidores web (Caddy ou Nginx) e diversos bancos de dados, tornando a configuração local do ThinkPHP muito mais simples.

O que é ThinkPHP?

ThinkPHP é um framework PHP de código aberto, originado na China, rápido, simples e orientado a objetos. Ele segue princípios de desenvolvimento limpos e eficientes, visando fornecer aos desenvolvedores um conjunto de ferramentas práticas para construir aplicações web modernas. Graças à sua facilidade de uso, funcionalidades completas (como ORM robusto, roteamento flexível, mecanismo de templates integrado, suporte a cache e muito mais) e à comunidade ativa, ThinkPHP é amplamente utilizado no desenvolvimento PHP na China.

Principais Características e Vantagens do ThinkPHP

• Simplicidade e eficiência: O framework possui design limpo, estrutura de código clara, fácil de entender e manter, promovendo alta produtividade no desenvolvimento.
• Recursos completos: Inclui componentes essenciais para desenvolvimento web, como estrutura MVC, ORM, motor de templates, cache, gerenciamento de sessão, autenticação, proteção contra CSRF, etc.
• ORM poderoso: Oferece mapeamento objeto-relacional eficiente e fácil de usar, simplificando operações com banco de dados.
• Roteamento flexível: Suporta várias formas de definição de rotas, atendendo necessidades complexas de URLs.
• Ecossistema rico: Muitos plugins e bibliotecas de extensão disponíveis, além de uma comunidade grande e ativa com muitos recursos.
• Atualizações constantes: O framework evolui rapidamente, acompanhando as tendências do PHP e do desenvolvimento web.

ThinkPHP atende desde pequenos projetos até aplicações empresariais de grande porte.

Utilizando ServBay para Configurar um Projeto ThinkPHP 8

ServBay oferece o ambiente ideal para desenvolvimento local com ThinkPHP 8, incluindo:

• Diversas versões do PHP e extensões populares já instaladas.
• Servidores web integrados (Caddy ou Nginx), facilitando a configuração do site.
• Serviços de banco de dados integrados: MySQL, PostgreSQL, MongoDB, Redis, Memcached, entre outros.
• Gerenciador de dependências Composer já integrado.

Este guia usa todas essas funções do ServBay para montar seu projeto ThinkPHP 8 de maneira rápida.

Pré-requisitos

Antes de começar, certifique-se de que:

1. Você já baixou e instalou o ServBay no seu macOS ou Windows.
2. O ServBay está em execução, e a versão necessária do PHP (ThinkPHP 8 exige PHP 8.0 ou superior) e os serviços de banco de dados desejados (MySQL, PostgreSQL, Redis, Memcached, etc.) estão ativos. Verifique e inicie esses serviços na aba “Pacotes” do painel de controle ServBay.

Criando um Projeto ThinkPHP

O ServBay recomenda que seus arquivos de sites locais sejam organizados no diretório /Applications/ServBay/www, facilitando a gestão de sites.

1. Verificar instalação do Composer

   O ServBay já vem com o Composer pré-instalado, normalmente não há necessidade de instalação adicional. Confirme via terminal do ServBay rodando o comando composer --version.

2. Criar projeto ThinkPHP com o Composer

   Abra o terminal do macOS e execute os comandos abaixo para criar um novo projeto ThinkPHP 8 na raiz web do ServBay:

   cd /Applications/ServBay/www
   composer create-project topthink/think servbay-thinkphp-app

   Isso cria uma pasta chamada servbay-thinkphp-app em /Applications/ServBay/www e baixa os arquivos principais do ThinkPHP 8 com suas dependências.

3. Acesse o diretório do projeto

   Após a criação, entre no diretório do projeto:

   cd /Applications/ServBay/www/servbay-thinkphp-app

Inicializando a Configuração do Projeto

Depois de criar o projeto, é necessário fazer algumas configurações básicas.

1. Configurar conexão com banco de dados

   A configuração do banco de dados do ThinkPHP geralmente está no arquivo config/database.php. Modifique este arquivo conforme o serviço de banco de dados que está rodando no ServBay.

   Exemplo de configuração para o MySQL padrão do ServBay:

   <?php
   // config/database.php
   
   return [
       // Configuração padrão de conexão
       'default'         => env('database.driver', 'mysql'),
   
       // Configurações de conexão
       'connections'     => [
           'mysql' => [
               // Tipo de banco de dados
               'type'     => 'mysql',
               // Endereço do servidor
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome do banco de dados
               'database' => env('database.database', 'servbay_thinkphp_app'), // Recomenda-se criar um banco exclusivo
               // Nome do usuário
               'username' => env('database.username', 'root'),
               // Senha
               'password' => env('database.password', 'password'), // Senha padrão do ServBay, apenas para desenvolvimento local!
               // Porta
               'hostport' => env('database.hostport', '3306'),
               // ... outras configurações ...
           ],
           // ... outras configurações de conexão ...
       ],
   ];

   Importante:

   • Altere o valor de database para o nome real do banco que você criou para o projeto (exemplo: crie um banco chamado servbay_thinkphp_app via phpMyAdmin ou Adminer do ServBay).
   • No ServBay, o usuário padrão root tem senha password. Use esta senha apenas em ambiente de desenvolvimento! Em produção, sempre use uma senha forte e um usuário com permissões mínimas.
   • Se você gerencia variáveis com .env, certifique-se de que as configurações do .env sobrescrevem os valores padrão do config/database.php.

Configurando o Servidor Web

O arquivo de entrada do ThinkPHP é public/index.php, e o framework depende de regras de Rewrite de URL para roteamento. Como o roteamento ThinkPHP difere do acesso direto a arquivos estáticos, é necessário aplicar as regras integradas do ServBay.

No menu de configuração do site, selecione a opção de Rewrite ThinkPHP e clique em salvar.

Para detalhes sobre configuração de sites no ServBay, consulte Adicionando o primeiro site.

Adicionando Código de Exemplo

Para testar se a configuração do site foi bem-sucedida e validar rotas e funcionalidades básicas do ThinkPHP, adicione uma rota e um controlador simples.

Edite o arquivo /Applications/ServBay/www/servbay-thinkphp-app/route/app.php e inclua este código para um GET simples:

<?php
// route/app.php

use think\facade\Route;

// Define rota 'servbay' para /servbay, executa função anônima ao acessar
Route::get('servbay', function () {
    return 'Hello ServBay!';
});

// ... outras rotas ...

Acessando o Site

Depois dos passos anteriores, abra o navegador e acesse o domínio local configurado e a rota de exemplo:

https://thinkphp.servbay.demo/servbay

Se tudo estiver correto, verá na tela a saída Hello ServBay!. Isso indica que seu projeto ThinkPHP 8 está rodando perfeitamente no ServBay, e as configurações do servidor web e PHP-FPM estão funcionando.

Exemplos com Bancos NoSQL

O ServBay já vem com bancos NoSQL como Memcached e Redis. O ThinkPHP tem uma camada de abstração de cache que facilita a integração destes serviços como drivers de cache.

Exemplo com Memcached

1. Instalar extensão do Memcached

   O PHP do ServBay já possui a extensão Memcached instalada. Basta verificar, na aba “Pacotes” do painel ServBay, se o serviço está ativo.

2. Configurar cache Memcached

   Edite config/cache.php para definir Memcached como driver de cache:

   <?php
   // config/cache.php
   
   return [
       // Driver de cache padrão
       'default' => env('cache.driver', 'memcached'),
   
       // Configuração de conexão de cache
       'stores'  => [
           'memcached' => [
               // Tipo de cache
               'type'       => 'memcached',
               // Lista de servidores
               'host'       => '127.0.0.1', // Endereço padrão do Memcached no ServBay
               'port'       => 11211, // Porta padrão do Memcached no ServBay
               'persistent' => false,
               'expire'     => 0,
               'timeout'    => 0,
               'prefix'     => '',
           ],
           // ... outras configurações de cache ...
       ],
   ];

3. Utilizando o Cache Memcached no código

   No controlador ou callback de rota, use o Facade Cache do ThinkPHP para acessar o Memcached:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/memcached-example', function () {
       // Define cache, válido por 600 segundos
       Cache::set('my_memcached_key', 'Este valor vem do Memcached!', 600);
   
       // Recupera cache
       $value = Cache::get('my_memcached_key');
   
       return 'Valor do Memcached: ' . $value;
   });

   Teste acessando https://thinkphp.servbay.demo/memcached-example.

Exemplo com Redis

1. Instalar extensão do Redis

   O PHP do ServBay já possuí a extensão Redis instalada. Basta confirmar que o serviço está ativo no painel do ServBay.

2. Configurar cache Redis

   Edite config/cache.php para usar o Redis como driver oficial:

   <?php
   // config/cache.php
   
   return [
       // Driver de cache padrão
       'default' => env('cache.driver', 'redis'),
   
       // Configuração de conexão de cache
       'stores'  => [
           'redis' => [
               // Tipo de cache
               'type'       => 'redis',
               // Endereço do servidor
               'host'       => env('cache.host', '127.0.0.1'), // Endereço padrão do Redis no ServBay
               // Porta
               'port'       => env('cache.port', 6379), // Porta padrão do Redis no ServBay
               // Senha (por padrão sem senha)
               'password'   => env('cache.password', ''), // Redis padrão do ServBay não possui senha
               'select'     => 0,
               'timeout'    => 0,
               'expire'     => 0,
               'persistent' => false,
               'prefix'     => '',
           ],
           // ... outras configurações de cache ...
       ],
   ];

   Atenção: O Redis padrão do ServBay não tem senha configurada. Se citar senha no Redis, ajuste o campo password conforme sua configuração.

3. Utilizando o Cache Redis no código

   Use o Facade Cache para acessar o Redis no controlador ou callback de rota:

   <?php
   use think\facade\Cache;
   use think\facade\Route;
   
   Route::get('/redis-example', function () {
       // Define cache, sem tempo de expiração (ou defina no terceiro parâmetro)
       Cache::set('my_redis_key', 'Olá do Redis!');
   
       // Recupera cache
       $value = Cache::get('my_redis_key');
   
       return 'Valor do Redis: ' . $value;
   });

   Teste acessando https://thinkphp.servbay.demo/redis-example.

Exemplos com Bancos de Dados Relacionais

O ServBay traz integração nativa com bancos como MySQL e PostgreSQL. O ORM do ThinkPHP facilita todo o trabalho de manipulação de dados nestes bancos.

Usando Ferramenta de Migração de Banco de Dados do ThinkPHP

No ThinkPHP, o controle de alterações de estrutura do banco de dados é feito por meio de ferramentas de migração, facilitando o trabalho em equipe e versionamento.

1. Instalar extensão de migração

   No diretório raiz do projeto, instale a extensão de migração:

   cd /Applications/ServBay/www/servbay-thinkphp-app
   composer require topthink/think-migration

2. Criar arquivo de migração

   Com o comando abaixo, gere um arquivo para criar a tabela users:

   php think migrate:create CreateUserTable

   Será criado um arquivo PHP novo em database/migrations, com nome composto por timestamp e o nome escolhido (exemplo: 20231027100000_create_user_table.php).

3. Editar arquivo de migração

   Abra o arquivo gerado e edite o método up() para definir a estrutura da tabela users:

   <?php
   // database/migrations/YYYYMMDDHHMMSS_create_user_table.php
   
   use think\migration\Migrator;
   use think\migration\db\Column;
   
   class CreateUserTable extends Migrator
   {
       /**
        * Change Method.
        *
        * Write your reversible migrations using this method.
        *
        * More information on writing migrations is available here:
        * http://docs.phinx.org/en/latest/migrations.html#the-change-method
        *
        * The following commands can be used in this method and Phinx will
        * automatically reverse them when rolling back:
        *
        * createTable
        * renameTable
        * addColumn
        * addCustomColumn
        * renameColumn
        * addIndex
        * addForeignKey
        * createDatabase
        * renameDatabase
        * dropTable
        * dropColumn
        * dropIndex
        * dropForeignKey
        */
       public function change()
       {
           // Cria tabela usando método createTable
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome do usuário'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Endereço de email'])
                 ->addIndex(['email'], ['unique' => true]) // Adiciona índice único
                 ->addTimestamps() // Adiciona campos created_at e updated_at
                 ->create(); // Executa a criação
       }
   
       // Caso não use o método change, pode definir métodos up() e down() separados
       /*
       public function up()
       {
           $table = $this->table('users');
           $table->addColumn('name', 'string', ['limit' => 50, 'comment' => 'Nome do usuário'])
                 ->addColumn('email', 'string', ['limit' => 100, 'comment' => 'Endereço de email'])
                 ->addIndex(['email'], ['unique' => true])
                 ->addTimestamps()
                 ->create();
       }
   
       public function down()
       {
           $this->dropTable('users');
       }
       */
   }

4. Executar as migrações

   No terminal do ServBay, estando na raiz do projeto, rode o comando para criar a tabela users:

   php think migrate:run

   Se tudo correr bem, verá a nova tabela users no banco de dados.

Exemplo com MySQL

Supondo o serviço MySQL ativo no ServBay e configuração feita no config/database.php.

1. Configurar conexão com MySQL

   Veja o exemplo em “Inicializando a Configuração do Projeto”; confirme se as informações do MySQL estão corretas no arquivo.

2. Inserindo dados de usuário via código

   Use o Facade Db ou modelos ORM do ThinkPHP para inserir dados. Exemplo com Facade Db:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-add-user', function () {
       try {
           Db::table('users')->insert([
               'name' => 'ServBay Demo User',
               'email' => 'demo@servbay.demo', // Email de exemplo do ServBay
               'created_at' => date('Y-m-d H:i:s'), // Adiciona timestamp manualmente se necessário
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'Usuário adicionado com sucesso!';
       } catch (\Exception $e) {
           return 'Erro ao adicionar usuário: ' . $e->getMessage();
       }
   });

   Experimente acessando https://thinkphp.servbay.demo/mysql-add-user.

3. Lendo os dados de usuário via código

   Consulte os dados com o Facade Db ou modelo:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/mysql-users', function () {
       $users = Db::table('users')->select(); // Busca todos os usuários
       return json($users); // Retorna o resultado em JSON
   });

   Experimente acessando https://thinkphp.servbay.demo/mysql-users para ver os dados na tabela.

Exemplo com PostgreSQL

Supondo o serviço PostgreSQL ativo e a configuração realizada no arquivo config/database.php.

1. Configurar conexão com PostgreSQL

   No arquivo de configuração, insira os dados de conexão (ajuste conforme sua configuração real):

   <?php
   // config/database.php (parcial)
   
   return [
       // ... outras configurações ...
   
       'connections'     => [
           // ... configuração do MySQL ...
   
           'pgsql' => [
               // Tipo de banco
               'type'     => 'pgsql',
               // Endereço do servidor
               'hostname' => env('database.hostname', '127.0.0.1'),
               // Nome do banco
               'database' => env('database.database', 'servbay_thinkphp_app'), // Recomenda criar banco exclusivo
               // Usuário
               'username' => env('database.username', 'root'),
               // Senha
               'password' => env('database.password', 'password'), // Senha padrão ServBay, apenas para desenvolvimento!
               // Porta
               'hostport' => env('database.hostport', '5432'), // Porta padrão do PostgreSQL
               // ... outras configurações ...
           ],
           // ... outras conexões ...
       ],
   ];

   Importante:

   • Assim como no MySQL, crie um banco exclusivo para seu projeto e ajuste a configuração.
   • O usuário padrão root e senha password para PostgreSQL são apenas para uso local.

2. Inserindo dados de usuário via código

   Use Facade Db ou modelo, especificando a conexão pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-add-user', function () {
       try {
           Db::connect('pgsql')->table('users')->insert([ // Usa conexão pgsql
               'name' => 'ServBay PgSQL User',
               'email' => 'pgsql-demo@servbay.demo', // Email de exemplo
               'created_at' => date('Y-m-d H:i:s'),
               'updated_at' => date('Y-m-d H:i:s'),
           ]);
           return 'Usuário PostgreSQL adicionado com sucesso!';
       } catch (\Exception $e) {
            return 'Erro ao adicionar usuário PostgreSQL: ' . $e->getMessage();
       }
   });

   Experimente acessando https://thinkphp.servbay.demo/pgsql-add-user.

3. Lendo os dados de usuário via código

   Consulte os dados, especificando a conexão pgsql:

   <?php
   use think\facade\Db;
   use think\facade\Route;
   
   Route::get('/pgsql-users', function () {
       $users = Db::connect('pgsql')->table('users')->select(); // Busca dados usando pgsql
       return json($users); // Retorna em formato JSON
   });

   Experimente acessando https://thinkphp.servbay.demo/pgsql-users para ver os dados.

Conclusão

Seguindo os passos acima, você já criou, configurou e executou com sucesso um projeto ThinkPHP 8 no ambiente local do ServBay. Aprendeu como usar o Composer integrado para criar projetos, configurar o servidor web Caddy para lidar com rotas do ThinkPHP e conectar-se com bancos de dados MySQL, PostgreSQL, Memcached e Redis fornecidos pelo ServBay.

O ServBay simplifica de verdade a implantação local de frameworks PHP como ThinkPHP, permitindo que você foque no desenvolvimento da sua aplicação. Continue desenvolvendo seu app ThinkPHP e aproveite ao máximo todos os recursos e pacotes disponíveis no ServBay.