1. Visão geral da configuração da primavera
1.1. Visão geral
O Spring Container lê informações de configuração de feijão da configuração XML, anotação Java e anotação da primavera para formar um registro de definição de feijão;
Defina o registro para instanciar o feijão de acordo com o feijão;
Coloque instâncias de feijão no pool de cache de feijão;
O aplicativo usa feijão.
1.2. Configuração baseada em XML
(1) Visão geral do arquivo XML
XMLNS ------------------------------------------------------------------------------------------------------------------------
xmlns: xsi ------------ namespace padrão, usado para especificar o arquivo de esquema do espaço de nome personalizado
xmlns: xxx = "aaaaa" ------------ namespace personalizado, xxx é um alias e o seguinte valor aaaa é o nome completo
XSI: Schemalocation -------- Especifique um arquivo de esquema específico para cada espaço de nome, formato: o endereço de nomes completo do nomes. . . Separado com espaços
2. Configuração básica de feijão
2.1. Nomeação de Bean
(1) O ID e o nome podem especificar vários nomes, e os nomes são separados por vírgulas, semicolons ou espaços.
<beanname = "#carro, 123, $ car" class = "xxxxxxxxxx">
Os usuários podem usar getbean ("#car"), getbean ("123"), getbean ("$ car") para getbean.
(2) Se nenhum ID e atributos de nome forem especificados, o Spring usará automaticamente o nome totalmente qualificado da classe como o nome do feijão
(3) Se houver vários feijões anônimos, ou seja, não existe <bean/> com ID e nome especificado, assumindo que o nome totalmente qualificado da classe é xxx.
Em seguida, obtenha o primeiro feijão usando getbean ("xxx"), obtenha o segundo feijão usando getbean ("xxx#1"), obtenha o terceiro feijão usando getbean ("xxx#2").
3. Injeção de dependência
3.1. Injeção de atributo
(1) A injeção de atributo exige que o feijão forneça um construtor padrão e forneça um método de setter para os atributos que precisam ser injetados. A primavera chama o construtor padrão para instanciar o objeto Bean e, em seguida, chama o método do setter para injetar o valor da propriedade através da reflexão.
(2) A mola verificará apenas se existe um método setter correspondente no feijão, e nenhum requisito será feito sobre se existe uma variável de atributo correspondente no feijão.
(3) Especificações especiais de Javabean para nomeação de atributos: as 2 primeiras letras de uma variável são todas maiúsculas ou de baixa forma.
3.2. Injeção de construtor
(1) A ordem de configuração dos parâmetros do construtor não afetará os resultados da configuração. O arquivo de configuração da Spring adota uma política que não está relacionada à ordem dos rótulos dos elementos. Essa estratégia pode garantir a certeza das informações de configuração até certo ponto.
(2) corresponder aos parâmetros por índice
Se o tipo de parâmetro de entrada do construtor for o mesmo, você precisará especificar o índice seqüencial dos parâmetros, caso contrário, o relacionamento correspondente não poderá ser determinado. como:
<construtor-argindex = "0" value = "xxxxxx"> <construtor-argindex = "1" value = "xxxxxxx">
O índice começa em 0.
(3) Problema de dependência circular
Se a configuração do construtor de 2 grãos depende da outra parte, ocorrerá um problema de impasse.
A solução é alterar a injeção do construtor para atribuir a injeção.
3.3. Injeção de método de fábrica
(1) Método não estático de fábrica
Como o método da fábrica não é estático, você deve primeiro criar um feijão de instância da classe de fábrica e usar o bean de fábrica para fazer referência a ele
<Beanid = "CarFactory" Class = "Classe de Fábrica"/> <Beanid = "Car5" Factory-Bean = "CarFactory" Factory-Method = "CreateCar"/>
(2) método de fábrica estática
<Beanid = "Car5" Class = "Classe de Fábrica" Factory-Method = "CreateCar"/>
3.4. Explicação detalhada dos parâmetros de injeção
(1) 5 caracteres especiais em XML
| Símbolos especiais | Sequência de fuga | Símbolos especiais | Sequência de fuga |
| < | < | "" | |
| > | > | ' | ' |
| & | & |
(2) <! [CDATA []]>
O objetivo de <! [CDATA []]> é deixar o analisador XML tratar a corda na tag como texto normal.
(3) Injetar valor nulo usando a tag <null/>
(4) Atributos em cascata
<Beanid = "Parent" Class = "XXXXXXX"> <PropertyName = "Child.xxx" Value = "Valor da propriedade do objeto de dependência"/> </i bean>
Antes da Spring3.0, o filho do objeto de dependência deve ser instanciado primeiro, caso contrário, uma exceção será lançada. Após o Spring3.0, não há necessidade de exibir instanciação. O contêiner de mola irá instanciar automaticamente o objeto de dependência.
(5) Merge de coleção
<SetMerge = "true"/>
Comumente usado em subclasses para mesclar elementos de coleta da classe pai
(6) Configurar feijões do tipo coleção através do espaço para nome de UTIL
Se você deseja configurar um feijão do tipo coleção em vez de uma propriedade do tipo de coleção, pode configurá -lo através do espaço para nome do UTIL.
3.5. Montagem automática
(1) O elemento <bean/> fornece um atributo que especifica o tipo AutoCire
3.6. Injeção de método
Se injetarmos o protótipo de feijão em feijões de modo singleton e esperamos devolver um novo feijão toda vez que chamamos, não será possível usar métodos tradicionais de injeção porque a ação dos grãos de modo singleton que injeta beans associados ocorre apenas uma vez.
(1) Uma solução opcional é permitir que o feijão hospedeiro implemente a interface BeanFactoryAware, para que o feijão host possa acessar as referências do contêiner, para que o método GET possa ser modificado e o contêiner's
Método Factory.getBean ("Bean Depended"), você pode obter o feijão mais recente todas as vezes.
(2) O método acima acopla nosso código e mola, que é a pior maneira de fazer, e podemos desacoplar a injeção de método.
Precisamos definir apenas uma interface e definir um método abstrato para obter feijões dependentes na interface. A configuração da primavera é a seguinte:
<beanid = "car" class = "bean dependente"/> <beanid = "host" class = "interface bean"> <lookup-methodname = "getcar" bean = "car"/> </sichean>
A tag de elemento de pesquisa-método fornece implementação dinâmica para getcar () de feijões de interface. A implementação da injeção de método depende principalmente da tecnologia de operação dinâmica do pacote CGLIB.
3.7. Substituição do método
Use o Bean2 para substituir o método getcar de Bean1, desde que o Bean2 seja implementado a interface MethodReplacer, e a configuração é a seguinte:
<beanid="bean1"class="aaaaaaaaa"><replaced-methodname="getCar"replacer="bean2"/></bean><beanid="bean2"class="bbbbbbbbbb"/>
4. A relação entre <Bean>
4.1. Herança
A configuração do feijão pai pode ser herdada por subclasses para evitar definições repetidas. A configuração é a seguinte:
<beanid = "parent bean" class = "aaaaaaa" abstract = "true"/> <beanid = "child bean" class = "bbbbbb">
As subclasses podem substituir a configuração da classe pai. Se o resumo = "verdadeiro" da classe pai não for especificado, o feijão pai será instanciado.
4.2. Dependência
Alguns feijões instantados dependem de outros feijões e outros feijões devem ser instanciados antes que possam instanciar o feijão do hospedeiro. A primavera fornece o atributo depende e especifica que o feijão de dependência é instanciado primeiro, como:
•
Se houver vários grãos de pré-dependência, você poderá criar o nome do feijão por vírgulas, espaços ou semicolons.
4.3. Escopo de feijão
(1) O recipiente de mola instanciará todos os feijões quando for iniciado. Se você não deseja instanciar com antecedência, a propriedade Lazy-init = "True" de <Bean/> pode controlar a instanciação atrasada, mas se o feijão for referenciado por outros grãos que precisam ser instantados com antecedência, a primavera também ignorará a configuração de instanciação atrasada.
(2) escopo relacionado ao aplicativo da web
Se o usuário usar a solicitação, a sessão e o escopo da GlobalSession, a configuração adicional deverá ser feita no contêiner da web primeiro:
Em versões mais baixas dos contêineres da web (antes da configuração do filtro de solicitação HTTP:
<filter> <filter-name>requestContextFilter</filter-name> <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class> </filter> <filter-mapping> <filter-name>requestContextFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
Em versões mais altas dos contêineres da web, você pode usar o ouvinte de solicitação HTTP para configurar:
<Ilanter> <Ilvier-class> org.springframework.web.context.request.requestContextListener </lirerv-class> </lister>
(3) Problema de dependência do escopo
Ao injetar feijões escondidos na web em grãos singleton ou protótipo, use AOP, por exemplo:
<bean id = "web1" scope = "request"> <aOP: Scoped-proxy/> </bean> <bean id = "singleton1"> <propriedade name = "z1" ref = "web1"/> </shean>
4.4. FactoryBean
De um modo geral, a primavera usa o atributo de classe de <Bean/> para especificar o feijão instanciação da classe de implementação através do mecanismo de reflexão. Mas, em alguns casos, o processo de instanciar um feijão é mais complicado. Se da maneira tradicional, uma grande quantidade de informações de configuração é necessária no <Bean>. A flexibilidade do método de configuração é limitada e uma solução simples pode ser obtida usando métodos de codificação.
O Spring fornece uma interface de classe de fábrica org.springframework.beans.Factory.FactoryBean para isso, e os usuários podem personalizar a lógica de feijões instantantes implementando essa interface.
Quando a classe de implementação configurada pelo atributo de classe <bean/> é fábrica e sua subclasse, o retorno do método FactoryBean () não retorna o FactoryBean e sua própria subclasse, mas o objeto retornado pelo método FactoryBean GetObject ().
Se você deseja obter o objeto do FactoryBean e sua própria subclasse, prefixo explicitamente o nome do feijão com um prefixo "&", como getbean ("& car5") quando o método getBean (beanname).
5. Configuração baseada em anotação
5.1. Tipo de anotação
@Component ----- Anotação nativa
Anotações derivadas:
@Repositório: anote Dao
@Service: Serviço de etiqueta
@Controller: controlador de anotação
5.2. Use informações de configuração de anotação para iniciar o recipiente de mola
(1) Após a primavera 2.5, foi introduzido o espaço para nome de contexto, que fornece a aplicação de anotações para definir feijões, digitalizando o pacote de classe:
<Contexto: componente-Scan Base-Package = "XXXXXXXXXX" Recurso-Pattern = "XXXX/*. Classe">
O atributo de padrão de recursos é usado para especificar classes sob pacotes específicos que precisam ser digitalizados no pacote base
(2) Existem sub-rabelas de filtro mais poderosas
<context:component-scan base-package="xxxxxxxxxx" > <context:include-filter type="xxxx" expression="xxxxxxxxxxxxxxxx"/> <context:exclude-filter type="xxxx" expression="xxxxxxxxxxxxxxx"/></context:component-scan>
De todos os tipos, a capacidade de filtragem de AspectJ é a mais poderosa.
5.3. Conjunto automático de feijão
(1) @Autowired
@Autowired Matches por tipo por padrão. Se não houver feijão correspondente no contêiner, uma exceção será lançada quando o contêiner de mola iniciar. Você pode usar @Autowired (requerir = false) para anotação, e nenhuma exceção será lançada.
Use @Autowired para anotar diretamente os parâmetros do método. Se um método possui vários parâmetros, por padrão, o Spring seleciona automaticamente os feijões que correspondem ao tipo de parâmetro para injeção.
Usando a anotação @Autowired de variáveis de coleta, você pode injetar todos os feijões que correspondem ao tipo de elemento da coleção, que é muito poderoso.
Usando a propriedade @Autowired Assembler, não pode haver método Setter.
(2) @qualifiler
Se houver mais de um feijão correspondente no contêiner, o nome do feijão poderá ser qualificado pela anotação @qualifiler.
(3) Suporte para marcação e anotação
A primavera também suporta @resource definida por JSR-250 e @inject anotações definidas por JSR-330
@Resource exige que o atributo de nome de um feijão seja fornecido. Se o atributo estiver vazio, o nome da variável ou o nome do método será automaticamente usado como o nome do feijão.
(4) Pontos -chave:
Se você usar apenas @Autowired, ainda precisamos definir explicitamente o nó <bean/> no XML. O contêiner de mola desativa o conjunto da anotação por padrão. A maneira de ativar é configurar o elemento <contexto: anotação-config/> no XML.
Mas a primavera também fornece outro truque. Usando o elemento <contexto: componente/>, o contêiner de mola detectará automaticamente o feijão sem definir explicitamente o nó <bean/>.
A primavera anota a aula de anotação através do @Component, @Repository, @Service e @Controller, para que <Contexto: componente-Scan/> saiba quais classes precisam ser registradas como Springbean.
Se você usa um pacote JAR de terceiros e deseja injetar automaticamente classes no pacote JAR de terceiros, mesmo que o pacote JAR de terceiros não os anote com anotações, o elemento de filtro <Contexto: Incluir-filter> pode substituir as classes baseadas em anotação.
5.4. O escopo de ação de Bean e o método do processo de vida
(1) @Scope ("xxxx")
A gama padrão de feijões configurados pela anotação é Singleton.
A primavera fornece anotação @Scope. Quando se trata da classe, os parâmetros de anotação são os mesmos que o valor do atributo de escopo no XML.
(2) Comparação de métodos de processo de vida
| <Bean> | anotação |
| init-method | @PostConstruct |
| Destory-Method | @Predestroy |
Diferença: as anotações podem definir vários métodos em uma classe, e os métodos são executados em ordem
6. Configuração baseada em Java
6.1. Use as classes Java para fornecer informações de definição de feijão
(1) Pojo comum pode fornecer informações de definição de feijão para recipientes de mola, desde que a anotação @Configuration esteja marcada. Cada método marcado com @Bean é equivalente a fornecer uma informação de definição de feijão.
(2) @Bean
O tipo de feijão é determinado pelo tipo de retorno do tipo de método anotado por @bean
O nome padrão do feijão é o mesmo que o nome do método e também pode ser explicitamente especificado por @Bean (name = "xxx").
Você pode usar @scope em @bean para indicar o escopo do uso do feijão
(3) @Configuration
Como a própria classe de anotação @Configuration foi marcada com a anotação @Component, qualquer classe marcada com @configurtion pode ser montada automaticamente em outras classes usando @Autowired.
6.2. Inicie o recipiente de mola usando informações de configuração com base na classe Java
(1) O Spring fornece uma classe AnotationConfigApplicationContect, que pode iniciar diretamente o contêiner de mola através da anotação anotação @Configuration.
(2) Quando existem várias classes de configuração
Você pode registrar um por um através do método de registro de anotaçãoConfigApplicationContect e, em seguida, ligar para o método de atualização para atualizar o contêiner para aplicar essas classes de configuração registradas.
Você também pode usar a anotação @import (xxx.class) para introduzir todas as outras classes de configuração em uma classe de configuração, para que você precise apenas registrar uma classe de configuração.
(3) Consulte a configuração do @Configuration através da classe de configuração XML
<Contexto: Componente-ScanBase-Package = "..." Recurso-Pattern = "Nome da classe Configuration">
(4) Informações de configuração XML de referência na classe de configuração
Use @IMPORTRESOURCE ("ClassPath: ............") na @configuration para importar o arquivo de configuração XML
6.3. Comparação de 3 métodos de configuração
| Xml | anotação | Classe Java |
| A classe de implementação do feijão é o desenvolvimento atual do projeto | Controle a lógica geral da inicialização do feijão através do código, adequado para cenários onde a instanciação de feijões é mais complexa |
Resumir
O exposto acima é toda a explicação detalhada da mola montando feijões em recipientes do IOC. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a este site:
Uma explicação detalhada dos três métodos de configuração do feijão na primavera 3.x
Uma breve discussão sobre a diferença entre o Spring Singleton Bean e o Singleton Pattern
Explicação detalhada do ciclo de vida do uso da configuração da primavera
Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!