1
@注解名(参数列表) public class MyClass { // 类内容 }

1
import java.lang.reflect.Method;
2

3
public class AnnotationProcessor {
4

5
    public static void processClass(Class<?> clazz) {
6
        // 检查类上的注解
7
        if (clazz.isAnnotationPresent(MyCustomAnnotation.class)) {
8
            MyCustomAnnotation annotation = clazz.getAnnotation(MyCustomAnnotation.class);
9
            System.out.println("Class annotation:");
10
            System.out.println("  Value: " + annotation.value());
11
            System.out.println("  Name: " + annotation.name());
12
            System.out.println("  Priority: " + annotation.priority());
13
            System.out.println("  Tags: " + String.join(", ", annotation.tags()));
14
        }
15

16
        // 检查方法上的注解
17
        Method[] methods = clazz.getDeclaredMethods();
18
        for (Method method : methods) {
19
            if (method.isAnnotationPresent(MyCustomAnnotation.class)) {
20
                MyCustomAnnotation annotation = method.getAnnotation(MyCustomAnnotation.class);
21
                System.out.println("Method " + method.getName() + " annotation:");
22
                System.out.println("  Value: " + annotation.value());
23
            }
24
        }
25
    }
26

27
    public static void main(String[] args) {
28
        processClass(TestClass.class);
29
    }
30
}

1
import javax.annotation.processing.*;
2
import javax.lang.model.element.*;
3
import javax.lang.model.SourceVersion;
4
import java.util.Set;
5

6
@SupportedAnnotationTypes("com.example.MyCustomAnnotation")
7
@SupportedSourceVersion(SourceVersion.RELEASE_8)
8
public class MyAnnotationProcessor extends AbstractProcessor {
9

10
    @Override
11
    public boolean process(Set<? extends TypeElement> annotations,
12
                          RoundEnvironment roundEnv) {
13

14
        for (Element element : roundEnv.getElementsAnnotatedWith(MyCustomAnnotation.class)) {
15
            MyCustomAnnotation annotation = element.getAnnotation(MyCustomAnnotation.class);
16

17
            // 在编译时处理注解
18
            processingEnv.getMessager().printMessage(
19
                Diagnostic.Kind.NOTE,
20
                "Processing element: " + element.getSimpleName() +
21
                " with value: " + annotation.value()
22
            );
23
        }
24

25
        return true;
26
    }
27
}

1
// 定义缓存注解
2
@Target(ElementType.METHOD)
3
@Retention(RetentionPolicy.RUNTIME)
4
public @interface Cacheable {
5
  // 缓存的键
6
    String key();
7
    // 过期时间（秒），默认5分钟
8
    int expireTime() default 300;
9
}
10

11
// 缓存切面处理器
12
@Component
13
@Aspect
14
public class CacheAspect {
15

16
    private Map<String, CacheItem> cache = new ConcurrentHashMap<>();
17

18
    // 拦截所有带@Cacheable注解的方法
19
    @Around("@annotation(cacheable)")
20
    public Object handleCache(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
21
      // 1. 获取缓存键
22
        String key = cacheable.key();
23

24
        // 2. 检查缓存是否存在且未过期
25
        CacheItem item = cache.get(key);
26
        if (item != null && !item.isExpired()) {
27
            return item.getValue();
28
        }
29

30
        // 3. 缓存不存在或已过期，执行原方法
31
        Object result = joinPoint.proceed();
32

33
        // 4. 将结果存入缓存
34
        cache.put(key, new CacheItem(result, cacheable.expireTime()));
35

36
        return result;
37
    }
38

39
    private static class CacheItem {
40
      // 缓存的值
41
        private Object value;
42
        // 过期时间戳
43
        private long expireTime;
44

45
        public CacheItem(Object value, int expireSeconds) {
46
            this.value = value;
47
            this.expireTime = System.currentTimeMillis() + expireSeconds * 1000L;
48
        }
49

50
        // 检查是否过期
51
        public boolean isExpired() {
52
            return System.currentTimeMillis() > expireTime;
53
        }
54

55
        public Object getValue() {
56
            return value;
57
        }
58
    }
59
}
60

61
// 使用缓存注解
62
@Service
63
public class UserService {
64
    // 缓存10分钟
65
    @Cacheable(key = "user_#{id}", expireTime = 600)
66
    public User findById(Long id) {
67
        // 模拟数据库查询
68
        return userRepository.findById(id);
69
    }
70
}

1
// 定义日志注解
2
@Target(ElementType.METHOD)
3
@Retention(RetentionPolicy.RUNTIME)
4
public @interface LogExecution {
5
    String value() default "";
6
    boolean logParams() default false;
7
    boolean logResult() default false;
8
}
9

10
// 日志切面处理器
11
@Component
12
@Aspect
13
public class LogAspect {
14

15
    private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
16

17
    @Around("@annotation(logExecution)")
18
    public Object logExecutionTime(ProceedingJoinPoint joinPoint, LogExecution logExecution) throws Throwable {
19
        long startTime = System.currentTimeMillis();
20
        String methodName = joinPoint.getSignature().getName();
21

22
        // 记录方法开始执行
23
        if (logExecution.logParams()) {
24
          // 获取方法参数
25
            Object[] args = joinPoint.getArgs();
26
            logger.info("方法 {} 开始执行，参数: {}", methodName, Arrays.toString(args));
27
        } else {
28
            logger.info("方法 {} 开始执行", methodName);
29
        }
30

31
        try {
32
            Object result = joinPoint.proceed();
33

34
            long endTime = System.currentTimeMillis();
35
            long executionTime = endTime - startTime;
36

37
            if (logExecution.logResult()) {
38
                logger.info("方法 {} 执行完成，耗时: {}ms，结果: {}", methodName, executionTime, result);
39
            } else {
40
                logger.info("方法 {} 执行完成，耗时: {}ms", methodName, executionTime);
41
            }
42

43
            return result;
44
        } catch (Exception e) {
45
            long endTime = System.currentTimeMillis();
46
            long executionTime = endTime - startTime;
47
            logger.error("方法 {} 执行异常，耗时: {}ms", methodName, executionTime, e);
48
            throw e;
49
        }
50
    }
51
}
52

53
// 使用日志注解
54
@Service
55
public class OrderService {
56

57
    @LogExecution(value = "创建订单", logParams = true, logResult = true)
58
    public Order createOrder(OrderDto orderDto) {
59
        // 业务逻辑
60
        Order order = new Order();
61
        order.setOrderNumber(generateOrderNumber());
62
        order.setAmount(orderDto.getAmount());
63
        return orderRepository.save(order);
64
    }
65
}