Spring-AOP

最新推荐文章于 2024-04-26 20:19:53 发布
最新推荐文章于 2024-04-26 20:19:53 发布
阅读量185 收藏
点赞数 1
分类专栏： javaRoad 文章标签： spring 代理模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Al_tair/article/details/125895797
版权

Spring-AOP

大家好呀！我是小笙，本节我来讲述一下AOP的机制以及实现

AOP

代理模式为另一个对象提供一个替身或占位符以控制对这个对象的访问，被代理的对象可以是远程对象，创建开销大的对象或需要安全控制的对象

​ --《Head First 设计模式》

概述

​ AOP 英文：Aspect Oriented Programming 即 面向切面编程 和Ioc一样是一种设计思想

​ 目的：处理OOP在解决侵入式业务上的不足 （什么是侵入性业务？类似日志统计、性能分析等就属于侵入性业务）

​ 代理模式: 静态代理 动态代理

动态代理
  • 创建一个代理类，用来管理实现了该接口的类和对象
  • 可以在该接口类的实现方法前后添加业务并且可以动态创建

image-20211104150354249

代码示例 - 无参构造器

VehicleProxyProvider 代理类

public class VehicleProxyProvider {

    /**
     *  targetVehicle 表示真正要执行的对象的指向
     */
    private Vehicle targetVehicle;

    public VehicleProxyProvider(Vehicle targetVehicle) {
        this.targetVehicle = targetVehicle;
    }

    /**
     *  public static Object newProxyInstance(
     *      ClassLoader loader, 类的加载器
     *      Class<?>[] interfaces, 要代理的对象接口信息
     *      InvocationHandler h) 调用处理器/对象
     * @return  一个代理对象
     */
    public Vehicle getProxy(){

        // 1.得到类加载器 ClassLoader
        ClassLoader classLoader = targetVehicle.getClass().getClassLoader();

        System.out.println(classLoader);

        // 2.要代理的对象接口信息,底层是用接口来完成调用
        Class<?>[] interfaces = targetVehicle.getClass().getInterfaces();

        // 3.创建InvocationHandler,调用处理器/对象
        // 因为InvocationHandler是接口，我们可以通过匿名对象的方式来创建该对象
        InvocationHandler invocationHandler = new InvocationHandler(){
            /**
             * 执行到 targetVehicle 的方法时候会调用
             * @param proxy 表示代理对象
             * @param method 表示将来通过代理对象调用方法时候会调用
             * @param args 表示调用的时候传入的参数
             * @return
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("开始运行...");
                Object result = method.invoke(targetVehicle, args);
                System.out.println("停止运行...");
                return result;
            }
        };


        Vehicle v = (Vehicle)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return v;
    }
}

被代理的接口以及实现该接口的对象

interface Vehicle {
    public void run();
}
public class Car implements Vehicle{
    @Override
    public void run() {
        System.out.println("小汽车哒哒哒...");
    }
}
public class Ship implements Vehicle{
    @Override
    public void run() {
        System.out.println("轮船嘟嘟嘟...");
    }
}

测试类

@Test
public void run(){
    Vehicle car = new Car();
    VehicleProxyProvider proxy = new VehicleProxyProvider(car);
    proxy.getProxy().run();
    //开始运行...
    //小汽车哒哒哒...
    //停止运行...
}
代码示例 - 有参构造器

加法减法的运算

CalculatorProxy代理类

public class CalculatorProxy {
    private Calculator targetCalculator;

    public CalculatorProxy(Calculator targetCalculator) {
        this.targetCalculator = targetCalculator;
    }

    public Calculator getProxy(){
        // 1.获取类加载器
        ClassLoader classLoader = targetCalculator.getClass().getClassLoader();

        // 2.获取接口信息
        Class<?>[] interfaces = targetCalculator.getClass().getInterfaces();

        // 3.创建InvocationHandler,调用处理器/对象
        InvocationHandler invocationHandler = new InvocationHandler(){

            @Override
            public Double invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Double result = null;
                try {
                    // 前置通知
                    System.out.println("方法执行开始-日志-方法名-" + method.getName() + "-参数" + Arrays.toString(args));
                    result = (Double)method.invoke(targetCalculator, args);
                    // 返回通知
                    System.out.println("方法执行正常结束-日志-方法名-" + method.getName() + "-结果" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    // 如果反射执行方法时出现异常 - 异常通知
                    System.out.println("方法执行异常-日志-方法名-" + method.getName() + "异常信息" + e.getMessage());
                } finally {
                    // 最终通知
                    System.out.println("方法执行最终结束-日志-方法名-" + method.getName());
                }
                return result;
            }
        };
        return (Calculator) Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}

被代理的接口以及实现该接口的对象

public interface Calculator {
    public double calculatorResult(double num1,double num2);
}

public class Add implements Calculator{
    @Override
    public double calculatorResult(double num1, double num2) {
        return num1 + num2;
    }
}

public class Sub implements Calculator{
    @Override
    public double calculatorResult(double num1, double num2) {
        return num1 - num2;
    }
}

测试类

public class CalculatorTest {
    @Test
    public void test(){
        CalculatorProxy calculatorProxy = new CalculatorProxy(new Sub());
        calculatorProxy.getProxy().calculatorResult(10.0,2.0);
        //方法执行开始-日志-方法名-calculatorResult-参数[10.0, 2.0]
        //方法执行正常结束-日志-方法名-calculatorResult-结果8.0
        //方法执行最终结束-日志-方法名-calculatorResult
    }
}
运用简易AOP思想优化简易计算器

上述存在的问题：代码的耦合性太高，很难拓展代码等

将前置代码，后置代码，异常代码，最终代码脱离出代理类，更加灵活运用

public class LnsAOP {
    public static void before(Method method, Object[] args){
        // 前置通知
        System.out.println("方法执行开始-日志-方法名-" + method.getName() + "-参数" + Arrays.toString(args));
    }

    public static void after(Method method, Object[] args){
        // 前置通知
        System.out.println("方法执行开始-日志-方法名-" + method.getName() + "-参数" + Arrays.toString(args));
    }

    public static void abnormal(Method method, Exception e){
        // 如果反射执行方法时出现异常 - 异常通知
        System.out.println("方法执行异常-日志-方法名-" + method.getName() + "异常信息" + e.getMessage());
    }

    public static void last(Method method){
        // 最终通知
        System.out.println("方法执行最终结束-日志-方法名-" + method.getName());
    }
}

public class CalculatorProxy {
    private Calculator targetCalculator;

    public CalculatorProxy(Calculator targetCalculator) {
        this.targetCalculator = targetCalculator;
    }

    public Calculator getProxy(){
        // 1.获取类加载器
        ClassLoader classLoader = targetCalculator.getClass().getClassLoader();

        // 2.获取接口信息
        Class<?>[] interfaces = targetCalculator.getClass().getInterfaces();

        // 3.创建InvocationHandler,调用处理器/对象
        InvocationHandler invocationHandler = new InvocationHandler(){

            @Override
            public Double invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Double result = null;
                try {
                    LnsAOP.before(method,args);
                    result = (Double)method.invoke(targetCalculator, args);
                    LnsAOP.after(method,args);
                } catch (Exception e) {
                    e.printStackTrace();
                    LnsAOP.abnormal(method,e);
                } finally {
                    LnsAOP.last(method);
                }
                return result;
            }
        };
        return (Calculator) Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}
面向切面编程 AOP

将被代理的类和相关日志杂糅在代理类中，动态组合

image-20220630214739043

快速入门

首先引入四个包

image-20220630220019948

配置类

<?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 http://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">
    <!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.Al_tair.proxy.calculatorAOP" />
    <!-- 注意添加自动开启基于注解的AOP功能-->
    <aop:aspectj-autoproxy/>
</beans>

被代理类

public interface Calculator {
    public double calculatorResult(double num1,double num2);
}
@Component // 用于注入到ioc容器
public class Add implements Calculator{
    @Override
    public double calculatorResult(double num1, double num2) {
        return num1 + num2;
    }
}
@Component
public class Sub implements Calculator{
    @Override
    public double calculatorResult(double num1, double num2) {
        return num1 - num2;
    }
}

切面类

@Component
@Aspect
public class AspectJ {
    /**
     * 切入方法
     * @Before： 表示前置通知 还有 @After 最后通知 @AfterThrowing  异常通知 @AfterReturning  返回通知
     * execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))
     * 指定执行哪个类中的哪个方法：execution( 访问修饰符 + 返回类型 + 类的全路径 + 方法名 + （形参列表）)
     * @param joinPoint 连接器：将方法参数等信息封装成joinPoint对象，方 便在切面方法中使用
     */
    @Before(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))")
    public static void log1(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature() + ": 前置通知~");
    }

    @After(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))")
    public static void log2(JoinPoint joinPoint){
        System.out.println(joinPoint.getTarget()+ ": 后置通知~");
    }

    @Before(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Sub.calculatorResult(double,double))")
    public static void log3(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature() + ": 前置通知~");
    }

    @After(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Sub.calculatorResult(double,double))")
    public static void log4(JoinPoint joinPoint){
        System.out.println(joinPoint.getTarget()+ ": 后置通知~");
    }
}

测试类

public class AOPTest {
    @Test
    public void test(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("bean4.xml");
        Calculator add = ioc.getBean("add", Calculator.class);
        Calculator sub = ioc.getBean("sub", Calculator.class);
        // 编译： Add类型 运行： Proxy代理类型
        System.out.println(add); // com.Al_tair.proxy.calculatorAOP.Add@61d6015a
        System.out.println(add.getClass()); // class com.sun.proxy.$Proxy14
        add.calculatorResult(3,2);
        sub.calculatorResult(4,2);
        //double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知~
        //com.Al_tair.proxy.calculatorAOP.Add@61d6015a: 后置通知~
        //double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知~
        //com.Al_tair.proxy.calculatorAOP.Sub@3315d2d7: 后置通知~
    }
}

注意：需要jdk1.8（版本不要太高）

@Before
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Before {
    String value();

    String argNames() default "";
}

代码示例

@Before(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))")
public static void log1(JoinPoint joinPoint){
    System.out.println(joinPoint.getSignature() + ": 前置通知~");
}
@AfterReturning
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterReturning {
    String value() default "";

    String pointcut() default "";

    String returning() default ""; // 接收方法返回值

    String argNames() default "";
}

代码示例

// returning 指定返回值的引用名
@AfterReturning(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))",returning = "res")
public static void log2(JoinPoint joinPoint,Object res){
    System.out.println(res.toString()+ ": 返回通知~");
}
@AfterThrowing
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterThrowing {
    String value() default "";

    String pointcut() default "";

    String throwing() default ""; // 接收异常信息

    String argNames() default "";
}

代码示例

// throwing 指定异常引用名
@AfterThrowing(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))", throwing = "throwable")
public void log3(JoinPoint joinPoint, Throwable throwable) {
    Signature signature = joinPoint.getSignature();
    System.out.println("异常通知~")
@After
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface After {
    String value();

    String argNames() default "";
}

代码示例

@After(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Sub.calculatorResult(double,double))")
public static void log4(JoinPoint joinPoint){
    System.out.println(joinPoint.getTarget()+ ": 后置通知~");
}
@Around
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Around {
    String value();

    String argNames() default "";
}

代码示例

//1. @Around: 表示这是一个环绕通知[完成其它四个通知的功能]
@Around(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Sub.calculatorResult(double,double))")
public Object doAround(ProceedingJoinPoint joinPoint) {
    Object result = null;
    String methodName = joinPoint.getSignature().getName();
    try {
        //1.相当于前置通知完成的事情
        Object[] args = joinPoint.getArgs();
        List<Object> argList = Arrays.asList(args);
        System.out.println("AOP环绕通知[-前置通知]" + methodName + "方法开始了--参数有：" + argList);
        //在环绕通知中一定要调用joinPoint.proceed()来执行目标方法
        result = joinPoint.proceed();
        //2.相当于返回通知完成的事情
        System.out.println("AOP环绕通知[-返回通知]" + methodName + "方法结束了--结果是：" + result);
    } catch (Throwable throwable) {
        //3.相当于异常通知完成的事情
        System.out.println("AOP环绕通知[-异常通知]" + methodName + "方法抛异常了--异常对象：" + throwable);
    } finally {
        //4.相当于最终通知完成的事情
        System.out.println("AOP环绕通知[-后置通知]" + methodName + "方法最终结束了...");
    }
    return result;
	//AOP环绕通知[-前置通知]calculatorResult方法开始了--参数有：[4.0, 2.0]
    //AOP环绕通知[-返回通知]calculatorResult方法结束了--结果是：2.0
    //AOP环绕通知[-后置通知]calculatorResult方法最终结束了
}
@Pointcut

思考：execution（）是否有大量的重复代码，能否抽出共同点？

引出切入点，减少代码复用

public class AspectJ {
    @Pointcut(value = "execution(public double com.Al_tair.proxy.calculatorAOP.Add.calculatorResult(double,double))")
    public void myPointCut(){}
   
    @Before(value = "myPointCut()")
    public static void log1(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature() + ": 前置通知~");
    }

    @AfterReturning(value = "myPointCut()",returning = "res")
    public static void log2(JoinPoint joinPoint,Object res){
        System.out.println(res.toString()+ ": 后置通知~");
    }
}
多个切面类的执行顺序

优先级别:value的值越小，反而前置通知优先级别越高（类似Fileter过滤的规则）

image-20220706222331749

结果分析 （order1 > order2）
double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知2~
double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知1~
5.0: 后置通知1~
5.0: 后置通知2~
double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知2~
double com.Al_tair.proxy.calculatorAOP.Calculator.calculatorResult(double,double): 前置通知1~
com.Al_tair.proxy.calculatorAOP.Sub@22e357dc: 后置通知1~
com.Al_tair.proxy.calculatorAOP.Sub@22e357dc: 后置通知2~
Al_tair
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Aspect execution AfterThrowing 实例
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
12-27 1596
execution是使用的最多的一种Pointcut表达式，表示某个方法的执行，其标准语法如下 execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) modifiers-pattern表示方法的访问类型，public等； ...
spring-aop-5.1.0.RELEASE.jar
03-09
spring-**core**-4.3.6.RELEASE.jar ：包含spring框架基本的核心工具类，spring其他组件都要用到这个包里的类，其他组件的基本核心 spring-**beans**-4.3.6.RELEASE.jar：所有应用都要用到的jar包，它包含访问配置...
Spring框架中@AfterReturning的returning返回值对于String类型与自定义对象类型的参数值在方法中改变，返回值前者没有变化而后者改变问题的看法。
tiantian469的博客
04-17 2314
萌新的第一篇文章，还请轻喷！ 1.定义一个实体类，名为Student，参数有String name和Integer age，里面有toString方法，有参构造方法，set和get方法。 2.定义一个名为ServiceTest接口，里面有两个方法，doString()与doStudent()，第一个方法返回值为String，第二个方法返回值为Student。 3.定义接口实现类ServiceTestImpl，实现两个方法，第一个返回return “abc”;第二个返回return new Student(“
Spring系列26：Spring AOP 通知与顺序详解
kongxubihai的博客
03-21 457
本文内容 如何声明通知 如何传递参数到通知方法中 多种通知多个切面的通知顺序 多个切面通知的顺序源码分析与图解 声明通知 Spring中有5种通知，通过对应的注解来声明： @BeforeBefore 通知，用于方法执行前增强 @AfterReturning ：After Returning 通知，方法正常执行返回后增强 @AfterThrowing：After Throwing 通知，方法执行通过抛出异常退出时 @After：After (Finally) 通知，方法执行退出时执行增强，不管是正常返回
@AfterReturning里面的Returning值解释,以及获取自定义注解参数值
热门推荐
weixin_47733858的博客
07-21 1万+
今天写代码遇到了@AfterReturning(returning = ‘var’) 查了很多网络资料都只说这个是方法返回值,并没有说是什么方法返回值,这里坐下代码解释 // 被切方法 @RestController @RequestMapping("/show") public class ControllerTwo { @RequestMapping("/test") @Hh(status = "2") public String test(){ retur.
自定义注解
lcjjy666的博客
09-11 151
一、注解的作用 注解的作用就是代替配置文件，一般的配置文件都是xml，也有properties文件 注：注解版会比配置文件运行效率低，注解使用是反射进行解析，反射就会比较慢 二、怎么定义注解 1、格式：public @interface 名称{} 2、要求： 定义任何一个注解必须定义注解时，写上以下三个注解： @Documented 表示一个注解文档 @Target() 自定义注解作用在什么位
开发工具 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-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
spring-aop
03-17
在学spring时，做的有关aop的代码。可以直接导入使用。
SpringBoot项目打包分离高阶操作
Record Little
04-23 617
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 959
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
SpringCloudAlibaba：2.1nacos
最新发布
m0_63040701的博客
04-26 698
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
SpringCloud Ribbon介绍
赵先森
04-26 305
Ribbon 是 Spring Cloud 技术栈中非常重要的基础框架，它为 Spring Cloud 提供了负载均衡的能力，比如 Fegin 和 OpenFegin 都是基于 Ribbon 实现的，就连 Nacos 中的负载均衡也使用了 Ribbon 框架。
每日一题：Spring 框架中都用到了哪些设计模式❓
lhcong_的博客
04-24 289
总之，Spring 框架中充分利用了许多设计模式，提供了良好的扩展性和灵活性，降低了代码的耦合度，提高了代码的可维护性。
SpringBoot JPA使用
gochenguowei的博客
04-25 715
是 Spring 框架提供的一个模块，用于简化与关系型数据库的交互和数据访问。它基于JPA（Java Persistence API）标准，并提供了一组易于使用的API和工具，帮助开发人员更轻松地进行数据库操作。通过Spring Data JPA，开发人员可以通过编写简洁的代码来执行常见的 CRUD 操作，同时还支持高级查询、分页、事务管理等功能。它的目标是提供一种更简单、更高效的方式来处理数据库操作，减少开发人员的工作量，并提高应用程序的可维护性和可扩展性。
SpringBoot内容协商机制（就是接受数据的类型如json，xml）
gaoqiandr的博客
04-23 411
本文主要介绍的是SpringBoot中的内容协商机制，也就是接收参数的数据格式，如xml，json等等
javaweb-SpringBoot基础
kussm_的博客
04-20 1334
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
spring-aop maven
12-21
Spring AOP是Spring框架中的一个模块，用于实现面向切面编程（AOP）。在Maven中，你可以通过添加以下Maven坐标来引入Spring AOP依赖： ```xml <groupId>org.springframework <artifactId>spring-aop <version>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Al_tair

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值