JAVA中的代理

简介

代理模式（Proxy Pattern）是23种经典设计模式之一，属于结构型设计模式。它通过创建代理对象来控制对原始对象的访问，常用于实现访问控制、延迟初始化、日志记录等场景。

静态代理实现

实现原理

静态代理在编译期明确指定代理类，需要开发者手动创建代理类。

代码示例

package DailyTest._250219;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        DemoProxy();


    }
    public static void DemoProxy(){
        Proxy proxy = new Proxy();
        proxy.clothes("xxxL");
    }
}
interface ByClothes {

    public abstract void clothes(String size);

}
class ClothesFactory implements ByClothes{

    public void clothes(String size){
        System.out.println("已经给您定制好了一件大小为"+size+"的衣服");
    }

    public void 机器处理(){

    }

    public void 原材料(){}
}
class Proxy implements ByClothes {

    private ClothesFactory clothesFactory = new ClothesFactory();


    @Override
    public void clothes(String size) {
        FrontService();
        clothesFactory.clothes(size);
        endService();
    }


    //前置服务
    public void FrontService() {
        System.out.println("根据您的需求进行市场调研");
    }

    //前置服务
    public void endService() {
        System.out.println("为您提供一条龙的包办服务");
    }


}

输出

根据您的需求进行市场调研
已经给您定制好了一件大小为xxxL的衣服
为您提供一条龙的包办服务

优缺点分析

-- 优点：直观易懂，编译期检查
-- 缺点：接口修改需同步修改代理类，多个代理类会导致类膨胀

动态代理实现

JDK动态代理

核心API

-- java.lang.reflect.Proxy：生成代理类的工厂类
-- java.lang.reflect.InvocationHandler：方法调用处理器

代码实现

package TempTest.Proxy;

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

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

public class Main {
    public static void main(String[] args) {
        ClothesFactory clothesFactory = new ClothesFactory();
        ByClothes clothes = (ByClothes) new DyProxy(clothesFactory).getProxyInterFace();

        clothes.clothes("XXXL");
    }
}

class DyProxy implements InvocationHandler {

    //被代理的对象
    //代理对象如何得知自己代理的是哪个目标类
    //这里这样写其实是让用户告诉我，我要代理谁
    private Object o ;
    public DyProxy(Object o){
        this.o = o;
    }


    //2.获取目标类的接口，要知道自己代理的核心方法是啥？
    public Object getProxyInterFace(){
        return Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(),this);
    }



    //知道了接口----》变相得知了自己要代理的核心方法:
    //invoke方法是利用反射的方式获取到了要代理的核心方法
    //1.Object：jdk创建的代理类，无需赋值
    //2.Method：目标类当中的方法，jdk提供，无需赋值
    //3.Object[]：目标类当中的方法的参数，jdk提供，无需赋值
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        FrontService();
        method.invoke(o,args);
        endService();
        return null;
    }

    //前置服务
    public void FrontService() {
        System.out.println("根据您的需求进行市场调研");
    }

    //前置服务
    public void endService() {
        System.out.println("为您提供一条龙的包办服务");
    }

}
interface ByClothes {

    public abstract void clothes(String size);

}
class ClothesFactory implements ByClothes {

    public void clothes(String size){
        System.out.println("已经给您定制好了一件大小为"+size+"的衣服");
    }

    public void 机器处理(){

    }

    public void 原材料(){}
}

输出

根据您的需求进行市场调研
已经给您定制好了一件大小为XXXL的衣服
为您提供一条龙的包办服务

代理是开发中重要的设计模式，理解其实现原理对于：
- 掌握框架底层机制（如Spring AOP）
- 实现优雅的代码增强
- 提高系统可维护性