spring-代理模式

代理模式

1静态代理

角色分析：

​ 1.抽象角色：一般会使用接口或者抽象类

​ 2.真是角色：被代理角色

​ 3.代理角色：代理真是角色，代理真实角色后会增加一些附属操作

​ 4.客户：访问被代理的对像

代码步骤

1.接口

public interface Rent {
    void rent();
}

2.真实角色

public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东出租了房子");
    }
}

3.代理角色

public class Proxy implements Rent{

    private Host host;

    public Host getHost() {
        return host;
    }

    public void setHost(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHost();
        hetong();
        host.rent();
        payFee();
    }

    private void seeHost(){
        System.out.println("中介带着看房");
    }

    private void hetong(){
        System.out.println("中介签合同");
    }

    private void payFee(){
        System.out.println("给中介费和房租");
    }
}

4.客户端访问

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮忙租房子，同时会有一些附属操作
        Proxy proxy = new Proxy();
        proxy.setHost(host);
        //不需要面对中介，直接出租房子
        proxy.rent();
    }
}

代理模式的好处：

​ 。真实角色的操作更加存粹，不需要处理公共业务

​ 。公共业务交给代理处理，实现业务分工

​ 。公共业务交给代理处理，方便管理

代理模式确定

​ 。一个真实角色就一个代理角色，代码量翻倍

2代理模式实现aop的思想

​ 在原有代码完全实现的情况下，如果需要在原有代码中增加日志功能，这个时候，防止对原有代码产生影响，可以用代理模式，代理类中增加日志功能，原有代码不变。需要日志的调用只要调用代理类就可以。

3动态代理

​ 。动态代理类和静态代理类同样使用

​ 。动态代理类是动态生成的，不是我们直接手写的

​ 。动态代理类分为两大类，基于接口的动态代理，基于类的动态代理

​ . 基于接口------JDK的动态代理

​ . 基于类的-----cglib

​ . java字节码实现----javasist

需要了解两个类 Proxy代理，InvocationHandler调用处理程序

动态代理的好处：

​ 。真实角色的操作更加存粹，不需要处理公共业务

​ 。公共业务交给代理处理，实现业务分工

​ 。公共业务交给代理处理，方便管理

​ 。一个动态代理类代理的一个接口，一般对应一类业务

​ 。一个动态代理类可以代理多个类，只要实现了同一个接口

接口：
    public interface HostService {
    public void addHouse();
    public void deleteHouse();
    public void selectHouse();
    public void updateHouse();
}
实现接口的真实类：
    public class Host implements HostService{
    @Override
    public void addHouse() {
        System.out.println("买了套房");
    }
    @Override
    public void deleteHouse() {
        System.out.println("卖了套房");
    }
    @Override
    public void selectHouse() {
        System.out.println("巡视了房");
    }
    @Override
    public void updateHouse() {
        System.out.println("装修了套房");
    }
}
实现InvocationHandler接口的处理器：
    
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {

    //接口
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    //生成代理类的方法
    public  Object getProxy(){
      return  Proxy.newProxyInstance(this.getClass().getClassLoader(),object.getClass().getInterfaces(),  this);
    }

   //反射调用方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        before();
        Object invoke =  method.invoke(object,args);
        after();
        return invoke;
    }
    private void before(){
        System.out.println("方法之前执行，");
    }
    private void after(){
        System.out.println("方法之后执行，后台通知之类");
    }
    
    客户端调用生成代理类并调用犯法：
        public class Client {
    public static void main(String[] args) {
        //真实角色
        HostService host = new Host();//对象可以是实现接口的不同对象
        //  代理角色不存在，一个生成程序
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setObject(host);
        //得到代理类
        HostService hostService = (HostService) proxyInvocationHandler.getProxy();
        //代理类执行方法
        hostService.addHouse();
        hostService.deleteHouse();
    }