四、Spring 注解
一、Spring 组件注解
1. @CompentScan 包扫描
/**
* @author wy
* describe `@ComponentScan`注解，包扫描。
*/
@Configuration
// 1. 扫描当前类所在包，及其子包下。
//@ComponentScan
// 2. 扫描指定包下。
//@ComponentScan(basePackages = {"com.qs.springannotation.component_scan.controller"})
// 3. 排除、包含。
@ComponentScan(basePackages = {"com.qs.springannotation.component_scan"},
// 排除（注意：排除优先级高于包含）。
excludeFilters = {
// 根据`注解`排除。
@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class}),
// 根据`类型`排除。
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = {UserService.class}),
// 根据`自定义`排除。
@ComponentScan.Filter(type = FilterType.CUSTOM, value = CustomTypeFilter.class),
},
// 包含（注意：`useDefaultFilters=false`表示只扫描包含的）。
useDefaultFilters = false,
includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Repository.class)
})
public class ComponentScanConfig {
public ComponentScanConfig() {
System.out.printf("`%s`无参构造", this.getClass().getName()).println();
}
}
- TypeFilter 接口
/**
* @author wy
* describe `TypeFilter`接口，类型过滤器。
*/
public class CustomTypeFilter implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
// 获取当前类的`资源信息`。
Resource resource = metadataReader.getResource();
// 获取当前类的`Class源信息`。
ClassMetadata classMetadata = metadataReader.getClassMetadata();
// 获取当前类的`注解源信息`。
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
String className = classMetadata.getClassName();
System.out.printf("类的路径：%s", className).println();
return className.contains("dao");
}
}
public enum FilterType {
/**
* 注解
*/
ANNOTATION,
/**
* 类型
*/
ASSIGNABLE_TYPE,
/**
* AspectJ
*/
ASPECTJ,
/**
* 正则
*/
REGEX,
/**
* 自定义
*/
CUSTOM
}
2. @Scope 范围
/**
* `@Scope` 范围
* 1. `singleton`：单例（默认，饿汉式加载，容器启动实例就创建好了）。
* 2. `prototype`：多例（懒汉式加载，（IOC容器启动的时候，并不会创建对象，而是在第一次使用的时候才会创建）。
* 3. `request`：同一次请求。
* 4. `session`：同一个会话级别。
*/
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Bean("personPrototype")
public Person personPrototype() {
return new Person("personPrototype");
}
/**
* `@Scope` 范围
*/
@Test
public void testScope() {
System.out.println("------------------------------");
// 1. 创建容器（传入`配置类`）。
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(BeanConfig.class);
System.out.println("------------------------------");
// 2. 容器中获取`Bean`。
Object bean = applicationContext.getBean("personPrototype");
// 3. 打印`Bean`。
System.out.println(bean);
// 2. 容器中获取`Bean`。
Object bean2 = applicationContext.getBean("personPrototype");
// 3. 打印`Bean`。
System.out.println(bean2);
/*
------------------------------
`com.qs.springannotation.beans.Person`有参构造，`name = personPrototype`
Person{name='personPrototype'}
`com.qs.springannotation.beans.Person`有参构造，`name = personPrototype`
Person{name='personPrototype'}
*/
applicationContext.close();
}
3. @Lazy 懒加载
/**
* `@Lazy` 懒加载（默认：非懒加载，创建即加载）。
* 主要针对`单例Bean`，容器启动的时候，不创建对象，在第一次使用的时候才会创建该对象。
*/
@Lazy
@Bean(name = "personLazy")
public Person personLazy() {
return new Person("personLazy");
}
/**
* `@Lazy` 懒加载
*/
@Test
public void testLazy() {
System.out.println("------------------------------");
// 1. 创建容器（传入`配置类`）。
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(BeanConfig.class);
System.out.println("------------------------------");
// 2. 容器中获取`Bean`。
Object bean = applicationContext.getBean("personLazy");
// 3. 打印`Bean`。
System.out.println(bean);
/*
------------------------------
------------------------------
`com.qs.springannotation.beans.Person`有参构造，`name = personLazy`
Person{name='personLazy'}
*/
}
4. @Conditional 指定依赖的条件
/**
* @author wy
* describe 条件
*/
public class ConditionalConfig {
@Bean
public Qs qs() {
return new Qs(1);
}
/**
* `@Conditional` 指定依赖的条件。
* 当前容器中必须存在`qs组件`，才会创建`qsHome组件`。
*/
@Conditional(QsCondition.class)
@Bean
public QsHome qsHome(Qs qs) {
return new QsHome(qs);
}
}
/**
* @author wy
* describe `Condition`接口，条件。
*/
public class QsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
// 判断容器中是否存在`qs组件`。
return conditionContext.getBeanFactory().containsBean("qs");
}
}
/**
* `@Conditional` 指定依赖的条件
*/
@Test
public void testConditional() {
System.out.println("------------------------------");
// 1. 创建容器（传入`配置类`）。
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext(ConditionalConfig.class);
System.out.println("------------------------------");
// 2. 容器中获取`Bean`。
Qs qs = applicationContext.getBean(Qs.class);
// 3. 打印`Bean`。
System.out.println(qs);
// 2. 容器中获取`Bean`。
QsHome qsHome = applicationContext.getBean(QsHome.class);
// 3. 打印`Bean`。
System.out.println(qsHome);
/*
------------------------------
`com.qs.springannotation.conditional.Qs`有参构造，`flag = 1`
`com.qs.springannotation.conditional.QsHome`有参构造，`qs = Qs(flag=1)`
------------------------------
Qs(flag=1)
QsHome(qs=Qs(flag=1))
*/
}
5. @Import 导入组件
/**
* @author wy
* describe `@Import`注解，导入`Bean`。
* 用于导入第三方组件。
*/
@Configuration
// 1. 导入一个`Bean`。
//@Import({com.qs.springannotation.import_bean.Qs.class})
// 2. 导入多个`Bean`。
//@Import({Qs.class, QsHome.class})
// 3. `ImportSelector`接口，自动装配。
//@Import({QsHome.class, MyImportSelector.class})
// 4. `ImportBeanDefinitionRegistrar`接口，注册`Bean定义`。
@Import({QsHome.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
public class ImportConfig {
}
- ImportSelector
/**
* @author wy
* describe `ImportSelector`自动装配
*/
public class MyImportSelector implements ImportSelector {
/**
* 可以获取导入类的注解信息。
*/
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
// 导入组件的id，为全类名路径。
return new String[]{"com.qs.springannotation.import_bean.Qs"};
}
}
- ImportBeanDefinitionRegistrar 注册 Bean 定义。
/**
* @author wy
* describe `ImportBeanDefinitionRegistrar`接口，注册`Bean定义`。
*/
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(QsHome.class);
// 导入组件，可以指定`Bean名称`。
beanDefinitionRegistry.registerBeanDefinition("qsHome2", rootBeanDefinition);
}
}
6. @AutoWired 自动装配
/**
* @author wy
* describe `@Autowired`注解，自动装配。
*/
@Data
@Service
public class AutowiredService {
private int flag = 0;
/**
* `@Autowired`注解，自动装配。
* 自动装配首先时按照`类型装配`，若在`IOC容器`中发现了多个相同类型的组件，那么就按照`属性名称`来进行装配。
*
* 比如：容器中有二个`AutowiredDao`类型的组件，`autowiredDao`和`autowiredDao1`。
* 1. 通过`@AutoWired`来修饰的`autowiredDao`属性名称时，那么就加载容器的`autowiredDao`组件。
* 2. 若属性名称为`autowiredDao1`时，那么就加载`autowiredDao1`组件。
*/
@Autowired
private AutowiredDao autowiredDao;
@Autowired
private AutowiredDao autowiredDao1;
/**
* 假设容器中即没有`autowiredDao9`，那么在装配的时候就会抛出异常。
* No qualifying bean of type 'com.qs.springannotation.autowired.dao.AutowiredDao' available:
* expected single matching bean but found 3: autowiredDao,autowiredDao1,autowiredDao2
* 若不想抛异常，需要指定`required=false`就可以了。
*/
@Autowired(required = false)
@Qualifier(value = "autowiredDao9")
private AutowiredDao autowiredDao9;
}
6.1 @Autowired 方法注入
/**
* 标注在`配置类上的入参`中（可以不写）。
*/
@Bean
public AutowiredMethodService autowiredMethodService2(@Autowired AutowiredDao autowiredDao) {
AutowiredMethodService service = new AutowiredMethodService();
service.setAutowiredDao(autowiredDao);
return service;
}
@Data
@Primary
@Service
public class AutowiredMethodService {
@Autowired
private AutowiredDao autowiredDao;
public AutowiredMethodService() {
System.out.printf("`%s`无参构造", this.getClass().getName()).println();
}
/**
* 标注在`构造方法`上。
*/
@Autowired
public AutowiredMethodService(AutowiredDao autowiredDao1) {
System.out.printf("`%s`有参构造，`autowiredDao = %s`", this.getClass().getName(), autowiredDao).println();
this.autowiredDao = autowiredDao1;
}
public AutowiredDao getAutowiredDao() {
return autowiredDao;
}
/**
* 标注在`setXX`上。
*/
@Autowired
public void setAutowiredDao(AutowiredDao autowiredDao2) {
System.out.printf("`%s`.setAutowiredDao，`autowiredDao = %s`", this.getClass().getName(), autowiredDao).println();
this.autowiredDao = autowiredDao2;
}
}
7. @Qualifier 指定名称装配
/**
* @author wy
* describe `@Qualifier`指定名称装配
*/
@Data
@Service
public class QualifierService {
private int flag = 1;
/**
* `@Qualifier`注解，指定名称装配。
*
* `@AutoWired`默认使用`BY_NAME`。
* 当发现多个`同类型的Bean`，就通过`BY_NAME`。
* 需要通过名称装配，使用`@Qualifier`指定名称装配。
*/
@Qualifier(value = "autowiredDao1")
@Autowired
private AutowiredDao autowiredDao;
@Qualifier(value = "autowiredDao")
@Autowired
private AutowiredDao autowiredDao1;
}
8. @Primary 存在多个按类型装配时标记默认的
/**
*`@Primary`注解，按类型（`BY_TYPE`）装配时优先。
*/
@Primary
@Bean
public AutowiredDao autowiredDao2() {
AutowiredDao dao = new AutowiredDao();
dao.setFlag(2);
return dao;
}
/**
* 默认通过类型（`BY_TYPE`），当发现多个`同类型的Bean`，就通过名称（`BY_NAME`）。
*/
@Primary
@Bean(autowire = Autowire.BY_TYPE)
// @Bean(autowire = Autowire.BY_NAME)
public AutowiredService autowiredService3() {
AutowiredService service = new AutowiredService();
service.setFlag(3);
return service;
}
/**
* @author wy
* describe `@Primary`注解，按类型（`BY_TYPE`）装配时优先。
*/
@Data
@Service
public class PrimaryService {
private int flag = 2;
/**
* `@Autowired`失败问题。
* 1. `Service`使用类型（`BY_TYPE`）注入时，`Dao`会注入`@Primary`修饰的。
* 2. `Service`使用名称（`BY_NAME`）注入时，`Dao`只能使用名称注入。
*/
@Autowired
private AutowiredDao autowiredDao;
@Qualifier(value = "autowiredDao1")
@Autowired
private AutowiredDao autowiredDao1;
@Autowired
private AutowiredDao autowiredDao2;
}
10. @Resource JSR250 规范
/**
* @author wy
* describe `@Resource`注解，`JSR250`规范。
* 和`@AutoWired`的功能差不多一样，但是不支持`@Primary`和`@Qualifier`。
*/
@Data
@Service
public class ResourceService {
@Resource
private AutowiredDao resourceDao;
}
11. @InJect JSR330 规范
/**
* @author wy
* describe `@InJect`注解，`JSR330`规范。
* 需要导入`jar`包`javax.inject`。
* 和`@AutoWired`的功能差不多一样，支持`@Primary`和`@Qualifier`，但是没有`require=false`的功能。
*/
@Service
@Data
public class InjectService {
@Inject
private AutowiredDao injectDao;
}
二、Spring 配置注解
1. @Profile 环境注入
/**
* @author wy
* describe `@Profile`注解，环境注入，根据环境来激活标识不同的Bean。
* 1. `@Profile`标识在类上，那么只有当前环境匹配，整个配置类才会生效。
* 2. `@Profile`标识在`Bean`上 ，那么只有当前环境的Bean才会被激活。
* 3. 没有标志为`@Profile`的`Bean`，不管在什么环境都可以被激活。
*
* `EmbeddedValueResolverAware`接口，内嵌式值解析器。
*/
@Configuration
@PropertySource(value = {"classpath:ds.properties"})
public class ProfileConfig implements EmbeddedValueResolverAware {
private String classDriver;
private String jdbcUrl;
@Value("${ds.username}")
private String userName;
@Value("${ds.password}")
private String password;
@Override
public void setEmbeddedValueResolver(StringValueResolver stringValueResolver) {
this.jdbcUrl = stringValueResolver.resolveStringValue("${ds.jdbcUrl}");
this.classDriver = stringValueResolver.resolveStringValue("${ds.classDriver}");
}
/**
* 标识为测试环境，才会被装配。
*/
@Bean
@Profile(value = "test")
public DataSource testDS() {
return buildDataSource(new DruidDataSource());
}
/**
* 标识开发环境，才会被激活。
*/
@Bean
@Profile(value = "dev")
public DataSource devDS() {
return buildDataSource(new DruidDataSource());
}
/**
* 标识生产环境，才会被激活。
*/
@Bean
@Profile(value = "prod")
public DataSource prodDS() {
return buildDataSource(new DruidDataSource());
}
private DataSource buildDataSource(DruidDataSource dataSource) {
dataSource.setDriverClassName(classDriver);
dataSource.setUrl(jdbcUrl);
dataSource.setUsername(userName);
dataSource.setPassword(password);
return dataSource;
}
}
AnnotationConfigApplicationContext applicationContext =
new AnnotationConfigApplicationContext();
// 设置环境属性（或者JVM参数`-Dspring.profiles.active=test,dev,prod`）
applicationContext
.getEnvironment()
.setActiveProfiles("test", "dev");
2. @PropertySource + @Value 组件赋值
- @PropertySource 导入属性配置文件
/**
* @author wy
* describe `@PropertySource`导入属性配置文件。
*/
@Configuration
@PropertySource(value = {"classpath:person.properties"})
public class ValueConfig {
@Bean
public Person person() {
return new Person();
}
}
- @Value 注入属性
/**
* @author wy
* describe `@Value`注解，注入属性
*/
@Data
public class Person {
@Value("骑士")
private String firstName;
/**
* `SPEL`表达式。
*/
@Value("#{28-8}")
private Integer age;
/**
* 读取外部配置文件的值
*/
@Value("${person.lastName}")
private String lastName;
}