Spring é uma estrutura de desenvolvimento de software livre para Java empresarial. Os principais recursos do Spring Framework podem ser usados ​​no desenvolvimento de qualquer aplicativo Java, mas existem extensões para a construção de aplicativos da web na plataforma Java EE. O Spring framework visa tornar o desenvolvimento J2EE mais fácil de usar e promover boas práticas de programação, permitindo um modelo de programação baseado em POJO.

A seguir está uma lista de alguns dos grandes benefícios de usar o Spring Framework:

• Lightweight- A mola é leve quando se trata de tamanho e transparência. A versão básica do Spring Framework tem cerca de 2 MB.

• Inversion of control (IOC)- O acoplamento frouxo é obtido na mola usando a técnica de Inversão de Controle. Os objetos fornecem suas dependências em vez de criar ou procurar objetos dependentes.

• Aspect oriented (AOP) - Spring suporta programação orientada a Aspect e permite desenvolvimento coeso separando a lógica de negócios do aplicativo dos serviços do sistema.

• Container - Spring contém e gerencia o ciclo de vida e configuração de objetos de aplicativos.

• MVC Framework - A estrutura da web do Spring é uma estrutura MVC da web bem projetada, que fornece uma ótima alternativa para estruturas da web, como Struts ou outras estruturas da web com engenharia excessiva ou menos populares.

• Transaction Management - O Spring fornece uma interface de gerenciamento de transações consistente que pode ser reduzida para uma transação local (usando um único banco de dados, por exemplo) e expandida para transações globais (usando JTA, por exemplo).

• Exception Handling - O Spring fornece uma API conveniente para converter exceções específicas de tecnologia (lançadas por JDBC, Hibernate ou JDO, por exemplo) em exceções consistentes e não verificadas.

A seguir estão os módulos do framework Spring:

• Módulo principal
• Módulo de feijão
• Módulo de contexto
• Módulo Expression Language
• Módulo JDBC
• Módulo ORM
• Módulo OXM
• Módulo Java Messaging Service (JMS)
• Módulo de transação
• Módulo web
• Módulo Web-Servlet
• Módulo Web-Struts
• Módulo Web-Portlet

O arquivo de configuração do Spring é um arquivo XML. Este arquivo contém as informações das classes e descreve como essas classes são configuradas e apresentadas umas às outras.

Inversão de controle (IoC) é um conceito geral e pode ser expresso de muitas maneiras diferentes e a injeção de dependência é apenas um exemplo concreto de inversão de controle.

Este conceito diz que você não cria seus objetos, mas descreve como eles devem ser criados. Você não conecta diretamente seus componentes e serviços no código, mas descreve quais serviços são necessários para quais componentes em um arquivo de configuração. Um contêiner (o contêiner IOC) é então responsável por conectar tudo.

Tipos de IoC são -

• Constructor-based dependency injection - A DI baseada em construtor é realizada quando o contêiner invoca um construtor de classe com vários argumentos, cada um representando uma dependência de outra classe.

• Setter-based dependency injection - A DI baseada em setter é realizada pelo contêiner chamando métodos setter em seus beans após invocar um construtor sem argumento ou método de fábrica estático sem argumento para instanciar seu bean.

Visto que você pode misturar ambos, DI baseado em construtor e setter, é uma boa regra usar argumentos de construtor para dependências obrigatórias e setters para dependências opcionais. Observe que o uso de uma anotação @Required em um configurador pode ser usado para tornar os configuradores dependências obrigatórias.

Os principais benefícios do IOC ou injeção de dependência são -

• Ele minimiza a quantidade de código em seu aplicativo.

• Isso torna seu aplicativo fácil de testar, pois não requer singletons ou mecanismos de pesquisa JNDI em seus casos de teste de unidade.

• O acoplamento fraco é promovido com esforço mínimo e mecanismo menos intrusivo.

• Os contêineres IOC oferecem suporte à instanciação rápida e carregamento lento de serviços.

A programação orientada a aspectos, ou AOP, é uma técnica de programação que permite aos programadores modularizar questões transversais ou comportamento que atravessa as divisões típicas de responsabilidade, como registro e gerenciamento de transações. A construção central do AOP é o aspecto, que encapsula comportamentos que afetam várias classes em módulos reutilizáveis.

O Spring IoC cria os objetos, conecta-os, configura-os e gerencia seu ciclo de vida completo, desde a criação até a destruição. O contêiner Spring usa injeção de dependência (DI) para gerenciar os componentes que constituem um aplicativo.

Existem dois tipos de contêineres IoC -

• Bean Factory container - Este é o contêiner mais simples que fornece suporte básico para DI. A BeanFactory é geralmente preferida onde os recursos são limitados, como dispositivos móveis ou aplicativos baseados em applet

• Spring ApplicationContext Container - Este contêiner adiciona mais funcionalidades específicas da empresa, como a capacidade de resolver mensagens textuais de um arquivo de propriedades e a capacidade de publicar eventos de aplicativo para ouvintes de eventos interessados.

A implementação BeanFactory mais comumente usada é a XmlBeanFactoryclasse. Este contêiner lê os metadados de configuração de um arquivo XML e os usa para criar um sistema ou aplicativo totalmente configurado.

As três implementações comumente usadas de 'Contexto do Aplicativo' são -

• FileSystemXmlApplicationContext- Este contêiner carrega as definições dos beans de um arquivo XML. Aqui você precisa fornecer o caminho completo do arquivo de configuração do bean XML para o construtor.

• ClassPathXmlApplicationContext- Este contêiner carrega as definições dos beans de um arquivo XML. Aqui, você não precisa fornecer o caminho completo do arquivo XML, mas precisa definir CLASSPATH corretamente porque esse contêiner parecerá com o arquivo XML de configuração de bean em CLASSPATH.

• WebXmlApplicationContext - Este contêiner carrega o arquivo XML com definições de todos os beans de um aplicativo da web.

A seguir estão algumas das diferenças -

• Os contextos de aplicativo fornecem um meio para resolver mensagens de texto, incluindo suporte para i18n dessas mensagens.

• Os contextos de aplicativo fornecem uma maneira genérica de carregar recursos de arquivo, como imagens.

• Os contextos do aplicativo podem publicar eventos em beans que são registrados como ouvintes.

• Certas operações no contêiner ou beans no contêiner, que devem ser tratadas de maneira programática com uma fábrica de bean, podem ser tratadas declarativamente em um contexto de aplicativo.

• O contexto do aplicativo implementa MessageSource, uma interface usada para obter mensagens localizadas, com a implementação real sendo conectável.

Os objetos que formam o backbone de seu aplicativo e que são gerenciados pelo contêiner Spring IoC são chamados de beans. Um bean é um objeto instanciado, montado e gerenciado de outra forma por um contêiner Spring IoC. Esses beans são criados com os metadados de configuração que você fornece ao contêiner, por exemplo, na forma de definições XML <bean />.

A definição do bean contém as informações chamadas metadados de configuração que são necessários para o contêiner saber o seguinte -

• Como criar um bean
• Detalhes do ciclo de vida do Bean
• Dependências de feijão

Seguem três métodos importantes para fornecer metadados de configuração para o Spring Container -

• Arquivo de configuração baseado em XML.
• Configuração baseada em anotação
• Configuração baseada em Java

Verifique o seguinte exemplo -

<?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 = "helloWorld" class = "com.tutorialspoint.HelloWorld">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Ao definir um <bean> no Spring, você tem a opção de declarar um escopo para aquele bean. Por exemplo, para forçar o Spring a produzir uma nova instância de bean cada vez que uma for necessária, você deve declarar o atributo de escopo do bean comoprototype. De maneira semelhante, se você deseja que o Spring retorne a mesma instância de bean cada vez que uma for necessária, você deve declarar o atributo de escopo do bean singleton.

O Spring Framework suporta os cinco escopos a seguir, três dos quais estão disponíveis apenas se você usar um ApplicationContext compatível com a web.

• singleton - Isso define o escopo da definição do bean para uma única instância por contêiner Spring IoC.

• prototype - Isso define o escopo de uma única definição de bean para ter qualquer número de instâncias de objeto.

• request- Isso define o escopo de uma definição de bean para uma solicitação HTTP. Válido apenas no contexto de um Spring ApplicationContext ciente da web.

• session- Isso define o escopo de uma definição de bean para uma sessão HTTP. Válido apenas no contexto de um Spring ApplicationContext ciente da web.

• global-session- Isso define o escopo de uma definição de bean para uma sessão HTTP global. Válido apenas no contexto de um Spring ApplicationContext ciente da web.

O escopo padrão do bean é Singleton for Spring framework.

Não, os beans singleton não são seguros para thread no framework Spring.

A seguir está a sequência do ciclo de vida de um bean no Spring -

• Instantiate - Primeiro, o container spring encontra a definição do bean no arquivo XML e instancia o bean.

• Populate properties - Usando a injeção de dependência, o spring preenche todas as propriedades conforme especificado na definição do bean.

• Set Bean Name - Se o bean implementa a interface BeanNameAware, o spring passa o id do bean para o método setBeanName ().

• Set Bean factory - Se o Bean implementa a interface BeanFactoryAware, o spring passa o beanfactory para o método setBeanFactory ().

• Pre Initialization- Também chamado de pós-processo de bean. Se houver qualquer bean BeanPostProcessors associado ao bean, Spring chama o método postProcesserBeforeInitialization ().

• Initialize beans- Se o bean implementa IntializingBean, seu método afterPropertySet () é chamado. Se o bean tiver declaração de método init, o método de inicialização especificado é chamado.

• Post Initialization - Se houver qualquer BeanPostProcessors associado ao bean, seus métodos postProcessAfterInitialization () serão chamados.

• Ready to use - Agora o bean está pronto para ser usado pelo aplicativo.

• Destroy - Se o bean implementar DisposableBean, ele chamará o método destroy ().

Um elemento <bean /> dentro dos elementos <property /> ou <constructor-arg /> define um chamado bean interno. Uma definição de bean interno não requer um id ou nome definido; o contêiner ignora esses valores. Ele também ignora o sinalizador de escopo. Os beans internos são sempre anônimos e sempre têm como escopo protótipos.

Spring oferece quatro tipos de elementos de configuração de coleção que são os seguintes -

• <list> - Isso ajuda na fiação, ou seja, injetando uma lista de valores, permitindo duplicatas.

• <set> - Isso ajuda a conectar um conjunto de valores, mas sem duplicatas.

• <map> - Isso pode ser usado para injetar uma coleção de pares nome-valor em que nome e valor podem ser de qualquer tipo.

• <props> - Isso pode ser usado para injetar uma coleção de pares nome-valor onde o nome e o valor são ambos Strings.

O contêiner Spring é capaz de autowire relacionamentos entre beans colaborativos. Isso significa que é possível permitir que o Spring resolva automaticamente os colaboradores (outros beans) para seu bean inspecionando o conteúdo da BeanFactory sem usar os elementos <constructor-arg> e <property>.

A funcionalidade de autowiring tem cinco modos que podem ser usados ​​para instruir o Spring container a usar autowiring para injeção de dependência -

• no- Esta é a configuração padrão, o que significa nenhum autowiring e você deve usar uma referência explícita de bean para a fiação. Você não tem nada a fazer de especial para esta fiação. Isso é o que você já viu no capítulo Injeção de Dependências.

• byName- Autowiring por nome de propriedade. O Spring container examina as propriedades dos beans nos quais o atributo autowire está definido como byName no arquivo de configuração XML. Em seguida, ele tenta combinar e conectar suas propriedades aos beans definidos pelos mesmos nomes no arquivo de configuração.

• byType- Autowiring por tipo de dados de propriedade. O contêiner Spring examina as propriedades dos beans nos quais o atributo autowire está definido como byType no arquivo de configuração XML. Em seguida, ele tenta corresponder e conectar uma propriedade se seu tipo corresponder exatamente a um dos nomes de beans no arquivo de configuração. Se mais de um desses beans existir, uma exceção fatal será lançada.

• constructor- Semelhante a byType, mas o tipo se aplica a argumentos do construtor. Se não houver exatamente um bean do tipo de argumento do construtor no contêiner, um erro fatal será gerado.

• autodetect - O Spring primeiro tenta conectar usando autowire pelo construtor, se não funcionar, Spring tenta fazer o autowire por byType.

As limitações do autowiring são -

• Overriding possibility - Você ainda pode especificar dependências usando as configurações <constructor-arg> e <property> que sempre substituirão a autowiring.

• Primitive data types - Você não pode autowire as chamadas propriedades simples, como primitivas, Strings e Classes.

• Confusing nature - A fiação automática é menos exata do que a fiação explícita, portanto, se possível, prefira usar fiação explícita.

Sim.

Uma alternativa às configurações XML é fornecida pela configuração baseada em anotação, que conta com os metadados do bytecode para conectar componentes em vez de declarações de colchetes angulares. Em vez de usar XML para descrever uma fiação de bean, o desenvolvedor move a configuração para a própria classe do componente usando anotações na classe, método ou declaração de campo relevante.

A fiação de anotação não é ativada no contêiner Spring por padrão. Portanto, antes de usarmos a fiação baseada em anotação, precisaremos habilitá-la em nosso arquivo de configuração Spring configurando <context: annotation-config />.

Essa anotação indica simplesmente que a propriedade do bean afetada deve ser preenchida no momento da configuração, por meio de um valor de propriedade explícito em uma definição de bean ou por meio de autowiring. O contêiner lança BeanInitializationException se a propriedade de bean afetada não foi preenchida.

Essa anotação fornece um controle mais refinado sobre onde e como a fiação automática deve ser realizada. A anotação @Autowired pode ser usada para autowire bean no método setter, assim como a anotação @Required, construtor, uma propriedade ou métodos com nomes arbitrários e / ou vários argumentos.

Pode haver uma situação quando você cria mais de um bean do mesmo tipo e deseja conectar apenas um deles com uma propriedade, neste caso você pode usar a anotação @Qualifier junto com @Autowired para remover a confusão especificando qual bean exato será conectado.

Spring tem anotações baseadas em JSR-250 que incluem anotações @PostConstruct, @PreDestroy e @Resource.

• @PostConstruct - Esta anotação pode ser usada como uma alternativa ao retorno de chamada de inicialização.

• @PreDestroy - Essa anotação pode ser usada como uma alternativa de retorno de chamada de destruição.

• @Resource - Esta anotação pode ser usada em campos ou métodos de setter. A anotação @Resource recebe um atributo 'nome' que será interpretado como o nome do bean a ser injetado. Você pode dizer que segue a semântica de autowiring por nome.

A opção de configuração baseada em Java permite que você escreva a maior parte de sua configuração Spring sem XML, mas com a ajuda de algumas anotações baseadas em Java.

Por exemplo: Anotação @Configurationindica que a classe pode ser usada pelo contêiner Spring IoC como uma fonte de definições de bean. o@Bean a anotação diz ao Spring que um método anotado com @Bean retornará um objeto que deve ser registrado como um bean no contexto do aplicativo Spring.

Manipulação no evento ApplicationContext é fornecido através do ApplicationEvent classe e ApplicationListener interface. Portanto, se um bean implementa o ApplicationListener , toda vez que um ApplicationEvent é publicado no ApplicationContext, esse bean é notificado.

Spring fornece os seguintes eventos padrão -

• ContextRefreshedEvent- Este evento é publicado quando o ApplicationContext é inicializado ou atualizado. Isso também pode ser gerado usando o método refresh () na interface ConfigurableApplicationContext.

• ContextStartedEvent- Este evento é publicado quando o ApplicationContext é iniciado usando o método start () na interface ConfigurableApplicationContext. Você pode pesquisar seu banco de dados ou reiniciar qualquer aplicativo interrompido após receber este evento.

• ContextStoppedEvent- Este evento é publicado quando o ApplicationContext é interrompido usando o método stop () na interface ConfigurableApplicationContext. Você pode fazer o trabalho de limpeza necessário após receber este evento.

• ContextClosedEvent- Este evento é publicado quando o ApplicationContext é fechado usando o método close () na interface ConfigurableApplicationContext. Um contexto fechado chega ao fim de sua vida; ele não pode ser atualizado ou reiniciado.

• RequestHandledEvent - Este é um evento específico da web que informa a todos os beans que uma solicitação HTTP foi atendida.

Um módulo que possui um conjunto de APIs que fornecem requisitos transversais. Por exemplo, um módulo de registro seria chamado de aspecto AOP para registro. Um aplicativo pode ter vários aspectos, dependendo do requisito. No Spring AOP, os aspectos são implementados usando classes regulares (a abordagem baseada em esquema) ou classes regulares anotadas com a anotação @Aspect (estilo @AspectJ).

Concern- A preocupação é o comportamento que queremos ter em um módulo de um aplicativo. A preocupação pode ser definida como uma funcionalidade que desejamos implementar. As questões nas quais estamos interessados ​​definem nossas preocupações.

Cross-cutting concern- É uma preocupação que se aplica a todo o aplicativo e afeta todo o aplicativo. por exemplo, registro, segurança e transferência de dados são as preocupações necessárias em quase todos os módulos de um aplicativo, portanto, são questões transversais.

Isso representa um ponto em seu aplicativo onde você pode inserir o aspecto AOP. Você também pode dizer que é o lugar real no aplicativo onde uma ação será realizada usando a estrutura Spring AOP.

Esta é a ação real a ser realizada antes ou depois da execução do método. Este é o trecho real do código que é invocado durante a execução do programa pelo framework Spring AOP.

Este é um conjunto de um ou mais pontos de junção onde um conselho deve ser executado. Você pode especificar pontos de corte usando expressões ou padrões, como veremos em nossos exemplos de AOP.

Uma introdução permite adicionar novos métodos ou atributos às classes existentes.

Sendo o objeto avisado por um ou mais aspectos, este objeto será sempre um objeto proxy. Também conhecido como objeto aconselhado.

Tecelagem é o processo de vincular aspectos a outros tipos de aplicativos ou objetos para criar um objeto recomendado.

A tecelagem pode ser feita em tempo de compilação, tempo de carregamento ou tempo de execução.

Os aspectos da mola podem funcionar com cinco tipos de conselhos mencionados abaixo -

• before - Execute o conselho antes da execução do método.

• after - Execute o conselho após a execução de um método, independentemente de seu resultado.

• after-returning - Execute o conselho após a execução do método a apenas se o método for concluído com êxito.

• after-throwing - Execute o conselho após a execução de um método apenas se o método for encerrado lançando uma exceção.

• around - Execute o conselho antes e depois de invocar o método recomendado.

Aspectos são implementados usando classes regulares junto com configuração baseada em XML.

@AspectJ refere-se a um estilo de declaração de aspectos como classes Java regulares anotadas com anotações Java 5.

O JDBC pode ser usado de forma mais eficiente com a ajuda de uma classe de modelo fornecida pelo spring framework chamada JdbcTemplate.

Com o uso da estrutura Spring JDBC, a carga de gerenciamento de recursos e tratamento de erros é muito reduzida. Portanto, resta aos desenvolvedores escrever as instruções e consultas para obter os dados de e para o banco de dados. JdbcTemplate fornece muitos métodos convenientes para fazer coisas como converter dados de banco de dados em primitivos ou objetos, executar instruções preparadas e chamáveis ​​e fornecer tratamento de erros de banco de dados personalizado.

Spring suporta dois tipos de gerenciamento de transações -

• Programmatic transaction management- Isso significa que você gerenciou a transação com a ajuda da programação. Isso proporciona extrema flexibilidade, mas é difícil de manter.

• Declarative transaction management- Isso significa que você separa o gerenciamento de transações do código de negócios. Você só usa anotações ou configuração baseada em XML para gerenciar as transações.

O gerenciamento de transações declarativas é preferível ao gerenciamento de transações programáticas, embora seja menos flexível do que o gerenciamento de transações programáticas, que permite controlar as transações por meio de seu código.

A estrutura MVC da web Spring fornece arquitetura de controlador de visualização de modelo e componentes prontos que podem ser usados ​​para desenvolver aplicativos da web flexíveis e fracamente acoplados. O padrão MVC resulta na separação dos diferentes aspectos do aplicativo (lógica de entrada, lógica de negócios e lógica de IU), enquanto fornece um acoplamento fraco entre esses elementos.

A estrutura Spring Web MVC é projetada em torno de um DispatcherServlet que trata todas as solicitações e respostas HTTP.

O WebApplicationContext é uma extensão do ApplicationContext simples que possui alguns recursos extras necessários para aplicativos da web. Ele difere de um ApplicationContext normal porque é capaz de resolver temas e sabe a qual servlet está associado.

A seguir estão algumas das vantagens do Spring MVC sobre Struts MVC -

• O MVC do Spring é muito versátil e flexível baseado em interfaces, mas Struts força Actions e Form objeto em herança concreta.

• O Spring fornece interceptores e controladores, portanto, ajuda a fatorar o comportamento comum para o tratamento de muitas solicitações.

• O Spring pode ser configurado com diferentes tecnologias de visualização como Freemarker, JSP, Tiles, Velocity, XLST etc. e você também pode criar seu próprio mecanismo de visualização customizado implementando a interface Spring View.

• No Spring MVC, os controladores podem ser configurados usando DI (IOC) que facilita o seu teste e integração.

• A camada da Web do Spring MVC é fácil de testar do que a camada da Web do Struts, por causa da prevenção de herança concreta forçada e dependência explícita de controladores no servlet do despachante.

• Struts força seus controladores a estender uma classe Struts, mas o Spring não, há muitas implementações de controladores convenientes que você pode escolher estender.

• No Struts, as ações são acopladas à visualização, definindo ActionForwards dentro de um ActionMapping ou globalmente. SpringMVC possui interface HandlerMapping para suportar esta funcionalidade.

• Com o Struts, a validação geralmente é realizada (implementada) no método de validação de um ActionForm. No SpringMVC, os validadores são objetos de negócios que NÃO dependem da API Servlet, o que faz com que esses validadores sejam reutilizados em sua lógica de negócios antes de persistir um objeto de domínio em um banco de dados.

Os controladores fornecem acesso ao comportamento do aplicativo que você normalmente define por meio de uma interface de serviço. Os controladores interpretam a entrada do usuário e a transformam em um modelo que é representado para o usuário pela visualização. O Spring implementa um controlador de uma maneira muito abstrata, o que permite criar uma ampla variedade de controladores.

A anotação @Controller indica que uma classe particular tem o papel de controlador. O Spring não requer que você estenda nenhuma classe base do controlador ou faça referência à API Servlet.

A anotação @RequestMapping é usada para mapear um URL para uma classe inteira ou um método de tratamento específico.

Existem duas maneiras de acessar o modo de hibernação usando a mola -

• Inversão de controle com um modelo de Hibernate e retorno de chamada.

• Estendendo HibernateDAOSupport e aplicando um nó AOP Interceptor.

Spring suporta os seguintes ORMs -

• Hibernate
• iBatis
• JPA (Java Persistence API)
• TopLink
• JDO (Java Data Objects)
• OJB