Boa tarde
Eu me propus a meta de aprender o framework Spring para a linguagem Java. Durante o estudo, decidi verificar por mim mesmo o algoritmo de aprendizado de Richard Feynman: organizar-simplificar-treinar outro. Em geral, comecei a gravar uma série de lições curtas para iniciantes sobre o trabalho na primavera. Para quem quer repetir, eu expus o
código fonte .
Lição 01. Compreendendo a IoC
Então, vamos reunir poetas, deixá-los compor e ler seus poemas.
Primeiro, declare uma interface que gere os versos
src \ main \ java \ spring \ interfaces \ Lyricist.java:package spring.intarfaces; public interface Lyricist { public String Generate(); }
Implementamos essa interface na
classe src \ main \ java \ spring \ impls \ Mayakovsky.java :
package spring.impls; import spring.intarfaces.Lyricist; public class Mayakovsky implements Lyricist { @Override public String Generate() { return " \r\n" + " \r\n" + " \r\n" + " ?"; } }
Escreveremos que criaremos um objeto Mayakovsky específico no arquivo de configuração xml
src \ main \ resources \ ApplicationContext.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="LyricistBean1" class="spring.impls.Mayakovsky"/> </beans>
Identificação associada LyricistBean1 com o nome da classe Mayakovsky. Quase tudo está pronto, apenas a classe de chamada
src \ main \ java \ spring \ main \ Start.java está ausente :
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml"); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
Na classe Start, lemos nosso arquivo de configuração, criamos uma instância do poeta chamado bean LyricistBean1. Consegui uma cópia do poeta Mayakovsky. A função Generate () nos retornou seqüências imortais:
E você
jogo noturno
poderia
em uma flauta de cano?
Lição 02. Selecionando uma Instância para Criar Através do Arquivo de Configuração
Digamos que um amigo nos ajudou e forneceu outra implementação de nossa
interface Lyricist
src \ main \ java \ spring \ impls \ Poushkin.java :
package spring.impls; import spring.intarfaces.Lyricist; public class Poushkin implements Lyricist { @Override public String Generate() { return " :\r\n" + " ,\r\n" + " ,\r\n" + " ."; } }
No arquivo de configuração ApplicationContext.xml, altere Mayakovsky para Poushkin.
Execute o programa.
Obtemos um resultado completamente diferente
sem reconstruir :
Eu lembro de um momento maravilhoso
Você apareceu diante de mim
Como uma visão fugaz
Como um gênio de pura beleza.
Lição 03. Beans no código, não no arquivo de configuração
Suponha que não gostemos de dar a escolha da classe de poetas que estamos criando
nas mãos do destino no arquivo de configuração.
Alterar a classe Poushkin.java
- Adicionar biblioteca de importação importa org.springframework.stereotype.Component;
- Coloque a anotação de componente ("LyricistBean1") antes da declaração de classe
Então, sugerimos a Spring que queremos ver Poushkin na forma do primeiro poeta, e não de outra pessoa.
Resta corrigir um pouco o arquivo de configuração ApplicationContext.xml:
1. Adicione o contexto do espaço para nome: xmlns: context = "
www.springframework.org/schema/context ";
2. Exclua a linha desnecessária: />
3. Adicione um comando em vez dele para adicionar automaticamente compartimentos de todas as classes localizadas no diretório spring.impls ao programa:
<contexto: package-scan-base-package = "spring.impls" />
Como resultado, o arquivo ApplicationContext.xml deve ficar assim:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <context:component-scan base-package="spring.impls"/> </beans>
Começamos. Obtemos o mesmo resultado da lição anterior.
Lição 04. Classe de Configuração
Vamos nos livrar completamente do arquivo xml.
Todas as configurações também podem estar na classe java. Às vezes é conveniente.
Adicione uma classe de configuração especial
src \ main \ java \ spring \ main \ LyricistConfiguration.java ao nosso programa:
package spring.main; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; @ComponentScan(basePackages = { "spring.impls" }) @Configuration public class LyricistConfiguration { }
O @ComponentScan mostra em qual diretório procurar beans.
O @Configuration relata que nossa classe é especial, configuração.
É isso, o arquivo xml não é mais necessário. Resta reportar esta notícia à nossa turma principal:
- Complemente com a importação necessária import org.springframework.context.annotation.AnnotationConfigApplicationContext;
- Substitua a linha de criação de contexto
ApplicationContext context = new AnnotationConfigApplicationContext (LyricistConfiguration.class);
Como resultado, o
arquivo src \ main \ java \ spring \ main \ Start.java principal deve ficar assim:
package spring.main; import org.springframework.context.ApplicationContext; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import spring.intarfaces.Lyricist; public class Start { public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(LyricistConfiguration.class); Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); ((ConfigurableApplicationContext) context).close();
Tudo começa e ainda produz linhas Pushkin imortais. Tudo funciona. Mas já sem xml.
Lição 05. Singleton e Protótipo
Explore os recursos do arquivo de configuração. Portanto, voltemos ao projeto a partir da segunda lição. Vamos tentar criar duas instâncias da classe Poushkin no Start.java e garantir que o grande poeta seja o mesmo:
Lyricist lyr1 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean1", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
E os versos são os mesmos, e o código de hash cai. Está tudo bem.
Adicione ao nosso projeto um cidadão simples que não escreve os versos
src \ main \ java \ spring \ impls \ SimpleMan.java :
package spring.impls; import spring.intarfaces.Lyricist; public class SimpleMan implements Lyricist { @Override public String Generate() { return " , "; } }
Registre a classe no arquivo de configuração (imediatamente após a primeira lixeira)
<bean id="LyricistBean2" class="spring.impls.SimpleMan"/>
Estamos tentando criar
Lyricist lyr1 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr1.Generate()); System.out.println(lyr1.hashCode()); Lyricist lyr2 = context.getBean("LyricistBean2", Lyricist.class); System.out.println(lyr2.Generate()); System.out.println(lyr2.hashCode());
O cidadão é o mesmo o tempo todo. A bagunça ...
Altere o registro do bean no arquivo de configuração adicionando a palavra mágica scope = "prototype"
Como resultado, o arquivo
src \ main \ resources \ ApplicationContext.xml terá a seguinte aparência:
<?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="LyricistBean1" class="spring.impls.Poushkin" scope="singleton"/> <bean id="LyricistBean2" class="spring.impls.SimpleMan" scope="prototype"/> </beans>
Agora está tudo bem. Os cidadãos são diferentes todas as vezes. Mas Pushkin está sempre sozinho.
As pessoas atentas perceberam que a configuração scope = “singleton” foi adicionada na primeira lixeira, mas essa configuração é usada por padrão, portanto você não pode escrevê-lo.
Isso é tudo por hoje. Se este post passar por moderação, e eu tiver tempo e energia, haverá uma continuação sobre AOP, JDBC, transações, MVC e outras informações.
Atenciosamente, Vladimir