Spring框架—AOP总结&整合日志

最新推荐文章于 2024-06-29 11:28:02 发布
最新推荐文章于 2024-06-29 11:28:02 发布
阅读量721 收藏 19
点赞数 12
分类专栏： Spring框架 文章标签： spring java idea xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rxdasd123456/article/details/140004071
版权

AOP

概念

面向切面编程。 在软件业， AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护 的一种技术。

功能

利用 AOP 可以对 业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的 耦合度 降低，提高程序的 可重用性 ，同时提高了开发的效率。

作用

AOP影响的是Service层

  • 日志记录，
  • 性能统计，
  • 安全控制，
  • 事务处理，
  • 异常处理

半自动AOP

  • target:目标类——》如UserServiceImpl.class;需要扩展的类;
  • joinpoint:连接点——》目标类中所有的方法;
  • pointcut: 切入点——》如:insertS;连接点中的具体要扩展的某个方法；
  • advisor: 增强（通知）——》切入点需要进行的扩展；
  • weaver:织入——》将增强应用到切入点的过程；
  • proxy:代理对象——》织入以后生成的代理对象；
  • aspect: 切面——》多个连接点连成一个面;

AOP增强分类

增强代码出现的位置

  • 前置增强： 在目标方法执行前进行增强;
  • 后置增强: 在目标方法执行后进行增强;
  • 环绕增强: 前后都增强;
  • 异常增强: 抛出异常后进行功能增强;
  • 引介增强: 可以为目标类增加方法和属性；（基本不用）
try {
// 前置
// 目标方法 ;
// 后置
} catch {
// 异常增强；
}  

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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
">
<!-- 开启包扫描:开启后的包中的类添加@Component就可以交给spring容器管理
注意:
1、此处写的是包名；
2、多个的话使用,进行分隔;
-->
<context:component-scan base-package="cn.ry.pojo,cn.ry.dao">
</context:component-scan>
<!-- 半自动aop进行配置: -->
<!-- 1、将目标类交给spring容器来管理 ; -->
<bean id="service" class="cn.ry.service.impl.UserServiceImpl"></bean>
<!-- 3、将增强类交给spring容器管理: -->
<bean id="advisor1" class="cn.ry.advisor.Advisor1"></bean>
<!-- 2、依赖于代理工厂类进行配置 -->
<bean id="proxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!--target：属性指的是目标类 -->
<property name="target" ref="service"></property>
<!-- 向代理工厂类注入增强: -->
<property name="interceptorNames" value="advisor1"></property>
<!-- 表示的是是否强制使用cglib动态代理:
true强制；
false：不是;
-->
<property name="optimize" value="false"></property>
</bean>
</beans>

 java代码增强

package cn.ry.advisor;
import java.lang.reflect.Method;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
*
* <p>Title: Advisor1<／p>
* <p>Description:模拟半自动aop的环绕增强；不同增强接口不同 <／p>
* @author dzc
* @date 2024年6月5日
*/
public class Advisor1 implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation arg0) throws Throwable {
// TODO Auto-generated method stub
//编写之前的增强内容:
long before = System.currentTimeMillis();
//重写方法内容:
arg0.proceed();
long after= System.currentTimeMillis();
System.out.println("执行时间为"+(after-before)+"ms");
return null;
}
}

总结

优点
代替了 ProxyFactory 里面复杂的两种代理方式，通过 spring 的 ProxyFactoryBean 实体类中的 target 属性和interceptorNames 属性将目标类和增强类注入其中，即可生效。
缺点
  • 每一个bean都需要配置一个ProxyFactoryBean这样的配置，很麻烦；
  • 增强需要实现不同的接口，增加了耦合度；
  • 同种类型bean在容器中有多个；
  • 织入过程没看到，需要将增强和目标类注入到ProxyFactoryBean中，手动织入；
  • 没办法找到具体的切入点，是对目标类中所有的方法进行增强，不合理。

传统AOP

添加 jar: aopalliance.jar;
自动织入的 jar:aspectjweaver- 版本号 ;
  • 确定目标类;
  • 确定增强类;
  • 确定切入点；
  • 自动织入；

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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/springcontext.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- 开启包扫描:开启后的包中的类添加@Component就可以交给spring容器管理
注意:
1、此处写的是包名；
2、多个的话使用,进行分隔;
-->
<context:component-scan base-package="cn.ry.pojo,cn.ry.dao">
</context:component-scan>
<!-- 传统aop进行配置: -->
<!-- 1、将目标类交给spring容器来管理 ; -->
<bean id="service" class="cn.ry.service.impl.UserServiceImpl">
</bean>
<!-- 2、将增强类交给spring容器管理: -->
<bean id="advisor1" class="cn.ry.advisor.Advisor1"></bean>
<!-- aop配置 主要确定切入点和织入 -->
<!-- proxy-target-class="false"为false的时候表示默认jdk动态代理;
为true的时候，强制使用cglib动态代理;
-->
<aop:config proxy-target-class="false">
<!-- 配置aop的切入点
id指的是唯一标识;
expression指的是切入点表达式:
execution(* cn.ry.service.impl.UserServiceImpl.方法
名字(..))
java
没进行任何改变;
总结
优点
采用切入点表达式，可以找到具体的需要增强的方法，从而进行增强；
采用了自动织入的方式，省略了ProxyFactoryBean的配置；
缺点
java代码并未改动，存在增强硬编码的问题；
基于AspectJ的aop
 AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器
用来生成遵守Java字节编码规范的Class文件。
添加依赖包: spring-aspects;
增强类型
前置
后置
环绕
异常
引介
最终
核心特点
增强类本身不依赖于任何框架，也就是不需要去实现任何接口，普通的java类也能作为增强类。
xml版本
增强类
格式: 修饰符 返回结果 包名.类名.方法名(形参);
修饰符很一般省略
返回结果： 无返回是void *代表的是任意类型;
cn.ry.*.impl.*. cn.ry.下面的所有dao和service的实现类中
的所有类都被选中;
方法: select*(..) 表示的是所有select开头的方法;
-->
<aop:advisor advice-ref="advisor1" pointcut="execution(*
cn.ry.service.*.*.insert*(..))"/>
</aop:config>
</beans>

java代码没进行任何改变

总结

优点
  • 采用切入点表达式，可以找到具体的需要增强的方法，从而进行增强；
  • 采用了自动织入的方式，省略了ProxyFactoryBean的配置；
缺点
  • java代码并未改动，存在增强硬编码的问题；

基于AspectJ的AOP

添加依赖包 : spring-aspects;

概念

AspectJ 是一个面向 切面 的框架，它扩展了 Java 语言。 AspectJ 定义了 AOP 语法，它有一个专门的 编译器 用来生成遵守 Java 字节编码规范的 Class 文件。

增强类型

  • 前置
  • 后置
  • 环绕
  • 异常
  • 引介
  • 最终
核心特点
  • 增强类本身不依赖于任何框架，也就是不需要去实现任何接口，普通的java类也能作为增强类。

XML版本

增强类
package cn.ry.advisor;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
//增强类:
public class Advisor2 {
//前置增强的方法：
//方法可以有参；可以无参
//如果有参只能是JoinPoint:主要用来获取目标方法名字;
public void before(JoinPoint point) {
String name = point.getSignature().getName();
System.out.println(name+"before--------------------");
}
//环绕增强必须有返回值；
// 环绕增强参数必须有ProceedingJoinPoint
public Object around(ProceedingJoinPoint point) throws Throwable {
System.out.println("前-------");
Object obj = point.proceed();
System.out.println("后-------");
return obj;
}
//后置增强:
//后置增强的参数:
//第一个参数JoinPoint
//第二个参数用来接收目标方法的返回结果，放到第二参数中;
public Object afterReturning(JoinPoint point,Object obj) {
String name = point.getSignature().getName();
System.out.println(name+"afterReturning--------------------"+obj);
return obj;
}
//异常增强:
public void afterThrowing(JoinPoint point,Throwable ex) {
String name = point.getSignature().getName();
System.out.println(name+"afterThrowing--------------------
"+ex.getMessage());
}
//最终增强
public void after() {
System.out.println("最终增强哈哈哈---------");
}
}
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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
注解版本
需要在xml中开启包扫描;
设置aspectj自动代理
">
<!-- 开启包扫描:开启后的包中的类添加@Component就可以交给spring容器管理
注意:
1、此处写的是包名；
2、多个的话使用,进行分隔;
-->
<context:component-scan base-package="cn.ry.pojo,cn.ry.dao">
</context:component-scan>
<!-- 传统aop进行配置: -->
<!-- 1、将目标类交给spring容器来管理 ; -->
<bean id="service" class="cn.ry.service.impl.UserServiceImpl">
</bean>
<!-- 2、将增强类交给spring容器管理: -->
<bean id="advisor2" class="cn.ry.advisor.Advisor2"></bean>
<!-- 3、aop配置发生改变: -->
<aop:config proxy-target-class="false">
<!-- aop:aspect 中的ref表示的是引入进来的增强； -->
<aop:aspect ref="advisor2">
<!-- 设置的切入点: -->
<aop:pointcut expression="execution(* cn.ry.service.*.*.*
(..))" id="p1"/>
<!--
aop:around:环绕增强 Method属性指的是方法名;环绕增强的方法要求
返回值是Object；
-->
<aop:around method="around" pointcut-ref="p1"/>
<!-- 前置: -->
<aop:before method="before" pointcut-ref="p1"/>
<!-- 后置:
returning=""放的是后置增强方法中第二个参数的形参;
-->
<aop:after-returning method="afterReturning" pointcutref="p1" returning="obj"/>
<!-- 异常: -->
<aop:after-throwing method="afterThrowing" pointcut-ref="p1"
throwing="ex"/>
<!-- 最终: -->
<aop:after method="after" pointcut-ref="p1"/>
</aop:aspect>
</aop:config>
</beans>

注解版本

  • 需要在xml中开启包扫描;
  • 设置aspectj自动代理 
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- 开启包扫描:开启后的包中的类添加@Component就可以交给spring容器管理
注意:
1、此处写的是包名；
2、多个的话使用,进行分隔;
-->
<context:component-scan base-package="cn.ry.service,cn.ry.advisor">
</context:component-scan>
<!-- 开启aop自动代理 -->
<aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectjautoproxy>
</beans>
  • 在增强类上添加@Aspect注解;
package cn.ry.advisor;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//增强类:
@Component
@Aspect //声明当前是增强类;
public class Advisor2 {
//主要是相当于xml中配置切入点:
//value中写的是expression表达式
@Pointcut(value = "execution(* cn.ry.service.*.*.*(..))")
public void a() {
}
//前置增强的方法：
//方法可以有参；可以无参
//如果有参只能是JoinPoint:主要用来获取目标方法名字;
@Before(value = "a()")
public void before(JoinPoint point) {
String name = point.getSignature().getName();
System.out.println(name+"before--------------------");
}
//环绕增强必须有返回值；
// 环绕增强参数必须有ProceedingJoinPoint
@Around(value = "a()")
public Object around(ProceedingJoinPoint point) throws Throwable {
System.out.println("前-------");
Object obj = point.proceed();
整合日志
指的是spring去整合日志框架。
log4j2：
需要导入jar包； log4j-core 、 log4j-api;
配置文件：log4j2.xml;
将jar包和配置文件导入进来以后，运行即可（要求spring导入对应的jar包：spring-test.jar、junit、
hamcrest）。
测试
白盒测试、黑盒测试。
白盒测试也就是结构测试、 透明盒测试、逻辑驱动测试或基于代码的测试，也就相当于平时debug进行
调试、测试。
黑盒测试也就是功能测试，主要用户按照 需求规格说明书进行使用，检查看一下能够正常运行此功能。
Junit
System.out.println("后-------");
return obj;
}
//后置增强:
//后置增强的参数:
//第一个参数JoinPoint
//第二个参数用来接收目标方法的返回结果，放到第二参数中;
@AfterReturning(value="a()")
public Object afterReturning(JoinPoint point,Object obj) {
String name = point.getSignature().getName();
System.out.println(name+"afterReturning--------------------"+obj);
return obj;
}
//异常增强:
@AfterThrowing(value="a()")
public void afterThrowing(JoinPoint point,Throwable ex) {
String name = point.getSignature().getName();
System.out.println(name+"afterThrowing--------------------
"+ex.getMessage());
}
//最终增强
@After(value="a()")
public void after() {
System.out.println("最终增强哈哈哈---------");
}
}

整合日志

概念

指的是 spring 去整合日志框架。

导入jar包

log4j-core 、 log4j-api;

配置文件：

log4j2.xml;
将 jar 包和配置文件导入进来以后，运行即可（要求 spring 导入对应的 jar 包： spring-test.jar 、 junit 、
hamcrest ）。

本次分享就到这里，博主创作不易，你的关注是我坚持更新源源不断的动力。点个关注不迷路，感谢家人们！！！我们下次见

一只小叮东
关注
  • 12
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【七】springboot整合AOP实现日志操作
weixin_56995925的博客
09-07 1万+
springboot整合AOP实现日志操作
Spring框架学习总结&AOP环绕通知用法
weixin_44924238的博客
06-28 1970
2020.06.25 今天是端午节，也是我的“开学”第一课，感触很多一直以来我知道自己学的不够，也还有很多要学，可是当这座山摆在我面前的时候，才知道之前的自己逃避了很多。 ------please try harder. Spring 框架学习Spring的诞生Spring框架的组成优势，目标，原则Spring jar下载Spring IOC Spring的诞生 Spring : 春天 泉水 官网： https://spring.io/ GO Spring诞生以前 Java Web.
Spring框架AOP学习总结（下）
宜春
08-12 1万+
文章目录1、 AOP 的概述1、1 为什么学习 AOP1、2 AOP底层实现: 代理机制（了解）2、 Spring 的基于 AspectJ 的 AOP 开发（XML 的方式）2.1 AOP 的开发中的相关术语:2.2 Spring 使用 AspectJ 进行 AOP 的开发入门（XML 的方式）：2.2.1 引入相应的 jar 包2.2.2 引入 Spring 的配置文件2.2.3 编写目标类...
ssm框架，利用Spring AOP实现行为日志记录
qq_41606400的博客
12-30 463
Spring AOP 行为日志记录
SpringAOP+注解实现简单的日志管理
qq_44880019的博客
12-21 1058
今天在再次深入学习SpringAOP之后想着基于注解的AOP实现日志功能，在面试过程中我们也经常会被问到:假如项目已经上线，如何增加一套日志功能?我们会说使用AOP，AOP也符合开闭原则:对代码的修改禁止的，对代码的扩展是允许的。今天经过自己的实践简单的实现了AOP日志。 在这里我只是简单的记录下当前操作的人、做了什么操作、操作结果是正常还是失败、操作时间，实际项目中，如果我们需要记录的更详细，可以记录当前操作人的详细信息，比如说部门、身份证号等信息，这些信息可以直接从session中获取，也可以从sess
【Spring进阶系列丨第八篇】Spring整合junit & 面向切面编程(AOP)详解
热门推荐
陈橘又青的博客
04-10 1万+
是Endava的专职开发主管和培训师，他负责欧洲、美国和亚洲客户的金融市场项目开发。他有超过10年的开发经验。Laurenţiu相信，重要的不仅是交付高质量的软件，还要分享知识和帮助他人提升技能。这些信念驱使他去设计和讲授与Java技术相关的课程，并进行演示和参与研讨会。
Spring框架学习总结
thinkhi9999的博客
08-16 1139
Spring框架的优势是模块化的IoC设计模式，使得开发人员可以专心开发程序的模块化部分。它能够降低开发企业级应用的复杂性，使用Spring替代EJP发开企业级应用，而不用提心工作量太大，开发进度难以控制和复杂的测试过程等问题。Spring简化了企业级应用的开发，降低了开发成本并整合了各种流行框架，它以IoC和AOP(面向切面编程)两种先进的技术为基础，完美简化了企业级应用开发的复杂度。 Spring组成 ...
IOC、AOP、以及Spring框架的面试整合题
m0_73671382的博客
04-03 821
spring是一个开放源代码的设计层面框架,它解决的是业务逻辑层和其他各层的松耦合问题,是一个分层的javaEE一站式轻量级开源框架。
ssm框架整合AOP，实现日志记录功能
天大会下雨的博客
09-14 6655
在ssm框架中，实现一个切面日志功能，起码要掌握的知识有四点： 1：在切面类的方法里面获取一个request 2：springAOP中JoinPoint类的知识 3：用到自定义注解类的知识 4：用到类对象的各种方法 以下是自己之前做的一个项目，希望对你们有帮助 1：先定义一个自定义注解类 @Target({METHOD, TYPE}) @Retention(RetentionPolic...
SpringBoot整合AOP
HLH_2021的博客
08-08 1479
文章目录1. AOP介绍1.1 什么是AOP1.2 AOP中的名词介绍1.3 注解介绍1.4 切入点表达式2. 测试2.1 简单案例2.2 execution2.3 within2.4 this2.5 target2.6 args2.7 @args2.8 @within2.9 @target2.10 @annotation2.10 bean3. 案例3.1 AOP日志3.2 登录用户参数注入 1. AOP介绍 1.1 什么是AOP aop全称Aspect Oriented Programming，即为面向切
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
首先，Spring框架是核心，它提供了一个全面的编程和配置模型，用于简化企业级应用的开发。Spring的依赖注入特性使得对象之间的关系在运行时动态地决定，而不是硬编码在类的内部。这样，我们可以更容易地进行单元测试...
Flex整合Spring实现aop日志管理
11-09
本文将深入探讨如何使用Flex与Spring框架整合，实现AOP（面向切面编程）来达到日志管理的目标。AOP允许我们在不修改原有业务逻辑的情况下，插入日志记录代码，使得日志功能的实现更加灵活和高效。 首先，让我们理解...
Spring+SpringMVC+Hibernate 框架整合
12-15
SpringMVC是Spring框架的一个模块，专门用于处理Web请求。它遵循Model-View-Controller设计模式，负责接收HTTP请求，调用业务逻辑，处理结果，并将结果返回给客户端。SpringMVC通过DispatcherServlet作为前端控制器...
Spring高级框架课程笔记.pdf
04-30
* 在 Spring 框架中，AOP 是一个核心组件，提供了对横切关注点的支持，例如安全检查、日志记录、事务管理等。 四、Spring MVC * Spring MVC 是一个基于 Java 的 Web 应用程序框架，提供了一个松散耦合的架构，帮助...
SpringMVC+springAOP+spring security+Hibernate整合实例代码
01-12
- 配置文件：如`spring-context.xml`，包含了Spring框架的配置，包括对Spring MVC、AOP和Security的配置。 - Hibernate的配置文件：如`hibernate.cfg.xml`，定义了数据库连接和实体类映射。 - Java源代码：包括控制...
从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
最新发布
欢迎来到“代码匠心”！我是您的博客主，一名专注于后端技术的程序员。在这里，我将与您分享我在Java、大数据和系统架构等领域的学习心得、实践经验以及技术前沿动态。
06-29 418
在Web应用程序中，安全性是一个至关重要的方面。Spring Security是Spring框架的一个子项目，用于提供安全访问控制的功能。通过集成Spring Security，我们可以轻松实现用户认证、授权、加密、会话管理等安全功能。本篇文章将指导大家从零开始，在Spring Boot项目中集成Spring Security，并通过MyBatis-Plus从数据库中获取用户信息，实现用户认证与授权。
Spring数据访问架构设计解析
alan_gaohaodong的博客
06-24 380
3、事物事件监听器：@TransactionalEventListener，事物只有在commit后，才能把事件发出来。1、开启基于注解的声明式事物：@EnableTransactionManagement。1、Spring事物管理器：PlatformTransactionManager。2、Spring事物模板:TransactionTemplate。二、Spring声明式事物(aop原理)四、Spring R2DBC数据访问。二、Spring事物管理器。四、Spring事物管理器。
Spring 内部类获取不到@Value配置值问题排查（附Spring代理方式）
YY-帆S的博客
06-24 698
异常处理、@Value 、Spring 代理模式
Vue + SpringBoot 实现文件的断点上传、秒传，存储到Minio
m0_73179389的博客
06-19 723
前端页面使用的elment-plus的el-upload组件。当上传文件后，会调用handleChange 方法，可以在这里进行文件相关的操作。计算文件的MD5值。
qfedu三段Spring以及Spring整合MyBatis
03-07
在Spring框架中，AOP（面向切面编程）是一个重要的核心功能，它允许开发者将系统中的非核心逻辑，如日志记录、事务管理等，抽取出来作为独立的模块，以切面的形式存在。AOP的概念是对面向对象编程（OOP）的一种补充...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值