一、基本概念
代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。通俗的来讲代理模式就是中介。
想象一下我们生活中购买火车票的情节,我们可以通过飞猪购买,也可以到窗口购买,飞猪就相当于代理模式,秒懂吧?
二、代理模式的结构
代理是英文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接口绑定原理(代理设计模式)。