Spring事物失效的几种场景

╰+攻爆jí腚メ 2022-09-10 05:19 212阅读 0赞

### Spring事物失效的几种场景 ###

*  1. 业务概述
 *  2. 异常场景
 *   *  2.1 事务不生效
     *   *  2.1.1 访问权限问题
         *  2.1.2 方法用final修饰
         *  2.1.3 方法内部调用
         *  2.1.4 未被spring管理
         *  2.1.5 多线程调用
         *  2.1.6 表不支持事务
         *  2.1.7 未开启事务
     *  2.2 事务不回滚
     *   *  2.2.1 错误的传播特性
         *  2.2.2 捕获异常
         *  2.2.3 手动抛了别的异常
         *  2.2.4 自定义了回滚异常
         *  2.2.5 嵌套事务回滚多了
     *  2.3 其他情况
     *   *  2.3.1 大事务问题
         *  2.3.2 编程试事物
 *  3. 实现验证
 *   *  3.1 GoodsController
     *  3.2 GoodsService
     *  3.3 GoodsServiceImpl

# 1. 业务概述 #

日常开发中事物的使用非常常见，就是为了保证数据库的四大特性ACID，原子，一致，隔离，持久中的原子性，尤其是一个接口涉及多个操作，又要保证操作的数据原子性，事物就是解决此问题的，但是在使用过程中会存在一些事物失效的场景。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Z2W6IqC5YWI55Sf_size_20_color_FFFFFF_t_70_g_se_x_16]

# 2. 异常场景 #

## 2.1 事务不生效 ##

### 2.1.1 访问权限问题 ###

众所周知，java的访问权限主要有四种：private、default、protected、public，它们的权限从左到右，依次变大。

但如果我们在开发过程中，把有某些事务方法，定义了错误的访问权限，就会导致事务功能出问题，例如：

/** * 事务不生效 * 1.访问权限问题。 * private void add(Goods goods) {} * 虽然这种情况理论上存在，但是实际开发中绝对不会存在！！！ * 因为private修饰的方法其他类调用不了，编译就会不通过。 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        //private void addPrivate(Goods goods) { 
        public void addPrivate(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }

### 2.1.2 方法用final修饰 ###

有时候，某个方法不想被子类重新，这时可以将该方法定义成final的。普通方法这样定义是没问题的，但如果将事务方法定义成final，例如：

/** * 事务不生效 * 2. 方法用final修饰 * 提示：Methods annotated with '@Transactional' must be overridable * 虽然有提示事物注解不能有final修饰，但是可以编译通过 * 事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public final void addFinal(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }

### 2.1.3 方法内部调用 ###

有时候我们需要在某个Service类的某个方法中，调用另外一个事务方法，比如：

/** * 事务不生效 * 3.方法内部调用 * 实现：有时候我们需要在某个Service类的某个方法中，调用另外一个事务方法 * 验证：事物不会回滚，新增成功，更新失败 * 如果有些场景，确实想在同一个类的某个方法中，调用它自己的另外一个方法，该怎么办呢？ * 新加一个Service方法 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addMethod(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            // 事物修改
            updateTransactional(goods);
        }

这个方法非常简单，只需要新加一个Service方法，把@Transactional注解加到新Service方法上，把需要事务执行的代码移到新方法中。具体代码如下：

@Servcie
    public class ServiceA { 
       @Autowired
       prvate ServiceB serviceB;
    
       public void save(User user) { 
             queryData1();
             queryData2();
             serviceB.doSave(user);
       }
     }
    
     @Servcie
     public class ServiceB { 
    
        @Transactional(rollbackFor=Exception.class)
        public void doSave(User user) { 
           addData1();
           updateData2();
        }
    
     }

### 2.1.4 未被spring管理 ###

在我们平时开发过程中，有个细节很容易被忽略。即使用spring事务的前提是：对象要被spring管理，需要创建bean实例。

通常情况下，我们通过@Controller、@Service、@Component、@Repository等注解，可以自动实现bean实例化和依赖注入的功能。

/** * 事务不生效 * 4.未被spring管理 * 实现：对象要被spring管理，需要创建bean实例。去掉@Controller、@Service、@Component、@Repository等注解，可以自动实现bean实例化和依赖注入的功能。 * 验证：这种情况下比如去掉@Service，在Controller或者其他service都无法注入，肯定异常，一般不会发生 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addNoSpring(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            update(goods);
        }

### 2.1.5 多线程调用 ###

在实际项目开发中，多线程的使用场景还是挺多的。如果spring事务用在多线程场景中

/** * 事务不生效 * 5.多线程调用 * 实现：多线程情况下第一一条还没抛出异常，第二条可能已经成功提交，所以在事物内多线程操作事物失效 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addMulThread(Goods goods) { 
            for (int i = 10; i < 15; i++) { 
                int finalI = i;
                goods.setId((long) finalI);
                goods.setGoodsName(goods.getGoodsName() + finalI);
    
                // 异常数据
                if (i == 11 || i == 12) { 
                    pool.execute(() -> { 
                        insertException(goods);
                    });
                }
                //正常数据
                pool.execute(() -> { 
                    insert(goods);
                });
            }
        }

### 2.1.6 表不支持事务 ###

周所周知，在mysql5之前，默认的数据库引擎是myisam。

它的好处就不用多说了：索引文件和数据文件是分开存储的，对于查多写少的单表操作，性能比innodb更好。

有些老项目中，可能还在用它。

在创建表的时候，只需要把ENGINE参数设置成MyISAM即可：

CREATE TABLE `category` (
      `id` bigint NOT NULL AUTO_INCREMENT,
      `one_category` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      `two_category` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      `three_category` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      `four_category` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=MyISAM AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

myisam好用，但有个很致命的问题是：不支持事务。

如果只是单表操作还好，不会出现太大的问题。但如果需要跨多张表操作，由于其不支持事务，数据极有可能会出现不完整的情况。

此外，myisam还不支持行锁和外键。

所以在实际业务场景中，myisam使用的并不多。在mysql5以后，myisam已经逐渐退出了历史的舞台，取而代之的是innodb。

### 2.1.7 未开启事务 ###

如果你使用的是springboot项目，那么你很幸运。因为springboot通过DataSourceTransactionManagerAutoConfiguration类，已经默默的帮你开启了事务。

## 2.2 事务不回滚 ##

### 2.2.1 错误的传播特性 ###

其实，我们在使用@Transactional注解时，是可以指定propagation参数的。

该参数的作用是指定事务的传播特性，spring目前支持7种传播特性：

REQUIRED 如果当前上下文中存在事务，那么加入该事务，如果不存在事务，创建一个事务，这是默认的传播属性值。  
SUPPORTS 如果当前上下文存在事务，则支持事务加入事务，如果不存在事务，则使用非事务的方式执行。  
MANDATORY 如果当前上下文中存在事务，否则抛出异常。  
REQUIRES\_NEW 每次都会新建一个事务，并且同时将上下文中的事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。  
NOT\_SUPPORTED 如果当前上下文中存在事务，则挂起当前事务，然后新的方法在没有事务的环境中执行。  
NEVER 如果当前上下文中存在事务，则抛出异常，否则在无事务环境上执行代码。  
NESTED 如果当前上下文中存在事务，则嵌套事务执行，如果不存在事务，则新建事务。  
如果我们在手动设置propagation参数的时候，把传播特性设置错了，比如：

/** * 事务不生效 * 7.未开启事务 * 实现：如果你使用的是springboot项目，那么你很幸运。因为springboot通过DataSourceTransactionManagerAutoConfiguration类，已经默默的帮你开启了事务。 * 8.我们在使用@Transactional注解时，是可以指定propagation参数的。 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class, propagation = Propagation.NEVER)
        public void addSpread(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            // 由于指定了事物传播属性，所以never下不会回滚
            updateException(goods);
        }

### 2.2.2 捕获异常 ###

/** * 事务不生效 * 2.捕获异常 * 实现：捕获异常后没有抛出，事物检测不到异常自然不会回滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addTry(Goods goods) { 
            try { 
                insert(goods);
                goods.setGoodsName(goods.getGoodsName() + "up");
                // 由于指定了事物传播属性，所以never下不会回滚
                updateException(goods);
            } catch (Exception e) { 
                System.out.println("异常啦：" + e);
            }
        }

### 2.2.3 手动抛了别的异常 ###

即使开发者没有手动捕获异常，但如果抛的异常不正确，spring事务也不会回滚。

/** * 事务不生效 * 3.手动抛了别的异常 * 实现：手动捕获异常后抛出，事物检测不到异常，事物不会滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addThrow(Goods goods) throws Exception { 
            try { 
                insert(goods);
                goods.setGoodsName(goods.getGoodsName() + "up");
                // 由于指定了事物传播属性，所以never下不会回滚
                updateException(goods);
            } catch (Exception e) { 
                System.out.println("异常啦：" + e);
                throw new Exception(e);
            }
        }

### 2.2.4 自定义了回滚异常 ###

在使用@Transactional注解声明事务时，有时我们想自定义回滚的异常，spring也是支持的。可以通过设置rollbackFor参数，来完成这个功能。

/** * 事务不生效 * 4.自定义了回滚异常 * 实现：指定或者自定义指定异常，事物只检测指定异常，其他异常不会滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = ArrayIndexOutOfBoundsException.class)
        public void addRollBack(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }

### 2.2.5 嵌套事务回滚多了 ###

/** * 事务不生效 * 5.嵌套事务回滚多了 * 实现： * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addNested(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }

## 2.3 其他情况 ##

### 2.3.1 大事务问题 ###

事物内容涉及到比较多的操作，导致超时问题等。

### 2.3.2 编程试事物 ###

事物分为编程式事务与声明式事务，编程是比较灵狐，手动代码里处理，但是耦合性太强，不移维护。

@Autowired
    private TransactionTemplate transactionTemplate;
    
    public void ad(){ 
    	 transactionTemplate.execute(()->{ 
    		// 执行操作
    	})
    }

# 3. 实现验证 #

## 3.1 GoodsController ##

package com.example.category.controller;
    
    import com.example.category.entity.Goods;
    import com.example.category.service.GoodsService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.web.bind.annotation.*;
    import com.example.category.entity.Response;
    
    import javax.annotation.Resource;
    
    /** * 商品表(Goods)控制层 * 事务不生效测试 * * @author zrj * @since 2021-09-05 10:48:26 */
    @RestController
    @Api(tags = "商品管理", description = "商品管理")
    @RequestMapping("/goods")
    public class GoodsController { 
    
        @Resource
        private GoodsService goodsService;
    
        /** * 事物新增商品 */
        @ApiOperation(value = "事物新增商品")
        @RequestMapping(value = "add", method = RequestMethod.POST)
        public Response<Integer> add(@RequestBody Goods goods) { 
            //正常事物
            //goodsService.addNormal(goods);
    
            //1访问权限问题
            //goodsService.addPrivate(goods);
    
            //2方法用final修饰
            //goodsService.addFinal(goods);
    
            //3方法内部调用
            //goodsService.addMethod(goods);
    
            //4未被spring管理
            //goodsService.addNoSpring(goods);
    
            //5多线程调用
            //goodsService.addMulThread(goods);
    
            //6表不支持事物
            //goodsService.addTableNoSupport(goods);
    
            //7事物传播错误
            //goodsService.addSpread(goods);
    
            //8捕获异常
            goodsService.addTry(goods);
    
            //9手动抛出异常
            //goodsService.addThrow(goods);
    
            //10自定义回滚
            //goodsService.addRollBack(goods);
    
            //11嵌套事物回滚异常
            //goodsService.addNested(goods);
            return Response.success("新增成功", null);
        }
    
        /** * 新增商品 */
        @ApiOperation(value = "新增商品")
        @RequestMapping(value = "insert", method = RequestMethod.POST)
        public Response<Integer> insert(@RequestBody Goods goods) { 
            int result = goodsService.insert(goods);
            if (result > 0) { 
                return Response.success("新增成功", result);
            }
            return Response.fail("新增失败");
        }
    
        /** * 修改商品 */
        @ApiOperation(value = "修改商品")
        @RequestMapping(value = "update", method = RequestMethod.PUT)
        public Response<Integer> update(@RequestBody Goods goods) { 
            int result = goodsService.update(goods);
            if (result > 0) { 
                return Response.success("修改成功", result);
            }
            return Response.fail("修改失败");
        }
    }

## 3.2 GoodsService ##

package com.example.category.service;
    
    import com.example.category.entity.Goods;
    
    import java.util.List;
    import java.util.Map;
    
    /** * 商品服务接口 * * @author zrj * @since 2021-09-05 */
    public interface GoodsService { 
    
        /** * 正常事物 */
        void addNormal(Goods goods);
    
        /** * 访问权限问题 */
        void addPrivate(Goods goods);
    
        /** * 方法用final修饰 */
        void addFinal(Goods goods);
    
        /** * 方法内部调用 */
        void addMethod(Goods goods);
    
        /** * 未被spring管理 */
        void addNoSpring(Goods goods);
    
        /** * 多线程调用 */
        void addMulThread(Goods goods);
    
        /** * 表不支持事物 */
        void addTableNoSupport(Goods goods);
    
        /** * 错误事物传播特性 */
        void addSpread(Goods goods);
    
        /** * 捕获异常 */
        void addTry(Goods goods);
    
        /** * 手动抛出异常 */
        void addThrow(Goods goods) throws Exception;
    
        /** * 自定义回归异常 */
        void addRollBack(Goods goods);
    
        /** * 嵌套事物回滚异常 */
        void addNested(Goods goods);
    
        /** * 新增数据 */
        int insert(Goods goods);
    
        /** * 异常新增数据 */
        int insertException(Goods goods);
    
        /** * 修改数据 */
        int update(Goods goods);
    
        /** * 异常修改数据 */
        int updateException(Goods goods);
    
        /** * 事物修改数据 */
        int updateTransactional(Goods goods);
    
    }

## 3.3 GoodsServiceImpl ##

package com.example.category.service.impl;
    
    import com.example.category.entity.Goods;
    import com.example.category.mapper.GoodsMapper;
    import com.example.category.service.GoodsService;
    import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import javax.annotation.Resource;
    import java.util.concurrent.*;
    
    /** * 商品服务实现类 * * @author zrj * @since 2021-09-05 */
    @Service("goodsService")
    public class GoodsServiceImpl implements GoodsService { 
        // 自定义线程名称
        private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-%d").build();
        // 定义线程池
        private static ExecutorService pool = new ThreadPoolExecutor(30, 200, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
    
        @Resource
        private GoodsMapper goodsMapper;
    
        /** * 正常事务 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addNormal(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            update(goods);
        }
    
        /** * 事务不生效 * 1.访问权限问题。 * private void add(Goods goods) {} * 虽然这种情况理论上存在，但是实际开发中绝对不会存在！！！ * 因为private修饰的方法其他类调用不了，编译就会不通过。 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        //private void addPrivate(Goods goods) { 
        public void addPrivate(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }
    
        /** * 事务不生效 * 2. 方法用final修饰 * 提示：Methods annotated with '@Transactional' must be overridable * 虽然有提示事物注解不能有final修饰，但是可以编译通过 * 事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public final void addFinal(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }
    
        /** * 事务不生效 * 3.方法内部调用 * 实现：有时候我们需要在某个Service类的某个方法中，调用另外一个事务方法 * 验证：事物不会回滚，新增成功，更新失败 * 如果有些场景，确实想在同一个类的某个方法中，调用它自己的另外一个方法，该怎么办呢？ * 新加一个Service方法 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addMethod(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            // 事物修改
            updateTransactional(goods);
        }
    
        /** * 事务不生效 * 4.未被spring管理 * 实现：对象要被spring管理，需要创建bean实例。去掉@Controller、@Service、@Component、@Repository等注解，可以自动实现bean实例化和依赖注入的功能。 * 验证：这种情况下比如去掉@Service，在Controller或者其他service都无法注入，肯定异常，一般不会发生 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addNoSpring(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            update(goods);
        }
    
        /** * 事务不生效 * 5.多线程调用 * 实现：多线程情况下第一一条还没抛出异常，第二条可能已经成功提交，所以在事物内多线程操作事物失效 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addMulThread(Goods goods) { 
            for (int i = 10; i < 15; i++) { 
                int finalI = i;
                goods.setId((long) finalI);
                goods.setGoodsName(goods.getGoodsName() + finalI);
    
                // 异常数据
                if (i == 11 || i == 12) { 
                    pool.execute(() -> { 
                        insertException(goods);
                    });
                }
                //正常数据
                pool.execute(() -> { 
                    insert(goods);
                });
            }
        }
    
        /** * 事务不生效 * 6.表不支持事务 * 实现：在创建表的时候，只需要把ENGINE参数设置成MyISAM即可： * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addTableNoSupport(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            update(goods);
        }
    
        /** * 事务不生效 * 7.未开启事务 * 实现：如果你使用的是springboot项目，那么你很幸运。因为springboot通过DataSourceTransactionManagerAutoConfiguration类，已经默默的帮你开启了事务。 * 8.我们在使用@Transactional注解时，是可以指定propagation参数的。 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class, propagation = Propagation.NEVER)
        public void addSpread(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            // 由于指定了事物传播属性，所以never下不会回滚
            updateException(goods);
        }
    
        /** * 事务不生效 * 2.捕获异常 * 实现：捕获异常后没有抛出，事物检测不到异常自然不会回滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addTry(Goods goods) { 
            try { 
                insert(goods);
                goods.setGoodsName(goods.getGoodsName() + "up");
                // 由于指定了事物传播属性，所以never下不会回滚
                updateException(goods);
            } catch (Exception e) { 
                System.out.println("异常啦：" + e);
            }
        }
    
        /** * 事务不生效 * 3.手动抛了别的异常 * 实现：手动捕获异常后抛出，事物检测不到异常，事物不会滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addThrow(Goods goods) throws Exception { 
            try { 
                insert(goods);
                goods.setGoodsName(goods.getGoodsName() + "up");
                // 由于指定了事物传播属性，所以never下不会回滚
                updateException(goods);
            } catch (Exception e) { 
                System.out.println("异常啦：" + e);
                throw new Exception(e);
            }
        }
    
        /** * 事务不生效 * 4.自定义了回滚异常 * 实现：指定或者自定义指定异常，事物只检测指定异常，其他异常不会滚 * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = ArrayIndexOutOfBoundsException.class)
        public void addRollBack(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }
    
        /** * 事务不生效 * 5.嵌套事务回滚多了 * 实现： * 验证：事物不会回滚，新增成功，更新失败 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public void addNested(Goods goods) { 
            insert(goods);
            goods.setGoodsName(goods.getGoodsName() + "up");
            updateException(goods);
        }
    
        /** * 新增数据 */
        @Override
        public int insert(Goods goods) { 
            return this.goodsMapper.insert(goods);
        }
    
        /** * 异常新增数据 */
        @Override
        public int insertException(Goods goods) { 
            int result = 0;
            try { 
                int res = 1 / 0;
                this.goodsMapper.insert(goods);
            } catch (Exception e) { 
                throw new RuntimeException("更新失败啦，哈哈哈");
            }
            return result;
        }
    
        /** * 正常修改数据 */
        @Override
        public int update(Goods goods) { 
            return this.goodsMapper.update(goods);
        }
    
        /** * 异常修改数据 */
        @Override
        public int updateException(Goods goods) { 
            int result = 0;
            try { 
                int res = 1 / 0;
                this.goodsMapper.update(goods);
            } catch (Exception e) { 
                throw new RuntimeException("更新失败啦，哈哈哈");
            }
            return result;
        }
    
        /** * 事物修改数据 */
        @Override
        @Transactional(rollbackFor = Exception.class)
        public int updateTransactional(Goods goods) { 
            int result = 0;
            try { 
                int res = 1 / 0;
                this.goodsMapper.update(goods);
            } catch (Exception e) { 
                throw new RuntimeException("更新失败啦，哈哈哈");
            }
            return result;
        }
    
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6Z2W6IqC5YWI55Sf_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/578cae1823534962ac0412de084d364e.png