北风设计模式课程---深入理解［代理模式］原理与技术

一、总结

一句话总结：

不仅要通过视频学，还要看别的博客里面的介绍，搜讲解，搜作用，搜实例

设计模式都是对生活的抽象，比如用户获得装备，我可以先装备工厂先生产出来装备，然后给宗门武器库，宗门武器库发给我，如果是打怪获得的装备，可以是装备工厂把装备给的怪物装备库

 

1、问题解决：我们需要为一个业务方法在执行前后记录日志？

代理模式：为了达到解耦的目的，我们可以再新建一个类并定义一个新的业务方法，该方法既可以调用原业务方法，又可以在调用前后进行日志处理

CarProxy.classpublic void move() {System.out.println("日志开始记录....");new Car().move();System.out.println("日志记录完成...."); }

 

 

 

 

二、深入理解［代理模式］原理与技术

转自或参考：深入理解［代理模式］原理与技术
https://www.cnblogs.com/yueshutong/p/9500632.html">深入理解［代理模式］原理与技术

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。

代理模式是23种常用的面向对象软件的设计模式之一，具体又分为静态代理、动态代理。

如何理解代理模式？

思考抽象问题最好的办法就是具体化！

比如我们需要为一个业务方法在执行前后记录日志，为了达到解耦的目的，我们可以再新建一个类并定义一个新的业务方法，该方法既可以调用原业务方法，又可以在调用前后进行日志处理，例如：

CarProxy.classpublic void move() {System.out.println("日志开始记录....");new Car().move();System.out.println("日志记录完成....");}

代理模式的应用很多，比如Spring容器的延迟加载，AOP增强处理等。

一：静态代理

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。

所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

一句话，自己手写代理类就是静态代理。

基于继承的静态代理

目标对象：定义一个普通方法

public class Car {public void move() {System.out.println("1.汽车开始跑步");System.out.println("2.汽车跑到了终点");}}

代理对象：主要作用是继承目标对象，进行增强处理，并使用关键字super调用父类方法。

public class CarProxy extends Car {@Overridepublic void move() {System.out.println("日志开始记录....");super.move();System.out.println("日志记录完成....");}}

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) {Car car = new CarProxy();car.move();}

基于接口的静态代理

共同接口：定义一个普通的接口方法

public interface Moveable {void move(); }

目标对象：实现该接口方法。

public class Car implements Moveable {@Overridepublic void move() {System.out.println("汽车行驶中....");}}

代理对象：调用目标对象的方法，并在调用前后进行增强处理。

public class CarProxy implements Moveable{private Moveable move;@Overridepublic void move() {if(move==null){move = new Car();}System.out.println("开始记录日志：");move.move();System.out.println("记录日志结束！");} }

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) throws Exception {Moveable m =new CarProxy();m.move();}

静态代理的优缺点

优点：

业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理模式的共有优点。

缺点：

1）代理对象的一个接口只服务于一种类型的对象，如果要代理的类型很多，势必要为每一种类型的方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

• 比如Car类的move()方法需要记录日志，如果还有汽车，火车，自行车类的move()方法也需要记录日志，我们都要一个个的去为它们生成代理类，太麻烦了。

2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。显而易见，增加了代码维护的复杂度。

二：动态代理

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成 。

简单来说，动态代理就是交给程序去自动生成代理类。

JDK的动态代理

JDK动态代理实现步骤：

创建被代理的类以及实现的接口；

创建一个实现接口InvocationHandler的类，它必须实现invoke方法；

调用Proxy的newProxyInstance静态方法，创建一个代理类。

通过代理对象调用目标方法。

代码示例

共同接口

public interface Moveable {String move(); }

目标对象：正常实现接口方法

public class Car implements Moveable {@Overridepublic String move() {return "汽车行驶中";}}

对目标对象的增强处理：

public class LogHandler implements InvocationHandler{private Object target;public LogHandler(Object object){super();this.target = object;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//增强处理Object o = method.invoke(target,args);//增强处理return o;}}

实现InvocationHandler接口步骤：

定义含参构造方法，该参数为要代理的实例对象，目的是用于执行method.invoke()方法（也就是执行目标方法）

实现接口的invoke()方法，该方法用于对目标方法的增强处理，比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。具体参数：

proxy 动态生成的代理对象

method 目标方法的实例

args 目标方法的参数

测试方法：

public static void main(String[] args) {Moveable move = (Moveable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new LogHandler(new Car()));System.out.println("代理对象:"+move.getClass().getName());System.out.println("执行方法:"+move.move()); }

通过调用Proxy.newProxyInstance方法生成代理对象，具体参数有：

loader 目标类的类加载器

interfaces 目标类实现的接口

InvocationHandler 调用处理程序的实现对象

打印结果

代理对象:com.sun.proxy.$Proxy0 执行方法:汽车行驶中

值得一提的是，JDK动态代理针对每个代理对象都会有一个关联的调用处理程序，即实现InvocationHandler接口。当在代理对象上调用目标方法时，将对方法调用进行编码并将其分配给其实现 InvocationHandler 接口的 invoke 方法。

特点

JDK的动态代理只能代理实现了接口的类， 没有实现接口的类不能实现动态代理。

---

cglib的动态代理

引用cglib的依赖包

<dependency><groupId>cglib</groupId><artifactId>cglib-nodep</artifactId><version>2.2</version> </dependency>

为了方便思考它的原理，我把执行步骤按顺序写下

public static void main(String[] args) {Enhancer enhancer = new Enhancer();//设置父类，被代理类（这里是Car.class）enhancer.setSuperclass(Car.class);//设置回调函数enhancer.setCallback(new MethodInterceptor() {@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {//增强处理...Object o= proxy.invokeSuper(obj, args);//代理类调用父类的方法//增强处理...return o;}});//创建代理类并使用回调（用父类Car去引用）Car car = (Car) enhancer.create();//执行目标方法System.out.println(car.move());}

方法拦截器

实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。

intercept方法的具体参数有

obj 目标类的实例

method 目标方法实例（通过反射获取的目标方法实例）

args 目标方法的参数

proxy 代理类的实例

该方法的返回值就是目标方法的返回值。

特点

cglib的动态代理是针对类来实现代理。

对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。

因为是通过继承实现，final类无法使用。

三：别人手写JDK动态代理源码

从上面可以看到JDK动态代理的核心代码在于Proxy.newProxyInstance方法。

Moveable m = (Moveable)Proxy.newProxyInstance(Car.class,new InvocationHandler());

实现原理

声明一段源码，源码动态产生动态代理

源码产生java文件，对java文件进行编译

得到编译生成后的class文件

把class文件load到内存之中，产生代理类对象返回即可。

下面附源码！

生产代理对象类，核心类！难点，思路都在这里~

public class Proxy {/*** 生产代理对象* @param clazz* @param h* @return* @throws Exception*/public static Object newProxyInstance(Class clazz,InvocationHandler h) throws Exception{//代理类类名String cname = clazz.getName().substring(clazz.getName().lastIndexOf(".")+1) + "$Proxy0";//手写代理类源码StringBuilder source = getSource(clazz, h, cname);//产生代理类的java文件String filename = Thread.currentThread().getContextClassLoader().getResource("").getPath()+ clazz.getPackage().getName().replaceAll("\\.", "/") +"/"+cname+".java";System.out.println(filename);//把源码写入到文件中File file = new File(filename);FileUtil.writeStringToFile(file, source.toString());//编译//拿到编译器JavaCompiler complier = ToolProvider.getSystemJavaCompiler();//文件管理者StandardJavaFileManager fileMgr =complier.getStandardFileManager(null, null, null);//获取文件Iterable units = fileMgr.getJavaFileObjects(filename);//编译任务CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);//进行编译t.call();fileMgr.close();//load 到内存ClassLoader cl = ClassLoader.getSystemClassLoader();Class<?> c = cl.loadClass(clazz.getPackage().getName() + "."+cname);//获取构造函数ConstructorConstructor<?> ctr = c.getConstructor(h.getClass());return ctr.newInstance(h);}/*** 代理类源码* @param clazz* @param h* @param cname* @return*/private static StringBuilder getSource(Class clazz, InvocationHandler h, String cname) {//调用处理接口String handler = h.getClass().getName();//换行符号String line = "\r\n";String space = " ";//代理类源码StringBuilder source = new StringBuilder();//包声明source.append("package" + space + clazz.getPackage().getName() + ";").append(line);//获取类的名称source.append(Modifier.toString(clazz.getModifiers()) + space + "class" + space + cname + space);//继承接口source.append("implements" + space);Class[] interfaces = clazz.getInterfaces();for (int i = 0; i < interfaces.length; i++) {source.append(interfaces[i].getName());if (i != interfaces.length - 1) {source.append(",");}}source.append("{").append(line);//声明变量source.append("private " + handler + " h;").append(line);//构造方法source.append("public " + cname + "(" + handler + " h){").append(line);source.append("this.h=h;").append(line).append("}").append(line);//实现所有方法Method[] methods = clazz.getDeclaredMethods();for (Method method : methods) {//获取方法返回类型Class returnType = method.getReturnType();//获取方法上的所有注释Annotation[] annotations = method.getDeclaredAnnotations();for (Annotation annotation : annotations) {//打印注释类型source.append("@" + annotation.annotationType().getName()).append(line);}//打印方法声明source.append(Modifier.toString(method.getModifiers()) + " " + returnType.getName() + " " + method.getName() + "(");//获取方法的所有参数Parameter[] parameters = method.getParameters();//参数字符串StringBuilder args = new StringBuilder();for (int i = 0; i < parameters.length; i++) {//参数的类型，形参（全是arg123..）source.append(parameters[i].getType().getName() + " " + parameters[i].getName());args.append(parameters[i].getName());if (i != parameters.length - 1) {source.append(",");args.append(",");}}source.append("){").append(line);//方法逻辑source.append("Object obj=null; \n try {").append(line);source.append("Class[] args = new Class[]{" + args + "};").append(line);source.append(Method.class.getName()+" method = " + clazz.getName() + ".class.getMethod(\"" + method.getName() + "\",args);").append(line);source.append("obj = h.invoke(this,method,args);").append(line);source.append("} catch (Exception e) {\n" + "e.printStackTrace();\n" + "}catch (Throwable throwable) {\n" +"throwable.printStackTrace();\n" + "}").append(line);//方法结束source.append("return (obj!=null)?("+returnType.getName()+")obj:null;\n}").append(line);}//类结束source.append("}");return source;}}

单元测试

public static void main(String[] args) throws Exception {Moveable m = (Moveable) Proxy.newProxyInstance(Car.class, new TimeHandler(new Car()));String s = m.move();System.out.println(s);}

测试结果

/D:/IDEA/workSpace/myJdkProxy/target/classes/cn/zyzpp/client/Car$Proxy0.java 开始记录时间 汽车行驶中.... 耗时：481毫秒！ success

转载于:https://www.cnblogs.com/Renyi-Fan/p/11030915.html

总结

以上是生活随笔为你收集整理的北风设计模式课程---深入理解［代理模式］原理与技术的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。