DEV Community: Daiene Lima

Usando o ApacheBench (ab) para testes de carga simples

Daiene Lima — Tue, 27 Sep 2022 23:07:12 +0000

O que é Apache Bench ?

É uma ferramenta de benchmarking que mede o desempenho de um servidor web enviando varias solicitações HTTP e registrando métricas de latência e sucesso.
O ApacheBench pode ajudá-lo a determinar quanto tráfego seu servidor HTTP pode sustentar antes que o desempenho diminua e definir linhas de base para tempos de resposta típicos.

Como instalar ?

Nos servidores Mac e Linux ele vem instalado por padrão no pacote básico do sistema.
No windows é necessário baixar e instalar
link para download
após a instalação é possível encontrar o executável na pasta
apache\bin

Executando os testes

Aqui temos alguns argumentos aceitos:

Basta executar o seguinte comando
ab -n 100 -c 10 https://www.google.com/

Ao executar a instrução recebemos a métrica abaixo contendo algumas informações como: tempo de requisição, porcentagem de sucesso e etc.

Http Client Api Java 11

Daiene Lima — Fri, 19 Mar 2021 22:58:42 +0000

Tem muito tempo que os desenvolvedores java sofrem para trabalhar com HTTP, se não fosse por meio de recursos externos essa solicitação ficava muito verbosa e cansativa.

Mas nas ultimas release do java tivemos a inclusão da Api cliente padronizada que visa substituir o HttpURLConnection que está presente no JDK desde os primeiros anos.

A nova Api suporta HTTP/1.1 e HTTP/2. A versão mais recente do protocolo HTTP foi projetada para melhorar o desempenho geral do envio de solicitações e do recebimento de respostas de um servidor.
Isso aconteceu através da introdução de varias alterações como:
multiplexação de fluxo, compactação de cabeçalho e Push Promise.
Além disso o novo HTPP suporta nativamente webSockets.

Ao contrário do HttpURLConnection, o HttpClient fornece mecanismos de solicitação síncrona e assíncrona.

A API consiste em 3 classes principais:

HttpRequest - representa a solicitação a ser enviada por meio do HttpClient
HttpClient - se comporta como um contêiner para informações de configuração comuns a várias solicitações
HttpResponse - representa o resultado de uma chamada HttpRequest

Um exemplo simples

var url = "https://postman-echo.com/get";
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(url))
                .GET()
                .build();

        HttpClient httpClient = HttpClient.newHttpClient();
        var response =
                httpClient.send(request, HttpResponse.BodyHandlers.ofString());
return  response.body();

Configurando Headers

Podemos usar o headers que recebe vários parâmetros ou header
que recebe apenas um parâmetro ambos os métodos são chave e valor.

        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(url))
                .header("Content-Type", "text/plain;charset=UTF-8")
                .GET()
                .build();

//varios headers
.headers("Content-Type", "application/json", "token", "dadda")
//apenas um header
.header(Content-Type", "application/json")

Requisição com corpo

A nova API fornece várias implementações de BodyProcessor prontas para usar, que simplificam a passagem do corpo da solicitação.

StringProcessor - (lê o corpo de uma String , criada com HttpRequest.BodyProcessor.fromString )
InputStreamProcessor - (lê o corpo de um InputStream , criado com HttpRequest.BodyProcessor.fromInputStream )
ByteArrayProcessor - (lê o corpo de uma matriz de bytes, criada com HttpRequest.BodyProcessor.fromByteArray )
FileProcessor - (lê o corpo de um arquivo no caminho fornecido, criado com HttpRequest.BodyProcessor.fromFile )

var url = "https://postman-echo.com/post";
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(url))
                .POST(HttpRequest.BodyPublishers.ofString("exemplo"))
                .build();

        HttpClient httpClient = HttpClient.newHttpClient();
        var response =
                httpClient.send(request, HttpResponse.BodyHandlers.ofString());

        return  response.body();

O client suporta todos os métodos HTTP, mas o construtor contém apenas esses métodos pré-definidos: GET(), POST(), DELETE(), e PUT(). Para criar uma solicitação com um método HTTP diferente, você precisa chamar method().

    var request = HttpRequest.newBuilder(URI.create("https://postman-echo.com/headers"))
            .method("HEAD", BodyPublishers.noBody())
            .build();

Configurações disponíveis

    var client = HttpClient.newBuilder()
            .authenticator(Authenticator.getDefault())
            .connectTimeout(Duration.ofSeconds(30))
            .cookieHandler(CookieHandler.getDefault())
            .executor(Executors.newFixedThreadPool(2))
            .followRedirects(Redirect.NEVER)
            .priority(1) 
            .proxy(ProxySelector.getDefault())
            .sslContext(SSLContext.getDefault())
            .version(HttpClient.Version.HTTP_2) 
            .sslParameters(new SSLParameters())
            .build();

Por padrão, o cliente tenta abrir uma conexão HTTP / 2, se o servidor responder com HTTP / 1.1, o cliente retorna automaticamente para esta versão.

connectTimeout() - determina quanto tempo o cliente espera até que uma conexão possa ser estabelecida. Se a conexão não puder ser estabelecida, o cliente lançará uma HttpConnectTimeoutExceptionexceção.

executor() - define o executor a ser usado para tarefas assíncronas e dependentes.

Alguns dos métodos fornecidos na interface HttpResponse.

body() - retorna o corpo da resposta
headers() - retorna os cabeçalhos de resposta
statusCode() - retorna o código de status HTTP
version() - retorna o protocolo HTTP

Solicitações assíncrona

O novo HttpClient oferece duas possibilidades para enviar uma solicitação a um servidor:

send de forma síncrona (bloqueia até que a resposta chegue)
sendAsync de forma assíncrona (não espera pela resposta, sem bloqueio)

o método sendAsync retorna CompletableFeature - para processar uma solicitação de forma assíncrona :

var url = "https://postman-echo.com/post";
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI(url))
                .POST(HttpRequest.BodyPublishers.ofString("exemplo"))
                .build();

        HttpClient httpClient = HttpClient.newHttpClient();
        var response =
                httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println);
        return response;

Mockito: como utilizar de maneira simples

Daiene Lima — Tue, 09 Mar 2021 23:59:51 +0000

Eu utilizo o Mockito tem algum tempo e é uma ferramenta muito poderosa. Sem ele criar testes seria muito mais verboso e de certa forma complicado.
Depois de entender bem o conceito e a forma de utilizar o desenvolvimento de testes fica muito mais rápido e assertivo.

O que é o Mockito?

O Mockito é um framework de Test and Spy e o seu principal objetivo é simular a instancia de classes e comportamento de métodos. Ao mockar uma dependência com o mockito, eu faço com que a classe que vai ser testada simule o método testado e suas dependências. Durante o mock eu posso configurar retorno e ações de acordo com o necessidade do teste.

Principais funções

Mock: cria uma instancia de uma classe, porém Mockada. Se você chamar um metodo ele não irá chamar o metodo real, a não ser que você queira.
Spy: cria uma instancia de uma classe, que você pode mockar ou chamar os metodos reais. É uma alternativa ao InjectMocks, quando é preciso mockar metodos da propria classe que esta sendo testada.
InjectMocks: criar uma intancia e injeta as dependências necessárias que estão anotadas com @Mock.
Verify: verifica a quantidade de vezes e quais parametros utilizados para acessar um determinado metodo.
When: Após um mock ser criado, você pode configurar ações na chamada e o retorno.
Matchers: permite a verificação por meio de matchers de argumentos (anyObject(), anyString() …)

Criando um mock

Há duas formas de criar um mock usando o mockito por meio de um método estático ou com a anotação @Mock

Utilizando método statico ```

var EmployeeRepository = Mockito.mock(EmployeeRepository.class)

* anotação @Mock

@Mock
private EmployeeRepository employeeRepository;

### Configurando a classe testada
Ao declarar a classe vamos anotar ela com @InjectMocks. O Mockito vai criar uma instância real dessa classe e injetar todos os objetos @ Mock que foram declarados na classe de teste.

@InjectMocks
private EmployeeController employeeController;

### Hibilitando as anotações
Para essas anotações @Mock e @InjectMocks funcionar, é preciso habilita-las. existem duas formas:
* Anotando a classe de teste com @RunWith(MockitoJUnitRunner.class)

@RunWith(MockitoJUnitRunner.class)
public class EmployeeControllerTest {}

* Usando o MockitoAnnotations.initMocks () antes dos testes

@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}


### Testando um metodo void
O método que vai ser testado:

@DeleteMapping("/employees/{id}")
public void deleteEmployee(@PathVariable Long id) {
repository.deleteById(id);
}

O teste

@test
public void deleteEmployee() {
employeeController.deleteEmployee(1L);
Mockito.verify(employeeRepository, Mockito.times(1)).deleteById(1L);
}

Primeiro chamamos o método que vai ser testado e passamos os 
parâmetros necessários.
Em seguida usamos o _Mockito.verify_ para verificar se durante a execução das classes mocadas foi chamado o método em questão.
Podemos verificar varias coisas com _Mockito.verify_ numero de vezes que executou, parâmetros recebidos e etc.

### @Spy Annotation
Usamos o @Spy para espionar uma instância existente.
No exemplo abaixo eu adicionei dois elementos a uma lista e em seguida verifiquei se os elementos foram mesmo inseridos.

@test
public void spyTest() {
List employees = Mockito.spy(new ArrayList());
Employee one = new Employee("Bilbo Baggins", "burglar");
Employee two = new Employee("Frodo Baggins", "thief");

    employees.add(one);
    employees.add(two);

    Mockito.verify(employees).add(one);
    Mockito.verify(employees).add(two);
    assertEquals(2, employees.size());

    Mockito.doReturn(100).when(employees).size();
    assertEquals(100, employees.size());
}

* employees.add() para adicionar elementos a employees.
* employees.size() para retornar 100 em vez de 2 usando Mockito.doReturn()

### Método when
Através dele é possível simular chamadas a recursos externos a classe, como acesso a um banco de dados por exemplo, sem se preocupar como funcionará essa consulta, não é responsabilidade desse teste.
A sintaxe do when é essa:
* when(employeeRepository.save(Mockito.any(Employee.class))).thenReturn(employee);
* when(employeeRepository.save(Mockito.eq(employeeInput))).thenReturn(employee);
* when(employeeRepository.save(Mockito.any())).thenReturn(employee);

@test
public void newEmployee_test() {
Employee employee = EmployeeTest.create();
when(employeeRepository.save(Mockito.any(Employee.class))).thenReturn(employee);
ResponseEntity newEmployee = employeeController.newEmployee(employee);
assertEquals(employee.getName(), newEmployee.getBody().getName());
assertEquals(employee.getRole(), newEmployee.getBody().getRole());
}


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mukdycphq9tqiv813dcy.png)

[Repo com mais exemplos](https://github.com/daienelima/exemplo-HATEOAS)

Hypermedias com Spring HETEOAS

Daiene Lima — Tue, 15 Dec 2020 02:56:54 +0000

O que é HATEOAS ?

HATEOAS ou (Hypertext as the Engine of Application State) é um modelo que permite que você navegue entre seus endpoints de forma dinâmica através de links e URLs e sem precisar do conhecimento prévio sobre a API. Nesse caso o cliente descobrirá as URLs conforme navega entre seus recursos.

Uma boa forma de comparação de HATEOAS é o Hypertext ou Hipertexto que é comum para quem navega na internet diariamente. Quando estamos pesquisando por algo na internet ou lendo alguma notícia e nos deparamos com alguma informação que nos direciona para outro link.
O mesmo conceito pode ser aplicado a API em que a aplicação consumidora terá um link inicial e a partir dele terá acesso a outros recursos caso necessário.

Spring-HATEOAS é uma biblioteca de APIs que podemos usar para criar representações REST que seguem o padrão HATEOAS.

Vamos construir uma aplicação simples com o objetivo de mostrar as vantagens de usar o HATEOAS

Primeiro adicionamos a dependência do spring-HATEOAS

<dependency>             
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>

Criaremos um model

@Entity
public class Employee {

    private @Id @GeneratedValue Long id;
    private String name;
    private String role;

    public Employee() {}
    public Employee(String name, String role) {
        this.name = name;
        this.role = role;
    }
    //gets and sets

Depois vamos implementar a seguinte lógica no nosso controller

import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo;
import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.CollectionModel;
import org.springframework.hateoas.EntityModel;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.exception.EmployeeNotFoundException;
import com.example.demo.model.Employee;
import com.example.demo.repository.EmployeeRepository;

@RestController
public class EmployeeController {

    @Autowired
    private EmployeeRepository repository;


    @GetMapping("/employees")
    public ResponseEntity<CollectionModel<EntityModel<Employee>>> all() {

        List<EntityModel<Employee>> employees = repository.findAll().stream()
                .map(employee -> EntityModel.of(employee,
                        linkTo(methodOn(EmployeeController.class).one(employee.getId())).withSelfRel()))
                .collect(Collectors.toList());

        return ResponseEntity.ok(CollectionModel.of(employees));
    }

    @GetMapping("/employees/{id}")
    public ResponseEntity<EntityModel<Employee>> one(@PathVariable Long id) {

        Employee employee = repository.findById(id) 
                .orElseThrow(() -> new EmployeeNotFoundException(id));

        return ResponseEntity.of(Optional.of(EntityModel.of(employee, 
                linkTo(methodOn(EmployeeController.class).all()).withRel("employees"))));
    }
}

O methodOn() obtém o mapeamento do método fazendo uma invocação fictícia do método de destino.
O método linkTo() inspeciona a classe do controlador e obtém seu mapeamento raiz e finalmente, o withSelfRel() qualifica a relação como um link próprio.

Nesse exemplo usamos o CollectionModel ele auxilia na criação de um wrapper para uma coleção de entidades.

No final temos o seguinte resultado

Se listarmos todos os employees, ele vai retornar no json um link para acessar cada employee individualmente, caso seja necessário.

Se fizemos uma busca por apenas um employee ele nos retorna no json um link para acessar todos os employees

Esse é um exemplo simples onde vemos que o cliente pode ter um único ponto de entrada para a aplicação e outras ações podem ser tomadas com base na resposta.
Nessa aplicação eu mostrei como Spring HATEOAS promove a descoberta de API em um serviço rest.

link do repositório com o código fonte projeto-exemplo

Como consumir uma API externa na sua aplicação Spring Boot

Daiene Lima — Mon, 12 Oct 2020 19:03:49 +0000

Em algum momento pode acontecer da nossa aplicação ter a necessidade de consumir ou se integrar com um serviço externo.
Pensando nisso surgiu um projeto chamado Feign.

O que é Feign?

O Feign é um projeto que está dentro do Spring Cloud ele é
utilizado para integração e consumo de serviços rest.

Ele torna o consumo de clients de serviço da web mais fácil. Foi
inspirado no Retrofit e JAX-RS-2.0.
Uma grande facilidade do uso do Feign é que não precisamos
escrever nenhum código para chamar o serviço, a não ser uma
definição de interface.

@FeignClient é a notação que torna o consumo do serviço
extremamente simples.

Eu vou mostrar um exemplo simples consumindo a api
viacep.com.br/ws/{cep}/json/

A api devolve um json na seguinte estrutura;

Vamos adicionar duas dependências ao nosso pom.xml

spring-cloud-starter-openfeign

    <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

spring-cloud-dependencies

  <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

Configurações do Projeto

Precisamos anotar @EnableFeignClients na classe principal do
projeto, para habilitar o Feign, no caso aqui a classe
Application.
Com essa anotação habilitamos uma busca pela interface client
que devem ser consumida.

@SpringBootApplication
@EnableFeignClients
public class ConsumoApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumoApplication.class, args);
    }

}

Criaremos a classe que vai retornar nosso objeto

   public class Endereco {

    private String cep;
    private String logradouro;
    private String complemento;
    private String bairro;
    private String localidade;
    private String uf;
    private String ibge;
    private String gia;
    private String ddd;
    private String siafi;

}

Criaremos uma interface onde o @FeignClient irá fazer a chamada do serviço.

Os parâmetros url e name são obrigatórios;
onde url: é a base do serviço que vai ser consumido
e name: o nome do cliente
Precisamos dizer qual o Endepoint o buscarEnderecoPorCep vai
utilizar;

@FeignClient(url= "https://viacep.com.br/ws/" , name = "viacep")
public interface CepService {

    @GetMapping("{cep}/json")
    Endereco buscaEnderecoPorCep(@PathVariable("cep") String cep);
}

Agora é só criar a rota que usaremos para consumir o serviço;

@RestController
public class CepRestService {

    @Autowired
    private CepService cepService;

    @GetMapping("/{cep}")
    public ResponseEntity<Endereco> getCep(@PathVariable String cep) {

        Endereco endereco = cepService.buscaEnderecoPorCep(cep);

        return endereco != null ? ResponseEntity.ok().body(endereco) : ResponseEntity.notFound().build(); 
    }

}

Pronto, agora sua aplicação está consumindo um serviço externo
com poucas linhas e com o mesmo resultado que teríamos com
RestTemplate.

Link da aplicação modelo no git Exemplo