Arquivo de configuração
Nos exemplos anteriores, usamos a definição de feijão XML para configurar componentes. Em um projeto um pouco maior, geralmente existem centenas de componentes. Se esses componentes forem configurados usando definições de feijão XML, ele obviamente aumentará o tamanho do arquivo de configuração, tornando -se muito conveniente para encontrar e manter.
A Spring 2.5 apresenta um mecanismo automático de varredura de componentes para nós. Ele pode encontrar classes anotadas com anotações @Component, @service, @Controller e @Repository sob o ClassPath e incorporar essas classes no contêiner de mola para gerenciar.
Sua função é a mesma que usar componentes de configuração do nó do feijão nos arquivos XML. Para usar o mecanismo automático de varredura, precisamos abrir as seguintes informações de configuração:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 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.2.xsd "> <Contexto: componentscan-package =" cn.itcast "/BASEMBENSD:
O <context:component-scan base-package="cn.itcast" /> Configuração registra implicitamente vários processadores que analisam as anotações, incluindo o processador <Contexto: anotação-config /> registrado com o configuração, se é escrito, se é escrito, que é escrito <context:component-scan base-package="cn.itcast" /> shiStigaturs é, se é escrito, que é escrito, o número de contextos <context:annotation-config/> configuração. Além disso, o pacote básico é um pacote (subpackage) que precisa ser digitalizado.
anotação
O @Service é usado para anotar os componentes da camada de negócios, o @Controller é usado para anotar os componentes da camada de controle (como a ação no Struts2) e o @repository é usado para anotar o componente de acesso a dados, ou seja, o componente DAO. @Component refere -se a componentes. Quando os componentes não são fáceis de classificar, podemos usar essa anotação para anotar.
Este artigo é baseado no caso de anotação @Autowire e montagem automática.
Primeiro, mudamos o arquivo de configuração da Spring para:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 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.2.xsd "> <Contexto: componentscan-package =" cn.itcast "/BASEMBENSD:
Um exemplo
Em seguida, use a anotação @Service para anotar a classe PersenserviceBean, como segue:
@ServicePublic Class PerseviceServiceBean implementa Persevice {Private Persondao Persondao; public void setPersondao (persondao persondao) {this.persondao = persondao; } @Override public void save () {persondao.add (); }}Anote a classe Persondaobean usando a anotação @repository, como segue:
@RepositoryPublic Classe PersondaBean implementa Persondao {@Override public void add () {System.out.println ("Execute o método add () em persondaBean"); }}Finalmente, modificamos o código da classe Springtest para:
classe pública Springtest {@Test public void Instânciaspring () {AbstractApplicationContext ctx = new ClassPathXMLApplicationContext ("beans.xml"); Persevice PersonService = (Persenservice) ctx.getBean ("PerseviceBean"); Persondao persondao = (persondao) ctx.getbean ("persondaobean"); System.out.println (Persenservice); System.out.println (persondao); ctx.close (); }}Teste o método InstancesPring () e você pode ver que o Eclipse Console Prints:
Se quisermos usar o nome especificado para obtê -lo, podemos modificar o código da classe PersenserviceBean para:
@Service ("PERSONSERVICE") Classe pública PERSOnserviceBean implementa PERSOnservice {private Persondao persondao; public void setPersondao (persondao persondao) {this.persondao = persondao; } @Override public void save () {persondao.add (); }}Dessa forma, o código da classe Springtest deve ser alterado para:
classe pública Springtest {@Test public void Instânciaspring () {AbstractApplicationContext ctx = new ClassPathXMLApplicationContext ("beans.xml"); Persevice Persenservice = (PERSONSERVICE) CTX.GETBEAN ("PERSONSERVICE"); System.out.println (Persenservice); ctx.close (); }}Teste o método InstancesPring () e você pode ver que o Eclipse Console Prints:
Aprendemos o escopo dos grãos gerenciados pela primavera antes, e podemos saber que o escopo dos dois grãos gerenciados pela primavera acima é Singleton por padrão. Obviamente, também podemos alterar o escopo dos feijões gerenciados pela primavera, como alterar o código da classe PersonServiceBean para:
@Service ("PERSONSERVICE") @SCOPE ("Prototype") Classe pública PERSONSERVICEBEAN IMPLEMENTOS PERSONSERVAMENTO {private Persondao Persondao; public void setPersondao (persondao persondao) {this.persondao = persondao; } @Override public void save () {persondao.add (); }}Isso significa que o escopo do PERSONSERVICEBEAN gerenciado pela primavera se tornou um protótipo. Neste momento, modificamos o código da classe Springtest para:
classe pública Springtest {@Test public void Instânciaspring () {AbstractApplicationContext ctx = new ClassPathXMLApplicationContext ("beans.xml"); Persevice Persenservice1 = (PERSONSERVICE) CTX.GETBEAN ("PERSONSERVICE"); Persevice Persenservice2 = (PERSONSERVICE) CTX.GETBEAN ("PERSONSERVICE"); System.out.println (Persenservice1 == Persenservice2); ctx.close (); }}Teste o método InstancesPring () e você pode ver que o Eclipse Console Prints:
O escopo do protótipo significa que toda vez que você recebe um feijão de um recipiente de mola, é um novo objeto.
Se os componentes estiverem incluídos no recipiente da mola, digitalizando automaticamente o caminho da Path, como especificar o método de inicialização e o método de destruição do feijão? Neste momento, precisamos usar duas anotações: @PostConstruct e @Predestroy. Para experimentação, modificamos o código da classe PersenserviceBean para:
@Service ("PERSONSERVICE") Classe pública PERSOnserviceBean implementa PERSOnservice {private Persondao persondao; @PostConstruct public void init () {System.out.println ("Initialize Resource"); } @Predestroy public void Destro () {System.out.println ("Destroy, Close Resource"); } public void setPersondao (persondao persondao) {this.persondao = persondao; } @Override public void save () {persondao.add (); }}Em seguida, precisamos modificar o código da classe Springtest para:
classe pública Springtest {@Test public void Instânciaspring () {AbstractApplicationContext ctx = new ClassPathXMLApplicationContext ("beans.xml"); Persevice Persenservice = (PERSONSERVICE) CTX.GETBEAN ("PERSONSERVICE"); ctx.close (); }}Dessa forma, teste o método Instancespring () e o console do eclipse imprimirá:
Para visualizar o código -fonte, clique para deixar o Spring digitalizar e gerenciar o feijão automaticamente para fazer o download.
Resumir
O acima é o pacote automático de varredura de mola introduzido pelo editor. Espero que seja útil para todos. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a todos a tempo. Muito obrigado pelo seu apoio ao site wulin.com!