Spring注解有哪些核心概念及用法简析？

本文共计4789个文字，预计阅读时间需要20分钟。

包含：1、Java注解：元注解和内置注解；2、Spring（Boot）注解：包括声明Bean、注入Bean、配置类、Web、AOP等。Java元注解：@Documented、@Inherited、@Retention、@Target、@Repeatable、@Native。

包含：1、java注解：元注解和内置注解 2、Spring（boot）注解：包括声明bean、注入bean、配置类、web、aop等。 JAVA 元注解

• @Documented
• @Inherited
• @Retention
• @Target
• @Repeatable
• @Native

在java.lang.annotation包下，除了@Native之外都为元注解

元注解：是一种基础注解（根注解），可以注解其他的注解上。

作用：用来解释说明其他的注解。

@Documented

• 源码：

@Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Documented { }

• 说明：

​ Document：文档。被标注的注解用在类A上后类A的注解信息可以被例如javadoc此类的工具文档化，相关的注解信息会出现在Doc中

@Inherited

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Inherited { }

• 说明：

  Inherited：动词，被继承。被@Inherited注解标注的注解去注解了一个类后，凡是该类的子类均继承注解被标注的注解

• 示例：

  /** 被@Inherited注解标注的注解MySelf去注解了类Human后，类Human的子类Man继承注解MySelf **/ @Inherited @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @Interface MySelf{ } @MySelf public class Human{} public class Man extends Human{}

@Retention

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Retention { RetentionPolicy value(); }

• 说明：

  Retention：保留期，存活期。解释说明了被标注的注解的存活时间。

  RetentionPolicy

  SOURCE---------------------注解只保留在源文件，当Java文件编译成class文件的时候，注解被丢弃

  CLASS------------------------默认值，注解被写入字节码文件，但jvm加载class文件时候被丢弃

  RUNTIME-------------------表明注解会被写入字节码文件，jvm运行时能够获取到，通过反射可以解析到

  一般如果需要在运行时去动态获取注解信息，那只能用 RUNTIME 注解

  如果要在编译时进行一些预处理操作，比如生成一些辅助代码（如 ButterKnife），就用 CLASS注解

  如果只是做一些检查性的操作，比如 @Override 和 @SuppressWarnings，则可选用 SOURCE 注解

@Target

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { ElementType[] value(); }

• 说明：

  target：目标，对象。描述被修饰的注解的使用范围，可以用在什么地方

  ElementType

  TYPE----------接口、类、枚举、注解

  FIELD--------------字段、枚举的常量

  METHOD----------------方法

  PARAMETER------------------方法参数

  CONSTRUCTOR-------------------构造函数

  LOCAL_VARIABLE----------------------局部变量

  ANNOTATION_TYPE------------------------注解

  PACKAGE-------------------------------------------包

  TYPE_PARAMETER-----------------------------------类型参数

  TYPE_USE------------------------------------------------------任意类型(不包括class)

@Repeatable

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Repeatable { Class<? extends Annotation> value(); }

• 说明：

  repeatabled：可重复。允许注解的重复使用，如：@ComponentScan

• 示例：

  spring中示例：Scheduled

  @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Human { Man[] value(); } @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented @Repeatable(Human.class) public @interface Man { String name; } @Man("will") @Man("Jacky") public void test(){ }

@Native

• 源码：

@Documented @Target(ElementType.FIELD) @Retention(RetentionPolicy.SOURCE) public @interface Native { }

• 说明：

  指示定义常量值的字段可以从本机代码引用。

内置注解 @Deprecated

• 源码

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD, ElementType.PACKAGE, ElementType.PARAMETER, ElementType.TYPE}) public @interface Deprecated { }

• 说明：

  Deprecated：强烈反对。标记一个方法、变量、包等已经过时，再使用被标记的方法等会报编译警告

• 示例：

  public class Man(){
  @Deprecated
  public void getName(){}

  }

  Man man = new Man();
  man.getName();

@Override

• 源码：

  @Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override { }

• 说明：

  override：推翻重写。仅用在方法上，对该类所继承的父类方法进行重写

@SafeVarargs

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.CONSTRUCTOR, ElementType.METHOD}) public @interface SafeVarargs {}

• 说明：

  safe varargs：安全的可变参数。声明了可变参数的构造函数或方法，会让java编译器报unchecked警告，如果程序员断定该方法的主体不会对可变参数执行潜在的不安全的操作，可以使用@SafeVarargs来去除警告。说白了就是防止安全警告带来的编译错误。

  可以用于构造函数和static、final声明的方法

• 示例：

  public class Man(){ @SafeVarargs public Man(Object... val){} @SafeVarargs public static<T> void getName(T... tVal){} @SafeVarargs public final void getAge(String... val){} /**--------------Wrong------------ @SafeVarargs is not allowed on methods with fixed arity @SafeVarargs不允许在具有固定值的方法上使用 **/ @SafeVarargs public void getAge(String. tVal){} }

@SuppressWarnings

• 源码：

  @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) @Retention(RetentionPolicy.SOURCE) public @interface SuppressWarnings { String[] value(); }

• 说明：

  suppress warning：抑制警告。对被注解的作用域内部的警告保持静默，抑制警告的发生。value参数是抑制的警告类型， 详见blog.csdn.net/lftaoyuan/article/details/104813851

@FunctionalInterface

• 源码：

  @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface FunctionalInterface {}

• 说明：

  functional interface：函数式接口，功能接口。Java8新特性

  特点：

  • 有且仅有一个抽象方法
  • 允许静态方法
  • 允许默认方法
  • 允许java.lang.Object中public类型的方法，这些方法对于函数式接口来说，不被当成是抽象方法，因为所有的函数式接口的实现都是默认继承了Object类，Object类含有该方法的实现。
  • 该注解非必须，只要符合函数式接口的条件，可以不加注解，加上注解知识辅助编译器进行检查

  Java的函数式接口有什么意义？ - 知乎 (zhihu.com)

• 示例：

  @FunctionalInterface interface Man{ // 抽象方法 void setName(String name); // 静态方法 public static void getName(){ } // 默认方法 public default void setAge(){ } // java.lang.Object的public方法 public boolean equals(Object val); }

Spring(Boot) 声明bean

​ 声明一个类为Spring的bean，可以被自动装配，区别在于定位一个类的作用，由于企业级应用的开发注重分层，所以使用注解分别定义类的层次也可以更好地助力于开发，比使用xml进行配置更加简单。

• @Controller

• @Service

• @Repository

• @Component

@Controller

• 源码：

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

• 说明：

  controller：控制者，控制器。对应MVC中的控制层

  作用：接收用户请求并调用不同的Service进行数据处理封装，再将数据返回给前端，配合视图解析器可以返回一个指定的页面，而使用RestController则无法返回指定页面，但是可以返回json

  但是，@Controller仅说明这个类是一个控制器类，接收用户请求需要@RequestMapping来映射一个Url让用户能够通过该路径访问到

• 示例：

  @Controller public class MyUser(){ @RequestMapping(value = "getName",method=RequestMethod.GET) public String getName(){ } } /** 调用getName方法： me.com") @Controller public class Man{ } /** 2、写在方法上，允许该跨域请求该方法 **/ @Controller public class Man{ @CrossOrigin @RequestMapping(...) public String getName(){...} }

@ResponseBody

• 源码：

  @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface ResponseBody { }

• 说明：

  response body：响应体，对应请求体。

  用于将返回的参数格式化为json类型，按照SpringMVC的运行流程，一个请求应该返回的是一个视图，通过视图解析器后展现在web页面，而添加@ResponseBody后可以将结果写入到该net请求的response body中去，而不走试图解析器

@RestController

• 源码：

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

• 说明：

  @Restcontroller 集成了@Controller和@ResponseBody，可以以json的形式返回数据给前端，如果返回字符串的话当然还是String类型，不会被json化。目前很多项目都是前后端分离的，所以对外的接口一般都用@RestController

@RequestMapping

• 源码：

  @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Mapping public @interface RequestMapping { ... }

• 说明：

  request mapping：请求映射。

  用于映射一个请求的路径供外部请求的进入,可以作用于方法、类上，

• 示例：

  /** 请求路径为host:port/human-request/getName 如果类上不加该注解的话， 请求路径为host:port/getName 一般都会在类上添加该注解，因为项目方法多了之后，请求路径容易重复 **/ @RequestMapping("human-request") @RestController public class Human{ @RequestMapping("getName",method=Requestmethod.GET) public String getName(){ return ""; } } /** 可以与@Pathvariable注解一块使用，可以在请求路径上添加参数 传入id为2，请求路径为 host:port/getName/2 **/ @RestController public class Human{ @RequestMapping("getName/{id}",method=Requestmethod.GET) public String getName(@Pathvariable int id){ return ""; } } /** @RequestMapping("getName",method=Requestmethod.GET)==@GetMapping("getName") @RequestMapping("getName",method=Requestmethod.POST)==@PostMapping("getName") 同PutMapping,DeleteMapping,PatchMapping **/

@PathVariable

• 源码：

  @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface PathVariable { @AliasFor("name") String value() default ""; @AliasFor("value") String name() default ""; boolean required() default true; }

• 说明：

  path variable：路径变量。

  用于接收请求路径中占位符的值，默认是必须传入，可以传入多个

• 示例：

  /** 若传入id为2 请求路径为host:port/getName/2且路径中的2必穿 **/ @RequestMapping("getName/{id}",method=RequestMethod.GET) public String getName(@PathVariable int id){ return ""; } /** 设置required=false时 若传入id为2 请求路径为host:port/getName/2,路径中的2可以不传 **/ @RequestMapping("getName/{id}",method=RequestMethod.GET) public String getName(@PathVariable(required=false) int id){ return ""; }

@RequestParam

• 源码：

  @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestParam { ... }

• 说明：

  request param：请求参数。

  用于将参数赋给控制器方法中的形参上，默认参数必传，可以传递多个，仅作用于参数，可以使用required=false

• 示例：

  /** 请求路径：host:port/getName?id=2 **/ @RequestMapping("getName", method=RequestMathod.GET) public String getName(@Requestparam Long id){ return ""; }

@RequestBody

• 源码：

  @Target({ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestBody { boolean required() default true; }

• 说明：

  request body：请求体

  用于接收传递的json数据，前端传递json数据一般都用POST提交到请求体中用于后端接收，仅能有一个。

• 示例：

  /** 请求路径：host:port/getName 前端使用axios的话将json数据传入data中 **/ @RequestMapping("getName", method=RequestMathod.POST) public String getName(@RequestBody Man man){ return ""; }

AOP

​ AOP（Aspect Orient Programming） 面向切面编程，底层的实现就是采用动态代理模式实现的，采用了JDK的动态代理和CGLIB的动态代理。

• @Aspect

• @Before

• @AfterReturning

• @Around

• @AfterThrowing

• @After

• @PointCut

@Aspect

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface Aspect { String value() default ""; }

• 说明：

​ Aspect：方面，切面。

​ 标识一个类为切面类，用于给目标类增加一些功能

​ 特点：一般都是非业务方法，独立使用的AspectJ的相关注解，一般配合@Component使用，先将类加到spring容器，再使用@Aspect定义为切面类

@Before

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface Before { String value(); String argNames() default ""; }

• 说明：

  属性: value，是切入点表达式，表示切面的功能执行的位置。 位置: 在方法的上面 功能：前置通知，在目标方法之前执行 特点: 1.在目标方法之前先执行的 2.不会改变目标方法的执行结果 3.不会影响目标方法的执行。

• 示例：

  @Before(value="execution(public void com.will.HumanImpl.getName(id))") public void getNameBefore(){ // 需要执行的功能代码 } /* * 指定通知方法中的参数：JoinPoint * JoinPoint:业务方法，要加入切面功能的业务方法 * 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法的实参。 * 如果你的切面 功能中需要用到方法的信息，就加入JoinPoint. * 这个JoinPoint参数的值是由框架赋予，必须是第一个位置的参数 */ @Before(value="execution(public void com.will.HumanImpl.getName(id))") public void myBefore(JoinPoint jp){ //获取方法的完整定义 system.out.println("方法的签名（定义)="+jp.getsignature()); system.out.println("方法的名称="+jp.getsignature().getName());//获取方法的实参 object args []= jp.getArgs(); for (object arg:args){ system.out.println("参数="+arg); } }

@AfterReturning

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface AfterReturning { String value() default ""; String pointcut() default ""; String returning() default ""; String argNames() default ""; }

• 说明：

  后置通知定义方法，方法是实现切面功能的。

  方法的定义要求：

  ​ 1.公共方法 public

  ​ 2.方法没有返回值

  ​ 3.方法名称自定义

  ​ 4.方法有参数的，推荐是object，参数名自定义

  **@AfterReturning:后置通知** 属性: 1.value切入点表达式 2.returning自定义的变量，表示目标方法的返回值的。自定义变量名必须和通知方法的形参名一样。 位置：在方法定义的上面 特点: 1. 在目标方法之后执行的。 2. 能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能 3. 可以修改这个返回值

• 示例：

  @AfterReturning(value="execution(* *..SomeServiceImpl.doOther(..))",returning="res") // 此处returning的res名称=Object的res名称就行 public void myAfterReturing(object res){ // object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理 // 思考：如果是对类对象res的更改会不会影响在程序执行后得到的输出结果？ system.out.println("后置通知:在目标方法之后执行的，获取的返回值是:"+res); if(res.equals("abcd")) { //做―些功能 } e1se { //做其它功能 } }

@Around

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface Around { String value(); String argNames() default ""; }

• 说明：

  环绕通知 方法的定义格式: 1.public 2.必须有一个返回值，推荐使用object 3.方法名称自定义 4.方法有参数，固定的参数ProceedingjoinPoint 等同于jdk动态代理的，InvocationHandler接口 参数：ProceedingJoinPoint 等同于Method 作用：执行目标方法 返回值：就是目标方法的执行结果，可以被修改

• 示例：

  @Around(value = "execution(* *..SomeService1mpl.doFirst(..))") public object myAround(ProceedingJoinPoint pjp) throws Throwable { // 获取第一个参数值 Object[] args = pjp.getArgs(); String name = ""; if(args != null && args.length > 1){ Object arg = args[0]; name = (String)arg; } //实现环绕通知 object result = null; system.out.println("环绕通知:在目标方法之前，输出时间:"+ new Date()); //1.目标方法调用 if("xxx".equals(name)){ // 控制是否执行目标方法 result = pjp.proceed(); //method.invoke(); object result = doFirst(); } system.out.println("环绕通知:在目标方法之后，提交事务"); //2.在目标方法的前或者后加入功能 //返回目标方法的执行结果 return result; }

@AfterThrowing

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface AfterThrowing { String value() default ""; String pointcut() default ""; String throwing() default ""; String argNames() default ""; }

• 说明：

  方法的定义格式:

  1、public

  2、没有返回值

  3、方法，名称自定义

  4、方法有一个Exception，如果还有就是JoinPoint

  @AfterThrowing：异常通知 属性： 1、value 2、throwing自定义变量，表示目标方法抛出的异常对象，变量名和方法的参数名一样 特点： 1、在目标方法抛出异常时执行 2、可以做异常的监控程序，如果有异常，可以发邮件，短信通知等 执行时： 没有异常就走正常逻辑，有异常就走定义的@AfterThrowing注解的方法

  try{ SomeServiceImpl.doSecond(..); } catch(Exception ex){ myAfterThrowing(ex); }

• 示例：

  @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing = "ex") public void myAfterThrowing(Exception ex){ system.out.println("异常通知:方法发生异常时,执行: "+ex.getMessage());//发送邮件，短信，通知开发人员 }

@ After

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface After { String value(); String argNames() default ""; }

• 说明：

  After：最终通知

  方法的定义格式

  ​ 1.public

  ​ 2.没有返回值

  ​ 3.方法名称自定义

  ​ 4.方法没有参数，如果还有是JoinPoint

  @After:最终通知 属性：value 切入点表达式 位置：方法上面 特点： 1、总是执行 2、目标方法后执行，即使抛出了异常 类似于： try/catch中的finally代码块

• 示例：

  @After(value = "execution(* *..SomeserviceImpl.doThird(..))") public loidmyAfter(){ //一般做资源清除工作的。 systemyout.println("执行最终通知，总是会被执行的代码"); }

@PointCut

• 源码：

  @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface Pointcut { String value() default ""; String argNames() default ""; }

• 说明：

  定义管理切入点

  如果项目中很多个切入点表达式是重复的，，使用@PointCut

  属性：value 切入点表达式 位置：方法上面 特点： 当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名。其它的通知中，value属性就可以使用这个方法名称，代替切入点表达式了

• 示例：

  @Pointcut(value = "execution(* *..SomeserviceImpl.doThird(..))”) private void mypt(){ //无需代码， } // 然后： @Before(value="mypt()") public void myBefore(){ }