Spring 三种不同的装配方式。set注入、构造器注入与自动装配

一、Spring的第一种注入方式，是使用property这个标签配合Bean类属性的set方法进行注入，代码如下：

为了测试我创建了一个maven项目，并且在pom.xml中引入了以下依赖包：（日志系统不需要使用到）

    <dependencies>
        <!--springframewok模板-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <!--日志系统-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--测试-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <!--junit单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

在java包下创建一个包，这里我创建的是com.zm.a,再创建两个测试类a1类和a2类，（这里的构造方法不写的话在构造器注入那里会报错）代码如下

package com.zm.a;


public class a1 {
    public a1() {
        super();
        System.out.println("a1的无参构造方法");
    }

    private a2 a2;

　　//使用set方法配合xml的property标签进行注入装配
    public void setA2(com.zm.a.a2 a2) {
        this.a2 = a2;
    }
　　
    public void play(){
        System.out.println("a1的play方法");
        a2.play();
    }
}

package com.zm.a;

public class a2 {
    public a2() {
        super();
        System.out.println("a2的无参构造方法");
    }

    public void play(){
        System.out.println("a2的play()方法");
    }
}

在resources包下创建一个applicationContext.xml的配置文件

下面是set方法注入的xml的配置，把a2注入到a1中，set方法和构造器的注入使用配置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="a1" class="com.zm.a.a1">
                <property name="a2" ref="a2"></property>
        </bean>
        <bean id="a2" class="com.zm.a.a2"></bean>
</beans>

最后我们在test下的java包下创建一个com.zm.a的包，并且创建一个测试类进行单元测试，代码如下：

package com.zm.a;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestA {

  
    @Autowired
    private a1 a1;

    @Test
    public void test(){
        a1.play();
    }
}

第二种方法：使用构造器配合constructor-arg进行注入，只需要修改a1和a2类还有xml的代码，如下

package com.zm.a;


public class a1 {
    public a1() {
        super();
        System.out.println("a1的无参构造方法");
    }

    private a2 a2;

    //使用构造器配合xml的constructor-arg进行注入装配
    public a1(com.zm.a.a2 a2) {
        this.a2 = a2;
    }

    public void play(){
        System.out.println("a1的play方法");
        a2.play();
    }
}

package com.zm.a;

public class a2 {
    public a2() {
        super();
        System.out.println("a2的无参构造方法");
    }

    public void play(){
        System.out.println("a2的play()方法");
    }
}

<?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="a1" class="com.zm.a.a1">
                <constructor-arg ref="a2"></constructor-arg>
        </bean>
        <bean id="a2" class="com.zm.a.a2"></bean>
</beans>

第三种方法，使用注解实现自动注入装配，代码如下：

package com.zm.a;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class a1 {
    public a1() {
        super();
        System.out.println("a1的无参构造方法");
    }
    @Autowired
    private a2 a2;

    public void play(){
        System.out.println("a1的play方法");
        a2.play();
    }
}

package com.zm.a;

import org.springframework.stereotype.Component;

@Component
public class a2 {
    public a2() {
        super();
        System.out.println("a2的无参构造方法");
    }

    public void play(){
        System.out.println("a2的play()方法");
    }
}

package com.zm.a;
import config.AppConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class TestA {


    @Autowired
    private a1 a1;

    @Test
    public void test(){
        a1.play();
    }
}

因为不使用xml配置bean，所以需要一个容器类，我们在com.zm.config包下创建一个AppConfig类，然后通过扫描指定包下的组件进行注入装配，
这里使用的是com.zm.a，所以指定了com.zm.a包

package config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.zm.a")
public class AppConfig {
}

构造器注入和set注入还可以在xml中导入p,c命名空间简化代码，具体怎么实现我也不写了

当然我是为了简单测试一下才没有使用分层结构，在实际开发中，比如dao下的接口的实现类会出现多个，这个时候需要涉及到

@Primary@Qualifier@Resource这些注解了，这些注解主要是指定需要装配的类。看不懂就算了。