基于JDK动态代理/Cglib代理，结合MethodInterceptor实现代理对象的切面功能

最新推荐文章于 2023-10-23 15:27:30 发布
最新推荐文章于 2023-10-23 15:27:30 发布
阅读量368 收藏 1
点赞数
文章标签： java 代理模式 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43389741/article/details/130060067
版权

我们都知道，java中的代理分为JDK动态代理和Cglib代理，JDK动态代理是基于反射创建代理对象的，而Cglib是通过字节码技术实现的代理对象创建，使用代理对象的强大作用我们都很清楚，其中spring 中 aop 的核心思想就是基于代理对象的创建，并在切点处织如切面，从而实现aop,今天我们就来实现一下基于JDK动态代理和Cglib代理实现切面功能。

1.AopProxy（interface），定义获取代理对象的方法，具体交由子类实现。

public interface AopProxy {
    /**
     * 获取代理对象
     * @return
     */
    Object getInstance();
}
  1. 具体实现

Jdk动态代理

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * JDK 动态代理
 */
public class JdkDynamicProxy implements AopProxy{

    private AspectSupport aspectSupport;

    public JdkDynamicProxy(AspectSupport aspectSupport) {
        this.aspectSupport = aspectSupport;
    }

    @Override
    public Object getInstance() {
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                aspectSupport.getTargetSource().targetInterfaces(),new Handler());
    }

    private class Handler implements InvocationHandler{

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            MethodMatcher methodMatcher = aspectSupport.getMethodMatcher();
            if (methodMatcher.matches(method)){
                MethodInterceptor methodInterceptor = aspectSupport.getMethodInterceptor();
                return methodInterceptor.invoke(new ReflectInvocation(args,method,aspectSupport.getTargetSource().getTarget()));
            }
            return method.invoke(aspectSupport.getTargetSource(),args);
        }
    }

    private class ReflectInvocation implements MethodInvocation {
        private Object[] args;
        private Method method;
        private Object target;

        public ReflectInvocation(Object[] args, Method method, Object target) {
            this.args = args;
            this.method = method;
            this.target = target;
        }

        @Override
        public Object[] getArguments() {
            return args;
        }

        @Override
        public Object proceed() throws Throwable {
            return method.invoke(target,args);
        }

        @Override
        public Object getThis() {
            return target;
        }

        @Override
        public AccessibleObject getStaticPart() {
            return method;
        }

        @Override
        public Method getMethod() {
            return method;
        }
    }
}

Cglib代理

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.aopalliance.intercept.MethodInvocation;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;

/**
 * Cglib 代理
 */
public class CglibProxy implements AopProxy{
    private AspectSupport aspectSupport;

    public CglibProxy(AspectSupport aspectSupport) {
        this.aspectSupport = aspectSupport;
    }

    @Override
    public Object getInstance() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(aspectSupport.getTargetSource().targetClass());
        enhancer.setInterfaces(aspectSupport.getTargetSource().targetInterfaces());
        enhancer.setCallback(new CglibMethodInterceptor(aspectSupport));
        return enhancer.create();
    }

    // 这个类类似于 InvocationHandler
    private class CglibMethodInterceptor implements MethodInterceptor{
        private AspectSupport aspectSupport;

        public CglibMethodInterceptor(AspectSupport aspectSupport) {
            this.aspectSupport = aspectSupport;
        }

        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            MethodMatcher methodMatcher = aspectSupport.getMethodMatcher();
            if (methodMatcher != null && methodMatcher.matches(method)){
                return aspectSupport.getMethodInterceptor().invoke(new CglibMethodInvocation(args,method,aspectSupport.getTargetSource().getTarget()));
            }
            return method.invoke(aspectSupport.getTargetSource().getTarget(),args);
        }
    }


    private class CglibMethodInvocation implements MethodInvocation{
        private Object[] args;
        private Method method;
        private Object target;

        public CglibMethodInvocation(Object[] args, Method method, Object target) {
            this.args = args;
            this.method = method;
            this.target = target;
        }

        @Override
        public Object[] getArguments() {
            return args;
        }

        @Override
        public Object proceed() throws Throwable {
            return method.invoke(target,args);
        }

        @Override
        public Object getThis() {
            return target;
        }

        @Override
        public AccessibleObject getStaticPart() {
            return method;
        }

        @Override
        public Method getMethod() {
            return method;
        }
    }
}
  1. 切点接口（Pointcut）
/**
 * 切点
 */
public interface Pointcut {

    /**
     * 类匹配
     * @return
     */
    ClassFilter getClassFilter();

    /**
     * 方法匹配
     * @return
     */
    MethodMatcher getMethodMatcher();
  1. 类匹配接口

/**
 *
 * 通过配置的切点表达式进行类匹配
 */
public interface ClassFilter {
    /**
     * 是否匹配
     * @param clazz
     * @return
     */
    boolean matches(Class<?> clazz);
}

5.方法匹配接口

import java.lang.reflect.Method;

/**
 *
 * 通过配置的切点表达式进行方法匹配
 */
public interface MethodMatcher {
    /**
     * 是否匹配
     * @param method
     * @return
     */
    boolean matches(Method method);
}
  1. 切点，类匹配，方法匹配实现类
    注意: 切点表达式采用 aspectj 中的PointcutExpression实现
    通过PointcutParser(切点解析器)生成一个PointcutExpression 对象，通过这个对象实现方法和类的匹配功能。
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;

/**
 * 切点表达式具体实现
 * 这个类主要是通过配置的切点表达式实现类和方法的匹配功能
 */
public class AspectJExpressionPointcut implements Pointcut,ClassFilter,MethodMatcher{
    private static final Set<PointcutPrimitive> PRIMITIVES = new HashSet<>();
    static {
        PRIMITIVES.add(PointcutPrimitive.EXECUTION);
    }
    private final PointcutExpression pointcutExpression;
    public AspectJExpressionPointcut(String execution){
        PointcutParser parser = PointcutParser
                .getPointcutParserSupportingSpecifiedPrimitivesAndUsingContextClassloaderForResolution(PRIMITIVES);
        pointcutExpression = parser.parsePointcutExpression(execution);
    }

    @Override
    public boolean matches(Class<?> clazz) {
        return pointcutExpression.couldMatchJoinPointsInType(clazz);
    }

    @Override
    public boolean matches(Method method) {
        return pointcutExpression.matchesMethodExecution(method).alwaysMatches();
    }

    @Override
    public ClassFilter getClassFilter() {
        return this;
    }

    @Override
    public MethodMatcher getMethodMatcher() {
        return this;
    }
}

7.TargetSource(封装被代理对象)

/**
 * 封装被代理对象，
 * JDK 动态代理通过生成接口的实现类创建代理对象
 * Cglib通过生成类的子类实现代理对象的创建
 */
public class TargetSource {
    private Object target;

    public TargetSource(Object target) {
        this.target = target;
    }

    public Object getTarget(){
        return target;
    }

    public Class<?> targetClass(){
        return target.getClass();
    }

    public Class<?>[] targetInterfaces(){
        return target.getClass().getInterfaces();
    }
}

8.AspectSupport(切面支持类)

import org.aopalliance.intercept.MethodInterceptor;

/**
 * 切面支持
 * 封装 被代理对象
 * MethodInterceptor(方法拦截器，在方法拦截器中实现具体的代理逻辑)
 * MethodMatcher(方法匹配器)
 */
public class AspectSupport {
    private TargetSource targetSource;

    private MethodInterceptor methodInterceptor;

    private MethodMatcher methodMatcher;

    public AspectSupport(TargetSource targetSource, MethodInterceptor methodInterceptor, MethodMatcher methodMatcher) {
        this.targetSource = targetSource;
        this.methodInterceptor = methodInterceptor;
        this.methodMatcher = methodMatcher;
    }

    public TargetSource getTargetSource() {
        return targetSource;
    }

    public MethodInterceptor getMethodInterceptor() {
        return methodInterceptor;
    }

    public MethodMatcher getMethodMatcher() {
        return methodMatcher;
    }
}

9.测试类
UserService
UserServiceInterceptor
UserServiceImpl
Main

public interface UserService {
    String sayHello(String name);
}


public class UserServiceImpl implements UserService{
    @Override
    public String sayHello(String name) {
        System.out.println("hello -->" + name);
        return "hello -->" + name;
    }
}

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
	这里在切点处实现了具体的切面逻辑
*/
public class UserServiceInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            return invocation.proceed();
        }finally {
            long timeTakeUp = System.currentTimeMillis() - start;
            System.out.println("方法执行耗时-->" + timeTakeUp);
        }

    }
}

import aop.test.UserService;
import aop.test.UserServiceImpl;
import aop.test.UserServiceInterceptor;

public class Main {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        String execution = "execution(* aop.test.UserService.*(..))";
        AspectSupport aspectSupport = new AspectSupport(
                new TargetSource(userService),
                new UserServiceInterceptor(),
                new AspectJExpressionPointcut(execution)
        );
        //UserService instance = (UserService)new CglibProxy(aspectSupport).getInstance();
        UserService instance = (UserService)new JdkDynamicProxy(aspectSupport).getInstance();

        String result = instance.sayHello("夏天");
        System.out.println("result -- >" + result);
    }
}

在这里插入图片描述
从上面的结果可以看到，直接生成（new UserServuiceImpl）的UserService对象被代理对象代理了，并且在具体的切点处加入了切面逻辑。

夏夏夏红伟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JDK动态代理和Cglib动态代理实例源码
01-04
在Java编程领域，动态代理是一种强大的技术，它允许我们在运行时创建对象的代理，以便在调用实际...动态代理在AOP（面向切面编程）、缓存、日志记录、事务管理等多个场景中都有广泛应用，是Java开发中不可或缺的技术。
代理模式-静态动态代理-jdk动态代理-cglib动态代理
最新发布
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
Spring方法拦截器MethodInterceptor
热门推荐
淡淡的倔强的博客
05-12 3万+
前言实现MethodInterceptor 接口，在调用目标对象的方法时，就可以实现在调用方法之前、调用方法过程中、调用方法之后对其进行控制。MethodInterceptor 接口可以实现MethodBeforeAdvice接口、AfterReturningAdvice接口、ThrowsAdvice接口这三个接口能够所能够实现的功能，但是应该谨慎使用MethodInterceptor 接口，很可能
JDK和CGLIB动态代理的简单使用和底层分析
m0_56642345的博客
11-30 301
JDK通过实现接口进行代理，Cglib通过继承类进行代理，Cglib 在类的生成阶段所做的操作会相对耗时，且生成的类的数目较多，会占据大量的元空间的内存（永久代）。但是，被代理类的子类一旦生成，之后的方法调用则变成搜索方法索引和直接调用，则在 switch-case 块不大，且当前调用方法的 index 在 switch-case 块的前部时，能够获得比 JDK 反射更高的效率。
动态代理 cglib MethodInterceptor
10-14 475
动态代理 cglib MethodInterceptor cglib实现动态代理的步骤简单描述
MethodInterceptor
Crush_kylin的博客
12-13 1362
文章目录1、Filter、HandlerInterceptor和MethodInterceptor的区别2、MethodInterceptor+自定义注解实例 1、Filter、HandlerInterceptor和MethodInterceptor的区别 在Web开发中，我们经常会用到拦截器。而常用用于实现拦截的有：Filter、HandlerInterceptor、MethodInterceptor。我们也简单了解一下他们的区别： 1、Filter是Servlet规范规定的，不属于spring框架，也是
CGLIB动态代理 -- MethodInterceptor、整体过程分析
剁椒咸鱼
03-28 1400
使用ASM字节码生成框架，生成目标类的子类作为代理类，其中有MethodInterceptor 类型的成员变量， 在静态方法中，有通过反射获取目标类方法，并通过MethodProxy.create(xxx)创建代理方法，如下下图： Class var1 = Class.forName("com.example.springsourcestudy.proxy.MessageServer")Class var0 =Class.forName("com.example.springsour..
基于MAVEN项目的CGLib动态代理原理及实现
01-15
它广泛用于许多AOP(面向切面编程)框架，如Spring AOP和dynaop，作为JDK动态代理的替代品，当目标类不支持接口时，CGLib能发挥重要作用。 3. CGLib工作原理 CGLib通过继承的方式创建代理对象。它会生成一个目标类的...
java动态代理(JDK和cglib)共10页.pdf.zip
10-28
Java动态代理是Java编程中一个重要的特性，它允许我们在运行时创建代理类，这些代理类可以作为原有类的增强，通常用于实现AOP（面向切面编程）或为已有对象提供额外的服务。在这个主题中，我们将深入探讨JDK动态代理...
动态代理-jdk、cglib、javassist.zip
05-19
总结来说，JDK动态代理适合处理实现了接口的对象，CGLIB适用于没有接口或者对性能要求较高的情况，而javassist提供了更灵活的字节码操作，适用于更复杂的场景。理解并掌握这三种动态代理技术，对于提升Java编程的...
spring拦截器Interceptor:HandlerInterceptor和MethodInterceptor
meser88的博客
08-12 1484
在Spring Boot中，拦截器可以分为两种类型： 一是WebMVC，负责拦截请求，类似于过滤器，对用户的请求在Controller接收前进行处理，在Controller处理完成后加工结果等。使用时需实现HandlerInterceptor接口。 一是AOP，拦截指定类型的方法，通过动态代理模式实现，可以在方法的调用前和调用后添加功能处理。使用时需要实现MethodInterceptor接口。 拦截器（Interceptor）和过滤器（Filter）对比 相同点： 都可以对请求进行提前处理和响
Spring 之 AOP 原理详解
20年码农
04-14 2069
AOP是一种编程范式，用于在不修改原始代码的情况下向现有应用程序添加新功能。这种编程方式将应用程序分成许多独立的部分，称为切面。这些切面可以在应用程序的不同位置进行编写和维护，从而提高了应用程序的可重用性和可维护性。AOP主要用于实现横切关注点（Cross-Cutting Concerns），例如日志记录、性能监测、事务管理等。通过AOP，我们可以将这些关注点与应用程序的其他部分分离开来，从而使应用程序更加模块化和易于维护。
Spring中方法拦截器
x2656271356的博客
10-23 256
Spring中方法拦截器
CGLIB实现AOP，MethodInterceptor接口和Enhancer详解——Spring AOP（四）
方圆几里
10-26 6373
上一章讲到了使用JDK的Proxy实现AOP： https://blog.csdn.net/qq_34598667/article/details/83380628 这一章我们讲另外一种方式，使用CGLIB实现AOP 使用CGLIB实现AOP功能 上一章我们已经说过，要产生某个对象的代理对象，这个对象必须实现一个接口，动态代理技术只能基于接口进行代理。 可是有时候我们在开发时碰到一些对象没有接口...
CGLIB动态代理底层实现原理
wajueji的博客
03-28 605
一、前言 最近在探究Spring AOP的性能，发现最后是绕不开JDK动态代理和CGLIB动态代理这两个点。笔者心里大致有这么个概念：对于动态代理来说，CGLIB性能要好于JDK。也知道CGLIB是利用ASM技术基于继承子类实现动态代理，JDK是基于实现接口实现动态代理，但是对于底层实现还是比较模糊。今天就彻底整明白CGLIB动态代理的底层实现。二、前置准备(一)测试代码CGLIB核心的几个概念...
实战CGLib系列文章 MethodInterceptor和Enhancer
jackyechina的专栏
11-08 4710
实战CGLib系列文章 本篇介绍通过MethodInterceptor和Enhancer实现一个动态代理。 一、首先说一下JDK中的动态代理： JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的，不了解的同学请参考我的这篇Blog：Java动态代理详解 http://shensy.iteye.com/blog/1698197  但是
JDK动态代理实现切面Logger
weixin_44825085的博客
01-26 629
JDK动态代理完成日志添加 JDK动态代理是通过java.lang.reflect包下的工具类实现的 1、编写接口 编写calculator接口 package cn.dynamic.proxy.logger; public interface Calculator { // 定义四则运算 public Integer add(int i,int j); public Integer sub(int i,int j); public Integer mult(int
Spring AOP小记
weixin_30588675的博客
08-13 61
AOP 1.aop是spring框架的核心概念之一,用于对类的方法进行增强,分为静态增强和动态增强. 　　基本概念 动态增强是基于jdk自身的动态代理和cglib动态代理. 目标对象 -->target 需要增强的目标对象 (目标类) 切点 -->pointCut 目标类中的方法(method),当切点是实现了父接口中的方法时,使用java的动态代理,当方法不属于接口时,...
Spring的动态代理开发.docx
01-21
Spring的动态代理开发.docx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值