Uaijug ADF - spring boot - microservice - Introdução

UaiJUG - ADF
Microservices com Spring boot
Prof. Rogério Fontes
@rogeriofontes
14/07/2018

Agenda
• Conceitos de Microserviços
• Conceitos do Modelo arquitetural RestFul.
• O que é o spring boot?
• Overview de como funciona o Spring boot.
• Criando uma Aplicação, baseada em microsevice.
• Customização, padrões e extensão e conceitos fundamentais e
de performasse do Java.
14/07/2018

Sobre Palestrante
• Apaixonado em Maneiras e Formas Ágeis de Criar Código
Fonte.
• Sempre programando com um Bom Café e Escutando um Belo
e Pesado Rock`n Roll... Trabalha há mais de 10 Anos com JAVA
e LINUX, passando por ANDROID, PYTHON, PHP, ANGULAR E
NODE.JS.
• É Professor Universitário e ministra as disciplinas: Redes de
Computadores; Java e Dispositivos Móveis. Jugleader e Co-
Fundador do UAIJUG (Grupo de Usuários do Triângulo
Mineiro) e do TRIÂNGULO HACKERSPACE.
• Hoje na Equipe e dos projetos do PPE’s na ALGAR TECH.
14/07/2018

Microservices
14/07/2018
https://martinfowler.com/articles/microservices.html

Microservices
• O que é arquitetura de micro serviço?
Para entendermos a arquitetura de micro serviços, precisamos
saber que não há uma definição formal ao termo micro
serviços. Não temos um modelo padrão que representado, que
podemos usar em nossos sistemas de micro serviços com base
nesse estilo arquitetural.
14/07/2018

Microservices
• Para arquitetura micro serviços, podemos seguir algumas
características comuns, que são compartilhadas para micro
serviços.
14/07/2018

Microservices
• Uma arquitetura de micro serviços é composta por uma
coleção de serviços pequenos e autónomos. Cada serviço
deve ter uma regra de negocio única, facilitando
escalabilidade, e gerência desse serviço.
14/07/2018

Microservices
• Mas não é uma bala de prata.
14/07/2018

Microservices
Prós Contras
Melhor para gerenciar Complexidade
Stack de tecnologia, mais flexível Fontes de dados diferentes
Custo reduzido de falha Autenticação
Mais especializado Logs descentralizados
Divisão dos times API Gateway Bottleneck
Escalabilidade Seletiva Transações Distribuídas
Velocidade de desenvolvimento
Liberdade de escolha de tecnologias
14/07/2018

Microservices
14/07/2018
• O paradigma de Micro serviços está na moda mas temos que
parar para pensar nos prós e contras.
• Não há nada de errado com aplicações monolíticas, tudo
depende do seu contexto. É necessário avaliar esse contexto.
• Como em qualquer decisão de uso de alguma tecnologia, a
pergunta que você tem que fazer é: Qual problema eu quero
resolver com micro serviços? E quais problemas eu vou
introduzir com eles? É importante ter uma regra de negócio
separa? Vale a pena?

Microservices
14/07/2018
• Se sua empresa não tem uma cultura forte de DevOps,
esqueça Micro serviços. Micro Serviços, é fortemente acoplado
a cultura DevOps. Ou seja, testes automatizados, deploy
continuo entre outros conceitos.
“Primeiro fortaleça essa cultura e somente quando estiverem
muito bons nisso comecem a pensar nesse paradigma.”
• Deploy vai ser peça primordial no sucesso ou no fracasso de
um sistema baseado em micro serviços.

Microservices
14/07/2018
• Os benefícios normalmente superam as desvantagens de
aplicativos grandes e complexos. Mais sempre em mente,
melhoria continua:
“Crie e entregue um software melhor mais rápido, baseado em
arquitetura emergente.”

Microservices
14/07/2018
• Aprofundando mais:
• Monoliths and Conway’s Law
• Microservices: Avoiding the Monoliths
• Service Objects and Identifying Data
• Coordination and Dumb Pipes
• User creates a manual invoice
• User finishes a job, creating an invoice
• SOA vs. Microservices
• The Future of Microservice Architecture

Arquitetura emergente
14/07/2018

Spring boot?
• Spring boot é uma grande “sacada” da equipe da Spring
Source. Essa sacada foi focar em minimizar o tempo de criação
e configuração de um projeto novo. Como isso o
desenvolvedor terá tempo de criar aplicação melhores,
focando em desenvolvever a sua regra de negócio.
Spring boot
14/07/2018

Spring boot?
• Baseado na arquitetura de Microservices, com ele é possível
criar facilmente aplicações completas com o mínimo de
esforço pois sua filosofia baseada em convenções elimina a
necessidade da maior parte das configurações.
Spring boot
14/07/2018

Spring boot?Spring boot
• Um ponto único de configuração, ao contrario de ter várias coleções de
configuração como spring-*.
• Uma ferramenta para começar muito rapidamente com o Spring
• Requisitos não-funcionais comuns para uma aplicação "real”
• Expõe um monte de recursos úteis por padrão
• É bem simpls com spring boot, se você alterar os padrões adotados.
14/07/2018

O que é RestFUL?
• Representation State Transfer (REST) é um estilo arquitetural,
quando dados e funcionalidades são acessado por URIs.
• REST não tem regras rígidas e consume é rápido
• REST é um estilo arquitetônico, não um padrão
• REST usa cabeçalhos para descrever os pedidos e respostas
• REST abraça os verbos HTTP (DRY)
14/07/2018

O que é RestFUL?
• Serviços Web RESTful são construídos para funcionar com os
protocolos HTTP (GET, PUT, DELETE, POST).
• É um protocolo de comunicação cacheado, Stateles, client-
side, como HTTP.
• É simples, leve e rápido.
14/07/2018

Sobre Resources
• Dados e funcionalidade são considerados Resources e
acessados usando URIs.
• Resources são manipulados usando as operações: [POST, PUT,
GET, DELETE].
• Recursos são separados de suas representações, de modo que
o seu conteúdo pode ser acessado em uma variedade de
formatos como HTML, JSON,Text, XML.
• Toda interação com os Resources são Stateless.
• Estado pode ser incorporado em mensagens de resposta para
apontar para futuros estados válidos da interação[1] [200,
201, 404, 500].
14/07/2018

Níveis de Maturidade
http://martinfowler.com/articles/richardsonMaturityModel.html
14/07/2018

Maturidade de Richardson
• O modelo de maturidade de Richardson é um caminho para
definir o nível de maturidade de uma API REST.
• Nível 0 - Uma única URI e um único HTTP method.
• Nível 1 – Diversas URI e um único HTTP method.
• Nível 2 – Diversas URI e diversos HTTP methods.
• Nível 3 - HATEOAS. Fornece links de hipermidia para
direcionar os usuário clientes.
14/07/2018

Os principios do REST
• Ser cliente-servidor – Deve sempre haver um cliente que
realiza as requisições e um servidor que as responde;
14/07/2018

• Sem estado – As requisições feitas pelo cliente devem conter
todas as informações necessárias para que o servidor consiga
processar o pedido. Ou seja, o servidor não tem seu estado
alterado e não trata requisições semelhantes de formas
diferentes devido a isso. Note que os recursos que o servidor
provê podem ser alterados, e que isso é completamente
diferente do estado da aplicação;
14/07/2018

• Cache – As respostas às requisições feitas pelo cliente podem
ser marcadas como “cacheáveis” ou “não-cacheáveis” pelo
servidor, indicando se podem ou não ser armazenadas em
cache pelo cliente;
14/07/2018

• Interface uniforme – Um dos pontos centrais do REST é a
ênfase na interface uniforme entre os componentes da
arquitetura. As informações devem ser transferidas de forma
padronizada. Este pré-requisito define outros quatro pré-
requisitos de interface:
• Identificação dos recursos – Cada recurso deve possuir um
identificador universal (URI – Universal Resource Identifier);
14/07/2018

Interface uniforme …
• Representação de recursos – Os recursos são manipulados a
partir de suas representações, que podem ser em diversos
formatos, como XML, JSON, TEXT, etc. Um detalhe importante
que uma aplicação REST não transmite o recurso
efetivamente, mas sempre uma representação do mesmo, em
um formato pré-acordado entre o cliente e o servidor;
• Mensagem auto descritivas – Os pedidos e respostas devem
conter meta-dados que indicam como o conteúdo transmitido
deve ser tratado (cabeçalhos para formato, autenticação, etc.);
14/07/2018

• Utilização de hipermídia para estado da aplicação – Este pré-
requisito é o menos cumprido por aplicações autointituladas
RESTful: As representações de recursos obtidas em uma
aplicação REST devem possuir hiperlinks que permitam a
navegação do cliente pelos recursos. Ou seja, diferentemente
de arquiteturas baseadas em RPC (Remote Procedure Call), o
cliente não deve conhecer previamente as URIs para os
recursos da aplicação (apenas a raiz do serviço), sendo que o
servidor deve prover links que permita a descoberta dos
recursos pelo cliente; não há contrato do serviço e não há
garantia que um recurso em uma determinada URI possa estar
disponível no futuro;
14/07/2018

• Sistema em camadas – A aplicação deve ser construída em
camadas sendo que uma camada só pode ver a camada
imediatamente abaixo. O objetivo principal deste pré-requisito é
garantir que as aplicações sejam escaláveis;
• Executar código sob demanda – O cliente deve ser capaz de
executar scripts armazenados no servidor de forma a estender as
funcionalidades do cliente. Um exemplo disso é a habilidade dos
browsers HTTP executarem JavaScripts. Este é o único pré-
requisito opcional para arquiteturas REST.
14/07/2018

Itentificação de Resources
• A sintaxe URI pode ser simplificada através do esquema:
{esquema}://{autoridade}{caminho}?{query}#{fragmento}
• Esquema: “HTTP”, “FTP”, “mailto”, “URN”, “tel”, “rtsp”, “file”
• Autoridade: www.app.com
• Caminho: /users
• Query: ?fields=_id,content
• Fragmento: #titleContent
14/07/2018

Interface uniforme
• Princípios Flexívies “No Hard and Fast Rules”
• Identificação dos Recursos
• Manipulação de Recursos
• Auto-descrição de Mensagens
• Hypermedia é o motor de estado da Aplicação.
14/07/2018

Formatos de mídia:
• Quando falamos de HTTP os tipos de conteúdo comumente
suportados são os definidos pela IANA. Esses contratos são
negociados da seguinte maneira:
• Accept: application/xml, application/json – Cliente declara
formatos aceitos de resposta
Content-Type: application/json – Servidor indica formato da
resposta
14/07/2018

Métodos:
• Como já é de se esperar o protocolo mais comum usado em
arquiteturas REST é o HTTP que define 6 métodos-base em
sua versão 1.1:
• GET
• POST
• PUT
• DELETE
• OPTIONS
• HEAD
14/07/2018

Respostas de métodos:
• Categorias:
• 1xx: informational
• 2xx: success
• 3xx: redirection
• 4xx: client error
• 5xx: server error
• "HTTP response codes for dummies. 50x: we fucked up. 40x:
you fucked up. 30x: ask that dude over there. 20x: cool."
@DanaDanger.
14/07/2018

Verbos
• GET - Recuperar Informação.
• Devem ser seguros e idempotente, ou seja, sempre tem o
mesmo valor mesmo ser chamado várias vezes.
• GET /users
14/07/2018

Verbos
• POST - Solicitar que um recurso seja criado.
• A maior diferenca entre POST e PUT é a identidicação na URI
• POST /users
14/07/2018

Verbos
• PUT - Solicitar que um recurso seja alterado.
• PUT /users/1/role/2
• {"status":"SELECTED"}
14/07/2018

Verbos
• DELETE - Solicitar que um recurso seja removido.
• DELEE /users/1
14/07/2018

Anotações Rest
• @Path - Um URI relativo indica onde a classe Java será
hospedada.
• @[GET/PUT/POST/DELETE] - rá processar solicitações HTTP
requests
• @[PathParam/QueryParam] - para extrair os parâmetros
• @[Consumes/Produtos] - espeficica MIME types
14/07/2018

Suporte MINEs types
• @Consumes – Específica a lista de media types que podem ser
consumidos.
• @Produces - Específica a lista de media types que podem ser
produzidos.
• Media-Types:
• application/xml
• application/json
• text/plain
• text/html
14/07/2018

Exemplo:
@Path("/users/{username}")
public class UserResource {
@GET
@Produces("text/html")
public String getUser(@PathParam("username") String
username) {
..........
}
}
14/07/2018

Spring boot start
• https://start.spring.io/
14/07/2018

Instalação
• Java (>=1.6) + (for Java projects) Maven 3 or gradle >=1.6
• Download:
http://repo.spring.io/milestone/org/springframework/boot/sp
ring-boot-cli/0.5.0.M6/spring-boot-cli-0.5.0.M6-bin.zip
• Descompactar e procurar o diretorio: bin/
• $ spring --help ...
14/07/2018

Iniciando super rápido
• @RestController
• class Example {
• @RequestMapping("/")
• public String hello() {
• return "Hello World!";
• }
}
• $ mvn spring-boot:run
• ... application is running at http://localhost:8080
14/07/2018

O Que aconteceu?
• // import org.springframework.web.bind.annotation.RestController
// other imports ... //
• //@Grab("org.springframework.boot:spring-boot-web-
starter:0.5.0")
• // @EnableAutoConfiguration
• @RestController
• class Example {
• }
• }
14/07/2018

O Que aconteceu?
• // import org.springframework.web.bind.annotation.RestController
// other imports ...
• // @Grab("org.springframework.boot:spring-boot-web-
starter:0.5.0")
• // @EnableAutoConfiguration
• @RestController
• class Example {
• }
• // public static void main(String[] args) {
• // SpringApplication.run(Example.class, args);
• //
• }
• }
14/07/2018

Spring boot em Java
• import org.springframework.boot.SpringApplication;
• import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
• import org.springframework.context.annotation.*;
• @RestController
• @EnableAutoConfiguration
• public class MyApplication {
• public static void main(String[] args) {
• SpringApplication.run(MyApplication.class, args);
• }
• }
14/07/2018

Iniciando os POMs
• O Spring boot usa o conceito de POMs padrões do que é mais
usado no Spring.
• <dependency>
• <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
• </dependency>
• Esse resume tudo que é necessário para iniciar uma aplicação
web, Spring MVC.
14/07/2018

Iniciando os POMs
• Spring 4.0 – Sem Spring boot
• 
• <dependency>
• <groupId>org.springframework</groupId>
• <artifactId>spring-core</artifactId>
• <version>${spring.version}</version>
• </dependency>
• <dependency>
• <artifactId>spring-web</artifactId> <version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
14/07/2018

Iniciando os POMs
• Essa opção está disponível para web, batch, integration, data,
amqp, aop, jdbc, ...
• e.g. data = hibernate + spring-data + JSR 303
14/07/2018

SpringApplication
• SpringApplication app = new SpringApplication(MyApplication.class);
• app.setShowBanner(false);
• app.run(args);
• Essa opção roda a apllicação com Spring ApplicationContext.
• Use EmbeddedWebApplicationContext para aplicações web,
que vai gerar um ambiente embarcado.
• Podemos rodar por uma unica linha, com o comando:
• SpringApplication.run(MyApplication.class, args)
• Ou pode ser customizado (veremos mais tarde)
14/07/2018

@EnableAutoConfiguration
• Anotar uma classe com @Configuration indica que essa classe pode ser
usada pelo Spring como fonte de definições de beans.
• @Configuration
• @EnableAutoConfiguration
• public class MyApplication {
• }
• Podemos usar @ConditionalOnClass e @ConditionalOnMissingBean,
não veremos nesse artigo.
14/07/2018

@Configuration
• DispatcherConfig.java
• @Configuration
• @Import(WebAppConfig.class)
• public class DispatcherConfig {
• @Bean
• public ViewResolver viewResolver() {
• InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
• viewResolver.setPrefix("/WEB-INF/jsp/");
• viewResolver.setSuffix(".jsp"); return viewResolver;
• }
• }
14/07/2018

Empacotando para produção
• Maven plugin (using spring-boot-starter-parent):
• <plugin>
• <groupId>org.springframework.boot</groupId>
• <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
$ mvn package
• Gradle plugin:
• apply plugin: 'spring-boot'
• $ gradle repackage
14/07/2018

Empacotando para produção
• $ java -jar yourapp.jar
• O Spring boot gera um simples jar para rodar a aplicação
então basta rodar com um comando simple de jar do java, que
a aplicação já estará sobrando, ou seja, não precisa
descompactar ou criar scripts como sh ou python para rodar
essa aplicação. Aplicação gerada é leve e eficiente, pacote com
menos de 10Mb.
14/07/2018

Módulos do Spring Boot
• Spring Boot – Biblioteca principal que suporta outras partes do
Spring.
• Spring Boot Autoconfigure - @EnableAutoConfiguration
annotation, cria um conjunto de contexto do Spring.
• Spring Boot Starters - Um conjunto de dependency descriptors
que você pode incluir em sua aplicação.
• Spring Boot CLI – Compila sua aplicação Spring usando groovy
e rodando-a no terminal.
14/07/2018

• Spring Boot Actuator[11] - Actuator habilita os recurso
production-ready, para uma aplicação de inicialização Spring -
sem ter de aplicar na prática estas coisas sozinho.
• Eles são usados principalmente para expor diferentes tipos de
informações sobre o aplicativo em execução - saúde, métricas,
info, despejo, env etc. E enquanto estes são nenhum
substituto para uma solução de monitoramento de nível de
produção - elas são um bom ponto de partida.
14/07/2018

• Spring Boot Tools - Usado para construir um container
proprios para arquivos jars e WARs
• Spring Boot Samples - Uma ampla gama de aplicativos de
exemplo para seguir e usar.
14/07/2018

Relações entre módulos
14/07/2018

Não é uma aplicação web?
• CommandLineRunner
• é um gancho para executar código específico do aplicativo
depois que o contexto é criado.
• @Component public class Startup implements CommandLineRunner {
• @Override
• public void run(String... args) throws Exception {
• System.out.println("Hello World");
• }
}
14/07/2018

SpringApplicationBuilder
• Estilo flexivel para construir API fluente para construção de
uma Aplicação Spring com requisitos mais complexos.
• new SpringApplicationBuilder(ParentConfiguration.class)
• .profiles("adminServer”,"single")
• .child(AdminServerApplication.class) .run(args);
14/07/2018

Ambiente e Perfis
• Todo ApplicationContext tem um Ambiente (Environment)
• Spring Environment existe desde a versão 3.1
• Abstracção por pares de chave / valor de múltiplas fontes
• Usado para gerenciar trocas de @Profile.
• Always available: System properties and OS ENV vars
• Sempre disponível: Propriedades do sistema e OS ENV vars.
14/07/2018

Command Line Arguments
• SpringApplication acrescenta argumentos de linha de
comando para o Ambiente do Spring para que possa consultá-
los e injetar os beans:
• @Value("${name}")
• private String name;
• $ java -jar yourapp.jar --name=Dave
• Você também pode configurar muitos aspectos do Spring
Boot:
• $ java -jar target/*.jar --server.port=9000
14/07/2018

Propriedades
• Basta colocar o arquivo application.properties no seu
classpath ou no mesmo diretorio do seu jar.
• Arquivo /src/main/resource/application.properties
• server.port: 9000 # conteúdo de exemplo.
• Properties pode ser subistituídas (command line
arg > file > classpath)
14/07/2018

Use YAML
• É uma forma de você definir uma ou mais ambientes
• Inclu-a snake-yaml.jar e o arquivo application.yml em seu
classpath
• /src/main/resources/application.yml
• server: port: 9000
• Podemos definir mais de um ambiente no YAML, se
necessário.
14/07/2018

Binding Configurationpara Beans
• MyProperties.java
• @ConfigurationProperties(prefix="mine")
• public class MyPoperties {
• private Resource location;
• private boolean skip = true;
• // ... getters and setters
• }
• application.properties:
• mine.location: classpath:mine.xml
• mine.skip: false
14/07/2018

DataBinding
para @ConfigurationProperties
• Spring DataBinder faz a coerção e a conversão quando possível.
• Custom ConversionService adicionalmente descobre o nome do
bean (igual a ApplicationContext)
• Ditto for validation
• configurationPropertiesValidator bean, se ele estiver presente.
• JSR303, se ele estiver presente.
• ignoreUnkownFields=true (default)
• ignoreInvalidFields=false (default)
•
• Usa uma RelaxedDataBinder que aceita variaveis comuns para
nomes de propriedades
(e.g. CAPITALIZED, camelCased orwith_underscores)
• Também faz bind para o SpringApplication
14/07/2018

Customizandoconfiguraçãolocal
• Set
• spring.config.name - default application, por ser separado por
virgula a lista de nomve
• spring.config.location - a Resource path, substitui o nome
• .
• $ java -jar target/*.jar --spring.config.name=production
14/07/2018

Spring Profiles
• ….
• Activate external configuration with a Spring profile
• file name convention e.g. application-development.properties
• or nested documents in YAML:
• application.yml
• defaults: etc... --- spring: profiles: development,postgresql
other: stuff: more stuff...
• Set o perfil default do spring em uma configuração externa:
• application.properties
• spring.profiles.active: default, postgresql
14/07/2018

Logging
• Spring Boot providencia uma configuração default usando a
commons logging frameworks: logback, log4j e
java.util.logging
• Starters (e Samples) usam logback com cores para output do
log.
• Configuração externa e classpath influiencia o comportamento
do runtime
• LoggingApplicationContextInitializer, configura a dependência
do framework de logging que ele encontra no classpath e no
Ambiente (Environment).
14/07/2018

Adicionandocomportamentoao
Autoconfigured
• <dependency>
• <artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
</dependency>
• Add o JDBC.
• Add um banco em memoria (hsqldb).
• Add connection pool ao Tomcat.
14/07/2018

Adding Static Resources
• Facilidade: use classpath:/static/**
• Muitas alternativas:
• classpath:/public/**
• classpath:/resources/**
• classpath:/META-INF/resources/**
• Normal servlet context / (root of WAR file, será visto depois)
• i.e. src/main/webapp se criado com Maven ou Gradle
• static/**
• public/**
• set documentRoot in EmbeddedServletContextFactory (será visto
depois)
• Tratamento especial para o index.html (em qualquer um dos locais
acima)
14/07/2018

Adicino UI comThymeleaf
• Adicione Thymeleaf no seu classpath para redenrizar a view.
• Spring Boot Autoconfigure adiciona configurações padrões.
• Configurações padrões via spring.thymeleaf.*, e.g.
• spring.thymeleaf.prefix:classpath:/templates/ (location of
templates)
• spring.thymeleaf.cache:true (seta para false pra atualizar
templates quando mudados)
• Para extender e substituir, apenas adicione os beans:
• Thymeleaf IDialect
• thymeleafViewResolver
• SpringTemplateEngine
• defaultTemplateResolver
14/07/2018

Comportamento do
Autoconfigured
• Embedded servlet container (Tomcat or Jetty)
• JDBC: DataSource and JdbcTemplate
• JPA, JMS, AMQP (Rabbit), AOP
• Websocket
• Spring Data JPA (scan for repositories) e Mongodb
• Thymeleaf
• Mobile
• Batch processing
• Reactor for events and async processing
• Actuator features (Security, Audit, Metrics, Trace)
14/07/2018

Actuator
• Adiciona requisitos não funcionais para aplicação e expoem
endpoints MVC para interações Security
• Secure
endpoints: /metrics, /health, /trace, /dump, /shutdown, /bean
s, /env
• /info
• Audit
• Se a aplicação for embarcada use a mesma porta diferente
(management.port) e direfentes interfaces de rede
(management.address) e caminho do contexto
(management.context_path).
14/07/2018

Adicione um servidor SSH
• Use o Actuator.
• Adicione spring-boot-starter-shell-remote no classpath.
• A aplicação é exposta na porta 2000 de SSH por default.
14/07/2018

Criando seu WAR
• Spring boot usa por padrao o resultado da aplicação em um
jar, mas se quisermos podemos reda-lo com WAR para
colocara em nossos servidores. Para isso podemos
usar SpringBootServletInitializer em vez do nosso
“famoso” SpringApplication.
14/07/2018

CustomizandoBusiness Content
• Relembre, spring boot é Spring. 
• Adicione definições de@Bean
• Use @Autowired, @Value e @ComponentScan
• Groovy CLI auto-imports common DI annotations
• Mesmo se você usar XML se você gosta.
14/07/2018

CustomizandoApplicationContext
• Diretamente SpringApplication instance (spring.main.*)
• Adicione configuração externa (System properties, OS env
vars, config file, command line arguments)
• Adicione implementações SpringApplicationInitializer e
habilite dentro de META-INF/spring.factories
14/07/2018

CustomizandoApplicationContext
• Desabilite feature específica:
• @EnableAutoConfiguration(disable={WebMvcAutoConfigurati
on.class})
• Escreva seu próprio...
• Add JAR com META-INF/spring.factories entrada
para EnableAutoConfiguration
• Todas as entradas do classpath aleradas e adicionadas para o
context
14/07/2018

Customizando o CLI
• Use standard Java META-INF/services scanning
• CompilerAutoConfiguration: adicione dependencias e imports
• CommandFactory: adicione comandos via a
custom CommandFactory in META-INF/services
• E.g. pode-se adicionar script commands (written in Groovy)
• $ spring foo ...
• Exemplo:
• Para foo.groovy in ${SPRING_HOME}/bin and ${SPRING_HOM
E}/ext por default.
14/07/2018

Customizando Container de
propriedades
• Algumas features comuns são exportas com configuração
externa, exemplo:
server.port (ServerProperties bean) Adicionento um bean de
tipo EmbeddedServletContainerCustomizer - todas as
instancias pega o callback.
• Adiciona bean de
tippo EmbeddedServletContainerFactory (subistitue uma
auto-configução)
14/07/2018

Spring Boot Loader
• Motivação: Existe soluções para executar JAR que não são
robustas; WAR executável é muito difícil de criar.
• Resposta: JarLauncher e WarLauncher comspecialized ClassLo
ader e JarFile implementations que pode encontrar resources
dentro dos JARs (e.g. lib/*.jar or WEB-INF/lib/*.jar)
14/07/2018

Spring Test (and MVC)
• SpringApplication é um criador de ApplicationContext
opinativo, mas a maior parte do comportamento é
encapsulado em implementações
inApplicationContextInitializer. Para reproduzir o
comportamento do seu aplicativo em, por exemplo, em um
teste de integração é útil para duplicar esses recursos, para
que você possa usar os initializers correspondentes. Você
pode usar contexto correspondentes fornecido pelo Spring
Boot.
14/07/2018

Spring Test (and MVC)
• Exemplo com configuração externa:
• @RunWith(SpringJUnit4ClassRunner.class)
• @ContextConfiguration(classes = IntegrationTestsConfiguration.class, loader =
SpringApplicationContextLoader.class)
• public class IntegrationTests {
• // Normal Spring Test stuff
• }
• dica: use spring-boot-starter-test no pom do maven.
14/07/2018

Referências
[1] - http://www.restapitutorial.com/httpstatuscodes.html
[3] - http://pt.slideshare.net/evandrovenancio35/hateoas-arquitetura-rest-
100-aderente.
[4] - http://pages.apigee.com/rs/apigee/images/api-design-ebook-2012-03.pdf
[5] - https://pt.wikipedia.org/wiki/REST
[6] - http://sao-paulo.pm.org/pub/arquitetura-rest-e-o-servico-web-restful-
[7] - http://www.infoq.com/br/articles/rest-introduction
[8] - https://andrebires.wordpress.com/2012/08/14/rest-e-apis-hipermidia/
[9] - http://www.mobiliza.com.br/the-rest-of-us-parte-2/
[10] - http://www.infoq.com/br/news/2013/05/idempotent
[11] - http://www.baeldung.com/spring-boot-actuators
14/07/2018

Uaijug ADF - spring boot - microservice - Introdução

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Uaijug ADF - spring boot - microservice - Introdução

Semelhante a Uaijug ADF - spring boot - microservice - Introdução (20)

Mais de Rogerio Fontes

Mais de Rogerio Fontes (6)

Uaijug ADF - spring boot - microservice - Introdução