目录
一、注解的概念
1.Java注解简介
Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说说明、配置的功能。
注解相关类都包含在java.lang.annotation包中.
① Java注解分类
JDK基本注解
JDK元注解
自定义注解
② JDK基本注解
@Override
重写@SuppressWarnings(value = "unchecked")
压制编辑器警告
③ JDK元注解
@Retention：定义注解的保留策略
@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS) //默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，
@Retention(RetentionPolicy.RUNTIME) //注解会在class字节码文件中存在，在运行时可以通过反射获取到@Target：指定被修饰的Annotation可以放置的位置(被修饰的目标)
@Target(ElementType.TYPE) //接口、类
@Target(ElementType.FIELD) //属性
@Target(ElementType.METHOD) //方法
@Target(ElementType.PARAMETER) //方法参数
@Target(ElementType.CONSTRUCTOR) //构造函数
@Target(ElementType.LOCAL_VARIABLE) //局部变量
@Target(ElementType.ANNOTATION_TYPE) //注解
@Target(ElementType.PACKAGE) //包
注：可以指定多个位置，例如：
@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用@Inherited：指定被修饰的Annotation将具有继承性
@Documented：指定被修饰的该Annotation可以被javadoc工具提取成文档.
④ 自定义注解
注解分类（根据Annotation是否包含成员变量,可以把Annotation分为两类）:
标记Annotation:
没有成员变量的Annotation; 这种Annotation仅利用自身的存在与否来提供信息元数据Annotation:
包含成员变量的Annotation; 它们可以接受(和提供)更多的元数据;
标记注解：指的就是 这个@Override重写，不需要添加任何东西
元素注解:指的就是@SuppressWarnings(value = "unchecked") 它这里面的注解可以加些内容进去
⑤ 如何自定义注解？
使用@interface关键字, 其定义过程与定义接口非常类似, 需要注意的是:
Annotation的成员变量在Annotation定义中是以无参的方法形式来声明的, 其方法名和返回值类型定义了该成员变量的名字和类型,
而且我们还可以使用default关键字为这个成员变量设定默认值；
二、自定义注解
我们最常见的自定义注解有四种：注解用在类上面、注解用在方法上面、注解用在属性上面、注解用在参数上面
这个Target里面标记的这些属性，决定了你自定义注解能放在哪里使用
当我们不知道这个注解是干嘛用的，可以点进去查看
Target注解我即想用在类上面和方法上面和属性上面等。
这个Retention策略一共有三种：source、class、runtime
如果属性是value的话，可以省略.
可以省略value =；如果是其他的，则不可以省略的。
1.获取类上注解值
我们使用自定义注解就是为了那这上面的数据的
MyAnnotation1.java
package com.jwj.ssm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 20:09
*/
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
// 指的是注解中的属性
public String desc() default "desc可以修饰符、方法、属性";
public String value() default "value可以修饰符、方法、属性";
}
MyAnnotation2.java
package com.jwj.ssm.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 20:09
*/
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation2 {
// 指的是注解中的属性
public String desc() default "desc可以修饰符、方法、属性";
public String value() default "value可以修饰符、方法、属性";
}
Studentcontroller.java
package com.jwj.ssm.annotation;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 20:11
*/
@MyAnnotation1(desc = "标记在类上面")
public class Studentcontroller {
@MyAnnotation1("标记在属性id上面")
private String id;
@MyAnnotation1("标记在属性name上面")
private String name;
@MyAnnotation1
public void test1(@MyAnnotation2("用来修饰id参数") String id,@MyAnnotation2("用来修饰name参数") String name){
System.out.println("测试...");
}
}
Demo1.java
package com.jwj.ssm.annotation.demo;
import com.jwj.ssm.annotation.MyAnnotation1;
import com.jwj.ssm.annotation.Studentcontroller;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 22:10
*
* 目标：
* 1.获取studentController 类上自定义注解 中的内容
* 2.获取studentController 方法上自定义注解 中的内容
* 3.获取studentController 属性上自定义注解 中的内容
* 4.获取studentController 参数上自定义注解 中的内容
* * *..*Service.*pager(..)
* com.zking.service.BookService.queryPager(..);
* com.zking.service.OrderService.queryPager(..);
*/
public class Demo1 {
public static void main(String[] args) {
// 拿到类、拿注解
MyAnnotation1 annotation = Studentcontroller.class.getAnnotation(MyAnnotation1.class);
System.out.println(annotation.value());
System.out.println(annotation.desc());
}
}
当我们运行main方法的时候会出错，原因是因为如图所示：
当我们在次去运行的时候就不会报错了。 
2. 获取类属性上的注解属性值
Demo1.java
package com.jwj.ssm.annotation.demo;
import com.jwj.ssm.annotation.MyAnnotation1;
import com.jwj.ssm.annotation.MyAnnotation2;
import com.jwj.ssm.annotation.Studentcontroller;
import java.lang.reflect.Field;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 22:10
*
* 目标：
* 1.获取studentController 类上自定义注解 中的内容
* 2.获取studentController 方法上自定义注解 中的内容
* 3.获取studentController 属性上自定义注解 中的内容
* 4.获取studentController 参数上自定义注解 中的内容
* * *..*Service.*pager(..)
* com.zking.service.BookService.queryPager(..);
* com.zking.service.OrderService.queryPager(..);
*/
public class Demo1 {
public static void main(String[] args) throws NoSuchFieldException {
// 拿到类、拿注解
MyAnnotation1 annotation = Studentcontroller.class.getAnnotation(MyAnnotation1.class);
System.out.println(annotation.value());
System.out.println(annotation.desc());
// 获取属性上的
Field id = Studentcontroller.class.getDeclaredField("id");
Field name = Studentcontroller.class.getDeclaredField("name");
System.out.println(id.getAnnotation(MyAnnotation1.class).value());
System.out.println(name.getAnnotation(MyAnnotation1.class).value());
}
}
运行结果如图所示：
3. 获取方法上的注解值
// 获取到方法上的 Method m1 = Studentcontroller.class.getDeclaredMethod("test1", String.class, String.class); System.out.println(m1.getAnnotation(MyAnnotation1.class).value()); 运行结果如图所示：
4. 获取参数修饰注解对应的属性值
这里注意如果出现了空指针的问题，上面也讲到过。
Demo1.java
package com.jwj.ssm.annotation.demo;
import com.jwj.ssm.annotation.MyAnnotation1;
import com.jwj.ssm.annotation.MyAnnotation2;
import com.jwj.ssm.annotation.Studentcontroller;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-28 22:10
*
* 目标：
* 1.获取studentController 类上自定义注解 中的内容
* 2.获取studentController 方法上自定义注解 中的内容
* 3.获取studentController 属性上自定义注解 中的内容
* 4.获取studentController 参数上自定义注解 中的内容
* * *..*Service.*pager(..)
* com.zking.service.BookService.queryPager(..);
* com.zking.service.OrderService.queryPager(..);
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
// 拿到类、拿注解
MyAnnotation1 annotation = Studentcontroller.class.getAnnotation(MyAnnotation1.class);
System.out.println(annotation.value());
System.out.println(annotation.desc());
// 获取属性上的
Field id = Studentcontroller.class.getDeclaredField("id");
Field name = Studentcontroller.class.getDeclaredField("name");
System.out.println(id.getAnnotation(MyAnnotation1.class).value());
System.out.println(name.getAnnotation(MyAnnotation1.class).value());
// 获取到方法上的
Method m1 = Studentcontroller.class.getDeclaredMethod("test1", String.class, String.class);
System.out.println(m1.getAnnotation(MyAnnotation1.class).value());
// 获取参数上的标识
for (Parameter p : m1.getParameters()) {
System.out.println(p.getAnnotation(MyAnnotation2.class).value());
}
}
}
三、aop应用自定义注解
在我们做的系统中，有时需要记录操作日志，方便找到某个操作是谁进行的，这个可以用spring的aop来实现，本篇博客记录用自定义注解+aop应用于springboot项目中实现操作日志的记录
1、aop相关术语介绍
- 连接点（Joinpoint)： 程序执行的某个特定位置，如某个方法调用前，调用后，方法抛出异常后，这些代码中的特定点称为连接点；简单来说，就是在哪加入你的逻辑增强，连接点表示具体要拦截的方法，切点是定义一个范围，而连接点是具体到某个方法
- 切点（PointCut）：每个程序的连接点有多个，如何定位到某个感兴趣的连接点，就需要通过切点来定位。比如，连接点是数据库的记录，切点是查询条件；切点用于来限定Spring-AOP启动的范围，通常我们采用表达式的方式来设置，所以关键词是范围
- 增强（Advice）：增强是织入到目标类连接点上的一段程序代码；在Spring中，像BeforeAdvice等还带有方位信息；通知是直译过来的结果，我个人感觉叫做“业务增强”更合适，对照代码就是拦截器定义的相关方法，通知分为如下几种：
前置通知（before）：在执行业务代码前做些操作，比如获取连接对象
后置通知（after）：在执行业务代码后做些操作，无论是否发生异常，它都会执行，比如关闭连接对象
异常通知（afterThrowing）：在执行业务代码后出现异常，需要做的操作，比如回滚事务
返回通知（afterReturning）：在执行业务代码后无异常，会执行的操作
环绕通知（around）：环绕通知可以在方法调用前后完成自定义的行为，它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行
目标对象（Target）：需要被加强的业务对象
织入（Weaving）：织入就是将增强添加到对目标类具体连接点上的过程；织入是一个形象的说法，具体来说，就是生成代理对象并将切面内容融入到业务流程的过程。
代理类（Proxy）：一个类被AOP织入增强后，就产生了一个代理类
切面（Aspect）：切面由切点和增强组成，它既包括了横切逻辑的定义，也包括了连接点的定义，SpringAOP就是将切面所定义的横切逻辑织入到切面所制定的连接点中。SpringAOP将切面定义的内容织入到我们的代码中，从而实现前后的控制逻辑。 比如我们常写的拦截器Interceptor，就是一个切面类
1.自定义注解日志的使用
DemoController.java
package com.jwj.ssm.annotation.aop;
import org.springframework.stereotype.Controller;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-29 14:19
*/
@Controller
public class DemoController {
@MyLog(desc = "这是一个测试类的方法")
public void test(){
System.out.println("测试方法");
}
}
MyLog.java
package com.jwj.ssm.annotation.aop;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
String desc();
}AnnotationTest.java
package com.jwj.ssm.annotation.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class MyLogAspect {
private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);
/**
* 只要用到了com.javaxl.p2.annotation.springAop.MyLog这个注解的，就是目标类
*/
@Pointcut("@annotation(com.jwj.ssm.annotation.aop.MyLog)")
// 这是以前的写法 @Around("execution"(* *..*Service.*Pager(..))")
// 上面这个已经把这个替代掉了 @Pointcut("@execution(* *.*Controller.add())")
private void MyValid() {
}
@Before("MyValid()")
public void before(JoinPoint joinPoint) {
// joinPoint
// 目标对象、目标方法、传递的参数
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
logger.debug("[" + signature.getName() + " : start.....]");
System.out.println("[" + signature.getName() + " : start.....]");
MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);
logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());
System.out.println("【目标对象方法被调用时候产生的日志，记录到日志表中】：" + myLog.desc());
}
}
我们在我们的测试类里面写一个测试方法
AnnotationTest.java
package com.jwj.shiro;
import com.jwj.ssm.annotation.aop.DemoController;
import com.jwj.ssm.biz.ClazzBiz;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author 敢敢
* @site www.javajwj.com
* @company xxx公司
* @create 2022-10-27 22:21
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class AnnotationTest {
@Autowired
private DemoController demoController;
@Test
public void test1(){
demoController.test();
}
}
运行结果如图所示：
2.自定义注解数据字典的使用
可以参考这个地址博客专栏 - 晓码阁
http://47.100.191.44/index
四、总结
1.自定义注解简介
基本注解、元注解、自定义注解
基本注解：@override
元注解：
target：类、属性、方法、参数
retention：source、 class、runtime
如何定义：@interface
自定义注解的分类：标记注解、元数据注解
2.自定义注解
案例
类：Demo.class.getAnnotation
方法：Demo.class.getMethod().getAnnotation
属性：Demo.class.getFiled().getAnnotation
参数：
Method m1 = Studentcontroller.class.getDeclaredMethod("test1", String.class, String.class);
for (Parameter p : m1.getParameters()) {
System.out.println(p.getAnnotation(MyAnnotation2.class).value());
}
注意：只有自定义注解中value在使用时是不需要写出来
列如：@requestmapping（“/list”）
3.aop使用自定义注解
① Mylog 常规使用
Mylog被@aspect所标记的切面类中，原来的规则定义；
@Around("execution"(* *..*Service.*Pager(..))")
是存在弊端的，在特定场景下规则不好定义，现在的规则定义：
@Pointcut("@annotation(com.jwj.ssm.annotation.aop.MyLog)")
代表使用Mylog注解的方法就是目标对象
811
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
