JavaAOP的底层实现原理

Java AOP的底层实现原理

⼀、什么是AOP

1、AOP：Aspect Oriented Programming（⾯向切⾯编程），OOP是⾯向对象编程，AOP是在OOP基础之上的⼀种更⾼级的设计思想。2、OOP和AOP之间也存在⼀些区别，OOP侧重于对象的提取和封装。----封装对象

AOP侧重于⽅⾯组件，⽅⾯组件可以理解成封装了通⽤功能的组件，⽅⾯组件可以通过配置⽅式，灵活地切⼊到某⼀批⽬标对象⽅法上。----封装功能

3、AOP⽤于处理系统中分布于各个模块的横切关注点，⽐如事务管理、⽇志、缓存等。

⼆、AOP代理

1.AOP实现的关键，在于AOP框架⾃动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；⽽动态代理则以Spring AOP为代表。

2.使⽤AspectJ的编译时增强，实现AOP。

之前提到，AspectJ是静态代理的增强。所谓的静态代理，就是AOP框架会在编译阶段⽣成AOP代理类，因此也称为编译时增强。3.举个实例来说。⾸先我们有⼀个普通的Hello类：

public class Hello {

public void sayHello() {

System.out.println(\"hello\"); }

public static void main(String[] args) { Hello h = new Hello(); h.sayHello(); }}

4.使⽤AspectJ编写⼀个Aspect：

public aspect TxAspect {

void around:call(void Hello.sayHello()) { System.out.println(\"开始事务。。。\"); proceed();

System.out.println(\"结束事务。。。\"); }}

5.这⾥模拟了⼀个事务的场景，类似于Spring的声明式事务。使⽤AspectJ的编译器编译：ajc -d . Hello.java TxAspect.aj

编译完成之后，再运⾏Hello类，可以看到以下输出：1）开始事务。。。2）hello

3）结束事务。。。

显然，AOP已经⽣效了。这就是AspectJ的静态代理，它会在编译阶段将Aspect织⼊Java字节码中，运⾏的时候就是经过增强之后的AOP对象。proceed⽅法就是回调执⾏被代理类中的⽅法。

三、使⽤Spring AOP

1.与AspectJ的静态代理不同，Spring AOP使⽤的是动态代理。所谓的动态代理，就是说AOP框架不会去修改字节码，⽽是在内存中临时为⽅法⽣成⼀个AOP对象，这个AOP对象包含了⽬标对象的全部⽅法，并且在特定的切点做了增强处理，并回调原对象的⽅法。

2.Spring AOP中的动态代理，主要有两种⽅式：JDK动态代理和CGLIB动态代理。JDK动态代理通过“反射”来接收被代理的类，并且要求被代理的类必须实现⼀个接⼝。JDK动态代理的核⼼是InvocationHandler接⼝和Proxy类。如果⽬标类没有实现接⼝，那么Spring AOP会选择使⽤CGLIB来动态代理⽬标类。

3.CGLIB（Code Generation Library），是⼀个代码⽣成的类库，可以在运⾏时动态地⽣成某个类的⼦类。注意，CGLIB是通过继承的⽅式做的动态代理，因此如果某个类被标记为final，那么它是⽆法使⽤CGLIB做动态代理的。

四、JDK动态代理

1.为了验证以上的说法，可以做⼀个简单的测试。⾸先测试实现接⼝的情况。2.定义⼀个接⼝：

public interface Person {

void sayHello(String name);}

3.实现类：

@Component

public class Chinese implements Person { @Timer @Override

public void sayHello(String name) { System.out.println(\"-- sayHello()--\"); };

public void eat(String food) {

System.out.println(\"我正在吃：\" + food); }}

这⾥的@Timer注解，是⾃定义的⼀个普通注解，⽤来标记Pointcut。4.定义Aspect：

@Aspect @Component

public class AdviceTest {

@Pointcut(\"annotation(com.spring.aop.Timer)\") public void pointcut() {}

@Before(\"pointcut()\") public void before() {

System.out.println(\"before\"); }}

5.运⾏：

@SpringBootApplication @RestController

public class SpringBootDemoApplication { // 这⾥必须使⽤Person接⼝做注⼊ @Autowired

private Person chinese;

@RequestMapping(\"/test\") public void test() {

chinese.sayHello(\"listen\");

System.out.println(chinese.getClass());}

public static void main(String[] args) {

SpringApplication.run(SpringBootDemoApplication.class, args); }}

6.输出：

1）before

2）-- sayHello() --3）class com.sun.proxy.$Proxy53

可以看到类型是class com.sun.proxy.$Proxy53，也就是前⾯提到的Proxy类，因此这⾥Spring AOP使⽤了JDK的动态代理。

五、CGLIB动态代理

1.再来看看不实现接⼝的情况，修改Chinese类：@Component

public class Chinese {@Timer

public void sayHello(String name) {System.out.println(\"-- sayHello() --\"); };

public void eat(String food) {

System.out.println(\"我正在吃：\" + food);}}

2.定义Aspect。3.运⾏：

@SpringBootApplication @RestController

public class SpringBootDemoApplication { // 直接⽤Chinese类注⼊ @Autowired

private Chinese chinese;

@RequestMapping(\"/test\") public void test() {

chinese.sayHello(\"listen\");

System.out.println(chinese.getClass()); }

public static void main(String[] args) {

SpringApplication.run(SpringBootDemoApplication.class, args); }}

4.输出：

1）before

2）-- sayHello() --3）class com.spring.aop.Chinese

可以看到类被CGLIB增强了，也就是动态代理。这⾥的CGLIB代理就是Spring AOP的代理，这个类也就是所谓的AOP代理，AOP代理类在切点动态地织⼊了增强处理。