带你重新认识Java动态代理

什么是动态代理？

代理模式是一种设计模式，它允许我们创建一个对象，该对象充当其他对象的代表或占位符，以便控制对这些对象的访问。

在Java中，我们可以使用静态代理和动态代理。其中，静态代理需要自行编写代理类，因此显得比较复杂。而动态代理则可以通过Java API来实现，大大减少了编程的工作量。

动态代理是Java中的一项高级编程技术，它允许我们在运行时动态生成代码，从而实现代理对象的创建和管理。在动态代理模式中，我们不需要显式地编写代理类，而是依赖于Java反射机制在运行时生成代理对象并自动处理代理方法。

动态代理的优点

• 类的职责分离：代理类作为原有类的代理，可以将一些原有类中的方法抽象出来，保留真正关心的核心业务逻辑，使得代理类具有更高的聚合性和可维护性。
• 代码复用：一个代理类可以代理多个委托类，而静态代理则需要每个委托类对应一个代理类，代码冗余度更高。
• 高可扩展性：动态代理在实现时使用反射机制，在运行时动态地创建了代理类的对象，因此可以在代理类的实现上进行更多的扩展，实现更复杂的业务逻辑。

动态代理的缺点

• 性能较差：由于动态代理的实现机制是基于反射实现的，因此在运行时会有额外的开销，而静态代理则可以直接调用委托对象的方法，效率更高。
• 编程复杂度高：相较于静态代理，动态代理实现的过程较为复杂，需要涉及到反射机制、方法调用等多个方面。

举例说明

下面我们通过两个示例来详细说明动态代理的实现过程。

示例1

首先，我们需要定义一个接口UserService，并在其中定义一个getUser方法。

public interface UserService {
    User getUser(String name);
}

然后，我们定义一个UserServiceImpl类来实现接口中的方法。

public class UserServiceImpl implements UserService {
    @Override
    public User getUser(String name) {
        return new User(name);
    }
}

其中，User类是一个简单的JavaBean类，用来存储用户信息。

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

接着，我们定义一个UserInvocationHandler类，用来处理代理对象的方法调用。

public class UserInvocationHandler implements InvocationHandler {
    private UserService userService;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before invoke method: " + method.getName());
        Object result = method.invoke(userService, args);
        System.out.println("after invoke method: " + method.getName());
        return result;
    }
}

最后，我们在main方法中创建一个代理对象，并调用其getUser方法。在代理对象调用getUser方法之前和之后，都会输出一些调试信息。

public static void main(String[] args) {
    UserService userService = new UserServiceImpl();
    UserInvocationHandler invocationHandler = new UserInvocationHandler(userService);
    UserService proxy = (UserService) Proxy.newProxyInstance(
            UserService.class.getClassLoader(),
            new Class[]{UserService.class},
            invocationHandler);
    User user = proxy.getUser("Tom");
    System.out.println("get user: " + user.getName());
}

示例2

接下来，我们用另外一个示例来说明动态代理的实现过程。

首先，我们需要定义一个接口Calculator，并在其中定义两个方法add和subtract。

public interface Calculator {
    int add(int x, int y);

    int subtract(int x, int y);
}

然后，我们定义一个CalculatorImpl类来实现接口中的方法。

public class CalculatorImpl implements Calculator {
    @Override
    public int add(int x, int y) {
        System.out.println("add: " + x + " + " + y);
        return x + y;
    }

    @Override
    public int subtract(int x, int y) {
        System.out.println("subtract: " + x + " - " + y);
        return x - y;
    }
}

接着，我们定义一个CalculatorInvocationHandler类，用来处理代理对象的方法调用。

public class CalculatorInvocationHandler implements InvocationHandler {
    private Calculator calculator;

    public CalculatorInvocationHandler(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before invoke method: " + method.getName());
        Object result = method.invoke(calculator, args);
        System.out.println("after invoke method: " + method.getName());
        return result;
    }
}

最后，我们在main方法中创建一个代理对象，并调用其add和subtract方法。在代理对象调用add和subtract方法之前和之后，都会输出一些调试信息。

public static void main(String[] args) {
    Calculator calculator = new CalculatorImpl();
    CalculatorInvocationHandler invocationHandler = new CalculatorInvocationHandler(calculator);
    Calculator proxy = (Calculator) Proxy.newProxyInstance(
            Calculator.class.getClassLoader(),
            new Class[]{Calculator.class},
            invocationHandler);
    int result1 = proxy.add(2, 3);
    System.out.println("result1: " + result1);
    int result2 = proxy.subtract(5, 2);
    System.out.println("result2: " + result2);
}

注意，在示例中，我们使用了Java反射机制来调用代理对象的方法。由于反射机制会带来额外的性能开销，因此在实际应用中需要慎重选择。