java aop实现

Java AOP实现

介绍

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它将程序逻辑分为核心业务逻辑和横切关注点（如日志、权限控制等）两部分。AOP的基本思想是通过在代码运行前、运行后或者抛出异常时插入代码，来实现对核心业务逻辑的增强。Java作为一种面向对象的编程语言，提供了多种方式来实现AOP，本文将介绍其中的几种常见方式。

静态代理

静态代理是最简单的实现AOP的方式之一。通过在核心业务类的每个方法前后插入代码，实现对核心业务逻辑的增强。

// 核心业务接口
public interface UserService {
    void addUser(String userName);
}

// 核心业务实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String userName) {
        System.out.println("添加用户：" + userName);
    }
}

// 代理类
public class UserServiceProxy implements UserService {
    private UserService userService;

    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void addUser(String userName) {
        System.out.println("添加用户前的处理");
        userService.addUser(userName);
        System.out.println("添加用户后的处理");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserServiceProxy proxy = new UserServiceProxy(userService);
        proxy.addUser("Tom");
    }
}

在上述代码中，UserServiceImpl是核心业务类，UserServiceProxy是代理类。UserServiceProxy实现了UserService接口，它在调用核心业务方法前后分别执行了前置处理和后置处理。

JDK动态代理

JDK动态代理是基于接口实现的动态代理方式。它通过在运行时创建动态代理类和动态代理对象来实现AOP。

// 核心业务接口
public interface UserService {
    void addUser(String userName);
}

// 核心业务实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String userName) {
        System.out.println("添加用户：" + userName);
    }
}

// 动态代理处理器
public class UserServiceProxyHandler implements InvocationHandler {
    private Object target;

    public UserServiceProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("添加用户前的处理");
        Object result = method.invoke(target, args);
        System.out.println("添加用户后的处理");
        return result;
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        InvocationHandler handler = new UserServiceProxyHandler(userService);
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler);
        proxy.addUser("Tom");
    }
}

在上述代码中，UserServiceImpl是核心业务类，UserServiceProxyHandler是动态代理处理器。UserServiceProxyHandler实现了InvocationHandler接口，它在invoke方法中执行了前置处理、核心业务方法调用和后置处理。

CGLIB动态代理

CGLIB动态代理是基于继承实现的动态代理方式。它通过在运行时创建目标类的子类（代理类）来实现AOP。

// 核心业务类
public class UserService {
    public void addUser(String userName) {
        System.out.println("添加用户：" + userName);
    }
}

// 方法拦截器
public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("添加用户前的处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("添加用户后的处理");
        return result;
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());
        UserService proxy = (UserService) enhancer.create();
        proxy.addUser("Tom");
    }
}

在