Spring 注解篇
文章目录
一、注解
1.用于创建对象的注解
定义:是指由一个工厂对象决定创建出哪一种产品类
提示:这些注解的作用和在xml中配置标签的作用一样。
● @Component
作用: 用于将当前类对象存入Spring容器中
属性:value属性用于指定存入spring容器中的bean的id,不配置时默认为:当前类的类名首字母转小写
● @Controller
一般用在表现层。
作用、属性同@Component完全一样。
● @Service
一般用在业务层。
作用、属性同@Component完全一样。
● @Repository
一般用在持久层。
作用、属性同@Component完全一样。
提示:@Controller、@Service、@Repository三个注解的作用、属性同@Component完全一样
2.用于注入数据的注解
这些注解的作用和xml配置的标签下的标签的作用是一样的。
@Autowired、@Qualifier、@Resource三个注解只能注入bean类型的数据,不能注入基本数据类型和String类型。
● @Autowired
作用:
自动按照类型注入,只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配,就可以注入成功。
如果IoC容器中没有任何bean的类型和要注入的变量的类型匹配,则报错。
如果IoC容器中该类型的bean存在多个,则将要注入的变量的变量名作为bean的id进行二次匹配:
如果根据变量名可以找到唯一的bean,则进行注入。
如果根据变量名匹配不到,则报错。
出现位置:可以使变量上,也可以是方法上。
细节:在使用注解进行注入时,变量的setter方法就不是必须的了。
@Autowired有一个属性required,默认为true。如果设置为false,则该对象可以在获取不到bean时默认为null。
- 标注在属性上
public class Boss {
@Autowired
private Car car;
}
- 标注在方法上
Spring容器创建当前对象,就会调用方法,完成赋值。
方法使用的参数,自定义类型的值从ioc容器中获取。
示例:
@Autowired
public void setCar(Car car) {
this.car = car;
}
- 标注在有参构造器上
默认加在ioc容器中的组件,容器启动会调用无参构造器创建对象,再进行初始化赋值等操作。
给bean移除无参构造器,添加一个有参构造器,为该有参构造器添加@Autowired注解。Spring容器启动时会调用该有参构造器,并从ioc容器中获取参数对应类型的bean对象进行注入。
@Autowired
public Boss(Car car) {
this.car = car;
}
- 标注在构造器参数位置
public Boss(@Autowired Car car) {
this.car = car;
}
如果当前类只有一个有参构造器,Spring容器创建该bean只能调用该有参构造器,有参构造器的@Autowired可以省略,参数依然可以从ioc容器中获取:
使用构造函数进行注入时,需要标注final来表示这个注入的变量不能被改变。
在@Configuration类中通过@Bean将Color加入容器,并使用@Autowired注入Car:
● @Qualifier
作用:
在按照类型匹配的基础上,再按照名称匹配注入。
它在给类的成员变量注入时,不能单独使用,要和@Autowired配合使用。当按照类型注入冲突时配合@AutoWired
它在给方法参数进行注入时,可以单独使用。
属性:
value:用于指定要注入的bean的id。
● @Resource
作用:直接按照bean的id进行注入。它可以独立使用。
属性:
name:用于指定bean的id。
● @Value
作用:用于注入基本类型和String类型的变量
属性:
value:用于指定数据的值。可以配置:字面量、${key}(从环境变量、配置文件中获取值)、使用Spring中的SpEL(Spring中的EL表达式:#{表达式})。
public class Person {
@Value("张三")
private String name;
@Value("#{ 10 + 8} ")
private Integer age;
@Value("${person.nickName}")
private String nickName;
// getter/setter方法
}
●@Inject
和@Autowired功能类似,但是没有required属性。
需要导入包
<dependency>
<gourpId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
3.用于改变作用范围的注解
提示:这些注解的作用和xml配置的标签的scope属性的作用一样。
●@Scope
作用:用于指定bean的作用范围。
属性:
value:指定范围的取值。常用取值:singleton、prototype。(不配置时默认为singleton)
● value
取值:
● ConfigurableBeanFactory.SCOPE_SINGLETON : “singleton”,单实例(默认值),ioc容器启动就会调用方法创建对象到ioc容器中。
● ConfigurableBeanFactory.SCOPE_PROTOTYPE : “prototype”,多实例,ioc容器启动时并不会调用方法创建对象,每次获取时才会调用方法创建对象。
● WebApplicationContext.SCOPE_REQUEST:“request”,同一个请求创建一个实例
● WebApplicationContext.SCOPE_SESSION:“session”,同一个session创建一个实例
● scopeName
同’value’
●@Profile
Spring为我们提供的可以根据当前环境,动态的激活和切换一系列Bean的功能。
指定组件在哪个环境的情况下才能被注册到容器中,不指定时在任何环境下都能注册这个组件。
加了@Profile环境标识的bean,只有这个环境被激活的时候才能被注册到容器中。默认是default环境。
例如:
@Profile("default")
@Bean("defaultDataSource")
public DataSource dataSourceDefault(@Value("${db.password}") String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("test") // value可以随便自定义
@Bean("color")
public Color color() {
return new Color();
}
@Profile("test")
@Bean("testDataSource")
public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("dev")
@Bean("devDataSource")
public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
切换激活profile环境:(不切换时,系统默认为default环境)
使用 JVM 命令行参数
添加 VM arguments:-Dspring.profiles.active=test,便可以将环境切换到test环境
使用ioc无参构造器,激活环境配置
如果使用有参构造器AnnotationConfigApplicationContext(Class<?>… annotatedClasses)获取ioc容器,该构造函数中会执行以下代码:
可以使用无参构造器手动调用这些方法,实现这个效果。同时,可以在注册配置类之前,切换环境配置,防止把配置类中所有配置全部加载:
通过无参构造器获取ioc容器
通过ioc容器的environment对象切换环境(可以同时配置多个环境)
调用register注册主配置类
调用refresh加载bean
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
@Test
public void test01() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.getEnvironment().setActiveProfiles("dev", "test");
applicationContext.register(MainConfigOfProfile.class);
applicationContext.refresh();
String[] beans = applicationContext.getBeanNamesForType(DataSource.class);
Arrays.asList(beans).forEach(System.out::println);
}
@Profile也可以注解在配置类上:只有在指定的环境的时候,整个配置类里面的所有配置才能生效。
如果此时激活的环境为dev:虽然devDataSource这个bean上配置的环境是dev,但是因为整个配置类的环境是test,所以整个配置类都不进行加载,devDataSource也不会进行加载。
@Profile("test")
@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {
@Value("${db.user}")
private String user;
private StringValueResolver resolver;
private String driverClass;
@Profile("default")
@Bean("defaultDataSource")
public DataSource dataSourceDefault(@Value("${db.password}") String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("test")
@Bean("testDataSource")
public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("dev")
@Bean("devDataSource")
public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Profile("prod")
@Bean("prodDataSource")
public DataSource dataSourceProd(@Value("${db.password}")String pwd) throws Exception{
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(user);
dataSource.setPassword(pwd);
dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
dataSource.setDriverClass(driverClass);
return dataSource;
}
@Override
public void setEmbeddedValueResolver(StringValueResolver resolver) {
this.resolver = resolver;
this.driverClass = resolver.resolveStringValue("${db.driverClass}");
}
}
4.和生命周期相关的注解
提示:这些注解的作用和xml配置的标签的init-method、destroy-method属性作用相同。
● @PreDestroy
作用:用于指定销毁方法。
● @PostConstruct
作用:用于指定初始化方法。
@Service("accountService")
@Scope("prototype")
public class AccountServiceImpl implements IAccountService {
@Value("${server.port}")
private String port;
@Resource(name = "accountDao")
private IAccountDao accountDao;
@Autowired
@Qualifier("hAccountDao")
private HAccountDao hAccountDao;
public void saveAccount() {
accountDao.saveAccount();
}
@PostConstruct
public void init() {
System.out.println("初始化方法");
}
@PreDestroy
public void destroy() {
System.out.println("销毁方法");
}
}
● @Lazy
作用:针对单实例的Bean。单实例Bean默认在容器启动时创建对象。懒加载在第一次使用Bean时才创建对象并初始化。
@Bean
@Lazy
public Person person() {
System.out.println("方法调用了。");
return new Person("ZhangSan", 10);
}
● @Conditional
作用:照条件进行判断,满足条件才给容器中注册Bean。该注解在Spring、SpringBoot底层中经常使用
value属性需要传入一个判断条件,该判断条件是一个实现了Condition接口的类。
自定义判断条件类
public class MyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// 获取类加载器
ClassLoader classLoader = context.getClassLoader();
// 获取ioc使用的beanFactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
// 获取到bean定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();
ResourceLoader resourceLoader = context.getResourceLoader();
// 获取当前环境信息
Environment environment = context.getEnvironment();
String osName = environment.getProperty("os.name");
return osName.startsWith("Linux");
}
}
测试小技巧:
os.name是获取当前系统,默认取的当前系统的系统名称,但是我们可以在 JVM 参数上强制给一个值。
VM options: -Dos.name=linux
在bean上加上判断条件
@Bean("person01")
@Conditional(MyCondition.class)
public Person person01() {
return new Person("lisi", 18);
}
该注解也可以用在类上,对类中所有bean统一设置:
@Configuration
@Conditional(MyCondition.class)
public class MyConfig {
@Bean("person")
public Person person() {
return new Person("ZhangSan", 10);
}
@Bean("person01")
public Person person01() {
return new Person("lisi", 18);
}
}
5.在配置类中利用java方法创建bean
提示:当我们需要在程序中使用commons-dbutils去操作数据库时,需要创建DataSource、QueryRunner对象存入Spring的容器。创建对象、存入容器的过程可以放在一个配置类中,将创建对象的方法返回值作为bean存入容器。
设置配置类的不同方式:
- 在AnnotationConfigApplicationContext构造方法中传参:
- 使用@Configuration注解声明配置类:(需要在主配置类中使用@ComponentScan注解扫描到该配置类所在的包)
- 使用@Import注解导入其他配置
● @Configuration
作用:指定当前类为一个配置类
细节:当该类作为AnnotationConfigApplicationContext对象创建的参数时,该注解可以不写。
● @ComponentScan
作用:指定Spring在创建容器时要扫描的包。作用和xml中配置的context:component-scan一样。
属性:value/basePackages:两个属性的作用一样,都是指定创建容器时要扫描的包。属性的值为数组。
● value
要扫描的包,等同于basePackages
● basePackages
同value
● includeFilters
指定只包含的组件
属性值是一个@Filter数组
● excludeFilters
指定排除的组件。
属性值是一个@Filter数组
示例:扫描com.study包下的组件,排除@Controller、@Service注解的类
@Configuration
@ComponentScan(value = "com.study", excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
})
public class MyConfig {
@Bean
public Person person() {
return new Person("ZhangSan", 10);
}
}
示例:只包含@Controller、@Service注解的类。(需要先禁用默认的过滤规则useDefaultFilters=false,因为默认的过滤规则是全部扫描)
@Configuration
@ComponentScan(value = "com.study",
useDefaultFilters = false,
includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
})
public class MyConfig {
@Bean
public Person person() {
return new Person("ZhangSan", 10);
}
}
● @ComponentScans
作用:指定Spring在创建容器时要扫描的包。作用和xml中配置的context:component-scan一样。
属性:value/basePackages:两个属性的作用一样,都是指定创建容器时要扫描的包。属性的值为数组。
@ComponentScan使用了 JDK8的@Repeatable的注解,表示这个注解可以在一个类上多次使用。
如果使用的 JDK7,则可以使用@ComponentScans,value属性为 @ComponentScan数组。
● @Bean
作用:将方法的返回值作为一个bean对象,存入Spring的IoC容器中。
属性:value/name:两个属性的作用一样,用于指定bean的id。不配置该属性时,默认以方法名作为id。
细节:当我们给方法配置@Bean注解时,如果方法有参数,Spring会去容器中查找有无可用的bean对象。查找的方式和@Autowired相同。
●@ComponentScan.Filter
作用:配置包扫描的过滤规则
@Filter
type
要排除的方式:FilterType。
Annotation:按照注解
Assignable_type:按照给定的类
AspectJ:使用AspectJ表达式
Regex:使用正则表达式
Custom:使用自定义规则,该规则必须是TypeFilter的实现类
value
要排除的类型,同classes
classes
同value
pattern
正则表达式
自定义TypeFilter规则:
MetadataReader:读取到的当前正在扫描的类的信息
MetadataReaderFactory:可以获取到其他任何类的信息
实例:
public class MyTypeFilter implements TypeFilter {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
// 获取当前正在扫描类的注解信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
// 获取当前正在扫描的类的类信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
// 获取当前的资源信息
metadataReader.getResource();
String className = classMetadata.getClassName();
return "com.study.book.dao.BookDao".equals(className);
}
}
配置:
@Configuration
@ComponentScan(value = "com.study",
useDefaultFilters = false,
includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
})
public class MyConfig {
// ...
}
● @Import
作用:用于导入其他的配置类。
属性:value:用于指定要导入的其他配置类的字节码文件。当使用@Import的注解之后,有@Import注解的就是主配置类,而导入的都是子配置类。
使用方式:
@Configuration
public class JdbcConfiguration {
// ....
}
@Configuration
@ComponentScan("com.study")
@Import(JdbcConfiguration .class)
public class SpringConfiguration {
@Bean("runner")
@Scope("prototype") // Spring容器的bean默认为单例,为避免不同数据库操作之间的干扰,此处应该使用Scope将runner指定为多例
public QueryRunner createQueryRunner(DataSource dataSource) {
return new QueryRunner(dataSource);
}
@Bean("dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("oracle.jdbc.driver.OracleDriver");
dataSource.setJdbcUrl("jdbc:oracle:thin:@127.0.0.1:1521/orcl");
dataSource.setUser("springtest");
dataSource.setPassword("tiger");
return dataSource;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
}
@Test
public void testFindAll(){
// 读取配置类中的配置(如果有多个配置类,也可以传入多个配置类)
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
IAccountService as = ac.getBean("accountService", IAccountService.class);
as.findAllAccount().forEach(System.out::println);
}
给容器中注册组件:
● 包扫描+组件标注注解(@Controller、@Service、@Repository、@Component)[自己写的类]
● @Bean [导入的第三方包里面的组件]
● @Import[快速的给容器中导入一个组件]
● 使用Spring提供的FactoryBean(工厂bean)
自定义ImportSelector:
AnnotationMetadata:当前标注@Import注解的类的所有注解信息。
返回值不能是null,否则会报空指针异常。如果需要返回的内容,则需使用:return new String[0]。
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.study.bean.Yellow", "com.study.bean.Blue"};
}
}
自定义ImportBeanDefinitionRegistrar:
AnnotationMetadata:当前类的注解信息
BeanDefinitionRegistry:BeanDefinition注册类。需要添加到容器中的Bean,可以通过BeanDefinitionRegistry.registerBeanDefinition手工注册进来。
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
String[] beanDefinitionNames = registry.getBeanDefinitionNames();
Arrays.asList(beanDefinitionNames).forEach(System.out::println);
// 判断ioc容器中是否注册了指定id的Bean
boolean redDefinition = registry.containsBeanDefinition("com.study.bean.Red");
boolean blueDefinition = registry.containsBeanDefinition("com.study.bean.Blue");
if(redDefinition && blueDefinition) {
// 调用registry的registerBeanDefinition方法手工注册Bean
// 使用RootBeanDefinition指定要注册的Bean的类型
RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
// 指定注册进容器的bean的id
registry.registerBeanDefinition("rainBow", beanDefinition);
}
}
}
配置示例:
@Configuration
@Conditional(MyCondition.class)
@Import({Color.class, Red.class, MyImportSelector.class}) // 可以同时配置要导入的类名、ImportSelector、ImportBeanDefinitionRegistrar
public class MyConfig {
@Bean("person")
public Person person() {
return new Person("ZhangSan", 10);
}
}
推荐博文:https://blog.csdn.net/qq_15719169/article/details/119252781
6.从properties配置文件中获取配置
提示: 使用@PropertySource指定读取的配置文件路径:
@PropertySource
是一个可重复使用的注解。
●@PropertySource的value属性可以传多个路径。
或者使用@PropertySources指定多个@PropertySource
编写jdbcConfig.properties配置文件:
jdbc.driver=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521/orcl
jdbc.username=springtest
jdbc.password=tiger
在JdbcConfig.java中获取properties中配置的信息
@Configuration
@ComponentScan({"com.study","com.config"})
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {
}
在JdbcConfig.java中获取properties文件中的配置信息
@Configuration
public class JdbcConfig {
@Value("${jdbc.driver}")
private String jdbcDriver;
@Value("${jdbc.url}")
private String jdbcUrl;
@Value("${jdbc.username}")
private String jdbcUser;
@Value("${jdbc.password}")
private String jdbcPassword;
@Bean("dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass(jdbcDriver);
dataSource.setJdbcUrl(jdbcUrl);
dataSource.setUser(jdbcUser);
dataSource.setPassword(jdbcPassword);
return dataSource;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
}
二、接口
1.FactoryBean接口
Spring提供的 工厂Bean接口
自定义FactoryBean,用来生成Color的Bean:
public class ColorFactoryBean implements FactoryBean<Color> {
// 返回一个color对象,这个对象会添加进容器中
@Override
public Color getObject() throws Exception {
return new Color();
}
// 返回的对象的类型
@Override
public Class<?> getObjectType() {
return Color.class;
}
// 是否为单例:true代表这个bean是单实例的,false代表每次获取都会创建一个新的bean
@Override
public boolean isSingleton() {
return true;
}
}
添加该FactoryBean为Bean:
public class ColorFactoryBean implements FactoryBean<Color> {
// 返回一个color对象,这个对象会添加进容器中
@Override
public Color getObject() throws Exception {
return new Color();
}
// 返回的对象的类型
@Override
public Class<?> getObjectType() {
return Color.class;
}
// 是否为单例:true代表这个bean是单实例的,false代表每次获取都会创建一个新的bean
@Override
public boolean isSingleton() {
return true;
}
}
在获取colorTest这个Bean时,实际获取到的bean对象的类型是ColorFactoryBean::getObjectType()返回的类型,即Color类型。获取到的Bean对象是ColorFactoryBean::getObject()创建的对象。
如果想要获取ColorFactoryBean类型的bean对象,需要在BeanID前添加前缀&,即&colorTest。这个前缀是在BeanFactory.FACTORY_BEAN_PREFIX中定义的。
2.Aware接口
自定义组件想要使用Spring容器底层的一些组件(例如ApplicationContext、BeanFactory、BeanName等),实现xxxAware接口,在创建对象的时候,会调用接口规定的方法,注入相应的组件。
xxxAware的总接口为Aware接口。xxxAware的对应的解析为xxxAwarePropressor。
示例:
在Bean中注入ioc容器ApplicationContext,实现ApplicationContextAware接口
public class Car implements ApplicationContextAware {
private ApplicationContext applicationContext;
public Car() {
System.out.println("Car constructor...");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("为car注入applicationContext");
this.applicationContext = applicationContext;
}
}
String值解析器(可以解析String、SpEL表达式、环境变量值、配置文件值):
public class Person implements EmbeddedValueResolverAware {
@Override
public void setEmbeddedValueResolver(StringValueResolver resolver) {
String str = resolver.resolveStringValue("test: #{ 10 * 2} ==== ${person.nickName} ==== ${os.name} .");
System.out.println(str);
}
}