DEV Community: Bruno Barros

Introdução aos Testes Unitários com Pest em PHP

Bruno Barros — Tue, 05 Mar 2024 23:38:23 +0000

Neste tutorial, vamos explorar os fundamentos dos testes unitários em PHP usando a biblioteca Pest. Pest é um framework de teste moderno, simples e elegante, que oferece uma sintaxe limpa e amigável para escrever testes.

Pré-requisitos

Antes de prosseguirmos, certifique-se de ter o seguinte instalado em sua máquina:

PHP (versão mínima 7.3 ou superior)
Composer (um gerenciador de dependências para PHP)

Instalação do Pest

Para instalar o Pest em seu projeto PHP, execute o seguinte comando no terminal:

composer require pestphp/pest --dev

Configuração do Pest

Após a instalação, crie um arquivo de configuração chamado pest.php na raiz do seu projeto. Aqui está um exemplo básico de configuração:

<?php

return [
    'paths' => [
        'app',
    ],
];

Neste exemplo, estamos configurando o diretório de testes para app, onde os testes serão armazenados.

Escrevendo Testes

Crie um diretório chamado tests na raiz do seu projeto. Dentro deste diretório, você pode começar a escrever seus testes.

Vamos criar um teste simples para uma classe de exemplo. Crie um arquivo chamado ExampleTest.php dentro do diretório tests com o seguinte conteúdo:

<?php

use App\Example; // Suponha que esta seja a classe que estamos testando

it('can instantiate Example', function () {
    $example = new Example();

    expect($example)->toBeInstanceOf(Example::class);
});

it('can get the name', function () {
    $example = new Example();
    $name = $example->getName();

    expect($name)->toBe('Example');
});

Para executar:

vendor/bin/pest

Isso iniciará a execução dos testes no diretório tests e mostrará o resultado no terminal.

Conclusão

Este tutorial cobre os conceitos básicos dos testes unitários em PHP usando Pest. Recomenda-se explorar a documentação oficial do Pest para aprender mais sobre recursos avançados e boas práticas de teste.

O que é CI/CD

Bruno Barros — Wed, 28 Dec 2022 00:34:32 +0000

CI/CD é uma abreviação para "Integração Contínua/Entrega Contínua". Trata-se de um conjunto de práticas e técnicas que visam automatizar e acelerar o processo de desenvolvimento de software, garantindo a entrega de novas versões de forma rápida e confiável.

A Integração Contínua (CI, do inglês Continuous Integration) refere-se ao processo de integrar o código de desenvolvimento com a branch principal de um projeto de forma frequente, geralmente várias vezes ao dia. Isso permite detectar problemas de integração de código de forma rápida e resolvê-los de maneira eficiente.

A Entrega Contínua (CD, do inglês Continuous Delivery) refere-se ao processo de entregar novas versões do software de forma rápida e confiável. Isso inclui a automatização de todas as etapas do processo de entrega, desde o build e testes até o d*eploy em produção*.

Em resumo, o CI/CD é uma abordagem que visa agilizar e automatizar o processo de desenvolvimento de software, garantindo a entrega de novas versões de forma rápida e confiável.

[Básico] Teste unitários em Java

Bruno Barros — Tue, 27 Dec 2022 14:19:14 +0000

Neste tutorial, explicarei como criar testes unitários em Java usando o framework de teste JUnit.

Antes de começar, você precisará instalar o JUnit em seu ambiente de desenvolvimento. No Eclipse, por exemplo, você pode fazer isso clicando em "Help > Install New Software" e procurando pelo "JUnit" na lista de opções. Você também pode adicionar o JUnit ao seu projeto usando o Maven ou o Gradle.

<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

Para criar um teste unitário, você precisará criar uma classe de teste e adicionar um método de teste a ela. O método de teste deve ter a anotação "@test" e deve ser um método público que não possui nenhum parâmetro de entrada. O método de teste deve conter as verificações que você deseja realizar para garantir que o seu código esteja funcionando corretamente.

Por exemplo, imagine que você tenha uma classe chamada "Calculadora" com um método "somar" que recebe dois números inteiros e retorna a soma desses números. Você pode criar um teste unitário para essa classe da seguinte maneira:

import org.junit.Test;
import static org.junit.Assert.*;

public class CalculadoraTest {

    @Test
    public void testSomar() {
        Calculadora calc = new Calculadora();
        int resultado = calc.somar(1, 2);
        assertEquals(3, resultado);
    }

}

Neste exemplo, estamos criando uma nova instância da classe "Calculadora" e chamando o método "somar" com os valores 1 e 2. Em seguida, verificamos se o resultado é igual a 3 usando o método "assertEquals" do JUnit. Esse método recebe dois valores e verifica se eles são iguais. Se eles forem, o teste passará. Caso contrário, o teste falhará.

Existem muitos outros recursos e técnicas que você pode usar ao escrever testes unitários em Java, mas este é um exemplo básico para começar.

Para obter mais informações e outros Asserts, consulte a documentação do JUnit.

** post gerado por AI e revisado por mim.

Chamada HTTP em Rust

Bruno Barros — Sat, 24 Dec 2022 14:15:48 +0000

Para fazer uma chamada HTTP em Rust, você pode usar a biblioteca reqwest. Você pode adicioná-la como uma dependência no seu arquivo Cargo.toml:

[dependencies]
reqwest = "0.10.8"

Em seguida, você pode importá-la no seu código e usá-la para fazer uma chamada HTTP. Aqui está um exemplo de como fazer uma chamada GET simples para a URL "https://www.example.com":

extern crate reqwest;

fn main() {
    let res = reqwest::get("https://www.example.com")
        .expect("Falha ao fazer a chamada HTTP");
    println!("Status: {}", res.status());

    let body = res.text().expect("Falha ao ler o corpo da resposta");
    println!("Corpo: {}", body);
}

Isso faz uma chamada GET para a URL "https://www.example.com" e imprime o status da resposta e o corpo da resposta.

Você também pode fazer chamadas HTTP usando outros métodos, como POST, PUT e DELETE. Aqui está um exemplo de como fazer uma chamada POST com um corpo de solicitação JSON:

extern crate reqwest;
extern crate serde_json;

use serde_json::Value;

fn main() {
    let client = reqwest::Client::new();

    let mut json = Value::new_object();
    json.insert("name".to_string(), Value::from("John"));
    json.insert("age".to_string(), Value::from(30));

    let res = client.post("https://www.example.com/api/users")
        .json(&json)
        .send()
        .expect("Falha ao fazer a chamada HTTP");

    println!("Status: {}", res.status());
}

*** post gerado via AI e revisado por mim.**

Chamadas HTTP com Java

Bruno Barros — Thu, 22 Dec 2022 01:18:44 +0000

Para fazer uma requisição HTTP em Java, você pode usar a classe HttpURLConnection do pacote java.net. Aqui está um exemplo de como enviar uma requisição GET simples e ler a resposta:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Main {
  public static void main(String[] args) throws Exception {
    // Cria a URL da requisição
    URL url = new URL("http://www.example.com");

    // Cria a conexão HTTP
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();

    // Define o método da requisição como GET
    connection.setRequestMethod("GET");

    // Envia a requisição e armazena a resposta
    BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
    String inputLine;
    StringBuilder response = new StringBuilder();
    while ((inputLine = in.readLine()) != null) {
      response.append(inputLine);
    }
    in.close();

    // Exibe a resposta
    System.out.println(response.toString());
  }
}

Você também pode adicionar cabeçalhos à sua requisição usando o método setRequestProperty. Por exemplo, para adicionar um cabeçalho "User-Agent" à sua requisição, você pode fazer o seguinte:

connection.setRequestProperty("User-Agent", "My Java App");

Para enviar dados com a sua requisição, como um corpo de solicitação em uma requisição POST, você pode usar os métodos setDoOutput e getOutputStream. Aqui está um exemplo de como enviar um corpo de solicitação em uma requisição POST:

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class Main {
  public static void main(String[] args) throws Exception {
    // Cria a URL da requisição
    URL url = new URL("http://www.example.com");

    // Cria a conexão HTTP
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();

    // Define o método da requisição como POST
    connection.setRequestMethod("POST");

    // Adiciona o cabeçalho "Content-Type" com o tipo de conteúdo do corpo de solicitação
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

    // Ativa a opção de envio de dados com a requisição
    connection.setDoOutput(true);

_ Este post foi gerado pelo chatgpd e revisado por mim._

[Basico] Utilizando threads em Java

Bruno Barros — Thu, 22 Dec 2022 01:08:23 +0000

O Java permite que você crie threads para que seus programas possam fazer mais de uma coisa ao mesmo tempo. Isso é especialmente útil quando você precisa realizar tarefas que levam muito tempo, como acessar a Internet ou ler arquivos grandes.

Para criar uma thread em Java, você deve criar uma classe que implemente a interface Runnable. Essa interface possui apenas um método: run(). Você deve implementar esse método para conter o código que a thread deve executar. Por exemplo:

public class MinhaThread implements Runnable { public void run() { // código da thread aqui } }
Para iniciar uma thread, você deve criar uma instância da classe Thread e passar sua instância de Runnable como argumento para o construtor da classe Thread. Em seguida, chame o método start() da classe Thread para iniciar a execução da thread. Por exemplo:

MinhaThread minhaThread = new MinhaThread(); Thread thread = new Thread(minhaThread); thread.start();
Você também pode criar uma thread anônima diretamente ao passar um novo Runnable como argumento para o construtor da classe Thread. Por exemplo:

Thread thread = new Thread(new Runnable() { public void run() { // código da thread aqui } }); thread.start();

Você também pode usar a classe Thread para criar uma thread extendendo-a e sobrescrevendo o método run(). Por exemplo:

`public class MinhaThread extends Thread {
public void run() {
// código da thread aqui
}
}

MinhaThread minhaThread = new MinhaThread();
minhaThread.start();
`

Existem várias outras coisas que você pode fazer com threads, como alterar a prioridade da thread, aguardar a conclusão de uma thread ou interromper uma thread.

Consulte a documentação da classe Thread para obter mais informações.

Este post foi gerado automaticamente pelo chatGPT.

Diferença entre os GenerationTypes do Hibernate

Bruno Barros — Sat, 08 Oct 2022 21:57:49 +0000

Questão de entrevista de emprego!

IDENTITY: Talvez o mais usado, quando utilizamos IDENTITY o Hibernate utilizará a geração AUTO_INCREMENT para SQL/MySQL, já para o Postgres faz uso do tipo SERIAL.

SEQUENCE: Se permitido pelo banco, utiliza sequencias (sequences) para gerar a chave primária, do contrário, automaticamente será utilizado o padrão TABLE. (https://lnkd.in/d8x5_3bx) - podemos customizar esse generation com nome e valores da sequencia. Atualmente o generation type recomendado pelo Hibernate.

Podemos definir o gerador das sequências através da anotação @SequenceGenerator

AUTO: Default. Se nenhum valor for especificado para o GenerationType, este será utilizado. A implementação definirá que estratégia utilizar. No caso do Hibernate com JPA, seria a SEQUENCE para Postgres e oracle e TABLE para MySQL.

TABLE: Funciona em todos os bancos relacionais. Porém, quando fazemos uso dela o Hibernate precisa necessariamente uma outra tabela para gerar e guardar as chaves primárias. Por motivos de locks e lentidão ao escalar a aplicação, é bom evitar o uso de TABLE.

Mais detalhes e fontes:

https://lnkd.in/dXm6RV3i

https://lnkd.in/dAnHUnMW

Builder Pattern em PHP

Bruno Barros — Thu, 08 Sep 2022 10:52:34 +0000

O padrão Builder tem como objetivo simplificar a criação de objetos que possuem caracteristicas parecidas, mas valores diferentes em seus atributos e/ou diferentes implementações de métodos.

O Builder encapsula a criação do objeto, ocultando os detalhes de criação, delegando a responsabilidade para outras classes (mais especificas) implementarem a lógica.

Com o padrão de projeto Builder separamos a construção do objeto de suas representações.

Situação problema - Capítulo 5 do livro Design Patterns:

Atualmente, uma grande empresa que constrói nada menos do
que foguetes espaciais teve a necessidade de um software para a gestão dos seus produtos, e você foi contratado para executar este serviço. O sistema basicamente permitiria o cadastro dos foguetes que a empresa disponibiliza.

Posteriormente, os foguetes previamente cadastrados passariam por diversas rotinas de teste através do mesmo sistema usado como catálogo para apresentação e venda.

Cada foguete possui suas respectivas características: seu
modelo, um tipo de motor, tanque de combustível, número de
assentos para os tripulantes, entre uma infinidade de outras
características específicas de cada modelo.

Todos os modelos dentro do sistema possuirão uma classe em comum, porém, os atributos de cada um são diferentes e devem ser informados quando criamos cada um dos objetos que os representa. Por exemplo, um foguete Modelo I possui 3 motores, já o foguete Modelo II possui 5; ou seja, são características particulares de cada um. Além disso, temos uma série de outros atributos que definem suas representações.

Product: objeto complexo construido pelo Builder
Builder (construtor): interface que serve de contrato das partes do Product
Concrete Builder: implementação concreta que constrói o Product
Director: classe responsável por definir a construção dos objetos utilizando a interface Builder

Começamos definindo nosso objeto complexo:


namespace Builder;

// Objeto complexo que define um foguete
class FogueteProduct
{


    protected float $tanqueCombustivel;
    protected string $modelo;
    protected int $numeroMotores;
    protected int $numeroLugares;

    // getters e setters omitidos!!!

}

Em seguida, definimos nossa interface Builder através de uma classe abstrata:


namespace Builder;

// esta é a interface que será extendida pelas outras classes
abstract class FogueteBuilder
{
    // sempre que uma classe implementar o Builder, teremos uma instancia de um foguete pronto para uso
    protected FogueteProduct $foguete;

    public function __construct()
    {
        $this->foguete = new FogueteProduct();
    }

    public function getFoguete():FogueteProduct
    {
        return $this->foguete;
    }

    // métodos que serão implementados por outros foguetes, especificando seus atributos variados que os diferem
    abstract public function buildTanqueCombustivel(): void;
    abstract public function buildModelo(): void;
    abstract public function buildMotores(): void;
    abstract public function buildNumeroLugares(): void;
}

class FogueteModeloIBuilder extends \Builder\FogueteBuilder
{

    // Repare que já possuimos acesso a um objeto do tipo foguete
    public function buildTanqueCombustivel(): void
    {
        $this->foguete->setTanqueCombustivel(1313);
    }

    public function buildModelo(): void
    {
        $this->foguete->setModelo('Foguete tipo 1');
    }

    public function buildMotores(): void
    {
        $this->foguete->setNumeroMotores(4);
    }

    public function buildNumeroLugares(): void
    {
        $this->foguete->setNumeroLugares(13);
    }
}

Importante: Já possuímos uma instância de um foguete, assim como os métodos para criação do mesmo SEM CONHECERMOS verdadeiramente como essa criação é feita.

Isso não importa para as classes que implementarão os modelos, o montador (builder) do foguete não precisa conhecer a criação de cada parte do foguete, apenas implementar a especificação daquele objeto.

Se criarmos outro foguete, modelo 2:

class FogueteModeloIIBuilder extends \Builder\FogueteBuilder
{

    // Repare que já possuimos acesso a um objeto do tipo foguete
    public function buildTanqueCombustivel(): void
    {
        $this->foguete->setTanqueCombustivel(850);
    }

    public function buildModelo(): void
    {
        $this->foguete->setModelo('Foguete tipo 2');
    }

    public function buildMotores(): void
    {
        $this->foguete->setNumeroMotores(54);
    }

    public function buildNumeroLugares(): void
    {
        $this->foguete->setNumeroLugares(133);
    }
}

Aqui a classe abstrata FogueteBuilder, serve como interface. Ela é a garantia para a classe FabricaFoguetesDirector de que todas as classes Builder conterão os métodos que precisamos para montar um foguete.

Na propriedade $construtorDeFoguetes, uma instância de FogueteBuilder, corresponde aos nossos construtores concretos (Concrete Builder).

use Builder\FogueteProduct;

class FoguetesDirectorFabrica
{
    protected \Builder\FogueteBuilder $construtorDeFoguetes;

    public function __construct(\Builder\FogueteBuilder $construtorDeFoguetes) {
        $this->construtorDeFoguetes = construtorDeFoguetes;
    }

    public function getFoguete(): FogueteProduct
    {
        return $this->construtorDeFoguetes->getFoguete();
    }
    public function construirFoguete(): void
    {
        $this->construtorDeFoguetes->buildModelo();
        $this->construtorDeFoguetes->buildMotores();
        $this->construtorDeFoguetes->buildTanqueCombustivel();
        $this->construtorDeFoguetes->buildNumeroLugares();
    }

}

Implementação no index:

<?php 

use Builder\FogueteProduct;

// implementação
$montadoraDeFoguetesTestI = new Builder\FoguetesDirectorFabrica(new FogueteModeloIBuilder());
$montadoraDeFoguetesTestII = new Builder\FoguetesDirectorFabrica(new FogueteModeloIIBuilder());

print_r($montadoraDeFoguetesTestI);
print_r($montadoraDeFoguetesTestII);

$montadoraDeFoguetesTestI->construirFoguete();
$montadoraDeFoguetesTestI->getFoguete();

Repare como a utilização em si do objeto é simplificada, este é o principal objetivo do padrão Builder.

Utilizando-o abstraimos a lógica de criação dos objetos, delegando para classes mais especificas implementarem as diferenças de propriedades e métodos (modelos 1 e 2), desta forma, o objeto final instanciado não precisa saber 'como' ele é feito, apenas que deve fazer.

Código do post: https://github.com/bbwithpointers/design-patterns-php

Prototype Pattern em PHP

Bruno Barros — Wed, 07 Sep 2022 23:05:18 +0000

Neste padrão os objetos criados servem como uma espécie de protótipo, que serão clonados para a criação de novos objetos. Diferente dos demais padrões de criação, o Prototype utiliza o próprio objeto para criar as novas instâncias em vez de usar classes auxiliares para fazer isso.

Este padrão é indicado principalmente quando se quer criar
cópias exatas de um objeto, incluindo seus atributos. Assim, temos um custo muito menor de memória do que instanciar o mesmo objeto muitas vezes.

Imagine que uma livraria precisa 'assinar' o nome do comprador em cada capa de livro. Se fossemos por uma abordagem sem padrões, teriamos que instanciar um novo objeto a cada livro comprado, certo?

Todo esse 'esforço'computacional somente parar alterar uma propriedade do objeto.

Para isso, vamos utilizar o padrão Prototype que nos da uma solução muito mais leve para esse problema.

Prototype: classe abstrata que define o contrato a ser 'clonado'
Concrete Type: classe concreta que implementa a Prototype.
Client: classes que fazem uso dos objetos. _

LivroPrototype: 

/**
 * Livro Design Patterns PHP 7
 *  Pagina 73 
 * O objetivo desse padrão é definir alguns objetos que servem
 *como uma instância de protótipo, clonada para a criação de novos
 *objetos. Diferente dos demais padrões de criação, o Prototype
 *utiliza o próprio objeto para criar as novas instâncias em vez de
 *usar classes auxiliares para fazer isso.
 *Este padrão é indicado principalmente quando se quer criar
 *cópias exatas de um objeto, incluindo seus atributos. Assim, temos
 *um custo muito menor de memória do que instanciar o mesmo
 *objeto muitas vezes e, em cada uma dessas vezes, setar exatamente
 *os mesmos valores em suas propriedades. 
 */

namespace Prototype;

abstract class LivroPrototype
{
    protected string $titulo;
    // método mágico __clone() é chamaod quando clonamos uma classe com a palavra clone - de forma abstrata, a implementação deve ser feita nas subclasses
    abstract public function __clone();

    public function  getTitulo(): string
    {
        return $this->titulo;
    }

    public function setTitulo(string $titulo) : LivroPrototype 
    {
        $this->titulo = $titulo;
        return $this;
    }
}

A classe LivroPrototype representa o nosso protótipo. Ela
estende da classe abstrata LivroPrototype , herdando assim suas propriedades e métodos.

class LivroPhpPrototype extends LivroPrototype
{
    public function __construct()
    {
        $this->setTitulo("Livro PHP");
    }

    public function __clone()
    {
        echo "Livro PHP Clonado\n";
    }
}

Abaixo, o código dos clientes:

// CLIENTES 

$compradores = ['Gabriel', 'Anderson', 'Bruno'];

$livroPhp = new LivroPhpPrototype();
$livroPhp->setTitulo("Padroes de projeto em PHP");
print_r($livroPhp);

// criando vários clones 

$livros = [];
foreach($compradores as $nomeComprador)
{
    $livroComprador = clone $livroPhp;
    $livroComprador->setNome($nomeComprador);
    $livros[] = $livroComprador; 
}
print_r($livros);

Com isso, a nossa livraria agora pode gerar centenas de livros com assinatura, consumindo muito menos memória que uma solução sem o prototype.

É importante observar que no ultimo loop, estamos trabalhando sempre com um clone do objeto já instanciado, motificando apenas o nome que seria 'assinado' no livro.

Repositório com código: https://github.com/bbwithpointers/design-patterns-php

Factory Method com PHP

Bruno Barros — Wed, 07 Sep 2022 00:16:59 +0000

No padrão Factory Method, temos uma interface que implementará o 'básico' que seus objetos deverão possuir.

Este é mais um padrão de projeto do GOF, onde programamos voltados a interface, deixando a responsabilidade de implementação especificos para cada objeto particular.

Um exemplo prático seria definirmos tipos de pagamentos, existem infinitos tipos e formas de realizarmos um pagamento, mas podemos resumi-los a alguns itens em comum:

Todo pagamento tem um valor, a moeda (dólar, real), juros, parcelamento etc. Poderiamos ter então uma PagamentoProduct com esses métodos, e cada forma de pagamento deverá implementar esses métodos e definir suas regras.

A 'programação voltada a interfaces'é muito utilizado em Golang, onde para podermos testar os objetos, precisamos primeiro de uma interface que modele o comportamento do mesmo.

CarroProduct.php:

<?php

namespace FactoryMethod\Product;

// Todos os subprodutos de um carro, precisam implementar os métodos desta interface
interface CarroProduct
{
    public function acelerar(): void;
    public function frear(): void;
    public function trocarMarcha(): void;
}

Dentro deste arquivo, para diminuir o número de arquivos, eu criei 2 classes diferentes que implementam nossa interface: TeslaModel e Fusca. Este dois são nossos objetos 'concretos' que implementam o modelo (interface).

// Concrete product, ou seja, um objeto concreto que implementa a interface
class TeslaModel implements CarroProduct
{
    public function acelerar(): void
    {
        echo "Tesla acelerando\n";
    }

    public function frear(): void
    {
        echo "Tesla freando\n";
    }

    public function trocarMarcha(): void
    {
        echo "Tesla trocando marcha";
    }
}

// Concrete product, ou seja, um objeto concreto que implementa a interface
class Fusca implements CarroProduct
{
    public function acelerar(): void
    {
        echo "Fusca acelerando\n";
    }

    public function frear(): void
    {
        echo "Fusca freando\n";
    }

    public function trocarMarcha(): void
    {
        echo "Fusca trocando marcha";
    }
}

Agora, criamos outra interface, desta vez a que será responsável pelo controle de criação dos nossos objetos, ou seja, a interface responsável por definir nossa fábrica.

CarroFactory.php:

<?php

use FactoryMethod\Product\CarroProduct;

// A carro factory, permite que a gente crie qualquer objeto concreto que implemente a interface CarroProduct
interface CarroFactory 
{
    public function criarCarro(string $modeloDoCarro) : CarroProduct;
}

Faremos uso da classe CarroProduct acima, já que nossa Factory (fábrica) será responsável por criar objetos do tipo CarroProduct, ou seja, qualquer classe que implementar nossa interface.

Agora, criaremos 2 classes FuscaFactory e TeslaFactory, que serão as classes responsáveis por criar nosso Fusca e nosso Tesla.

<?php

use FactoryMethod\Product\CarroProduct;
use FactoryMethod\Product\Fusca;

class FuscaFactory implements CarroFactory 
{
    public function criarCarro(string $modeloDoCarro): CarroProduct
    {
        if ($modeloDoCarro == "fusca")
        {
            return new Fusca();
        } else {
            throw new Exception("Modelo de carro invalido!");
        }
    }
}

Finalmente, nosso index:


<?php

/**
 * 
 * No padrão Factory Method, temos uma interface que define
 *um contrato para os objetos a serem criados pelas fábricas, que
 *seriam nossos produtos finais. Também temos uma interface que
 *define como nossas classes-fábrica deverão ser construídas.
 * 
 * 
 */

 $teslaFactory = new TeslaFactory();
 $fuscaFactory = new FuscaFactory();

 try 
 {
    $teslas = $teslaFactory->criarCarro('modeloX');
 } 
 catch(Exception $e)
 { 
    echo $e->getMessage();
 }

 $teslas->acelerar();
 $teslas->trocarMarcha();
 $teslas->frear();

Resumidamente, o método fábrica é muito util quando precisamos criar vários objetos que terão comportamentos similares. Claro que aqui foi um exemplo não tão prático, mas por exemplo, se fosse uma montadora de automóveis real, imagine quantos modelos de carro existem.

Padrão Singleton com PHP

Bruno Barros — Tue, 06 Sep 2022 00:10:58 +0000

O padrão singleton tem como finalidade centralizar a criação de um objeto, mantendo o vivo durante todo o ciclo de execução.

SINGLETON, O ANTI-PATTERN
Para muitos, o padrão Singleton é considerado um anti-
pattern por conta do seu uso em forma estática (chamando a
classe sem precisar instanciá-la) e, principalmente, pelo
acesso global à instância da classe. Os problemas de utilizar
classes estáticas são vários: não podemos trabalhar com
interfaces, nosso código fica com um acoplamento mais alto,
entre outros.
(quote do livro: Design pattern com PHP 7 - página 43.)

Dito isso, o singleton ainda é muito utilizado no mercado quando precisamos de uma instância unica.

Com esse controle, impedimos a criação descontralada de instancias de classes. Este padrão é muito utilizado quando estamos lidando com classes/frameworks de logs.

<?php 

namespace Singleton; 

class LogsSingleton 
{

    /** @var self $singleton instância da classe de logs. */
    protected static LogsSingleton $instancia;

    /** os métodos construtor, clone e wake up precisam ser privados, para que a classe só seja criado via método getInstancia */
    private function __construct()
    {

    }
    private function __clone()
    {

    }
    private function __wakeup()
    {

    }

    public static function getInstancia() : self 
    { 
        // self => se refere a própria classe 
        // Se a instancia estiver vazia, nenhuma classe foi criada ainda 
        if (empty(self::$instancia))
        {
            self::$instancia = new self();
        }
        return self::$instancia;
    }

    /** function para gravar dados em um arquivo de texto, simulando log */
    public function gravarLog(array $dados):void 
    {
        $nomeArquivo = 'logs.txt';

        $logsAnteriores = [];

        if (filesize($nomeArquivo) > 0)
        {
            $conteudoArquivo = file_get_contents($nomeArquivo);
            // com esse array vazio, impedimos erros casos o arquivo inicial esteja vazio
            $logsAnteriores = json_decode($conteudoArquivo, true);
        }
        $logsAnteriores[] = $dados;
        // escreve no arquivo 
        $arquivo = fopen($nomeArquivo, 'w');
        fwrite($arquivo, json_encode($logsAnteriores));
        fclose($arquivo);
    }
}

$instanciaLogs = LogsSingleton::getInstancia();
print_r($instanciaLogs);

Criamos a propriedade $instancia de forma estática, já que ela será responsável por garantir o acesso único a instância da classe. Os métodos mágicas __construct, __wakeup e __clone estão privados para impedir que sejam chamados e criem instâncias da classe.

Se tentarmos criar uma instância desta classe, sem utilizar o método getInstancia(), teremos um fatal error.

Testando:


$instancia = LogsSingleton::getInstancia();
$instanciaNova = LogsSingleton::getInstancia(); 

if ($instancia === $instanciaNova) 
{ 
 echo "são iguais";
}

Fix: tailwind not working on Laravel 9 with Vite

Bruno Barros — Sun, 04 Sep 2022 01:06:52 +0000

If you having trouble loading your tailwind styles and everything looks fine.

Try to add this line on your vite.config.js, it solve the problem for me.

This error happens when Vite doenst recognize the localhost as a server/host.