Java注解示例详解(含底层原理)

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited // 仅对类上的注解有效，方法和字段上的该注解不会被继承
public @interface MyAnnotation { ... }

// 容器注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
    MyAnnotation[] value();
}

// 重复注解（使用@Repeatable标记）
@Repeatable(MyAnnotations.class)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

// 使用示例
@MyAnnotation("a")
@MyAnnotation("b")
public class MyClass {}

import java.lang.annotation.*;

// 元注解：指定注解的适用范围（类、方法、字段等）
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
// 元注解：指定注解的生命周期（SOURCE/CLASS/RUNTIME）
@Retention(RetentionPolicy.RUNTIME)
// 元注解：是否被javadoc文档提取
@Documented
// 元注解：是否允许子类继承该注解（仅对类注解有效）
@Inherited
public @interface MyAnnotation {
    // 注解属性（类似接口方法，但可指定默认值）
    String value(); // 必选属性（无默认值）
    int count() default 1; // 可选属性（有默认值）
    String[] tags() default {}; // 数组类型
}

// 定义仅含value属性的注解
public @interface MyAnnot {
    String value();
}

// 使用时可简化
@MyAnnot("test")  // 等价于 @MyAnnot(value = "test")
public class Demo {}

public @interface MyAnnot {
    String value();
    int count() default 1; // 有默认值
}

// 仅指定value，可省略属性名
@MyAnnot("test")  // 等价于 @MyAnnot(value = "test", count = 1)
public class Demo {}

public @interface MyAnnot {
    String value();
    int count() default 1;
}

// 错误写法：多属性时不能省略value=
// @MyAnnot("test", count = 2) 

// 正确写法：必须显式指定value=
@MyAnnot(value = "test", count = 2)
public class Demo {}

import java.lang.annotation.*;

/**
 * 自定义日志注解
 * 用于标记需要记录日志的方法
 */
@Target(ElementType.METHOD) // 仅用于方法
@Retention(RetentionPolicy.RUNTIME) // 运行时保留，可通过反射获取
@Documented // 生成文档时包含该注解
public @interface Log {
    // 操作描述（value属性，可简化使用）
    String value() default "";
    
    // 是否记录参数
    boolean recordParams() default true;
    
    // 是否记录返回值
    boolean recordResult() default false;
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * 运行时注解解析器
 * 通过动态代理实现日志记录功能
 */
public class LogRuntimeParser implements InvocationHandler {
    
    // 目标对象
    private final Object target;
    
    public LogRuntimeParser(Object target) {
        this.target = target;
    }
    
    // 创建代理对象
    public static Object createProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LogRuntimeParser(target)
        );
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 检查方法是否有@Log注解
        if (method.isAnnotationPresent(Log.class)) {
            Log log = method.getAnnotation(Log.class);
            
            // 记录开始时间
            long startTime = System.currentTimeMillis();
            
            // 打印日志信息
            System.out.println("\n===== 日志开始 =====");
            System.out.println("操作描述: " + log.value());
            System.out.println("方法名称: " + method.getName());
            
            // 如果需要记录参数
            if (log.recordParams() && args != null) {
                System.out.println("参数列表: " + Arrays.toString(args));
            }
            
            // 执行目标方法
            Object result = method.invoke(target, args);
            
            // 如果需要记录返回值
            if (log.recordResult()) {
                System.out.println("返回结果: " + result);
            }
            
            // 记录执行时间
            System.out.println("执行时间: " + (System.currentTimeMillis() - startTime) + "ms");
            System.out.println("===== 日志结束 =====");
            
            return result;
        }
        
        // 没有@Log注解的方法，直接执行
        return method.invoke(target, args);
    }
}

/**
 * 用户服务接口，用于动态代理
 */
public interface UserServiceInterface {
    boolean login(String username, String password);
    String register(String username, String email);
    void updateProfile(String username, String newEmail);
}

/**
 * 业务服务类，使用自定义的@Log注解
 */
public class UserService {
    
    // 使用注解，仅指定value（可简化写法）
    @Log("用户登录")
    public boolean login(String username, String password) {
        System.out.println("执行登录逻辑...");
        return "admin".equals(username) && "123456".equals(password);
    }
    
    // 完整指定注解的所有属性
    @Log(value = "用户注册", recordParams = true, recordResult = true)
    public String register(String username, String email) {
        System.out.println("执行注册逻辑...");
        return "注册成功，用户ID: " + System.currentTimeMillis();
    }
    
    // 不使用注解的方法（不会被日志记录）
    public void updateProfile(String username, String newEmail) {
        System.out.println("执行更新资料逻辑...");
    }
}

/**
 * 测试主类
 */
public class Main {
    public static void main(String[] args) {
        // 创建目标对象
        UserService userService = new UserService();
        
        // 创建代理对象（用于运行时解析注解）
        UserServiceInterface proxy = (UserServiceInterface) LogRuntimeParser.createProxy(userService);
        
        // 调用被@Log注解的方法
        proxy.login("admin", "123456");
        proxy.register("testUser", "test@example.com");
        
        // 调用未被@Log注解的方法
        proxy.updateProfile("admin", "new@example.com");
    }
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author NanJi
 * @version 1.0
 * @annotationName InitMethod
 * @desc 自定义的初始化方法注解
 * @date 2025/8/2: 11:20
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InitMethod {
    String value() default "";
}

// 编译后的 InitMethod.class
public interface InitMethod extends java.lang.annotation.Annotation {
     public abstract String value(); // 对应注解的value属性
    
    // 编译器自动添加：返回注解类型
    Class<? extends Annotation> annotationType();
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author NanJi
 * @version 1.0
 * @annotationName InitMethod
 * @desc 自定义的初始化方法注解
 * @date 2025/8/2: 11:20
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InitMethod {
    String value() default "";
}

/**
 * @author NanJi
 * @version 1.0
 * @className InitDemo
 * @desc 测试初始化方法注解
 * @date 2025/8/2 : 11:23
 */
public class InitDemo {
    @InitMethod("init...")
    public void init() {
        System.out.println("正在初始化...");
    }
}

import java.lang.reflect.*;

/**
 * @author NanJi
 * @version 1.0
 * @className Main
 * @desc 测试类
 * @date 2025/8/2: 11:30
 */
public class Main {
    public static void main(String[] args) throws Exception {
        // 写入代理类文件
        System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
        Class<InitDemo> cls = InitDemo.class;
        // 获取 InitDemo 类的所有方法
        Method[] methods = cls.getMethods();
        // 遍历所有方法
        for (Method method : methods) {
            // 判断方法是否有 InitMethod 注解
            boolean isInitMethod = method.isAnnotationPresent(InitMethod.class);
            // 如果有 InitMethod 注解，则获取当前的注解代理类
            if (isInitMethod) {
                // 获取 InitMethod 注解的代理类
                InitMethod initMethod = method.getAnnotation(InitMethod.class);
                // 获取代理类的类实例
                System.out.println(initMethod.getClass());
                // 获取注解的值，实际上是通过代理类调用了注解的 value() 方法
                String value = initMethod.value();
                // 打印注解的 value() 方法的值
                System.out.println("InitMethod value: " + value);
                // 调用 InitDemo 类的 init() 方法
                method.invoke(cls.getConstructor().newInstance());
            }
        }
    }
}

// 写入代理类文件
System.setProperty("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");

package jdk.proxy2;

import com.ktjiaoyu.annotation.demo.init.InitMethod;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy1 extends Proxy implements InitMethod {
    private static final Method m0;
    private static final Method m1;
    private static final Method m2;
    private static final Method m3;
    private static final Method m4;

    public $Proxy1(InvocationHandler var1) {
        super(var1);
    }

    public final int hashCode() {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final boolean equals(Object var1) {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String value() {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final Class annotationType() {
        try {
            return (Class)super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.ktjiaoyu.annotation.demo.init.InitMethod").getMethod("value");
            m4 = Class.forName("com.ktjiaoyu.annotation.demo.init.InitMethod").getMethod("annotationType");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(((Throwable)var2).getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(((Throwable)var3).getMessage());
        }
    }

    private static MethodHandles.Lookup proxyClassLookup(MethodHandles.Lookup var0) throws IllegalAccessException {
        if (var0.lookupClass() == Proxy.class && var0.hasFullPrivilegeAccess()) {
            return MethodHandles.lookup();
        } else {
            throw new IllegalAccessException(var0.toString());
        }
    }
}

static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.ktjiaoyu.annotation.demo.init.InitMethod").getMethod("value");
            m4 = Class.forName("com.ktjiaoyu.annotation.demo.init.InitMethod").getMethod("annotationType");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(((Throwable)var2).getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(((Throwable)var3).getMessage());
        }
    }

public final String value() {
        try {
            return (String)super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }