Primeiro de tudo, para aprender a injetar feijão na primavera, você deve primeiro entender o que é a injeção de dependência. Injeção de dependência refere -se a: deixe a classe de chamada injetar a dependência da classe de implementação da classe de implementação de uma determinada interface por terceiros, eliminando assim a dependência da classe de chamada na classe de implementação de uma determinada interface.
Os métodos de injeção de dependência suportados nos recipientes de mola incluem principalmente injeção de propriedade, injeção de construtor e injeção de método de fábrica. Em seguida, introduziremos esses três métodos de injeção de dependência e seus métodos específicos de configuração em detalhes.
1. Injeção de atributo
A injeção de atributo significa injetar o valor do atributo ou objeto dependente do bean através do método setxxx (). Como o método de injeção de atributo é seletivo e flexível, também é o método de injeção mais comumente usado no desenvolvimento real.
A primavera primeiro chamará o construtor padrão do feijão para instanciar o objeto Bean e depois chamará o método definido através do método refletido para injetar o valor da propriedade.
A injeção de propriedade exige que o feijão forneça um construtor padrão e deve fornecer um método definido para as propriedades que precisam ser injetadas.
Dicas: o chamado construtor padrão, ou seja, um construtor sem parâmetros. Se não houver construtor personalizado na classe, o sistema (JVM) gerará automaticamente um construtor padrão sem parâmetros. Se o construtor com parâmetros for explicitamente personalizado na classe, o sistema não gerará automaticamente o construtor padrão e você precisará adicionar manualmente um construtor sem parâmetros.
A seguir, é apresentado um exemplo para demonstrar o método de injeção de propriedade de feijão na primavera:
Escreva uma classe de usuário:
pacote com.kevin.bean;/** * Crie um método de injeção de propriedade de bean de classe * @author kevin * */public classe usuário {private string userName; public String getUserName () {return Username; } public void setUserName (string userName) {this.username = nome de usuário; }}Arquivo 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.xsd "> <!-BEAN DEFINIÇÕES-> <!-configuration objeto-> <Value> Kevin </value> </ouse> </ Beans>
Entre eles, cada valor da propriedade corresponde a uma tag de propriedade e o valor do nome da propriedade é o nome da propriedade na classe. Na classe de implementação do feijão, possui o método de implementação correspondente setUserName ().
Dicas: A primavera verá apenas se o feijão contém um método do setter e não faz requisitos específicos para se existem variáveis de atributo correspondentes. No entanto, de acordo com as regras convencionais, devemos definir as variáveis de atributo correspondentes para ela.
Nomeação de especificações para tags <propriedade> na primavera:
De um modo geral, os nomes de variáveis de atributo Java começam com letras minúsculas, mas considerando algumas abreviações em inglês com significados especiais, os feijões Java também permitem nomes de variáveis que começam com letras maiúsculas. Mas os dois pontos a seguir devem ser atendidos:
Para métodos de injeção de atributos, as garantias só podem ser fornecidas no arquivo de configuração artificialmente, mas as garantias não podem ser fornecidas no nível de sintaxe. No momento, você precisa usar a injeção de construtor para atender melhor aos requisitos.
2. Injeção do construtor
A injeção do construtor é outro método de injeção comumente usado, além da injeção de atributo. Ele pode garantir que algumas propriedades necessárias sejam definidas quando os grãos são instantados e podem ser usados após a instanciação.
O pré -requisito para o uso da injeção de construtor é que o feijão deve fornecer a um construtor argumentos.
Para injeção de construtor, os arquivos de configuração podem ser usados das seguintes maneiras:
【MACH MACH Método de entrada de parâmetros por tipo】
Escreva o código do feijão:
pacote com.kevin.bean;/** * Escreva o teste do feijão para corresponder aos parâmetros por tipo * @author kevin * */public class Person {private string name; idade inteira privada; public String getName () {Return Name; } public void setName (nome da string) {this.name = name; } public integer getage () {retorna idade; } public void setage (idade inteira) {this.age = Age; }}Escreva arquivos 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.xsd "> <!-Bean Definições aqui-> <!-Objetivo-> <Bean idan" <Value> kevin </value> </fruvuctor-arg> <construtor-arg type = "Integer"> <Value> 20 </value> </strowortor-arg> </sieves>
Os arquivos de configuração da Spring adotam estratégias de configuração que são independentes da ordem dos rótulos dos elementos; portanto, a certeza das informações de configuração pode ser garantida até certo ponto.
Então, quando vários parâmetros de tipo do construtor em um feijão são os mesmos, é fácil causar confusão ao corresponder aos parâmetros de acordo com o tipo. No momento, é necessário outro método: parâmetros correspondentes de acordo com o índice.
【Match parâmetros de acordo com o índice】
Escreva o código do feijão:
pacote com.kevin.bean;/** * Escreva testes e parâmetros de feijão no método do índice * @author kevin * */public classe estudante {name de string privado; gênero de cordas privadas; Pontuação dupla privada; estudante público (nome da string, gênero de string, pontuação dupla) {super (); this.name = nome; this.gnder = gênero; this.score = score; }}O arquivo de configuração está escrito da seguinte forma:
<? 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.xsd "> <!-Definições aqui-> <!-Objetivo-> <eng idan" value = "Kevin"> </fruvuctor-arg> <construtor-arg index = "1" value = "masculino"> </construtor-arg> <construtor-arg index = "2" value = "66"> </construtor-arg> </ Bean> </beans>
Dicas: Durante a injeção da propriedade, a primavera determina o atributo de configuração e o método do setter correspondente de acordo com as especificações do feijão Java e usa o mecanismo de reflexão Java para chamar o método setter do atributo para concluir a injeção da propriedade. No entanto, o mecanismo de reflexão Java não se lembra do nome do parâmetro do construtor; portanto, não podemos configurar o construtor formulando o nome do parâmetro do construtor, para que possamos concluir indiretamente a injeção de propriedade do construtor através do tipo de parâmetro e índice.
【Tipo de uso combinado e parâmetros de correspondência de índice】
Em alguns arquivos de configuração complexos, o tipo e o índice devem ser usados simultaneamente para concluir a injeção de parâmetro do construtor. Aqui está um exemplo para demonstrar.
Escreva feijão:
pacote com.kevin.bean;/** * Escreva testes de feijão para usar parâmetros de correspondência de tipo e índice * @Author Kevin * */public Class Professor {nome da string privada; endereço de string privado; Salário duplo privado; private Int Age; professor público (nome da string, endereço da string, salário duplo) {super (); this.name = nome; this.address = endereço; this.salary = salário; } Professor público (nome da string, endereço da string, Int Age) {super (); this.name = nome; this.address = endereço; this.age = idade; }}Nesta classe, existem dois construtores sobrecarregados e todos têm três parâmetros. Nesse caso, o uso dos métodos de tipo e índice não pode concluir os requisitos. Neste momento, ambas as propriedades precisam ser usadas ao mesmo tempo.
Arquivo 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.xsd "> <!-Bean aqui-> <!-Object-> <zé idan" <Value> kevin </value> </fruvuctor-arg> <construtor-arg index = "1" type = "string"> <value> China </value> </structor-arg> <construtor-arg index = "2" type = "int"> <Value> 20 </value> </construtor-arg> </baine = "
Você pode ver que o foco está realmente no tipo de terceiro parâmetro, portanto, especificamos o índice e digite o arquivo de configuração, para que a mola possa saber qual construtor injetar o parâmetro.
Dicas: adicione ao nosso arquivo de configuração, há um problema de ambiguidade. O contêiner de mola pode ser iniciado normalmente e não relatará um erro. Ele usará aleatoriamente um construtor correspondente para instanciar o feijão. O construtor selecionado aleatoriamente pode não ser necessário pelo usuário, portanto, devemos ter cuidado para evitar essa ambiguidade ao programar.
【Combine os parâmetros por meio de seu próprio tipo de reflexão】
Se o tipo de parâmetro do construtor do feijão for discernível, pois o mecanismo de reflexão Java poderá obter o tipo de parâmetro construtor, mesmo que a injeção do construtor não forneça informações de tipo e índice, a mola ainda poderá concluir a injeção de informações do construtor. Por exemplo, no exemplo a seguir, o tipo de parâmetro do construtor da classe do gerente pode ser distinguido.
Escreva aula de gerente:
pacote com.kevin.bean;/** * Escreva um teste de feijão para combinar argumentos por meio de seu próprio tipo de reflexão * @Author Kevin * */Public Class Manager {Nome da String Private; Salário duplo privado; pessoa privada; gerente público (nome da string, salário duplo, pessoa de pessoa) {super (); this.name = nome; this.salary = salário; this.person = pessoa; }}Escreva arquivos 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.xsd "> <!-BEAN DEFINIMENTO> <!-Objetivo- </construtor-arg> <Construtor-arg> <ref bean = "user"/> </structor-arg> <brutor-arg> <ref bean = "pessoa"/> </structor-arg> </beans>
Os métodos acima podem implementar a injeção de parâmetros do construtor, mas, para evitar a ocorrência de problemas, é recomendável usar o índice e digitar explícitos para configurar as informações de entrada do parâmetro do construtor.
3. Injeção de método de fábrica
O método da fábrica é um padrão de design que é frequentemente usado em aplicações e também é o principal método de implementar a idéia de inversão de controle e design de instância única. A classe de fábrica é responsável por criar uma ou mais instâncias de classe de fábrica. O método da classe de fábrica geralmente retorna a instância da classe de destino na forma de uma interface ou variável de classe abstrata.
A classe de fábrica bloqueia as etapas de instanciação da classe de destino externamente, e o chamador nem precisa especificar qual é a classe de destino específica. Como os contêineres da mola fornecem a funcionalidade dos métodos de fábrica nos métodos da estrutura e estão abertos aos desenvolvedores de maneira transparente. Portanto, raramente é necessário escrever métodos de engenharia manualmente. No entanto, os métodos de engenharia ainda serão encontrados em alguns sistemas herdados ou biblioteca de terceiros. Neste momento, o método de injeção de fábrica de primavera pode ser usado para injetar a mola.
Os métodos de injeção de fábrica de primavera podem ser divididos em estática e não estática.
【Método não estático de fábrica】
Alguns métodos de fábrica não são estáticos e devem ser instanciados antes que os métodos de fábrica possam ser chamados. O seguinte é um exemplo a serem demonstrado.
Escreva aula de fábrica:
pacote com.kevin.FactoryBean;/** * Escreva a classe de fábrica testa injeção de método de fábrica não estática * @Author Kevin * */public class BookFactory {public Book Buybook () {Book Book = new Book (); book.setName ("pense em java"); livro de retorno; }}Redação de arquivos 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.xsd "> <!-BEANS aqui-> <!-Object-> <ean id id =" Factory-bean = "bookfactory" fábrica-method = "BuyBook"> </sheans> </sicheans>
Como o método da fábrica de bookfactory não é estático, você precisa primeiro definir um feijão da classe de fábrica e, em seguida, se referir à instância do feijão de fábrica por meio da propriedade do feijão da fábrica. Em seguida, o método de fábrica correspondente é usado para especificar o método de fábrica correspondente.
【Método de fábrica estática】
Muitos métodos de classe de fábrica são estáticos, o que significa que os métodos de classe de fábrica podem ser chamados sem criar instâncias de classe de fábrica. Portanto, os métodos de engenharia estática são mais convenientes e concisos do que os métodos não estáticos de fábrica. A seguir, é apresentado um exemplo para demonstrar o método de fábrica estática.
Escreva aula de fábrica:
pacote com.kevin.FactoryBean;/** * Escreva a classe de fábrica de fábrica injeção de método de fábrica estática * @Author Kevin * */public class CarFactory {public static car CreateCar () {carro = carro novo (); car.setbrand ("Lamborghini"); carro de volta; }}Escreva arquivos 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.xsd "> <!-Bean Definições-> <!-Object-> <ean idan" </ Beans>
Resumir
A Spring fornece três métodos de injeção opcional, mas em aplicações reais, não há padrão unificado para qual método de injeção deve escolher. Aqui estão alguns motivos para se referir:
Razão para injeção de construtor:
Razão de injeção de propriedades:
De fato, a Spring nos fornece tantos métodos para injetar parâmetros, portanto esses métodos devem ter suas próprias razões. Cada método tem vantagens únicas em um determinado problema. Precisamos escolher apenas o método apropriado de acordo com nossas necessidades específicas de uso, mas a injeção de método de fábrica geralmente não é recomendada.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.