Spring(五)：静态代理和动态代理

静态代理(staticproxy)：代理一个具体的类

角色分析：

拿房东找中介出租房子来比喻。
抽象角色：出租房子。一般会使用抽象类或者接口实现
真实角色：房东。被代理的角色
代理角色：中介。代理真实角色，代理真实角色后，一般会做一些附属的操作；
客户：租房的人。使用代理角色进行一些操作。

代码实现：

接口：

//租房的接口：抽象
public interface Rent {
    //租房
    void rent();
}

真实对象:

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

代理对象：

package com.duan.staticproxy;

//房屋中介--代理
public class Proxy implements Rent {

    //房东
    private Host host;

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

    public void rent() {
        lookHouse();
        host.rent();
        fare();
    }

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

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

}

测试：

public class You {
    public static void main(String[] args){
    	Host host = new Host();
        Proxy proxy = new Proxy();
        proxy.setHost(host);
        proxy.rent();

    }
}

静态代理的好处：

• 可以使真实角色更加纯粹，不用去关注一些公共的事情；
• 公共的业务由代理来完成，实现业务的分工；
• 公共业务的要扩展的话，可以更加集中和方便；

静态代理的缺点：

• 假如我们的真实角色变得非常多，代理类也会随之增多，工作量变大，开发效率变低！如何解决呢？
  AOP:面向切面编程。不改变原来的业务，即横向编程。在不改变原来的代码下，动态的增加一些功能就是一些增强。核心是通过动态代理+反射，插入一段代码进去。
  原先是纵向编程：
  从Dao–>Service–>Servlet–>前端
  现在：横向编程：
  UserService直接插入log代码，而肯定不是通过静态代理，因为不可能写一个东西就注册一个Bean。所以动态代理。

动态代理(dynamicproxy)： 代理接口

动态代理和静态代理的角色都是一样；
静态代理模式的代理类是我们提前写好的，动态代理的类是动态生成的；
动态代理大概分两类：
1.基于接口实现：JDK
2.基于类实现：cglib
当今用的比较多的是 JAVAssist(Java字节码)来生成动态代理。
了解动态代理之前，需要掌握两个类：

• InvocationHandler：InvocationHandler是由代理实例的调用处理程序实现的接口 。
  invoke(Object proxy, 方法 method, Object[] args) 处理代理实例上的方法调用并返回结果。 给方法设值
  proxy：该方法的代理实例，就是用来生成咱们的代理对象的类。
  method：普通的方法
  args：参数
• Proxy：Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。动态生成类
  static Object：newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

代码实现：

抽象角色：

//租房的接口：抽象
public interface Rent {
    //租房
    void rent();
}

真实对象：

//这个房子要出租
public class Host implements Rent {

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

}

动态代理类生成的接口对象：

package com.duan.dynamicproxy;

import com.duan.staticproxy.Rent;

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

public class InvocationHandlerProxy 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);
    }

    //proxy:代理类
    //method ：代理类的调用处理程序的方法 的对象
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        lookHouse();
        Object result = method.invoke(rent, args);
        zhongJieFei();
        return result;
    }

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

    private void zhongJieFei(){
        System.out.println("收中介费");
    }


}

测试：

public static void main(String[] args) {

    Host host = new Host();
    InvocationHandlerProxy ihp = new InvocationHandlerProxy();
    ihp.setRent(host);

    Rent proxy = (Rent) ihp.getProxy(); //动态生成的

    proxy.rent();
}

动态代理的好处：

• 可以使真实角色更加纯粹，不用去关注一些公共的事情；
• 公共的业务由代理来完成，实现业务的分工；
• 公共业务的要扩展的话，可以更加集中和方便；
• 一个动态代理，一般代理一类的业务，一个动态代理可以代理多个类，代理接口；