Use o código e tenha 10% de desconto!

Vire o jogo com Spring Framework

Henrique Lobo Weissmann
Capa

Spring Framework

Prefácio

Neste livro trataremos do Spring, um framework usado no desenvolvimento de aplicações corporativas baseado nos conceitos de inversão de controle, injeção de dependências e AOP. São palavras que muitas vezes soam alienígenas e não adquirem significado na mente do desenvolvedor. Este livro possui dois objetivos: clarificar o significado por trás destes conceitos e expor como sua aplicação acaba por gerar sistemas de qualidade superior, mais fáceis de manter e que, com isto, acabam por aumentar o valor agregado do nosso trabalho.

Mais que um framework para desenvolvimento de aplicações corporativas, vejo o Spring como uma ferramenta disciplinadora. Conforme o desenvolvedor vai se habituando ao seu modo de trabalho começa a valorizar ainda mais qualidades como uma melhor modularização do sistema, escrita de código mais simples, reaproveitamento de código legado e tecnologias já existentes, além da criação de interfaces mais significativas. No Spring podemos ver de forma nítida o núcleo da arquitetura de sistemas que é justamente o modo como componentes de software interagem entre si de uma maneira explícita. Para os que anseiam trilhar este caminho, é também um auxílio em sua formação.

O livro é dividido em duas partes. Na primeira tratamos dos conceitos em que se baseia o Spring. Veremos o que motivou sua criação, o que o framework trouxe de ganho para o desenvolvimento de aplicações corporativas e como são aplicados no núcleo do Spring que é seu container de inversão de controle/injeção de dependências. Com isto, é fornecida ao leitor uma base sólida que pode ser aplicada tanto dentro quanto fora do contexto do Spring.

Na segunda parte temos uma abordagem mais mão na massa. Veremos aplicações do framework em situações reais do dia a dia, como por exemplo na camada de persistência, controle transacional, segurança e também criaremos uma aplicação web real baseada no Spring MVC. A grosso modo, pode-se dizer que quando escrevi a primeira parte do livro incluí o conteúdo que gostaria muito de ter aprendido na faculdade, enquanto na segunda estão as informações que teriam me poupado muito tempo no meu cotidiano como desenvolvedor.

 

A quem se destina

 

Este livro se destina a todos aqueles que já possuem algum conhecimento da plataforma Java, que já terão uma bagagem mais rica para entender o que tento explicar neste texto. Caso não seja o seu caso, tudo bem: os três primeiros capítulos contém o conceitual que você poderá aplicar em práticamente qualquer plataforma.

 

Agradecimentos

 

Agradeço à confiança e ao apoio (isto sem mencionar a paciência!) dos meus editores Paulo Silveira e Adriano Almeida sem os quais este livro não seria possível. Claro que eles não agiram sozinhos, Nanna – minha esposa – é fundamental por ter conseguido me aguentar neste processo de tradução do Springolês para o Português. Também preciso agradecer aos meus colegas, em especial ao Matheus Eduardo Moreira e o Felipe Zampa.

Os leitores tiveram participação extremamente importante: após o lançamento da versão beta fiquei maravilhado com a quantidade de pessoas interessadas neste material, o que me motivou a concluí-lo mais rápido e com a melhor qualidade possível. Alguns entraram em contato direto comigo com dicas e sugestões, e a estes ofereço meu agradecimento especial: Renan Reis, Rodrigo Monteiro, Adriano Faria Alves e Willardy Tyrone de Oliveira. E ei, também não posso deixar de agradecer ao apoio do Rodrigo Fernandes Moreira e Gabriela Corrêa da Eteg. Finalmente, para evitar que eu sofra consequências imprevisíveis, à minha mãe, Selma Weissmann. Infelizmente o espaço deste prefácio é limitado para conter todas as pessoas a quem devo agradecer, assim como minha memória. Caso seu nome me tenha escapado, por favor desculpe este mal agradecido: com certeza encontrarei alguma forma de retribuí-lo no futuro ok?

Muito obrigado a todos vocês.

Sumário

  • 1 - Lide com o alto acoplamento de forma elegante
    • 1.1 - Problema essencial: acoplamento
    • 1.2 - A famigerada inversão
  • 2 - Conheça o Spring Framework
    • 2.1 - Por que criaram o Spring?
    • 2.2 - O Mundo dos objetos em 2004
    • 2.3 - Os problemas do EJB em 2004
    • 2.4 - Alternativas começam a surgir: IoC/DI e AOP
    • 2.5 - Container: o sujeito que torna tudo isto possível
    • 2.6 - Do início ao fim de um objeto, entenda o ciclo de vida
    • 2.7 - Spring em partes
    • 2.8 - O Container
    • 2.9 - Trabalhando com AOP e Aspects
    • 2.10 - Instrumentação de código
    • 2.11 - Acesso a dados e integração
    • 2.12 - Aplicações na Web com o Spring
    • 2.13 - E ainda mais componentes!
    • 2.14 - Resumindo
  • 3 - Conhecendo o Container
    • 3.1 - Preparando seu ambiente de desenvolvimento
    • 3.2 - Nosso sistema de exemplo
    • 3.3 - Declarando beans
    • 3.4 - Instanciação por factory method
    • 3.5 - Mapeando atributos complexos
    • 3.6 - Usando o container
    • 3.7 - O ciclo de vida do container
    • 3.8 - Escopos
    • 3.9 - Instanciação tardia
    • 3.10 - Aproveitando o ciclo de vida dos beans
    • 3.11 - Quando o bean conhece seu container
    • 3.12 - Modularizando a configuração
    • 3.13 - Aplicando herança na definição dos beans
    • 3.14 - Spring Expression Language (SpEL)
    • 3.15 - Resumindo
  • 4 - Minimizando o XML com autowiring, anotações e Java
    • 4.1 - Autowiring: automatizando a injeção de dependências
    • 4.2 - Vantagens e limitações da injeção automática
    • 4.3 - Facilitando ainda mais com Anotações
    • 4.4 - Configuração programática com Java
    • 4.5 - XML, anotações ou configuração programática?
  • 5 - AOP: adicionando novos comportamentos aos beans
    • 5.1 - Como identificar os interesses transversais
    • 5.2 - Entendendo AOP
    • 5.3 - Preparando o ambiente de desenvolvimento
    • 5.4 - A implementação do primeiro aspecto
    • 5.5 - Entenda os advices
    • 5.6 - Use os around advices
    • 5.7 - Use o advice before
    • 5.8 - E onde entra o Proxy nessa história?
    • 5.9 - Entenda a execução
    • 5.10 - Um uso interessante para AOP: Log de erros
    • 5.11 - Declare aspectos com anotações AspectJ e esquemas XML
    • 5.12 - A sintaxe AspectJ de declaração de point cuts
    • 5.13 - Concluindo com um resumão conceitual
  • 6 - Colocando a mão na massa
    • 6.1 - Obtendo o código fonte
    • 6.2 - Configure seu ambiente de desenvolvimento
    • 6.3 - O que vem por ai
  • 7 - Acesso a dados
    • 7.1 - DAO: no centro da mentalidade Spring
    • 7.2 - Conecte-se ao banco de dados
    • 7.3 - De volta ao DAO: o problema com as exceções
    • 7.4 - Templates: acabe com o código repetido
    • 7.5 - O trabalho com JDBC
    • 7.6 - O trabalho com o Hibernate
    • 7.7 - Integre com a JPA
    • 7.8 - Concluindo
  • 8 - Desenvolva aplicações web com Spring MVC
    • 8.1 - O que iremos desenvolver
    • 8.2 - A base para tudo: MVC
    • 8.3 - Iniciando o Projeto
    • 8.4 - Dispatcher Servlet: o maestro por trás do Spring MVC
    • 8.5 - Olá mundo com Spring MVC
    • 8.6 - O primeiro controlador útil do Spring Fórum
    • 8.7 - Autenticando usuários: como redirecionar e lidar com a sessão HTTP
    • 8.8 - Definindo qual método HTTP usar
    • 8.9 - Recebendo parâmetros de entrada
    • 8.10 - O que é aquele "redirect:/" retornado pela action login?
    • 8.11 - Como lidar com a sessão do usuário e a classe ModelAndView
    • 8.12 - Cadastrando usuários: submissão de formulários
    • 8.13 - Submetendo o formulário de cadastro
    • 8.14 - Melhorando a camada de visualização com o Tiles
    • 8.15 - Lidando com conteúdo estático
    • 8.16 - Ainda há mais de SpringMVC por vir
  • 9 - Ações recorrentes com o SpringMVC
    • 9.1 - Faça a validação de formulários com o Hibernate Validator
    • 9.2 - Envie seus avatares para o servidor com upload de arquivos
    • 9.3 - Defina o corpo da resposta
    • 9.4 - Faça requisições assíncronas com AJAX
    • 9.5 - Concluindo com uma surpresa
  • 10 - Gerenciando transações
    • 10.1 - Entendendo as transações
    • 10.2 - As políticas transacionais
    • 10.3 - Preparando o ambiente de desenvolvimento
    • 10.4 - Como o Spring implementa o suporte a transações
    • 10.5 - Transações programáticas
    • 10.6 - Declarando transações
    • 10.7 - Concluindo
  • 11 - Protegendo nossa aplicação com Spring Security
    • 11.1 - Entendendo autenticação e autorização
    • 11.2 - Os módulos do Spring Security
    • 11.3 - Configurando os filtros de acesso
    • 11.4 - Configurando o contexto do Spring
    • 11.5 - O formulário de login
    • 11.6 - Escrevendo um provedor de autenticação
    • 11.7 - Usando SpEL
    • 11.8 - Protegendo invocação de métodos em beans
    • 11.9 - Tags
    • 11.10 - Conclusão
  • 12 - E ai, gostou?

    Dados do produto

    Número de páginas:
    296
    ISBN:
    978-85-66250-09-1
    Data publicação:
    05/2012

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter