【Spring进阶系列丨第七篇】Spring框架新注解分类及详解

2024-04-06 17:52

本文主要是介绍【Spring进阶系列丨第七篇】Spring框架新注解分类及详解,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

  • 一、Spring新注解
    • 1.1、Configuration注解
      • 1.1.1、定义一个类
      • 1.1.2、使用Configuration注解修饰类
      • 1.1.3、作用
    • 1.2、Bean注解
      • 1.2.1、定义bean
      • 1.2.2、在主配置类中注册bean
      • 1.2.3、测试容器中是否有该bean
      • 1.2.4、注册bean的同时可以指定bean名称
      • 1.2.5、补充内容
        • 1.2.5.1、案例1【方法有参数】
        • 1.2.5.2、案例2
    • 1.3、ComponentScan注解
      • 1.3.1、案例1
      • 1.3.2、案例2
      • 1.3.3、案例3
    • 1.4、Scope注解
      • 1.4.1、定义Bean
      • 1.4.2、注册Bean并定义作用域
      • 1.4.3、测试
      • 1.4.4、将Bean的作用域改为多例
      • 1.4.5、测试1
      • 1.4.6、测试2
    • 1.5、Lazy注解
      • 1.5.1、注册Bean
      • 1.5.2、测试
      • 1.5.3、总结
    • 1.6、Conditional注解【了解】
      • 1.6.1、定义两个Bean
      • 1.6.2、定义两个类实现Condition接口
      • 1.6.3、注册Bean
      • 1.6.4、测试1
      • 1.6.5、测试2
      • 1.6.6、总结
    • 1.7、Import注解
      • 1.7.1、用法一
        • 1.7.1.1、定义Bean
        • 1.7.1.2、注册Bean
        • 1.7.1.3、测试容器中是否有该Bean
        • 1.7.1.4、注意
      • 1.7.2、用法二
        • 1.7.2.1、定义Bean
        • 1.7.2.2、新建配置类并注册Bean
        • 1.7.2.3、Import导入配置类
        • 1.7.2.4、测试容器有哪些Bean
        • 1.7.2.5、总结
    • 1.8、PropertySource注解
      • 1.8.1、定义Pig.properties文件
      • 1.8.2、主配置类
      • 1.8.3、测试
  • 好书推荐

在这里插入图片描述

一、Spring新注解

1.1、Configuration注解

1.1.1、定义一个类

public class SpringMainConfig {}

1.1.2、使用Configuration注解修饰类

@Configuration
public class SpringMainConfig {}

1.1.3、作用

​ 使用Configuration注解修饰的类表示的是:当前类是一个配置类。该类的作用和beans.xml是一样的,换句话说,该注解所修饰的类就是用来代替beans.xml文件的。

1.2、Bean注解

1.2.1、定义bean

public class User {private Integer id;private String name;public User(Integer id, String name) {this.id = id;this.name = name;}
}

1.2.2、在主配置类中注册bean

​ 在以前,使用xml去注册bean的时候,使用的是bean标签,形如:

<bean id="user" class="cn.bdqn.User"/>

​ 现在改为使用注解,使用的是@Bean注解。

@Configuration
public class SpringMainConfig {// 给容器中注册一个bean;类型为方法返回值的类型,默认方法名作为id,即bean的名字默认是方法名@Beanpublic User user(){return new User(1,"段康家");}
}

1.2.3、测试容器中是否有该bean

@Test
public void testUser() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);User user = (User) ac.getBean("user");System.out.println(user);	// User{id=1, name='段康家'}
}

1.2.4、注册bean的同时可以指定bean名称

@Configuration
public class SpringMainConfig {// 给容器中注册一个Bean;类型为返回值的类型,id默认是用方法名作为id// 可以再注册Bean的同时,不用方法名作为id,可以指定bean的名称。@Bean("user01")public User user(){return new User(1,"段康家");}
}

1.2.5、补充内容

1.2.5.1、案例1【方法有参数】
// 定义UserDao接口
public interface UserDao {}
// 定义UserDao接口的实现类
public class UserDaoImpl01 implements UserDao{}
// 定义UserService
public class UserServiceImpl {private UserDao userDao;// 构造方法接收UserDao类型的对象public UserServiceImpl(UserDao userDao){this.userDao = userDao;}
}

重点看主配置类:

@Configuration
public class SpringMainConfig {// 给容器中注册一个Bean;类型为返回值的类型,id默认是用方法名作为id@Beanpublic UserServiceImpl userService(UserDao userDao){return new UserServiceImpl(userDao);}@Beanpublic UserDao userDao01(){return new UserDaoImpl01();}
}
 @Test
public void testUser() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);UserServiceImpl userService = (UserServiceImpl) ac.getBean("userService");System.out.println(userService);
}

说明:测试后发现程序能够正常运行,说明UserDao能够正常的以构造函数参数的形式注入到UserServiceImpl类中。

总结:当我们使用Bean注解配置方法时,如果方法有参数,spring框架会去容器中查找有没有可用的bean对象。查找的方式和Autowired注解的作用是一样的。即:Spring会从容器中根据类型注入

1.2.5.2、案例2

当然还有一种情况是:容器中注册了多个相同类型的Bean,那么Spring又是如何注入的呢?在8.2.5.1案例基础之上再添加一个UserDaoImpl02。

public class UserDaoImpl02 implements UserDao{}

在再主配置类中注册该UserDaoImpl02的Bean.

在这里插入图片描述

通过看图可以知道,有问题,不能够实现自动注入,该怎么办呢?两种方式:

a、修改方法的参数

在这里插入图片描述

b、指定Bean的名称

在这里插入图片描述

总结:本质上来说,解决方案1和解决方案2是一样的。

c、使用Qualifier注解。

​ 实际上在7.3.2章节中,已经讲到了关于Qualifier注解的使用,通过该注解实现的功能是:当系统中存在多个相同类型的bean的时候,Spring就会注入失败,这个时候就需要再根据名称实现注入,而使用Qualifier注解可以达到根据给定名称的bean实现注入 。在以前讲解的过程中,我们是把该注解应用到了对类的成员变量上 ,但是需要注意的细节是:该注解应用到成员变量上时,注入时不能单独使用,需要搭配Autowired注解 。 但是,这里有一个例外,那么就是该注解也可以应用在方法参数上。

在这里插入图片描述

特别注意:当把Qualifier注解应用在方法参数上时,可以单独使用

1.3、ComponentScan注解

==作用:==指定spring在创建容器时要扫描的包。作用就如同在配置文件中这样的定义:

<beans><context:component-scan base-package="cn.bdqn"/>
</beans>

1.3.1、案例1

第一步:定义三个Bean,分别是CatController、CatService、CatMapper,并分别用@Controller、@Service、@Repository修饰。

package cn.bdqn.controller;@Controller
public class CatController {}
package cn.bdqn.service;@Service
public class CatServiceImpl {}
package cn.bdqn.mapper;@Repository
public class CatMapper {}

第二步:要想真正的注册到容器中,就必须要让容器扫描到此注解所修饰的类所在的包。

@Configuration
@ComponentScan(value = {"cn.bdqn"})
public class SpringMainConfig {
}

第三步:测试容器中是否注册了该bean。

@Test
public void testComponentScan() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);// 获取Spring容器中已经注册好的bean,把所有bean的名字获取出来String[] names = ac.getBeanDefinitionNames();for (String name:names) {System.out.println(name);}
}
/**结果:catControllercatMappercatServiceImpl
*/

总结:默认情况下,Spring会扫描cn.bdqn包以及子包下面所有的使用@Controller、@Service、@Repository、@Component所修饰的bean注册到容器中

1.3.2、案例2

**需求:**我现在不想扫描被@Controller所修饰的类注册到容器中,即让Spring扫描不到即可。言外之意就是:把所有被@Controller所修饰的类给排除掉。

说明:定义的CatController、CatServiceImpl、CatMapper不变,使用的是案例1。唯一要修改的配置是主配置文件类。为@ComponentScan注解添加excludeFilters属性即可。

**含义:**excludeFilters的作用指定扫描的时候按照什么规则排除那些组件。

**做法:**修改主配置类,即

@Configuration
@ComponentScan(value = {"cn.bdqn"},excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class})}
)
public class SpringMainConfig {}

**测试:**测试代码同案例1

/**catMappercatServiceImpl
**/

1.3.3、案例3

**需求:**我现在只想扫描被@Controller所修饰的类注册到容器中,被其他修饰的注解不扫描。

说明:定义的CatController、CatServiceImpl、CatMapper不变,使用的是案例1。唯一要修改的配置是主配置文件类。为@ComponentScan注解添加includeFilters属性即可。

**含义:**includeFilters的作用指定扫描的时候只需要包含哪些组件。

**做法:**修改主配置类,即

@Configuration
@ComponentScan(value = {"cn.bdqn"},includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, Service.class})}
)
public class SpringMainConfig {
}

**测试:**测试代码同案例1

/**catControllercatMappercatServiceImpl测试,发现,不仅仅Controller被扫描进来了,包括Service,Mapper也都扫描进来了,好像不起作用,没有生效,原因是在于在使用includeFilters做只包含的时候,还需要关闭默认的过滤规则【在默认情况下,Spring是扫描指定包及子包下的被@Component、@Controller、@Service等bean的。】
*/

主配置文件类修改如下:

@Configuration
@ComponentScan(value = {"cn.bdqn"},includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, Service.class})},useDefaultFilters = false
)
public class SpringMainConfig {
}

测试:

/**catController测试发现:结果正常,符合预期结果,只扫描到了Controller注解。
*/

1.4、Scope注解

作用:可以改变bean的作用域。在Spring中,Bean的默认作用域是单例的。

1.4.1、定义Bean

public class User {private Integer id;private String name;public User(Integer id, String name) {this.id = id;this.name = name;}
}

1.4.2、注册Bean并定义作用域

@Configuration
public class SpringMainConfig {@Bean@Scopepublic User user(){System.out.println("对象创建啦");return new User(1,"HelloWorld");}
}

1.4.3、测试

 @Test
public void testComponentScan() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
}
/**对象创建啦
*/

结果:注册的Bean默认是单实例的,Spring容器将会在启动的时候调用方法创建对象后放入容器中,以后每次需要拿对象了就直接从容器中拿,而且每次拿的还是同一个。

1.4.4、将Bean的作用域改为多例

@Configuration
public class SpringMainConfig {@Bean@Scope("prototype")public User user(){System.out.println("对象创建啦");return new User(1,"HelloWorld");}
}

1.4.5、测试1

@Test
public void testPrototype() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
}
/**测试后发现容器启动的时候,多例对象并不会创建。
*/

1.4.6、测试2

 @Test
public void testPrototype() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);User user01 = (User) ac.getBean("user");User user02 = (User) ac.getBean("user");
}
/**对象创建啦对象创建啦
*/

总结:对于多实例来说,Spring容器在启动的时候并不会去调用方法创建对象并放在容器中,而是每次获取的时候才会调用方法创建对象,并且每次获取到的对象还不一样。

1.5、Lazy注解

作用:用此注解修饰的Bean表示的该Bean需要被懒加载,即不会随着Spring容器的启动而去创建。

1.5.1、注册Bean

@Configuration
public class SpringMainConfig {@Bean@Lazy(value = true)	// 开启懒加载public User user(){System.out.println("对象创建啦");return new User(1,"HelloWorld");}
}

1.5.2、测试

@Test
public void testSingleton() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
}
/**控制台什么都没有输出,因为我们的Bean被Layz注解修饰了,即使Spring容器启动了,我们的Bean也不会去创建,只有等到了真正要用到该bean了才去创建。
*/

1.5.3、总结

  • 这个Lazy注解是针对单实例Bean才有效,因为也只有单实例Bean才会默认在容器启动的时候创建对象。
  • 懒加载:容器启动不创建对象,只有在第一次使用(获取)Bean的时候采取创建对象,并初始化。
  • 该注解的作用等价于。

1.6、Conditional注解【了解】

作用: 根据一定的条件进行判断,当满足这个条件时给容器注入Bean。

==位置:==既可以修饰类也可以修饰方法。

==需求:==当前操作系统如果是window,则注入WindoBean,如果是linux系统,则注入LinuxBean。

首先查看下@Conditional注解的源代码,即:

public @interface Conditional {// 该注解的属性值是一个Class类型的数组,数组的Class元素类型必须继承Condition接口,即元素的类型必// 须是Condition类型。Class<? extends Condition>[] value();	
}

继续Condition接口的源代码:

public interface Condition {// 提供一个返回boolean值的方法,返回true则注入bean,false则不注入boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

1.6.1、定义两个Bean

// Window的bean
public class WindowBean {private String name;public WindowBean(String name) {this.name = name;}
}
// Linux的Bean
public class LinuxBean {private String name;public LinuxBean(String name) {this.name = name;}
}

1.6.2、定义两个类实现Condition接口

// Window环境的条件
public class WindowCondition implements Condition {// context:上下文环境public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {String osName = context.getEnvironment().getProperty("os.name");if (osName.contains("Windows")){return true;}return false;}
}
// Linux环境条件
public class LinuxCondition implements Condition {@Overridepublic boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {String osName = context.getEnvironment().getProperty("os.name");if (osName.contains("linux")){return true;}return false;}
}

1.6.3、注册Bean

@Configuration
public class SpringMainConfig {// 如果当前环境是Winows环境则注入WindowBean@Bean@Conditional(value = {WindowCondition.class})public WindowBean windowBean(){return new WindowBean("这个是window操作系统");}// 如果当前环境是Linux环境则注入LinuxBean@Bean@Conditional(value = {LinuxCondition.class})public LinuxBean linuxBean(){return new LinuxBean("这个是Linux操作系统");}
}

1.6.4、测试1

@Test
public void testBean() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);// 查看Spring容器中所有注册的BeanString[] names = ac.getBeanDefinitionNames();for (String name:names) {System.out.println(name);	}
}
/**windowBean由于现在是在window操作系统上测试,故仅仅注册了WindowBean。
*/

1.6.5、测试2

测试下如果程序运行在linux下,是否能够注入LinuxBean?测试过程,即:运行程序的时候手动的指定运行时参数信息,步骤如下:

在这里插入图片描述

在这里插入图片描述

测试后,发现,打印的结果是:LinuxBean。

1.6.6、总结

  • 使用Conditional注解修饰在方法上,只有当条件满足的时候,即返回true,才会将所修饰的方法调用并且会创建Bean对象添加到容器中。
  • 使用Conditional也可以修饰类,比如修饰主配置类,那么假如这个主配置类中定义了很多的Bean,如果该注解修饰了一个类,则只有条件满足的时候,即返回true,那么主配置类中所定义的Bean才会注册到容器中。即:@Conditional标注在类上就决定了该类中的一批bean是否能够注入。

1.7、Import注解

在这里插入图片描述

1.7.1、用法一

​ 简单来说,Import注解可以去修饰常规组件类,意思是:所谓的常规组件类就是一个普通的Java类, 而如果这个普通的Java类被@Import注解修饰,那么也可以将这个Java类注册到Spring容器中,成为Bean。

1.7.1.1、定义Bean
public class Dog {}
1.7.1.2、注册Bean
@Configuration
@Import(value = {Dog.class})
public class SpringMainConfig {
}
1.7.1.3、测试容器中是否有该Bean
@Test
public void testDogBean() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);// 查看Spring容器中所有注册的BeanString[] names = ac.getBeanDefinitionNames();for (String name:names) {System.out.println(name);}
}
/**cn.bdqn.Dog
*/
1.7.1.4、注意

使用Import注解导入一个常规组件的时候,这个Bean的名称是类的全路径

1.7.2、用法二

​ 即Import可以导入被@Configuration注解所修饰的类,换句话说,Import注解可以去导入其他的配置类,存在的一个细节是:假如这个配置类里面也注册了多个Bean,那么同样也会将这些个Bean一并注册到Spring容器中。

1.7.2.1、定义Bean
// 奥迪
public class AuDi {}
// 宝马
public class BMW {}
1.7.2.2、新建配置类并注册Bean
// 针对系统中存在的车的一个配置类
@Configuration
public class Car {@Beanpublic AuDi auDi(){return new AuDi();}@Beanpublic BMW bmw(){return new BMW();}
}
1.7.2.3、Import导入配置类
@Configuration
@Import(value = {Car.class})
public class SpringMainConfig {
}
1.7.2.4、测试容器有哪些Bean

​ 测试代码如同8.7.1.3,结果如下:

/**cn.bdqn.Car	---> 配置类auDi		---> 配置类中的奥迪Beanbmw			---> 配置类中的宝马Bean
*/
1.7.2.5、总结
  • 测试后发现,如果Import导入的是一个配置类,那么Spring会将这个配置类、以及配置类中定义的Bean都会注册到容器中。
  • 同时,有Import注解修饰的那个配置类是主配置类,被Import注解导入的配置类也叫子配置类。例如用法二,SpringMainConfig这个配置类就是主配置类,Car这个配置类称之为子配置类。
  • 这样做的好处:可以将不同功能、不同业务的Bean单独分开配置,而不是统一的都配置到一个配置类中,单独配置,结构清晰,功能划分的也很清楚。

1.8、PropertySource注解

==作用:可以设置properties文件的位置,这样的话,就可以通过Value注解读取配置文件的内容。==该注解的作用等同于:

<context:property-placeholder location="classpath:db.properties"/>

位置:该注解通常和@Configuration注解一起使用。

1.8.1、定义Pig.properties文件

id=1
name=丁春秋

1.8.2、主配置类

@Configuration	// 主配置类
@ComponentScan("cn.bdqn")	// 扫描包,目的是能够扫描到Pig类
@PropertySource(value = {"pig.properties"})	//加载配置文件
public class SpringMainConfig {}

1.8.3、测试

 @Test
public void testPig() throws Exception{ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);Pig pig = (Pig) ac.getBean("pig");System.out.println(pig);	// 1,name
}

好书推荐

在这里插入图片描述

《Java官方入门教程(第9版·Java 17)》

本书针对Java SE 17做了全面细致的更新,将引导你轻松学习最新的核心Java编程技能。开篇讲述基础知识,内容涉及如何创建、编译和运行Java程序。此后浓墨重彩地描述构成Java语言核心的关键字、语法和结构。本书还涵盖Java的一些更高级特性,如多线程编程、泛型、lambda表达式、模块、记录、密封类和Swing。另外,还介绍了Java的交互式编程工具JShell。本书通俗易懂、简明扼要、详略得当,成为全球数百万读者的选择。

作者简介

[美]赫伯特·希尔特(Herbert Schildt)
Herbert是Java语言领域的权威专家,拥有伊利诺伊大学的学士和硕士学位。被International Developer杂志评为“全球最著名的编程书籍创作者之一”“。他撰写的编程书籍在全球范围内销售了数百万册,已被翻译 成所有主要的非英语语言。他撰写了大量Java方面的书籍,包括Java: The Complete Reference、Herb Schildt’s Java Programming Cookbook、Introducing JavaFX 8 Programming和 Swing: A Beginner’s Guide。还撰写了许多关于C、C++和C#的图书。Ed Burns在Secrets of the Rock Star Programmers: Riding the IT Crest一书中将Herbert列为明星程序员。尽管对计算机的所有方面都感兴趣,但Herbert主要关注计算机语言。

购书链接:点此进入

在这里插入图片描述

这篇关于【Spring进阶系列丨第七篇】Spring框架新注解分类及详解的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/880463

相关文章

Linux换行符的使用方法详解

《Linux换行符的使用方法详解》本文介绍了Linux中常用的换行符LF及其在文件中的表示,展示了如何使用sed命令替换换行符,并列举了与换行符处理相关的Linux命令,通过代码讲解的非常详细,需要的... 目录简介检测文件中的换行符使用 cat -A 查看换行符使用 od -c 检查字符换行符格式转换将

Java编译生成多个.class文件的原理和作用

《Java编译生成多个.class文件的原理和作用》作为一名经验丰富的开发者,在Java项目中执行编译后,可能会发现一个.java源文件有时会产生多个.class文件,从技术实现层面详细剖析这一现象... 目录一、内部类机制与.class文件生成成员内部类(常规内部类)局部内部类(方法内部类)匿名内部类二、

SpringBoot实现数据库读写分离的3种方法小结

《SpringBoot实现数据库读写分离的3种方法小结》为了提高系统的读写性能和可用性,读写分离是一种经典的数据库架构模式,在SpringBoot应用中,有多种方式可以实现数据库读写分离,本文将介绍三... 目录一、数据库读写分离概述二、方案一:基于AbstractRoutingDataSource实现动态

Springboot @Autowired和@Resource的区别解析

《Springboot@Autowired和@Resource的区别解析》@Resource是JDK提供的注解,只是Spring在实现上提供了这个注解的功能支持,本文给大家介绍Springboot@... 目录【一】定义【1】@Autowired【2】@Resource【二】区别【1】包含的属性不同【2】@

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖(即BeanA依赖BeanB,而BeanB又依赖BeanA),会导致Spring的... 目录1. 什么是循环依赖?2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1:使用 @La

Java枚举类实现Key-Value映射的多种实现方式

《Java枚举类实现Key-Value映射的多种实现方式》在Java开发中,枚举(Enum)是一种特殊的类,本文将详细介绍Java枚举类实现key-value映射的多种方式,有需要的小伙伴可以根据需要... 目录前言一、基础实现方式1.1 为枚举添加属性和构造方法二、http://www.cppcns.co

Elasticsearch 在 Java 中的使用教程

《Elasticsearch在Java中的使用教程》Elasticsearch是一个分布式搜索和分析引擎,基于ApacheLucene构建,能够实现实时数据的存储、搜索、和分析,它广泛应用于全文... 目录1. Elasticsearch 简介2. 环境准备2.1 安装 Elasticsearch2.2 J

详解C#如何提取PDF文档中的图片

《详解C#如何提取PDF文档中的图片》提取图片可以将这些图像资源进行单独保存,方便后续在不同的项目中使用,下面我们就来看看如何使用C#通过代码从PDF文档中提取图片吧... 当 PDF 文件中包含有价值的图片,如艺术画作、设计素材、报告图表等,提取图片可以将这些图像资源进行单独保存,方便后续在不同的项目中使

Java中的String.valueOf()和toString()方法区别小结

《Java中的String.valueOf()和toString()方法区别小结》字符串操作是开发者日常编程任务中不可或缺的一部分,转换为字符串是一种常见需求,其中最常见的就是String.value... 目录String.valueOf()方法方法定义方法实现使用示例使用场景toString()方法方法

Java中List的contains()方法的使用小结

《Java中List的contains()方法的使用小结》List的contains()方法用于检查列表中是否包含指定的元素,借助equals()方法进行判断,下面就来介绍Java中List的c... 目录详细展开1. 方法签名2. 工作原理3. 使用示例4. 注意事项总结结论:List 的 contain