手写Spring：第12章-基于JDK、Cglib实现AOP切面
文章目录
- 一、目标：基于JDK、Cglib实现AOP切面
- 二、设计：基于JDK、Cglib实现AOP切面
- 三、实现：基于JDK、Cglib实现AOP切面
-
- 3.0 引入依赖
- 3.1 工程结构
- 3.2 AOP切点表达式和使用以及基于JDK和CGLIB的动态代理类图
- 3.3 切点表达式
-
- 3.3.1 类匹配接口
- 3.3.2 匹配方法接口
- 3.3.3 切点表达式接口
- 3.3.4 实现切点表达式类
- 3.4 包装切面通知信息
-
- 3.4.1 被代理的目标对象
- 3.4.2 包装切面通知消息
- 3.5 代理抽象实现(JDK&Cglib)
-
- 3.5.1 反射方法调用
- 3.5.2 AOP代理接口
- 3.5.3 JDK 动态代理
- 3.5.4 Cglib代理
- 四、测试：基于JDK、Cglib实现AOP切面
-
- 4.1 添加测试配置
-
- 4.1.1 用户接口
- 4.1.2 用户接口实现类
- 4.1.3 自定义用户拦截方法
- 4.2 单元测试
-
- 4.2.1 代理方法测试
- 4.2.2 匹配方法测试
- 4.2.3 单元测试
- 五、总结：基于JDK、Cglib实现AOP切面
一、目标：基于JDK、Cglib实现AOP切面
AOP是什么？如何实现AOP？
- AOP：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能的统一维护。
- 其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容。
- 使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各个模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。
- AOP 的核心技术实现主要是：动态代理的使用，就像你可以给一个接口的实现类，使用代理的方式替换掉这个代理类，使用代理类来处理你需要的逻辑。
动态代理
@Test
public void test_proxy_class() {
IUserService userService = (IUserService) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{IUserService.class}, (proxy, method, args) -> "你被代理了！");
String result = userService.queryUserInfo();
System.out.println("测试结果：" + result);
}
测试结果
测试结果：你被代理了！
- 代理类的实现就是使用
Proxy.newProxyInstance方法。 - 那么有了一个基本的思路后，解析来就考虑怎么给方法做代理，而不是代理类？另外怎么去代理所有符合某些规则的所有类中方法？
- 如果可以代理掉所有类的方法，就可以做一个方法拦截器，给所有被代理的方法添加一些自定义处理。如：打印日志、记录耗时、监控异常等。
二、设计：基于JDK、Cglib实现AOP切面
如何给符合规则的方法做代理？怎么做完代理方法的案例后，把类的职责拆分出来？
- 这两个功能点的实现，都是以切面的思想进行设计和开发。
- 就像你在使用 Spring AOP 一样，只处理一些需要被拦截的方法。在拦截方法后，执行你对方法的扩展操作。
- 需要先实现一个可以代理方法的
Proxy，其实代理方法主要是使用到方法拦截器类处理方法的调用MethodInterceptor#invoke，而不是直接使用invoke方法中的入参Method method进行method.invoke(targetObj, args)。 - 除了以上的核心功能实现，还需要使用到
org.aspectj.weaver.tools.PointcutParser处理拦截表达式execution(* com.lino.springframework.test.bean.IUserService.*(..))，有了方法代理和处理拦截，就可以设计出一个 AOP 的雏形了。
三、实现：基于JDK、Cglib实现AOP切面
3.0 引入依赖
<dependency>
<groupId>aopalliancegroupId>
<artifactId>aopallianceartifactId>
<version>1.0version>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.7version>
dependency>
3.1 工程结构
spring-step-11
|-src
|-main
| |-java
| |-com.lino.springframework
| |-aop
| | |-aspectj
| | | |-AspectJExpressionPointcut.java
| | |-framework
| | | |-AopProxy.java
| | | |-Cglib2AopProxy.java
| | | |-JdkDynamicAopProxy.java
| | | |-ReflectiveMethodInvocation.java
| | |-AdvisedSupport.java
| | |-ClassFilter.java
| | |-MethodMatcher.java
| | |-Pointcut.java
| | |-TargetSource.java
| |-beans
| | |-factory
| | | |-config
| | | | |-AutowireCapableBeanFactory.java
| | | | |-BeanDefinition.java
| | | | |-BeanFactoryPostProcessor.java
| | | | |-BeanPostProcessor.java
| | | | |-BeanReference.java
| | | | |-ConfigurableBeanFactory.java
| | | | |-SingletonBeanRegistry.java
| | | |-support
| | | | |-AbstractAutowireCapableBeanFactory.java
| | | | |-AbstractBeabDefinitionReader.java
| | | | |-AbstractBeabFactory.java
| | | | |-BeabDefinitionReader.java
| | | | |-BeanDefinitionRegistry.java
| | | | |-CglibSubclassingInstantiationStrategy.java
| | | | |-DefaultListableBeanFactory.java
| | | | |-DefaultSingletonBeanRegistry.java
| | | | |-DisposableBeanAdapter.java
| | | | |-FactoryBeanRegistrySupport.java
| | | | |-InstantiationStrategy.java
| | | | |-SimpleInstantiationStrategy.java
| | | |-support
| | | | |-XMLBeanDefinitionReader.java
| | | |-Aware.java
| | | |-BeanClassLoaderAware.java
| | | |-BeanFactory.java
| | | |-BeanFactoryAware.java
| | | |-BeanNameAware.java
| | | |-ConfigurableListableBeanFactory.java
| | | |-DisposableBean.java
| | | |-FactoryBean.java
| | | |-HierarcgicalBeanFactory.java
| | | |-InitializingBean.java
| | | |-ListableBeanFactory.java
| | |-BeansException.java
| | |-PropertyValue.java
| | |-PropertyValues.java
| |-context
| | |-event
| | | |-AbstractApplicationEventMulticaster.java
| | | |-ApplicationContextEvent.java
| | | |-ApplicationEventMulticaster.java
| | | |-ContextclosedEvent.java
| | | |-ContextRefreshedEvent.java
| | | |-SimpleApplicationEventMulticaster.java
| | |-support
| | | |-AbstractApplicationContext.java
| | | |-AbstractRefreshableApplicationContext.java
| | | |-AbstractXmlApplicationContext.java
| | | |-ApplicationContextAwareProcessor.java
| | | |-ClassPathXmlApplicationContext.java
| | |-ApplicationContext.java
| | |-ApplicationContextAware.java
| | |-ApplicationEvent.java
| | |-ApplicationEventPublisher.java
| | |-ApplicationListener.java
| | |-ConfigurableApplicationContext.java
| |-core.io
| | |-ClassPathResource.java
| | |-DefaultResourceLoader.java
| | |-FileSystemResource.java
| | |-Resource.java
| | |-ResourceLoader.java
| | |-UrlResource.java
| |-util
| | |-ClassUtils.java
|-test
|-java
|-com.lino.springframework.test
|-bean
| |-IUserService.java
| |-UserService.java
| |-UserServiceInterceptor.java
|-ApiTest.java
|-resources
|-spring.xml
3.2 AOP切点表达式和使用以及基于JDK和CGLIB的动态代理类图
- 整个类图就是 AOP 实现核心逻辑的地方，上面部分是关于方法的匹配实现，下面从 AopProxy 开始是关于方法的代理操作。
AspectJExpressionPointcut的核心功能主要依赖于aspectj组件并处理Pointcut、ClassFilter、MethodMatcher接口实现，专门用于处理类和方法的匹配过滤操作。AopProxy是代理的抽象对象，它的实现主要是基于 JDK 的代理和 Cglib 代理。
3.3 切点表达式
3.3.1 类匹配接口
ClassFilter.java
package com.lino.springframework.aop;
/**
* @description: 类匹配接口
*/
public interface ClassFilter {
/**
* 匹配类
*
* @param clazz 类类型
* @return 是否匹配类
*/
boolean matches(Class<?> clazz);
}
- 定义类匹配类，用于切点好到给定的接口和目标类
3.3.2 匹配方法接口
MethodMatcher.java
package com.lino.springframework.aop;
import java.lang.reflect.Method;
/**
* @description: 匹配方法接口
*/
public interface MethodMatcher {
/**
* 匹配方法
*
* @param method 匹配方法
* @param targetClass 类
* @return 是否匹配方法
*/
boolean matches(Method method, Class<?> targetClass);
}
- 方法匹配，找到表达式范围内匹配下的目标类和方法。
3.3.3 切点表达式接口
Pointcut.java
package com.lino.springframework.aop;
/**
* @description: 切点表达式接口
*/
public interface Pointcut {
/**
* 获取切点中类匹配类
*
* @return 类匹配类
*/
ClassFilter getClassFilter();
/**
* 获取切点中匹配方法
*
* @return 匹配方法
*/
MethodMatcher getMethodMatcher();
}
- 切入点接口，定义用于获取
ClassFilter、MethodMatcher两个类，这两个接口获取都是切点表达式提供的内容。
3.3.4 实现切点表达式类
AspectJExpressionPointcut.java
package com.lino.springframework.aop.aspectj;
import com.lino.springframework.aop.ClassFilter;
import com.lino.springframework.aop.MethodMatcher;
import com.lino.springframework.aop.Pointcut;
import org.aspectj.weaver.tools.PointcutExpression;
import org.aspectj.weaver.tools.PointcutParser;
import org.aspectj.weaver.tools.PointcutPrimitive;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
/**
* @description: 切点表达式实现类
*/
public class AspectJExpressionPointcut implements Pointcut, ClassFilter, MethodMatcher {
private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
static {
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
}
private final PointcutExpression pointcutExpression;
public AspectJExpressionPointcut(String expression) {
PointcutParser pointcutParser = PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(SUPPORTED_PRIMITIVES, this.getClass().getClassLoader());
pointcutExpression = pointcutParser.parsePointcutExpression(expression);
}
@Override
public boolean matches(Class<?> clazz) {
return pointcutExpression.couldMatchJoinPointsInType(clazz);
}
@Override
public boolean matches(Method method, Class<?> targetClass) {
return pointcutExpression.matchesMethodExecution(method).alwaysMatches();
}
@Override
public ClassFilter getClassFilter() {
return this;
}
@Override
public MethodMatcher getMethodMatcher() {
return this;
}
}
- 切点表达式实现了
Pointcut, ClassFilter, MethodMatcher，三个接口定义方法，同时这个类主要是对aspectj包提供的表达式校验方法使用。 - 匹配
matches：pointcutExpression.couldMatchJoinPointsInType(clazz)pointcutExpression.matchesMethodExecution(method).alwaysMatches()
3.4 包装切面通知信息
3.4.1 被代理的目标对象
TargetSource.java
package com.lino.springframework.aop;
/**
* @description: 被代理的目标对象
*/
public class TargetSource {
private final Object target;
public TargetSource(Object target) {
this.target = target;
}
/**
* 获取目标对象列表
*
* @return 目标对象列表
*/
public Class<?>[] getTargetClass() {
return this.target.getClass().getInterfaces();
}
/**
* 获取目标对象
*
* @return 目标对象
*/
public Object getTarget() {
return this.target;
}
}
3.4.2 包装切面通知消息
AdvisedSupport.java
package com.lino.springframework.aop;
import org.aopalliance.intercept.MethodInterceptor;
/**
* @description: 包装切面通知信息
*/
public class AdvisedSupport {
/**
* 被代理的目标对象
*/
private TargetSource targetSource;
/**
* 方法拦截器
*/
private MethodInterceptor methodInterceptor;
/**
* 方法匹配器(检查目标方法是否符合通知条件)
*/
private MethodMatcher methodMatcher;
public TargetSource getTargetSource() {
return targetSource;
}
public void setTargetSource(TargetSource targetSource) {
this.targetSource = targetSource;
}
public MethodInterceptor getMethodInterceptor() {
return methodInterceptor;
}
public void setMethodInterceptor(MethodInterceptor methodInterceptor) {
this.methodInterceptor = methodInterceptor;
}
public MethodMatcher getMethodMatcher() {
return methodMatcher;
}
public void setMethodMatcher(MethodMatcher methodMatcher) {
this.methodMatcher = methodMatcher;
}
}
AdvisedSupport：主要用于把代理、拦截、匹配的各项属性包装到一个类中，方便在Proxy实现类进行使用。TargetSource：是一个目标对象，在目标对象类中提供 Object 入参属性，以及获取目标类 TargetClass 信息。MethodInterceptor：是一个具体拦截方法实现类，由用户自己实现MethodInterceptor#invoke方法，做具体的实现。MethodMatcher：是一个匹配方法，这个对象由AspectJExpressionPointcut提供服务。
3.5 代理抽象实现(JDK&Cglib)
3.5.1 反射方法调用
ReflectiveMethodInvocation.java
package com.lino.springframework.aop.framework;
import org.aopalliance.intercept.MethodInvocation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
/**
* @description: 反射方法调用
* @author: lingjian
* @createDate: 2022/12/2 9:44
*/
public class ReflectiveMethodInvocation implements MethodInvocation {
/**
* 目标对象
*/
protected final Object target;
/**
* 方法
*/
protected final Method method;
/**
* 入参
*/
protected final Object[] arguments;
public ReflectiveMethodInvocation(Object target, Method method, Object[] arguments) {
this.target = target;
this.method = method;
this.arguments = arguments;
}
@Override
public Method getMethod() {
return method;
}
@Override
public Object[] getArguments() {
return arguments;
}
@Override
public Object proceed() throws Throwable {
return method.invoke(target, arguments);
}
@Override
public Object getThis() {
return target;
}
@Override
public AccessibleObject getStaticPart() {
return method;
}
}
3.5.2 AOP代理接口
AopProxy.java
package com.lino.springframework.aop.framework;
/**
* @description: AOP代理接口
*/
public interface AopProxy {
/**
* 获取代理对象
*
* @return 代理对象
*/
Object getProxy();
}
- 定义一个标准接口，用于获取代理类。因为具体实现代理的方式可以有 JDK 方式，也可以是 Cglib 方式，所以定义接口会更加方便管理。
3.5.3 JDK 动态代理
JdkDynamicAopProxy.java
package com.lino.springframework.aop.framework;
import com.lino.springframework.aop.AdvisedSupport;
import org.aopalliance.intercept.MethodInterceptor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @description: JDK 动态代理
*/
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
private final AdvisedSupport advised;
public JdkDynamicAopProxy(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object getProxy() {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), advised.getTargetSource().getTargetClass(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (advised.getMethodMatcher().matches(method, advised.getTargetSource().getTarget().getClass())) {
MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
return methodInterceptor.invoke(new ReflectiveMethodInvocation(advised.getTargetSource().getTarget(), method, args));
}
return method.invoke(advised.getTargetSource().getTarget(), args);
}
}
- 基于 JDK 实现的代理类，需要实现
AopProxy、InvocationHandler，这样就可以把代理对象getProxy和反射调用方法invoke分开处理了。 getProxy方法中的是代理一个对象的操作，需要提供入参ClassLoader、AdvisedSupport和当前类this，因为这个类提供了invoke方法。invoke方法中主要处理匹配的方法后，使得用户自己提供的方法拦截实现，做反射调用methodInterceptor.invoke。- 这里还有一个
ReflectiveMethodInvocation，其实它就是一个入参的包装信息，提供了入参对象：目标对象、方法、入参。
3.5.4 Cglib代理
Cglib2AopProxy.java
package com.lino.springframework.aop.framework;
import com.lino.springframework.aop.AdvisedSupport;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @description: Cglib代理
*/
public class Cglib2AopProxy implements AopProxy {
private final AdvisedSupport advised;
public Cglib2AopProxy(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object getProxy() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(advised.getTargetSource().getTarget().getClass());
enhancer.setInterfaces(advised.getTargetSource().getTargetClass());
enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
return enhancer.create();
}
private static class DynamicAdvisedInterceptor implements MethodInterceptor {
private final AdvisedSupport advised;
public DynamicAdvisedInterceptor(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
CglibMethodInvocation methodInvocation = new CglibMethodInvocation(advised.getTargetSource().getTarget(), method, objects, methodProxy);
if (advised.getMethodMatcher().matches(method, advised.getTargetSource().getTarget().getClass())) {
return advised.getMethodInterceptor().invoke(methodInvocation);
}
return methodInvocation.proceed();
}
}
private static class CglibMethodInvocation extends ReflectiveMethodInvocation {
private final MethodProxy methodProxy;
public CglibMethodInvocation(Object target, Method method, Object[] arguments, MethodProxy methodProxy) {
super(target, method, arguments);
this.methodProxy = methodProxy;
}
@Override
public Object proceed() throws Throwable {
return this.methodProxy.invoke(this.target, this.arguments);
}
}
}
- 基于 Cglib 使用
Enhancer代理的类可以在运行期间为接口使用底层 ASM 字节码增强技术处理对象的代理对象生成，因此被代理类不需要实现任何接口。 - 关于扩展用户拦截方法，主要在
Enhancer#setCallback中处理，用户自己的新增的拦截处理。- 这里可以看到
DynamicAdvisedInterceptor#intercept匹配方法后做了相应的反射操作。
- 这里可以看到
四、测试：基于JDK、Cglib实现AOP切面
4.1 添加测试配置
4.1.1 用户接口
IUserService.java
package com.lino.springframework.test.bean;
/**
* @description: 用户接口
*/
public interface IUserService {
/**
* 查询用户信息
*
* @return 用户信息
*/
String queryUserInfo();
/**
* 注册用户
*
* @param userName 用户名
* @return 用户信息
*/
String register(String userName);
}
4.1.2 用户接口实现类
UserService.java
package com.lino.springframework.test.bean;
import java.util.Random;
/**
* @description: 用户接口实现类
*/
public class UserService implements IUserService {
@Override
public String queryUserInfo() {
try {
Thread.sleep(new Random(1).nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
return "张三，100001，杭州";
}
@Override
public String register(String userName) {
try {
Thread.sleep(new Random(1).nextInt(100));
} catch (InterruptedException e) {
e.printStackTrace();
}
return "注册用户：" + userName + " success!";
}
}
- 在 UserService 中提供了2个不同方法。查询和注册。
4.1.3 自定义用户拦截方法
UserServiceInterceptor.java
package com.lino.springframework.test.bean;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
* @description: 用户拦截器
*/
public class UserServiceInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
long start = System.currentTimeMillis();
try {
return invocation.proceed();
} finally {
System.out.println("监控 - Begin By AOP");
System.out.println("方法名称：" + invocation.getMethod());
System.out.println("方法耗时：" + (System.currentTimeMillis() - start) + "ms");
System.out.println("监控 - End\r\n");
}
}
}
- 用户自定义的拦截方法需要实现
MethodInterceptor接口的invoke方法，使用方式于 Spring AOP 类似，也是包装invocation.proceed()放行，并在finally中添加监控信息。
4.2 单元测试
4.2.1 代理方法测试
ApiTest.java
@Test
public void test_proxy_method() {
// 目标对象
Object targetObj = new UserService();
// AOP代理
IUserService proxy = (IUserService) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), targetObj.getClass().getInterfaces(), new InvocationHandler() {
// 方法匹配器
MethodMatcher methodMatcher = new AspectJExpressionPointcut("execution(* com.lino.springframework.test.bean.IUserService.*(..))");
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (methodMatcher.matches(method, targetObj.getClass())) {
// 方法拦截器
MethodInterceptor methodInterceptor = invocation -> {
long start = System.currentTimeMillis();
try {
return invocation.proceed();
} finally {
System.out.println("监控 - Begin By AOP");
System.out.println("方法名称：" + invocation.getMethod());
System.out.println("方法耗时：" + (System.currentTimeMillis() - start) + "ms");
System.out.println("监控 - End\r\n");
}
};
return methodInterceptor.invoke(new ReflectiveMethodInvocation(targetObj, method, args));
}
return method.invoke(targetObj, args);
}
});
String result = proxy.queryUserInfo();
System.out.println("测试结果：" + result);
}
- 整个案例的目标是把一个
UserService当成目标对象，对类中的所有方法进行拦截添加监控信息打印处理。 - 从案例中可以看到有代理的实现
Proxy.newProxyInstance，有方法的匹配MethodMatcher，有反射的调用invoke(Object proxy, Method method, Object[] args)，也有用户自己拦截方法后的操作。 - 这样看其实就和我们使用的 AOP 非常类似。
测试结果
监控 - Begin By AOP
方法名称：public abstract java.lang.String com.lino.springframework.test.bean.IUserService.queryUserInfo()
方法耗时：86ms
监控 - End
测试结果：张三，100001，杭州
- 从测试结果看，我们已经对
UserService#queryUserInfo方法进行了拦截监控操作。
拆解案例
- 拆解过程参考上图，把代理对象拆解出来，因为它可以是 JDK 的实现也可以是 Cglib 的处理。
- 方法匹配器操作其实已经是一个单独的实现类了，不过我们还需要把传入的目标对象、方法匹配、拦截方法，都进行统一的包装，方便外部调用时进行一个入参透传。
- 最后其实就是
ReflectiveMethodInvocation的使用，它目前已经是实现MethodInvocation接口的一个包装后的类。- 参数信息包括：调用的对象、调用的方法、调用的入参。
4.2.2 匹配方法测试
ApiTest.java
@Test
public void test_aop() throws NoSuchMethodException {
AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut("execution(* com.lino.springframework.test.bean.UserService.*(..))");
Class<UserService> clazz = UserService.class;
Method method = clazz.getDeclaredMethod("queryUserInfo");
System.out.println(pointcut.matches(clazz));
System.out.println(pointcut.matches(method, clazz));
}
测试结果
true
true
- 这是一个匹配方法的测试，可以看看拦截的方法与对应的对象是否匹配。
4.2.3 单元测试
ApiTest.java
@Test
public void test_dynamic() {
// 目标对象
IUserService userService = new UserService();
// 组装代理信息
AdvisedSupport advisedSupport = new AdvisedSupport();
advisedSupport.setTargetSource(new TargetSource(userService));
advisedSupport.setMethodInterceptor(new UserServiceInterceptor());
advisedSupport.setMethodMatcher(new AspectJExpressionPointcut("execution(* com.lino.springframework.test.bean.IUserService.*(..))"));
// 代理对象(JDKDynamicAopProxy)
IUserService proxy_jdk = (IUserService) new JdkDynamicAopProxy(advisedSupport).getProxy();
// 测试调用
System.out.println("测试结果：" + proxy_jdk.queryUserInfo());
// 代理对象(Cglib2AopProxy)
IUserService proxy_cglib = (IUserService) new Cglib2AopProxy(advisedSupport).getProxy();
// 测试调用
System.out.println("测试结果：" + proxy_cglib.register("小零"));
}
- 整个案例测试了 AOP 在与 Spring 结合前的核心代码，包括什么是目标对象、怎么组装代理信息、如何调用代理对象等。
AdvisedSupport：包装了目标对象、用户自己实现的拦截方法以及方法匹配表达式。- 之后就是分别调用
JdkDynamicAopProxy、Cglib2AopProxy，两个不同方式实现的代理类，看看是否可以成功拦截方法。
测试结果
监控 - Begin By AOP
方法名称：public abstract java.lang.String com.lino.springframework.test.bean.IUserService.queryUserInfo()
方法耗时：90ms
监控 - End
测试结果：张三，100001，杭州
监控 - Begin By AOP
方法名称：public java.lang.String com.lino.springframework.test.bean.UserService.register(java.lang.String)
方法耗时：99ms
监控 - End
测试结果：注册用户：小零 success!
- 如 AOP 功能定义一样，我们可以通过这样的代理方式、方法匹配和拦截后，在对应的目标方法下，做了拦截操作进行监控信息打印。
五、总结：基于JDK、Cglib实现AOP切面
- 本文对
Proxy#newProxyInstance、MethodInterceptor#invoke的使用验证切面核心原理以及再把功能拆解到 Spring 框架实现中。- 可以看到一个貌似复杂的技术其实核心内容往往没有太多，但因为需要为了满足后续更多的扩展就需要进行职责解耦和包装，通过这样设计模式的使用，以此让调用方能更加简化，自身也可以不断按需扩展。
- AOP 的功能实现目前还没有与 Spring 结合，只是对切面技术的一个具体实现，可以先学到：如何处理代理对象、过滤方法、拦截方法，以及使用 JDK 和 Cglib 代理的区别。