什么是aop
aop(aspect-orientedprogramming,面向方面编程),可以说是oop(object-oriented programing,面向对象编程)的补充和完善。oop引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候,oop则显得无能为力。也就是说,oop允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在oop设计中,它导致了大量代码的重复,而不利于各个模块的重用。
简介
前段时间写的java设计模式--代理模式,最近在看spring aop的时候,觉得于代理模式应该有密切的联系,于是决定了解下spring aop的实现原理。
说起aop就不得不说下oop了,oop中引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。但是,如果我们需要为部分对象引入公共部分的时候,oop就会引入大量重复的代码。例如:日志功能。
aop技术利用一种称为“横切”的技术,解剖封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,这样就能减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。aop把软件系统分为两个部分:核心关注点和横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。
实现原理
前面在学习代理模式的时候,了解到代理模式分为动态代理和静态代理。现在我们就以代理模式为基础先实现我们自己的aop框架,再来研究spring的aop的实现原理。
先以静态代理实现,静态代理关键是在代理对象和目标对象实现共同的接口,并且代理对象持有目标对象的引用。
公共接口代码:
public interface ihello { /** * 业务方法 * @param str */ void sayhello(string str); } 目标类代码: public class hello implements ihello{ @override public void sayhello(string str) { system.out.println("hello "+str); } }
代理类代码,我们给它添加日志记录功能,在方法开始前后执行特定的方法,是不是和aop特别像呢?
public class proxyhello implements ihello{ private ihello hello; public proxyhello(ihello hello) { super(); this.hello = hello; } @override public void sayhello(string str) { logger.start();//添加特定的方法 hello.sayhello(str); logger.end(); } }
日志类代码:
public class logger { public static void start(){ system.out.println(new date()+ " say hello start..."); } public static void end(){ system.out.println(new date()+ " say hello end"); } }
测试代码:
public class test { public static void main(string[] args) { ihello hello = new proxyhello(new hello());//如果我们需要日志功能,则使用代理类 //ihello hello = new hello();//如果我们不需要日志功能则使用目标类 hello.sayhello("明天"); } }
这样我们就实现了一个最简单的aop,但是这样会存在一个问题:如果我们像hello这样的类很多,那么,我们是不是要去写很多个helloproxy这样的类呢。其实也是一种很麻烦的事。在jdk1.3以后,jdk跟我们提供了一个api java.lang.reflect.invocationhandler的类, 这个类可以让我们在jvm调用某个类的方法时动态的为些方法做些什么事。下面我们就来实现动态代理的实现。
动态代理实现主要是实现invocationhandler,并且将目标对象注入到代理对象中,利用反射机制来执行目标对象的方法。
接口实现与静态代理相同,代理类代码:
public class dynaproxyhello implements invocationhandler{ private object target;//目标对象 /** * 通过反射来实例化目标对象 * @param object * @return */ public object bind(object object){ this.target = object; return proxy.newproxyinstance(this.target.getclass().getclassloader(), this.target.getclass().getinterfaces(), this); } @override public object invoke(object proxy, method method, object[] args) throws throwable { object result = null; logger.start();//添加额外的方法 //通过反射机制来运行目标对象的方法 result = method.invoke(this.target, args); logger.end(); return result; } }
测试类代码:
public class dynatest { public static void main(string[] args) { ihello hello = (ihello) new dynaproxyhello().bind(new hello());//如果我们需要日志功能,则使用代理类 //ihello hello = new hello();//如果我们不需要日志功能则使用目标类 hello.sayhello("明天"); } }
看完上面的代码可能和spring aop相比有一个问题,日志类只能在方法前后打印,但是aop应该是可以在满足条件就可以执行,所有是否可以将dynapoxyhello对象和日志操作对象(logger)解耦呢?
看下面代码实现,将将dynapoxyhello对象和日志操作对象(logger)解耦:
我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码),那么,我们可以抽象出一个接口,这个接口里就只有两个方法:一个是在被代理对象要执行方法之前执行的方法,我们取名为start,第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end。
logger的接口:
public interface ilogger { void start(method method); void end(method method); }
logger的接口实现:
public class dlogger implements ilogger{ @override public void start(method method) { system.out.println(new date()+ method.getname() + " say hello start..."); } @override public void end(method method) { system.out.println(new date()+ method.getname() + " say hello end"); } }
动态代理类:
public class dynaproxyhello implements invocationhandler{ //调用对象 private object proxy; //目标对象 private object target; public object bind(object target,object proxy){ this.target=target; this.proxy=proxy; return proxy.newproxyinstance(this.target.getclass().getclassloader(), this.target.getclass().getinterfaces(), this); } @override public object invoke(object proxy, method method, object[] args) throws throwable { object result = null; //反射得到操作者的实例 class clazz = this.proxy.getclass(); //反射得到操作者的start方法 method start = clazz.getdeclaredmethod("start", new class[]{method.class}); //反射执行start方法 start.invoke(this.proxy, new object[]{this.proxy.getclass()}); //执行要处理对象的原本方法 method.invoke(this.target, args); //反射得到操作者的end方法 method end = clazz.getdeclaredmethod("end", new class[]{method.class}); //反射执行end方法 end.invoke(this.proxy, new object[]{method}); return result; } }
测试代码:
public class dynatest { public static void main(string[] args) { ihello hello = (ihello) new dynaproxyhello().bind(new hello(),new dlogger());//如果我们需要日志功能,则使用代理类 //ihello hello = new hello();//如果我们不需要日志功能则使用目标类 hello.sayhello("明天"); } }
通过上面例子,可以发现通过动态代理和发射技术,已经基本实现了aop的功能,如果我们只需要在方法执行前打印日志,则可以不实现end()方法,这样就可以控制打印的时机了。如果我们想让指定的方法打印日志,我们只需要在invoke()方法中加一个对method名字的判断,method的名字可以写在xml文件中,这样我们就可以实现以配置文件进行解耦了,这样我们就实现了一个简单的spring aop框架。
以上内容是小编给大家介绍的spring 的aop实现原理 ,希望对大家有所帮助!
如对本文有疑问, 点击进行留言回复!!
unity的错误解决办法:NullReferenceException: Object reference not set to an instance of an object;tiny proje
Hadoop 之 HDFS (HDFS 数据流的 读写 流程)
听说你一读Spring源码就懵逼?我帮你把架子搭好了,你填就行!
首席架构师推荐:金融保险领域数字化转型实践--如何优雅地修改业务中台中分层应用Maven多模块的版本号?(命令导入式)
[JVM学习之路]一、初识JVM,了解其结构、模型及生命周期
网友评论