代理模式

代理模式

• 代理模式是SpringAOP的底层【spring和springmvc】
• 代理模式分静态代理和动态代理

静态代理

1.案例引入

把静态代理类比成一件事（例如租房），有以下角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色
• 客户:访问代理对象的人

2.案例代码

• 抽象角色

//租房
public interface Rent {
    public void rent();
}

• 真实角色

//房东
public class Host implements Rent{
    public void rent(){
        System.out.println("房东要出租房子");
    }
}

• 代理角色：

//中介
public class Proxy {
    private Host host;

    public Proxy(){

    }

    public Proxy(Host host){
        this.host=host;
    }

    //出租（代理）
    public void rent(){
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //合同
    public void hetong(){
        System.out.println("签租赁合同");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

• 客户：

//客户
public class Client {
    public static void main(String[] args) {
        Host host=new Host();
        Proxy proxy=new Proxy(host);
        proxy.rent();
    }
}

3.小结

优点：

1. 可以使真实角色的操作更加纯粹，不用去关注公共的业务！

2. 公共也就交给代理角色，实现了业务的分工。

3. 公共业务发生扩展的时候，方便集中管理。

缺点：一个真实角色就产生一个代理角色，开发时代码过于冗杂。

动态代理

• 动态代理中的“角色”和静态代理一样

• 动态代理中的代理类是动态生成的

• 动态代理分为：基于接口的动态代理(JDK动态代理)和基于类的动态代理(cglib),以及java字节码实现（javasist）

1.案例（租房）

抽象角色类

//租房
public interface Rent {
    public void rent();
}

真实角色类

//房东
public class Host implements Rent {
    public void rent(){
        System.out.println("房东要出租房子");
    }
}

代理类

public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;//抽象角色
     
    //拿到需要代理的真实角色
    public void setRent(Rent rent){
        this.rent=rent;
    }

    //生成得到代理角色
    public Object getProxy(){
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
   }

   //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是是用反射机制
        Object result=method.invoke(rent,args);
        return null;
    }

2.动态代理的过程

1）创建一个真实角色（需要代理的对象）

Host host=new Host();//真实角色

2).创建一个进行代理的对象(代理类：是一个处理类，处理代理这件事，并不是代理角色)

 ProxyInvocationHandler pih=new ProxyInvocationHandler(); //代理角色（还不存在）

此时因为该对象没有拿到动态代理实例，所以代理角色还不存在！

3).将真实角色拿到代理对象里面

 pih.setRent(host);//设置要代理的对象

4).通过代理对象拿到代理角色

 Rent proxy=(Rent)pih.getProxy();//动态生成的代理角色

 //生成得到代理角色并返回
    public Object getProxy(){
        return  Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
   }

• this.getClass().getClassLoader():代理类的路径
• rent.getClass().getInterfaces():抽象角色类

通过ava.lang.reflect.Proxy这个类中的newProxyInstance方法拿到动态代理实例（代理角色），并返回该角色。

5).通过代理角色进行代理操作

proxy.rent();//操作

操作时默认调用代理类中的invoke（）方法：

  //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是是用反射机制
        Object result=method.invoke(rent,args);
        return null;
 }

如果代理类还添加其他的事务和日志方法，也需要写入该方法中.

3.代理操作代码

public class Client {
    public static void main(String[] args) {
        Host host=new Host();//真实角色

        //代理角色（还不存在）
        ProxyInvocationHandler pih=new ProxyInvocationHandler();

        pih.setRent(host);//设置要代理的类

        Rent proxy=(Rent)pih.getProxy();//动态生成的代理类（代理角色已存在）

        proxy.rent();//操作
    }
}

4.小结

在静态代理的优点基础上，动态代理的好处有:

一个动态代理类代理的是一个接口，一般就是对应的一类业务（只要是实现了该接口的类，都被代理了）。

所以只需要让要代理的类（真实角色类）继承该接口（抽象角色类），然后将要代理的对象放入动态代理实例中（代理角色），就可以实现动态代理了。