JAVA 注解Annotation开发流程从原理到实战应用

/**
 * @Override 注解使用示例
 */
class ParentClass {
    public void sayHello() {
        System.out.println("父类的sayHello方法");
    }
}
class ChildClass extends ParentClass {
    // 使用@Override标记该方法是重写自父类
    @Override
    public void sayHello() {
        System.out.println("子类重写的sayHello方法");
    }
    // 错误示例：方法签名与父类不一致，编译报错
    // @Override
    // public void sayHello(String name) {
    //     System.out.println("Hello " + name);
    // }
}
public class OverrideDemo {
    public static void main(String[] args) {
        ParentClass child = new ChildClass();
        child.sayHello(); // 输出：子类重写的sayHello方法
    }
}

/**
 * @Deprecated 注解使用示例
 */
public class DeprecatedDemo {
    // 标记该方法已过时
    @Deprecated
    public static void oldMethod() {
        System.out.println("这个方法已经过时了，请使用newMethod替代");
    }
    // 新的替代方法
    public static void newMethod() {
        System.out.println("这是新的推荐方法");
    }
    public static void main(String[] args) {
        // 使用过时方法，编译器会发出警告
        oldMethod();
        // 使用推荐方法
        newMethod();
    }
}

import java.util.ArrayList;
import java.util.List;
/**
 * @SuppressWarnings 注解使用示例
 */
public class SuppressWarningsDemo {
    public static void main(String[] args) {
        // 抑制未检查转换警告
        @SuppressWarnings("unchecked")
        List<String> list = new ArrayList(); // 原始类型ArrayList，默认会产生警告
        list.add("Hello Annotation");
        System.out.println(list.get(0));
        // 抑制过时方法警告
        @SuppressWarnings("deprecation")
        void test() {
            DeprecatedDemo.oldMethod(); // 调用过时方法，不会产生警告
        }
        test();
    }
}

import java.lang.annotation.*;
/**
 * 自定义注解 + 元注解使用示例
 * 该注解用于标记类的作者信息
 */
// 该注解只能修饰类
@Target(ElementType.TYPE)
// 注解在运行时有效，可通过反射获取
@Retention(RetentionPolicy.RUNTIME)
// 注解信息会被javadoc提取
@Documented
// 注解可以被子类继承
@Inherited
public @interface Author {
    // 注解属性：作者姓名，必填
    String name();
    // 注解属性：作者邮箱，可选，默认值为空字符串
    String email() default "";
}

[元注解]
public @interface 注解名称 {
    // 注解属性定义
    属性类型 属性名() [default 默认值];
}

import java.lang.annotation.*;
/**
 * 注解1：用于标记业务日志，记录方法的操作信息
 */
@Target(ElementType.METHOD) // 仅修饰方法
@Retention(RetentionPolicy.RUNTIME) // 运行时有效
public @interface Log {
    // 操作描述
    String desc();
    // 操作类型，默认值为"OTHER"
    String type() default "OTHER";
}
/**
 * 注解2：用于标记数据校验，校验方法参数的合法性
 */
@Target(ElementType.PARAMETER) // 仅修饰方法参数
@Retention(RetentionPolicy.RUNTIME) // 运行时有效
public @interface Validate {
    // 参数不能为空
    boolean notNull() default true;
    // 参数长度最小值，默认值为0
    int minLength() default 0;
}

/**
 * 自定义注解使用示例：用户服务类
 */
public class UserService {
    // 使用@Log注解标记方法，记录操作日志
    @Log(desc = "根据ID查询用户", type = "QUERY")
    public String getUserById(
            // 使用@Validate注解标记参数，校验参数合法性
            @Validate(notNull = true, minLength = 1) String userId) {
        if (userId == null || userId.length() < 1) {
            return "参数不合法";
        }
        return "用户ID：" + userId + "，用户名：张三";
    }
    @Log(desc = "添加用户", type = "ADD")
    public String addUser(
            @Validate(notNull = true, minLength = 2) String username) {
        if (username == null || username.length() < 2) {
            return "用户名长度不能小于2";
        }
        return "添加用户成功：" + username;
    }
}

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
/**
 * 注解解析器：解析@Log和@Validate注解
 */
public class AnnotationParser {
    /**
     * 解析@Log注解，输出方法操作日志
     */
    public static void parseLogAnnotation(Class<?> clazz) {
        // 获取类中所有方法
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            // 判断方法是否有@Log注解
            if (method.isAnnotationPresent(Log.class)) {
                Log log = method.getAnnotation(Log.class);
                System.out.println("===== 方法操作日志 =====");
                System.out.println("方法名：" + method.getName());
                System.out.println("操作描述：" + log.desc());
                System.out.println("操作类型：" + log.type());
                System.out.println("-----------------------");
            }
        }
    }
    /**
     * 解析@Validate注解，校验方法参数合法性
     */
    public static Object invokeAndValidate(Object obj, String methodName, Object... args) throws Exception {
        // 获取目标方法
        Method method = obj.getClass().getDeclaredMethod(methodName, getParameterTypes(args));
        Parameter[] parameters = method.getParameters();
        // 校验参数
        for (int i = 0; i < parameters.length; i++) {
            Parameter param = parameters[i];
            if (param.isAnnotationPresent(Validate.class)) {
                Validate validate = param.getAnnotation(Validate.class);
                Object arg = args[i];
                String paramName = param.getName();
                // 非空校验
                if (validate.notNull() && arg == null) {
                    throw new IllegalArgumentException(paramName + " 不能为null");
                }
                // 长度校验
                if (arg instanceof String && ((String) arg).length() < validate.minLength()) {
                    throw new IllegalArgumentException(paramName + " 长度不能小于" + validate.minLength());
                }
            }
        }
        // 调用目标方法
        return method.invoke(obj, args);
    }
    // 获取参数类型数组
    private static Class<?>[] getParameterTypes(Object... args) {
        if (args == null || args.length == 0) {
            return new Class[0];
        }
        Class<?>[] types = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            types[i] = args[i].getClass();
        }
        return types;
    }
    // 测试方法
    public static void main(String[] args) throws Exception {
        UserService userService = new UserService();
        // 解析@Log注解
        parseLogAnnotation(UserService.class);
        // 解析@Validate注解并调用方法
        System.out.println("正常调用：" + invokeAndValidate(userService, "getUserById", "1001"));
        System.out.println("参数非法调用：" + invokeAndValidate(userService, "getUserById", ""));
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 基于注解的AOP日志切面
 */
// 定义切面注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface LogAspect {
}
// 业务接口
interface OrderService {
    @LogAspect
    void createOrder(String orderId);
}
// 业务实现类
class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(String orderId) {
        System.out.println("创建订单：" + orderId);
    }
}
// 日志切面处理器
class LogAspectHandler implements InvocationHandler {
    private Object target;
    public LogAspectHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法执行前：判断是否有@LogAspect注解
        if (method.isAnnotationPresent(LogAspect.class)) {
            System.out.println("[前置日志] 方法 " + method.getName() + " 开始执行，参数：" + args[0]);
        }
        // 执行目标方法
        Object result = method.invoke(target, args);
        // 方法执行后
        if (method.isAnnotationPresent(LogAspect.class)) {
            System.out.println("[后置日志] 方法 " + method.getName() + " 执行完毕");
        }
        return result;
    }
    // 创建代理对象
    public static <T> T createProxy(T target) {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LogAspectHandler(target)
        );
    }
}
// 测试类
public class AnnotationAopDemo {
    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        OrderService proxy = LogAspectHandler.createProxy(orderService);
        proxy.createOrder("ORDER_20260129");
    }
}

import java.lang.annotation.*;
/**
 * 基于注解的ORM映射示例
 */
// 表映射注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    String name();
}
// 字段映射注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Column {
    String name();
    String type() default "VARCHAR";
    int length() default 255;
}
// 实体类
@Table(name = "t_user")
class User {
    @Column(name = "user_id", type = "INT", length = 10)
    private Integer userId;
    @Column(name = "user_name", type = "VARCHAR", length = 50)
    private String userName;
    @Column(name = "age", type = "INT", length = 3)
    private Integer age;
    // 省略getter/setter方法
    public Integer getUserId() { return userId; }
    public void setUserId(Integer userId) { this.userId = userId; }
    public String getUserName() { return userName; }
    public void setUserName(String userName) { this.userName = userName; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}
// ORM工具类：生成SQL语句
class OrmUtil {
    public static String generateSelectSql(Class<?> clazz) {
        // 获取表名
        Table table = clazz.getAnnotation(Table.class);
        if (table == null) {
            throw new IllegalArgumentException("实体类未添加@Table注解");
        }
        String tableName = table.name();
        // 获取字段名
        StringBuilder columns = new StringBuilder();
        java.lang.reflect.Field[] fields = clazz.getDeclaredFields();
        for (java.lang.reflect.Field field : fields) {
            Column column = field.getAnnotation(Column.class);
            if (column != null) {
                columns.append(column.name()).append(",");
            }
        }
        // 移除最后一个逗号
        columns.deleteCharAt(columns.length() - 1);
        // 生成查询SQL
        return "SELECT " + columns + " FROM " + tableName;
    }
    public static void main(String[] args) {
        System.out.println("生成的查询SQL：" + generateSelectSql(User.class));
    }
}

import java.lang.annotation.*;
import java.lang.reflect.Method;
/**
 * 简化版JUnit框架：基于注解的单元测试
 */
// 测试方法注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface TestCase {
}
// 测试类
class MathTest {
    @TestCase
    public void testAdd() {
        int result = 1 + 2;
        assert result == 3 : "加法测试失败";
        System.out.println("testAdd 测试通过");
    }
    @TestCase
    public void testMultiply() {
        int result = 2 * 3;
        assert result == 6 : "乘法测试失败";
        System.out.println("testMultiply 测试通过");
    }
    // 非测试方法，不会被执行
    public void normalMethod() {
        System.out.println("这是普通方法，不会被测试");
    }
}
// 测试运行器
class TestRunner {
    public static void run(Class<?> testClass) throws Exception {
        Object obj = testClass.getDeclaredConstructor().newInstance();
        Method[] methods = testClass.getDeclaredMethods();
        int passCount = 0;
        int failCount = 0;
        for (Method method : methods) {
            if (method.isAnnotationPresent(TestCase.class)) {
                try {
                    method.invoke(obj);
                    passCount++;
                } catch (Exception e) {
                    failCount++;
                    System.out.println(method.getName() + " 测试失败：" + e.getCause().getMessage());
                }
            }
        }
        System.out.println("\n===== 测试结果 ======");
        System.out.println("总测试数：" + (passCount + failCount));
        System.out.println("通过数：" + passCount);
        System.out.println("失败数：" + failCount);
    }
    public static void main(String[] args) throws Exception {
        TestRunner.run(MathTest.class);
    }
}

import java.lang.annotation.*;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
/**
 * 基于注解的权限校验框架
 */
// 权限校验注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresPermission {
    // 所需权限角色
    String[] value();
}
// 用户上下文类：存储当前登录用户信息
class UserContext {
    private static ThreadLocal<String> currentUser = new ThreadLocal<>();
    private static Set<String> userRoles = new HashSet<>();
    // 设置当前用户
    public static void setCurrentUser(String username, String... roles) {
        currentUser.set(username);
        userRoles.clear();
        userRoles.addAll(Arrays.asList(roles));
    }
    // 获取当前用户角色
    public static Set<String> getUserRoles() {
        return userRoles;
    }
    // 清除当前用户
    public static void clear() {
        currentUser.remove();
        userRoles.clear();
    }
}
// 权限校验切面类
class PermissionAspect {
    /**
     * 执行方法并校验权限
     */
    public static Object invoke(Object obj, String methodName, Object... args) throws Exception {
        Method method = obj.getClass().getDeclaredMethod(methodName, getParameterTypes(args));
        // 权限校验
        if (method.isAnnotationPresent(RequiresPermission.class)) {
            RequiresPermission annotation = method.getAnnotation(RequiresPermission.class);
            String[] requiredRoles = annotation.value();
            Set<String> userRoles = UserContext.getUserRoles();
            // 检查是否有匹配的角色
            boolean hasPermission = false;
            for (String role : requiredRoles) {
                if (userRoles.contains(role)) {
                    hasPermission = true;
                    break;
                }
            }
            if (!hasPermission) {
                throw new SecurityException("无权限访问该方法，所需角色：" + Arrays.toString(requiredRoles));
            }
        }
        // 执行目标方法
        return method.invoke(obj, args);
    }
    private static Class<?>[] getParameterTypes(Object... args) {
        if (args == null || args.length == 0) {
            return new Class[0];
        }
        Class<?>[] types = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            types[i] = args[i].getClass();
        }
        return types;
    }
}
// 业务服务类
class AdminService {
    @RequiresPermission({"ADMIN", "SUPER_ADMIN"})
    public String deleteUser(String userId) {
        return "删除用户成功：" + userId;
    }
    @RequiresPermission({"USER", "ADMIN", "SUPER_ADMIN"})
    public String queryUser(String userId) {
        return "查询用户信息：" + userId;
    }
}
// 测试类
public class PermissionFrameworkDemo {
    public static void main(String[] args) throws Exception {
        AdminService adminService = new AdminService();
        // 测试1：管理员用户，拥有ADMIN角色
        UserContext.setCurrentUser("admin", "ADMIN");
        System.out.println(PermissionAspect.invoke(adminService, "deleteUser", "1001"));
        System.out.println(PermissionAspect.invoke(adminService, "queryUser", "1001"));
        // 测试2：普通用户，只有USER角色
        UserContext.setCurrentUser("user", "USER");
        System.out.println(PermissionAspect.invoke(adminService, "queryUser", "1001"));
        try {
            PermissionAspect.invoke(adminService, "deleteUser", "1001");
        } catch (Exception e) {
            System.out.println(e.getCause().getMessage());
        }
        UserContext.clear();
    }
}