Java代码解释静态代理和动态代理的区别

静态代理

在静态代理中，代理类是固定的，在编译时就已经确定了。

目标对象接口（TargetInterface）

public interface TargetInterface {
   
    void request();
}

目标对象实现类（TargetClass）

public class TargetClass implements TargetInterface {
   
    @Override
    public void request() {
   
        System.out.println("目标操作");
    }
}

代理对象接口（ProxyInterface）与代理对象实现类（ProxyClass）

public interface ProxyInterface extends TargetInterface {
   
    // 代理对象包含对目标对象的引用
    private TargetInterface target;

    public ProxyInterface(TargetInterface target) {
   
        this.target = target;
    }

    @Override
    public void request() {
   
        System.out.println("前置操作");
        target.request();
        System.out.println("后置操作");
    }
}

测试类（Test）

public class Test {
   
    public static void main(String[] args) {
   
        // 创建目标对象实例
        TargetInterface target = new TargetClass();
        // 创建代理对象实例
        ProxyInterface proxy = new ProxyClass(target);
        // 通过代理对象执行请求操作
        proxy.request();
    }
}

动态代理

动态代理使用Java的反射机制来创建代理类，可以在运行时生成。

目标对象接口（TargetInterface）

public interface TargetInterface {
   
    void request();
}

实现目标接口的目标对象实现类（TargetClass）

public class TargetClass implements TargetInterface {
   
    @Override
    public void request() {
   
        System.out.println("目标操作");
    }
}

使用动态代理创建代理对象

使用Java的Proxy类来创建动态代理：

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

public class DynamicProxyTest {
   
    public static void main(String[] args) {
   
        // 创建目标对象实例
        TargetInterface target = new TargetClass();

        // 定义InvocationHandler实现类
        InvocationHandler handler = new InvocationHandler() {
   
            @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;
            }
        };

        // 使用Proxy类创建代理对象
        TargetInterface proxyInstance = (TargetInterface) Proxy.newProxyInstance(
                TargetClass.class.getClassLoader(),
                new Class[]{
   TargetInterface.class},
                handler
        );

        // 通过代理对象执行请求操作
        proxyInstance.request();
    }
}

总结

• 静态代理：在编译时就已经确定了代理类，较为固定。适用于功能简单的场景。
• 动态代理：利用Java的反射机制可以在运行时生成代理类，更加灵活和通用。

通过上述代码示例可以看到，静态代理需要手动创建代理对象并定义好方法；而动态代理则不需要提前知道接口的具体实现细节，只需编写InvocationHandler逻辑即可。