Spring Java Config——组件注册相关注解
目录
组件注册
- 一、@Configuration
- 二、@Bean
- 三、@ComponentScan
- 四、@Scope
- 五、@Condition
- 六、@Import
- 七、使用FactoryBean注册组件
给容器中注册组件
包扫描+组件标注注解（@Component、@Service、@Controller、@Repository，主要是自己写的类@Bean[导入的第三方包里面的组件]@Import[快速给容器中导入一个组件]Import(类名.class),容器中就会自动注册这个组件，id默认是组件的全名ImportSelector：返回需要导入的组件的全类名的数组- ImportBeanDefinitionRegistrar：手动注册bean
- 使用Spring提供的FactoryBean（工厂bean）
- 默认获取到的是工厂bean调用getObject创建的对象
- 要获取到bean本身，需要给id前面加个&标识
@Conditional({Condition}):按照一定的条件判断，满足条件给容器中注册bean@Scope- prototype:多例的 ioc容器启动并不会去调用方法创建对象在容器中，而是每次获取时才会调用方法创建对象
- singleton:单例的（默认值） ioc容器启动会调用方法创建对象放到ioc容器中，以后每次获取就是从容器中拿
一、@Configuration
跳转到目录
@Configuration: 把一个类标记为spring的配置类,相当于之前的applicationContext.xml文件
1、看看之前通过applicationContext.xml配置文件来创建类的实例
public class SomeBean {}
<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="somebean" class="com.zy._01_hello.SomeBean"/>
beans>
测试方法
public class SomeBeanTest {
/*
Spring XML Config
*/
@Test
public void test(){
// 加载配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
// 从Spring容器中获取SomeBean的实例
SomeBean someBean = ctx.getBean("somebean", SomeBean.class);
System.out.println(someBean);
}
}
- 这种方式是通过
Spring XML Config的方式来将类交给Spring容器处理; 但是后来发现有很多这样的xml不容易管理,形成了配置类; 于是就有了后来的SpringBoot在SpringBoot中几乎看不到配置文件了,取而代之的是Spring Java Config的配置类的形式!
2、创建配置类
// 把一个类标记为spring的配置类; (类名Config可以简单理解为XML中的 beans)
@Configuration
public class Config {
@Bean
public SomeBean somebean(){
return new SomeBean();
}
}
测试方法
public class SomeBeanTest {
/*
Spring Java Config
*/
@Test
public void test1(){
ApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
SomeBean someBean = ctx.getBean(SomeBean.class);
System.out.println(someBean);
}
}
- 这里要通过
AnnotationConfigApplicationContext(config.class)来加载配置类,然后拿到配置类中SomeBean的实例即可(将组件的创建交给Spring容器处理, 也就是将组件注册到容器中)!
二、@Bean
跳转到目录
@Bean相当于在配置文件中写的＜bean id="" class="" /＞, 将一个类的创建实例交给Spring IoC来处理;
在配置文件中写的bean
<bean id="" class="" name="" init-method="" destory-method="" scope="">
<property name="" value=""/>
<property name="" ref=""/>
bean>
在配置类中写的bean
@Configuration
public class Config {
@Bean
public SomeBean someBean1() {
return new SomeBean();
}
@Bean
public SomeBean someBean2() {
return new SomeBean();
}
@Bean(name = {"sb", "sbb"})
public SomeBean someBean3() {
return new SomeBean();
}
}
1、在配置类中@Bean的含义
- 被@Bean标注的
方法的名字—> bean的id - 方法的
返回值类型—> bean的class类型 - 除了默认使用方法的名字作为id外, 还可以通过
@Bean(name={"xxx1", "xxx2"})来指定多个id名
@Test
public void test2() {
ApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
SomeBean someBean1 = ctx.getBean("someBean1", SomeBean.class); // bean的id去找
System.out.println(someBean1);
SomeBean someBean2 = ctx.getBean("someBean2", SomeBean.class);
System.out.println(someBean2);
SomeBean someBean3 = ctx.getBean("sb", SomeBean.class);
System.out.println(someBean3);
SomeBean someBean4 = ctx.getBean("sbb", SomeBean.class);
System.out.println(someBean4);
}
2、配置initMethod、destroyMethod的方法
构造(对象创建)
- 单例: 在容器
启动(加载配置类/加载配置文件)的时候创建对象;- 容器启动先创建对象, 然后调用init(初始化方法);
- 多例: 在每次
获取bean(getBean())的时候创建对象;- 容器创建完成之后, 才创建对象完成init(初始化);
- 方式一: 可以在@Bean中的属性
initMethod,destroyMethod来指定初始化,销毁方法
@Bean(name="sb", initMethod = "init", destroyMethod = "destory")
- 方式二:
@PostConstruct,@PreDestroy来指定初始化,销毁方法
public class SomeBean {
// 方式二: 配置init,destory @PostConstruct,@PreDestroy
@PostConstruct
public void init() {
System.out.println("SomeBean.init");
}
@PreDestroy
public void destory() {
System.out.println("SomeBean.destory");
}
}
测试方法
public class SomeBeanTest {
/*
Spring Java Config
*/
@Test
void test(){
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
SomeBean someBean = ctx.getBean("sb", SomeBean.class);
System.out.println(someBean);
ctx.close(); // 非Spring Test,容器不会正常关闭,调用close方法才可以
}
}
3、@Bean依赖注入的方式
public class OtherBean {
}
@Setter
@Getter
public class SomeBean {
private OtherBean otherBean;
}
- 方式一: 通过类似
内部bean的方式
@Configuration
public class Config {
/*
方式一: 相当于内部Bean的形式
这种方式用的很少!
*/
@Bean
public SomeBean someBean() {
SomeBean sb = new SomeBean();
sb.setOtherBean(new OtherBean());
return sb;
}
}
- 方式二: 通过调用需要注入的Bean的
方式名()即可
配置类
@Configuration
public class Config {
@Bean
public SomeBean someBean() {
SomeBean sb = new SomeBean();
sb.setOtherBean(otherBean());
return sb;
}
@Bean
public SomeBean someBean2() {
SomeBean sb = new SomeBean();
sb.setOtherBean(otherBean());
return sb;
}
@Bean
public OtherBean otherBean() {
return new OtherBean();
}
}
- 方式三: 需要依赖的
Bean, 放入到参数列表中,会自动注入;- 当有多个OtherBean的实例时,可以使用
@Qualifier("bean的id")来指定 - 有多个OtherBean时,在某个bean上添加
@Primary, 会优先注入该bean - 有多个OtherBean时,在参数列表中通过
形参名称来指定对应的bean
- 当有多个OtherBean的实例时,可以使用
@Bean
// public SomeBean someBean(@Qualifier("otherBean") OtherBean ob) {
public SomeBean someBean(OtherBean otherBean) {
SomeBean sb = new SomeBean();
sb.setOtherBean(otherBean);
return sb;
}
@Bean
//@Primary
public OtherBean otherBean() {
return new OtherBean("ob1");
}
@Bean
public OtherBean otherBean2() {
return new OtherBean("ob2");
}
三、@ComponentScan
跳转到目录
- 可以完成
Spring组件的自动扫描(默认情况下,会去扫描被标注的类的对应的包(及其子包中)的所有的类;
配置类Config
@Configuration
// 可以完成Spring组件的自动扫描(默认情况下,会去扫描被标注的类的对应的包(及其子包中)的所有的类
//@ComponentScan(basePackages = "com.zy._04_componentscan") // 也可以自己指定扫描的范围
@ComponentScan
public class Config {
}
OtherBean和SomeBean类
@Component //设置该类作为Spring管理的组件
public class OtherBean {
}
@Component
public class SomeBean {
@Autowired // 将Spring通过@Component创建好的OtherBean的实例,注入到下面的属性中
private OtherBean otherBean;
}
测试方法
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class SomeBeanTest {
@Autowired
private SomeBean someBean;
@Test
public void test(){
System.out.println(someBean.getOtherBean());
}
}
- 组件注册时的
过滤条件- @ComponentScan value:指定要扫描的包
excludeFilters=Filter[]:指定扫描包的时候按照什么规则排除哪些组件includeFilters=Filter[]:指定扫描包的时候要包含哪些组件,需将useDefaultFilters置false- FilterType.
ANNOTATION:按照注解 - FilterType.
ASSIGNABLE_TYPE:按照指定的类型 - FilterType.REGEX:使用正则指定
- FilterType.CUSTOM:使用自定义规则
// 配置类 == 配置文件
@Configuration // 告诉Spring这是一个配置类
//@ComponentScan(value = "com.zy") // 不写默认扫描当前类所在包(及其子包)下的所有类(指定要扫描的包)
//@ComponentScan(value = "com.zy", excludeFilters = {
// // excludeFilters: FilterType是过滤条件(这里是根据注解来过滤); 将Controller,Service的bean过滤掉(不扫描它们)
// @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
//})
@ComponentScan(value = "com.zy", includeFilters = {
// excludeFilters: FilterType是过滤条件(这里是根据注解来过滤); 将Controller,Service的bean过滤掉(不扫描它们)
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {BookService.class})
}, useDefaultFilters = false)
// @ComponentScan value: 指定扫描的包
// excludeFilters = Filter[] : 指定扫描的时候按照什么规则排除哪些组件
// includeFilters = Filter[] : 指定扫描的时候只需要包含哪些组件
// FilterType.ANNOTATION: 按照注解作为过滤规则
// FilterType.ASSIGNABLE_TYPE: 按照给定的类型作为过滤规则
public class MainConfig {
// 给容器中注册一个Bean, 类型为返回值类型, id默认是方法名
@Bean("person")
public Person person(){
return new Person("lisi", 22);
}
}
测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MainConfig.class)
public class IoCTest {
@Test
public void test1(){
ApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
// 看容器中有哪些bean,返回这些bean的名称
String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
for (String name : beanDefinitionNames) {
System.out.println(name);
}
}
}
四、@Scope
跳转到目录
- 用来表示bean的范围(是
单例还是多例) prototype: 多例的 : IoC容器启动并不会去调用方法创建对象放在容器中, 每次获取bean的时候才会调用方法创建对象;singleton: 单例的 : IoC容器启动就会调用方法创建对象放到IoC容器中;- request: 同一次请求创建一个实例
- session: 同一个session创建一个实例
@Scope("prototype")
//@Scope // 默认不写value就是singleton
@Bean
public Person person(){
System.out.println("给容器中添加Person...");
return new Person("张三", 22);
}
@Test
public void test2(){
ApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig2.class);
// 看容器中有哪些bean,返回这些bean的名称
// String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
// for (String name : beanDefinitionNames) {
// System.out.println(name);
// }
// 默认是单例的
System.out.println("IoC容器创建完成...");
Object person1 = ctx.getBean("person");
Object person2 = ctx.getBean("person");
System.out.println(person1 == person2);
}
@Lazy
第一次使用Bean的时候创建,不使用则不创建(即使IoC容器启动了) ;
//@Scope("prototype")
@Scope
@Lazy //第一次使用Bean的时候创建,不使用则不创建(即使IoC容器启动了)
@Bean
public Person person(){
System.out.println("给容器中添加Person...");
return new Person("张三", 22);
}
五、@Condition
跳转到目录
@Conditional: 按照一定的条件进行判断,满足条件给容器中注册bean
MacOSXCondition
// 判断是否Mac系统
public class MacOSXConditaion implements Condition {
/**
*
* @param conditionContext :判断条件能使用的上下文(环境)
* @param annotatedTypeMetadata : 注释信息
* @return
*/
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
// 是否Mac系统
//1. 能获取到IoC使用的beanfactory
ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
//2. 获取类加载器
ClassLoader classLoader = conditionContext.getClassLoader();
//3. 获取当前环境信息(封住系统的的环境信息等,虚拟机等信息)
Environment environment = conditionContext.getEnvironment();
//4. 获取到bean定义的注册类
BeanDefinitionRegistry registry = conditionContext.getRegistry();
String property = environment.getProperty("os.name");
if (property.contains("Mac OS X"))
return true;
return false;
}
}
WindowsCondition
// 判断是否windows系统
public class WindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
Environment environment = conditionContext.getEnvironment();
String property = environment.getProperty("os.name");
if (property.contains("Windows"))
return true;
return false;
}
}
配置类
/*
@Conditional: 按照一定的条件进行判断,满足条件给容器中注册bean
如果系统是windows, 给容器中注册("bill")
如果系统是mac, 给容器中注册("linus")
*/
// 配置到这个方法上,只对这个方法作条件判断: 如果满足,则这个方法注册的bean才能生效
@Conditional({WindowsCondition.class})
@Bean("bill")
public Person person1(){
return new Person("Bill Gates", 62);
}
@Conditional({MacOSXConditaion.class})
@Bean("linus")
public Person person2(){
return new Person("linus", 48);
}
测试
@Test
public void test3(){
// 根据Person类型来获取容器中bean的名称
String[] beanNamesForType = ctx.getBeanNamesForType(Person.class);
// 动态获取环境变量的值: Mac OS X
Environment environment = ctx.getEnvironment();
String property = environment.getProperty("os.name");
System.out.println(property);
for (String name : beanNamesForType) {
System.out.println(name);
}
Map<String, Person> persons = ctx.getBeansOfType(Person.class);
System.out.println(persons);
}
六、@Import
跳转到目录
- 作用：用于导入
其他的配置类。 - 也可以导入一个需要注册的
组件(类), id默认是全类名;
DataSource类
public class DataSource {
}
RedisTemplate类
public class RedisTemplate {
}
DataSourceConfig配置类
@Configuration
public class DataSourceConfig {
@Bean
public DataSource dataSource(){
return new DataSource();
}
}
RedisConfig配置类
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate redisTemplate(){
return new RedisTemplate();
}
}
AppConfig配置类
@Configuration
@Import({DataSourceConfig.class, RedisConfig.class})
public class AppConfig {
}
ImportTest测试类
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(classes = {DataSourceConfig.class, RedisConfig.class})
@ContextConfiguration(classes = AppConfig.class)
public class ImportTest {
@Autowired
private DataSource ds;
@Autowired
private RedisTemplate rt;
@Test
public void test() {
System.out.println(ds);
System.out.println(rt);
}
}
1、ImportSelector
- 返回需要
导入的组件的全类名
需要导入的组件
public class Blue {
}
public class Red {
}
自定义MyImportSelector
// 自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
/**
*
* @param annotationMetadata 当前标注@Import注解类的所有注解信息
* @return 返回要导入到容器中的组件的全类名
*/
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
return new String[]{"com.zy.beans.Blue","com.zy.beans.Red"};
}
}
配置类
@Configuration
@Import(MyImportSelector.class)
public class MainConfig2 {
}
测试
@Test
public void testImport(){
ApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig2.class);
printBeans((AnnotationConfigApplicationContext) ctx);
Blue bean = ctx.getBean(Blue.class);
System.out.println(bean); // 这样就可以成功在Spring 容器中获取到bean了
}
private void printBeans(AnnotationConfigApplicationContext atx){
String[] definitionNames = atx.getBeanDefinitionNames();
for (String name : definitionNames) {
System.out.println(name);
}
}
2、@ImportResource
@ImportResource来引入xml配置文件, 使xml和javaconfig共同使用;
public class OtherBean {
}
@Setter
@Getter
public class SomeBean {
private OtherBean otherBean;
}
配置类
@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AppConfig {
@Bean
public SomeBean someBean(OtherBean otherBean){
SomeBean sb = new SomeBean();
sb.setOtherBean(otherBean);
return sb;
}
}
测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class AppTest {
@Autowired
private SomeBean someBean;
@Test
public void test() {
System.out.println(someBean.getOtherBean());
}
}
七、使用FactoryBean注册组件
跳转到目录
// 创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {
// 返回一个Color对象,这个对象会添加到容器中
@Override
public Color getObject() throws Exception {
System.out.println("ColorFactoryBean.getObject");
return new Color();
}
@Override
public Class<?> getObjectType() {
return Color.class;
}
// 是否是单例: true, 在容器中只会保留一份
@Override
public boolean isSingleton() {
return true;
}
}
配置类
@Configuration
public class MainConfig{
// 实际返回的是getObject()方法返回的对象
@Bean
public ColorFactoryBean colorFactoryBean(){
return new ColorFactoryBean();
}
}
测试
@Test
public void testImport() {
ApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig2.class);
printBeans((AnnotationConfigApplicationContext) ctx);
Blue bean = ctx.getBean(Blue.class);
System.out.println(bean);
// 工厂Bean获取的是调用getObject创建的对象
Object bean2 = ctx.getBean("colorFactoryBean");
Object bean3 = ctx.getBean("colorFactoryBean");
System.out.println("bean的类型:" + bean2.getClass());
System.out.println(bean2 == bean3);
// 获取ColorFactorybean的本身
Object bean4 = ctx.getBean("&colorFactoryBean");
System.out.println(bean4.getClass());
}
private void printBeans(AnnotationConfigApplicationContext atx) {
String[] definitionNames = atx.getBeanDefinitionNames();
for (String name : definitionNames) {
System.out.println(name);
}
}