细说之前博客--手写简单AOP

最新推荐文章于 2023-10-21 16:51:39 发布
最新推荐文章于 2023-10-21 16:51:39 发布
阅读量95 收藏
点赞数 1
分类专栏： Spring java 文章标签： aop spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43110503/article/details/119811984
版权

目录

是什么时AOP

aop在我的理解的就是干动态代理，方法增加的。专业一点就是面向切面编程！！
我们实现aop选择spring实现aspectJ aop框架，说白了就是那几个注解：pointCut,before,after,afterthrowing,ascept
不过实现之前还是先了解一下aop的相关概论：

  • pointCut：切入点，可以理解要增强的具体方法
  • advice：通知 ，就是要增加的具体逻辑，比如前置通知before注解啊，就是在切入点执行之前执行你要执行的逻辑就行了
  • aspect： 切面，嗯，，这个我也不是很懂，大概就是切入点和avice通知和在一起，这个类叫切面吧，代码是这样表现的。

实现aop的具体思路

  1. 之前ioc文章里讲过，我们先后初始化BeanDefinition对象，在BeanDefinition对象里面定义一个属性判断是否是切面
  2. 初始化aop，遍历BeanDefinition，如果是，则将pointcut，before等注解解析成GPAopConfig对象
  3. 然后在getBean方法里面，class.newInstance();之后判断是否需要动态代理，就是class是否有切入点
  4. 如果有就利用动态代理（jdk，cglib）返回一个代理后的对象，后面的属性赋值什么的都对代理对象进行

相关类及其作用

  • GPAopConfig：相当于一个切面，储蓄切面的信息
    GPAopConfig
    这个我要说一下，我能力不够，无法解析pointCui对应的表达式，于是想出了给pointCut注解3个属性，分别是package，class，methon，这样我就可以定位到是否要被代理

  • GPAdvice：通知对象，里面有切面和要加强的方法
    GPAdvice

  • GPAdviceSupport： 这个是个很重要的类，里面有methodCache对象（存放所有被增强方法及相对应的通知和切面（GPAdvice对象））

在这里插入图片描述
这个map的key是要被加强的方法，value是个map1，map1就是前置后置啊啥的，map1的key是before，after这种，value就是具体的通知，还是个list，通知有个order是排序用的。

具体思路代码

  1. 初始化：
/**
     * 初始化aop容器
     */
    public void initAspect() {
        ConcurrentHashMap<String, BeanDefinition> beanDefinitions = BeanFactory.getBeanDefinitions();

        List<GPAopConfig> configs = new ArrayList<>();
        beanDefinitions.forEach((beanName, beanDefinition) -> {
            if (beanDefinition.isAspect()) {
                Class clazz = beanDefinition.getClazz();
                GPAopConfig aopConfig = new GPAopConfig();
                if (clazz.isAnnotationPresent(Order.class)) {
                    aopConfig.setOrder(((Order) clazz.getDeclaredAnnotation(Order.class)).value());
                } else {
                    aopConfig.setOrder(1);
                }
                Method[] declaredMethods = clazz.getDeclaredMethods();
                for (Method declaredMethod : declaredMethods) {

                    String methodString = declaredMethod.getName();
                    if ("wait".equals(methodString) || "equals".equals(methodString) || "toString".equals(methodString) ||
                            "hashCode".equals(methodString) || "getClass".equals(methodString) || "notify".equals(methodString) ||
                            "notifyAll".equals(methodString)) {
                        continue;
                    }
                    aopConfig.setAspectClass(clazz.getName());
                    try {
                        if (declaredMethod.isAnnotationPresent(PointCut.class)) {
                            PointCut annotation = declaredMethod.getAnnotation(PointCut.class);
                            aopConfig.setPointCut_class(annotation.class_name());
                            aopConfig.setPointCut_package(annotation.package_name());
                            aopConfig.setPointCut_method(annotation.method_name());
                        }
                        if (declaredMethod.isAnnotationPresent(Before.class)) {
                            aopConfig.setAspectBefore(declaredMethod.getName());
                        }
                        if (declaredMethod.isAnnotationPresent(After.class)) {
                            aopConfig.setAspectAfter(declaredMethod.getName());
                        }
                        if (declaredMethod.isAnnotationPresent(AfterThrowing.class)) {
                            aopConfig.setAfterThrowing(declaredMethod.getName());
                        }
                        if (declaredMethod.isAnnotationPresent(AfterReturning.class)) {
                            aopConfig.setAfterReturning(declaredMethod.getName());
                        }
                        if (declaredMethod.isAnnotationPresent(Around.class)) {
                            aopConfig.setAround(declaredMethod.getName());
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
                configs.add(aopConfig);
            }
        });
        AopFactory.setConfigs(configs);

    }
  1. 判断是否需要初始化，如果需要的话将要被加强的mehon放methodCache中
    判断是否需要代理：
GPAdviceSupport config = new GPAdviceSupport();
        config.setTargetClass(clazz);
        config.setTarget(newInstance);
        if (config.pointCutMatch()) {
            try {
                newInstance = new CglibDynamicAopProxy(config).getProxy();
            } catch (Exception e) {
                newInstance = new GPJDKDynamicAopProxy(config).getProxy();
            }

        }
        Object finalNewInstance1 = newInstance;

这里是逻辑：，，我把整个类都贴出来吧，不太好说，，

package it.yuzuojian.com.aop;


import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GPAdviceSupport {
    private Class targetClass;
    private Object target;
    private Map<Method, Map<String, List<GPAdvice>>> methodCache = new HashMap<>();
    private boolean check = false;


    public boolean pointCutMatch() {

        return check;
    }

    public void parse() {
        List<GPAopConfig> configs = AopFactory.getConfigs();
        configs.forEach((config) -> {
            String pointCut_package = config.getPointCut_package();
            if (targetClass.getPackage().getName().contains(pointCut_package)) {
                String[] pointCut_class = config.getPointCut_class();
                String[] pointCut_method = config.getPointCut_method();
                Map<String, Method> aspectMethods = new HashMap<>();
                Class aspectClass = null;
                try {
                    aspectClass = Class.forName(config.getAspectClass());
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                for (Method declaredMethod : aspectClass.getDeclaredMethods()) {
                    aspectMethods.put(declaredMethod.getName(), declaredMethod);
                }
                if (pointCut_class[0].equals("") && pointCut_method[0].equals("")) {
                    if (!check) {
                        check = true;
                    }
                    init(config, aspectClass, aspectMethods);
                } else if (!pointCut_class[0].equals("") && pointCut_method[0].equals("")) {
                    if (targetClass.getSimpleName().equals(pointCut_class)) {
                        if (!check) {
                            check = true;
                        }
                        init(config, aspectClass, aspectMethods);
                    }
                } else if (pointCut_class[0].equals("") && !pointCut_method[0].equals("")) {
                    init(config, aspectClass, aspectMethods, pointCut_method);

                } else {
                    if (!check) {
                        check = true;
                    }
                    init(config, aspectClass, aspectMethods, pointCut_class, pointCut_method);
                }
            }
        });


    }

    public void init(GPAopConfig config, Class aspectClass, Map<String, Method> aspectMethods) {
        for (Method declaredMethod : this.targetClass.getDeclaredMethods()) {
            String methodString = declaredMethod.getName();
            if ("wait".equals(methodString) || "equals".equals(methodString) || "toString".equals(methodString) ||
                    "hashCode".equals(methodString) || "getClass".equals(methodString) || "notify".equals(methodString) ||
                    "notifyAll".equals(methodString)) {
                continue;
            }
            Map<String, List<GPAdvice>> advices = methodCache.get(declaredMethod);
            if (advices == null || advices.size() == 0) {
                advices = new HashMap<>();
            }
            try {
                if (!(null == config.getAspectBefore() || "".equals(config.getAspectBefore()))) {
                    List<GPAdvice> before = advices.get("before");
                    if (before == null || before.size() == 0) {
                        before = new ArrayList<>();
                    }
                    before.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectBefore()), config.getOrder()));
                    advices.put("before", before);
                }
                if (!(null == config.getAspectAfter() || "".equals(config.getAspectAfter()))) {
                    List<GPAdvice> after = advices.get("after");
                    if (after == null || after.size() == 0) {
                        after = new ArrayList<>();
                    }
                    after.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectAfter()), config.getOrder()));
                    advices.put("after", after);
                }
                if (!(null == config.getAfterThrowing() || "".equals(config.getAfterThrowing()))) {
                    List<GPAdvice> afterThrowing = advices.get("afterThrowing");
                    if (afterThrowing == null || afterThrowing.size() == 0) {
                        afterThrowing = new ArrayList<>();
                    }
                    GPAdvice gpAdvice = new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAfterThrowing()), config.getOrder());
                    afterThrowing.add(gpAdvice);
                    advices.put("afterThrowing", afterThrowing);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            methodCache.put(declaredMethod, advices);

        }
    }

    public void init(GPAopConfig config, Class aspectClass, Map<String, Method> aspectMethods, String[] pointCut_method) {
        for (Method declaredMethod : this.targetClass.getDeclaredMethods()) {
            String methodString = declaredMethod.getName();
            if ("wait".equals(methodString) || "equals".equals(methodString) || "toString".equals(methodString) ||
                    "hashCode".equals(methodString) || "getClass".equals(methodString) || "notify".equals(methodString) ||
                    "notifyAll".equals(methodString)) {
                continue;
            }
            if (methodString.contains("throws")) {
                methodString = methodString.substring(0, methodString.lastIndexOf("throws")).trim();
            }
            if (check(pointCut_method,methodString)) {
                if (!check) {
                    check = true;
                }
                Map<String, List<GPAdvice>> advices = methodCache.get(declaredMethod);
                if (advices == null || advices.size() == 0) {
                    advices = new HashMap<>();
                }
                try {
                    if (!(null == config.getAspectBefore() || "".equals(config.getAspectBefore()))) {
                        List<GPAdvice> before = advices.get("before");
                        if (before == null || before.size() == 0) {
                            before = new ArrayList<>();
                        }
                        before.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectBefore()), config.getOrder()));
                        advices.put("before", before);
                    }
                    if (!(null == config.getAspectAfter() || "".equals(config.getAspectAfter()))) {
                        List<GPAdvice> after = advices.get("after");
                        if (after == null || after.size() == 0) {
                            after = new ArrayList<>();
                        }
                        after.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectAfter()), config.getOrder()));
                        advices.put("after", after);
                    }
                    if (!(null == config.getAfterThrowing() || "".equals(config.getAfterThrowing()))) {
                        List<GPAdvice> afterThrowing = advices.get("afterThrowing");
                        if (afterThrowing == null || afterThrowing.size() == 0) {
                            afterThrowing = new ArrayList<>();
                        }
                        GPAdvice gpAdvice = new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAfterThrowing()), config.getOrder());
                        afterThrowing.add(gpAdvice);
                        advices.put("afterThrowing", afterThrowing);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                methodCache.put(declaredMethod, advices);
            }

        }
    }
    public boolean check(String[] arr,String name){
        for (String s : arr) {
            if(s.equals(name)){
                return true;
            }
        }

        return false;
    }


    public void init(GPAopConfig config, Class aspectClass, Map<String, Method> aspectMethods, String pointCut_class[], String pointCut_method[]) {
        if (check(pointCut_class, targetClass.getSimpleName())) {
            for (Method declaredMethod : this.targetClass.getDeclaredMethods()) {
                String methodString = declaredMethod.getName();
                if ("wait".equals(methodString) || "equals".equals(methodString) || "toString".equals(methodString) ||
                        "hashCode".equals(methodString) || "getClass".equals(methodString) || "notify".equals(methodString) ||
                        "notifyAll".equals(methodString)) {
                    continue;
                }
                if (methodString.contains("throws")) {
                    methodString = methodString.substring(0, methodString.lastIndexOf("throws")).trim();
                }
                if (check(pointCut_method, methodString)) {
                    if (!check) {
                        check = true;
                    }
                    Map<String, List<GPAdvice>> advices = methodCache.get(declaredMethod);
                    if (advices == null || advices.size() == 0) {
                        advices = new HashMap<>();
                    }
                    try {
                        if (!(null == config.getAspectBefore() || "".equals(config.getAspectBefore()))) {
                            List<GPAdvice> before = advices.get("before");
                            if (before == null || before.size() == 0) {
                                before = new ArrayList<>();
                            }
                            before.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectBefore()), config.getOrder()));
                            advices.put("before", before);
                        }
                        if (!(null == config.getAspectAfter() || "".equals(config.getAspectAfter()))) {
                            List<GPAdvice> after = advices.get("after");
                            if (after == null || after.size() == 0) {
                                after = new ArrayList<>();
                            }
                            after.add(new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAspectAfter()), config.getOrder()));
                            advices.put("after", after);
                        }
                        if (!(null == config.getAfterThrowing() || "".equals(config.getAfterThrowing()))) {
                            List<GPAdvice> afterThrowing = advices.get("afterThrowing");
                            if (afterThrowing == null || afterThrowing.size() == 0) {
                                afterThrowing = new ArrayList<>();
                            }
                            GPAdvice gpAdvice = new GPAdvice(aspectClass.newInstance(), aspectMethods.get(config.getAfterThrowing()), config.getOrder());
                            afterThrowing.add(gpAdvice);
                            advices.put("afterThrowing", afterThrowing);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    methodCache.put(declaredMethod, advices);
                }

            }
        }

    }

    public Map<String, List<GPAdvice>> getAdvices(Method method, Class targetClass) throws NoSuchMethodException {
        Map<String, List<GPAdvice>> adviceMap = methodCache.get(method);
        if (null == adviceMap) {
            Method declaredMethod = targetClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
            adviceMap = methodCache.get(declaredMethod);
            this.methodCache.put(declaredMethod, adviceMap);
        }
        return adviceMap;
    }

    public Class getTargetClass() {
        return targetClass;
    }

    public void setTargetClass(Class targetClass) {
        this.targetClass = targetClass;
        parse();
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }


}
  1. 最后就是动态代理了，这个没啥好说的，前面都把对象放入methonCache中了，获取在进行代理就好了，有个排序要注意一下，更具order排序嘛，before跟after要是反的哦，因为是链式的嘛
 public static Object getProxy(GPAdviceSupport config, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Map<String, List<GPAdvice>> adviceMap=config.getAdvices(method,config.getTargetClass());
        Object result=null;
        try {

            List<GPAdvice> befores = adviceMap.get("before");
            befores.sort(new Comparator<GPAdvice>() {
                @Override
                public int compare(GPAdvice o1, GPAdvice o2) {
                    return o1.getOrder()- o2.getOrder();
                }
            });
            for (GPAdvice before : befores) {
                before.getAdviceMethod().invoke(before.getAspect());
            }
            result=method.invoke(config.getTarget(),args);
            List<GPAdvice> afters = adviceMap.get("after");
            afters.sort(new Comparator<GPAdvice>() {
                @Override
                public int compare(GPAdvice o1, GPAdvice o2) {
                    return o2.getOrder()- o1.getOrder();
                }
            });
            for (GPAdvice after : afters) {
                after.getAdviceMethod().invoke(after.getAspect());
            }
        } catch (Exception e) {
            e.printStackTrace();
            List<GPAdvice> afterThrowings = adviceMap.get("afterThrowing");
            afterThrowings.sort(new Comparator<GPAdvice>() {
                @Override
                public int compare(GPAdvice o1, GPAdvice o2) {
                    return o2.getOrder()- o1.getOrder();
                }
            });
            for (GPAdvice afterThrowing : afterThrowings) {
                afterThrowing.getAdviceMethod().invoke(afterThrowing.getAspect());
            }
        }
        return result;
    }

相关事项

我这里实现的也有很多的不足：

  1. pointCut不会解析表示式，用了3个属性去代替
  2. 没有用实现around注解
  3. 比较重要的一点就是我这实现逻辑是一个切面定义一个切入点，这个切面的所有的通知都是只针对这个一个切入点说的，没有实现跟spring一样，一个切面可以有很多个pointCut，方法上可以同时加上pointcut注解和before注解这样，不过想想也不是很难呀，是不是可以针对befor，after这种加上几个map，然后被代理的方法去跟这些map匹配，有兴趣的可以去试一下。

本人目前刚刚毕业，写的不好，逻辑不对或表达不够清楚的可以一起说说，不要喷我就好了，，，源码地址在之前的博客有写！！

一切都是一场空
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-aop-6.0.11.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
spring-aop-6.0.10.jar
最新发布
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
手写简易AOP，彻底悟懂AOP
qq_63815371的博客
11-10 575
AOP 意为：面向切面编程，通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续，在 Spring 框架中是一个非常重要的内容，使用 AOP 可以对业务逻辑的各个部分进行隔离，从而使各模块间的业务逻辑耦合度降低，提高代码的可复用性，同时也能提高开发效率。
手写Aop
Trygoto的博客
02-25 907
手写简单Aop,展示aop设计思路和基础原理 提示：本文章适合有一定java反射基础的程序员，博主还是个新手新手超新手，欢迎指正！！！本文是参考Java 编程逻辑一书… 文章目录手写简单Aop,展示aop设计思路和基础原理Aop 简介：一、Aop 的基础原理是动态代理，动态代理又有哪些呢？二、手写Aop实例1.创建自定义注解2.创建切面类 Aop 简介： 简介百度一大堆，这里简单说下博主自己的理解，Aop其实就是用来解决成品系统中添加辅助功能的一种方式。当你的系统所有功能都完成了，你调试 的时候发现没有
手写Spring框架---AOP实现
汤键的博客
06-18 673
手写Spring框架---AOP实现
第三篇：Spring源码篇-手写篇-手写AOP
yqqの博客
03-18 219
手写IoC和DI后已经实现的类图结构。
第七篇 - 手写Aop(面向切面编程)
蓝星花
10-21 927
Github源码下载地址：https://github.com/chenxingxing6/sourcecode/tree/master/code-springaop 一、前言 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Sprin...
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-6.0.8.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
spring-aop-6.0.0.jar
04-22
spring-aop.jar 各个版本，免费下载 Spring 的面向切面编程，提供 AOP（面向切面编程）的实现。 如果下载不了，关注我，评论区联系我。
自己动手写的一个简单AOP小工具,开放了源代码,附带示例代码
05-03
如果对这个有兴趣的话，可以看我的博客 :http://blog.csdn.net/neusoftware_20063500
【框架源码篇 03】Spring源码手写篇-手写AOP
studyday1的博客
10-21 204
手写IoC和DI后已经实现的类图结构。
AOP切面前置后置环绕通知的讲解和运用之手写切面+详解
槐序二十四的博客
10-28 4831
首先让我们先说一下切面需要我们关注哪些地方(组成部分), 1.切面点表达式[pointcut]:指定类的指定方法(就是为了定位指定类的指定方法) 2.方位:定义在指定方法的前,后,抛出异常,等等 3.执行横切业务逻辑:公共部分的代码, 注:那什么是公共部分的代码？如:日志记录,性能统计,安全控制,事务处理等方面 4.通知[advice] : 包涵方位,横切业务逻辑 5.连接点[Join...
【03】Spring源码-手写篇-手写AOP实现(上)
波波烤鸭的博客
09-06 801
Spring源码手写篇-AOP 上
手写AOP框架
yshjvc的博客
06-06 206
业务和切面紧耦合在一起，没有拆分 第二个版本 使用子类代理的方式拆分业务和切面 第三个版本 使用静态代理拆分业务和切面。业务和业务接口已拆分，此时切面紧耦合在业务中 第四个版本 使用静态代理拆分业务和业务接口，切面和切面接口 第五个版本 使用动态代理完成第四个版本的优化 对Service接口进行修改 对BookServiceImpl实现类进行修改 新建java类，进行动态代理 修改主方法...
手写AOP实现过程
weixin_45032957的博客
08-14 302
三.手写aop主要实现过程 1.定义配置标记 @Aspect：配置标记横切对象（方法）的地址 @Order：配置标记横切的顺序 @Aspect/@Order Copy @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Aspect { String pointcut(); } Copy @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNT
手把手教你手写Spring框架(附源码)
10-17
  Java框架一直以来都是面试必备的知识点，而学习Java框架，不管在成熟的大公司，快速发展的公司，还是创业阶段的公司，都能对当前正在开发中的系统有整体的认知，从而更好的熟悉和学习技术。 本教程以项目实战为导向，帮助广大学员手把手教学，本课程从无到有，循序渐进的手写mvc框架，由于官方的框架比较复杂，为了让同学们能够学懂，先从简单地IOC框架入手，然后不断地升级和迭代，逐渐成为官方比较接近的Spring框架。希望同学们通过我的课程学习，能成为自己手动编写框架的高手，深化框架的使用，同时积累一定的代码量，在公司成为顶梁柱。 项目工程截图:    
SpringAop底层源码剖析详解
09-24
本次课程将带领大家深入剖析SPring的AOP原理，让大家了解底源码底层是怎么样允许的，带领大家手写SpringAOP底层调用链进行实战练习，详细看完本次课程的同学都会对AOP的理解度达到新的程度。还是那句老话，对视频里面讲解的知识点要是有不懂的记得联系我，私信我都行的
手写 简单 aop 框架
渐行渐远 的博客
04-18 2432
cglib 手写 简单 aop 框架，实现方法级别的拦截 cglib 手写 简单 aop 框架，实现方法级别的拦截 0 缘起 1 思路 2 使用 Step 1: 定义被代理的实体类 Step 2: 定义切点和切面， 并且继承 AbsMethodAdvance Step 3: 测试 3 核心代码 3.1 ApplicationContext 3.2 AbsMethodAdvance 4...
spring-aop-4.3.4jar包
11-19
spring-aop-4.3.4.jar包提供了一个简单而强大的AOP框架，使开发者可以更方便地实现面向切面编程。 在使用spring-aop-4.3.4.jar包时，我们可以使用注解或XML配置来定义切面（Aspect）和通知（Advice），并将它们织入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值