文章目录

• 回顾注解
• • 注解怎么定义，注解中的属性怎么定义？
  • • 元注解
    • • @Target注解
      • @Retention注解
  • 注解怎么使用？
  • 通过反射机制怎么读取注解？
• Spring注解原理
• 声明Bean的注解
• Spring注解的使用
• • 第一步：加入aop的依赖
  • 第二步：在配置文件中添加context命名空间
  • 第三步：在配置文件中指定要扫描的包
  • 第四步：在Bean类上使用注解
• 选择性实例化Bean
• • use-default-filters="true"情况
  • use-default-filters="false"情况
• 负责注入的注解
• • @Value
  • • 声明在属性上
    • 声明setter方法上
    • 声明构造方法的参数上
  • @Autowired与@Qualifier
  • • 根据类型自动装配
    • • 声明在属性上
      • 声明在构造方法上
      • 声明在构造方法的参数上
      • 声明在setter方法上
    • 根据名称自动装配
    • 总结
  • @Resource
• 全注解式开发

回顾注解

注解的存在主要是为了简化XML的配置。Spring6倡导全注解开发。
我们来回顾一下：

• 第一：注解怎么定义，注解中的属性怎么定义？
• 第二：注解怎么使用？
• 第三：通过反射机制怎么读取注解？

注解怎么定义，注解中的属性怎么定义？

注解使用@interface定义，注解中的属性与接口的方法的定义一样。
自定义一个注解Component

@Target(ElementType.TYPE_USE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {String value();//String name();//int[] ages();
}

元注解

该注解上面修饰的注解包括：Target注解和Retention注解，这两个注解被称为元注解。

@Target注解

@Target注解用来修饰注解可以出现的位置。只有一个属性，是一个value，且类型是一个枚举类型。
具体值：

• ElementType.TYPE：能修饰类、接口或枚举类型
• ElementType.FIELD：能修饰成员变量
• ElementType.METHOD：能修饰方法
• ElementType.PARAMETER：能修饰参数
• ElementType.CONSTRUCTOR：能修饰构造器
• ElementType.LOCAL_VARIABLE：能修饰局部变量
• ElementType.ANNOTATION_TYPE：能修饰注解
• ElementType.PACKAGE：能修饰包
• ElementType.RECORD_COMPONENT：与记录相关，是Java语言的预览功能。
• ElementType.TYPE_PARAMETER：类型参数，是用在泛型类型 “T” 上的，是JDK8新推出的
• ElementType.TYPE_USE：类型的注解，表示这个注解可以在任意地方使用（如：泛型，类型转换等），是JDK8新推出的

@Retention注解

@Retention用来标注注解最终保留位置，同样只有一个属性，是一个value，且类型是一个枚举类型。
具体值：

• RetentionPolicy.SOURCE 注解仅存在于源码中，在class字节码文件中不包含
• RetentionPolicy.CLASS 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得
• RetentionPolicy.RUNTIME 注解会在class字节码文件中存在，在运行时可以通过反射获取到

注解怎么使用？

使用注解的语法：

• @注解名(属性名 = 属性值,属性名 = 属性值,属性名 = 属性值…)

使用某个注解的时候，属性名是value，value可以省略
如果属性值是一个数组，并且值只有一个，那么{}可以省略

//@Component(value = "userBean")
@Component("userBean")
public class User {
}

通过反射机制怎么读取注解？

步骤：

• 1.通过全限定类名获取类
• 2.判断类上面有没有这个注解
• 3.有则获取类上的注解
• 4.访问注解属性

public class ReflectAnnotationTest1 {public static void main(String[] args) throws Exception {//1.获取类Class aClass = Class.forName("com.review.bean.User");//2.判断类上面有没有这个注解if (aClass.isAnnotationPresent(Component.class)) {//3.有则获取类上的注解Component annotation = aClass.getAnnotation(Component.class);//4.访问注解属性System.out.println(annotation.value());}}
}

Spring注解原理

• 1.只知道包的名字，这个包下有多少个Bean我们不知道
• 2.扫描这个包下所有的类
• 3.当这个包下的类有注解的时候，实例化该类对象
• 4.放到一个Map集合当中

还是使用之前的自定义注解Component和User类，再添加两个类，一个有Component注解，一个没有

Order类

@Component("orderBean")
public class Order {
}

Products类：

public class Products {
}

原理程序：

public class ReflectAnnotationTest2 {public static void main(String[] args) {Map map = new HashMap<>();//1.包名字String packageName = "com.review.bean";//2.扫描程序//把'.'替换成'/'，正则表达式中'.'代表任意，我们需要把普通的点替换，需要加个\，在java语言中两个斜杠代表一个斜杠。String packagePath = packageName.replaceAll("\\.", "/");//变成 com/review/bean//packagePath是一个在类根路径的路径，需要通过系统类加载器加载，自动返回一个URL路径URL url = ClassLoader.getSystemClassLoader().getResource(packagePath);String path = url.getPath();//获取绝对路径//获取绝对路径下所有文件File file = new File(path);File[] files = file.listFiles();//通过流编程遍历filesArrays.stream(files).forEach(fileclass -> {try {//获取绝对路径类String className = packageName + "." + fileclass.getName().split("\\.")[0];//3.通过反射机制解析注解Class aClass = Class.forName(className);if (aClass.isAnnotationPresent(Component.class)) {Component annotation = aClass.getAnnotation(Component.class);String beanId = annotation.value();Object beanObj = aClass.newInstance();//4.放到一个Map集合当中map.put(beanId,beanObj);}} catch (Exception e) {e.printStackTrace();}});System.out.println(map);}
}

声明Bean的注解

负责声明Bean的注解，常见的包括四个：

• @Component
• @Controller
• @Service
• @Repository

源码如下：
@Component：

@Target(value = {ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Component {String value();
}

@Controller：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {@AliasFor(annotation = Component.class)String value() default "";
}

@Service注解：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {@AliasFor(annotation = Component.class)String value() default "";
}

@Repository：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {@AliasFor(annotation = Component.class)String value() default "";
}

通过源码可以看到，@Controller、@Service、@Repository这三个注解都是@Component注解的别名。
也就是说：这四个注解的功能都一样。用哪个都可以。
只是为了增强程序的可读性，建议：

• 控制器类上使用：Controller
• service类上使用：Service
• dao类上使用：Repository

如果把value属性彻底去掉，spring会自动取名，并且默认名字的规律是：Bean类名首字母小写即可。

Spring注解的使用

如何使用以上的注解呢？

• 第一步：加入aop的依赖
• 第二步：在配置文件中添加context命名空间
• 第三步：在配置文件中指定扫描的包
• 第四步：在Bean类上使用注解

第一步：加入aop的依赖

在Maven项目中，当加入spring-context依赖之后，会关联加入aop的依赖。所以这一步不用做。如果不是Maven项目，则需要把jar包导进库。

第二步：在配置文件中添加context命名空间

spring.xml文件

第三步：在配置文件中指定要扫描的包

spring.xml添加指定要扫描的包：

如果是多个包怎么办？有两种解决方案：

• 第一种：在配置文件中指定多个包，用逗号隔开。
• 第二种：指定多个包的共同父包，这种方式会牺牲一部分效率。

第四步：在Bean类上使用注解

四个注解都用一下，在bean包下创建四个类

@Controller注解使用：创建User类

//@Controller 不写value的话，默认是user，就是类名首字母小写
@Controller(value = "user")
public class User {
}

@Service注解使用：创建Student类

@Service("studentBean")
public class Student {
}

@Repository使用：创建Order类

@Repository("orderBean")
public class Order {
}

@Component使用：创建Car类

@Component("carBean")
public class Car {
}

测试程序：

@Testpublic void testBean(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");//User userBean = applicationContext.getBean("userBean", User.class);User userBean = applicationContext.getBean("user", User.class);System.out.println(userBean);Car carBean = applicationContext.getBean("carBean", Car.class);System.out.println(carBean);Student studentBean = applicationContext.getBean("studentBean", Student.class);System.out.println(studentBean);Order orderBean = applicationContext.getBean("orderBean", Order.class);System.out.println(orderBean);  }

选择性实例化Bean

假设在某个包下有很多Bean，有的Bean上标注了Component，有的标注了Controller，有的标注了Service，有的标注了Repository，
现在由于某种特殊业务的需要，只允许其中所有的Controller参与Bean管理，其他的都不实例化。这应该怎么办呢？

需要在配置文件的context:component-scan标签加一个属性use-default-filters，默认是true

• use-default-filters="true"表示：使用spring默认的规则，只要有Component、Controller、Service、Repository中的任意一个注解标注，则进行实例化。

  • 如果是默认值或者true，想让其特定注解失效，则添加context:exclude-filter标签

    • type属性：需要失效的类型
    • expression：需要失效的全限定路径

• use-default-filters="false"表示：不再spring默认实例化规则，即使有Component、Controller、Service、Repository这些注解标注，也不再实例化。

  • 如果设置成false后，想让其生效需要添加一个context:include-filter标签使特定的注解生效

    • type属性：需要生效的类型

    • expression：需要生效的全限定路径

这两种方式类似于黑名单和白名单
注意：因为Component注解是其他三个注解的”老大“，所以

• 如果是默认值或者true，让其Component失效，会连其三个注解全部失效。
• 如果设置成false，让其Component生效则其他三个注解也全部生效

创建bean2包，创建几个类，提供无参构造方法打印测试，为了方便测试，我们写在一个类里面：

@Component
public class A {public A() {System.out.println("A的无参数构造方法执行。。。");}
}
@Controller
class B{public B() {System.out.println("B的无参数构造方法执行。。。");}
}
@Service
class C{public C() {System.out.println("C的无参数构造方法执行。。。");}
}
@Repository
class D{public D() {System.out.println("D的无参数构造方法执行。。。");}
}
@Controller
class E{public E() {System.out.println("E的无参数构造方法执行。。。");}
}

创建spring-choose.xml配置文件：

use-default-filters="true"情况

让其@Controller失效，spring-choose.xml配置：

测试程序：因为只需要测试是否实例化，不用获取Bean

    @Testpublic void testBeanChoose(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-choose.xml");}

运行发现A、C、D实例化

如果把失效注解换成@Component：

再次运行测试程序：全都不生效了

use-default-filters="false"情况

记得上面的配置要注释掉，让其@Controller失效，spring-choose.xml配置：

测试程序是同一个，再次运行：B、E实例化

如果把生效注解换成@Component：

再次运行测试程序：全都生效

负责注入的注解

@Component @Controller @Service @Repository 这四个注解是用来声明Bean的，声明后这些Bean将被实例化。如何给Bean的属性赋值。给Bean属性赋值需要用到这些注解：

• @Value
• @Autowired
• @Qualifier
• @Resource

@Value

@Value注解的源码

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {String value();
}

只负责简单类型的注入，属性名value，用来赋值，可以声明在属性上或setter方法上或构造方法的参数上，声明在属性上可以不提供setter方法。
创建bean3包
创建spring-value.xml：

声明在属性上

在bean3包创建User1类：声明在属性上，先提供setter方法。

@Component
public class User1 {@Value("张三")private String name;@Value("30")private int age;public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}
}

测试程序：

    @Testpublic void testByValue(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-value.xml");User1 user1 = applicationContext.getBean("user1", User1.class);System.out.println(user1);}

删掉setter方法，再次运行测试程序：发现声明在属性上可以不提供setter方法。

声明setter方法上

在bean3包，创建User2类：

@Component
public class User2 {private String name;private int age;@Overridepublic String toString() {return "User2{" +"name='" + name + '\'' +", age=" + age +'}';}@Value("李四")public void setName(String name) {this.name = name;}@Value("20")public void setAge(int age) {this.age = age;}
}

在上面测试程序添加：

		User2 user2 = applicationContext.getBean("user2", User2.class);System.out.println(user2);

声明构造方法的参数上

在bean3包下，创建User3类

@Component
public class User3 {private String name;private int age;@Overridepublic String toString() {return "User3{" +"name='" + name + '\'' +", age=" + age +'}';}public User3(@Value("王五")String name, @Value("25")int age) {this.name = name;this.age = age;}
}

在上面测试程序添加：

		User3 user3 = applicationContext.getBean("user3", User3.class);System.out.println(user3);

@Autowired与@Qualifier

@Autowired 与 @Qualifier：Autowired翻译为：自动连线/自动装配，可以用来注入非简单类型

• 单独使用@Autowired注解，默认只能根据类型自动装配【默认是byType】
• @Autowired 与 @Qualifier 联合使用可以根据名称自动装配

创建bean4包
创建spring-autowired.xml文件：

在bean4包下创建dao包，在dao包下创建一个OrderDao接口：

public interface OrderDao {void insert();
}

在dao包下创建impl包，提供一个实现类：

@Repository
public class OrderDaoImplForMysql implements OrderDao {@Overridepublic void insert() {System.out.println("Mysql正在保存订单信息");}
}

创建service包

根据类型自动装配

@Autowired注解源码：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {boolean required() default true;
}

@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。同样注解如果声明在属性上可以不提供setter方法。当带参数的构造方法只有一个，@Autowired注解可以省略。

该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

声明在属性上

在service创建一个OrderService类：先提供setter方法

@Service
public class OrderService {@Autowiredprivate OrderDao orderDao;public void setOrderDao(OrderDao orderDao) {this.orderDao = orderDao;}public void generate(){orderDao.insert();}
}

测试程序：

    @Testpublic void testByAutowired(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-autowired.xml");OrderService orderService = applicationContext.getBean("orderService", OrderService.class);orderService.generate();}

删掉setter方法，再次运行测试程序：发现声明在属性上可以不提供setter方法。

声明在构造方法上

修改OrderService类：

@Service
public class OrderService {/*@Autowired*/private OrderDao orderDao;@Autowiredpublic OrderService(OrderDao orderDao) {this.orderDao = orderDao;}public void generate(){orderDao.insert();}
}

与上面相同的测试程序，再次运行：

声明在构造方法的参数上

@Service
public class OrderService {/*@Autowired*/private OrderDao orderDao;/*@Autowired*/public OrderService(@Autowired OrderDao orderDao) {this.orderDao = orderDao;}public void generate(){orderDao.insert();}
}

再次运行测试程序：

当带参数的构造方法只有一个，@Autowired注解可以省略。
去掉@Autowired注解，再次运行程序：

如果加一个带参数的构造方法

@Service
public class OrderService {/*@Autowired*/private OrderDao orderDao;/*@Autowired*/public OrderService(OrderDao orderDao) {this.orderDao = orderDao;}public OrderService(OrderDao orderDao,String s) {this.orderDao = orderDao;}public void generate(){orderDao.insert();}
}

再次运行：报错，当带参数的构造方法只能有一个，有无参构造也不行，这个可以自己测试。

声明在setter方法上

@Service
public class OrderService {/*@Autowired*/private OrderDao orderDao;/*@Autowired*//*public OrderService(OrderDao orderDao) {this.orderDao = orderDao;}*/@Autowiredpublic void setOrderDao(OrderDao orderDao) {this.orderDao = orderDao;}public void generate(){orderDao.insert();}
}

再次运行：

根据名称自动装配

以上程序OrderDao接口只有一个实现类，如果是多个呢？
在impl再创建一个实现类：

@Repository
public class OrderDaoImplForOracle implements OrderDao {@Overridepublic void insert() {System.out.println("Oracle正在保存订单信息");}
}

回到OrderService，发现报错了

怎么解决这个问题呢？当然要byName，根据名称进行装配了。
@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。
@Qualifier源码

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {String value() default "";
}

可见与@Autowired用法差不多，只是属性名是value，表示指定Bean名称，就能更加名称自动装配了。

修改OrderService类：添加@Qualifier注解

@Service
public class OrderService {@Autowired@Qualifier("orderDaoImplForMysql")private OrderDao orderDao;public void generate(){orderDao.insert();}
}

再次运行测试程序：

如果想使用其他实现类，修改@Qualifier注解的value即可

@Service
public class OrderService {@Autowired//@Qualifier("orderDaoImplForMysql")@Qualifier("orderDaoImplForOracle")private OrderDao orderDao;public void generate(){orderDao.insert();}
}

再次运行测试程序：

总结

• @Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。
• 注解如果声明在属性上可以不提供setter方法，当带参数的构造方法只有一个，@Autowired注解可以省略。
• @Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。

@Resource

@Resource源码

@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Resources.class)
public @interface Resource {String name() default "";String lookup() default "";Class type() default Object.class;Resource.AuthenticationType authenticationType() default Resource.AuthenticationType.CONTAINER;boolean shareable() default true;String mappedName() default "";String description() default "";public static enum AuthenticationType {CONTAINER,APPLICATION;private AuthenticationType() {}}
}

很多属性，我们只关注name属性：用来接收Bean的名称的，未指定时默认根据属性名作为name。
@Resource注解也可以完成非简单类型注入。那它和@Autowired注解有什么区别？

• 区别一：

  • @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
  • @Autowired注解是Spring框架自己的。

• 区别二：

  • @Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。
  • @Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。

• 区别三：

  • @Resource注解用在属性上、setter方法上。
  • @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。】
如果是spring6+版本使用这个依赖

jakarta.annotationjakarta.annotation-api2.1.1

如果是spring5-版本使用这个依赖

javax.annotationjavax.annotation-api1.3.2

创建bean5包
创建spring-resource.xml配置：

创建dao包
创建StudentDao接口

public interface StudentDao {void deleteById();
}

创建impl包
创建两个实现类：

@Repository("studentDaoMysql")
public class StudentDaoImplForMysql implements StudentDao {@Overridepublic void deleteById() {System.out.println("Mysql正在删除学生信息。。。");}
}

@Repository("studentDaoOracle")
public class StudentDaoImplForOracle implements StudentDao {@Overridepublic void deleteById() {System.out.println("Oracle正在删除学生信息。。。");}
}

创建service包
创建StudentService类

@Service("studentService")
public class StudentService {@Resource(name = "studentDaoMysql")private StudentDao studentDaoMysql;public void deleteStudent(){studentDaoMysql.deleteById();}
}

测试程序：

    @Testpublic void testByResource(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-resource.xml");StudentService studentService = applicationContext.getBean("studentService", StudentService.class);studentService.deleteStudent();}

如果把name去掉，再次运行程序：

如果把属性名改为别的

@Service("studentService")
public class StudentService {//@Resource(name = "studentDaoMysql")@Resourceprivate StudentDao studentDao;//private StudentDao studentDaoMysql;public void deleteStudent(){studentDao.deleteById();//studentDaoMysql.deleteById();}
}

再次运行：报错，所以说，不指定name时，默认会以属性名作为name，如果再找不到Bean，会切换成通过类型byType装配，而我们又有两个实现类，所以报错。

全注解式开发

所谓的全注解开发就是不再使用spring配置文件了。需要写一个配置类来代替配置文件。
使用@Configuration注解代替

@Configuration//代表配置文件
@ComponentScan({"com.annotation.bean5"})//这里代表context:component-scan标签
public class Spring6Config {
}

编写测试程序：不再new ClassPathXmlApplicationContext()对象了，new的是AnnotationConfigApplicationContext()对象

    @Testpublic void testByNoXML(){ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);StudentService studentService = applicationContext.getBean("studentService", StudentService.class);studentService.deleteStudent();}