Uma breve discussão sobre o método de injeção do COI da mola e a injeção de diferentes tipos de dados

Uma referência simples para usar o Spring-IOC:

Análise de instâncias simples do COI da primavera e atributos de escopo de feijão

1. Injetar diferentes tipos de dados através do método de conjunto

Código da classe de teste (as propriedades injetadas no método de conjunto devem ser adicionadas ao método de conjunto)

 /** Exemplo de injeção através do método de set*/public classe ioc_by_set {/** injeção de parâmetro inteiro do tipo*/private ID;/** injeção de string tipo parâmetro*/private string name;/** injeção de entidade/** Set; set;/** Injetar pares de valor-chave do mapa*/mapa privado <objeto, objeto> map;/** injetar propriedades Tipo*/Propriedades privadas Propriedades;/** injetar string vazia*/private string emptyValue;/** injetar valor nulo*/private string nullValue = ""; {return false;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nome);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- variedade) {System.out.println(object.toString());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println ("set:"); para (objeto objeto: set) {System.out.println (object.toString ());}} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println (Entry.getKey () + "|" + Entry.getValue ());}} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Entry.getValue ());}} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- setName (nome da string) {this.name = name;} public void SetUser (usuário do usuário) {this.User = user;} public void SetArray (object [] Array) {this.array = Array;} public SetSet SetSet <SetList (list> list) {this.list = List;} SetSet SetSet <Sient setMap (map <objeto, objeto> map) {this.map = map;} public void setProperties (Propriedades Propriedades) {this.properties = Properties;} public void setEmptyvalue (string emptiUe) {this.ementValue = VeltVulue;

ApplicationContext.xml Configuração

 <!-Definir injeção-> <bean id = "ioc_by_set"> <!-atributo de identificação de injeção-> <propriedade name = "id" value = "1"/> <!-usando <!-lidando com caracteres especiais xml com <!-usando <! [CDATA []]> tags ---> <! <Value> <! [CDATA [P&G]]> </Value> </propriedade> <!-Definindo injeção interna do feijão-> <Nome da propriedade = "User"> <Bean> <propriedade name = "id" value = "1"/> <names (! name = "Array"> <Array> <!-Definir elementos da matriz-> <Value> Array01 </value> <Value> Array02 </Value> <Value> Array03 </Value> </Array> </Property> <!-Inject List Type-> <Nome da propriedade "List"> <list> <!- <Value> list03 </value> </list> </property> <!-injetar conjunto de set type-> <erpown> <propriedade --- Definir elementos na lista-> <Value> list02 </value> <Value> list03 </value> </list> </property> <!-inject Set Type-> <weead Name = "set"> <!-Set> <value>set02</value> <value>set03</value> </set> </property> <!-- Inject Map type--> <property name="map"> <map> <!-- Define key-value pairs in map --> <entry> <key> <value>mapKey01</value> </key> <value>mapValue01</value> </entry> <entry> <key> <value>mapKey02</value> </key> <Value> mapValue02 </value> </string> </pap> </propriedade> <!-Injetar Tipos de propriedades-> <Property name = "Propriedades"> <ports> <!-Definir Key-value em Propriedades2 "Propperties2"> <-Properties 2 key2 "> <-pkeSky-Tensky-Tensky-Tensky-Tepers"> <! Injetar string vazia-> <propriedade name = "emptyValue"> <Value> </value> </propriedade> <!-injetar valor nulo-> <propriedade name = "nullValue"> <null/> </property> </i bean>

Código de teste

 public class IoC_Test {private ApplicationContext ctx;@Before public void load() {//Read applicationContext.xml configuration file ctx = new ClassPathXmlApplicationContext("applicationContext.xml");}@Test public void SetTest() {IoC_By_Set ioc = (IoC_By_Set) ctx.getbean ("ioc_by_set"); ioc.checkattr ();}}

Resultados do console:

 ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !

2. Injete vários tipos de atributos através de métodos de construção

Nota: Ao usar a versão JDK1.8, atualize o pacote JAR relacionado à mola para a versão 4.x ou acima, caso contrário, os construtores incompatíveis serão injetados.

Código da classe de teste

 /** Exemplo de injeção por meio do construtor*/public classe ioc_by_constructor {private ID ID; nome privado de string; usuário privado; list private <bject> list; public ioc_by_constructor () {} public ioc_by_constructor (this theger id, string name, usuário, list <> list) { List;}/** Verifique se a injeção é bem -sucedida*/public boolean checkattr () {if (id == null) {return false;} else {System.out.println ("id:" + id);} system.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + "| user.getpassword ());} system.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- verdadeiro;}}

ApplicationContext.xml Configuração

 <!-construtor-arg value = "p & g"/> <!-Objeto de injeção-> <bean id = "ioc_by_constructor"> <!-objeto de injeção-> <ipean> <construtor-arg value = "1" type = "java.lang.integer"/> <!-injeção- <Construtor-Arg> <!-Objeto interno-> <Bean> <construtor-arg value = "1"/> <construtor-arg value = "Construção Bean interno"/> <construtor-arg value = "666"/> </sicean> </frutor-arg> <!-injeção- <Value> list02 </value> <Value> LIST03 </Value> </list> </construtor-arg> </i bean>

Código de teste:

 public class ioc_test {private ApplicationContext ctx; @EBe Public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@test iRoid construtorTest () {______By__Byxt.xml ");}@Test public IVOrTORTORTORTEST () {_____By_Byxt.CML");}@Test Public Void ctx.getbean ("ioc_by_constructor"); ioc.checkattr ();}}

Resultados do console:

 ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !

3. Injeção automática (montagem automática)

Embora a montagem automática possa economizar algum código, não é recomendável usá -lo

Código da classe de teste:

 /** injeção de montagem automática*/public classe ioc_by_auto {usuário privado usuário;/** Verifique se a injeção é bem -sucedida*/public boolean checkAttr () {if (user == null) {return false;} else {System.out.println ("user:" + user.getid () + "" "" "" + user.out.out.println (user: " + user.getid () +" " user.getpassword ());} system.out.println ("correto !!!"); retorna true;}/** O atributo de montagem automática requer definir o método de set*/public void setUser (usuário do usuário) {this.User = user;}}

ApplicationContext.xml Configuração

 <!-Beans obtidos por montagem automática-> <bean id = "user"> <propriedade name = "id" value = "1"/> <propriedade name = "userName" value = "auto-assembly"/> <names name = "senha" "233"/> </bean> <!-bEan Autowire: porname "" 233 "/> </bean> <! tipo de propriedade da classe. Se vários feijões correspondem, jogue um construtor de exceção corresponder ao feijão correspondente de acordo com o tipo de parâmetro do construtor da classe. Não. Padrão, significa que o padrão de montagem automática não é usada: determinado pela propriedade padrão-Autowire da etiqueta superior <Heeans>-> <bean id = "ioc_by_auto" AutoCire = "Byname"> </ean>

Código de teste

 public class ioc_test {private ApplicationContext ctx; @EBe Public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@Test Void AutoTest () {IOC_ATEX ctx.getbean ("ioc_by_auto"); ioc.checkattr ();}}

Resultados do console

 Usuário: 1 | Montagem automática | 233 está correto! ! !

O acima está usando o modo Byname. O código de configuração de outros modos foi indicado e nenhum teste é realizado.

4. Atributos de injeção usando nomes de nome P

Código da classe de teste

 /** Injeção usando o espaço para nome de p*/public classe ioc_by_p {ID do número inteiro privado; nome de sequência privada; usuário privado usuário;/** Verifique se a injeção é bem -sucedida*/public boolean checkattr () {if (id == null) {return false;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nome);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void SetName (nome da string) {this.name = name;} public void setUser (usuário do usuário) {this.user = user;}}

ApplicationContext.xml Configuração

 <!-Injete vários tipos de propriedades usando o espaço de nome P-> <bean id = "user2"> <propriedade name = "id" value = "1"/> <propriedade name = "nome de usuário" value = "p"/> <names = "senha" p: "233"/> </bean> <Pean = "ioc_by_p" P: User-ref = "User2"> </sien>

Código de teste

 public class ioc_test {private ApplicationContext ctx; @Before public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@Test Void Ptest () {ioc_by _by IOC IOC = IOC =}}@public void ctx.getbean ("ioc_by_p"); ioc.checkattr ();}}

Resultados do console

 ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !

5. Injetar usando o método de anotação

A primavera forneceu injeção baseada em anotação após 3,0.

1.@Annotação automática de variáveis, métodos e construtores de membros para concluir o trabalho automático de montagem. Não é recomendável usá -lo.

2. @qualificador combinado com @Autowired para resolver a montagem de vários feijões do mesmo tipo

3. Anotação padrão @Resource-JSR-250, a função é equivalente a @Autowired, mas o @Autowired é automaticamente injetado de acordo com o BYTYPE, enquanto o @Resource é injetado automaticamente de acordo com o ByName por padrão.

4. @PostConstruct - Adicione anotação @PostConstruct ao método, e esse método será executado pelo contêiner de mola após a inicialização do feijão.

5. @PREDESTROY-ADD Anotação @PredeStroy No método, esse método será executado pelo contêiner de mola após a inicialização do feijão.

6. @Componente-somente Adicione uma anotação @Component à classe correspondente, a classe é definida como um feijão. Não é recomendável usá -lo. Recomenda -se usar mais três tipos refinados: @repository, @service, @Controller

@Repository Storage Cayer Bean

@Service Business Camyer Bean

@Controller Display Layer Bean

7.@Scope Define o escopo do feijão

Primeiro configure o ApplicationContext.xml para ativar a anotação

 <!-Digitalize a classe anotada no pacote-> <Contexto: Componente-Scan Base-Package = "com.bc.ioc.demo05"/>

Anotação do feijão da entidade

 @RepositoryPublic Class User {private IDEI ID = 1; String privada nome de usuário = "injeção de anotação"; private string senha = "233"; public user () {super ();} public user (Integer ID, string username, string senha) {); String getUserName () {return userName;} public string getPassword () {return senha;} public void setId (integer id) {this.id = id;} public void setUserName (string userName) {this.userName = username;} public void SetPassword (string senha) {this.

Anotação de código de teste

 /** Injetar atributos usando anotações*/@Service ("ioc_by_annotation") public class ioc_by_annotation {@Resource Usuário privado Usuário; public void setUser (usuário do usuário) {this.User = User = User;}/** Verifique se a injeção é bem -sucedida*/public boolean {) {se {System.out.println ("User:" + user.getId () + "|" + user.getUserName () + "|" + user.getpassword ());} System.out.println ("Correto !!!"); retorna true;}}}}

Código de teste

 public class ioc_test {private ApplicationContext ctx; @EBe Public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@Test public void annotationTest () {{ioc_by_by_by_by " ctx.getbean ("ioc_by_annotation"); ioc.checkattr ();}}

Saída do console

Após o teste, usando injeção de anotação. Se o ApplicationContext.xml estiver configurado com outros métodos de injeção, será relatado um erro, o que também fará com que outros métodos de injeção sejam anormais.

 Usuário: 1 | Injeção de anotação | 233 está correto! ! !

6. Injeção de feijão configurando o método de fábrica estática

Código de fábrica estática

 /** Fábrica estática*/public class StaticFactory {public static integer getId () {return 1;} public static string getName () {return "estática fábrica";} user estático public getUser () {retorna um novo usuário (1, "usuário fábrica", "666");}}}}

Código da classe de teste

 /** Injeção por meio de fábrica estática*/public classe ioc_by_staticFactory {ID inteiro privado; nome de string privada; usuário privado do usuário;/** verifique se a injeção é bem -sucedida*/public boolean checkAtTr () {if (id == null) {return); id);}System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nome);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void SetName (nome da string) {this.name = name;} public void setUser (usuário do usuário) {this.user = user;}}

ApplicationContext.xml Configuração

 <!-Configurando o método de fábrica estática Bean está realmente configurando o valor retornado pelo método da fábrica como um feijão-> <bean id = "factory_id" factory-method = "getId"/> <bean id = "factory_name" fábrica "Method =" getName "/> <bEan =" "fábrica" " id = "ioc_by_staticfactory"> <propriedade name = "id" ref = "factory_id"/> <propriedade name = "name" ref = "factory_name"/> <names name = "user" ref = "factory_user"/> </bean>

Código de teste

 public class ioc_test {private ApplicationContext ctx; @Before public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@teste public void staticTerTEst () {ioc_by_by_by "); ctx.getbean ("ioc_by_staticfactory"); ioc.checkattr ();}}

Resultados de saída do console

 ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !

7. Injeção através do exemplo de método de fábrica

A diferença de uma fábrica estática é que a fábrica de instância não é estática. Você precisa primeiro novo objeto de fábrica de instância antes de configurar seu método. O novo objeto também é gerenciado pela primavera.

Código da fábrica

 /** Factory da instância*/public class Factory {public integer getId () {return 1;} public string getName () {return

Código da classe de teste

 /** Injeção de fábrica da instância*/classe pública ioc_by_factory {ID inteiro privado; nome de string privada; usuário privado usuário;/** Verifique se a injeção é bem -sucedida*/public boolean checkAtTr () {if (id == null) {return false;} else {System.out.println ("id:" +) id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nome);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void SetName (nome da string) {this.name = name;} public void setUser (usuário do usuário) {this.user = user;}}

ApplicationContext.xml Configuração

 <!-Configure o feijão da fábrica da instância-> <bean id = "fábrica"/> <!-Configure o método da fábrica da instância Bean-> <bean id = "f_id" factory-bean = "fábrica" fábrica/"fábrica" "fábrica"/> <bean id = "f_name" "e" BEAN "BENSTENTE") Factory-Bean = "Factory" Factory-Method = "GetUser"/> <!-Injete o método de fábrica de instância correspondente Bean-> <Bean id = "ioc_by_factory"> <names name = "id" ref = "f_id"/> <nome da propriedade "Nome" Ref = "Fer"///> <ween> "User"/>

Código da classe de teste

 public class ioc_test {private ApplicationContext ctx; @Be antes public void load () {// Leia o arquivo de configuração ApplicationContext.xml ctx = new ClassPathXMLApplicationContext ("ApplicationContext.xml");}@Test Void FactoryTest () {IOC__FACTER ctx.getbean ("ioc_by_factory"); ioc.checkattr ();}}

Saída do console

 ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !

Resumir

O exposto acima é tudo sobre a breve discussão deste artigo sobre o método de injeção do COI da mola e a injeção de diferentes tipos de dados. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!