带你深入了解 Java 代理机制

代理机制是 Java 语言的一个重要特性，它允许我们在运行时生成一个替代某个对象的对象，从而能够控制访问、修改被代理对象的属性或方法。在本文中，我们将深入讲解 Java 的代理机制，包括代理类型、创建方式、使用场景等。

代理类型

Java 语言中有两种代理类型：静态代理和动态代理。

静态代理

静态代理是指在编译时确定代理类和被代理类的关系，代理类和被代理类实现共同的接口，代理类中调用被代理类中的方法。在使用静态代理时，需要手动编写代理类，这种方式比较麻烦且容易出现重复代码。

动态代理

动态代理是指在运行时根据需要动态生成代理类，不需要手动编写代理类。Java 中动态代理主要使用了两个类：InvocationHandler和Proxy。其中，InvocationHandler是一个接口，它只有一个invoke方法，在代理对象调用方法时，会先调用invoke方法，再执行相应的方法。Proxy类是动态代理的核心类，可以通过它的静态方法newProxyInstance创建一个动态代理对象。

创建动态代理

创建动态代理的步骤主要包括以下几个步骤：

1. 实现InvocationHandler接口，重写invoke方法；
2. 创建被代理类的实例对象和InvocationHandler对象；
3. 使用Proxy类的newProxyInstance方法创建代理类；
4. 通过代理类调用被代理类的方法。

以下是一个示例代码：

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

interface Hello {
    void sayHello();
}

class HelloImpl implements Hello {
    @Override
    public void sayHello() {
        System.out.println("Hello World!");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method invoke!");
        Object result = method.invoke(target, args);
        System.out.println("After method invoke!");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Hello hello = new HelloImpl();
        MyInvocationHandler handler = new MyInvocationHandler(hello);
        Hello proxy = (Hello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                handler);
        proxy.sayHello();
    }
}

以上代码中，我们定义了一个Hello接口和它的实现类HelloImpl，然后实现了一个MyInvocationHandler类，并实现了其中的invoke方法，在代理类调用方法前后打印日志。最后，通过Proxy类的newProxyInstance方法创建代理类，并调用其中的sayHello方法。

使用代理机制的场景

代理机制可以用于以下场景：

• AOP（面向切面编程）：通过代理对方法进行增强，如日志记录、权限控制等；
• 数据库连接池：通过代理实现数据库连接的多线程复用；
• 远程调用：通过代理实现远程调用，如 RMI（远程方法调用）等。

示例说明

示例 1：AOP

在日常开发中，我们经常需要在方法调用前后打印日志，可以通过代理实现这一功能。

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

interface UserService {
    void login();
}

class UserServiceImpl implements UserService {
    @Override
    public void login() {
        System.out.println("User Login");
    }
}

class LogHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method invoke!");
        Object result = method.invoke(target, args);
        System.out.println("After method invoke!");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        LogHandler handler = new LogHandler(userService);
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler);
        proxy.login();
    }
}

以上代码中，我们通过创建一个LogHandler类实现在调用login方法前后打印日志的功能。最后通过代理类proxy调用login方法。

示例 2：数据库连接池

在多线程环境下，为了避免频繁创建和销毁数据库连接，可以通过代理实现数据库连接的多线程复用。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

interface DataSource {
    Connection getConnection();
}

class DataSourceImpl implements DataSource {
    private String url;
    private String username;
    private String password;

    public DataSourceImpl(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    @Override
    public Connection getConnection() {
        Connection conn = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
}

class ConnectionHandler implements InvocationHandler {
    private DataSource dataSource;

    public ConnectionHandler(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("getConnection".equals(method.getName())) {
            Connection conn = (Connection) method.invoke(dataSource, args);
            return new ConnectionProxy(conn);
        }
        return null;
    }
}

class ConnectionProxy implements InvocationHandler {
    private Connection conn;

    public ConnectionProxy(Connection conn) {
        this.conn = conn;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("close".equals(method.getName())) {
            System.out.println("Connection return to pool!");
            return null;
        }
        return method.invoke(conn, args);
    }
}

public class Main {
    public static void main(String[] args) {
        DataSource dataSource = new DataSourceImpl("jdbc:mysql://localhost:3306/test", "root", "password");
        ConnectionHandler handler = new ConnectionHandler(dataSource);
        DataSource proxy = (DataSource) Proxy.newProxyInstance(
                dataSource.getClass().getClassLoader(),
                dataSource.getClass().getInterfaces(),
                handler);
        Connection conn = proxy.getConnection();
        conn.prepareStatement("SELECT * FROM user WHERE id = 1");
        conn.close();
    }
}

以上代码中，我们通过创建一个ConnectionProxy类实现对获取数据库连接的代理，通过代理类ConnectionProxy实现对连接的控制。最后通过代理类proxy获取数据库连接并进行操作。

结论

通过本文，我们了解了 Java 的代理机制及其应用场景，学会了使用动态代理实现对方法的增强和数据库连接的控制。在实际开发中，代理机制是一个非常有用的工具，能够提高代码的可维护性和可扩展性。