Injeção de dependência de mecanismo central do Spring

introdução

       No artigo anterior, seguimos como usar a ideia para criar o primeiro Spring.No artigo, Pessoa e Axe têm dependências! Então, como o Spring gerencia o relacionamento entre eles! !

Funções básicas do Spring

• Como uma super fábrica, o container Spring é responsável por criar e gerenciar todos os objetos Java.Estes objetos Java são chamados de Beans.
• O contêiner Spring gerencia as dependências entre os beans no contêiner.O Spring usa um método chamado "injeção de dependência" para gerenciar as dependências entre os beans.

Essência da primavera

       A essência do Spring: direcionar o código Java por meio da configuração XML. Familiarizado com Spring: Quase todo código Java é colocado em XML para configuração. Requisitos: A configuração XML que você vê em seus olhos, o que você pensa em sua mente é o código Java executado.
       Elemento bean: o driver usa new para chamar o construtor. Por padrão, ele sempre chama o construtor sem parâmetros. Se você deseja controlá-lo para chamar um construtor com parâmetros, você precisa adicionar um
              subelemento <constructor-arg ... /> no elemento <bean ... /> , cada um dos quais representa um parâmetro do construtor.
              O valor especificado pelo atributo value no elemento filho <constructor-arg ... /> será tratado como String primeiro. Para especificar explicitamente o tipo do valor, você pode especificar o atributo type.
       elemento de propriedade: direcione-o para chamar o método setter. Depois que o objeto for criado, ele será chamado imediatamente.
       O elemento constructor-arg: O driver chama o construtor com parâmetros.

Injeção de dependência

IOC e injeção de dependência

       Os dois são duas expressões do mesmo comportamento, mas o ângulo de descrição é diferente! O IOC começa do ponto de vista do chamador. O chamador não precisa tomar a iniciativa de obter o objeto dependente, mas é automaticamente atribuído a ele pelo recipiente Spring. Portanto, o chamador mudou de obter ativamente o objeto dependente para aceitar passivamente. A injeção de dependência ocorre da perspectiva do contêiner Spring, que é responsável por atribuir objetos dependentes a variáveis ​​de membro do chamador.

Método para realizar '

A injeção de dependência pode ser dividida em três tipos:

• Injeção de interface. raramente use.
• Injeção de valor de configuração: É para chamar o método setter através do controle do elemento de propriedade, que é a chamada injeção de valor de configuração.
• Injeção de construtor: Constructor-arg controla para chamar o construtor parametrizado, e o construtor injeta o componente dependente.

Injeção de setpoint

public interface Person {
    
    
    //定义一个使用斧头的方法
    public void useAxe();
}

public interface Axe {
    
    
    //Axe接口中定义一个chop()方法
    public String chop();
}

public class Chinese implements Person {
    
    
    private Axe axe;
    public void setAxe(Axe axe ){
    
    
        this.axe=axe;
    }
    @Override
    public void useAxe(){
    
    
        System.out.println(axe.chop());
    }
}

public class StoneAxe implements Axe{
    
    
    @Override
    public String chop(){
    
    
        return "石斧砍柴好慢";
    }
}

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!-- 配置名为person的Bean，其实现类是org.crazyit.app.service.Person类 -->
    <bean id="chinese" class="Chinese">
        <!-- 控制调用setAxe()方法，将容器中axe Bean作为传入参数 -->
        <property name="axe" ref="stoneAxe"/>
    </bean>
    <!-- 配置名为axe的Bean，其实现类是org.crazyit.app.service.Axe类 -->
    <bean id="stoneAxe" class="StoneAxe"/>
    <!-- 配置名为win的Bean，其实现类是javax.swing.JFrame类 -->
    <bean id="win" class="javax.swing.JFrame"/>
    <!-- 配置名为date的Bean，其实现类是java.util.Date类 -->
    <bean id="date" class="java.util.Date"/>
</beans>

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanTest {
    
    
    public static void main(String[] args)throws Exception
    {
    
    
        // 创建Spring容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
        // 获取id为person的Bean
        Person p = ctx.getBean("chinese" , Person.class);
        // 调用useAxe()方法
        p.useAxe();
    }
}

Três pontos básicos de uso do contêiner Spring IoC

• Os componentes do programa de aplicação são orientados à interface. A programação orientada à interface pode promover o relacionamento refinado entre os componentes para o nível da interface, o que conduz à expansão posterior do projeto.
• Os componentes do aplicativo não são mais criados ativamente pelo programa, mas são gerados e inicializados pelo contêiner Spring.
• Spring usa arquivos de configuração ou anotações para gerenciar as classes de implementação e dependências de Beans. O contêiner Spring usa reflexão para criar instâncias baseadas em arquivos de configuração ou anotações e injeta dependências neles.

Injeção de construção

public class Chinese implements Person {
    
    
    private Axe axe;
    public Chinese(Axe axe){
    
    
        this.axe=axe;
    }
    @Override
    public void useAxe(){
    
    
        System.out.println(axe.chop());
    }
}

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
    <!-- 配置名为person的Bean，其实现类是org.crazyit.app.service.Person类 -->
    <bean id="chinese" class="Chinese">
       <constructor-arg ref="stoneAxe"/>
    </bean>
    <!-- 配置名为axe的Bean，其实现类是org.crazyit.app.service.Axe类 -->
    <bean id="stoneAxe" class="StoneAxe"/>
    <!-- 配置名为win的Bean，其实现类是javax.swing.JFrame类 -->
    <bean id="win" class="javax.swing.JFrame"/>
    <!-- 配置名为date的Bean，其实现类是java.util.Date类 -->
    <bean id="date" class="java.util.Date"/>
</beans>

A diferença entre os dois

A diferença é: o tempo de criação da propriedade Ax na instância de Person é diferente. A injeção de configuração é primeiro criar uma instância de Bean por meio do construtor sem parâmetros e, em seguida, chamar o método setter correspondente para injetar a dependência: enquanto a injeção de construção diretamente chama o construtor parametrizado Depois que a instância Bean é criada, a injeção de dependência foi concluída.