Migrando do Spring para o Spring Boot

1. Visão geral

Neste artigo, vamos dar uma olhada em como podemos migrar um aplicativo Spring Framework existente para um aplicativoSpring Boot.

Spring Boot is not intended to replace Spring, but to make working with it faster and easier. Como resultado, a maioria das mudanças necessárias para migrar um aplicativo estão relacionadas à configuração. Na maior parte, nossos controladores personalizados e outros componentes permanecerão os mesmos.

O desenvolvimento comSpring Boot traz várias vantagens:

gerenciamento de dependência mais simples
configuração automática padrão
servidor da web incorporado
métricas de aplicativos e verificações de integridade
configuração externalizada avançada

**2. Spring Boot iniciantes**

Primeiro, precisamos de um novo conjunto de dependências. Spring Boot provides convenient starter dependencies, which are dependency descriptors que pode trazer toda a tecnologia necessária para determinada funcionalidade.

Eles têm a vantagem de que você não precisa mais especificar uma versão para cada dependência; em vez disso, deixe o iniciador gerenciar dependências para você.

A maneira mais rápida de começar é adicionandospring-boot-starter-parentpom.xml:


    org.springframework.boot
    spring-boot-starter-parent
    1.5.6.RELEASE

Isso cuidará do gerenciamento de dependências.

Passaremos por mais alguns iniciadores nas próximas seções, dependendo de qual funcionalidade iremos migrar. Para referência, você pode encontrar a lista completa dehere iniciais.

Como uma observação mais geral, queremos remover qualquer versão de dependência definida explicitamente que também seja gerenciada porSpring Boot. Caso contrário, podemos encontrar incompatibilidades entre nossas versões definidas e aquelas usadas pelo Boot.

3. Ponto de entrada do aplicativo

Cada aplicativo construído usandoSpring Boot precisa definir o ponto de entrada principal. Geralmente é uma classe Java com o métodomain, anotado com@SpringBootApplication:

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

A anotação@SpringBootApplication adiciona as seguintes anotações:

@Configuration - que marca a classe como uma fonte de definições de feijão
@EnableAutoConfiguration - que diz ao framework para adicionar beans com base nas dependências do classpath automaticamente
@ComponentScan - que verifica outras configurações e beans no mesmo pacote da classeApplication ou abaixo

By default, the @SpringBootApplication annotation scans all classes in the same package or below. Portanto, uma estrutura de pacote conveniente poderia ser assim:

Se o seu aplicativo for um aplicativo não web que cria umApplicationContext, este código pode ser removido e substituído pela classe@SpringBootApplication acima.

Um problema que podemos encontrar possui várias classes de configuração que entram em conflito. Para evitar isso, temos a possibilidade de filtrar as classes que são verificadas:

@SpringBootAppliaction
@ComponentScan(excludeFilters = {
  @ComponentScan.Filter(type = FilterType.REGEX,
  pattern = "com.example.config.*")})
public class Application {
    //...
}

4. Importar configuração e componentes

Spring Boot depende muito de anotações para configuração, mas você ainda pode importar sua configuração existente em formato de anotação e XML.

Para que suas@Configuration ou classes de componentes existentes sejam selecionadas, você tem duas opções:

mova as classes existentes para um pacote que seja o mesmo ou abaixo do pacote de classeApplication principal
importar explicitamente as classes

To import the classes explicitly, you can use the @ComponentScan or @Import annotations na classe principal:

@SpringBootApplication
@ComponentScan(basePackages="com.example.config")
@Import(UserRepository.class)
public class Application {
    //...
}

A documentação oficial recomenda o uso de anotações na configuração XML. No entanto, se você já tem arquivos XML que não deseja converter para a configuração Java, ainda pode importá-los usando@ImportResource:

@SpringBootApplication
@ImportResource("applicationContext.xml")
public class Application {
    //...
}

5. Migrar recursos de aplicativos

Por padrão,Spring Boot procura por arquivos de recursos em um dos seguintes locais:

/Recursos
/público
/estático
/META-INF/resources

Para migrar, podemos mover todos os nossos arquivos de recursos para um desses locais ou podemos personalizar os locais dos recursos definindo a propriedadespring.resources.static-locations:

spring.resources.static-locations=classpath:/images/,classpath:/jsp/

6. Migrar propriedades do aplicativo

O framework irá carregar automaticamente quaisquer propriedades definidas em arquivos chamadosapplication.properties ouapplication.yml colocados em um destes locais:

um subdiretório/config do diretório atual
o diretório atual
um diretório/config no classpath
a raiz do caminho de classe

Para evitar carregar propriedades explicitamente, podemos movê-las para um arquivo com esse nome em um desses locais. Por exemplo, na pasta/resources que deve estar presente no caminho de classe.

Também podemos carregar automaticamente as propriedades específicas do perfil de arquivos chamadosapplication-{profile}.properties.

Além disso, um grande número depredefined property names está disponível para configurar diferentes comportamentos do aplicativo.

Cada módulo da estrutura Spring usado em seu aplicativo exigirá pequenas modificações, principalmente relacionadas à configuração. Vamos dar uma olhada em algumas das funcionalidades mais comumente usadas.

7. Migrar um aplicativo Spring Web

7.1. Web Starter

Spring Boot fornece um iniciador para aplicativos da web que trará todas as dependências necessárias. Isso significa que podemos remover todas as dependências específicas da web do framework Spring e substituí-las porspring-boot-starter-web:


    org.springframework.boot
    spring-boot-starter-web

Visto queSpring Boot tenta configurar automaticamente um aplicativo sempre que possível com base no caminho de classe, adicionar esta dependência resultará em ter a anotação@EnableWebMvc adicionada à classeApplication principal, bem como configurar um feijãoDispatcherServlet.

Se você tinha uma classeWebApplicationInitializer que configuraDispatcherServlet, isso não é mais necessário, nem a anotação@EnableWebMvc.

É claro que podemos definir nossos beans se quisermos um comportamento personalizado e, nesse caso, nossos beans serão usados.

Se usarmos explicitamente a anotação@EnableWebMvc em uma classe@Configuration, a configuração automática do MVC não será mais habilitada.

A adição do iniciador da web também determina a configuração automática dos seguintes beans:

suporte para servir conteúdo estático de um diretório chamado/static,/public,/resources ou/META-INF/resources no classpath
BeansHttpMessageConverter para casos de uso comuns, como JSON e XML
um mapeamento/error que lida com todos os erros

7.2. Ver tecnologias

No que diz respeito à criação de páginas da web, a documentação oficial recomenda não usar arquivos JSP e usar um mecanismo de modelo. A configuração automática está incluída para os seguintes mecanismos de modelo:Thymeleaf,Groovy,FreeMarker,Mustache. Tudo o que precisamos fazer para usar um deles é adicionar o iniciador específico:


    org.springframework.boot
    spring-boot-starter-thymeleaf

Os arquivos de modelo devem ser colocados na pasta/resources/templates.

Se queremos continuar usando os arquivos JSP, precisamos configurar o aplicativo para que ele possa resolver os JSPs. Por exemplo, se nossos arquivos estão em/webapp/WEB-INF/views, precisamos definir as seguintes propriedades:

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

7.3. Servidor da Web incorporado

Além disso, também podemos executar nosso aplicativo usando um servidor Tomcat integrado, que será configurado automaticamente na porta 8080 adicionando a dependênciaspring-boot-starter-tomcat:


    org.springframework.boot
    spring-boot-starter-tomcat

Outros servidores da web para os quaisSpring Boot fornece configuração automática sãoJettyeUndertow.

8. Migrar um aplicativo Spring Security

O iniciador para ativar o Spring Security éspring-boot-starter-security:


    org.springframework.boot
    spring-boot-starter-security

Por padrão, isso criará um usuário chamado "usuário" com uma senha gerada aleatoriamente registrada durante a inicialização e protegerá todos os terminais com autenticação básica. No entanto, geralmente queremos adicionar nossa configuração de segurança, que é diferente do padrão.

Por esse motivo, manteremos nossa classe existente anotada com@EnableWebSecurity que estendeWebSecurityConfigurerAdaptere define uma configuração personalizada:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // ...
}

9. Migrar um aplicativo Spring Data

Dependendo de qual implementaçãoSpring Data estamos usando, precisaremos adicionar o iniciador correspondente. Por exemplo, para JPA, podemos adicionar a dependênciaspring-boot-starter-data-jpa:


    org.springframework.boot
    spring-boot-starter-data-jpa

Se quisermos usar um banco de dados na memória, adicionar a configuração automática habilitada para dependência correspondente para bancos de dados do tipoH2,Derby eHSQLDB.

Por exemplo, para trabalhar com um banco de dados na memóriaH2, tudo o que precisamos é a dependênciah2:


    com.h2database
    h2

Se quisermos trabalhar com um tipo e configuração de banco de dados diferente, como um banco de dadosMySQL, precisamos da dependência e também de definir uma configuração.

Para isso, podemos manter nossa definição de beanDataSource ou fazer uso de propriedades predefinidas:

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/myDb?createDatabaseIfNotExist=true
spring.datasource.username=user
spring.datasource.password=pass

Spring Boot irá configurar automaticamenteHibernate como o provedor JPA padrão, bem como um beantransactionManager.

10. Conclusão

Neste artigo, mostramos alguns cenários comuns encontrados ao migrar um aplicativo Spring existente para a estruturaSpring Boot mais recente.

No geral, sua experiência ao migrar dependerá, é claro, da alta dependência do aplicativo que você criou.

TOC

Migrando do Spring para o Spring Boot