spring注入对象的几种方式

短命女 2022-10-30 13:27 255阅读 0赞

## 写在前面 ##

spring通过IOC容器帮我们管理了对象，但是管理的这些对象，当我们需要其中一个或者是多个的时候应该怎么样获取呢，这就和对象注入有关系了，通过注入，我们可以从spring容器中反向被动的获取对象，然后就可以使用这些对象的能力来完成我们的任务了。

## 1：setter方法注入 ##

其实就是属性值入。

### 1.1：定义注入的类 ###

public class MyDao { 
    }

### 1.2：定义被注入的类 ###

public class MyAction { 
        private MyDao myDao;
    
        public MyDao getMyDao() { 
            return myDao;
        }
    
        public void setMyDao(MyDao myDao) { 
            this.myDao = myDao;
        }
    }

### 1.3：定义xml ###

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="myDao" class="yudaosourcecode.spring.MyDao"/>
        <bean id="myAction" class="yudaosourcecode.spring.MyAction">
            <property name="myDao" ref="myDao"/>
        </bean>
    </beans>

### 1.4：测试 ###

@Test
    public void testDiBySetter() { 
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        MyAction myAction = ac.getBean("myAction", MyAction.class);
        System.out.println("myAction.getMyDao(): ");
        System.out.println(myAction.getMyDao());
    }

运行：

myAction.getMyDao(): 
    yudaosourcecode.spring.MyDao@75881071

## 2：构造器注入 ##

### 2.1：定义注入的类 ###

public class DiPerson { 
    }
    public class DiUser { 
    }

### 2.2：定义被注入的类 ###

public class ConstructorDi { 
        public DiPerson diPerson;
        public DiUser diUser;
    
        public ConstructorDi(DiPerson diPerson, DiUser diUser) { 
            this.diPerson = diPerson;
            this.diUser = diUser;
        }
    }

注意其中的`private DiPerson diPerson`和`private DiUser diUser`我们没有定义读写方法。

### 2.3：定义xml ###

<beanid="myPerson" class="yudaosourcecode.spring.DiPerson"/>
    <bean id="myUser" class="yudaosourcecode.spring.DiUser"/>
    <bean id="constructorDi" class="yudaosourcecode.spring.ConstructorDi">
        
        <constructor-arg index="0" ref="myPerson"/>
        <constructor-arg index="1" ref="myUser"/>
    </bean>

### 2.4：测试 ###

@Test
    public void diByConstructorTest() { 
        ClassPathXmlApplicationContext ac
                = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        ConstructorDi constructorDi = ac.getBean("constructorDi", ConstructorDi.class);
        System.out.println("constructorDi.diPerson is: ");
        System.out.println(constructorDi.diPerson);
        System.out.println("constructorDi.diUser is: ");
        System.out.println(constructorDi.diUser);
    }

输出：

constructorDi.diPerson is: 
    yudaosourcecode.spring.DiPerson@7403c468
    constructorDi.diUser is: 
    yudaosourcecode.spring.DiUser@43738a82
    
    Process finished with exit code 0

## 3：静态工厂方法注入 ##

这种方式其实是调用调用某个类的静态方法来获取需要需要的对象来进行注入。

### 3.1：定义注入的类 ###

public class DiPerson { 
    }

### 3.2：定义静态工厂类 ###

该静态工厂类提供静态方法返回`DiPerson`对象：

public class StaticFactoryCls { 
    
        public static final DiPerson generatePersonDi() { 
            return new DiPerson();
        }
    }

### 3.3：定义被注入的类 ###

public class StaticFactoryMethodDi { 
        private DiPerson diPerson;
    
        public DiPerson getDiPerson() { 
            return diPerson;
        }
    
        public void setDiPerson(DiPerson diPerson) { 
            this.diPerson = diPerson;
        }
    }

### 3.4：定义xml ###

<bean id="staticFactoryDiPerson" class="yudaosourcecode.spring.StaticFactoryCls" factory-method="generatePersonDi"/>
    <bean id="staticFactoryMethodDi" class="yudaosourcecode.spring.StaticFactoryMethodDi">
        <property name="diPerson" ref="staticFactoryDiPerson"/>
    </bean>

### 3.5：测试 ###

staticFactoryMethodDi.getDiPerson() is: 
    yudaosourcecode.spring.DiPerson@67b467e9
    
    Process finished with exit code 0

## 4：实例工厂方法注入 ##

这种方式和静态工厂方法注入的唯一区别就是生成对象的方法是实例方法，而不是静态方法。

### 4.1：定义注入的类 ###

public class DiPerson { 
    }

### 4.2：定义实例工厂类 ###

public class InstanceFactoryCls { 
        public DiPerson generatePersonDi() { 
            return new DiPerson();
        }
    }

注意这里的方法是实例方法，而不是静态方法了。

### 4.3：定义被注入的类 ###

public class InstanceFactoryMethodDi { 
        private DiPerson diPerson;
        public DiPerson getDiPerson() { 
            return diPerson;
        }
    
        public void setDiPerson(DiPerson diPerson) { 
            this.diPerson = diPerson;
        }
    
    }

### 4.4：定义xml ###

<bean id="instanceFactoryCls" class="yudaosourcecode.spring.InstanceFactoryCls"/>
    
    <bean id="instanceFactoryDiPerson"
          factory-bean="instanceFactoryCls"
          factory-method="generatePersonDi"/>
    <bean id="instanceFactoryMethodDi" class="yudaosourcecode.spring.InstanceFactoryMethodDi">
        <property name="diPerson" ref="instanceFactoryDiPerson"/>
    </bean>

### 4.5：测试 ###

@Test
    public void diByInstanceFactoryTest() { 
        ClassPathXmlApplicationContext ac
                = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        InstanceFactoryMethodDi instanceFactoryMethodDi = ac.getBean("instanceFactoryMethodDi", InstanceFactoryMethodDi.class);
        System.out.println("instanceFactoryMethodDi.getDiPerson() is: ");
        System.out.println(instanceFactoryMethodDi.getDiPerson());
    }

运行：

instanceFactoryMethodDi.getDiPerson() is: 
    yudaosourcecode.spring.DiPerson@5c072e3f
    
    Process finished with exit code 0