Spring AOP的两种代理方式

原创

zhuyeshen 2022-03-30 09:54:06 博主文章分类：JAVA ©著作权

文章标签 spring java 目标对象 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者zhuyeshen的原创作品，请联系作者获取转载授权，否则将追究法律责任

Spring AOP主要有两种代理方式：

1.JDK动态代理 2.cglib代理

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

注：JDK动态代理要比cglib代理执行速度快，但性能不如cglib好。所以在选择用哪种代理还是要看具体情况，一般单例模式用cglib比较好，具体原因请自行百度。

一、JDK动态代理实现（原理是使用反射机制）

1、定义TestService接口

[java] view plain copy

package io.mykit.proxy.jdk.service;

/**

* JDK动态代理Service

* @author liuyazhuang

public interface TestService {

int add();

}

2、定义TestServiceImpl实现类

[java] view plain copy

package io.mykit.proxy.jdk.service.impl;

import io.mykit.proxy.jdk.service.TestService;

public class TestServiceImpl implements TestService {

@Override

public int add() {

System.out.println("开始执行add...");

return 0;

}

3、定义动态代理类JDKDynamicProxy

[java] view plain copy

package io.mykit.proxy.jdk.handler;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

* JDK的动态代理实现

* @author liuyazhuang

public class JDKDynamicProxy implements InvocationHandler {

//被代理的目标对象

private Object proxyObj;

/**

* Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

* loader :类加载器一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载

* interfaces:一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

* h :一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

public Object newProxy(Object proxyObj){

this.proxyObj = proxyObj;

//返回一个代理对象

return Proxy.newProxyInstance(proxyObj.getClass().getClassLoader(), proxyObj.getClass().getInterfaces(), this);

}

/**

* 执行目标对象

* Object proxy：被代理的对象

* Method method：要调用的方法

* Object args[]：方法调用时所需要的参数

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

before();

Object object = method.invoke(this.proxyObj, args); // 通过反射机制调用目标对象的方法

after();

return object;

}

public void before(){

System.out.println("开始执行目标对象之前...");

}

public void after(){

System.out.println("开始执行目标对象之后...");

}

4、实现测试类ProxyTest

[java] view plain copy

package io.mykit.proxy.jdk;

import io.mykit.proxy.jdk.handler.JDKDynamicProxy;

import io.mykit.proxy.jdk.service.TestService;

import io.mykit.proxy.jdk.service.impl.TestServiceImpl;

/**

* 动态代理测试

* @author liuyazhuang

public class ProxyTest {

public static void main(String[] args) {

// 我们要代理的真实对象

TestService testService = new TestServiceImpl();

testService.add();// 不是用代理

System.out.println("===================================");

JDKDynamicProxy JDKDynamicProxyTarget = new JDKDynamicProxy();

TestService testServiceProxy = (TestService) JDKDynamicProxyTarget.newProxy(testService);

// 执行代理类的方法

testServiceProxy.add();

}

5、测试结果如下

[plain] view plain copy

开始执行add...

===================================

开始执行目标对象之前...

开始执行add...

开始执行目标对象之后...

二、CGLIB代理

1、创建TestCGLIBServiceImpl类

[java] view plain copy

package io.mykit.proxy.cglib.service.impl;

/**

* 未实现接口的类

* @author liuyazhuang

public class TestCGLIBServiceImpl {

public int add() {

System.out.println("开始执行add...");

return 0;

}

2、创建代理类CGLIBProxy

[java] view plain copy

package io.mykit.proxy.cglib.handler;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

/**

* 基于CGLIB实现

* @author liuyazhuang

public class CGLIBProxy implements MethodInterceptor {

private Object targetObject;// 被代理的目标对象

/**

* 构造代理对象

* @param targetObject 传递的真实对象

* @return 代理对象

public Object createProxyInstance(Object targetObject) {

this.targetObject = targetObject;

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(targetObject.getClass());// 设置代理目标

enhancer.setCallback(this);// 设置回调

return enhancer.create();

}

/**

* 在代理实例上处理方法调用并返回结果

* @param object ：代理类

* @param method ：被代理的方法

* @param args ：该方法的参数数组

* @param methodProxy : 方法代理

@Override

public Object intercept(Object object, Method method, Object[] args, MethodProxy methodproxy) throws Throwable {

Object result = null;

try {

System.out.println("前置处理开始 ...");

result = methodproxy.invoke(targetObject, args);// 执行目标对象的方法

System.out.println("后置处理开始 ...");

} catch (Exception e) {

System.out.println(" 异常处理 ...");

} finally {

System.out.println(" 调用结束 ...");

}

return result;

}

3、创建测试类ProxyTest

[java] view plain copy

package io.mykit.proxy.cglib;

import io.mykit.proxy.cglib.handler.CGLIBProxy;

import io.mykit.proxy.cglib.service.impl.TestCGLIBServiceImpl;

/**

* 测试CGLIB代理

* @author liuyazhuang

public class ProxyTest {

public static void main(String[] args) {

//我们要代理的真实对象

TestCGLIBServiceImpl testCGLIB = new TestCGLIBServiceImpl();

testCGLIB.add();

System.out.println("======================================");

CGLIBProxy CGLIBproxy = new CGLIBProxy();

TestCGLIBServiceImpl testCGLIBProxy = (TestCGLIBServiceImpl) CGLIBproxy.createProxyInstance(testCGLIB);

testCGLIBProxy.add();

}

4、测试结果

[plain] view plain copy

开始执行add...

======================================

前置处理开始 ...

开始执行add...

后置处理开始 ...

调用结束 ...

5、pom.xml中添加的Jar包

[html] view plain copy

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

<skip_maven_deploy>false</skip_maven_deploy>

<jdk.version>1.8</jdk.version>

<spring.version>4.1.0.RELEASE</spring.version>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-expression</artifactId>