devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring学习之声明式事务（Spring事务学习这一篇足够了）_spring声明式事务

作者：羊村懒王 | 2024-06-12 10:31:55

赞

踩

spring声明式事务

目录

一、Spring声明式事务

1.1 声明式事务概念

1.1.1 编程式事务

1.1.2 声明式事务

1.1.3 二者的区别：

1.2 Spring事务管理器

1.2.1、Spring声明式事务对应依赖

1.2.2、Spring声明式事务对应事务管理器接口

二、基于注解的声明式事务

2.1 准备项目

2.2 事务添加

2.3 事务属性：只读

2.3.1.  只读介绍

2.3.2.  设置方式

2.3.3.  针对DML动作设置只读模式

2.3.4.  @Transactional注解放在类上

    1.  生效原则

    2.  用法举例

2.4 事务属性：超时时间

2.4.1.  需求

2.4.2.  设置超时时间

2.5 事务属性：事务异常

2.5.1.  默认情况

2.5.2.  设置回滚异常

2.5.3.  设置不回滚的异常

2.6 事务属性：事务隔离级别

2.6.1.  事务隔离级别

2.6.2.  事务隔离级别设置

2.7 事务属性：事务传播行为

2.7.1.  事务传播行为要研究的问题

2.7.2.  propagation属性

2.7.3.  测试

1.  声明两个业务方法

    2.  声明一个整合业务方法

 3.  添加传播行为测试

注意：

4.  其他传播行为值（了解）

一、Spring声明式事务

1.1 声明式事务概念

1.1.1 编程式事务

编程式事务是指手动编写程序来管理事务，即通过编写代码的方式直接控制事务的提交和回滚。在 Java 中，通常使用事务管理器(如 Spring 中的 `PlatformTransactionManager`)来实现编程式事务。

编程式事务的主要优点是灵活性高，可以按照自己的需求来控制事务的粒度、模式等等。但是，编写大量的事务控制代码容易出现问题，对代码的可读性和可维护性有一定影响。

  1. Connection conn = ...;
  2.   
  3. try {
  4.     // 开启事务：关闭事务的自动提交
  5.     conn.setAutoCommit(false);
  6.     // 核心操作
  7.     // 业务代码
  8.     // 提交事务
  9.     conn.commit();
  10.   
  11. }catch(Exception e){
  12.   
  13.     // 回滚事务
  14.     conn.rollBack();
  15.   
  16. }finally{
  17.   
  18.     // 释放数据库连接
  19.     conn.close();
  20.   
  21. }

编程式的实现方式存在缺陷：

-   细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

-   代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

1.1.2 声明式事务

声明式事务是指使用注解或 XML 配置的方式来控制事务的提交和回滚。

开发者只需要添加配置即可， 具体事务的实现由第三方框架实现，避免我们直接进行事务操作！

使用声明式事务可以将事务的控制和业务逻辑分离开来，提高代码的可读性和可维护性。

1.1.3 二者的区别：

-   编程式事务需要手动编写代码来管理事务

-   而声明式事务可以通过配置文件或注解来控制事务。

1.2 Spring事务管理器

我们在学习Spring事务的过程中就需要用到Spring事务管理器。

1.2.1、Spring声明式事务对应依赖

    -   spring-tx: 包含声明式事务实现的基本规范（事务管理器规范接口和事务增强等等）

    -   spring-jdbc: 包含DataSource方式事务管理器实现类DataSourceTransactionManager

    -   spring-orm: 包含其他持久层框架的事务管理器实现类例如：Hibernate/Jpa等

1.2.2、Spring声明式事务对应事务管理器接口

    ![](image/image_s2BCX_Qltm.png)

我们现在要使用的事务管理器是org.springframework.jdbc.datasource.DataSourceTransactionManager，将来整合 JDBC方式、JdbcTemplate方式、Mybatis方式的事务实现！

    DataSourceTransactionManager类中的主要方法：

    -   doBegin()：开启事务

    -   doSuspend()：挂起事务

    -   doResume()：恢复挂起的事务

    -   doCommit()：提交事务

    -   doRollback()：回滚事务

二、基于注解的声明式事务

2.1 准备项目

pom依赖

  1. <dependencies>
  2.       <!--spring context依赖-->
  3.       <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
  4.       <dependency>
  5.           <groupId>org.springframework</groupId>
  6.           <artifactId>spring-context</artifactId>
  7.           <version>6.0.6</version>
  8.       </dependency>
  9.  
  10.       <!--junit5测试-->
  11.       <dependency>
  12.           <groupId>org.junit.jupiter</groupId>
  13.           <artifactId>junit-jupiter-api</artifactId>
  14.           <version>5.3.1</version>
  15.       </dependency>
  16.  
  17.  
  18.       <dependency>
  19.           <groupId>org.springframework</groupId>
  20.           <artifactId>spring-test</artifactId>
  21.           <version>6.0.6</version>
  22.           <scope>test</scope>
  23.       </dependency>
  24.  
  25.       <dependency>
  26.           <groupId>jakarta.annotation</groupId>
  27.           <artifactId>jakarta.annotation-api</artifactId>
  28.           <version>2.1.1</version>
  29.       </dependency>
  30.  
  31.       <!-- 数据库驱动 和 连接池-->
  32.       <dependency>
  33.           <groupId>mysql</groupId>
  34.           <artifactId>mysql-connector-java</artifactId>
  35.           <version>8.0.25</version>
  36.       </dependency>
  37.  
  38.       <dependency>
  39.           <groupId>com.alibaba</groupId>
  40.           <artifactId>druid</artifactId>
  41.           <version>1.2.8</version>
  42.       </dependency>
  43.  
  44.       <!-- spring-jdbc -->
  45.       <dependency>
  46.           <groupId>org.springframework</groupId>
  47.           <artifactId>spring-jdbc</artifactId>
  48.           <version>6.0.6</version>
  49.       </dependency>
  50.  
  51.       <!-- 声明式事务依赖-->
  52.       <dependency>
  53.           <groupId>org.springframework</groupId>
  54.           <artifactId>spring-tx</artifactId>
  55.           <version>6.0.6</version>
  56.       </dependency>
  57.  
  58.  
  59.       <dependency>
  60.           <groupId>org.springframework</groupId>
  61.           <artifactId>spring-aop</artifactId>
  62.           <version>6.0.6</version>
  63.       </dependency>
  64.  
  65.       <dependency>
  66.           <groupId>org.springframework</groupId>
  67.           <artifactId>spring-aspects</artifactId>
  68.           <version>6.0.6</version>
  69.       </dependency>
  70.     </dependencies>

配置文件jdbc.properties

  1. gedeshidai.driver=com.mysql.jdbc.Driver
  2. gedeshidai.url=jdbc:mysql://localhost:3306/studb?serverTimezone=UTC&characterEncoding=utf8
  3. gedeshidai.username=root
  4. gedeshidai.password=root

Spring配置文件

  1. @Configuration
  2.     @ComponentScan("com.gedeshidai")
  3.     @PropertySource("classpath:jdbc.properties")
  4.     public class JavaConfig {
  5.  
  6.         @Value("${gedeshidai.driver}")
  7.         private String driver;
  8.         @Value("${gedeshidai.url}")
  9.         private String url;
  10.         @Value("${gedeshidai.username}")
  11.         private String username;
  12.         @Value("${gedeshidai.password}")
  13.         private String password;
  14.  
  15.  
  16.  
  17.         //druid连接池
  18.         @Bean
  19.         public DataSource dataSource(){
  20.             DruidDataSource dataSource = new DruidDataSource();
  21.             dataSource.setDriverClassName(driver);
  22.             dataSource.setUrl(url);
  23.             dataSource.setUsername(username);
  24.             dataSource.setPassword(password);
  25.             return dataSource;
  26.         }
  27.  
  28.  
  29.         @Bean
  30.         //jdbcTemplate
  31.         public JdbcTemplate jdbcTemplate(DataSource dataSource){
  32.             JdbcTemplate jdbcTemplate = new JdbcTemplate();
  33.             jdbcTemplate.setDataSource(dataSource);
  34.             return jdbcTemplate;
  35.         }
  36.  
  37.     }

dao层

  1. @Repository
  2.     public class StudentDao {
  3.         
  4.         @Autowired
  5.         private JdbcTemplate jdbcTemplate;
  6.         
  7.         public void updateNameById(String name,Integer id){
  8.             String sql = "update students set name = ? where id = ? ;";
  9.             int rows = jdbcTemplate.update(sql, name, id);
  10.         }
  11.  
  12.         public void updateAgeById(Integer age,Integer id){
  13.             String sql = "update students set age = ? where id = ? ;";
  14.             jdbcTemplate.update(sql,age,id);
  15.         }
  16.     }

service层

  1. @Service
  2.     public class StudentService {
  3.         
  4.         @Autowired
  5.         private StudentDao studentDao;
  6.         
  7.         public void changeInfo(){
  8.             studentDao.updateAgeById(100,1);
  9.             System.out.println("-----------");
  10.             studentDao.updateNameById("test1",1);
  11.         }
  12.     }

测试环境搭建

  1. /**
  2.      * projectName: com.gedeshidai.test
  3.      *
  4.      * description:
  5.      */
  6.     @SpringJUnitConfig(JavaConfig.class)
  7.     public class TxTest {
  8.  
  9.         @Autowired
  10.         private StudentService studentService;
  11.  
  12.         @Test
  13.         public void  testTx(){
  14.             studentService.changeInfo();
  15.         }
  16.     }

数据库代码

  1. create database studb;
  2.  
  3.     use studb;
  4. 		CREATE TABLE students (
  5.       id INT PRIMARY KEY,
  6.       name VARCHAR(50) NOT NULL,
  7.       gender VARCHAR(10) NOT NULL,
  8.       age INT,
  9.       class VARCHAR(50)
  10.     );
  11. 		INSERT INTO students (id, name, gender, age, class)
  12.     VALUES
  13.       (1, '张三', '男', 20, '高中一班'),
  14.       (2, '李四', '男', 19, '高中二班'),
  15.       (3, '王五', '女', 18, '高中一班'),
  16.       (4, '赵六', '女', 20, '高中三班'),
  17.       (5, '刘七', '男', 19, '高中二班'),
  18.       (6, '陈八', '女', 18, '高中一班'),
  19.       (7, '杨九', '男', 20, '高中三班'),
  20.       (8, '吴十', '男', 19, '高中二班');

错误解决

类文件具有错误的版本 61.0, 应为 52.0

请删除该文件或确保该文件位于正确的类路径子目录中。

当出现这种情况可以去检查自己jdk版本，博主的jdk1.8和这个冲突了，所以改成了jdk17或以上版本。

2.2 事务添加

@Transactional

注释添加位置：方法/类上

方法：当前方法有事务

类上：类下所有的方法都有事务

在JavaConfig.java中，我们需要添加第三方的类进入到IOC容器

在提交事务的方法/类上添加注释：@Transactional，博主这里是在类上添加的。

当在类上添加注释后会，运行测试类会出现如下报错：

2.3 事务属性：只读

2.3.1.  只读介绍

    对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

2.3.2.  设置方式

  1.     // readOnly = true把当前事务设置为只读 默认是false!
  2.  
  3.     @Transactional(readOnly = true)

2.3.3.  针对DML动作设置只读模式

    会抛出下面异常：

    Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

2.3.4.  @Transactional注解放在类上

    1.  生效原则

        如果一个类中每一个方法上都使用了 @Transactional 注解，那么就可以将 @Transactional 注解提取到类上。反过来说：@Transactional 注解在类级别标记，会影响到类中的每一个方法。同时，类级别标记的 @Transactional 注解中设置的事务属性也会延续影响到方法执行时的事务属性。除非在方法上又设置了 @Transactional 注解。

        对一个方法来说，离它最近的 @Transactional 注解中的事务属性设置生效。

    2.  用法举例

        在类级别@Transactional注解中设置只读，这样类中所有的查询方法都不需要设置@Transactional注解了。因为对查询操作来说，其他属性通常不需要设置，所以使用公共设置即可。

        然后在这个基础上，对增删改方法设置@Transactional注解 readOnly 属性为 false。

代码实现：

当我们添加已读，把报错那一行注释后，运行测试结果如下：

这里可能小伙伴会想，既然进行修改的方法加只读不会运行，那么我们只进行查询是不是就可以加只读模式了？

答案当然是：可以的！

但是，既然我们是查询了，也就没必要添加事务了呀！

所以已读模式一般都是添加到类上的，类下的所有方法都有事务，查询方法可以通过再次添加注解，设置为只读模式，提高效率。（@Transactional默认为非只读模式）

2.4 事务属性：超时时间

2.4.1.  需求

    事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

    此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

    概括来说就是一句话：超时回滚，释放资源。

2.4.2.  设置超时时间

如果类上设置事务属性，方法也设置了事务注解！那么方法会不会生效呢？

答案是：不会生效！！！

因为方法上的注解覆盖了类上的注解（直接在方法上设置注解是比在类上的优先级大的）

2.5 事务属性：事务异常

2.5.1.  默认情况

    默认只针对运行时异常回滚，编译时异常不回滚。情景模拟代码如下：

  1. @Service
  2.     public class StudentService {
  3.  
  4.         @Autowired
  5.         private StudentDao studentDao;
  6.  
  7.         /**
  8.          * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
  9.          * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
  10.          * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
  11.          */
  12.         @Transactional(readOnly = false,timeout = 3)
  13.         public void changeInfo() throws FileNotFoundException {
  14.             studentDao.updateAgeById(100,1);
  15.             //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内! 
  16.             new FileInputStream("xxxx");
  17.             studentDao.updateNameById("test1",1);
  18.         }
  19.     }

2.5.2.  设置回滚异常

    rollbackFor属性：指定哪些异常类才会回滚,默认是 RuntimeException and Error 异常方可回滚！

  1. /**
  2.      * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
  3.      * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
  4.      * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
  5.      */
  6.     @Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class)
  7.     public void changeInfo() throws FileNotFoundException {
  8.         studentDao.updateAgeById(100,1);
  9.         //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内! 
  10.         new FileInputStream("xxxx");
  11.         studentDao.updateNameById("test1",1);
  12.     }

2.5.3.  设置不回滚的异常

    在默认设置和已有设置的基础上，再指定一个异常类型，碰到它不回滚。

    noRollbackFor属性：指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!

  1. @Service
  2.     public class StudentService {
  3.  
  4.         @Autowired
  5.         private StudentDao studentDao;
  6.  
  7.         /**
  8.          * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
  9.          * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
  10.          * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
  11.          */
  12.         @Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class,noRollbackFor = FileNotFoundException.class)
  13.         public void changeInfo() throws FileNotFoundException {
  14.             studentDao.updateAgeById(100,1);
  15.             //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
  16.             new FileInputStream("xxxx");
  17.             studentDao.updateNameById("test1",1);
  18.         }
  19.     }

2.6 事务属性：事务隔离级别

2.6.1.  事务隔离级别

    数据库事务的隔离级别是指在多个事务并发执行时，数据库系统为了保证数据一致性所遵循的规定。常见的隔离级别包括：

    1.  读未提交（Read Uncommitted）：事务可以读取未被提交的数据，容易产生脏读、不可重复读和幻读等问题。实现简单但不太安全，一般不用。

    2.  读已提交（Read Committed）：事务只能读取已经提交的数据，可以避免脏读问题，但可能引发不可重复读和幻读。

    3.  可重复读（Repeatable Read）：在一个事务中，相同的查询将返回相同的结果集，不管其他事务对数据做了什么修改。可以避免脏读和不可重复读，但仍有幻读的问题。

    4.  串行化（Serializable）：最高的隔离级别，完全禁止了并发，只允许一个事务执行完毕之后才能执行另一个事务。可以避免以上所有问题，但效率较低，不适用于高并发场景。

        不同的隔离级别适用于不同的场景，需要根据实际业务需求进行选择和调整。

2.6.2.  事务隔离级别设置

  1. package com.gedeshidai.service;
  2.  
  3.     import com.gedeshidai.dao.StudentDao;
  4.     import org.springframework.beans.factory.annotation.Autowired;
  5.     import org.springframework.stereotype.Service;
  6.     import org.springframework.transaction.annotation.Isolation;
  7.     import org.springframework.transaction.annotation.Transactional;
  8.  
  9.     import java.io.FileInputStream;
  10.     import java.io.FileNotFoundException;
  11.  
  12.     /**
  13.      * projectName: com.gedeshidai.service
  14.      */
  15.     @Service
  16.     public class StudentService {
  17.  
  18.         @Autowired
  19.         private StudentDao studentDao;
  20.  
  21.         /**
  22.          * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
  23.          * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
  24.          * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
  25.          * isolation = 设置事务的隔离级别,mysql默认是repeatable read!
  26.          */
  27.         @Transactional(readOnly = false,
  28.                        timeout = 3,
  29.                        rollbackFor = Exception.class,
  30.                        noRollbackFor = FileNotFoundException.class,
  31.                        isolation = Isolation.REPEATABLE_READ)
  32.         public void changeInfo() throws FileNotFoundException {
  33.             studentDao.updateAgeById(100,1);
  34.             //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
  35.             new FileInputStream("xxxx");
  36.             studentDao.updateNameById("test1",1);
  37.         }
  38.     }

2.7 事务属性：事务传播行为

2.7.1.  事务传播行为要研究的问题

   举例代码：

  1. @Transactional
  2.     public void MethodA(){
  3.         // ...
  4.         MethodB();
  5.         // ...
  6.     }
  7.  
  8.     //在被调用的子方法中设置传播行为，代表如何处理调用的事务！ 是加入，还是新事务等！
  9.     @Transactional(propagation = Propagation.REQUIRES_NEW)
  10.     public void MethodB(){
  11.         // ...
  12.     }

2.7.2.  propagation属性

@Transactional 注解通过 propagation 属性设置事务的传播行为。它的默认值是：

Propagation propagation() default Propagation.REQUIRED;

    propagation 属性的可选值由 org.springframework.transaction.annotation.Propagation 枚举类提供：

    | 名称                | 含义                        |

    | ----------------- | ------------------------- |

    | REQUIRED &#xA;默认值 | 如果父方法有事务，就加入，如果没有就新建自己独立！ |

    | REQUIRES\_NEW     | 不管父方法是否有事务，我都新建事务，都是独立的！  |

2.7.3.  测试

1.  声明两个业务方法
  1.  @Service
  2.         public class StudentService {
  3.  
  4.             @Autowired
  5.             private StudentDao studentDao;
  6.  
  7.             /**
  8.              * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
  9.              * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
  10.              * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
  11.              * isolation = 设置事务的隔离级别,mysql默认是repeatable read!
  12.              */
  13.             @Transactional(readOnly = false,
  14.                            timeout = 3,
  15.                            rollbackFor = Exception.class,
  16.                            noRollbackFor = FileNotFoundException.class,
  17.                            isolation = Isolation.REPEATABLE_READ)
  18.             public void changeInfo() throws FileNotFoundException {
  19.                 studentDao.updateAgeById(100,1);
  20.                 //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
  21.                 new FileInputStream("xxxx");
  22.                 studentDao.updateNameById("test1",1);
  23.             }
  24.             
  25.  
  26.             /**
  27.              * 声明两个独立修改数据库的事务业务方法
  28.              */
  29.             @Transactional(propagation = Propagation.REQUIRED)
  30.             public void changeAge(){
  31.                 studentDao.updateAgeById(99,1);
  32.             }
  33.  
  34.             @Transactional(propagation = Propagation.REQUIRED)
  35.             public void changeName(){
  36.                 studentDao.updateNameById("test2",1);
  37.                 int i = 1/0;
  38.             }
  39.  
  40.         }
    2.  声明一个整合业务方法
  1. @Service
  2.         public class TopService {
  3.  
  4.             @Autowired
  5.             private StudentService studentService;
  6.  
  7.             @Transactional
  8.             public void  topService(){
  9.                 studentService.changeAge();
  10.                 studentService.changeName();
  11.             }
  12.         }
 3.  添加传播行为测试
  1. @SpringJUnitConfig(classes = AppConfig.class)
  2.         public class TxTest {
  3.  
  4.             @Autowired
  5.             private StudentService studentService;
  6.  
  7.             @Autowired
  8.             private TopService topService;
  9.  
  10.             @Test
  11.             public void  testTx() throws FileNotFoundException {
  12.                 topService.topService();
  13.             }
  14.         }
注意：

    在同一个类中，对于@Transactional注解的方法调用，事务传播行为不会生效。这是因为Spring框架中使用代理模式实现了事务机制，在同一个类中的方法调用并不经过代理，而是通过对象的方法调用，因此@Transactional注解的设置不会被代理捕获，也就不会产生任何事务传播行为的效果。

4.  其他传播行为值（了解）

    1.  Propagation.REQUIRED：如果当前存在事务，则加入当前事务，否则创建一个新事务。

    2.  Propagation.REQUIRES\_NEW：创建一个新事务，并在新事务中执行。如果当前存在事务，则挂起当前事务，即使新事务抛出异常，也不会影响当前事务。

    3.  Propagation.NESTED：如果当前存在事务，则在该事务中嵌套一个新事务，如果没有事务，则与Propagation.REQUIRED一样。

    4.  Propagation.SUPPORTS：如果当前存在事务，则加入该事务，否则以非事务方式执行。

    5.  Propagation.NOT\_SUPPORTED：以非事务方式执行，如果当前存在事务，挂起该事务。

    6.  Propagation.MANDATORY：必须在一个已有的事务中执行，否则抛出异常。

    7.  Propagation.NEVER：必须在没有事务的情况下执行，否则抛出异常。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/707711
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号