Spring 基于注解配置&装配Bean

该篇博客主要阐述使用注解来配置Bean以及装配Bean(Bean与Bean之间关联关系)，通过注解可以大大减少使用XML一大堆的配置代码，方便开发

注意：该篇博客阅读时必须理解清楚什么是配置Bean什么是装配Bean
- 配置Bean：将Bean装载到IoC容器中(注册)
- 装配Bean：Bean与Bean之间的依赖注入

博客主要阐述

1、基于注解配置Bean

2、基于注解装配Bean

---

一、基于注解配置Bean

作用：就是将Bean装到IoC容器中

1、为自动检测标注Bean

Spring能从classpath下自动扫描、侦测、实例化具有特定注解的组件，这些特定注解的组件如下

• @Component——通用的构造型注解
• @Controller——标识控制层(web层)
• @Repository——标识持久层(Dao层)
• @Service——标识业务层(Service层)

在目前的Spring版本中，@Controller、@Repository、@Service这三个注解与@Component基本等效，可以混用，但是从命名上可以看出三个注解分别代表哪一层。所以虽然目前三个注解与@Component是等效的，但Spring之后版本或许会为这三个注解带来不一样的新意，所以最好是使用这三个注解来标注每一个层

2、Component用法

Person.java

package com.linjie.springidol;

import org.springframework.stereotype.Component;

/**
 * @author LinJie
 * Component用法
 */
@Component("person")
public class Person {
    public void add(Person p) {
        System.out.println("Person.....");
    }
}

测试类

package com.linjie.springidol;

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

/**
 * @author LinJie
 *
 */
public class SpringTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
        person.add(person);
    }
}

applicationContext.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"
    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 definitions here -->

            <!--base-package:指定Spring IoC容器 扫描的包  -->
         <context:component-scan base-package="com.linjie.springidol">
         </context:component-scan>

</beans>

结果

运行的结果就很清楚了，@Component为我们完成了Bean的注册和装配，我们就不再需要使用XML中的< bean>元素了。其实就相当于

<bean id="person" class="com.linjie.springidol.Person">

1、在applicationContext我们只需要用：

<context:component-scan base-package="com.linjie.springidol"></context:component-scan>

就能够使用注解了，假如你无法实现的话，可能是你未导入spring-aop-4.3.10.RELEASE.jar 具体原因可转战笔者这篇博客：https://blog.youkuaiyun.com/w_linux/article/details/80098853

2、要注意需要在applicationContext中引用context约束，如果你没有相关插件引入可以用以下方法将context约束模板引入

进入该路径spring-framework-4.3.10.RELEASE-dist\spring-framework-4.3.10.RELEASE\docs\spring-framework-reference\html，找到xsd-configuration.html，搜索the context schema，将模板导入到自己的applicationContext.xml中即可

3、base-package：指定一个需要扫描的父类包，Spring容器将会扫描这个父类包及其子类包中的所有类，当需要扫描多个包(没有继承关系)时，可以使用逗号分隔

4、@Component所标注的Person类，如果不像上面例子中@Component(“person”)，而只是@Component，其Bean的ID默认为无限定类名，即首字母小写。Person Bean的ID就是person，当然显示命名ID即@Component(“person”)

5、resource-pattern只扫描指定的类而非基包下的所有类，这里dao是springidol的子包

<context:component-scan
         base-package="com.linjie.springidol"
         resource-pattern="dao/*.class"
         ></context:component-scan>

6、context:component-scan的两个子节点

• context:exclude-filter：子节点指定排除哪些指定表达式的组件（排除）

• context:include-filter：子节点指定包含哪些表达式的组件 （只包含），该子节点需要use-default-filters=”false”配合使用

   <context:component-scan
   base-package="com.linjie.springidol">
   <context:exclude-filter type="annotation"
       expression="org.springframework.stereotype.Service"/> 
        <!--<context:include-filter type="annotation"
           expression="org.springframework.stereotype.Service"/> -->  
   </context:component-scan>
  

type属性值：

7、一个简单例子

项目目录(一个父包三个子包)

UserView.java(Controller)

package com.linjie.springidol.view;

import org.springframework.stereotype.Controller;

/**
 * @author LinJie
 * View层
 */
@Controller
public class UserView {
    public void show() {
        System.out.println("view1...");
    }
}

UserService.java(Service)

package com.linjie.springidol.service;
import org.springframework.stereotype.Service;
/**
 * @author LinJie
 * Service层
 */
@Service
public class UserService {
    public void show() {
        System.out.println("service....");
    }
}

UserDao.java(Repository)

package com.linjie.springidol.dao;

import org.springframework.stereotype.Repository;

/**
 * @author LinJie
 * Dao层
 */
@Repository
public class UserDao {
    public void show() {
        System.out.println("dao...");
    }
}

Person.java(Component)

package com.linjie.springidol;

import org.springframework.stereotype.Component;

/**
 * @author LinJie
 * Component用法
 */
@Component("person")
public class Person {
    public void show() {
        System.out.println("Person.....");
    }
}

applicationContext.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"
    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 definitions here -->


         <context:component-scan
         base-package="com.linjie.springidol">

         </context:component-scan>


</beans>

测试类

package com.linjie.springidol;

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

import com.linjie.springidol.dao.UserDao;
import com.linjie.springidol.service.UserService;
import com.linjie.springidol.view.UserView;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        person.show();

        UserDao userDao = (UserDao) context.getBean("userDao");
        userDao.show();

        UserService userService = (UserService) context.getBean("userService");
        userService.show();

        UserView userView = (UserView) context.getBean("userView");
        userView.show();
    }
}

结果

---

二、基于注解装配Bean

作用：Bean与Bean之间的关联关系建立（前提：已经装配Bean到IoC容器中）

元素会自动注册AutowiredAnnotationBeanPostProcessor实例（一个Bean后置处理器），该实例可以自动装配具有@Autowired、@Resource、@Inject注解的属性

Autowired

1. @Autowired注解自动装配具有兼容类型的单个Bean属性

2. 构造器、普通字段(访问控制符没有影响)、一切具有参数的方法都可以应用

普通字段：在UserService中调用UserDao

UserService.java

package com.linjie.springidol.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.linjie.springidol.dao.UserDao;
/**
 * @author LinJie
 * Service层
 */
@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void show() {
        System.out.println("service....");
        userDao.show();
    }
}

构造器：在UserService中调用UserDao

package com.linjie.springidol.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.linjie.springidol.dao.UserDao;
/**
 * @author LinJie
 * Service层
 */
@Service
public class UserService {

    private UserDao userDao;

    @Autowired
    public UserService(UserDao userDao) {
        super();
        this.userDao = userDao;
    }


    public void show() {
        System.out.println("service....");
        userDao.show();
    }
}

有参数的方法上：在UserService中调用UserDao

package com.linjie.springidol.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.linjie.springidol.dao.UserDao;
/**
 * @author LinJie
 * Service层
 */
@Service
public class UserService {

    private UserDao userDao;

    @Autowired
    public void setUserService(UserDao userDao) {
        this.userDao = userDao;
    }


    public void show() {
        System.out.println("service....");
        userDao.show();
    }
}

3. 加上@Autowired意思就是会去IoC容器里找是否有与其被注解的Bean类型兼容的Bean（通过@Component等注册Bean的注解所装饰的才会在IoC容器里）

4. 所有使用@Autowired注解的属性都需要被设置(即通过@Component等注解配置到IoC容器中)，否则会报异常，如果没有配置这个Bean,可以设置@Autowired注解的required属性为false，但该Bean就是null：@Autowired(required=false),但是注意当使用构造器装配时，只有一个构造器可以将@Autowired的required属性设置为true。其他使用@Autowired注解所标注的构造器只能将required属性设置为false，当使用@Autowired标注多个构造器时，Spring就会从所有满足装配条件构造器中选择入参最多的那个构造器

UserDao未被配置
若此时调用UserDao则报错

 org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.linjie.springidol.dao.UserDao' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {}

使用@Autowired(required=false)

package com.linjie.springidol.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.linjie.springidol.dao.UserDao;
/**
 * @author LinJie
 * Service层
 */
@Service
public class UserService {

    private UserDao userDao;

    @Autowired(required=false)
    public void setUserService(UserDao userDao) {
        this.userDao = userDao;
    }


    public void show() {
        System.out.println("service....");
        System.out.println("userDao :"+userDao);
        userDao.show();
    }
}

显示结果(无法实现调用show()，因为userDao为null)

5. 限定歧义性的依赖：可能会有多个Bean都满足装配条件，并且都可以装配到属性或参数中(采用@Qualifier)

场景

假设有两个Bean都实现了Instrument接口

分析

在这种场景下，@Autowired注解没办法选择哪一个Bean才是它需要的

解决

采用Spring的@Qualifier

用法

public void setInstrument(@Qualifier("small1")Instrument instrument){}

或者

@Qualifier("small1")
public void setInstrument(Instrument instrument) {}

代码演示

Instrument.java(接口)

package com.linjie.springidol;

public interface Instrument {
    public void play();
}

small1.java（实现类1）

package com.linjie.springidol;

import org.springframework.stereotype.Component;

@Component
public class small1 implements Instrument{

    @Override
    public void play() {
        System.out.println("small1");
    }

}

small2.java（实现类2）

package com.linjie.springidol;

import org.springframework.stereotype.Component;

@Component
public class small2 implements Instrument{

    @Override
    public void play() {
        System.out.println("small2");
    }

}

big.java（调用IoC中的Bean）

package com.linjie.springidol;

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

@Component("b")
public class big {
    private Instrument instrument;

    @Autowired
    public void setInstrument(@Qualifier("small1")Instrument instrument) {
        this.instrument = instrument;
    }

    public void show() {
        System.out.println(instrument);
        instrument.play();
    }
}

测试类

package com.linjie.springidol;

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

import com.linjie.springidol.dao.UserDao;
import com.linjie.springidol.service.UserService;
import com.linjie.springidol.view.UserView;

public class SpringTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        big b = (big) context.getBean("b");
        b.show();
    }
}

结果(可以看到通过Qualifier来指定使用small1 Bean)

6、@Autowired可以应用在数组类型的属性上，此时Spring将会把所有匹配的Bean都进行自动装配

7、@Autowired可以应用在集合属性上，此时Spring读取集合的类型信息，然后自动装配所有与之兼容的Bean

8、@Autowired用在java.util.Map上，若Map的键值为String，那么Spring将自动装配与之Map值类型兼容的Bean，此时Bean的名称作为键值

9、关于@Resource、@Inject与@Autowired相类似，所以不多做阐述

---

参考

《Spring IN ACTION》