AOP(面向方面编程)可以说是OOP(面向对象编程)的补充和完善。本文介绍了Spring的aop实现原理，让感兴趣的朋友一起学习。

什么是AOP

AOP(面向方面编程)可以说是OOP(面向对象编程)的补充和完善。OOP引入了封装、继承和多态的概念来建立一个对象层次结构来模拟一组公共行为。当我们需要为分散的对象引入公共行为时，OOP是无能为力的。也就是说，OOP允许你从上到下定义关系，但不适合从左到右定义关系。比如日志功能。日志通常水平分布在所有对象层次结构中，与它们所分布到的对象的核心功能无关。其他类型的代码也是如此，比如安全性、异常处理和透明持久性。这种分散在各处的无关代码叫做横切代码。在OOP设计中，导致大量的代码重复，不利于各个模块的重用。

简介

代理模式，前段时间写的一个java设计模式，最近在看Spring Aop的时候感觉应该和代理模式有密切关系，所以决定了解一下Spring Aop的实现原理。

说到AOP，就不得不说OOP，它引入封装、继承、多态等概念建立一个对象层次来模拟一组公共行为。但是，如果我们需要为某些对象引入公共部分，OOP会引入大量重复代码。比如：日志功能。

AOP技术使用一种叫做“横切”的技术来解剖封装对象的内部，将那些影响多个类的公共行为封装成一个可复用的模块，这样可以减少系统的重复代码，降低模块之间的耦合度，有利于以后的可操作性和可维护性。AOP将软件系统分为两部分：核心关注点和横切关注点。主要业务流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，它们经常出现在核心关注点的很多地方，而且所有的地方基本上都是相似的。例如授权认证、日志记录和事务处理。

实现原理　

在前面学习agent模式的时候，我了解到agent模式可以分为动态agent和静态agent。现在，我们将首先基于代理模式实现我们自己的AOP框架，然后研究Spring的AOP的实现原理。

首先，实现静态代理。静态代理的关键是实现代理对象和目标对象的公共接口，代理对象持有目标对象的引用。

公共接口代码：

公共接口IHello {

/**

*商业方法

* @param str

*/

void sayHello(字符串str)；

}

类别代码：

公共类Hello实现IHello{

@覆盖

public void sayHello(String str) {

system . out . println(' hello ' str)；

}

}

类代码，我们给它添加日志功能，在方法启动前后执行特定的方法。是不是和AOP特别像？

公共类ProxyHello实现IHello{

二等兵IHello你好；

公共代理Hello(IHello hello) {

super()；

this.hello=hello

}

@覆盖

public void sayHello(String str) {

logger . start()；//添加特定的方法

hello . say hello(str)；

logger . end()；

}

}

日志类代码：

公共类记录器{

公共静态void start(){

System.out.println(new Date()'说你好开始.');

}

公共静态void end(){

system . out . println(new Date()' say hello end ')；

}

}

测试代码：

公共类测试{

公共静态void main(String[] args) {

IHello Hello=new proxy Hello(new Hello())；//如果我们需要日志功能，请使用代理类

//IHello Hello=new Hello()；//如果我们不需要log函数，就使用目标类

Hello.sayHello('明天')；

}

}

这样我们实现了最简单的AOP，但是会有一个问题：如果我们有很多像Hello这样的类，是不是也要写很多像HelloProxy这样的类？其实也是一件很麻烦的事情。jdk1.3之后，jdk为我们提供了一个API Java . lang . reflect . invocation handler的类，允许我们在JVM调用一些方法的时候，动态地为它们做一些事情。让我们实现动态代理。

动态代理实现主要是实现InvocationHandler的方法，将目标对象注入代理对象，利用反射机制执行目标对象。

接口的实现与静态代理相同，代理类代码为：

公共类DynaProxyHello实现InvocationHandler{

私有对象目标；//目标对象

/**

*通过反射实例化目标对象

* @param对象

* @返回

*/

公共对象绑定(对象对象){

this.target=object

返回proxy . newproxyinstance(this . target . getclass()。getClassLoader()、this.target.getClass()。getInterfaces()，this)；

}

@覆盖

公共对象调用(对象代理、方法方法、对象[]参数)

可投掷的

对象结果=null

logger . start()；//添加其他方法

//通过反射机制运行目标对象的方法

result=method . invoke(this . target，args)；

logger . end()；

返回结果；

}

}

　　测试类代码：

公共类DynaTest {

公共静态void main(String[] args) {

IHello hello=(IHello)新DynaProxyHello()。bind(new Hello())；//如果我们需要日志功能，请使用代理类

//IHello Hello=new Hello()；//如果我们不需要log函数，就使用目标类

Hello.sayHello('明天')；

}

}

看了上面的代码，对比Spring AOP可能会有问题。log类只能在方法之前和之后打印，但是AOP在条件满足的情况下应该是可以执行的。那么，有没有可能将DynaPoxyHello对象与日志操作对象(Logger)解耦呢？

请看下面的代码实现，它将把DynaPoxyHello对象从日志操作对象(Logger)中分离出来：

如果我们想在代理对象的方法之前或之后添加日志操作码(或其他操作码)，那么我们可以抽象一个接口。这个接口只有两个方法：一个是代理对象执行方法之前执行的方法，我们称之为start，第二个是代理对象执行方法之后执行的方法，我们称之为end。

Logger的接口：

公共接口ILogger {

void start(方法Method)；

void end(方法方法)；

}

记录器的接口实现：

公共类DLogger实现ILogger{

@覆盖

公共void开始(方法方法){

system . out . println(new Date()method . getname()' say hello start . ');

}

@覆盖

公共void end(方法method) {

system . out . println(new Date()method . getname()' say hello end ')；

}

}

　动态代理类：

公共类DynaProxyHello实现InvocationHandler{

//调用对象

私有对象代理；

//目标对象

私有对象目标；

公共对象绑定(对象目标、对象代理){

this.target=target

this.proxy=proxy

返回proxy . newproxyinstance(this . target . getclass()。getClassLoader()、this.target.getClass()。getInterfaces()，this)；

}

@覆盖

公共对象调用(对象代理、方法方法、对象[]参数)

可投掷的

对象结果=null

//Reflect以获取运算符的示例

class clazz=this . proxy . getclass()；

//反射以获取运算符的开始方法

method start=clazz . getdeclaredmethod(' start '，new Class[]{ method . Class })；

//反射执行start方法

start.invoke(this.proxy，new Object[]{ this . proxy . getclass()})；

//执行要处理的对象的原始方法

方法.调用(this.target，args)；

//反射以获取运算符的结束方法

method end=clazz . getdeclaredmethod(' end '，new Class[]{ method . Class })；

//反射执行end方法

end.invoke(this.proxy，新对象[]{ method })；

返回结果；

}

}

测试代码：

公共类DynaTest {

公共静态void main(String[] args) {

IHello hello=(IHello)新DynaProxyHello()。bind(new Hello()、new DLogger())；//如果我们需要日志功能，请使用代理类

//IHello Hello=new Hello()；//如果我们不需要log函数，就使用目标类

Hello.sayHello('明天')；

}

}

通过上面的例子可以发现，通过动态代理和启动技术，AOP的功能已经基本实现。如果只需要在方法执行前打印日志，可以不实现end()方法，这样就可以控制打印的时间。如果要让指定的方法打印日志，我们只需要在invoke()方法中添加一个对方法名称的判断，方法名称就可以写入xml文件中，这样就可以实现与配置文件的解耦，从而实现了一个简单的spring aop框架。

以上是边肖介绍的Spring的aop实现原理。希望对你有帮助！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。