大家好,我是一只学弱狗,记录学习的点点滴滴!
优质文章
优质专栏
心心念念的Spring注解驱动开发来了
@Configuration注解
将一个类标注为配置类,相当于之前的applicationContext.xml配置文件
@Bean
将一个对象注册到IOC容器中,其作用在方法上,方法的返回值类型作为bean的类型,方法的方法名作为bean的id
@Configuration
public class Config {
@Bean
public Person person() {
return new Person("张三", "男", 20);
}
}
等同于
<bean id="person" class="pers.lele.bean.Person">
<property name="name" value="张三"/>
<property name="gender" value="男"/>
<property name="age" value="20"/>
</bean>
若需要在不修改方法名的情况下,修改bean的id值,则可以设置@Bean注解中的name属性
@ComponentScan注解
扫描指定包下标有@Controller、@Service、@Repository、@Component注解的类加入到容器中,其id为类名首字母小写,当不同包下存在相同的类,会出现id冲突异常
@Configuration
@ComponentScan(value = {"pers.lele"})
public class Config {
}
关于扫描规则,与.xml文件类型
如排除指定包
@Configuration
@ComponentScan(value = {"pers.lele"}, excludeFilters = {
@ComponentScan.Filter(
type = FilterType.ANNOTATION, value = {Controller.class, Service.class}
)
})
public class Config{
//...
}
在扫描指定包时,注意设置useDefaultFilters属性,因为默认是扫描标有@Controller、@Service、@Repository、@Component注解的类
@Configuration
@ComponentScan(value = {"pers.lele"}, includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {
Controller.class})
}, useDefaultFilters = false)
public class Config {
//...
}
具体的配置看注解属性即可,对于对个包的扫描,使用@componentScans注解
@Configuration
@ComponentScans({
@ComponentScan({"*","**"})
,
@ComponentScan({"*","**"})
})
public class Config{
}
@ComponentScan.Filter的过滤规则
- ANNOTATION 指定注解过滤
- ASSIGNABLE_TYPE 指定具体的类
@Configuration //扫描将类型为BookService的类注入容器中 @ComponentScan(value = {"pers.lele"}, includeFilters = { @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = { BookService.class}) }, useDefaultFilters = false) public class Config { //... }
- ASPECTJ ASPECTJ表达式 execution(<修饰符><返回类型><包.类.方法(参数)><异常>)
- REGEX 正则表达式
- CUSTOM 自定义过滤器规则 需自己实现org.springframework.core.type.filter.TypeFilter接口,重写匹配方法,若返回值为true,则注入到容器中
public class MyTypeFilterFilter implements TypeFilter {
/**
* @param metadataReader metadataReader the metadata reader for the target class 读取到的当前正在扫描的类的信息
* @param metadataReaderFactory metadataReaderFactory a factory for obtaining metadata readers 可以获取到其他任何类信息的
* @return
* @throws IOException
*/
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
//获取当前类的注解信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
//获取当前正在扫码的类的类信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
//获取当前类资源(类的路径)
Resource resource = metadataReader.getResource();
System.out.println("match: --->" + classMetadata.getClassName());
return false;
}
}
@Scope注解
调整bean对象的作用域
* singleton:单例的,在容器加载的时候即创建对象,且以后均是同一个对象
* prototype:多例的,在容器加载的时候不创建对象,在以后需要用到时才开始创建对象,且每次创建的对象均不同
java @Configuration @ComponentScan("pers.lele") public class Config { @Scope("prototype") //多实例 @Bean public Person person() { return new Person("张三", "男", 20); } }
* require: 一次请求
* session:一次会话
@Lazy
对于单实例bean,默认是在容器创建时就加载组件,使用@Lazy可保证在容器创建时不创建bean,则在第一次使用时创建bean,且保证以后使用的bean都是同一个bean
@Conditional注解
对于Bean对象的创建,有时是根据一些条件动态决定的
@Conditional注解一般标注于方法上,决定改Bean是否被创建,当前,也可以标注于配置类上,决定该配置类下的Bean是否均需要创建
以标注于方法上创建Bean为例,注解的参数需要一个实现了Condition接口的类,根据matches的返回值来决定是否创建该Bean对象
@Configuration
public class Config {
@Bean
@Conditional(BillCondition.class)
public Person bill(){
return new Person("Bill Gates","男",66);
}
@Bean
@Conditional(LinusCondition.class)
public Person linus(){
return new Person("linus","男",48);
}
}
根据操作系统创建不同的Bean,若为Windows则创建Bill,否则创建Linus
//Bill
public class BillCondition implements Condition {
/**
*
* @param context 判断条件可以使用的上下文环境
* @param metadata 注释信息
* @return
*/
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//获取bean工厂
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//获取类加载器
ClassLoader classLoader = context.getClassLoader();
//获取运行时环境
Environment environment = context.getEnvironment();
//获取bean定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();
String OS_Name = environment.getProperty("os.name");
if (OS_Name.contains("Window"))
return true;
else
return false;
}
}
//Linus
public class LinusCondition implements Condition {
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment environment = context.getEnvironment();
String OS_Name = environment.getProperty("os.name");
if (OS_Name.contains("Linux"))
return true;
else
return false;
}
}
@Import注解
目前,给Bean容器中注册组件有如下两种方式
- 使用包扫描+注解的方式,局限于我们自己写的类
- 适应@Bean注解的方式,在@Configuration标注的类下新建一些个方法,表明该方法为注入Bean对象的方法
有时为了快速的进行组件注册,可以使用@Import注解,如下面所示,id为该类的全类名 - @Import
1、@Import(要导入到容器中的组件),容器中就会自动注册这个组件,id默认是全类名
2、ImportSelector:返回要导入组件的全类名数组
3、ImportBeanDefinitionRegistrar接口
@Configuration
@Import(ATM.class)
public class Config {}
关于@Import注解,查看它的文档,说明如下,还可以传入实现了ImportSelector接口的对象
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
/**
* {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
* or regular component classes to import.
*/
Class<?>[] value();
}
@Configuration
@Import({ATM.class, MyImportSelector.class})
public class Config {}
//MyImportSelector实现了MyImportSelector接口
public class MyImportSelector implements ImportSelector {
// AnnotationMetadata 当前标注@Import注解的类的所有注解信息
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"pers.lele.bean.Color", "pers.lele.bean.HaHa","pers.lele.ATM"};
}
}
除了实现ImportSelector接口外,还可以实现ImportBeanDefinitionRegistrar接口
@Configuration
@Import({ATM.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class Config {}
//MyImportBeanDefinitionRegistrar实现ImportBeanDefinitionRegistrar
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
/**
*
* @param importingClassMetadata 当前类的注解信息
* @param registry BeanDefinition 注册类 调用registerBeanDefinition方法手工注册
*/
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(RainBow.class);
registry.registerBeanDefinition("rainbow", rootBeanDefinition);
}
}
除了上面的三种创建Bean对象外,还可以使用FactoryBean来创建Bean
自定义类,实现FactoryBean接口,其中泛型为工厂所需类型
public class ColorFactoryBean implements FactoryBean<Color> {
public Color getObject() throws Exception {
return new Color();
}
public Class<?> getObjectType() {
return Color.class;
}
public boolean isSingleton() {
return true;
}
}
在@Configure注解标注的类上定义即可
@Configuration
@Import({ATM.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class Config {
@Bean
public ColorFactoryBean colorFactoryBean(){
return new ColorFactoryBean();
}
}
需要注意的是,若直接通过以下方式来获取bean,则获取的实例的类型非工厂本身类型,而是工厂里面所装入实例的类型
若需要获取工厂实例类型,请使用前缀&符号
public class ContextTest {
@Test
public void test06() {
ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
Object bean1 = context.getBean("colorFactoryBean");
Object bean2 = context.getBean("colorFactoryBean");
System.out.println(bean1.getClass());//class pers.lele.bean.Color
System.out.println(bean1 == bean2);//true
Object bean3 = context.getBean("&colorFactoryBean");
System.out.println(bean3.getClass());//class pers.lele.bean.ColorFactoryBean
}
}
bean的生命周期:bean创建—初始化—销毁
- 创建
- 单实例:容器启动时创建
- 多实例:每次获取时创建
- 初始化 对象创建完成并赋值,调用其初始化方法
- 销毁
- 单实例 容器关闭时销毁
- 多实例 手动销毁
容器管理bean的生命周期:自定义初始化和销毁方法,容器在bean进行到当前生命周期时调用自定义的初始化和销毁方法
- 指定初始化和销毁方法
public class Car { public Car() { System.out.println("Car Constructor..."); } public void init() { System.out.println("Car init ..."); } public void destroy() { System.out.println("Car destroy ..."); } } //注册bean 指定初始化和销毁方法 @Bean(initMethod = "init", destroyMethod = "destroy") public Car car() { return new Car(); }
- 通过让Bean实现InitializingBean(定义初始化逻辑) DisposableBean(定义销毁逻辑)
public class Cat implements InitializingBean, DisposableBean {
public Cat() {
System.out.println("cat constructor");
}
public void destroy() throws Exception {
System.out.println("cat destroy");
}
public void afterPropertiesSet() throws Exception {
System.out.println("cat afterPropertiesSet");
}
}
- @PostConstruct和@PreDestroy
public class Dog {
public Dog() {
System.out.println("Dog Constructor");
}
@PostConstruct
public void init() {
System.out.println("Dog PostConstruct");
}
@PreDestroy
public void destroy() {
System.out.println("Dog PreDestroy");
}
}
- BeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization" + bean + " ---> " + bean);
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization" + bean + " ---> " + bean);
return bean;
}
}
加载配置文件
@PropertySource(value = {"classpath:/person.properties"})
@Configuration()
public class ConfigLifeCycle {
@Bean
public Person person() {
return new Person();
}
}
可以使用getEnvironment方法获取environment,从而获取K-V值
ApplicationContext context = new AnnotationConfigApplicationContext(ConfigLifeCycle.class);
Environment environment = context.getEnvironment();
System.out.println(environment.getProperty("person.name"));
属性赋值
- 基本赋值
- SpEL表达式赋值
- ${}赋值,读取配置文件 properties 中的值
自动装配:Spring利用DI,完成对IOC容器中各个组件的依赖关系赋值
- @Autowire 自动注入
- 默认按照类型去容器中找对应组件,若指定类型的组件一个也不存在,则引发NoSuchBeanDefinitionException,若允许不存在组件时为null,则设置@Autowire中required为false
- 如果找到多个相同类型的组件,再将属性的名称作为组件id去容器中查找,若不存在以属性名为id的组件,则报错NoUniqueBeanDefinitionException,此时设置required无效,仍报错
- 若需在不修改属性名的前提下,装配指定id的组件,则可以使用@Qualifier组件
- 使用注解@Primary,使得Spring在装配时,默认使用首选bean,若存在多个@Primary注解,则报异常NoUniqueBeanDefinitionException
- @Resource 可以和@Autowired一样实现自动装配功能,默认是按照组件名称进行装配的,与@Autowired的区别,不支持@Primary注解和@AutoWired中的属性等
- @Inject注解 支持@Primary注解 需要导入javax.inject 与@Autowired的区别 不存在@AutoWired中的属性
@Autowire作用范围
- 方法上 一般作用于set方法上,参考对象为方法参数 装配规则与作用于属性上一致
- 构造器上 若类只有一个有参构造器,则@Autowird可以省略,装配原则与作用于属性上一致
- 参数上 在配置类定义bean时,参数可以为容器中的组件,@Autowird可以省略,装配原则与作用于属性上一致
自定义组件使用Spring容器底层的一些组件,则需实现接口xxxAware
public class Red implements ApplicationContextAware, EmbeddedValueResolverAware, BeanNameAware {
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println(applicationContext);
}
public void setBeanName(String name) {
System.out.println(name);
}
public void setEmbeddedValueResolver(StringValueResolver resolver) {
String value = resolver.resolveStringValue("${os.name} #{20*1530}");
System.out.println(value);
}
}
@Profile:Spring为我们提供的动态配置组件,指定组件在哪个环境下才能被注册到容器中,若不指定,任何环境下都能注册到该组件
- 激活Profile
- 使用命令行动态参数/环境变量进行配置-Dspring.profiles.active=dev idea中可以不用-D
- 使用代码的方式
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.getEnvironment().setActiveProfiles("test", "dev");
context.register(ConfigAutowired.class);
context.refresh();