java动态代理详解

记录学习的每一点过程

本文主要介绍的是动态代理，所以静态代理在这里就简单介绍一下

1、静态代理

静态代理的角色介绍

抽象角色：一般是接口或者是抽象类

/**
 * 抽象角色:以租房为例，这是一个租房子的接口
 */
public interface Rent {
    void rent();
}

真实角色：被代理的角色

/**
 * 文件名：Host
 * 作 者：zyz
 * 时 间：2019/6/12 9:47
 * -------------------------
 * 功能和描述：真实角色，实现抽象角色对应的接口（Rent）
 **/
public class Host implements Rent{
    public void rent(){
        System.out.println("房屋出租");
    }
}

代理角色：代理真实角色，代理真实角色之后，一般会做一些附属（增强的操作）

/**
 * 代理角色：同真实角色实现同一个接口
 */
public class Proxy implements Rent {
    private Host host;

    public Proxy() {
    }

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

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

    public void rent() {
        seeHouse();
        host.rent();
        fee();
    }


    //**************代理角色附带（增强）的一些功能**************//
    private void seeHouse(){
        System.out.println("带租客看房子");
    }
    private void fee(){
        System.out.println("收取中介费");
    }
}

测试类 

/**
 * 文件名：Client
 * 作 者：zyz
 * 时 间：2019/6/12 9:47
 * -------------------------
 * 功能和描述：
 **/

public class Client {
    public static void main(String[] args) {
        //定义一个真实角色
        Host host = new Host();
        //定义代理角色
        Proxy proxy = new Proxy(host);
        //使用代理角色的实例去实现具体操作
        proxy.rent();
    }
}

 静态代理总结

　　优点：

　　　　使真实角色处理的业务更加的纯粹，不再关注一些公共的事；

　　　　公共的业务由代理来完成，实现了业务的分工；

　　　　公共业务的扩展变得更加集中和方便

　　缺点：

　　　　类变多了，多了代理类，工作量变大了，且不易扩展

　　　　解决此问题的方案就是使用动态代理

2、动态代理

 还是以租房子为例，因为在学习阶段，越是简单的例子越是容易理解，博主在学习的时候看到了好几篇文章光看代码就晕头转向的了，还没学习动态代理就已经蒙了。所以我这边举得例子基本都是大家常见的，代码简单，但是能将知识点介绍的很透彻。

动态代理有两种实现方式：一种是基于jdk的动态代理，一种是基于cglib的动态代理

基于jdk的动态代理

基于jdk的动态代理的特点是必须要有接口，记住一个类Proxy（java.lang.reflect.Proxy，别导错包）和一个接口InvocationHandler，废话少说，直接上代码

　第一步：新建一个接口Rent

public interface Rent {
    void rent();
}

第二步：新建一个类(Host)，实现该接口（Rent）

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

第三步：新建一个代理类，实现InvocationHandler接口

public class RentInvocationHandler implements InvocationHandler {

    private Object object;

    public  RentInvocationHandler(Object object) {
        this.object = object;
    }

    /**
     * @param proxy:代理类
     * @param method：代理类调用处理程序的方法对象
     * @param args：方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("使用动态代理做的一些增强的操作......");
        //第一个参数表示真实对象
        //第二个参数表示参数
        Object result = method.invoke(object, args);

        return result;
    }
}

完工就是这么easy，下面开始测试

public class Client {
    public static void main(String[] args) {
        //定义一个真实对象
        Host host = new Host();
        //创建代理类
        RentInvocationHandler pih = new RentInvocationHandler(host);
        //利用Proxy.newProxyInstance生成代理类
        //第一个参数：真实类对象的类加载器
        //第二个参数：真实类对象的所有的接口
        //第三个参数：代理类对象
        Rent p = (Rent)Proxy.newProxyInstance(host.getClass().getClassLoader(),host.getClass().getInterfaces(),pih);
        p.rent();

    }
}

输出：

再次强调一点：在调用的时候

Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

　　只要搞清楚这里面的三个参数是干嘛的就OK

基于CGLib的动态代理

　　基于CGLib的动态代理是没有接口的限制的，行了，直接撸代码（虽然有重复的代码，但是为了让读者能够看的清晰，每一步我都会写出来）

　第一步：创建一类真实类Host_CGLib　

　　<dependency>

        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
</dependency>　

public class Host_CGLib {
    public void rent(){
        System.out.println("租房子......CGLib");
    }
  }

第二步：创建一个拦截器类实现MethodInterceptor（net.sf.cglib.proxy.MethodInterceptor）接口

public class RentMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("使用CGLib方式做的增强......");
        Object result = methodProxy.invokeSuper(o, objects);
        return result;
    }
}

OK搞定，开始测试

public class CGLibTest {
    public static void main(String[] args) {
        //设置增强需要用到的类
        Enhancer enhancer = new Enhancer();
        //设置需要增强的类（这里是Host_CGLib类）
        enhancer.setSuperclass(Host_CGLib.class);
        //设置需要回调的拦截器
        enhancer.setCallback(new RentMethodInterceptor());
        //生成对应的增强类
        Host_CGLib host = (Host_CGLib)enhancer.create();
        host.rent();
    }
}

输出：

总结：对于底层和原理这边并没有介绍，至于为什么没有介绍（因为我也不会），因为初学者先知道怎么用就行，不是什么东西都是刨根问底的，现在知道是什么，再是搞为什么吧。熟悉了以后在此基础上去深挖，这才是王道。

如果您觉得我写的文章您看明白了，请动动您的小手，将文章分享给您的好友哦！