自定义注解与AOP结合使用-阿里云开发者社区

一、SpringMVC之自定义注解

1.1 Java注解简介

注解（Annotation）是Java语言的一种元数据（metadata）机制，它提供了一种在代码中添加额外信息的方式。注解可以用于标记代码的特定元素，如类、方法、字段、参数等，以便在编译时、运行时或者通过工具进行处理。

注解相关类都包含在java.lang.annotation包中。

1.2 为什么要用注解

使用注解的主要目的是为了提供更多的元数据信息，以便在编译时或运行时进行处理。注解可以用于以下几个方面：

编译时处理：注解可以在编译时被编译器识别和处理。通过在代码中添加注解，我们可以告诉编译器执行特定的操作，如生成额外的代码、进行静态检查、生成文档等。例如，JUnit框架中的@Test注解用于标记测试方法，在编译时会被JUnit运行器识别并执行相应的测试。
运行时处理：注解可以在程序运行时通过反射机制被读取和处理。通过读取注解，我们可以获取代码中的元数据信息，并根据注解的定义执行相应的逻辑。例如，Spring框架中的@Autowired注解用于自动注入依赖，通过读取注解，Spring容器可以自动将依赖注入到相应的对象中。
工具处理：注解可以被工具读取和处理，以实现特定的功能。例如，JavaDoc工具可以读取代码中的注解，并生成相应的文档。其他工具，如代码生成器、静态分析工具等，也可以利用注解来实现特定的功能。

使用注解的好处包括：

提供更多的元数据信息：注解可以为代码添加额外的元数据信息，使得代码更加丰富和可读。通过注解，我们可以标记代码的特定含义、行为和规则，提高代码的可理解性和可维护性。
简化开发流程：注解可以简化开发流程，减少重复的代码和配置。通过使用注解，我们可以自动化一些常见的任务，如依赖注入、配置解析、路由映射等，提高开发效率。
增强代码的可靠性和安全性：注解可以用于进行静态检查和约束，以确保代码的正确性和安全性。通过在代码中添加注解，我们可以在编译时或运行时进行验证，避免一些常见的错误和问题。

总之，注解是一种强大的元数据机制，它可以为代码添加额外的信息和行为，提高代码的可读性、可维护性和可靠性。通过使用注解，我们可以简化开发流程，提高开发效率，并实现更灵活和可扩展的功能。

1.3 注解的分类

1.3.1 JDK基本注解

JDK基本注解是Java开发工具包（JDK）中提供的一组预定义注解，用于标记代码的特定元素。这些注解包括：

@Override：用于标记方法覆盖（重写）父类中的方法。当一个方法使用了该注解时，编译器会检查该方法是否正确地覆盖了父类中的方法。
@Deprecated：用于标记已过时的方法、类或字段。当一个方法或类被标记为过时时，编译器会发出警告，提醒开发者不再推荐使用该方法或类。
@SuppressWarnings：用于抑制编译器产生的警告信息。可以在方法、类或整个代码块上使用该注解，以忽略特定类型的警告。

1.3.2 JDK元注解

JDK元注解是用于注解其他注解的注解，它们提供了更多的元数据和行为来定义注解的行为。JDK中提供了四个元注解：

@Retention：用于指定注解的生命周期。可以设置为SOURCE（只在源代码中可见）、CLASS（在编译时可见）或RUNTIME（在运行时可见）。
@Target：用于指定注解可以应用的目标元素类型。可以设置为TYPE（类、接口、枚举）、METHOD（方法）、FIELD（字段）等。
@Documented：用于指定注解是否包含在Java文档中。如果一个注解被@Documented注解修饰，那么它的信息将包含在生成的文档中。
@Inherited：用于指定注解是否可以被继承。如果一个注解被@Inherited注解修饰，那么它的子类将自动继承该注解（不常用）。

@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})，也就是此注解可以在方法和类上面使用

1.3.3 自定义注解

自定义注解是开发者根据自己的需求创建的注解。通过自定义注解，开发者可以为代码添加特定的元数据信息，并定义相应的处理逻辑。自定义注解的创建步骤包括：

使用@interface关键字定义一个注解类型。
在注解中定义需要的元素，可以包括基本类型、枚举类型、Class类型、注解类型等。
使用元注解对注解进行修饰，例如@Retention、@Target等，以定义注解的生命周期和使用范围。
在代码中使用自定义注解，可以通过反射获取注解的元素值，并根据注解的定义进行相应的处理。

要创建一个自定义注解，你需要使用Java的注解机制。下面是一个简单的示例，展示了如何创建一个自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomAnnotation {
    // 在这里定义注解的属性
    String value();
}

在上面的示例中，我们创建了一个名为CustomAnnotation的注解。它有一个属性value，可以用来传递一些自定义的信息。

通过自定义注解，开发者可以实现更灵活和可扩展的功能，如自定义验证规则、日志记录、权限控制等。自定义注解可以在类、方法、字段、参数等级别上使用，以满足不同的需求。

1.4 自定义注解三种使用案例

注解（根据Annotation是否包含成员变量,可以把Annotation分为两类）:

1. 标记注解（Marker Annotation）：这种注解没有成员变量，它们仅通过自身的存在与否来提供信息。

2. 元数据注解（Meta Annotation）：这种注解包含成员变量，它们可以接受和提供更多的元数据信息。元数据注解除了标记代码的特定元素外，还可以携带额外的数据或参数。通过元数据注解，我们可以为代码添加更多的元数据信息，以便在编译时、运行时或者通过工具进行处理。元数据注解可以用于配置、约束、验证等方面。

1.4.1 案例一（获取类与方法上的注解值）

1. 定义一个枚举类：用来表示一组固定的值。

package com.liwen.model;
public enum  TranscationModel {
    Read, Write, ReadWrite
}

2. 定义三个不同注解方式的类：

MyAnnotation1 :

package com.liwen.annotation;
import java.lang.annotation.*;
/**
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}

MyAnnotation2 :

package com.liwen.annotation;
import com.liwen.model.TranscationModel;
import java.lang.annotation.*;
/**
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

MyAnnotation3 :

package com.liwen.annotation;
import com.liwen.model.TranscationModel;
import java.lang.annotation.*;
/**
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}

Demo1测试类 : 获取类与方法上的注解值

package com.liwen.annotation.demo;
import com.liwen.annotation.MyAnnotation1;
import com.liwen.annotation.MyAnnotation2;
import com.liwen.annotation.MyAnnotation3;
import com.liwen.model.TranscationModel;
/**
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {
    @MyAnnotation1(name = "xyz")
    private Integer age;
    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }
    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}

Demo1Test测试类：

package com.liwen.annotation.demo;
import com.liwen.annotation.MyAnnotation1;
import com.liwen.annotation.MyAnnotation2;
import com.liwen.annotation.MyAnnotation3;
import com.liwen.model.TranscationModel;
import org.junit.Test;
public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc
//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read
//        获取属性上的注解
        MyAnnotation1 myAnnotation1 = Demo1.class.getDeclaredField("age").getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());// xyz
    }
    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

1.4.2 案例二（获取类属性上的注解属性值）

1. 自定义注解类：

package com.liwen.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";
    String what() default "这里是默认的what属性对应的值";
}

2. 定义测试类：获取类属性上的注解属性值

package com.liwen.annotation.demo2;
import com.liwen.annotation.TestAnnotation;
/**
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;
    @TestAnnotation("这就是value对应的值1")
    private static String msg2;
    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;
    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

3. 测试

package com.liwen.annotation.demo2;
import com.liwen.annotation.TestAnnotation;
import org.junit.Test;
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }
    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }
    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }
    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}

1.4.3 案例三（获取参数修饰注解对应的属性值）

1，创建自定义注解：

package com.liwen.annotation;
import java.lang.annotation.*;
/**
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

2. 创建测试类：获取参数修饰注解对应的属性值

package com.liwen.annotation.demo3;
import com.liwen.annotation.IsNotNull;
/**
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {
    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }
    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

3. 测试

package com.liwen.annotation.demo3;
import com.liwen.annotation.IsNotNull;
import org.junit.Test;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class Demo3Test {
    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }
    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }
    @Test
    public void hello3() throws Exception {
//        模拟浏览器传递到后台的参数 解读@requestParam
        String name = "zs";
        Demo3 demo3 = new Demo3();
        Method method = demo3.getClass().getMethod("hello1", String.class);
        for (Parameter parameter : method.getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
                if (annotation.value() && !"".equals(name)){
                    method.invoke(demo3,name);
                }
            }
        }
    }
}

二、Aop自定义注解的应用

2.1 自定义注解类

package com.liwen.annotation;
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();
}

2.2 切面类

package com.liwen.aspect;
import com.liwen.annotation.MyLog;
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.liwen.annotation.MyLog)")
    private void MyValid() {
    }
    @Before("MyValid()")
    public void before(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());
    }
}

2.3 Controller层代码

package com.liwen.web;
import com.liwen.annotation.MyLog;
import org.springframework.stereotype.Component;
@Component
public class LogController {
    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("记录日志...");
    }
}

自定义注解与AOP结合使用

一、SpringMVC之自定义注解

1.1 Java注解简介

1.2 为什么要用注解

1.3 注解的分类

1.3.1 JDK基本注解

1.3.2 JDK元注解

1.3.3 自定义注解

1.4 自定义注解三种使用案例

1.4.1 案例一（获取类与方法上的注解值）

1.4.2 案例二（获取类属性上的注解属性值）

1.4.3 案例三（获取参数修饰注解对应的属性值）

二、Aop自定义注解的应用

2.1 自定义注解类

2.2 切面类

2.3 Controller层代码

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

自定义注解与AOP结合使用

一、SpringMVC之自定义注解

1.1 Java注解简介

1.2 为什么要用注解

1.3 注解的分类

1.3.1 JDK基本注解

1.3.2 JDK元注解

1.3.3 自定义注解

1.4 自定义注解三种使用案例

1.4.1 案例一（获取类与方法上的注解值）

1.4.2 案例二（获取类属性上的注解属性值）

1.4.3 案例三（获取参数修饰注解对应的属性值）

二、Aop自定义注解的应用

2.1 自定义注解类

2.2 切面类

2.3 Controller层代码

热门文章

最新文章

相关电子书