@Configuration
注解在类上,标记此类是一个配置类,Spring会扫描到配置类并读取内部配置
@ComponentScan
注解在类上,用于指定spring扫描组件的包路径,可以为数组;还可以进行筛选过滤:excludeFilters includeFilters可以按照类型、正则、自定义(实现接口)、注解、AspectJ
@Controller @Service @Repository @Component
都是用来标记Spring容器组件的,只是场景不同;Controller Service Repository 在Component上扩展
@Resource是java的标准,不指定名称时,按属性名称装配;如果没有,按类型装配
@Bean
用于手动注解一个类, 通常用于注入jar包中不会被扫描到的类,不如数据库连接类
@Autowired
用于向组件内自动装配一个bean,默认按类型装配,如果同样类型有多个,取属性名作为id从容器中获取
@Qualifier
用于从容器中获取指定id的bean,当相同类型的bean有多个时可使用此注解
@Primary
如果相同类型的bean存在多个,某个bean上加了此注解,在不指定名称时,Autowired优先注入添加了Primary的bean,如果使用其他bean,则使用Qualifier指定bean
@Lazy
表示容器在启动时不会加载对应的bean,在get对应bean时才会初始化对应bean
@Conditional
按照一定的条件进行组件注册,可根据不同的环境,加载不同的组件
在启动环境是配置参数:-DisTest=true
添加bean组件
@Configuration
@ComponentScan("com.spring.test")
public class MainConfiguration {
@Bean
public Car car1() {
System.out.println("-----------1");
return new Car();
}
@Conditional(TestConditional.class)
@Bean
public Car car2() {
System.out.println("-----------2");
return new Car();
}
}
添加TestConditional,必须实现Condition接口,实现matches方法
可获取环境参数,返回true表示加载对应的bean,否则不加载
public class TestConditional implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
String isTest = conditionContext.getEnvironment().getProperty("isTest");
return "true".equals(isTest);
}
}
@Import
此注解用于向容器导入组件,此注解多用于spring框架扩展,mybatis,AOP都有使用,共有3种用法
@Configuration
@Import(Car.class)
// 手动导入多个类
@Configuration
@Import({Car.class, BenzCar.class})
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
annotationMetadata.getAnnotationTypes().forEach(System.out::println); // 可获取Import此类的类上的注解
return new String[]{Car.class.getName()}; //类的全路径名
}
}
@Configuration
@Import(MyImportSelector.class)
public class MyImportBeanDefinitionRegistry implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(
AnnotationMetadata annotationMetadata,
BeanDefinitionRegistry beanDefinitionRegistry) {
// 添加类定义信息
RootBeanDefinition beanDefinition = new RootBeanDefinition(Car.class);
beanDefinitionRegistry.registerBeanDefinition("car", beanDefinition);
// 删除类定义信息
beanDefinitionRegistry.removeBeanDefinition("indexController");
}
}
@Configuration
@Import(MyImportBeanDefinitionRegistry.class)
FactoryBean
返回的是类中getObject的bean对象,可以设置bean是否为单例,如果需要获取MyFactoryBean,应该添加前缀“&”
@Component
public class MyFactoryBean implements FactoryBean<Car> {
@Override
public Car getObject() throws Exception {
return new Car();
}
@Override
public Class<?> getObjectType() {
return Car.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfiguration.class);
Car car = (Car) ac.getBean("myFactoryBean");
System.out.println(car);
MyFactoryBean factoryBean2 = (MyFactoryBean) ac.getBean("&myFactoryBean");
System.out.println(factoryBean2.isSingleton());
---- 运行结果 ----
Car(name=A6L, brand=Audi)
false
bean生命周期
自定义init和destroy方法
@Data
@AllArgsConstructor
public class Car {
private String name;
private String brand;
public void init() {
System.out.println("执行了init...");
}
public void destroy() {
System.out.println("执行了destroy...");
}
}
// 配置类中注入bean 并制定初始化和销毁方法
@Bean(initMethod = "init", destroyMethod = "destroy")
public Car car2() {
return new Car("A4L", "Audi");
}
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfiguration.class);
ac.close();
---- 运行结果 ----
执行了init...
执行了destroy...
InitializingBean
bean实现InitializingBean接口,可在bean初始化并且属性赋值完成之后执行afterPropertiesSet方法
@Data
@AllArgsConstructor
public class Car implements InitializingBean {
private String name;
private String brand;
public void init() {
System.out.println("执行了init...");
}
public void destroy() {
System.out.println("执行了destroy...");
}
@Override
public void afterPropertiesSet() {
System.out.println(name + "--" + brand);
}
}
// 配置类中注入bean 并制定初始化和销毁方法
@Bean(initMethod = "init", destroyMethod = "destroy")
public Car car2() {
return new Car("A4L", "Audi");
}
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MainConfiguration.class);
ac.close();
---- 运行结果 ----
A4L--Audi
执行了init...
执行了destroy...
BeanPostProcessor
BeanPostProcessor为一个接口, 在bean初始化并且属性赋值完成后执行,其中postProcessBeforeInitialization,在Iinit方法之前; 而postProcessAfterInitialization,则在init方法之后执行
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("before " + beanName + " " + bean);
return null;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("after " + beanName + " " + bean);
return null;
}
}
@Bean(initMethod = "init", destroyMethod = "destroy")
public Car car() {
return new Car("A4L", "Audi");
}
---- 运行结果 ----
before car Car(name=A4L, brand=Audi)
A4L--Audi
执行了init...
after car Car(name=A4L, brand=Audi)
@PostConstruct @PreDestroy
二者作用在bean的方法上, 属于javax的注解; PostConstruct 等同于initMethod; PreDestroy等同于destroyMethod
@PostConstruct
private void postConstruct() {
System.out.println("执行了postConstruct");
}
@PreDestroy
private void preDestroy() {
System.out.println("执行了preDestroy");
}