# Apostila Java Webdeveloper WEB - Parte 2
## :leaves: SpringBoot
:link: **`https://projects.spring.io/spring-boot/`**
:point_right: [Documentação](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/ "Ir para o site oficial")
O **Spring Boot** é um projeto da Spring que veio para facilitar o processo de configuração e publicação de nossas aplicações. A intenção é ter o seu projeto rodando o mais rápido possível e sem complicação.
Ele consegue isso favorecendo a convenção sobre a configuração. Basta que você diga pra ele quais módulos deseja utilizar (WEB, Template, Persistência, Segurança, etc.) que ele vai reconhecer e configurar.
Você escolhe os módulos que deseja através dos starters que inclui no pom.xml do seu projeto. Eles, basicamente, são dependências que agrupam outras dependências. Inclusive, como temos esse grupo de dependências representadas pelo starter, nosso pom.xml acaba por ficar mais organizado.
Apesar do **Spring Boot**, através da convenção, já deixar tudo configurado, nada impede que você crie as suas customizações caso sejam necessárias.
O maior benefício do **Spring Boot** é que ele nos deixa mais livres para pensarmos nas regras de negócio da nossa aplicação.
O **Spring Boot**, busca solucionar a complexidade da inicialização e gerenciamento de dependências de um projeto com Spring, além de tratar de maneira coesa e eficiente a questão da configuração.
Essencialmente, o **Spring Boot** pode ser considerado um plugin para a ferramenta de building, seja ela o Maven ou o Gradle. Seus principais objetivos são gerenciar dependências de maneira opinativa e automática, e simplificar a execução do projeto em tempo de desenvolvimento e depuração.
O **Spring Boot** também possui a funcionalidade de empacotamento da sua aplicação em um JAR executável contendo todas as dependências necessárias, inclusive o Servlet Container, seja ele o Tomcat, Jetty ou mesmo Undertow, apesar de ainda ser possível empacotar um WAR da forma tradicional.
O principal benefício do Boot, entretanto, é a configuração de recursos baseada no que se encontra no classpath. Se o POM de seu Maven inclui a dependência do JPA e o driver do MySql, ele irá criar uma unidade de persistência baseada no MySql.
Se adicionarmos alguma dependência web, iremos perceber que o **Spring MVC** assumirá configurações default e dependências com relação a diversos aspectos, como a tecnologia de apresentação (o default é o **Thymeleaf**), o mapeamento de recursos e marshalling de JSON (o default é o Jackson) e/ou XML (o default é o JAXB 2) para o tratamento de dados de requisição e resposta, que necessitamos em uma aplicação REST, por exemplo.
### Historia
Há alguns anos – em abril de 2014 – a Spring IO disponibilizava a primeira versão não-beta do **Spring Boot**, a 1.0.0, depois de mais de dezoito meses de desenvolvimento e maturação.
Desde então, o projeto tem evoluído em grande velocidade e, na data de escrita deste artigo, já se encontra na versão 1.2.5, com a 1.3.x batendo a porta.
O **Spring Boot** é um projeto-chave para a Spring IO, mas, por ser recente, muitos desenvolvedores ainda não tiveram um primeiro contato com ele e muitos dos já introduzidos ainda desconhecem algumas ou várias de suas possibilidades e recursos.
É uma ferramenta de alavancagem de produtividade e qualidade. Assim, se você é um desenvolvedor que lida com aplicações baseadas em Spring, deve ao menos conhecê-la.
### Inicializadores
Os inicializadores são parte importante da magia do **Spring Boot**, usados para limitar a quantia de configuração de dependência manual que precisa ser feita. Para utilizar o **Spring Boot** de forma eficaz, é necessário conhecer os inicializadores.
Um inicializador é, essencialmente, um conjunto de dependências (como um POM Maven) específicas do tipo de aplicativo que o inicializador representa.
Todos os inicializadores usam a convenção de nomenclatura: spring-boot-starter-XYZ, em que XYZ é o tipo de aplicativo que você deseja desenvolver. Estes são alguns inicializadores populares do Spring Boot:
* spring-boot-starter-web é utilizado para desenvolver serviços da web RESTful usando Spring MVC e Tomcat como contêiner do aplicativo integrado.
* spring-boot-starter-jersey é uma alternativa ao spring-boot-starter-web que usa o Apache Jersey em vez do Spring MVC.
* spring-boot-starter-jdbc é utilizado para definição do conjunto de conexões do JDBC. Baseia-se na implementação do conjunto de conexões do JDBC do Tomcat.
### Command Line Runner
Interface usada para indicar que um bean deve ser executado quando estiver contido em um SpringApplication. Vários beans CommandLineRunner podem ser definidos no mesmo contexto de aplicativo e podem ser pedidos usando a interface Ordered ou a anotação ==@Order==.
o **Command Line Runner** é uma interface. Isso significa que não podemos criar uma instância dela, mas podemos implementá-la. Se definirmos uma implementação da interface do **Command Line Runner**, precisaremos substituir o método run. Este método será executado após o contexto do aplicativo ser carregado e logo antes da conclusão do método de execução do Aplicativo Spring.
Lembre-se de que isso será executado após o contexto do aplicativo ser carregado, para que você possa usá-lo para verificar se existem certos beans ou quais são os valores de determinadas propriedades. Outro motivo para usá-lo é carregar alguns dados antes de o aplicativo ser iniciado. Vou dizer que já usei um **Command Line Runner** para esses fins, mas ambos estavam em ambientes de desenvolvimento ou de demonstração.
### Diferença entre os Repositorios
* **CrudRepository** principalmente fornece funções CRUD.
* **PagingAndSortingRepository** fornece métodos para fazer paginação e classificação de registros.
* **JpaRepository** fornece alguns métodos relacionados à JPA, como liberar o contexto de persistência e excluir registros em um lote.
#### Fundamentos
A interface base que você escolhe para o seu repositório tem dois propósitos principais. Primeiro, você permite que a infraestrutura do repositório do Spring Data encontre sua interface e inicie a criação do proxy para injetar instâncias da interface nos clientes. O segundo objetivo é atrair a funcionalidade necessária para a interface sem precisar declarar métodos extras.
#### As interfaces comuns
A biblioteca principal do **Spring Data** é fornecida com duas interfaces básicas que expõem um conjunto dedicado de funcionalidades:
* **CrudRepository** - métodos CRUD
* **PagingAndSortingRepository** - métodos para paginação e classificação (estende **CrudRepository**)
#### Interfaces específicas
Os módulos de armazenamento individuais (por exemplo, para JPA ou MongoDB) expõem extensões específicas da loja dessas interfaces básicas para permitir o acesso a funcionalidades específicas da loja, como descarga ou lote dedicado, que levam em consideração alguns detalhes da loja. Um exemplo para isso é deleteInBatch(…)de **JpaRepository** que é diferente de delete(…), uma vez que utiliza uma consulta para excluir as entidades dadas, que é de maior performance, mas vem com o efeito colateral de não desencadeando as cascatas de APP-definidos (como a especificação define).
Geralmente, recomendamos não usar essas interfaces básicas, pois elas expõem a tecnologia de persistência subjacente aos clientes e, assim, aumentam o acoplamento entre eles e o repositório. Além disso, você se afasta um pouco da definição original de um repositório que é basicamente "uma coleção de entidades". Então, se você puder, fique com **PagingAndSortingRepository**.
#### Interfaces básicas do repositório customizado
A desvantagem de depender diretamente de uma das interfaces de base fornecidas é dupla. Ambos podem ser considerados teóricos, mas acho que são importantes:
1. Dependendo da interface do repositório do **Spring Data**, a interface do repositório é acoplada à biblioteca. Eu não acho que esse seja um problema específico, pois você provavelmente usará abstrações como Pageou Pageableno seu código de qualquer maneira. O **Spring Data** não é diferente de nenhuma outra biblioteca de uso geral como o commons-lang ou o "Goiaba". Contanto que forneça benefícios razoáveis, tudo bem.
2. Ao estender **CrudRepository**, por exemplo, você expõe um conjunto completo de métodos de persistência de uma só vez. Provavelmente, isso também é bom na maioria das circunstâncias, mas você pode se deparar com situações nas quais deseja obter um controle mais refinado sobre os métodos expostos, por exemplo, para criar um **ReadOnlyRepository** que não inclua os métodos save(…)e .delete(…) **CrudRepository**
A primeira interface de repositório é uma interface básica de uso geral que, na verdade, apenas corrige o ponto 1, mas também vincula o tipo de ID a Longconsistência. A segunda interface geralmente possui todos os find…(…)métodos opiados **CrudRepository** e **PagingAndSortingRepository** não expõe os métodos de manipulação. Leia mais sobre essa abordagem na documentação de referência .
### Resumo
• PagingAndSortingRepository estende CrudRepository
• JpaRepository estende PagingAndSortingRepository
A interface CrudRepository fornece métodos para operações CRUD, permitindo criar, ler, atualizar e excluir registros sem precisar definir seus próprios métodos.
O PagingAndSortingRepository fornece métodos adicionais para recuperar entidades usando paginação e classificação.
Finalmente, o JpaRepository adiciona um pouco mais de funcionalidade específica ao JPA.
### ExceptionHandlerAdvice
**ExceptionHandler** é uma anotação Spring que fornece um mecanismo para tratar exceções lançadas durante a execução de manipuladores (operações do Controller). Esta anotação, se usada em métodos de classes de controlador, servirá como ponto de entrada para lidar com exceções lançadas somente neste controlador.
A maneira mais comum é usar **@ExceptionHandlermétodos** de **@ControllerAdviceclasses** para que o tratamento de exceções seja aplicado globalmente ou a um subconjunto de controladores.
**ControllerAdvice** é uma anotação introduzida no Spring 3.2 e, como o nome sugere, é "Conselho" para vários controladores. É usado para permitir que um único **ExceptionHandler** seja aplicado a vários controladores. Dessa maneira, em um único lugar, podemos definir como tratar uma exceção e esse manipulador será chamado quando a exceção for lançada das classes cobertas por isso **ControllerAdvice**. O subconjunto de controladores afectadas podem definida usando os seguintes selectores em **@ControllerAdvice**: annotations(), basePackageClasses(), e basePackages(). Se nenhum seletor for fornecido, ele **ControllerAdvice** será aplicado globalmente a todos os controladores.
Portanto, usando **@ExceptionHandler** e **@ControllerAdvice**, poderemos definir um ponto central para tratar exceções e agrupá-las em um ApiErrorobjeto com melhor organização do que o mecanismo padrão de manipulação de erros do Spring Boot.
---
### ResourceException
Essa é a interface raiz da hierarquia de exceções definida para a arquitetura do Connector. O ResourceException fornece as seguintes informações:
* Uma cadeia específica do fornecedor do adaptador de recursos que descreve o erro. Essa sequência é uma mensagem de exceção Java padrão e está disponível através do método getMessage ().
* Código de erro específico do fornecedor do adaptador de recursos.
* Referência a outra exceção. Geralmente, uma exceção de recurso é resultado de um problema de nível inferior. Se apropriado, essa exceção de nível inferior pode ser vinculada à ResourceException. Observe que isso foi descontinuado em favor do recurso de encadeamento de exceção do J2SE release 1.4.
---
### Thymeleaf
:point_right: https://www.thymeleaf.org/
O **Thymeleaf** não é um projeto Spring, mas uma biblioteca que foi criada para facilitar a criação da camada de view com uma forte integração com o Spring, e uma boa alternativa ao JSP. O principal objetivo do **Thymeleaf** é prover uma forma elegante e bem formatada para criarmos nossas páginas. O dialeto do **Thymeleaf** é bem poderoso como você verá no desenvolvimento da aplicação, mas você também pode estendê-lo para customizar de acordo com suas necessidades.
O **Thymeleaf** é um mecanismo de modelo Java moderno do lado do servidor para ambientes da Web e independentes.
O principal objetivo do **Thymeleaf** é trazer modelos naturais elegantes para o seu fluxo de trabalho de desenvolvimento - HTML que pode ser exibido corretamente nos navegadores e também funciona como protótipos estáticos, permitindo uma colaboração mais forte nas equipes de desenvolvimento.
Com módulos para o Spring Framework, uma série de integrações com suas ferramentas favoritas e a capacidade de conectar sua própria funcionalidade, o **Thymeleaf** é ideal para o desenvolvimento da web em JVM HTML5 da atualidade - embora haja muito mais a fazer.
Documentação:
:point_right: https://www.thymeleaf.org/documentation.html
### Para criar um projeto Maven com SpringBoot
Clicar no menu, File -> New -> Maven Project...
Marcar “Create a simple Project...” -> Next....
Digitar “Group id” = nome do diretorio do seu projeto.
Digitar “Artfact id” = nome do seu projeto
Em “Packing”, selecionar “jar” pois é um projeto local
Finish e aguardar montar o projetoe baixar as dependencias...
Estrutura do projeto quando foi criado:
Para rodar o projeto:
Clicar na classe “Application” com o botão direito -> Run as -> Java application...
## Json
Site: http://www.json.org/
**JSON** (JavaScript Object Notation) é um modelo para armazenamento e transmissão de informações no formato texto. Apesar de muito simples, tem sido bastante utilizado por aplicações Web devido a sua capacidade de estruturar informações de uma forma bem mais compacta do que a conseguida pelo modelo XML, tornando mais rápido o parsing dessas informações. Isto explica o fato de o **JSON** ter sido adotado por empresas como Google e Yahoo, cujas aplicações precisam transmitir grandes volumes de dados.
### Sintaxe no JSON
A ideia utilizada pelo **JSON** para representar informações é simples: para cada valor representado, atribui-se um nome (ou rótulo) que descreve o seu significado. Esta sintaxe é derivada da forma utilizada pelo JavaScript para representar informações.
Um valor pode ser uma string entre aspas duplas, ou um número, ou verdadeiro ou falso ou nulo, ou um objeto ou uma matriz. Essas estruturas podem ser aninhadas.
Uma string é uma seqüência de zero ou mais caracteres Unicode, agrupados em aspas duplas, usando escapes de barra invertida. Um caractere é representado como uma única cadeia de caracteres. Uma string é muito parecida com uma string C ou Java.
Um número é muito parecido com um número C ou Java, exceto que os formatos octal e hexadecimal não são usados.
### Exemplos:
* Representando o ano de 2018
```javascript=
"ano": 2018
```
Um par nome/valor deve ser representado pelo nome entre aspas duplas, seguido de dois pontos, seguido do valor. Os valores podem possuir apenas 3 tipos básicos: numérico (inteiro ou real), booleano e string. As Listagens 2, 3, 4 e 5 apresentam exemplos. Observe que os valores do tipo string devem ser representados entre aspas.
* Representando um número real
```javascript=
"altura": 1.72
```
* Representando uma string
```javascript=
"site": “www.devmedia.com.br”
```
* Representando um número negativo
```javascript=
"temperatura": -2
```
* Representando um valor booleano
```javascript=
"casado": true
```
A partir dos tipos básicos, é possível construir tipos complexos: array e objeto. Os arrays são delimitados por colchetes, com seus elementos separados entre vírgulas. As listagens 6 e 7 mostram exemplos.
* Array de Strings
```javascript=
[“RJ”, “SP”, “MG”, “ES”]
```
* Matriz de Inteiros
```javascript=
[
[1,5],
[-1,9],
[1000,0]
]
```
Os objetos são especificados entre chaves e podem ser compostos por múltiplos pares nome/valor, por arrays e também por outros objetos. Desta forma, um objeto **JSON** pode representar, virtualmente, qualquer tipo de informação! O exemplo da Listagem 8 mostra a representação dos dados de um filme.
Um objeto é um conjunto não ordenado de pares nome / valor. Um objeto começa com {(chave esquerda) e termina com} (chave direita). Cada nome é seguido por: (dois pontos) e os pares nome / valor são separados por (vírgula).
* Objeto
```javascript=
{
“titulo”: “JSON x XML”,
“resumo”: “o duelo de dois modelos de representação de informações”,
“ano”: 2012,
“genero”: [“aventura”, “ação”, “ficção”]
}
```
Uma matriz é uma coleção ordenada de valores. Um array começa com [(colchete esquerdo) e termina com] (colchete direito). Os valores são separados por (vírgula).
Array de objetos
```javascript=
[
{
“titulo”: “JSON x XML”,
“resumo”: “o duelo de dois modelos de representação de informações”,
“ano”: 2012,
“genero”: [“aventura”, “ação”, “ficção”]
},
{
“titulo”: “JSON James”,
“resumo”: “a história de uma lenda do velho oeste”,
“ano”: 2012,
“genero”: [“western”]
}
]
```
A palavra-chave “null” deve ser utilizada para a representação de valores nulos.
* Representando um valor nulo
```javascript=
"site":null
```
### JSON x XML
Podemos entender o **JSON** como uma espécie de “concorrente” da XML na área de troca de informações.
#### Semelhanças:
• Os dois modelos representam informações no formato texto.
• Ambos possuem natureza auto-descritiva (ou seja, basta “bater o olho” em um arquivo **JSON** ou em um arquivo XML para entender o seu significado).
• Ambos são capazes de representar informação complexa, difícil de representar no formato tabular. Alguns exemplos: objetos compostos (objetos dentro de objetos), relações de hierarquia, atributos multivalorados, arrays, dados ausentes, etc.
• Ambos podem ser utilizados para transportar informações em aplicações AJAX.
• Ambos podem ser considerados padrões para representação de dados. XML é um padrão W3C, enquanto **JSON** foi formalizado na RFC 4627.
• Ambos são independentes de linguagem. Dados representados em XML e **JSON** podem ser acessados por qualquer linguagem de programação, através de API’s específicas.
#### Diferenças:
• **JSON** não é uma linguagem de marcação. Não possui tag de abertura e muito menos de fechamento!
• **JSON** representa as informações de forma mais compacta.
• **JSON** não permite a execução de instruções de processamento, algo possível em XML.
• **JSON** é tipicamente destinado para a troca de informações, enquanto XML possui mais aplicações. Por exemplo: nos dias atuais existem bancos de dados inteiros armazenados em XML e estruturados em SGBD’s XML nativo.
### JSON no Java
Ao acessar a home page oficial do **JSON** (www.json.org) você verá que existem parsers disponíveis para quase todas as linguagens: Delphi, PHP, Java, Matlab, C++, C#, etc.
No XML a coisa é bem mais fácil, pois existem duas API’s básicas para o parsing de informações: SAX e DOM. Ambas já são instaladas junto com o Java e, daí, basta utilizá-las. Adicionalmente, o princípio de funcionamento das API’s SAX e DOM é bastante conhecido pelos desenvolvedores: DOM importa o documento todo para a memória, criando uma árvore, enquanto o SAX percorre o arquivo sequencialmente disparando eventos, sem realizar a importação de informações para a memória.
O **JSON** parece ainda não ter atingido esse grau maturidade. Várias pessoas/empresas implementaram os seus próprios parsers, com diferentes princípios de funcionamento. Como ainda não há um padrão, fica difícil decidir qual utilizar!
Para converter um objeto Java para **JSON**, utiliza-se o método toJson. E para fazer ao contrário, ou seja, atribuir o conteúdo de um objeto Java a partir de uma string Json, utiliza-se fromJson.
## Json-server
### Para instalar o Json-server:
Precisamos ter o **Node** instalado.
Site **Node** :point_right: https://nodejs.org/en/download/
Depois de instalado o Node, instalaremos o **Json-server**.
Site **Json-server** :point_right: https://www.npmjs.com/package/json-server
Numa janela de terminal, digitar o comando de instalação:
```javascript=
npm i -g json-server
```
### O que é o JSON Server?
Ter uma API pronta para começar o desenvolvimento do front-end da sua aplicação as vezes pode ser um problema. Com isso te apresento o **JSON Server**. **JSON Server** é uma biblioteca capaz de criar uma API Fake em 30 segundos e sem precisar escrever nenhuma linha de código.
### O Que É REST?
REST vem de REpresentational State Transfer. É um estilo de arquitetura para projetar aplicações conectadas, usando os simples verbos HTTP para permitir a comunicação entre as máquinas. Assim, ao invés de usar uma URL para manipular informação do usuário, REST enviar uma requisição HTTP, como GET, POST, DELETE, etc., para uma URL manipular os dados.
### Por Que Precisamos de uma API REST Falsa?
APIs REST formam o backend de aplicações web e móveis. Ao criar aplicações, algumas vezes não temos APIs REST prontas para uso no durante o desenvolvimento. Para ver um app web ou móvel em ação, precisamos de um servidor que retorne dados **JSON** falsos.
É aí que uma API REST falsa entra em ação. json-server provê a funcionalidade para configurar um servidor de API REST falso com mínimo de esforço.
## HttpStatus
**HTTP** é um protocolo web para visualização de “hipertexto” – ou websites, em resumo, e este protocolo é trocado entre o servidor e o navegador. Então vamos aprofundar sobre o que é **HTTP**, o que significa este protocolo, qual a diferença entre as duas siglas e quais os principais códigos que você deve conhecer e se preocupar para garantir o bom funcionamento do seu site.
### O que é HTTP?
**HTTP** são respostas padrões que os servidores enviam aos navegadores quando acessam um site. Estas respostas são códigos que ajudam a identificar o status de uma página na internet, e quando há um problema no site ou em algum recurso do site, que não permite que o mesmo seja carregado devidamente, temos um código que indica o erro, o **HTTP** Error.
**HTTP** significa HyperText Transfer Protocol (Protocolo de Transferência de Hipertexto). O HTTP é formado de um código de status e um motivo, que dá significado ao que o código representa.
### Então o que é HTTPS?
O **HTTPS** é “Protocolo de Transferência de Hipertexto” com Secure Sockets Layer (SSL), que é um certificado de segurança digital para fazer com que a troca de dados na internet seja mais segura.
Este certificado de segurança, o SSL, é apropriado para todos os websites, sendo indispensável para lojas virtuais, onde acontece troca de dados financeiros e de cartão de crédito, e qualquer outro site onde haja troca de dados pessoais como formulários cadastrais com nome, email, telefone e senhas.
**1XX: Informativo – a solicitação foi aceita ou o processo continua em andamento;**
1 Lista de códigos de status HTTP
**2XX: Confirmação – a ação foi concluída ou entendida;**
2 1xx Informativa
2.1 100 Continuar
2.2 101 Mudando protocolos
2.3 102 Processamento (WebDAV) (RFC 2518)
2.4 122 Pedido-URI muito longo
**3XX: Redirecionamento – indica que algo mais precisa ser feito ou precisou ser feito para completar a solicitação;**
3 200 Sucesso
3.1 201 Criado
3.2 202 Aceito
3.3 203 não-autorizado (desde HTTP/1.1)
3.4 204 Nenhum conteúdo
3.5 205 Reset
3.6 206 Conteúdo parcial
3.7 207-Status Multi (WebDAV) (RFC 4918)
**4XX: Erro do cliente- indica que a solicitação não pode ser concluída ou contém a sintaxe incorreta;**
4 3xx Redirecionamento
4.1 300 Múltipla escolha
4.2 301 Movido
4.3 302 Encontrado
4.4 303 Consulte Outros
4.5 304 Não modificado
4.6 305 Use Proxy (desde HTTP/1.1)
4.7 306 Proxy Switch
4.8 307 Redirecionamento temporário (desde HTTP/1.1)
4.9 308 Redirecionamento permanente (RFC 7538)
**5XX: Erro no servidor – o servidor falhou ao concluir a solicitação.**
5 4xx Erro de cliente
5.1 400 Requisição inválida
5.2 401 Não autorizado
5.3 402 Pagamento necessário
5.4 403 Proibido
5.5 404 Não encontrado
5.6 405 Método não permitido
5.7 406 Não Aceitável
5.8 407 Autenticação de proxy necessária
5.9 408 Tempo de requisição esgotou (Timeout)
5.10 409 Conflito geral
5.11 410 Gone
5.12 411 comprimento necessário
5.13 412 Pré-condição falhou
5.14 413 Entidade de solicitação muito grande
5.15 414 Pedido-URI Too Long
5.16 415 Tipo de mídia não suportado
5.17 416 Solicitada de Faixa Não Satisfatória
5.18 417 Falha na expectativa
5.19 418 Eu sou um bule de chá
5.20 422 Entidade improcessável (WebDAV) (RFC 4918)
5.21 423 Fechado (WebDAV) (RFC 4918)
5.22 424 Falha de Dependência (WebDAV) (RFC 4918)
5.23 425 coleção não ordenada (RFC 3648)
5.24 426 Upgrade Obrigatório (RFC 2817)
5.25 450 bloqueados pelo Controle de Pais do Windows
5.26 499 cliente fechou Pedido (utilizado em ERPs/VPSA)
**6 5xx outros erros**
6.1 500 Erro interno do servidor (Internal Server Error)
6.2 501 Não implementado (Not implemented)
6.3 502 Bad Gateway
6.4 503 Serviço indisponível (Service Unavailable)
6.5 504 Gateway Time-Out
6.6 505 HTTP Version not supported
### O que é HTTP Error?
**Error HTTP** são os códigos HTTP que referem-se a erros de cliente e servidor, respectivamente, e impedem o carregamento de um site.
Quando você visita um site, o seu navegador faz uma solicitação ao servidor, e o servidor responde o navegador com um código, os códigos **HTTP**. São esses códigos que informam o que o servidor e navegador estão conversando entre si.
E com as informações do tópico anterior, fica fácil deduzir que os códigos **HTTP Error** são sempre começados pelos números 4 ou 5, que são respectivamente falhas do cliente (navegador) ou do servidor. Certo? Então vamos para o próximo passo.
## Stream
### Primeiros Passos
Vamos começar com um pouco de teoria. Qual a definição de stream? De forma sucinta, podemos dizer que é uma "sequência de elementos de uma fonte de dados que suporta operações de agregação". Vamos dividir a definição:
* **Sequência de elementos**: Uma stream oferece uma interface para um conjunto de valores sequenciais de um tipo de elemento particular. Apesar disso, as streams não armazenam elementos; estes são calculados sob demanda.
* **Fonte de dados**: As streams tomam seu insumo de uma fonte de dados, como coleções, matrizes ou recursos de E/S.
* **Operações de agregação**: As streams suportam operações do tipo SQL e operações comuns à maioria das linguagens de programação funcionais, como filter, map, reduce, find, match e sorted, entre outras.
Ainda mais, as operações das streams têm duas características fundamentais que as diferenciam das operações com coleções:
* **Estrutura de processo**: Muitas operações de stream retornam outra stream. Assim, é possível encadear operações para formar um processo mais abrangente. Isto, por sua vez, permite algumas otimizações, por exemplo mediante as noções de "preguiça" (laziness) e "corte de circuitos" (short-circuiting), que analisaremos mais a frente.
* **Iteração interna**: Diferentemente do trabalho com coleções, em que a iteração é explícita (iteração externa), as operações da stream realizam uma iteração por trás dos bastidores.
### Streams x coleções
A noção de coleções já existente em Java e a nova noção de streams se referem a interfaces com sequências de elementos. Então, qual a diferença? Resumindo, as coleções se referem a dados enquanto as streams se referem a cálculos.
Vamos pensar em um filme armazenado em um DVD. Trata-se de uma coleção (de bytes ou fotogramas, isto não é importante para nosso exemplo) pois contém toda a estrutura de dados. Agora vamos imaginar o mesmo vídeo, mas, desta vez, reproduzimos na Internet. Neste caso, falamos de uma stream (de bytes ou fotogramas). O reprodutor de vídeo por sequências (streaming) precisa descarregar apenas uns poucos fotogramas além daqueles que o usuário está assistindo; assim, é possível começar a mostrar os valores do início da stream antes de que a maior parte da stream tenha sido calculada (a transmissão de sequências ou streaming pode ser pensada como um jogo de futebol ao vivo).
Em palavras mais simples, a diferença entre coleções e streams tem a ver com quando os cálculos são feitos. As coleções são estruturas de dados armazenados na memória, onde estão todos os valores que a estrutura de dados tem em um momento determinado; cada elemento da coleção deve ser calculado antes de se agregar à coleção. Já as streams são estruturas de dados fixas, cujos elementos são calculados sob demanda.
Quando a interface Collection é usada, o usuário deve se ocupar da iteração (por exemplo, mediante foreach, laço for melhorado); essa abordagem é chamada de iteração externa.
```java=
List<String> transactionIds = new ArrayList<>();
for(Transaction t: transactions){
transactionIds.add(t.getId());
}
```
```java=
List<Integer> transactionIds =
transactions.stream()
.map(Transaction::getId)
.collect(toList());
```
### Operações de streams:
Como aproveitar as streams para processar dados. A interface Stream de java.util .stream.Stream define várias operações que podem ser reunidas em duas categorias. No exemplo da Figura 1 identificamos as seguintes operações:
* **filter**, sorted e map, que podem se conectar para formar um processo;
* **collect**, que encerra o processo e retorna um resultado.
As operações de streams que podem se conectar entre si são chamadas de operações intermediárias. Elas podem se conectar porque a saída retornada é de tipo Stream. As operações que encerram um processo de stream são chamadas de operações terminais. A partir de um processo, elas produzem um resultado de tipo List, Integer ou até void (de tipos distintos de Stream).
### Filtragem.
Diversas operações podem ser usadas para filtrar elementos de uma stream:
* **filter(Predicate)**: Toma um predicado (java.util.function.Predicate) como argumento e retorna uma stream incluindo todos os elementos que coincidem com o predicado indicado.
* **distinct**: Retorna uma stream com elementos únicos (dependendo da implementação de equals para um elemento da stream).
* **limit(n)**: Retorna uma stream cuja longitude máxima é n.
* **skip(n)**: Retorna uma stream em que se descartaram os primeiros n números.
### Mapeamento.
As streams suportam o método map, que usa uma função (java.util.function.Function) como argumento para projetar os elementos da stream em outro formato. A função é aplicada a cada elemento, que é "mapeado" ou associado a um novo elemento.
### Redução.
As operações terminais que vimos até agora retornam objetos boolean (allMatch e similares), void (forEach) ou Optional (findAny e similares). Também usamos collect para combinar todo o conjunto de elementos de uma Stream em um objeto List.
## Atalhos
|Atalho|Comando|
|--|--|
|ctrl + shift + o | importar bibliotecas |
|ctrl + shift + f | alinhar/formatar|
|ctrl + espaco | construtor vazio|
|main --> ctrl + espaco | método de execução|
|syso --> ctrl + espaco | System.out.println|
|alt+shift+s (source) | generate getter and setter|
|alt+shift+s (source) | generate construtor using fields|
|alt+shift+s (source) | generate construtor using fields toString() |
|new Nome() ... CTRL+1 ... Enter | cria variável tipada|
|CTRL+SHIFT+T | procurar classes|
|ALT +SHIFT +X ... + J | Run as Java application|
|ALT+ ENTER | Propriedades do projeto ( Para adicionar externals jars no Build Path, Ver diretório do proj...)|
|CTRL+M | Visualização das janelas|
|CTRL+1 | add package declaration|
|CTRL+ / | comentar bloco de código|
## CorsFilter
**CORS - Cross-Origin Resource Sharing** (Compartilhamento de recursos com origens diferentes) é um mecanismo que usa cabeçalhos adicionais HTTP para informar a um navegador que permita que um aplicativo Web seja executado em uma origem (domínio) com permissão para acessar recursos selecionados de um servidor em uma origem distinta. Um aplicativo Web executa uma requisição cross-origin HTTP ao solicitar um recurso que tenha uma origem diferente (domínio, protocolo e porta) da sua própria origem.
Um exemplo de requisição **cross-origin**: o código JavaScript frontend de um aplicativo web em um servidor http://domain-a.com usa XMLHttpRequest para fazer uma requisição em http://api.domain-b.com/data.json.
Por motivos de segurança, navegadores restringem requisições cross-origin HTTP a partir de scripts. Por exemplo, XMLHttpRequest e Fetch API seguem a política de mesma origem (same-origin policy). Assim, um aplicativo web que faz uso dessas APIs só poderá fazer requisições HTTP da mesma origem da qual o aplicativo foi carregado, a menos que a resposta da outra origem inclua os cabeçalhos CORS corretos.
O padrão **Cross-Origin** Resource Sharing trabalha adicionando novos cabeçalhos HTTP que permitem que os servidores descrevam um conjunto de origens que possuem permissão a ler uma informação usando o navegador. Além disso, para métodos de requisição HTTP que podem causar efeitos colaterais nos dados do servidor (em particular, para métodos HTTP diferentes de GET ou para uso de POST com certos MIME types), a especificação exige que navegadores "pré-enviem" a requisição, solicitando os métodos suportados pelo servidor com um método de requisição HTTP OPTIONS e, após a "aprovação", o servidor envia a requisição verdadeira com o método de requisição HTTP correto. Servidores também podem notificar clientes se "credenciais" (incluindo Cookies e dados de autenticação HTTP) devem ser enviadas com as requisições.
Falhas no **CORS** resultam em erros, mas por questões de segurança, detalhes sobre erros não estão disponíveis no código JavaScript. O código tem apenas conhecimento de que ocorreu um erro. A única maneira para determinar especificamente o que ocorreu de errado é procurar no console do navegador por mais detalhes.
Seções subsequentes discutem cenários, assim como fornecem um detalhamento dos cabeçalhos HTTP utilizados.
O mecânismo **CORS** suporta requisições seguras do tipo cross-origin e transferências de dados entre navegadores e servidores web. Navegadores modernos usam o CORS em uma API contêiner, como XMLHttpRequest ou Fetch, para ajudar a reduzir os riscos de requisições **cross-origin** HTTP.
### Quais solicitações usam o CORS?
Esse padrão de compartilhamento **cross-origin** é usado para habilitar solicitações HTTP entre sites para:
* Chamadas XMLHttpRequest ou Fetch API pela comunicação entre origens diferentes, tal como discutido acima.
* Web Fonts (para o uso de fontes pelo cross-domain em @font do CSS), para que os servidores possam implantar fontes TrueType que só podem ser carregadas em origens diferentes e usadas por sites com autorização para isso.
* Texturas WebGL.
* Frames de Imagens/vídeos desenhados em uma tela usando drawImage().
Leia mais :point_right: https://developer.mozilla.org/pt-BR/docs/Web/HTTP/Controle_Acesso_CORS
## Anotações JAXB (xml)
Aprenda sobre as anotações JAXB em detalhes, juntamente com seu uso durante as operações de empacotamento e descompilação.
|Anotação|Escopo|Descrição|
|--|--|--|
|@XmlRootElement| Classe, Enum| Define o elemento raiz XML. As classes Java raiz precisam ser registradas com o contexto JAXB quando ele é criado.|
|@XmlAccessorType| Pacote, Classe| Define os campos e propriedades de suas classes Java que o mecanismo JAXB usa para ligação. Ele tem quatro valores: PUBLIC_MEMBER, FIELD, PROPERTYe NONE.|
|@XmlAccessorOrder| Pacote, Classe| Define a ordem sequencial dos filhos.|
|@XmlType |Classe, Enum| Mapeia uma classe Java para um tipo de esquema. Ele define o nome do tipo e a ordem de seus filhos.|
|@XmlElement| Campo| Mapeia um campo ou propriedade para um elemento XML|
|@XmlAttribute| Campo| Mapeia um campo ou propriedade para um atributo XML|
|@XmlTransient| Campo| Impede o mapeamento de um campo ou propriedade para o esquema XML|
|@XmlValue| Campo| Mapeia um campo ou propriedade para o valor do texto em uma tag XML.|
|@XmlList| Campo, Parâmetro| Mapeia uma coleção para uma lista de valores separados por espaço.|
|@XmlElementWrapper| Campo| Mapeia uma coleção Java para uma coleção agrupada XML|
**1.1) @XmlRootElement**
Isso mapeia uma classe ou um tipo de enumeração para um elemento raiz XML. Quando uma classe de nível superior ou um tipo de enumeração é anotada com a @XmlRootElementanotação, seu valor é representado como elemento XML em um documento XML.
**1.2) @XmlAccessorType**
Ele define os campos ou propriedades de suas classes Java que o mecanismo JAXB usa para incluir no XML gerado. Possui quatro valores possíveis.
**FIELD**- Todo campo não estático e não transitório em uma classe vinculada a JAXB será automaticamente ligado ao XML, a menos que seja anotado por XmlTransient.
**NONE** - Nenhum dos campos ou propriedades está vinculado ao XML, a menos que sejam especificamente anotados com algumas das anotações JAXB.
**PROPERTY**- Cada par getter / setter em uma classe vinculada a JAXB será automaticamente associado a XML, a menos que seja anotado por XmlTransient.
**PUBLIC_MEMBER**- Todo par público de getter / setter e todo campo público serão automaticamente vinculados ao XML, a menos que anotados por XmlTransient.
O valor padrão é PUBLIC_MEMBER.
**1.3) @XmlAccessorOrder**
Controla a ordem dos campos e propriedades em uma classe. Você pode ter valores predefinidos ALPHABETICALou UNDEFINED.
**1.4) @XmlType**
Ele mapeia uma classe Java ou um tipo de enumeração para um tipo de esquema. Ele define o nome do tipo, espaço para nome e ordem de seus filhos. É usado para combinar o elemento no esquema ao elemento no modelo.
**1.5) @XmlElement**
Mapeia uma propriedade JavaBean para um elemento XML derivado do nome da propriedade.
**1.6) @XmlAttribute**
Mapeia uma propriedade JavaBean para um atributo XML.
**1.7) @XmlTransient**
Impede o mapeamento de uma propriedade / tipo JavaBean para representação XML. Quando colocada em uma classe, indica que a classe não deve ser mapeada para XML sozinha. As propriedades dessa classe serão mapeadas para XML junto com suas classes derivadas, como se a classe estivesse embutida.
**@XmlTransient** é mutuamente exclusivo com todas as outras anotações definidas pelo JAXB.
**1.8) @XmlValue**
Permite mapear uma classe para um tipo complexo de Esquema XML com um tipo simples simpleContent ou XML Schema. Está mais relacionado ao mapeamento de esquema para mapeamento de modelo.
**1.9) @XmlList**
Usado para mapear uma propriedade para um tipo simples de lista. Ele permite que vários valores sejam representados como tokens separados por espaços em branco em um único elemento.
**1.10) @XmlElementWrapper**
Gera um elemento de wrapper em torno da representação XML. Isso se destina principalmente a ser usado para produzir um elemento XML do wrapper em torno das coleções. Portanto, ele deve ser usado com a propriedade de coleção.
## Bootstrap
http://getbootstrap.com/
Desenvolvido pela equipe do Twitter, o Bootstrap é um framework front-end de código aberto (opensource). Em palavras simples, é um conjunto de ferramentas criadas para facilitar o desenvolvimento de sites e sistemas web.
Compatível com HTML5 e CSS3, o framework possibilita a criação de layouts responsivos e o uso de gris, permitindo que seu conteúdo seja organizado em até 12 colunas e que comporte-se de maneira diferente para cada resolução.
Como qualquer outra ferramenta, possui suas vantagens e desvantagens. É importante conhecer e entender suas funcionalidades para saber os momentos certos de utilizá-lo.
### Vantagens
* Possui documentação detalhada e de fácil entendimento;
* É otimizado para o desenvolvimento de layouts responsivos;
* Possui componentes suficientes para o desenvolvimento de qualquer site ou sistema web com interface simples;
* Facilita a criação e edição de layouts por manter padrões;
* Funciona em todos os navegadores atuais (Chrome, Safari, Firefox, IE, Opera).
### Desvantagens
* Seu código terá de seguir os “padrões de desenvolvimento Bootstrap”;
* Tema padrão e comum do Bootstrap (caso não faça ajustes visuais, seu projeto se parecerá com outros que também utilizam o Bootstrap).
A estrutura é simples e seu pacote contém três tipos diferentes de arquivos (CSS, JavaScrpipt e Fonts), que vêm devidamente organizados em suas pastas.
Montar um layout é simples e rápido utilizando sua documentação. Como toda a estrutura do CSS já vem definida, basta procurar o componente necessário e adicionar seu código. Em poucos minutos seu layout toma forma e está pronto para uso! E o mesmo acontece com o JavaScript.
### O sistema de grids
O uso efetivo dos grids é fundamental para um bom projeto com o Bootstrap e entender sua lógica é simples. O sistema de grids possibilita a divisão em até 12 colunas de mesma largura.
## Curl
O que é cURL?
O cURL é uma ferramenta para criar requisições em diversos protocolos (incluindo HTTP, HTTPS e FTP, entre muitos outros) e obter conteúdo remoto. Ele existe como ferramenta de linha de comando, e também como biblioteca
É um comando dos sistemas operacionais unix-like que obtêm ou envia documentos/arquivos para um servidor, usando qualquer um dos protocolos suportados (HTTP, HTTPS, FTP, Gopher DICT, telnet, SSH, LDAP ou arquivo). O comando é projetado para funcionar sem a interação do usuário ou qualquer tipo de interatividade entre servidor e cliente.
| comando | Abrir o arquivo | Local onde será gravado | Endereco da api a ser testada |
| -------- | -------- | -------- | ----|
| curl | -o | c:/temp3/meucep.json | http://api.postmon.com.br/v1/cep/20040007 |
## Para habilitar o Gmail a enviar email pelo Java:
Clicar na conta do usuario.
Clicar em Segurança e descer até Acesso a app menos seguro. Clicar em ativar acesso.
Será redirecionado a outra pagina.
Clicar no botão para ativar.
:point_right: Pronto!
---
## :leaves: Swagger
.
**`https://swagger.io/`**
### O que é o Swagger?
O **Swagger** é um framework composto por diversas ferramentas que, independente da linguagem, auxilia a descrição, consumo e visualização de serviços de uma API REST.
No framework **Swagger**, existem ferramentas para os seguintes tipos de tarefas a serem realizadas para o completo desenvolvimento da API de um serviço WEB:
1) A especificação da API consiste em determinar os modelos de dados que serão entendidos pela API e as funcionalidades presentes na mesma. Para cada funcionalidade, é preciso especificar o seu nome, os parâmetros que devem ser passados no momento de sua invocação e os valores que irão ser retornados aos usuários da API. Entre esta ferramentas, podemos citar o OpenAPI Specification.
2) Após especificar a API, o framework facilita sua implementação, com a ferramenta **Swagger** Codegen é possível montar o código inicial automaticamente nas principais linguagem de programação.
3) Os testes de API são extremamente importantes, pois ajudam a garantir o funcionamento, o desempenho e a confiabilidade da sua aplicação. O **Swagger** oferece ferramentas para teste manuais, automatizados e de desempenho
4) Para auxiliar na utilização da API, o **Swagger** dispõe de ferramenta para deixar a visualização mais intuitiva, permitindo também que interajam com a API.
O **Swagger** permite criar a documentação da API de 3 formas:
1- **Automaticamente**: Simultaneamente ao desenvolvimento da API é gerada a documentação.
2- **Manualmente**: Permite ao desenvolvedor escrever livremente as especificações da API e as publicar posteriormente em seu próprio servidor.
3- **Codegen**: Converte todas as anotações contidas no código fonte das APIs REST em documentação.
### Conheça o OpenAPI Specification
Apesar de ser open source desde sua criação, o **Swagger** Specification sempre teve uma empresa vinculada ao seu desenvolvimento. Entretanto em 2016, a SmartBear doou o projeto para a OpenAPI Initiative, uma organização criada pela mesma e que tem como integrantes alguns gigantes da indústria como Google, IBM, Microsoft. O projeto passou a ser chamado de OpenAPI Specification.
O OpenAPI Specification (OAS) é uma especificação para descrever, produzir, consumir e visualizar serviços de uma API REST. Com o OAS você poderá descrever recursos, URIs, modelo de dados, métodos HTTP aceitos e códigos de resposta. Infelizmente, nem toda ferramenta suporta a versão mais recente da OAS, logo, você terá que usar versões mais antigas caso queira utilizar as demais ferramentas que o Swagger disponibiliza.
.
### Ferramentas
#### Swagger Editor
O **Swagger Editor** é uma ferramenta online que permite criar manualmente a documentação da API. Ao utilizar YAML, faz com que o desenvolvedor não tenha dificuldades em descrever os seus serviços. Outro benefício do Editor é possuir um conjunto de templates de documentos que servem como base para quem não deseja iniciar a documentação do “zero”.
.
Ao lado esquerdo, podemos ver o “código” da documentação. No lado direito, é possível ver o resultado gerado a partir das informações contidas neste código. Ao editar o lado esquerdo podemos conferir de forma simultânea o resultado no lado direito.
.
#### Swagger UI
Com o **Swagger UI**, a partir da especificação da API, podemos criar documentações elegantes e acessíveis ao usuário, permitindo assim uma compreensão maior da API, pois além de poder ver os endpoints e modelos das entidades com seus atributos e respectivos tipos, o módulo de UI possibilita que os usuários da API interajam intuitivamente com a API usando uma sandbox. A sandbox é uma plataforma de testes onde as aplicações podem ser alteradas sem interferir no meio de produção. Nela, os desenvolvedores podem executar todas as operações de mudanças experimentais que vão garantir o bom funcionamento da solução, evitando danos que possam prejudicar o sistema.
.
Cada barra colorida é uma rota da API da Orquestra de Ouro Preto. Nas barras podemos ver o caminho da rota, o método utilizado e alguns dos parâmetros necessários. Ao clicar em uma das barras ela se expande mostrando um exemplo de como cada parâmetro deve ser preenchido e a resposta esperada, como podemos ver na figura.
.
.
É possível testar a requisição, para isso basta apenas clicar no botão “Try it out”, que está no canto superior na Figura 4, preenchendo os parâmetros e clicar no botão execute. Dessa forma, um desenvolvedor que utiliza esta documentação da API sabe exatamente o que esperar nas respostas e o que necessário enviar nas requisições. Há duas maneiras simples de tornar o módulo UI da API público. A primeira é utilizar a plataforma SwaggerHub, a plataforma online do Swagger, mas a plataforma é paga e o plano free permite publicar apenas 3 projetos. A outra maneira é, se a API for em NodeJS, você pode colocá-la no seu servidor e criar um endpoint na API dando acesso ao módulo.
.
#### Swagger Codegen
O **Swagger Codegen** é um projeto muito interessante, a partir da especificação em YAML gera automaticamente o “esqueleto” da API em diferentes linguagens, como Java, Python,Kotlin, Lua, Haskell, C++, entre outras . Isso mesmo, com algumas linhas de comando você cria todo o código inicial da sua API na linguagem que desejar. Se você deseja utilizar o Codegen é recomendável que primeiro verifique quais versões do OpenAPI Specification ele suporta. Você pode conferir no link: **`https://github.com/swagger-api/swagger-codegen#compatibility`**
.
#### Swagger Inspector e ReadyAPI
Assim como o Postman e o Insomnia, o **Swagger Inspector** é uma GUI que auxilia nos testes manuais da sua API, não só Rest como SOAP(Simple Object Access Protocol) ou GraphQL. Diferente dos outros dois citados, o **Swagger Inspector** não precisa ser instalado, todos seus testes são feitos na nuvem, basta criar uma conta no SwaggerHub, os teste são salvos e você pode acessar a qualquer momento. Se você utiliza o Chrome ou Firefox, você será solicitado a baixar a extensão, ela permite o compartilhamento de recursos de origem cruzada (CORS), que normalmente não é permitido em navegadores. Isso permite que seu navegador acesse informações de servidores fora do site em que você está e faça uma chamada à API.
**ReadyAPI** é a nova ferramenta paga que juntou LoadUI Pro e SoapUI Pro, com a ReadyAPI você pode fazer testes automatizados(SoapUI Pro), de segurança e carga (LoadUI Pro) em um só ambiente.
.
### Download do arquivo Swagger
É possível fazer download do arquivo **Swagger** da API em dois formatos: YAML ou JSON. Para isso, clique no botão File e escolha entre Save as YAML ou Convert and save as JSON.
.
## Apache Kafka
.
### O que é Kafka?
**Kafka** é uma plataforma de streaming de eventos distribuídos de código aberto, facilitando o rendimento bruto. Escrito em Java e Scala, o **Kafka** é um barramento de mensagem pub / sub voltado para fluxos e reprodução de dados de alto ingresso. Em vez de depender de uma fila de mensagens, **Kafka** anexa mensagens ao log e as deixa lá, onde permanecem até que o consumidor as leia ou alcance seu limite de retenção.
O **Kafka** emprega uma abordagem “baseada em pull”, permitindo que os usuários solicitem lotes de mensagens de deslocamentos específicos. Os usuários podem aproveitar o envio em lote de mensagens para maior rendimento e entrega eficaz de mensagens.
Embora o **Kafka** seja fornecido apenas com um cliente Java, ele oferece um SDK do adaptador, permitindo que os programadores construam sua integração de sistema exclusiva. Há também um catálogo crescente de projetos de ecossistemas comunitários e clientes de código aberto.
Segundo o livro Designing Event-Driven System, o **Kafka** é uma plataforma de Streaming. Há APIs de processamento de Stream e APIs para envio e recebimento de dados.
.
Você pode usar o **Kafka** como uma Fonte da Verdade. Recebendo eventos e dados, processando os dados e construir pipelines de dados e complexas arquiteturas baseadas em eventos e dados.
### Para que é usado o Kafka?
**Kafka** é melhor usado para streaming de A para B sem recorrer a roteamento complexo, mas com rendimento máximo. Também é ideal para originar eventos, processar stream e realizar mudanças de modelagem em um sistema como uma sequência de eventos. O **Kafka** também é adequado para processar dados em pipelines de vários estágios.
Resumindo, use o **Kafka** se precisar de uma estrutura para armazenar, ler, reler e analisar dados de streaming. É ideal para sistemas auditados rotineiramente ou que armazenam suas mensagens permanentemente. Dividindo ainda mais, **Kafka** brilha com processamento em tempo real e análise de dados.
### Arquitetura
O **Kafka** é um broker que roda em cluster, para sistemas tolerante a falhas, é aconselhável que seja configurar mais de uma instância. Como é um cluster, ele roda usando o ZooKeeper para sincronia.
Ele recebe, armazena e distribui records. Um record é um dado gerado por algum nó do sistema que pode ser um evento ou uma informação. Ele é enviado para o cluster e o mesmo o armazena em uma partition do tópico.
Cada record possui um offset sequência, e o consumer pode controlar o offset que está consumindo. Assim, caso há a necessidade de se reprocessar o tópico, pode ser feito baseado no offset.
.
* **Plataforma de fluxos e mensagens publicar-assinar de alto volume** - durável, rápida e escalonável.
* **Armazenamento de mensagem durável** - como um log, executado em um cluster de servidor, que mantém fluxos de registros em tópicos (categorias).
* **Mensagens** - compostas por um valor, uma chave e um carimbo de data / hora.
* **Modelo de corretor burro / consumidor inteligente** - não tenta rastrear quais mensagens são lidas pelos consumidores e apenas mantém as mensagens não lidas. **Kafka** guarda todas as mensagens por um determinado período de tempo.
* **Requer serviços externos para ser executado** - em alguns casos, o Apache Zookeeper.
.
### Apache Kafka: abordagem baseada em pull
**Kafka** usa um modelo pull. Os consumidores solicitam lotes de mensagens de um deslocamento específico. **Kafka** permite long-pooling, que evita loops apertados quando não há mensagem após o deslocamento.
Um modelo pull é lógico para **Kafka** por causa de suas partições. O **Kafka** fornece a ordem das mensagens em uma partição sem consumidores concorrentes. Isso permite que os usuários aproveitem o envio em lote de mensagens para uma entrega eficaz e um rendimento mais alto.
.
### Produzindo Mensagens
A produção de mensagens no **Kafka** é mais simples que o consumo. Uma mensagem é produzida e enviada para um Tópico. Não é preciso especificar um schema para mensagem, a única preocupação entre produtor e consumidor é como ela será Serializada.
Sistemas mais antigos usavam XML, mas o tanto de dados gerados é muito grande para pouca informação. Hoje é muito usado o formato JSON, que é de fácil leitura humana e gera mensagens menores do que se usarmos XML.
### Consumindo Mensagens
Como já disse anteriormente, para consumir uma mensagem sua única preocupação tem que ser a Serialização de dados. Esse é o maior contrato entre produtor e consumidor no **Kafka**.
O **Kafka** garante que todas as mensagens somente serão consumidas uma vez por cliente. Isso significa, se eu enviar uma mensagem para um tópico X, e tiver 1000 consumidores com o Client ID Y, somente um vai processar essa mensagem. Isso garante um bom desacoplamento e fácil escalabilidade. Você pode delegar toda a sincronicidade do processamento para o **Kafka**.
Para que uma mensagem seja consumida por dois consumidores diferentes, só usar dois client ID diferentes.
### Outras funcionalidades
O **Kafka** permite usar os tópicos como tabelas, permitindo fazer queries para aquisição de dados, isso pode ser usado para uma arquitetura baseada em Eventos.
Essa funcionalidade porém não é tão simples como é descrito na documentação. A serialização é um grande impeditivo e em muitos momentos o stream "se perde". Acredito que essa feature só é recomendada quando:
* Os dados são apenas incrementais
* Os dados não são relacionais
* Os dados são sequênciais
### Performance do Apache Kafka
O **Kafka** oferece um desempenho muito maior do que corretores de mensagens como o RabbitMQ. Ele usa E / S de disco sequencial para aumentar o desempenho, tornando-o uma opção adequada para a implementação de filas. Ele pode atingir alto rendimento (milhões de mensagens por segundo) com recursos limitados, uma necessidade para casos de uso de big data.
### Casos de uso do Apache Kafka
O Apache **Kafka** fornece o próprio broker e foi projetado para cenários de processamento de fluxo. Recentemente, ela adicionou o **Kafka** Streams, uma biblioteca cliente para a construção de aplicativos e microsserviços. O Apache **Kafka** oferece suporte a casos de uso como métricas, rastreamento de atividade, agregação de log, processamento de fluxo, logs de confirmação e origem de evento.
Os seguintes cenários de mensagens são especialmente adequados para **Kafka**:
* Streams com roteamento complexo, taxa de transferência de eventos de 100 K / s ou mais, com ordenação particionada “pelo menos uma vez”
* Aplicativos que requerem um histórico de fluxo, entregue em ordem particionada “pelo menos uma vez”. Os clientes podem ver uma 'reprodução' do fluxo de eventos.
* Fonte de eventos, modelagem de mudanças em um sistema como uma sequência de eventos.
* Transmita dados de processamento em pipelines de vários estágios. Os pipelines geram gráficos de fluxos de dados em tempo real.
## Instalação do Servidor Apache Kafka no windows
### Programas para instalar:
  
* Java JDK 8 :arrow_right: http://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html
* Apache Kafka :arrow_right: http://kafka.apache.org/downloads.html
* Apache Zookeeper :arrow_right: http://zookeeper.apache.org/releases.html
Descompactar os arquivo do Kafka e do Zookeeper no diretorio `C:`
### Instalação do ZooKeeper
:arrow_right: Entrar na pasta `conf` e renomear o arquivo `zoo_sample.cfg`para `zoo.cfg`
.
:arrow_right: Editar o arquivo `zoo.cfg`
:arrow_right: Na linha: `dataDir=/tmp/zookeeper` mudar para `C:\Zookeeper-3.5.9\data` (caminho onde está descompactado o seu zookeeper)
:arrow_right: Criar variável de ambiente `ZOOKEEPER_HOME = C:\Zookeeper-3.5.9`
.
:arrow_right: Incluir no path o caminho: `%ZOOKEEPER_HOME%\bin`
.
:arrow_right: Porta padrão do Zookeeper: 2181
:arrow_right: Execute o ZooKeeper abrindo um terminal cmd e digite **zkserver**.
.
### Instalação do Kafka
:arrow_right: Entrar na pasta `conf`.
:arrow_right: Editar o arquivo `server.properties`
:arrow_right: Na linha: `log.dirs=/tmp/kafka-logs` mudar para `log.dirs=C:\Kafka_2.12\kafka-logs`
:arrow_right: Verificar se o zookeeper está iniciado. Execute o ZooKeeper abrindo um terminal cmd e digite **zkserver**.
:arrow_right: Criar as pastas: `kafka-logs` e `zookeeper`
:arrow_right: Abrir um terminal CMD dentro do diretório do kafka
.
:arrow_right: Digitar:
**`.\bin\windows\kafka-server-start.bat .\config\server.properties`**
Clicar ENTER.
.
### Criar um tópico de teste com o Kafka
:arrow_right: Na pasta: `C:\kafka-2.8.0\bin\windows`, abrir um terminal CMD.
:arrow_right: Digitar o comando:
**`kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic nome_do_topico`**
Se não funcionar tente:
**`kafka-topics.bat --create --topic nome_do_topico --bootstrap-server localhost:9092`**
.
### Criação de um produtor para servidor de teste
:arrow_right: Dentro da pasta: `C:\kafka_2.11-0.9.0.0\bin\windows`, abrir um terminal CMD.
:arrow_right: Para iniciar um produtor, Digitar o comando:
**`kafka-console-producer.bat --broker-list localhost:9092 --topic nome_do_topico`**
.
### Criação de um consumidor para servidor de teste
:arrow_right: Dentro da pasta: `C:\kafka_2.11-0.9.0.0\bin\windows`, abrir um ==NOVO== terminal CMD.
:arrow_right: Digitar o comando:
**`kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic nome_do_topico`**
.
:arrow_right: O prompt do terminal ficará preso aguardando receber uma mensagem.
:arrow_right: Digitar uma mensagem no terminal do produtor.
.
:arrow_right: Será recebido no terminal do consumidor.
.
:point_right: Enviado.
.
:point_right: Recebido.
### Comandos úteis
* **Tópicos da lista:** `kafka-topics.bat --list --zookeeper localhost:2181`
* **Descrição do tópico:** `kafka-topics.bat --describe --zookeeper localhost:2181 --topic [Topic Name]`
* **Ler as mensagens desde o início:** `kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic [Topic Name] --from-beginn`
* **Excluir Tópico:** `kafka-run-class.bat kafka.admin.TopicCommand --delete --topic [topic_to_delete] --zookeeper localhost:2181`
###### tags: `kafka` `java` `instalação` `apostila` `web`
Sign in with Wallet
Connect another wallet