【源码分析设计模式 8】mybatis中的代理模式

一、基本概念

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是中介。

想象一下我们生活中购买火车票的情节，我们可以通过飞猪购买，也可以到窗口购买，飞猪就相当于代理模式，秒懂吧？

二、代理模式的结构

代理是英文proxy翻译过来的，我们生活中最常见的代理，代购，不需解释，都懂。

上图就是代理模式的UML类图。

1、用户只关心接口功能，而不在乎是谁提供了功能，上图中接口subject；

2、接口真正实现者是RealSubject，但是它不与用户直接接触，而是通过代理；

3、代理就是上图中的 Proxy，由于它实现了 Subject 接口，所以它能够直接与用户接触；

4、用户调用 Proxy 的时候，Proxy 内部调用了 RealSubject。所以，Proxy 是中介者，它可以增强 RealSubject 操作。

三、代理模式的优缺点

1、优点

（1）被代理类可以更加专注于主要功能的实现，在一定程度上降低了系统的耦合度。

还是卖火车票的例子，当火车站的火车票交给代理商去做的时候，他们就可以更加专注于完成其它业务，买票的效率也上去了，还可以提前订票，退票，好处简直太多太多。

（2）代理类可以提供额外的功能。

代理商代理了售卖火车票的事情后，顾客可以抢票了，在火车站你怎么抢？还可以预定座位，我记得火车站买票好像不能订座。。。

（3）代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用。

2、缺点

（1）由于客户端和对象之间增加了代理对象，因此有些类型的代理模式可能会造成请求处理速度变慢；

（2）实现代理模式需要额外的工作，有些代理模式的实现非常复杂；

四、代理模式的使用场景

1、虚代理

根据需要创建开销很大的对象时，只有用到才创建；

2、保护代理

控制对原始对象的访问，比如过滤器；

3、智能指引

在访问对象时附加一些操作，比如对象没有引用时释放资源；

4、远程代理

为一个对象在不同的地址空间提供局部代理；

五、静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者继承相同的父类。

我们经常去看电影，在电影的开始和结束阶段都会播放广告，这个可以给电影院带来经济效益，不同的电影可能对应不同的广告，但是同一个影片的广告基本上都是固定的，这就是静态代理，固定的，额外的；

1、接口IMovie

package designMode.advance.proxy;

public interface IMovie {
    void play();
}

2、实现类Movie  

package designMode.advance.proxy;

public class Movie implements IMovie {
    @Override
    public void play() {
        System.out.println("您正在观看电影《速度与激情8》");
    }
}

3、代理类MovieProxy   

package designMode.advance.proxy;

public class MovieProxy implements IMovie {
    Movie movie;

    public MovieProxy(Movie movie) {
        this.movie = movie;
    }

    @Override
    public void play() {
        advertising(true);
        movie.play();
        advertising(false);
    }

    private void advertising(boolean isBoforMovie){
        if(isBoforMovie){
            System.out.println("影片马上开始,素小暖入驻CSDN啦,快来关注我啊");
        }else{
            System.out.println("影片正片已经结束,马上彩蛋环节,不要离开哦,素小暖入驻CSDN啦,快来关注我啊");
        }
    }

    public static void main(String[] args) {
        Movie movie = new Movie();
        IMovie movieProxy = new MovieProxy(movie);
        movieProxy.play();
    }
}

4、控制台输出 

六、动态代理

1、动态代理特点

• 代理对象不需要实现接口，但是目标对象要实现接口；
• 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象；
• 动态代理也叫JDK代理或接口代理；

2、使用JDK实现动态代理

jdk实现动态代理必须有实现接口InvocationHandler的处理类，用于执行被代理类的方法。

（1）接口IMovie

package designMode.advance.proxy.dynamic;

public interface IMovie {
    void play(String movieName);
    void advertising(Boolean isBoforMovie,String txt);
}

（2）实现类Movie

package designMode.advance.proxy.dynamic;

public class Movie implements IMovie {

    @Override
    public void play(String movieName) {
        System.out.println("您正在观看电影《"+movieName+"》");
    }

    @Override
    public void advertising(Boolean isBoforMovie, String txt) {
        if(isBoforMovie){
            System.out.println("影片马上开始,"+txt);
        }else{
            System.out.println("影片正片已经结束,马上彩蛋环节,不要离开哦,"+txt);
        }
    }
}

（3）代理类MovieProxy

package designMode.advance.proxy.dynamic;

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

public class MovieProxy {
    private Object target;

    public MovieProxy(Object target) {
        this.target = target;
    }

    /*
    *
    * public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
    * 1、ClassLoader loader：指定当前目标对象使用的类加载器，获取加载器的方法；
    * 2、Class<?>[] interfaces：目标对象实现的接口类型，使用泛型方式确认类型；
    * 3、InvocationHandler h：事情处理，执行目标对象的方法时，会触发事情处理器方法，会吧当前
    *
    * */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("JDK代理开始~~");
                        //反射机制调用目标对象的方法
                        Object ret = method.invoke(target,args);
                        System.out.println("JDK代理结束~~");
                        return ret;
                    }
                });
    }
}

（4）测试类

package designMode.advance.proxy.dynamic;

public class Client {
    public static void main(String[] args) {
        IMovie target = new Movie();
        IMovie proxyInstance = (IMovie) new MovieProxy(target).getProxyInstance();
        System.out.println("proxyInstance="+proxyInstance.getClass());
        proxyInstance.advertising(true,"素小暖入驻CSDN啦,快来关注我啊");
        proxyInstance.play(" 速度与激情8 ");
        proxyInstance.advertising(false,"素小暖入驻CSDN啦,快来关注我啊");
    }
}

（5）控制台输出

3、使用JDK实现动态代理源码分析

（1）代理对象会在内部缓存，如果没有缓存则会由ProxyClassFactory生成。

首先会做接口校验，比如是否可以从提供的classLoader获取接口

（2） invoke方法的具体实现类，DynamicProxy

 （3）DynamicProxy类，调用invoke方法，生成代理对象，实现动态代理，并存入缓存

 七、cglib代理

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

1、引入jar包

2、普通类Movie

package designMode.advance.proxy.cglib;

public class Movie {
    public void play(String movieName) {
        System.out.println("我是cglib代理,不需要实现接口,您正在观看电影《"+movieName+"》");
    }

    public void advertising(Boolean isBoforMovie, String txt) {
        if(isBoforMovie){
            System.out.println("影片马上开始,"+txt);
        }else{
            System.out.println("影片正片已经结束,马上彩蛋环节,不要离开哦,"+txt);
        }
    }
}

3、代理类MovieProxy

package designMode.advance.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MovieProxy implements MethodInterceptor {
    //维护一个目标对象
    private Object target;

    //构造器，传入一个被代理的对象
    public MovieProxy(Object target) {
        this.target = target;
    }

    //返回一个代理对象:  是 target 对象的代理对象
    public Object getProxyInstance() {
        //1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类
        enhancer.setSuperclass(target.getClass());
        //3. 设置回调函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理开始~~");
        Object returnVal = method.invoke(target,objects);
        System.out.println("Cglib代理结束~~");
        return returnVal;
    }
}

4、测试类

package designMode.advance.proxy.cglib;

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        Movie target = new Movie();
        //获取到代理对象，并且将目标对象传递给代理对象
        Movie proxyInstance = (Movie)new MovieProxy(target).getProxyInstance();

        //执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
        proxyInstance.advertising(true,"素小暖入驻CSDN啦,快来关注我啊");
        proxyInstance.play(" 速度与激情8 ");
        proxyInstance.advertising(false,"素小暖入驻CSDN啦,快来关注我啊");
    }
}

5、控制台输出

八、几种常见的代理模式介绍

1、防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

2、缓存代理

当请求图片文件等资源时，先到缓存中去，如果没有再到数据库中取，然后缓存。

3、远程代理

远程对象的本地代表，通过它可以把远程对象当做本地对象来调用。

4、同步代理

主要在多线程编程中使用，完成多线程间的同步工作。

九、mybatis中的代理模式

下面我们进入configuration.addMapper(mapperInterface);这个方法看看源码如何实现

public <T> void addMapper(Class<T> type) {
    //点进入看具体实现源码
    mapperRegistry.addMapper(type);
}

1、首先看看mapperRegistry是什么东西，点进去看看

protected MapperRegistry mapperRegistry = new MapperRegistry(this);

2、原来是MapperRegistry 类，再点进去看看MapperRegistry 类里面怎么写的

public class MapperRegistry {
    private final Configuration config;
    //定义了一个map接口
    private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
}

//Mybatis扫包方式有两种一种是 写package、和resource 
public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        //重点来了，看看knownMappers是什么，就是一个map集合
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

通过上面的源码分析我们可以知道，使用map集合来装接口：再用configuration来接受配置文件所有信息

configuration.addMapper(mapperInterface);

configuration完成后。回到build(..)

进入build(..)方法，来看源码

 public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
 }

可以知道，最后通过sqlSession拿到Configuration对象

最后我们看看源码是如何获取mapper,入口代码如下

UserMapper mapper = sqlSession.getMapper(UserMapper.class);

点进getMapper(..)方法看源码如何实现的（ctrl+alt+B）选择DefaultSqlSession

public <T> T getMapper(Class<T> type) {
    //点这里进入具体实现源码
    return configuration.<T>getMapper(type, this);
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
}

上面源码分析了mapRegistry对象里面封装了一个map集合，用来存放mappers接口，我们点进去getMapper(..)看源码如何实现的

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //从map集合中获取接口
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      //使用工厂初始化，进入源码
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
 }

点进newInstance(..)看源码

public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    //点进去看看
    return newInstance(mapperProxy);
}

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

通过上述源码分析，我们知道了Mapper接口绑定原理（代理设计模式）。