面试官：Spring事务在哪几种情况下会不生效？

最新推荐文章于 2024-04-23 10:32:10 发布
最新推荐文章于 2024-04-23 10:32:10 发布
阅读量1.2k 收藏 7
点赞数
文章标签： spring java spring boot 后端 架构师
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Javatutouhouduan/article/details/130015772
版权

日常开发中，我们经常使用到spring事务。Spring 事务在哪几种情况下会不生效？ 今天跟大家聊聊，spring事务不生效的15种场景。

1. 你的service类没有被Spring管理

//@Service （注释了@Service）
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
     @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) {
        //保存tianluo实体数据库记录
        tianLuoMapper.save(tianluo);
        //保存tianluo流水数据库记录
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

  • 事务不生效的原因：上面例子中， @Service注解注释之后，spring事务（@Transactional）没有生效，因为Spring事务是由AOP机制实现的，也就是说从Spring IOC容器获取bean时，Spring会为目标类创建代理，来支持事务的。但是@Service被注释后，你的service类都不是spring管理的，那怎么创建代理类来支持事务呢。

  • 解决方案：加上@Service注解。

2.没有在Spring配置文件中启用事务管理器

@Configuration
public class AppConfig {
    // 没有配置事务管理器
}

@Service
public class MyService {
    @Transactional
    public void doSomething() {
        // ...
    }
}

  • 事务不生效的原因：没有在AppConfig中配置事务管理器，因此Spring无法创建事务代理对象，导致事务不生效。即使在MyService中添加了@Transactional注解，该方法也不会被Spring管理的事务代理拦截。

  • 解决方案：为了解决这个问题，应该在AppConfig中配置一个事务管器。例如：

@Configuration
public class AppConfig {
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

@Service
public class MyService {
    @Transactional
    public void doSomething() {
        // ...
    }
}

如果是Spring Boot项目，它默认会自动配置事务管理器并开启事务支持。

3. 事务方法被final、static关键字修饰

@Service
public class TianLuoServiceImpl  {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public final void addTianLuo(TianLuo tianluo) {
         //保存tianluo实体数据库记录
        tianLuoMapper.save(tianluo);
        //保存tianluo流水数据库记录
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

  • 事务不生效的原因：如果一个方法被声明为final或者static，则该方法不能被子类重写，也就是说无法在该方法上进行动态代理，这会导致Spring无法生成事务代理对象来管理事务。

  • 解决方案：addTianLuo事务方法不要用final修饰或者static修饰。

4. 同一个类中，方法内部调用

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;
    
    public void addTianLuo(TianLuo tianluo){
     // 调用内部的事务方法
     this.executeAddTianLuo(tianluo);
   }

    @Transactional
    public void executeAddTianLuo(TianLuo tianluo) {
        tianLuoMapper.save(tianluo);
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

  • 事务不生效的原因: 事务是通过Spring AOP代理来实现的，而在同一个类中，一个方法调用另一个方法时，调用方法直接调用目标方法的代码，而不是通过代理类进行调用。即以上代码，调用目标executeAddTianLuo方法不是通过代理类进行的，因此事务不生效。

  • 解决方案：可以新建多一个类，让这两个方法分开，分别在不同的类中。如下：

@Service
public class TianLuoExecuteServiceImpl implements TianLuoExecuteService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;
    
    @Transactional
    public void executeAddTianLuo(TianLuo tianluo) {
        tianLuoMapper.save(tianluo);
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

@Service
public class TianLuoAddServiceImpl implements TianLuoAddService {

    @Autowired
    private TianLuoExecuteService tianLuoExecuteService;
    
    public void addTianLuo(User user){
     tianLuoExecuteService.executeAddTianLuo(user);
   }
}

当然，有时候你也可以在该 Service 类中注入自己，或者通过AopContext.currentProxy()获取代理对象。

5.方法的访问权限不是public

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    private void addTianLuo(TianLuo tianluo) {
        tianLuoMapper.save(tianluo);
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

  • 事务不生效的原因：spring事务方法addTianLuo的访问权限不是public，所以事务就不生效啦，因为Spring事务是由AOP机制实现的，AOP机制的本质就是动态代理，而代理的事务方法不是public的话，computeTransactionAttribute()就会返回null，也就是这时事务属性不存在了。大家可以看下AbstractFallbackTransactionAttributeSource的源码：

  • 解决方案：addTianLuo事务方法的访问权限修改为public。

6. 数据库的存储引擎不支持事务

Spring事务的底层，还是依赖于数据库本身的事务支持。在MySQL中，MyISAM存储引擎是不支持事务的，InnoDB引擎才支持事务。因此开发阶段设计表的时候，确认你的选择的存储引擎是支持事务的。

7 .配置错误的 @Transactional 注解

@Transactional(readOnly = true)
public void updateUser(User user) {
    userDao.updateUser(user);
}

  • 事务不生效的原因：虽然使用了@Transactional注解，但是注解中的readOnly=true属性指示这是一个只读事务，因此在更新User实体时会抛出异常。

  • 解决方案：将readOnly属性设置为false，或者移除了@Transactional注解中的readOnly属性。

8.事务超时时间设置过短

@Transactional(timeout = 1)
public void doSomething() {
    //...
}

  • 事务不生效的原因：在上面的例子中，timeout属性被设置为1秒，这意味着如果事务在1 秒内无法完成，则报事务超时了。

9. 使用了错误的事务传播机制

@Service
public class TianLuoServiceImpl {
 
    @Autowired
    private TianLuoMapper tianLuoMapper;
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;
 
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public  void doInsertTianluo(TianLuo tianluo) throws Exception {
        tianLuoMapper.save(tianluo);
        tianLuoFlowMapper.saveFlow(buildFlowByTianLuo(tianluo));
    }
}

  • 事务不生效的原因：Propagation.NOT_SUPPORTED传播特性不支持事务。

  • 解决方案：选择正确的事务传播机制。

帮大家复习一下，Spring提供了七种事务传播机制。它们分别是：

  • REQUIRED（默认）：如果当前存在一个事务，则加入该事务；否则，创建一个新事务。该传播级别表示方法必须在事务中执行。

  • SUPPORTS：如果当前存在一个事务，则加入该事务；否则，以非事务的方式继续执行。

  • MANDATORY：如果当前存在一个事务，则加入该事务；否则，抛出异常。

  • REQUIRES_NEW：创建一个新的事务，并且如果存在一个事务，则将该事务挂起。

  • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在一个事务，则将该事务挂起。

  • NEVER：以非事务方式执行操作，如果当前存在一个事务，则抛出异常。

  • NESTED：如果当前存在一个事务，则在嵌套事务内执行。如果没有事务，则按REQUIRED传播级别执行。嵌套事务是外部事务的一部分，可以在外部事务提交或回滚时部分提交或回滚。

10. rollbackFor属性配置错误

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional(rollbackFor = Error.class)
    public void addTianLuo(TianLuo tianluo) {
        //保存tianluo数据库记录
        tianLuoMapper.save(tianluo);
        //保存tianluo流水数据库记录
        tianLuoFlowMapper.saveFlow(tianluo);
        //模拟异常抛出
        throw new Exception();
    }
}

  • 事务不生效的原因: 其实rollbackFor属性指定的异常必须是Throwable或者其子类。默认情况下，RuntimeException和Error两种异常都是会自动回滚的。但是因为以上的代码例子，指定了rollbackFor = Error.class，但是抛出的异常又是Exception，而Exception和Error没有任何什么继承关系，因此事务就不生效。

大家可以看一下Transactional注解源码哈：

  • 解决方案：rollbackFor属性指定的异常与抛出的异常匹配。

11.事务注解被覆盖导致事务失效

public interface MyRepository {
    @Transactional
    void save(String data);
}

public class MyRepositoryImpl implements MyRepository {
    @Override
    public void save(String data) {
        // 数据库操作
    }
}

public class MyService {

    @Autowired
    private MyRepository myRepository;

    @Transactional
    public void doSomething(String data) {
        myRepository.save(data);
    }
}

public class MyTianluoService extends MyService {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomething(String data) {
        super.doSomething(data);
    }
}

  • 事务失效的原因：MyTianluoService是MyService的子类，并且覆盖了doSomething()方法。在该方法中，使用了不同的传播行为（REQUIRES_NEW）来覆盖父类的@Transactional注解。在这种情况下，当调用MyTianluoService的doSomething()方法时，由于子类方法中的注解覆盖了父类的注解，Spring框架将不会在父类的方法中启动事务。因此，当MyRepository的save()方法被调用时，事务将不会被启动，也不会回滚。这将导致数据不一致的问题，因为在MyRepository的save()方法中进行的数据库操作将不会回滚。

12.嵌套事务的坑

@Service
public class TianLuoServiceInOutService {

    @Autowired
    private TianLuoFlowService tianLuoFlowService;
    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        tianLuoMapper.save(tianluo);
        tianLuoFlowService.saveFlow(tianluo);
    }
}

@Service
public class TianLuoFlowService {

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional(propagation = Propagation.NESTED)
    public void saveFlow(TianLuo tianLuo) {
        tianLuoFlowMapper.save(tianLuo);
        throw new RuntimeException();
    }
}

以上代码使用了嵌套事务，如果saveFlow出现运行时异常，会继续往上抛，到外层addTianLuo的方法，导致tianLuoMapper.save也会回滚啦。如果不想因为被内部嵌套的事务影响，可以用try-catch包住，如下：

    @Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        tianLuoMapper.save(tianluo);
        try {
            tianLuoFlowService.saveFlow(tianluo);
        } catch (Exception e) {
          log.error("save tian luo flow fail,message:{}",e.getMessage());
        }
    }

13. 事务多线程调用

@Service
public class TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Autowired
    private TianLuoFlowService tianLuoFlowService;

    @Transactional
    public void addTianLuo(TianLuo tianluo) {
        //保存tianluo数据库记录
        tianLuoMapper.save(tianluo);
        //多线程调用
        new Thread(() -> {
            tianLuoFlowService.saveFlow(tianluo);
        }).start();
    }
}

@Service
public class TianLuoFlowService {

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void save(TianLuo tianLuo) {
        tianLuoFlowMapper.saveFlow(tianLuo);
    }
}

  • 事务不生效原因：这是因为Spring事务是基于线程绑定的，每个线程都有自己的事务上下文，而多线程环境下可能会存在多个线程共享同一个事务上下文的情况，导致事务不生效。Spring事务管理器通过使用线程本地变量（ThreadLocal）来实现线程安全。大家有兴趣的话，可以去看下源码哈.

在Spring事务管理器中，通过TransactionSynchronizationManager类来管理事务上下文。TransactionSynchronizationManager内部维护了一个ThreadLocal对象，用来存储当前线程的事务上下文。在事务开始时，TransactionSynchronizationManager会将事务上下文绑定到当前线程的ThreadLocal对象中，当事务结束时，TransactionSynchronizationManager会将事务上下文从ThreadLocal对象中移除。

14.异常被捕获并处理了，没有重新抛出

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) {
        try {
            //保存tianluo数据库记录
            tianLuoMapper.save(tianluo);
            //保存tianluo flow数据库记录
            tianLuoFlowMapper.saveFlow(tianluo);
        } catch (Exception e) {
            log.error("add TianLuo error,id:{},message:{}", tianluo.getId(),e.getMessage());
        }
    }

}

  • 事务不生效的原因: 事务中的异常已经被业务代码捕获并处理，而没有被正确地传播回事务管理器，事务将无法回滚。我们可以从spring源码(TransactionAspectSupport这个类)中找到答案：

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {

 //这方法会省略部分代码，只留关键代码哈
  @Nullable
 protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable {

  if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
  
   TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
   Object retVal;
   try {
        //Spring AOP中MethodInterceptor接口的一个方法，它允许拦截器在执行被代理方法之前和之后执行额外的逻辑。
    retVal = invocation.proceedWithInvocation();
   }
   catch (Throwable ex) {
        //用于在发生异常时完成事务(如果Spring catch不到对应的异常的话，就不会进入回滚事务的逻辑)
    completeTransactionAfterThrowing(txInfo, ex);
    throw ex;
   }
   finally {
    cleanupTransactionInfo(txInfo);
   }

      //用于在方法正常返回后提交事务。
   commitTransactionAfterReturning(txInfo);
   return retVal;
  }
}

在invokeWithinTransaction方法中，当Spring catch到Throwable异常的时候，就会调用completeTransactionAfterThrowing()方法进行事务回滚的逻辑。但是，在TianLuoServiceImpl类的spring事务方法addTianLuo中，直接把异常catch住了，并没有重新throw出来，因此 Spring自然就catch不到异常啦，因此事务回滚的逻辑就不会执行，事务就失效了。

  • 解决方案：在spring事务方法中，当我们使用了try-catch，如果catch住异常，记录完异常日志什么的，一定要重新把异常抛出来，正例如下：

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;

    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional(rollbackFor = Exception.class)
    public void addTianLuo(TianLuo tianluo) {
        try {
            //保存tianluo数据库记录
            tianLuoMapper.save(tianluo);
            //保存tianluo flow数据库记录
            tianLuoFlowMapper.saveFlow(tianluo);
        } catch (Exception e) {
            log.error("add TianLuo error,id:{},message:{}", tianluo.getId(),e.getMessage());
            throw e;
        }
    }
}

15. 手动抛了别的异常

@Service
public class TianLuoServiceImpl implements TianLuoService {

    @Autowired
    private TianLuoMapper tianLuoMapper;
    
    @Autowired
    private TianLuoFlowMapper tianLuoFlowMapper;

    @Transactional
    public void addTianLuo(TianLuo tianluo) throws Exception {
        //保存tianluo数据库记录
        tianLuoMapper.save(tianluo);
        //保存tianluo流水数据库记录
        tianLuoFlowMapper.saveFlow(tianluo);
        throw new Exception();
    }
}

  • 失效的原因：上面的代码例子中，手动抛了Exception异常，但是是不会回滚的，因为Spring默认只处理RuntimeException和Error，对于普通的Exception不会回滚，除非，用rollbackFor属性指定配置。

  • 解决方案：添加属性配置@Transactional(rollbackFor = Exception.class)。

注解为事务范围的方法中，事务的回滚仅仅对于unchecked的异常有效。对于checked异常无效。也就是说事务回滚仅仅发生在，出现RuntimeException或Error的时候。通俗一点就是：代码中出现的空指针等异常，会被回滚。而文件读写、网络超时问题等，spring就没法回滚了。

Javatutouhouduan
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
面试官：Spring 注解 @After,@Around,@Before 的执行顺序是？.zip
03-02
面试官：Spring 注解 @After,@Around,@Before 的执行顺序是？.zip 面试官：Spring 注解 @After,@Around,@Before 的执行顺序是？.zip 面试官：Spring 注解 @After,@Around,@Before 的执行顺序是？.zip 面试官：...
事务失效的几种情况
blue_stars_的博客
10-18 146
事务失效的情况有以下几种：
spring中事务失效的情况（常见的5种）
荣山的博客
06-25 2155
spring中事务失效的情况（常见的5种）
事务 失效的八种情况
jyx_boy的博客
03-07 901
为了保证事务的正确执行，应该在整个业务逻辑的最外层进行事务的开始和结束操作，并正确处理异常、设置正确的隔离级别，同时注意数据库连接的正确性和并发操作的冲突。3. 事务的传播行为：如果新线程的异步操作在事务方法内部，且事务传播行为为REQUIRED_NEW（新建事务），则新线程将会开启一个新的事务，与原事务无关，导致事务失效。2. 事务隔离级别不正确：事务的隔离级别决定了事务对并发操作的影响程度，如果在类内部进行了对事务隔离级别的设置，可能会导致事务的隔离级别不正确，从而导致事务失效。
Spring事务失效的 8 大原因，这次可以吊打面试官了！
骏马逸动，心随你动的博客
01-07 1197
1、数据库引擎不支持事务 这里以 MySQL 为例，其 MyISAM 引擎是不支持事务操作的，InnoDB 才是支持事务的引擎，一般要支持事务都会使用 InnoDB。 根据 MySQL 的官方文档： https://dev.mysql.com/doc/refman/5.5/en/storage-engine-setting.html 从 MySQL 5.5.5 开始的默认存储引擎是：...
笔记-事务失效的12种场景
weixin_33427346的博客
06-12 1677
事务失效的场景
Spring事务失效的各种场景
Daylight629博客
07-17 3168
关于事务失效的各种场景
同一个Service类中非事务方法 调用 事务方法，事务失效 解决方法
佬涛的博客
05-26 3542
方法1.将需要进行事务管理的方法单独写到一个Service文件中 方法2.在该Service类中注入自己，使用注入的自己进行调用事务方法 方法3.使用 AopContext.currentProxy() 获取代理对象
【Spring事物三千问】如何快速判断Spring项目中的事务是否生效？
老王的专栏
02-27 1363
如果 Spring 的事务没有生效，很有可能导致严重的生产问题，自己的能力也会受到组员和领导的质疑。那么，刚接手一个新项目，或者搭建了一个新项目，如何快速的判断我们的事务配置是否生效？
事务失效的几种原因
Laoluyoudu的博客
03-21 1118
其实原因很简单，Spring在扫描Bean的时候会自动为标注了@Transactional注解的类生成一个代理类（proxy）,当有注解的方法被调用的时候，实际上是代理类调用的，代理类在调用之前会开启事务，执行事务的操作，但是同类中的方法互相调用，相当于this.B()，此时的B方法并非是代理类调用，而是直接通过原有的Bean直接调用，所以注解会失效。因为注解是 不能继承 的，这就意味着如果正在使用基于类的代理时，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。
Spring 事务失效的六种情况
z_ssyy的博客
06-15 743
数据库事务是指作为单个逻辑工作单元执行的一系列操作，这些操作要么一起成功，要么一起失败，是一个不可分割的工作单元。在我们日常工作中，涉及到事务的场景非常多，一个 service 中往往需要调用不同的 dao 层方法，这些方法要么同时成功要么同时失败，我们需要在 service 层确保这一点。
详解spring中aop不生效的几种解决办法
08-19
主要介绍了详解spring中aop不生效的几种解决办法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【面试】Spring事务面试考点吐血整理（建议珍藏）
08-26
本文是小编给大家收藏整理的Spring事务面试考点，非常不错，值得收藏，感兴趣的朋友参考下吧
hualinux spring 3.17：Spring事务.pdf
06-25
hualinux spring xml开发系列 hualinux spring 3.17：Spring事务.pdf 文字版
开源框架面试题系列：Spring+SpringMVC+MyBatis.zip
06-30
开源框架面试题系列：Spring+SpringMVC+MyBatis.zip
SpringBoot引入第三方jar包或本地jar包
zhourongxiang1的博客
04-23 284
在resources中新建jar目录，将第三方jar包fastjson2-2.0.47.jar放入其中。打完的war包在“D:\迅雷下载\snakerflow-master(1)\demoJar\target\demo-0.0.1-SNAPSHOT.war”中。),有两个Maven选择这一个。pom.xml中version改成2.5.10。pom.xml中添加configuration。pom.xml中添加dependence。pom.xml中再添加packaging。勾选Spring Web。
No spring.config.import property has been defined
一个写了10年bug的程序员日常笔记。
04-18 705
运行Springcloud项目出现下面错误：Description:No spring.config.import property has been definedAction:Add a spring.config.import=nacos: property to your configuration. If configuration is not required add spring.config.import=optional:nacos: instead. To disabl
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
最新发布
xzy的博客
04-23 442
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
Spring的事务在哪几种场景下会失效？为什么
05-17
Spring的事务在以下几种场景下会失效： 1. 非public方法：Spring的事务是通过AOP实现的，只有public方法才能被代理，如果一个方法不是public的，则无法被代理，事务也就无法生效。 2. 静态方法：静态方法和非public方法类似，也无法被代理，因此事务也无法生效。 3. 异常被catch：当在事务范围内的方法抛出异常时，如果该异常被catch住了，Spring就无法感知到异常的存在，也就无法回滚事务。因此，在捕获异常的情况下，需要手动回滚事务。 4. 事务方法内部调用本类的其他方法：Spring的事务是基于AOP实现的，只有通过代理对象调用方法，才能使事务生效，因此，如果在事务方法内部调用本类的其他方法，事务也无法生效。 5. 事务方法和非事务方法混合使用：如果在事务方法中调用了一个非事务方法，那么该非事务方法的操作不会被纳入到事务管理中，因此，如果该方法抛出异常，事务也不会回滚。 6. 多个事务方法互相调用：如果多个事务方法互相调用，每个方法都有独立的事务，事务之间无法相互协调，也就无法保证事务的一致性。 以上是Spring事务失效的一些场景，需要在开发时特别注意。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值