Spring Framework提供了以下几种依赖查找Bean的方式
1. 按名称进行查找
按id和name查找都归属于此。具体的又会分为直接查找与间接查找的方式。
1.1 直接查找
以xml为例，新建父Maven项目工程，pom依赖如下：
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.version>5.2.2.RELEASE</spring.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
新建子module工程，便于代码管理，依赖如下：
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
</dependencies>
定义模型对象User，内容如下：
public class User {
private Long id;
private String name;
// Getter、Setter方法略
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
在resources目录下新建META-INF/spring-ioc-overview.xml文件，定义User对象。内容如下：
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.vielat.spring.ioc.domain.User">
<property name="id" value="1" />
<property name="name" value="Michael" />
</bean>
</beans>
依赖查找测试类如下：
public class DependencyLookupDemo {
public static void main(String[] args) {
BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/spring-ioc-overview.xml");
lookupByName(beanFactory);
}
private static void lookupByName(BeanFactory beanFactory) {
User user = (User) beanFactory.getBean("user");
System.out.println("直接查找：" + user);
}
}
1.2 间接查找
间接查找也被称之为延迟查找，不是直接通过查找目标对象的方式获取Bean，而是通过ObjectFactory进行获取。
在META-INF/spring-ioc-overview.xml文件中新增如下配置：
...
<bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
<property name="targetBeanName" value="user" />
</bean>
测试类代码如下：
private static void lookupByObjectFactory(BeanFactory beanFactory) {
ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
User user = objectFactory.getObject();
System.out.println("间接查找：" + user);
}
2.按类型进行查找
从Spring 3.0开始，支持JDK 5，而JDK 5引入了泛型的概念，因此可以直接传入Class
2.1 查找单个对象
private static void lookupByType(BeanFactory beanFactory){
User user = beanFactory.getBean(User.class);
System.out.println("直接查找：" + user);
}
2.2 查找集合对象
private static void lookupCollectionByType(BeanFactory beanFactory) {
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String, User> userMap = listableBeanFactory.getBeansOfType(User.class);
System.out.println("查找到的集合对象：" + userMap);
}
}
2.3 间接（延迟）查找
在BeanFactory中直接提供了一种获取ObjectProvider对象的方式，如下：
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
ObjectProvider也是一个接口，提供了getObject()方法。通过此种方式获取User对象，
private static void lookupByObjectProvider(BeanFactory beanFactory) {
ObjectFactory<User> objectFactory = beanFactory.getBeanProvider(User.class);
System.out.println("ObjectFactory:" + objectFactory);
System.out.println(objectFactory.getObject());
}
运行后结果如下：
ObjectFactory:org.springframework.beans.factory.support.DefaultListableBeanFactory$1@7791a895
User{id=1, name='Michael'}
3. 结合名称和类型进行查询
在BeanFactory接口中提供了此种查找Bean的方式，如下：
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
案例略
4. 根据注解的方式进行查询
在ListableBeanFactory接口中提供了getBeansWithAnnotation()方法。案例如下：
定义的注解如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Candidate {
}
新增一个实体类AdminUser
public class AdminUser extends User {
private String address;
// Getter、Setter方法略
@Override
public String toString() {
return "AdminUser{" +
"address='" + address + '\'' +
"} " + super.toString();
}
}
在META-INF/spring-ioc-overview.xml配置文件中新增此类配置
<bean id="adminUser" class="com.vielat.spring.ioc.domain.AdminUser" parent="user">
<property name="address" value="广州"/>
</bean>
在根据类型获取当个对象时，就会报错：
Exception in thread "main" org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.vielat.spring.ioc.domain.User' available: expected single matching bean but found 2: user,adminUser
at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveNamedBean(DefaultListableBeanFactory.java:1180)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveBean(DefaultListableBeanFactory.java:416)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:349)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:342)
at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1126)
at com.vielat.spring.ioc.overview.DependencyLookupDemo.lookupByType(DependencyLookupDemo.java:43)
一种做法就是在其中一个Bean的配置上加primary="true"的配置；一种就是在对象上增加注解，通过注解的方式来获取：
增加配置的方式：
<bean id="adminUser" class="com.vielat.spring.ioc.domain.AdminUser" parent="user" primary="true">
<property name="address" value="广州"/>
</bean>
增加注解
@Candidate
public class AdminUser extends User {
......
}
测试类如下：
private static void lookupByAnnotation(BeanFactory beanFactory){
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String,Object> beanMap = listableBeanFactory.getBeansWithAnnotation(Candidate.class);
System.out.println("根据注解查找：" + beanMap);
}
}