代理模式

1.静态代理模式

代理模式优点：可以让真实角色更纯粹完成自己的工作（不影响原有代码结构）。

缺点：每个客户都会生成一个代理角色对象

//租房
public interface Rent {
    void rent();
}
//真实对象
//可以更纯粹地完成自己的功能
public class RealUser implements Rent {
    @Override
    public void rent(){
        System.out.println("房东要租房！");
    }
}
//代理角色
public class Proxy implements Rent {
    private RealUser realUser;

    public Proxy(RealUser realUser) {
        this.realUser = realUser;
    }
    @Override
    public void rent() {
        seeHouse();
        realUser.rent();
        chargeMoney();
    }
    //看房
    public void seeHouse(){
        System.out.println("看房!");
    }
    //收中介费
    public void chargeMoney(){
        System.out.println("收中介费！");
    }
}
//客户
public class Client {
    public static void main(String[] args) {

        RealUser realUser = new RealUser();

        Proxy proxy = new Proxy(realUser);
        proxy.rent();
    }
}

动态代理

​ 需要用到的两个类：InvocationHandle（调用处理）和Proxy（代理）

动态代理优点：所有代理角色用同一个代理对象，通过反射机制实现动态代理

接口：

public interface UserService {
    void add();
    void delete();
    void query();
    void update();
}

真实对象

public class UserSericeImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }
}

动态代理角色

//动态代理：Proxy 代理（生成代理类） InvocationHandler 调用处理程序（处理代理实例）
//用这个类自动生成代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//首先继承InvocationHandler调用处理程序接口
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;//这里使用泛型，万能工具类

    //被代理接口注入
    // 因Spring Aop，所以这里使用Set注入
    public void setTarget(Object target) {
        this.target = target;
    }
    //生成得到代理类
    public Object getProxy(){
        //第一个参数是类加载器获取类位置
        //第二个参数是被代理接口
        //第三个参数是调用处理程序的实现类
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    //调用处理程序
    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //利用反射动态设置
        log(method.getName());

        //执行方法 第一个参数是执行方法的对象，之后的参数是方法携带的参数
        Object result = method.invoke(target, args);

        return result;
    }

    //代理的格外工作
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

客户

public class Client {
    public static void main(String[] args) {
        //创建真实对象
        UserSericeImpl userSerice = new UserSericeImpl();

        //代理角色不存在，调用自动生成代理类的工具类
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        //设置要代理的接口
        pih.setTarget(userSerice);

        //获取代理类
        UserService proxy = (UserService) pih.getProxy();

        //测试代理类
        proxy.query();
    }
}