spring注解（属性赋值自动装配）
Posted 鸟随二月
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了spring注解（属性赋值自动装配）相关的知识，希望对你有一定的参考价值。
目录标题
生命周期
指定初始化和销毁方法
之前在src\\main\\resources\\beans.xml配置文件中
现在
新建一个bean car
第一种 @Bean(initMethod=“init”,destroyMethod=“detory”)
package com.spring.bean;
import org.springframework.stereotype.Component;
@Component
public class Car
public Car()
System.out.println("car constructor...");
public void init()
System.out.println("car ... init...");
public void detory()
System.out.println("car ... detory...");
新建一个配置类
package com.spring.config;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import com.spring.bean.Car;
/**
* bean的生命周期：
* bean创建---初始化----销毁的过程
* 容器管理bean的生命周期；
* 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
*
* 构造（对象创建）
* 单实例：在容器启动的时候创建对象
* 多实例：在每次获取的时候创建对象\\
*
* BeanPostProcessor.postProcessBeforeInitialization
* 初始化：
* 对象创建完成，并赋值好，调用初始化方法。。。
* BeanPostProcessor.postProcessAfterInitialization
* 销毁：
* 单实例：容器关闭的时候
* 多实例：容器不会管理这个bean；容器不会调用销毁方法；
*
*
* 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
* 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
*
* BeanPostProcessor原理
* populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
* initializeBean
*
* applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
* invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
* applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
*
*
*
*
* 1）、指定初始化和销毁方法；
* 通过@Bean指定init-method和destroy-method；
* 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
* DisposableBean（定义销毁逻辑）;
* 3）、可以使用JSR250；
* @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
* @PreDestroy：在容器销毁bean之前通知我们进行清理工作
* 4）、BeanPostProcessor【interface】：bean的后置处理器；
* 在bean初始化前后进行一些处理工作；
* postProcessBeforeInitialization:在初始化之前工作
* postProcessAfterInitialization:在初始化之后工作
*
* Spring底层对 BeanPostProcessor 的使用；
* bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
*
* @author lfy
*
*/
@ComponentScan("com.spring.bean")
@Configuration
public class MainConfigOfLifeCycle
//@Scope("prototype")
@Bean(initMethod="init",destroyMethod="detory")
public Car car()
return new Car();
测试
第二种 InitializingBean,DisposableBean
新建一个bean
package com.spring.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
@Component
public class Cat implements InitializingBean,DisposableBean
public Cat()
System.out.println("cat constructor...");
@Override
public void destroy() throws Exception
// TODO Auto-generated method stub
System.out.println("cat...destroy...");
@Override
public void afterPropertiesSet() throws Exception
// TODO Auto-generated method stub
//初始化
System.out.println("cat...afterPropertiesSet...");
修改配置类src\\main\\java\\com\\spring\\config\\MainConfigOfLifeCycle.java类名前
@ComponentScan("com.spring.bean")
测试
第三种 @PostConstruct @PreDestroy
新建bean
package com.spring.bean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class Dog
public Dog()
System.out.println("dog constructor...");
//对象创建并赋值之后调用
@PostConstruct
public void init()
System.out.println("Dog....@PostConstruct...");
//容器移除对象之前
@PreDestroy
public void detory()
System.out.println("Dog....@PreDestroy...");
配置类不用修改
src\\main\\java\\com\\spring\\config\\MainConfigOfLifeCycle.java
测试
第四种 BeanPostProcessor后置处理器
添加后置处理器
package com.spring.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* 后置处理器：初始化前后进行处理工作
* 将后置处理器加入到容器中
* @author lfy
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
// TODO Auto-generated method stub
System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
return bean;
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
// TODO Auto-generated method stub
System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
return bean;
测试
原理
populateBean为各种属性赋值
底层使用
1.注入IOC容器
修改src\\main\\java\\com\\spring\\bean\\Dog.java
package com.atguigu.bean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class Dog implements ApplicationContextAware
//@Autowired
private ApplicationContext applicationContext;
public Dog()
System.out.println("dog constructor...");
//对象创建并赋值之后调用
@PostConstruct
public void init()
System.out.println("Dog....@PostConstruct...");
//容器移除对象之前
@PreDestroy
public void detory()
System.out.println("Dog....@PreDestroy...");
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
// TODO Auto-generated method stub
this.applicationContext = applicationContext;
2.数据校验
3.处理 @PostConstruct @PreDestroy注解
处理Autowired注解
属性赋值
新建配置类
package com.spring.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import com.spring.bean.Person;
@Configuration
public class MainConfigOfPropertyValues
@Bean
public Person person()
return new Person();
新建配置文件
之前赋值
现在
修改配置类src\\main\\java\\com\\spring\\config\\MainConfigOfPropertyValues.java
修改bean src\\main\\java\\com\\spring\\bean\\Person.java
package com.spring.bean;
import org.springframework.beans.factory.annotation.Value;
public class Person
//使用@Value赋值；
//1、基本数值
//2、可以写SpEL； #
//3、可以写$；取出配置文件【properties】中的值（在运行环境变量里面的值）
@Value("张三")
private String name;
@Value("#20-2")
private Integer age;
@Value("$person.nickName")
private String nickName;
public String getNickName()
return nickName;
public void setNickName(String nickName)
this.nickName = nickName;
public String getName()
return name;
public void setName(String name)
this.name = name;
public Integer getAge()
return age;
public void setAge(Integer age)
this.age = age;
public Person(String name, Integer age)
super();
this.name = name;
this.age = age;
public Person()
super();
// TODO Auto-generated constructor stub
@Override
public String toString()
return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]";
测试
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(MainConfigOfPropertyValues.class);
printBeans(applicationContext);
System.out.println("=============");
Person person = (Person) applicationContext.getBean("person");
System.out.println(person);
ConfigurableEnvironment environment = applicationContext.getEnvironment();
String property = environment.getProperty("person.nickName");
System.out.println(property);
applicationContext.close();
private static void printBeans(AnnotationConfigApplicationContext applicationContext)
String[] definitionNames = applicationContext.getBeanDefinitionNames();
for (String name : definitionNames)
System.out.println(name);
自动装配
修改
新建配置类
package com.spring.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import com.spring.bean.Car;
import com.spring.bean.Color;
import com.spring.dao.BookDao;
/**
* 自动装配;
* Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；
*
* 1）、@Autowired：自动注入：
* 1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
* 2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
* applicationContext.getBean("bookDao")
* 3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
* 4）、自动装配默认一定要将属性赋值好，没有就会报错；
* 可以使用@Autowired(required=false);
* 5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
* 也可以继续使用@Qualifier指定需要装配的bean的名字
* BookService
* @Autowired
* BookDao bookDao;
*
*
* 2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
* @Resource:
* 可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
* 没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
* @Inject:
* 需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
* @Autowired:Spring定义的； @Resource、@Inject都是java规范
*
* AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；
*
* 3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
* 1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
* 2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
* 3）、放在参数位置：
*
* 4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
* 自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
* 把Spring底层一些组件注入到自定义的Bean中；
* xxxAware：功能使用xxxProcessor；
* ApplicationContextAware==》ApplicationContextAwareProcessor；
*
*
* @author lfy
*
*/
@Configuration
@ComponentScan("com.spring.service","com.spring.dao",
"com.spring.controller","com.spring.bean")
public class MainConifgOfAutowired
测试
@Qualifier、@Autowired(required=false)@Primary
修改
package com.spring.dao;
import org.springframework.stereotype.Repository;
//名字默认是类名首字母小写
@Repository
public class BookDao
private String lable = "1";
public String getLable()
return lable;
public void setLable(String lable)
this.lable = lable;
@Override
public String toString()
return "BookDao [lable=" + lable + "]";
package com.spring.service;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import com.spring.dao.BookDao;
@Service
public class BookService
//@Qualifier("bookDao")
//按照名字注册
@Autowired(required=false)
//有则注册，无则不注册
//@Autowired
private BookDao bookDao;
public void print()
System.out.prin以上是关于spring注解（属性赋值自动装配）的主要内容，如果未能解决你的问题，请参考以下文章
spring作用spring注解管理对象的作用域与生命周期自动装配
Spring注解驱动开发——自动装配 @Autowired @Qualifier @Primary