Framework Spring

Basis Tecnologia da Informação S.A. - 2019

Agenda

Histórico e Filosofia
O Container Spring
Configuração Java
Programação Orientada a Aspecto
Design Patterns (GoF, …)
Spring Utils

Histórico da Framework

2002: Publicação do livro One-To-One J2EE Design and Development de Rod Johnson, com esboço de uma framework
2003: Lançamento em OpenSource, Publicação da Versão 0.9
2004: Publicação da Versão 1.0. Lançamento do livro Expert One-To-One J2EE Development Without EJB

Histórico da Framework

Histórico de Releases:

1.0.0 - 24/03/2004
2.0.0 - 03/10/2006
3.0.0 - 16/12/2009
4.0.0 - 12/12/2013
5.0.0 - 28/09/2017

Filosofia

Integra com alguns elementos do padrão J2EE, como:

Servlet API (JSR 340)
WebSocket API (JSR 356)
Dependency Injection (JSR 330)
Common Annotations (JSR 250)
Bean Validation (JSR 303)
JPA (JSR 338)
JMS (JSR 914)

Filosofia

Modularidade
Adiar decisões de design o mais tarde possível
API bem desenhada e código limpo
Simplificar os testes
Desacoplar ao máximo o código de negócio da Framework

Programação Orientada a Aspectos Spring AOP

Introdução
Conceitos
Aplicação

Spring AOP - Introdução

A programação orientada a aspectos complementa a programação orientada a objetos adicionando uma nova forma de pensar na estrutura do programa. Através dela é possível separar funções que são de interesse de vários tipos de objetos da lógica de negócio.

Spring AOP - Conceitos

Aspect

Representa a modularização de um interesse comum de várias classes. É a unidade básica da AOP. Um aspecto representa a junção de advices e pointcuts. Através dele sabemos o que deve ser feito, onde e quando.

Spring AOP - Conceitos

Advice

Representa a ação a ser tomada por um aspect. Um advice define o que deve ser feito e quando deve ser feito. São implementados como interceptadores.

Spring AOP - Conceitos

Advice

Ações (trechos de código)
Tipos
- Before advice, After returning advice, After throwing advice, After advice, Around advice

Spring AOP - Conceitos

Pointcut

Define onde o aspecto deve ser aplicado. Uma definição de pointcut coincide com um ou mais join points onde um advice deve ser aplicado.

Spring AOP - Conceitos

Join point

É um ponto na execução do programa onde um aspecto pode ser plugado, por exemplo a execução de um método, o lançamento de uma exceção ou a alteração de um campo. É o ponto de junção do aspecto com o objeto alvo. Onde os aspectos alteram o fluxo normal de execução do código.

Spring AOP - Conceitos

Target object

Um objeto alvo de um ou mais advices. Como o spring AOP é implementado usando proxies de tempo de execução, os objetos alterados sempre são “proxiados”.

Spring AOP - Conceitos

Weaving

Processo de aplicar os aspectos em um target object para criar um novo objeto proxy. Pode acontecer em tempo de compilação, em tempo de classloading ou em tempo de execução. O spring faz o weaving em tempo de execução.

Spring AOP - Aplicação

Interceptação de métodos (Spring AOP)
Proxy objects
Suporta AspectJ (Habilita todo o suporte a AOP)
Exemplos de aplicação:
- Gerenciamento transacional
- Auditoria
- Segurança
- …

Container Spring - DI

Injeção de dependências

Processo pelo qual os objetos definem suas dependências somente através de argumentos de construtor, argumentos em um método de factory ou propriedades que são atribuídas depois que esses objetos são construídos.

Container Spring - Core

Core e Beans

Injeção de Dependências/Inversão de Controle
BeanFactory
ApplicationContext, WebApplicationContext, …

Container Spring - Context

Context

Tem por base Core e Beans
Acesso aos objetos da Framework
Integrações com:
- Funcionalidades de JavaEE como EJB e JMX
- Bibliotecas terceiras: Quartz/CommonJ, EHCache/JCache

Container Spring - Escopo

Define:

O ciclo de vida de um bean
A visibilidade

Container Spring - Escopo

Genérico:

Singleton (Default) - Uma instância por container
Prototype - Uma nova instância quando requerido

Container Spring - Escopo

Aplicações Web

Request - Uma instância por requisição HTTP
Session - Uma instância por sessão HTTP
Application - Uma instância por ServletContext

Container Spring - Environment

Interface Environment
@PropertySource
PropertySourcesPlaceholderConfigurer
@Value

Container Spring - EL

Expression Language (SpEL)

Pesquisa e manipulação dos grafos de objetos em tempo de execução
Acesso aos Objetos do Container de IoC
Inicialização e recuperação de propriedades
Execução de cálculos aritméticos

Configuração do Container

O Container é configurado a partir de metadados
Existem várias maneiras de representar esses metadados:
- Arquivos XML de configuração
- Anotações Java (Spring 2.5)
- Configuração Java (Spring 3.0)

Exemplo de configuração XML

[source, xml]
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="ola" class="treinamento.spring.corecontainer.bean.Ola">
        <constructor-arg name="mensagem" value="XML" ></constructor-arg>
    </bean>
</beans>

Anotações Java

@ComponentScan e context:component-scan
@Component
Meta anotações, exemplo: @Service, @Repository

Configuração Java

Anotação @Configuration para marcar as classes instanciando Beans
Anotação @Bean para marcar os métodos que criam os Beans
Anotação @Scope para definir o escopos

Configuração Java - Exemplo

@Configuration (1)
public class CicloDeVidaConfiguracao {

    @Bean (2)
    public ScopeSingleton scopeSingleton(){
        return new ScopeSingleton();
    }
}

1	Marcação da classe para o ApplicationContext
2	Método que cria uma instância de Bean

Spring Utils

Bibliotecas de uso geral
A maioria no Spring Core
Algumas classes utilitárias específicas em Spring AOP, Spring MVC, …

StringUtils

package org.springframework.util.StringUtils;

@Test
public void testStringUtils() {
    assertThat(StringUtils.hasText("    ")).isFalse();
    assertThat(StringUtils.hasText(" a ")).isTrue();
    assertThat(StringUtils.capitalize("hello world")).isEqualTo("Hello world");
    assertThat(StringUtils.trimAllWhitespace(" hello  world ")).isEqualTo("helloworld");
    assertThat(StringUtils.unqualify("test.hello")).isEqualTo("hello");
}

CollectionUtils

package org.springframework.util.CollectionUtils;

@Test
public void testCollectionUtils() {
    assertThat(CollectionUtils.isEmpty((Map<?, ?>) null)).isTrue();
    MultiValueMap<String, String> mv = new LinkedMultiValueMap<>();
    mv.add("a", "b");
    mv.add("a", "c");
    assertThat(CollectionUtils.contains(mv.get("a").iterator(), "b")).isTrue();
    assertThat(CollectionUtils.contains(mv.get("a").iterator(), "c")).isTrue();
}

Base64Utils e DigestUtils

package org.springframework.util.Base64Utils; package org.springframework.util.DigestUtils;

@Test
public void testHashUtils() {
    byte[] bytes = "Hello World".getBytes();
    assertThat(DigestUtils.md5DigestAsHex(bytes)).isEqualTo("b10a8db164e0754105b7a99be72e3fe5");
    assertThat(Base64Utils.encodeToString(bytes)).isEqualTo("SGVsbG8gV29ybGQ=");
}

FileCopyUtils

package org.springframework.util.FileCopyUtils;

@Test
public void testCopy() throws IOException {
    assertThat(FileCopyUtils.copy(
        new File(SystemPropertyUtils.resolvePlaceholders("${user.home}"), "/dummy.txt"),
        File.createTempFile("tmp", "")))
            .isEqualTo(6);
}