Java注解原理与高级应用实战

1. 注解的本质与核心价值

在Java开发中，注解（Annotation）已经成为现代框架和工具链不可或缺的一部分。作为一名有多年Java开发经验的工程师，我见证了注解从JDK5引入时的"新奇特性"到如今成为企业级开发标配的整个过程。注解的本质是一种特殊的接口，它为程序元素（类、方法、字段等）提供了一种声明式的元数据附加机制。

1.1 注解的底层实现原理

注解在JVM层面的实现相当精妙。当我们定义一个注解时，编译器实际上会生成一个继承自java.lang.annotation.Annotation的接口。这个接口包含了我们定义的所有注解属性方法。例如：

java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
    String module() default "";
}

编译后会生成一个LogExecutionTime.class文件，通过javap反编译可以看到它实际上是一个接口：

java复制public interface LogExecutionTime extends Annotation {
    public abstract String module();
}

运行时，当我们在代码中使用这个注解时，JVM会动态生成一个代理类来实现这个接口，并将注解的属性值存储在其中。这也是为什么我们可以通过反射API获取注解信息的原因。

1.2 注解的核心应用场景

在实际项目中，注解主要应用于以下几个关键场景：

1. 框架配置声明：Spring框架中的@Component、@Service等注解就是典型例子。它们简化了传统的XML配置方式，使代码更加直观。我在一个微服务项目中，通过合理使用这些注解，将配置代码减少了约70%。

2. 编译时检查：@Override、@Deprecated等内置注解帮助我们在编译阶段就能发现潜在问题。我曾经在一个重构项目中，通过添加@Override注解发现了多处方法重写错误，避免了运行时异常。

3. 运行时处理：这是注解最强大的应用场景。通过结合反射机制，我们可以实现各种横切关注点（AOP）。例如，我设计的一个性能监控系统就是基于自定义注解实现的：

java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MonitorPerformance {
    int threshold() default 100; // 毫秒
    String alertReceiver() default "dev-team";
}

4. 代码生成：Lombok工具就是利用注解在编译时生成代码的典范。通过@Getter、@Setter等注解，我们可以保持代码简洁的同时获得完整的功能。

提示：选择注解的应用场景时，需要考虑团队的技术栈和习惯。过度使用注解可能会降低代码可读性，特别是对于不熟悉注解机制的新成员。

2. 元注解：自定义注解的基石

元注解是定义注解的注解，它们是构建自定义注解的基础设施。Java提供了四种核心元注解，理解它们的用途和限制是设计高质量自定义注解的前提。

2.1 深度解析四种元注解

@Target：精确控制注解作用目标

@Target决定了注解可以应用在哪些程序元素上。它的取值来自ElementType枚举，常见的有：

• TYPE：类、接口、枚举
• FIELD：字段（包括枚举常量）
• METHOD：方法
• PARAMETER：形式参数
• CONSTRUCTOR：构造方法

在实际项目中，我建议尽可能精确地指定@Target。例如，字段级注解就应该限定为FIELD，避免被误用在方法上导致混淆。我曾经遇到一个案例：一个本应只用于字段的注解被误用在方法上，由于没有严格限制@Target，这个问题直到运行时才被发现。

@Retention：注解的生命周期管理

这是最重要的元注解之一，它决定了注解在什么阶段有效：

• SOURCE：仅存在于源码中，编译时丢弃。典型应用是@Override，它只在编译阶段用于检查。
• CLASS：保留到类文件但运行时不可见。这是默认值，但实际使用较少。
• RUNTIME：运行时保留，可通过反射读取。这是我们最常用的选项。

一个常见的错误是忘记设置@Retention(RUNTIME)，导致运行时无法通过反射获取注解信息。我在review代码时经常发现这个问题，特别是在自定义的AOP注解中。

@Documented与@Inherited的特殊用途

@Documented决定注解是否出现在JavaDoc中。对于公共API中的注解，建议都加上这个元注解，因为它能提高API文档的完整性。

@Inherited比较特殊，它只对类注解有效，并且只能继承直接父类的注解（不能继承接口的）。这个特性在某些框架设计中很有用，比如Spring的@Transactional注解就使用了@Inherited，使得子类可以继承父类的事务定义。

2.2 元注解组合实战案例

让我们看一个完整的自定义注解示例，它结合了所有元注解的最佳实践：

java复制/**
 * 用于标记需要特殊权限检查的方法
 */
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RequiresPermission {
    String[] value(); // 需要的权限列表
    Logical logical() default Logical.AND; // 权限检查逻辑：AND或OR
    
    enum Logical {
        AND, OR
    }
}

这个注解的设计考虑了以下因素：

1. 可以用于方法或类级别（@Target）
2. 运行时可用（@Retention）
3. 会出现在JavaDoc中（@Documented）
4. 子类可以继承父类的权限定义（@Inherited）
5. 支持灵活的权限检查逻辑（Logical枚举）

3. 自定义注解的设计与实现

设计一个好的自定义注解需要考虑多方面因素：语法规范、使用场景、可扩展性等。下面我将结合一个完整的脱敏场景，分享我在实际项目中的注解设计经验。

3.1 注解属性设计规范

注解属性的设计直接影响注解的易用性和灵活性。以下是一些经过验证的最佳实践：

1. 属性类型限制：注解属性只支持基本类型、String、Class、枚举、注解以及这些类型的数组。不能使用复杂对象或泛型。

2. 默认值策略：为属性提供合理的默认值可以大大简化注解使用。例如：

java复制public @interface Cacheable {
    String key() default ""; // 默认使用方法的签名作为key
    int ttl() default 60; // 默认缓存60秒
}

3. value属性的特殊地位：当注解只有一个属性且命名为value时，使用时可以省略属性名：

java复制@Cacheable("user:info") // 等价于@Cacheable(value="user:info")
public User getUser(Long id) { ... }

4. 数组属性的使用技巧：对于数组属性，当只有一个值时可以省略大括号：

java复制@RequiresPermission("user:read") // 等价于@RequiresPermission({"user:read"})
public void getUser() { ... }

3.2 脱敏注解的完整实现

数据脱敏是金融、医疗等行业常见的需求。下面是我设计的一套完整的脱敏注解方案，已经在多个生产环境中验证。

字段级脱敏注解

java复制/**
 * 标记字段需要进行脱敏处理
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = SensitiveDataSerializer.class)
public @interface SensitiveField {
    /**
     * 脱敏类型
     */
    SensitiveType type();
    
    /**
     * 自定义脱敏规则，格式取决于type
     * - 手机号：前n位保留，后m位保留，如"3,4"
     * - 身份证：同上
     * - 姓名：保留前n个字，如"1"
     */
    String pattern() default "";
    
    /**
     * 脱敏后的替换字符
     */
    char maskChar() default '*';
}

方法级脱敏注解

java复制/**
 * 标记方法的返回值需要脱敏处理
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveResult {
    /**
     * 是否递归处理嵌套对象
     */
    boolean recursive() default true;
    
    /**
     * 要排除的字段名
     */
    String[] excludes() default {};
}

脱敏类型枚举

java复制public enum SensitiveType {
    /**
     * 中文名：保留第一个字
     */
    CHINESE_NAME,
    
    /**
     * 身份证号
     */
    ID_CARD,
    
    /**
     * 手机号
     */
    PHONE_NUMBER,
    
    /**
     * 电子邮件
     */
    EMAIL,
    
    /**
     * 银行卡号
     */
    BANK_CARD,
    
    /**
     * 自定义模式
     */
    CUSTOM
}

3.3 注解处理器实现

定义了注解后，我们需要实现处理逻辑。以下是基于反射和Jackson的处理器实现：

反射处理器核心代码

java复制public class SensitiveDataProcessor {
    private static final Map<Class<?>, List<Field>> FIELD_CACHE = new ConcurrentHashMap<>();

    public static void process(Object obj) {
        if (obj == null) return;
        
        Class<?> clazz = obj.getClass();
        List<Field> fields = FIELD_CACHE.computeIfAbsent(clazz, SensitiveDataProcessor::findSensitiveFields);
        
        for (Field field : fields) {
            processField(obj, field);
        }
    }
    
    private static List<Field> findSensitiveFields(Class<?> clazz) {
        List<Field> sensitiveFields = new ArrayList<>();
        Class<?> current = clazz;
        
        while (current != Object.class) {
            for (Field field : current.getDeclaredFields()) {
                if (field.isAnnotationPresent(SensitiveField.class)) {
                    field.setAccessible(true);
                    sensitiveFields.add(field);
                }
            }
            current = current.getSuperclass();
        }
        
        return sensitiveFields;
    }
    
    private static void processField(Object obj, Field field) {
        try {
            SensitiveField annotation = field.getAnnotation(SensitiveField.class);
            Object value = field.get(obj);
            
            if (value instanceof String) {
                String original = (String) value;
                String masked = mask(original, annotation);
                field.set(obj, masked);
            }
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Failed to process sensitive field", e);
        }
    }
    
    private static String mask(String original, SensitiveField annotation) {
        SensitiveType type = annotation.type();
        String pattern = annotation.pattern();
        char maskChar = annotation.maskChar();
        
        // 具体的脱敏逻辑实现...
    }
}

Jackson序列化器实现

java复制public class SensitiveDataSerializer extends JsonSerializer<String> 
    implements ContextualSerializer {
    
    private SensitiveField annotation;
    
    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider provider) 
        throws IOException {
        if (annotation == null || value == null) {
            gen.writeString(value);
            return;
        }
        
        String masked = mask(value, annotation);
        gen.writeString(masked);
    }
    
    @Override
    public JsonSerializer<?> createContextual(SerializerProvider provider, 
        BeanProperty property) throws JsonMappingException {
        
        SensitiveField ann = property.getAnnotation(SensitiveField.class);
        if (ann != null) {
            SensitiveDataSerializer serializer = new SensitiveDataSerializer();
            serializer.annotation = ann;
            return serializer;
        }
        return provider.findValueSerializer(property.getType(), property);
    }
    
    private String mask(String original, SensitiveField annotation) {
        // 脱敏逻辑实现...
    }
}

4. 注解与框架的高级整合

在实际企业级应用中，单独使用注解往往不够，我们需要将其与主流框架深度整合，才能发挥最大价值。下面我将分享注解与Spring、Jackson等框架的高级整合技巧。

4.1 与Spring AOP的深度整合

Spring AOP是处理注解逻辑的绝佳选择。以下是一个完整的AOP切面实现，用于处理方法级的@SensitiveResult注解：

java复制@Aspect
@Component
@Slf4j
public class SensitiveAspect {
    
    @Autowired
    private SensitiveDataProcessor processor;
    
    @Around("@annotation(sensitiveResult)")
    public Object processSensitiveResult(ProceedingJoinPoint pjp, 
        SensitiveResult sensitiveResult) throws Throwable {
        
        Object result = pjp.proceed();
        if (result == null) {
            return null;
        }
        
        if (sensitiveResult.recursive()) {
            processRecursive(result, sensitiveResult.excludes());
        } else {
            processor.process(result);
        }
        
        return result;
    }
    
    private void processRecursive(Object obj, String[] excludes) {
        if (obj == null) return;
        
        Set<String> excludeSet = new HashSet<>(Arrays.asList(excludes));
        
        // 处理集合类型
        if (obj instanceof Collection) {
            ((Collection<?>) obj).forEach(item -> processRecursive(item, excludes));
            return;
        }
        
        // 处理数组类型
        if (obj.getClass().isArray()) {
            for (Object item : (Object[]) obj) {
                processRecursive(item, excludes);
            }
            return;
        }
        
        // 处理Map类型
        if (obj instanceof Map) {
            ((Map<?, ?>) obj).values().forEach(value -> processRecursive(value, excludes));
            return;
        }
        
        // 处理普通POJO
        if (!isPrimitiveOrWrapper(obj.getClass()) && !(obj instanceof String)) {
            processor.process(obj);
            
            // 递归处理嵌套对象
            for (Field field : getAllFields(obj.getClass())) {
                if (excludeSet.contains(field.getName())) {
                    continue;
                }
                
                try {
                    field.setAccessible(true);
                    Object fieldValue = field.get(obj);
                    processRecursive(fieldValue, excludes);
                } catch (IllegalAccessException e) {
                    log.warn("Failed to access field {} for sensitive processing", 
                        field.getName(), e);
                }
            }
        }
    }
    
    private List<Field> getAllFields(Class<?> clazz) {
        List<Field> fields = new ArrayList<>();
        while (clazz != Object.class) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            clazz = clazz.getSuperclass();
        }
        return fields;
    }
    
    private boolean isPrimitiveOrWrapper(Class<?> clazz) {
        return clazz.isPrimitive() || 
            Boolean.class == clazz ||
            Character.class == clazz ||
            Number.class.isAssignableFrom(clazz);
    }
}

4.2 与Spring Boot的自动配置

为了让我们的注解系统更加易用，可以创建Spring Boot Starter实现自动配置：

java复制@Configuration
@ConditionalOnClass(SensitiveDataProcessor.class)
@EnableConfigurationProperties(SensitiveProperties.class)
public class SensitiveAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public SensitiveDataProcessor sensitiveDataProcessor(SensitiveProperties properties) {
        SensitiveDataProcessor processor = new SensitiveDataProcessor();
        processor.setDefaultMaskChar(properties.getMaskChar());
        return processor;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public SensitiveAspect sensitiveAspect(SensitiveDataProcessor processor) {
        return new SensitiveAspect(processor);
    }
    
    @Bean
    public Module sensitiveModule() {
        SimpleModule module = new SimpleModule();
        module.addSerializer(String.class, new SensitiveDataSerializer());
        return module;
    }
}

@ConfigurationProperties(prefix = "sensitive")
@Data
public class SensitiveProperties {
    private char maskChar = '*';
    private boolean enabled = true;
}

这样，其他项目只需要引入我们的starter依赖，就可以自动获得完整的脱敏功能支持。

4.3 性能优化技巧

注解处理可能会成为性能瓶颈，特别是在处理大量数据时。以下是我在实践中总结的优化技巧：

1. 注解元数据缓存：反射操作代价高昂，应该缓存Class与注解的映射关系。可以使用ConcurrentHashMap实现线程安全的缓存：

java复制private static final Map<Class<?>, Map<Field, SensitiveField>> CACHE = new ConcurrentHashMap<>();

public static Map<Field, SensitiveField> getSensitiveFields(Class<?> clazz) {
    return CACHE.computeIfAbsent(clazz, c -> {
        Map<Field, SensitiveField> map = new HashMap<>();
        // 反射获取字段和注解...
        return Collections.unmodifiableMap(map);
    });
}

2. 选择性处理：在处理对象前先检查是否有相关注解，避免不必要的反射调用：

java复制public static boolean hasSensitiveFields(Class<?> clazz) {
    // 使用类级别的缓存标记
    return SENSITIVE_CLASS_CACHE.computeIfAbsent(clazz, c -> {
        // 检查类或其字段是否有相关注解
    });
}

3. 并行处理：对于集合类型的数据，可以使用并行流提高处理速度：

java复制if (result instanceof Collection && ((Collection<?>) result).size() > 100) {
    ((Collection<?>) result).parallelStream().forEach(this::processObject);
} else {
    processObject(result);
}

4. 字节码增强：对于性能要求极高的场景，可以考虑在编译期或类加载期通过字节码增强技术（如ASM）处理注解，避免运行时反射。

5. 注解设计的最佳实践与避坑指南

经过多个项目的实践，我总结出了一套注解设计的黄金法则和常见问题的解决方案。这些经验可以帮助你避免重蹈覆辙，设计出更加健壮、易用的注解系统。

5.1 设计原则与规范

1. 单一职责原则：每个注解应该只负责一个明确的功能。不要创建"全能型"注解，这会导致注解过于复杂且难以维护。例如，将日志记录和性能监控分开为两个注解：

java复制// 好：职责单一
@LogExecution(module = "user")
@MonitorPerformance(threshold = 200)
public User getUser(Long id) { ... }

// 不好：功能混杂
@CommonAspect(logModule = "user", monitorThreshold = 200)
public User getUser(Long id) { ... }

2. 合理默认值：为注解属性提供合理的默认值可以显著提高易用性。约80%的使用场景应该能够使用默认值。例如：

java复制public @interface DistributedLock {
    String key(); // 必须指定
    int timeout() default 30; // 默认30秒
    TimeUnit unit() default TimeUnit.SECONDS; // 默认秒
    boolean retry() default true; // 默认重试
}

3. 命名一致性：遵循Java注解的命名惯例：

   • 使用名词或形容词（如@Transactional，@Async）
   • 避免动词（如@ExecuteTransaction不好）
   • 使用驼峰命名法
   • 团队内部保持统一风格

4. 文档完整性：为每个注解和属性添加详细的JavaDoc，包括：

   • 注解的用途和典型使用场景
   • 每个属性的含义和允许值
   • 使用示例
   • 与其他注解的交互关系

5.2 常见问题与解决方案

1. 注解不生效：

   • 检查是否设置了@Retention(RUNTIME)
   • 确认@Target包含了使用位置
   • 确保注解处理器被正确调用（如AOP切面是否被Spring管理）

2. 性能问题：

   • 避免在循环中重复解析注解
   • 使用缓存存储解析结果
   • 考虑使用编译时注解处理器（APT）替代运行时处理

3. 继承问题：

   • 记住@Inherited只对类注解有效
   • 接口上的注解不会被实现类继承
   • 方法重写时，子类方法不会继承父类方法的注解

4. 属性类型限制：

   • 注解属性不支持null值
   • 数组属性初始化时不能使用null元素
   • 默认值必须是编译时常量

5.3 高级技巧：注解的注解

有时候我们需要对注解本身进行约束或配置，这时可以使用"元注解的元注解"。例如，我们可以定义一个@DocumentedOptional注解，用来标记哪些元注解是可选的：

java复制@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentedOptional {
    String reason() default "";
}

// 使用示例
@DocumentedOptional(reason = "大多数情况下不需要出现在JavaDoc中")
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface InternalApi {
    // ...
}

这种技巧在框架开发中特别有用，可以创建更加自描述的注解系统。

5.4 测试策略

注解系统也需要全面的测试覆盖：

1. 单元测试：测试注解定义本身（属性默认值等）
2. 集成测试：测试注解与框架的整合
3. 性能测试：特别是对反射密集型操作
4. 兼容性测试：确保注解在不同Java版本和框架版本中的行为一致

以下是一个典型的注解测试用例：

java复制public class SensitiveFieldTest {
    
    @Test
    public void testAnnotationAttributes() {
        SensitiveField ann = User.class.getDeclaredField("phoneNumber")
            .getAnnotation(SensitiveField.class);
        
        assertEquals(SensitiveType.PHONE_NUMBER, ann.type());
        assertEquals("3,4", ann.pattern());
        assertEquals('*', ann.maskChar());
    }
    
    @Test
    public void testSerialization() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new SensitiveModule());
        
        User user = new User("张三", "13812345678");
        String json = mapper.writeValueAsString(user);
        
        assertTrue(json.contains("张*"));
        assertTrue(json.contains("138****5678"));
    }
    
    static class User {
        @SensitiveField(type = SensitiveType.CHINESE_NAME, pattern = "1")
        private String name;
        
        @SensitiveField(type = SensitiveType.PHONE_NUMBER, pattern = "3,4")
        private String phoneNumber;
        
        // 构造方法、getter/setter省略
    }
}

6. 注解在复杂系统中的应用案例

在实际企业级系统中，注解的应用远比简单的示例复杂得多。下面我将分享几个我在实际项目中实现的复杂注解案例，这些案例都经过了生产环境的验证。

6.1 分布式锁注解

在分布式系统中，协调多个服务对共享资源的访问是一个常见需求。我们设计了一个@DistributedLock注解来简化这一过程：

java复制@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLock {
    /**
     * 锁的key，支持SpEL表达式
     * 示例: @DistributedLock("order:#orderId")
     */
    String value();
    
    /**
     * 锁的等待时间(默认不等待)
     */
    long waitTime() default 0;
    
    /**
     * 锁的持有时间(秒)，超过自动释放
     */
    long leaseTime() default 30;
    
    /**
     * 时间单位(默认秒)
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
    
    /**
     * 获取锁失败时的处理策略
     */
    LockFailStrategy strategy() default LockFailStrategy.THROW_EXCEPTION;
    
    enum LockFailStrategy {
        /**
         * 抛出异常
         */
        THROW_EXCEPTION,
        /**
         * 忽略，继续执行
         */
        CONTINUE,
        /**
         * 返回null
         */
        RETURN_NULL,
        /**
         * 重试(直到成功或超时)
         */
        RETRY
    }
}

对应的切面处理器实现了以下功能：

1. 解析SpEL表达式生成动态锁key
2. 根据配置尝试获取锁
3. 实现不同的失败策略
4. 添加监控指标

6.2 多数据源路由注解

在需要访问多个数据库的系统里，我们设计了@DataSource注解来实现声明式的数据源切换：

java复制@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    /**
     * 数据源名称
     */
    String value();
    
    /**
     * 是否在方法执行后恢复默认数据源
     */
    boolean resetAfter() default true;
    
    /**
     * 当指定数据源不存在时的处理策略
     */
    NotFoundAction notFoundAction() default NotFoundAction.FALLBACK_DEFAULT;
    
    enum NotFoundAction {
        /**
         * 回退到默认数据源
         */
        FALLBACK_DEFAULT,
        /**
         * 抛出异常
         */
        THROW_EXCEPTION,
        /**
         * 尝试初始化数据源
         */
        INIT_IF_POSSIBLE
    }
}

这个注解的实现涉及：

1. 自定义Spring的AbstractRoutingDataSource
2. 通过AOP在方法调用前后切换数据源
3. 数据源的动态注册机制
4. 连接池的健康检查

6.3 审计日志注解

为了满足合规性要求，我们设计了@AuditLog注解来自动记录关键操作：

java复制@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AuditLog {
    /**
     * 操作类型
     */
    OperationType operation();
    
    /**
     * 操作对象ID，支持SpEL
     */
    String objectId() default "";
    
    /**
     * 操作描述，支持SpEL
     */
    String description() default "";
    
    /**
     * 是否记录方法参数
     */
    boolean logParameters() default true;
    
    /**
     * 是否记录返回值
     */
    boolean logResult() default false;
    
    /**
     * 敏感参数索引(不记录)
     */
    int[] sensitiveParameters() default {};
    
    enum OperationType {
        CREATE, READ, UPDATE, DELETE, IMPORT, EXPORT, APPROVE, REJECT
    }
}

实现特点：

1. 支持SpEL表达式动态生成日志内容
2. 自动过滤敏感参数
3. 异步记录日志不影响主流程性能
4. 与安全框架集成自动获取操作人信息

6.4 性能监控注解

为了监控系统关键路径的性能，我们设计了@PerformanceMonitor注解：

java复制@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PerformanceMonitor {
    /**
     * 监控指标名称
     */
    String value();
    
    /**
     * 是否记录方法参数作为tag
     */
    boolean recordParameters() default false;
    
    /**
     * 慢操作阈值(毫秒)
     */
    long slowThreshold() default 500;
    
    /**
     * 采样率(0-1)
     */
    double sampleRate() default 1.0;
    
    /**
     * 监控系统类型
     */
    MonitorSystem system() default MonitorSystem.PROMETHEUS;
    
    enum MonitorSystem {
        PROMETHEUS, INFLUXDB, DATADOG, CUSTOM
    }
}

实现功能：

1. 支持多种监控系统
2. 可配置的采样率控制数据量
3. 自动识别慢操作并记录详细上下文
4. 与分布式追踪系统集成

这些案例展示了注解在复杂系统中的强大能力。通过合理的注解设计，我们可以将横切关注点模块化，保持业务代码的简洁性，同时获得强大的系统功能。