isAnnotationPresent方法的作用

isAnnotationPresent方法是Java反射API中的一个方法，用于判断某个类、方法、字段或构造器上是否存在指定的注解。

该方法的作用是判断某个类、方法、字段或构造器上是否存在某个注解，如果存在则返回true，否则返回false。通过该方法可以实现一些动态的操作，例如根据注解的信息来执行一些特定的逻辑或控制流程。

例如，我们可以使用isAnnotationPresent方法来判断某个类是否标注了指定的注解，如果标注了，则可以根据注解中的信息来执行一些特定的逻辑或控制流程。同时，该方法还可以用于编写通用的框架或工具类，例如自定义注解处理器、AOP框架等。

总之，isAnnotationPresent方法是Java反射API中非常常用的方法之一，它可以帮助我们实现一些动态的操作，提高了程序的灵活性和可扩展性。

相关问题

class.isAnnotationPresent(UmpType.class)的作用是什么

`class.isAnnotationPresent(UmpType.class)` 是一种 Java 反射 API 的应用，主要用于判断一个类（或接口、枚举等）是否被 `UmpType` 注解所标记。

在 Java 中，注解（Annotation）是一种元数据，用于为程序元素（如类、方法、字段等）添加附加信息。注解可以在编译时和运行时被读取，并且可以通过反射 API 获取到注解信息。

在 Spring AOP 中，我们可以在切面中定义注解来限定切入点的范围。例如，我们可以定义一个 `UmpType` 注解来标识需要监控的类，然后使用 `class.isAnnotationPresent(UmpType.class)` 来判断被切入的类是否被 `UmpType` 注解所标记。

例如，假设有以下代码：

@UmpType
@Service
public class UserServiceImpl implements UserService {
    public void save(User user) {
        // ...
    }
}

如果我们在切面中需要对被 `@UmpType` 注解标记的类进行处理，可以使用以下代码：

@Aspect
@Component
public class UmpAspect {
    @Before("execution(* com.example.service.*.*(..)) && @within(umpType)")
    public void beforeMethod(JoinPoint jp, UmpType umpType) {
        Class<?> clazz = jp.getTarget().getClass();
        if (clazz.isAnnotationPresent(UmpType.class)) {
            // do something
        }
    }
}

其中，`clazz.isAnnotationPresent(UmpType.class)` 就是用来判断被切入的类是否被 `UmpType` 注解所标记。

总之，`class.isAnnotationPresent(UmpType.class)` 可以帮助我们在切面中判断被切入的类是否被某个注解所标记，从而实现更加灵活的切面编程。

- 定义一个注解MyTest，要求只能定义在方法上，注解可以在运行时起作用 - 凡是被MyTest注解标记的方法，都可以自动执行 - MyTest注解有order属性，默认值是1。可以赋值整数数字，order值大的方法先执行

可以这样定义MyTest注解：

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 MyTest {
    int order() default 1;
}

- `@Retention(RetentionPolicy.RUNTIME)` 表示 MyTest 注解在运行时保留，可以通过反射获取；
- `@Target(ElementType.METHOD)` 表示 MyTest 注解只能定义在方法上；
- `int order() default 1;` 表示 MyTest 注解有一个 order 属性，默认值为 1。

接下来，我们可以定义一个测试类，使用 MyTest 注解：

public class MyTestDemo {
    @MyTest(order = 2)
    public void test1() {
        System.out.println("test1");
    }

    @MyTest(order = 1)
    public void test2() {
        System.out.println("test2");
    }

    @MyTest
    public void test3() {
        System.out.println("test3");
    }

    public static void main(String[] args) throws Exception {
        // 获取 MyTestDemo 类中所有方法
        Method[] methods = MyTestDemo.class.getDeclaredMethods();
        // 定义一个 Map 用于存放 MyTest 注解的方法
        Map<Integer, List<Method>> map = new TreeMap<>((o1, o2) -> o2 - o1);
        for (Method method : methods) {
            // 判断方法是否被 MyTest 注解标记
            if (method.isAnnotationPresent(MyTest.class)) {
                // 获取 MyTest 注解
                MyTest myTest = method.getAnnotation(MyTest.class);
                // 获取 order 值
                int order = myTest.order();
                // 判断 map 中是否已经存在 order 值对应的 List
                if (!map.containsKey(order)) {
                    map.put(order, new ArrayList<>());
                }
                // 将方法添加到 List 中
                map.get(order).add(method);
            }
        }
        // 循环执行方法
        for (Map.Entry<Integer, List<Method>> entry : map.entrySet()) {
            for (Method method : entry.getValue()) {
                // 执行方法
                method.invoke(new MyTestDemo());
            }
        }
    }
}

MyTestDemo 类中定义了三个方法 test1、test2 和 test3，并且都被 MyTest 注解标记，其中 test1 和 test2 的 order 值分别为 2 和 1，test3 没有指定 order 值，默认为 1。在 main 方法中，我们使用反射获取 MyTestDemo 类中所有方法，然后通过 TreeMap 来按照 order 值排序，最后循环执行方法。执行结果如下：

test1
test2
test3

可以看到，先执行了 order 值为 2 的 test1 方法，然后执行了 order 值为 1 的 test2 和 test3 方法。