【Spring源码分析】6、Spring Bean 以及组件常见注册方式案例分析

爱被打了一巴掌 2022-12-01 14:23 136阅读 0赞

### 文章目录 ###

*  1、Spring给容器中注册组件
 *  2、@Configuration和@Bean
 *  3、@ComponentScan
 *   *   *  （1）@ComponentScan扫描组件
         *  （2）@ComponentScan排除扫描组件
         *  （3）@ComponentScan指定扫描组件
         *  （4）FilterType的分类
         *  （5）FilterType自定义规则
 *  4、@Conditional
 *   *   *  （1）@Conditional条件注册bean
         *  （2）@Conditional作用在类上
 *  5、@Import
 *   *   *  （1）@Import快速导入组件
         *  （2）@Import的ImportSelector
         *  （3）@Import的ImportBeanDefinitionRegistrar
 *  6、使用FactoryBean注册组件
 *  7、@Scope设置组件作用域
 *   *   *  （1）@Scope的四种类型
         *  （2）@Scope使用案例
 *  8、@Lazy注解实现懒加载
 *  9、更多细节学习
 *  微信公众号

# 1、Spring给容器中注册组件 #

Spring 给容器中注册组件是也算spring核心的内容，通常情况下，我们最常见的是@Controller，@Service，@Repository等注解，实际上这些注解的作用，就是将对应类型的bean或组件注入到spring容器中，也就是交给spring容器管理，下面我们分析常见的bean或者组件注入方式

# 2、@Configuration和@Bean #

@Configuration表明一个类申明一个或多个bean组件，然后将这些bean交给spring管理，通常情况下是和@Bean注解一起使用的。@Configuration标注的类，我们可以理解为配置类（实际上等同于配置文件），下面这个示例定义了一个配置类，然后注入一个User的bean

package cn.tellsea.springbean.register;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class User { 
    
    	private String name;
    
    	private int age;
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public int getAge() { 
    		return age;
    	}
    
    	public void setAge(int age) { 
    		this.age = age;
    	}
    
    	@Override
    	public String toString() { 
    		return "User{" +
    				"name='" + name + '\'' +
    				", age=" + age +
    				'}';
    	}
    }

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class MyConfig { 
    	
    	@Bean
    	public User user() { 
    		User user = new User();
    		user.setName("Tellsea");
    		user.setAge(21);
    		return user;
    	}
    }

测试类测试一下这个User的bean是否能拿到

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class TestMain { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    		User user = applicationContext.getBean(User.class);
    		System.out.println(user);
    	}
    }

如果是配置文件的形式就是，相应的测试类使用ClassPathXmlApplicationContext获取applicationContent对象即可

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    	<bean id="user" class="cn.tellsea.springbean.register.User">
    		<property name="name" value="Tellsea"></property>
    		<property name="age" value="21"></property>
    	</bean>
    </beans>

我们使用注解注入Bean的时候，实际上默认有id的，就是当前方法的名称，这里的id对应的就是bean标签中的id，@Bean想要指定id的话，直接使用value属性修改即可，`@Bean(value = "user1")`

# 3、@ComponentScan #

@ComponentScan 能自动扫描组件和指定扫描规则，一次性通过指定的路径，扫描多个组件提供给spring进行管理

### （1）@ComponentScan扫描组件 ###

开发中最常见的就是UserController，UserService，UserDao，三个类都被标明为组件，我们这里就可以使用@ComponentScan指定包路径进行扫描加载

package cn.tellsea.springbean.register;
    
    import org.springframework.stereotype.Controller;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Controller
    public class UserController { 
    }

package cn.tellsea.springbean.register;
    
    import org.springframework.stereotype.Service;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Service
    public class UserService { 
    }

package cn.tellsea.springbean.register;
    
    import org.springframework.stereotype.Repository;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Repository
    public class UserDao { 
    }

扫描配置类

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class MyConfig { 
    
    	@Bean
    	public User user() { 
    		User user = new User();
    		user.setName("Tellsea");
    		user.setAge(21);
    		return user;
    	}
    }

测试类

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class TestMain { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    		String[] definitionNames = applicationContext.getBeanDefinitionNames();
    		for (String name : definitionNames) { 
    			System.out.println(name);
    		}
    	}
    }

测试结果分析

扫描配置类myConfig本身也被加载成了组件，扫描规则下的各个组件也被加载到了spring容器中

### （2）@ComponentScan排除扫描组件 ###

查看@ComponentScan源码可以知道，使用excludeFilters()方法可以具体排除扫描哪些类

下面的测试类，**扫描规则是排除扫描带有@Controller和@Service的类**

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScan.Filter;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.stereotype.Controller;
    import org.springframework.stereotype.Service;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    @ComponentScan(value = "cn.tellsea.springbean.register",
    		excludeFilters = { 
    				@Filter(type = FilterType.ANNOTATION, classes = { Controller.class, Service.class})
    		})
    public class MyConfig { 
    
    	@Bean
    	public User user() { 
    		User user = new User();
    		user.setName("Tellsea");
    		user.setAge(21);
    		return user;
    	}
    }

测试类

测试结果：myConfig是我们获得容器时加载的配置类，user是通过@Bean注入的，所以这两个bean存在，排除了带有@Controller和@Service的类，测试成功

### （3）@ComponentScan指定扫描组件 ###

查看@ComponentScan源码可以知道，使用includeFilters()方法可以具体指定扫描哪些类，**还要禁用掉默认的配置规则，只包含哪些组件的配置才能生效**

下面的测试类，**扫描规则是只扫描带有@Controller和@Service的类**

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScan.Filter;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.stereotype.Controller;
    import org.springframework.stereotype.Service;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    @ComponentScan(value = "cn.tellsea.springbean.register",
    		includeFilters = { 
    				@Filter(type = FilterType.ANNOTATION, classes = { Controller.class, Service.class})
    		}, useDefaultFilters = false)
    public class MyConfig { 
    
    	@Bean
    	public User user() { 
    		User user = new User();
    		user.setName("Tellsea");
    		user.setAge(21);
    		return user;
    	}
    }

测试类

测试结果：myConfig是我们获得容器时加载的配置类，user是通过@Bean注入的，所以这两个bean存在，之前还有一个UserDao的bean，这里就没有扫描到，测试成功

### （4）FilterType的分类 ###

上面的排除，指定规则扫描等，都使用到了`FilterType.ANNOTATION`，实际上该枚举对象总的有5中类型

package org.springframework.context.annotation;
    
    /** * Enumeration of the type filters that may be used in conjunction with * {@link ComponentScan @ComponentScan}. * * @author Mark Fisher * @author Juergen Hoeller * @author Chris Beams * @since 2.5 * @see ComponentScan * @see ComponentScan#includeFilters() * @see ComponentScan#excludeFilters() * @see org.springframework.core.type.filter.TypeFilter */
    public enum FilterType { 
    
    	/** * 指定注释 * @see org.springframework.core.type.filter.AnnotationTypeFilter */
    	ANNOTATION,
    
    	/** * 指定类型 * @see org.springframework.core.type.filter.AssignableTypeFilter */
    	ASSIGNABLE_TYPE,
    
    	/** * 指定切面 * @see org.springframework.core.type.filter.AspectJTypeFilter */
    	ASPECTJ,
    
    	/** * 指定正则 * @see org.springframework.core.type.filter.RegexPatternTypeFilter */
    	REGEX,
    
    	/** 自定义规则 * {@link org.springframework.core.type.filter.TypeFilter} implementation. */
    	CUSTOM
    
    }

指定注解（常用）

@Filter(type = FilterType.ANNOTATION, classes = { Controller.class, Service.class})

指定类型（常用）

@Filter(type = FilterType.ASSIGNABLE_TYPE, classes = { UserDao.class})

指定切面（不常用）  
指定正则（不常用）  
自定义规则

下面分析最后一种

### （5）FilterType自定义规则 ###

看FilterType的源码，几种的规则都有对应的TypeFilter实现类，所以我们自定义规则需要实现TypeFilter，并重写match()，然后重写匹配规则，下面的类定义的规则为，类名包含o的就匹配

package cn.tellsea.springbean.register;
    
    import org.springframework.core.type.ClassMetadata;
    import org.springframework.core.type.classreading.MetadataReader;
    import org.springframework.core.type.classreading.MetadataReaderFactory;
    import org.springframework.core.type.filter.TypeFilter;
    
    import java.io.IOException;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class MyTypeFilter implements TypeFilter { 
    
    	/** * @param metadataReader 当前正在扫描的类的信息 * @param metadataReaderFactory 获取到其他任何类的信息 * @return * @throws IOException */
    	@Override
    	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { 
    		// 获取到当前正在扫描的类的信息
    		ClassMetadata classMetadata = metadataReader.getClassMetadata();
    		String className = classMetadata.getClassName();
    		System.out.println("自定义扫描规则加载类：" + className);
    		if (className.contains("ro")) { 
    			return true;
    		}
    		return false;
    	}
    }

修改一下测试类，增加自定义扫描规则

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScan.Filter;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    import org.springframework.stereotype.Controller;
    import org.springframework.stereotype.Service;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    @ComponentScan(value = "cn.tellsea.springbean.register",
    		excludeFilters = { 
    				@Filter(type = FilterType.ANNOTATION, classes = { Controller.class, Service.class}),
    				@Filter(type = FilterType.CUSTOM, classes = { MyTypeFilter.class})
    		})
    public class MyConfig { 
    
    	@Bean
    	public User user() { 
    		User user = new User();
    		user.setName("Tellsea");
    		user.setAge(21);
    		return user;
    	}
    }

测试类

package cn.tellsea.springbean.register;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class TestMain { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    		String[] definitionNames = applicationContext.getBeanDefinitionNames();
    		for (String name : definitionNames) { 
    			System.out.println(name);
    		}
    	}
    }

测试结果：因为我们已经排除了带有@Controller，@Service，然后又自定义排除了带有o的，所以这里什么也没有了，myConfig是启动扫描的配置类，user是@Bean注入的，测试成功

自定义扫描规则加载类：cn.tellsea.springbean.register.MyTypeFilter
    自定义扫描规则加载类：cn.tellsea.springbean.register.TestMain
    自定义扫描规则加载类：cn.tellsea.springbean.register.User
    自定义扫描规则加载类：cn.tellsea.springbean.register.UserController
    自定义扫描规则加载类：cn.tellsea.springbean.register.UserDao
    自定义扫描规则加载类：cn.tellsea.springbean.register.UserService
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    myConfig
    user

# 4、@Conditional #

@Conditional主要实现的功能是按照条件注入bean，在spring boot中很常见。比如我们需要实现以下功能，有两个Bean（WindowsUser和LinuxUser），我需要根据当前系统判断，如果是Windows系统，则加载WindowsUser的bean，如果是Linux系统，则加载LinuxUser的bean

### （1）@Conditional条件注册bean ###

WindowsCondition环境判断

package cn.tellsea.springbean.conditional;
    
    import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.env.Environment;
    import org.springframework.core.type.AnnotatedTypeMetadata;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class WindowsCondition implements Condition { 
    
    	@Override
    	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    		// 能获取当前环境的信息
    		Environment environment = context.getEnvironment();
    		// 获取操作系统
    		String property = environment.getProperty("os.name");
    		if (property.contains("Windows")) { 
    			return true;
    		}
    		return false;
    	}
    }

LinuxCondition环境判断

package cn.tellsea.springbean.conditional;
    
    import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.env.Environment;
    import org.springframework.core.type.AnnotatedTypeMetadata;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class LinuxCondition implements Condition { 
    
    	@Override
    	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { 
    		// 能获取当前环境的信息
    		Environment environment = context.getEnvironment();
    		// 获取操作系统
    		String property = environment.getProperty("os.name");
    		if (property.contains("linux")) { 
    			return true;
    		}
    		return false;
    	}
    }

定义WindowsUser实体类

package cn.tellsea.springbean.conditional;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class WindowsUser { 
    }

定义LinuxUser实体类

package cn.tellsea.springbean.conditional;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class LinuxUser { 
    }

配置类注入bean，并通过@Conditional注解判断是否注入

package cn.tellsea.springbean.conditional;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Conditional;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @ComponentScan("cn.tellsea.springbean.conditional")
    public class AppConfig { 
    
    	@Bean
    	@Conditional({ WindowsCondition.class})
    	public WindowsUser windowsUser() { 
    		return new WindowsUser();
    	}
    
    	@Bean
    	@Conditional({ LinuxCondition.class})
    	public LinuxUser linuxUser() { 
    		return new LinuxUser();
    	}
    }

测试类

package cn.tellsea.springbean.conditional;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class AppTest { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    		String[] definitionNames = applicationContext.getBeanDefinitionNames();
    		for (String name : definitionNames) { 
    			System.out.println(name);
    		}
    	}
    }

测试结果：只有windowsUser的bean，Linux的测试可以在idea中配置`VM options：-Dos.name=linux`，模拟Linux环境

### （2）@Conditional作用在类上 ###

@Conditional作用在类上，只有满足条件，这个类中配置的所有bean注册才能生效

package cn.tellsea.springbean.conditional;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Conditional;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @ComponentScan("cn.tellsea.springbean.conditional")
    @Conditional({ LinuxCondition.class})
    public class AppConfig { 
    
    	@Bean
    	@Conditional({ WindowsCondition.class})
    	public WindowsUser windowsUser() { 
    		return new WindowsUser();
    	}
    
    	@Bean
    	@Conditional({ LinuxCondition.class})
    	public LinuxUser linuxUser() { 
    		return new LinuxUser();
    	}
    }

再运行一次测试类，会我们自己写的一个bean都没有了，因为条件是Linux系统才进行bean注册

# 5、@Import #

### （1）@Import快速导入组件 ###

使用@Import注解标注的类，spring容器会自动注册这个组件，id的名称为全类名

package cn.tellsea.springbean.annonimport;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class Red { 
    }

package cn.tellsea.springbean.annonimport;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Import;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Import({ Red.class})
    @Configuration
    @ComponentScan("cn.tellsea.springbean.annonimport")
    public class AppConfig { 
    }

package cn.tellsea.springbean.annonimport;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class AppTest { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    		String[] definitionNames = applicationContext.getBeanDefinitionNames();
    		for (String name : definitionNames) { 
    			System.out.println(name);
    		}
    	}
    }

测试结果

@Import() 也可以导入多个组件，`@Import({Red.class, Green.class, Yellow.class})`

### （2）@Import的ImportSelector ###

ImportSelector是一个接口，返回的结果为全类名的数组。下面再定义两个类，Green，Yellow

package cn.tellsea.springbean.annonimport;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class Green { 
    }

接下来自定义导入选择器

package cn.tellsea.springbean.annonimport;
    
    import org.springframework.context.annotation.ImportSelector;
    import org.springframework.core.type.AnnotationMetadata;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class MyImportSelector implements ImportSelector { 
    
    	@Override
    	public String[] selectImports(AnnotationMetadata importingClassMetadata) { 
    		return new String[]{ "cn.tellsea.springbean.annonimport.Green", "cn.tellsea.springbean.annonimport.Yellow"};
    	}
    }

将第一步的AppConfig配置类的@Import修改为以下内容

@Import({ Red.class, MyImportSelector.class})

再次执行测试类，会发现新增加的两个类已经注册到spring中了

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    appConfig
    cn.tellsea.springbean.annonimport.Red
    cn.tellsea.springbean.annonimport.Green
    cn.tellsea.springbean.annonimport.Yellow

### （3）@Import的ImportBeanDefinitionRegistrar ###

ImportBeanDefinitionRegistrar接口的作用也是根据需要注册bean，我们再增加一个类Black

package cn.tellsea.springbean.annonimport;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class Black { 
    }

重新ImportBeanDefinitionRegistrar接口的registerBeanDefinitions方法，并判断如果存在Red，Green，Yellow这三个类，我们就增加一个Black类

package cn.tellsea.springbean.annonimport;
    
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.RootBeanDefinition;
    import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
    import org.springframework.core.type.AnnotationMetadata;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { 
    
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
    		boolean redDefinition = registry.containsBeanDefinition("cn.tellsea.springbean.annonimport.Red");
    		boolean greenDefinition = registry.containsBeanDefinition("cn.tellsea.springbean.annonimport.Green");
    		boolean yellowDefinition = registry.containsBeanDefinition("cn.tellsea.springbean.annonimport.Yellow");
    		if (redDefinition && greenDefinition && yellowDefinition) { 
    			// 创建bean的定义信息
    			RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Black.class);
    			registry.registerBeanDefinition("black", rootBeanDefinition);
    		}
    	}
    }

修改AppConfig配置类的@Import修改为以下内容

@Import({ Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})

再次运行测试类，发现我们注册bean都加载出来了

# 6、使用FactoryBean注册组件 #

使用Spring提供的FactoryBean（工厂bean），默认获取到的是工厂bean调用getObject创建的对象，要获取工厂bean本身，我们需要给id前面加上一个“&”符号：&userFactoryBean

package cn.tellsea.springbean.factorybean;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class User { 
    }

package cn.tellsea.springbean.factorybean;
    
    import org.springframework.beans.factory.FactoryBean;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class UserFactoryBean implements FactoryBean<User> { 
    
    	@Override
    	public User getObject() throws Exception { 
    		System.out.println("FactoryBean User ...");
    		return new User();
    	}
    
    	@Override
    	public Class<?> getObjectType() { 
    		return User.class;
    	}
    
    	@Override
    	public boolean isSingleton() { 
    		return true;
    	}
    }

package cn.tellsea.springbean.factorybean;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class FactoryBeanConfig { 
    
    	@Bean
    	public UserFactoryBean userFactoryBean() { 
    		return new UserFactoryBean();
    	}
    }

package cn.tellsea.springbean.factorybean;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class FactoryBeanTest { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(FactoryBeanConfig.class);
    		String[] definitionNames = applicationContext.getBeanDefinitionNames();
    		for (String name : definitionNames) { 
    			System.out.println(name);
    		}
    		System.out.println("----------------------------------");
    		Object userFactoryBean = applicationContext.getBean("userFactoryBean");
    		System.out.println("UserFactoryBean 的类型：" + userFactoryBean.getClass());
    	}
    }

测试结果：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    factoryBeanConfig
    userFactoryBean
    ----------------------------------
    FactoryBean User ...
    UserFactoryBean 的类型：class cn.tellsea.springbean.factorybean.User

如果我们就想要获取这个工厂bean，我们就可以在id的前面加上一个"&"符号

测试结果

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    factoryBeanConfig
    userFactoryBean
    ----------------------------------
    FactoryBean User ...
    UserFactoryBean 的类型：class cn.tellsea.springbean.factorybean.User
    UserFactoryBean 的类型：class cn.tellsea.springbean.factorybean.UserFactoryBean

# 7、@Scope设置组件作用域 #

### （1）@Scope的四种类型 ###

@Scope设置组件作用域，源码如下

package org.springframework.context.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    import org.springframework.beans.factory.config.ConfigurableBeanFactory;
    import org.springframework.core.annotation.AliasFor;
    
    @Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Scope { 
    
    	/** * Alias for {@link #scopeName}. * @see #scopeName */
    	@AliasFor("scopeName")
    	String value() default "";
    
    	/** * Specifies the name of the scope to use for the annotated component/bean. * <p>Defaults to an empty string ({@code ""}) which implies * {@link ConfigurableBeanFactory#SCOPE_SINGLETON SCOPE_SINGLETON}. * @since 4.2 * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE * @see ConfigurableBeanFactory#SCOPE_SINGLETON * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION * @see #value */
    	@AliasFor("value")
    	String scopeName() default "";
    
    	/** * Specifies whether a component should be configured as a scoped proxy * and if so, whether the proxy should be interface-based or subclass-based. * <p>Defaults to {@link ScopedProxyMode#DEFAULT}, which typically indicates * that no scoped proxy should be created unless a different default * has been configured at the component-scan instruction level. * <p>Analogous to {@code <aop:scoped-proxy/>} support in Spring XML. * @see ScopedProxyMode */
    	ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
    
    }

可以看出常用属性值有四个

<table> 
 <thead> 
  <tr> 
   <th align="left">属性名称</th> 
   <th align="left">作用说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">prototype</td> 
   <td align="left">默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护</td> 
  </tr> 
  <tr> 
   <td align="left">singleton</td> 
   <td align="left">为每一个bean请求提供一个实例</td> 
  </tr> 
  <tr> 
   <td align="left">request</td> 
   <td align="left">为每一个网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收</td> 
  </tr> 
  <tr> 
   <td align="left">session</td> 
   <td align="left">与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效</td> 
  </tr> 
 </tbody> 
</table>

### （2）@Scope使用案例 ###

接下来测试默认模式下获取的对象是不是同一个对象

package cn.tellsea.springbean.scope;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class Student { 
    }

package cn.tellsea.springbean.scope;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class ScopeConfig { 
    
    	// 默认单例
    	@Bean
    	public Student student() { 
    		return new Student();
    	}
    }

package cn.tellsea.springbean.scope;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class ScopeTest { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ScopeConfig.class);
    		Student student = applicationContext.getBean(Student.class);
    		Student student2 = applicationContext.getBean(Student.class);
    		System.out.println(student);
    		System.out.println(student2);
    		System.out.println(student == student2);
    	}
    }

cn.tellsea.springbean.scope.Student@5ae50ce6
    cn.tellsea.springbean.scope.Student@5ae50ce6
    true

下面我们将bean改为多例，

package cn.tellsea.springbean.scope;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Scope;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class ScopeConfig { 
    
    	@Bean
    	@Scope("prototype")
    	public Student student() { 
    		return new Student();
    	}
    }

再次运行测试类查看结果

cn.tellsea.springbean.scope.Student@49d904ec
    cn.tellsea.springbean.scope.Student@48e4374
    false

**结论**：当bean的作用域为多例的时候，IOC容器启动的时候，就不会去创建bean的实例的，而是当我们调用getBean()获取的时候去创建bean的实例，而且每次调用的时候，都会创建bean的实例

# 8、@Lazy注解实现懒加载 #

懒加载是专门针对于单实例的bean的，容器启动的时候，不创建对象，而是在第一次使用（获取）Bean的时候来创建对象，并进行初始化

package cn.tellsea.springbean.lazy;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class Student { 
    }

package cn.tellsea.springbean.lazy;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class LazyConfig { 
    
    	@Bean
    	public Student student() { 
    		System.out.println("加载了bean ...");
    		return new Student();
    	}
    }

package cn.tellsea.springbean.lazy;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    /** * @author Tellsea * @date 2020-8-28 */
    public class LazyTest { 
    
    	public static void main(String[] args) { 
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(LazyConfig.class);
    		System.out.println("spring 启动完成 ...");
    	}
    }

测试结果

加载了bean ...
    spring 启动完成 ...

在student注入的时候，加上@Lazy注解

package cn.tellsea.springbean.lazy;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Lazy;
    
    /** * @author Tellsea * @date 2020-8-28 */
    @Configuration
    public class LazyConfig { 
    
    	@Lazy
    	@Bean
    	public Student student() { 
    		System.out.println("加载了bean");
    		return new Student();
    	}
    }

测试结果

spring 启动完成 ...

然后我们修改测试类，启动完成之后，获得该bean

测试结果，证明了懒加载是在调用时才创建对象并初始化

spring 启动完成 ...
    加载了bean ...
    cn.tellsea.springbean.lazy.Student@49b0b76

# 9、更多细节学习 #

*  [Tellsea全系列文章目录][Tellsea]

# 微信公众号 #

![每天Get一个小技巧][Get]

[Tellsea]: https://blog.csdn.net/qq_38762237/article/details/107228946
[Get]: /images/20221123/da3fe1b0b67347b297ba8cc861cab147.png