Spring的AOP

最新推荐文章于 2025-11-23 15:08:04 发布
原创 最新推荐文章于 2025-11-23 15:08:04 发布 · 655 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java

AOP相关简介 

AOP：预编译，在运行期执行的。

动态代理是在不修改源码的情况下，对代码进行相应的增强。可以完成程序功能上松耦合。

AOP和动态代理功能差不多，且不要自己写动态代理的代码了。

AOP松耦合，抽取功能，减少重复代码，提高开发效率，且便于维护。

Spring采用动态代理技术。AspectJ采用编译器植入和类装载期织入。

AOP底层：spring集成了jdk代理技术和gclib代理技术。

jdk代理：目标对象基于目标接口生成代理对象放入运行时的内存中。

cglib代理：为目标对象动态生成子对象，但这个子对象比父对象功能更强大，不是继承是动态生成基于目标对象的对象，放入运行时内存中。

在Spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式(jdk\cglib)。

 AOP相关术语

Target(目标对象：代理的目标对象

Proxy(代理)：一个类被AOP织入增强后，禅城一个结果代理类

JoinPoint(连接点)：被拦截到的点(方法)。可以被增强的方法叫做连接点。

Pointcut(切入点)：即我们要对哪些JoinPoint进行拦截。

注：切入点是真正被增强的方法，被选中增强的连接点才是切入点。连接点和切入点的关系就像公民和人大代表一样。

Advice(通知/增强)：即拦截到JoinPoint后要做的事情。即用于增强功能额外功能的代码。

Aspect(切面)：切入点和通知的结合。切面=目标方法+增强方法。

Weaving(织入)：把增强用于目标对象来创建新的代理对象的过程。织入是个动词，可以理解为切点和增强(通知)结合的过程就是织入。

AOP技术实现内容

 Spring框架监控切入点方法的执行，一旦监控到切入点方法被运行，则使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

举例

比如日志控制

传统的抽取日志控制代码：在业务方法中还需要引用如save(user)、update(user)之类调用抽取出来的日志控制代码，还是出现耦合。

使用AOP：

将业务方法作为切入点，将日志控制代码作为增强，通过对业务方法使用配置文件或注解，使得在运行业务方法(切点)前，通过spring动态代理技术对切点进行增强的织入，基于目标对象生成代理对象。运行时代理对象的根据增强类型先后，调用增强代码和目标对象的切点方法即可。这样，目标方法和日志控制完全解耦，仅在运行时结合在一起。

快速入门

基于jdk的动态代理

创建一个mavenWeb项目(cglib需要web环境)。
 com.kdy.proxy.jdk包中创建TargetInterface目标类接口
public interface TargetInterface {
    public void save();
}
com.kdy.proxy.jdk包中创建Target（目标类接口实现类）实现TargetInterface接口
public class Target implements TargetInterface {
    @Override
    public void save() {
        System.out.println("save running...");
    }
}
 com.kdy.proxy.jdk包中创建Advice增强类
public class Advice {
    //前置增强
    public void before(){
        System.out.println("before...");
    }
    //后置增强
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
}
 com.kdy.proxy.jdk包中创建测试类ProxyTest
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();
        //基于目标对象动态生成代理对象：返回值 就是动态生成的代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//目标对象类加载器
                target.getClass().getInterfaces(),//目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        advice.before();//前置增强
                        Object invoke = method.invoke(target, args);//执行目标方法
                        advice.afterReturning();//后置增强
                        return invoke;
                    }
                }
        );
        proxy.save();
    }
}
运行main方法即可。

基于cglib的动态代理

上面项目pom我呢见引入spring依赖(spring依赖中包含cglib包)
        <dependency><!--spring依赖包含cglib包-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
com.kdy.proxy.jdk包中创建Target（目标类）
public class Target {
    public void save(){
        System.out.println("save running......");
    }
}
 com.kdy.proxy.jdk包中创建Advice增强类
public class Advice {
    //前置增强
    public void before(){
        System.out.println("before...");
    }
    //后置增强
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
}
 com.kdy.proxy.jdk包中创建测试类ProxyTest
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //增强对象
        final Advice advice = new Advice();

        //返回值 就是动态生成的代理对象、基于cglib
        //1、创建增强器
        Enhancer enhancer = new Enhancer();
        //2、设置父类（目标）
        enhancer.setSuperclass(Target.class);
        //3、设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();//执行前置
                Object invoke = method.invoke(target, args);//执行目标
                advice.afterReturning();//执行后置
                return invoke;
            }
        });
        //创建代理对象
        Target proxy = (Target)enhancer.create();

        proxy.save();
    }
}
运行main方法即可。

面向切面编程-AOP开发 

基于XML的AOP开发

快速入门

创建mavenWeb项目
引入spring、aspectJ、junit、spring-test依赖
 <dependencies>
        <dependency><!--spring依赖包含cglib包-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>
在com.kdy.aop包中创建TargetInterface接口和Target目标类
public class Target implements TargetInterface{
    public void  save(){
        System.out.println("save running...");
//        int i =  1/0;//异常抛出
    }
}
在com.kdy.aop包中创建MyAspect切面类
public class MyAspect {
    //前置增强
    public void before() {
        System.out.println("before...");
    }
    //后置增强
    public void afterReturning() {
        System.out.println("afterReturning...");
    }
    //环绕增强
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before around...");//环绕前增强
        Object proceed = pjp.proceed();//切点方法
        System.out.println("after around...");//环绕后
        // 增强
        return proceed;
    }
    //异常抛出增强
    public void afterThrowing() {
        System.out.println("afterThrowing...");
    }
    //最终增强
    public void after() {
        System.out.println("after...");
    }
}
resource下applicationContext配置文件创建目标类的bena和切面类的bean，并配置织入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--目标对象-->
    <bean id="target" class="com.kdy.aop.Target"></bean>
    <!--切面对象-->
    <bean id="myAspect" class="com.kdy.aop.MyAspect"></bean>
    <!--配置织入：告诉spring框架 哪些方法(切点)需要进行哪些增强(前置、后置...)-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面：切点+通知--><!--method="before"表示增强/通知，aop:before表示需要前置增强操作
            pointcut="execution(public void com.kdy.aop.Target.save())为切点，execution为切点表达式-->
       <!--     <aop:before method="before" pointcut="execution(public void com.kdy.aop.Target.save())"/>-->
            <aop:before method="before" pointcut="execution(* com.kdy.aop.*.*(..))"/>
            <aop:after-returning method="afterReturning" pointcut="execution(* com.kdy.aop.*.*(..))"/>
            <aop:around method="around" pointcut="execution(* com.kdy.aop.*.*(..))"/>
            <aop:after-throwing method="afterThrowing" pointcut="execution(* com.kdy.aop.*.*(..))"/>
            <aop:after method="after" pointcut="execution(* com.kdy.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

切点表达式：

execution([修饰符] 返回值类型 包名.类名.方法名(参数)) 

修饰符可省略，返回值类型、包名、类名、方法名可用*代表任意

包名和类名之间一个点代表当前包下的类，两个点..代表当前包及其子包下的类

参数列表可使用两个点..表示任意个数，任意类型的参数列表

xml中的切点表达式除了写全，还可简写举例如下：

execution(void com.kdy.aop.Target.*(..))      execution(* com.kdy.aop.*.*(..))

execution(* com.kdy.aop..*.*(..))  execution(* com.kdy.aop.*.*(..))  execution(* *..*.*(..))

一般常用   execution(* com.kdy.aop.*.*(..))

通知类型：

前置通知：<aop:before>  用于配置前置通知。指定增强的方法在切入点方法之前执行。
后置通知：<aop:after-returning>配置后置通知。指定增强的方法在切入点方法之后执行。
环绕通知：< aop:around>用于环绕通知。指定增强的方法在切入点方法之前和之后都执行。
异常抛出通知：<aop:throwing>配置异常抛出通知。指定增强的方法在出现异常时执行。
最终通知：<aop:after>用于配置最终通知。无论增强方式执行是否有异常都会执行。

在test目录中写测试类，注入目标类，直接调用目标类的方法，运行测试用例即可
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    /*
    * 注：这里要注入接口TargetInterface，因为xml中声明的是Target实现类的bean，但经过织入生成代理对象的bean是最终要注入进来的
    * 因为Target有接口所以spring基于jdk来动态代理生成代理对象，这个代理对象也是TargetInterface接口类型的，
    * 所以spring生命周期中最终通过TargetInterface注入时找到的是动态代理对象的bean，将其注入进来
    * */
    @Autowired
    private TargetInterface target;

    @Test
    public void test1(){
        target.save();
    }
}

注：@Autowired注入的类型为接口，就是考虑到spring中aop，虽然类型为实现类也行，但aop的时候必须注入类型为接口，所以通常平时都注入接口类型。若某个注入接口有多实现类，可用配合@Qualify或直接用@Resource。

执行顺序增强类型都是相对切点方法的先后属顺序。

applicationContext.xml织入中抽取切点表达式的写法为：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--目标对象-->
    <bean id="target" class="com.kdy.aop.Target"></bean>
    <!--切面对象-->
    <bean id="myAspect" class="com.kdy.aop.MyAspect"></bean>
    <!--配置织入：告诉spring框架 哪些方法(切点)需要进行哪些增强(前置、后置...)-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--抽取切点表达式-->
            <aop:pointcut id="myPoint" expression="execution(* com.kdy.aop.*.*(..))"/>
            <aop:before method="before" pointcut-ref="myPoint"/>
            <aop:after-returning method="afterReturning" pointcut-ref="myPoint"/>
            <aop:around method="around" pointcut-ref="myPoint"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="myPoint"/>
            <aop:after method="after" pointcut-ref="myPoint"/>
        </aop:aspect>
    </aop:config>
</beans>

基于注解的AOP开发

快速入门

mavenWeb项目，pom文件引入spring、aspectJ、junit、spring-test依赖
 <dependencies>
        <dependency><!--spring依赖包含cglib包-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
    </dependencies>
在com.kdy.anoo包中创建Target目标类实现目标类接口TargetInterface，并使用spring注解声明bean。
@Component("target")
public class Target implements TargetInterface {
    public void  save(){
        System.out.println("save running...");
//        int i =  1/0;//异常抛出
    }
}
在com.kdy.anoo中创建MyAspect，并使用spring注解声明bean，并使用@Aspect声明为切面类
@Component("myAspect")
@Aspect//切面类
public class MyAspect {
    //抽取切点表达式
    @Pointcut("execution(* com.kdy.anno.*.*(..))")
    public void myPointcut(){}
    //前置增强
    @Before("myPointcut()")//使用上面抽取的切点表达式
    public void before() {
        System.out.println("before...");
    }
    //后置增强
    @AfterReturning("MyAspect.myPointcut()")//使用上面抽取的切点表达式
    public void afterReturning() {
        System.out.println("afterReturning...");
    }
    //环绕增强
    @Around("execution(* com.kdy.anno.*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before around...");//环绕前增强
        Object proceed = pjp.proceed();//切点方法
        System.out.println("after around...");//环绕后
        // 增强
        return proceed;
    }
    //异常抛出增强
    @AfterThrowing("execution(* com.kdy.anno.*.*(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing...");
    }
    //最终增强
    @After("execution(* com.kdy.anno.*.*(..))")
    public void after() {
        System.out.println("after...");
    }
}
resource下创建applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">
    <!--配置spring组件扫描-->
    <context:component-scan base-package="com.kdy.anno"/>
    <!--配置aop自动代理，@Aspect注解才会被扫描到-->
    <aop:aspectj-autoproxy/>
</beans>
 test目录下的测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    /*
    * 注：这里要注入接口TargetInterface，因为xml中声明的是Target实现类的bean，但经过织入生成代理对象的bean是最终要注入进来的
    * 因为Target有接口所以spring基于jdk来动态代理生成代理对象，这个代理对象也是TargetInterface接口类型的，
    * 所以spring生命周期中最终通过TargetInterface注入时找到的是动态代理对象的bean，将其注入进来
    * */
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.save();
    }
}

其实也可以创建如applicationContext-anno.xml，并复制以上applicationContext.xml中的内容，并在test的测试类中上方的改成@ContextConfiguration("classpath:applicationContext-anno.xml")。

运行测试用例即可。
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
Spring AOP 详解
2301_80035594的博客
10-19 6490
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP
2301_81096101的博客
03-22 1522
AOP（Aspect-Oriented Programming）即面向切面编程，是一种通过预编译或动态代理技术，将横切关注点（如日志、安全校验）与业务逻辑分离的编程范式。
spring AOP详解
是程序喵呀
11-07 4002
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
Spring Aop
会写Bug的攻城狮
08-30 2000
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
【JavaEE】Spring AOP的注解实现
yj20040627的博客
05-25 1万+
基于注解@annotation 和 execution 的方式实现SPring AOP
Spring AOP详解
2302_77758423的博客
07-21 1870
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP术语
yuehua00的专栏
11-11 1799
Spring AOP 中的核心术语和概念包括切面、通知、切入点、连接点、引介、目标对象、代理对象、织入、通知方法、切点表达式、切面优先级、织入器、AOP 代理和 AOP 框架。理解这些术语有助于更好地掌握 Spring AOP 的使用和原理，从而在实际开发中有效地应用 AOP 技术。通过合理使用 AOP，可以提高代码的模块化程度和可维护性，减少重复代码，提高开发效率。
Spring AOP 使用详解
lzz的博客
11-14 1693
Spring AOP 使用详解。核心概念+实现示例+注意事项
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
深入解析SpringBoot中的循环依赖机制与解决方案
EscaRC的博客
11-22 724
在Spring框架的上下文中，循环依赖（Circular Dependency）指的是两个或多个Bean之间形成了一个封闭的依赖链。最简单的形式是Bean A依赖于Bean B，同时Bean B又依赖于Bean A。更复杂的情况可能涉及多个Bean，例如A -> B -> C -> A。当Spring容器在启动和初始化Bean的过程中，沿着这个依赖链进行实例化和注入时，会发现最终回到了依赖链的起点，从而形成一个无法自然解开的“死结”。
【Spring】Cookie和Session是什么
2509_94088974的博客
11-22 599
在计算机领域，会话是一个客户与服务器之间的不中断的请求响应。对客户的每个请求，服务器能够识别出请求来自于同一个客户。当一个未知的客户向 Web 应用程序发送第一个请求时就开始了一个会话。当客户明确结束会话或服务器在一个时限内没有收到客户的任何请求时，会话就结束了。服务器需要清楚地区分每个请求时从属于哪个用户，也就是属于哪个会话，就需要在服务器这边记录。此时在服务器这边就需要记录“令牌”的信息，以及令牌对应的用户信息，这个就是。但是在实际开发中，我们很多时候是需要知道请求之间的关联关系的。
springboot接入deepseek深度求索 java
最新发布
2509_94082931的博客
11-23 338
以下是在springboot中接入aideepseek的过程。官网并没有java的示例。
Spring Boot + Spring AI快速体验
2509_94006535的博客
11-21 1332
Spring AI是Spring的一个子项目，是Spring专门面向于AI的应用框架。Spring AI 项目旨在简化整合人工智能功能的应用程序开发，避免不必要的复杂性。汲取了著名的 Python 项目 LangChain 和 LlamaIndex 的灵感，但 Spring AI 并不是这些项目的直接移植。该项目的成立的信念：下一波生成式人工智能应用程序不仅将面向Python开发人员，而且将在许多编程语言中无处不在。@Bean。
Spring aop
06-28
###Spring AOP 的概念 AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，旨在通过分离横切关注点来提高模块化程度。在 Spring 框架中，AOP 被广泛用于实现诸如日志记录、事务管理、安全性等通用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值