Spring学习——整合MyBatis

字数统计: 3.9k字   |   阅读时长≈ 21分

回顾MyBatis

MyBatis的文件结构

2021-02-03 pm 4.07.28

编写工具数据库连接池工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.asher.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;

    static {
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }
}

编写pojo实体类

1
2
3
4
5
6
7
package com.asher.pojo;

public class User {
    private Integer id;
    private String name;
    private String pwd;
}

实现mybatis的配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/asher/dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>

编写UserDao接口

1
2
3
4
5
6
7
8
package com.asher.dao;

import com.asher.pojo.User;
import java.util.List;

public interface UserMapper {
    public List<User> selectUser();
}

编写接口对应的Mapper映射问件

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.asher.dao.UserMapper">
    <select id="selectUser" resultType="com.asher.pojo.User">
    select * from mybatis.user
  </select>
</mapper>

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
ackage com.asher;

import com.asher.dao.UserMapper;
import com.asher.pojo.User;
import com.asher.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void testSelect() {
        SqlSession session = MyBatisUtils.getSession();
        UserMapper userDaomapper = session.getMapper(UserMapper.class);
        List<User> list = userDaomapper.selectUser();
        for (User user : list) {
            System.out.println(user.toString());
        }
        session.close();
    }
}

MyBatis-Spring学习

引入Spring之前需要了解mybatis-spring包中的一些重要类。

http://www.mybatis.org/spring/zh/index.html

截屏2021-02-03 pm 4.21.38

什么是Mybatis-Spring？

MyBatis-Spring会帮助我们把Mybatis的代码无缝整合到Spring中。

基础知识学习

2021-02-03 pm4.23.45

在开始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要，以上是对应的两个版本。

如果使用Maven作为构造工具，仅仅需要在pom.xml中加入一下代码即可以：

1
2
3
4
5
<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.2</version>
</dependency>

要和Spring一起使用Mybatis至少在Spring应用上下文中定义两样东西：一个SqlSessionFactory和一个数据映射器：mapperLocations

  • SqlSessionFactory有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

  • 一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是 < settings> 或 < typeAliases>元素。

  • mapperLocations用于映射Mapper接口实现SQL语句

1
2
3
4
5
6
<!--    关联MyBatis-->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource"></property>
      <property name="configLocation" value="mybatis-config.xml"></property>
      <property name="mapperLocations" value="classpath:com/asher/dao/*.xml"></property>
  </bean>

注意：

  • SqlSessionFactory需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

  • 在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。

  • 在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。

  • 这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

  • 模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

1
2
3
4
5
<!-- 方式一 -->
   <!-- 注册是qlSessionTemplate,关联sqlSessionFactory-->
   <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
       <constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
   </bean>

现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession 属性，就像下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class UserDaoImpl02 implements UserMapper {
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        return null;
    }

    public void addUser(User user) {

    }
}

按下面这样，注入 SqlSessionTemplate：

1
2
3
4
<!-- 注入sqlSession,用sqlSession获取getMapper-->
   <bean id="userDaoImpl02" class="com.asher.dao.Impl.UserDaoImpl02">
       <property name="sqlSession" ref="sqlSession"></property>
   </bean>

以上是整合Spring和Mybatis的理论，主要代码实现如下。

整合方式

整合方式不同主要区别在于sqlSessionFactory和sqlSession获取的方式不一样，最最主要使用的是方式三，简单，使用方便，只要配置一个地方，方式一二配置的方式不一样，方法是一样的。

  • 方式一：使用的是注册sqlSessionTemplate，关联sqlSessionFactory，然后把sqlSession注入到Dao接口的实现类。

  • 方式二：使用的是dao继承Support类，直接利用getSeeion()获得，不需要管理sqlSession-Template，对事务的支持更加友好。

  • 方式三：主要是直接配置接口uerMapper获取sqlSession和关联sqlSessionFactory，把接口和sqlSeeionFcatory直接注入到MapperFactoryBean中，这样dao中只要注入userMapper，就能直接调用接口的方法。

整合方式一

1、引入Spring配置文件beans.xml

1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

2、配置数据源替换mybaits的数据源，编写数据源配置db.properties

1
2
3
4
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=root
1
2
3
4
5
6
7
<!--    配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

3、配置SqlSessionFactory，关联MyBatis

1
2
3
4
5
6
<!--    配置SqlSessionFactory,关联MyBatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/asher/dao/*.xml"></property>
    </bean>

4、配置mybatis-config.xml文件，把Mybatis的相关配置配置到这个文件中，和配置到关联部分也可以，主要区分配置文件，防止因为配置过多导致文件出错。

1
2
3
4
5
6
<!--    配置SqlSessionFactory,关联MyBatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/asher/dao/*.xml"></property>
    </bean>

5、注册sqlSessionTemplate，关联sqlSessionFactory；

1
2
3
4
5
6
7
8
9
<!-- 方式一 -->
    <!-- 注册是qlSessionTemplate,关联sqlSessionFactory-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
    </bean>
    <!-- 注入sqlSession,用sqlSession获取getMapper-->
    <bean id="userDaoImpl02" class="com.asher.dao.Impl.UserDaoImpl02">
        <property name="sqlSession" ref="sqlSession"></property>
    </bean>

6、增加Dao接口的实现类；私有化sqlSessionTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class UserDaoImpl02 implements UserMapper {

   //sqlSession不用我们自己创建了，Spring来管理
   private SqlSessionTemplate sqlSession;

   public void setSqlSession(SqlSessionTemplate sqlSession) {
       this.sqlSession = sqlSession;
  }

   public List<User> selectUser() {
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       return mapper.selectUser();
  } 
}

7、测试

1
2
3
4
5
6
7
@Test
   public void test2(){
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       UserMapper mapper = (UserMapper) context.getBean("userDaoImpl02");
       List<User> user = mapper.selectUser();
       System.out.println(user);
  }

整合方式二

在Mybatis-Spring1.2.3版本中可以用现实类继承Support类，直接用getSession()获得，然后直接注入SqlSessionFactory，比起方式一，不需要管理SqlSessionTemplate , 而且对事务的支持更加友好。

1、编写UserDaoImpl

1
2
3
4
5
6
7
8
9
10
public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {

    public List<User> selectUser() {
        UserMapper mapper =getSqlSession().getMapper(UserMapper.class);
        return mapper.selectUser();
    }

    public void addUser(User user) {
    }
}

2、修改bean的配置

1
2
3
4
<!-- 方式二：实现类userDaoImpl02直接继承SqlSessionDaoSupport 使用getSession()获取getMapper-->
    <bean id="userDaoImpl" class="com.asher.dao.Impl.UserDaoImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>

3、测试

1
2
3
4
5
6
7
@Test
public void test2(){
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   UserMapper mapper = (UserMapper) context.getBean("userDaoImpl");
   List<User> user = mapper.selectUser();
   System.out.println(user);
}

整合方式三

1、编写UserDaoImpl03

1
2
3
4
5
6
7
8
9
10
11
12
public class UserDaoImpl03 implements UserMapper {
    @Autowired
    private UserMapper userMapper;
  
    public List<User> selectUser() {
        return userMapper.selectUser();
    }

    public void addUser(User user) {
        userMapper.addUser(new User(4,"asher","asher"));
    }
}

2、修改bean的配置

1
2
3
4
5
<!--  方式三：直接配置接口uerMapper获取sqlSession和关联sqlSessionFactory-->
   <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
       <property name="mapperInterface" value="com.asher.dao.UserMapper"></property>
       <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
   </bean>

3、测试

1
2
3
4
5
6
7
8
@Autowired
  private UserMapper userMapper;
  @Test
  public void testUserMapper(){
      for (User user : userMapper.selectUser()) {
          System.out.println(user);
      }
  }

完整的整合过程

2021-02-03 pm5.26.42

1、导入相关的依赖和添加文件过滤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
       </dependency>

       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.2</version>
       </dependency>

       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.47</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.1.10.RELEASE</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>5.1.10.RELEASE</version>
       </dependency>

       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.9.4</version>
       </dependency>

       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis-spring</artifactId>
           <version>2.0.2</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-test</artifactId>
           <version>5.1.10.RELEASE</version>
       </dependency>

   </dependencies>
	<build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>true</filtering>
           </resource>
       </resources>
   </build>

2、编写Dao接口，编写实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.asher.dao;

import com.asher.pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> selectUser();

    public int deleteUser(int id);

    public int addUser(User user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.asher.dao.Impl;

import com.asher.dao.UserMapper;
import com.asher.pojo.User;

import java.util.List;

public class UserMapperImpl implements UserMapper {
    private UserMapper userMapper;

    public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
    }

    @Override
    public List<User> selectUser() {
        return userMapper.selectUser();
    }

    @Override
    public int deleteUser(int id) {
        return userMapper.deleteUser(id);
    }

    @Override
    public int addUser(User user) {
        return userMapper.addUser(user);
    }
}

3、编写实体类pojo

1
2
3
4
5
6
7
package com.asher.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;
}

4、编写Service接口和实现类

（规范编写作用，可以不写这一部分）

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.asher.service;

import com.asher.pojo.User;

import java.util.List;

public interface UserService {
    public List<User> selectUser();

    public int deleteUser(int id);

    public int  addUser(User user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.asher.service.Impl;

import com.asher.dao.Impl.UserMapperImpl;
import com.asher.pojo.User;
import com.asher.service.UserService;

import java.util.List;

public class userServiceImpl implements UserService {
    private UserMapperImpl userMapperImpl;

    public void setUserMapperImpl(UserMapperImpl userMapperImpl) {
        this.userMapperImpl = userMapperImpl;
    }
    @Override
    public List<User> selectUser() {
        return userMapperImpl.selectUser();
    }

    @Override
    public int deleteUser(int id) {
        return userMapperImpl.deleteUser(id);
    }

    @Override
    public int addUser(User user) {
        return userMapperImpl.addUser(user);
    }

}

5、编写UserMapper.xml实习sql查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.asher.dao.UserMapper">

   <select id="selectUser" resultType="user">
       select * from mybatis.user;
   </select>

    <insert id="addUser" parameterType="user">
        insert into mybatis.user (id,name,pwd)
        values (#{id},#{name},#{pwd});
    </insert>

    <delete id="deleteUser" parameterType="int">
        test delete from mybatis.user where id=#{id}
    </delete>
</mapper>

6、编写数据库配置文件db.properties

1
2
3
4
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=root

7、编写mybatis-config.xml

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <typeAliases>
        <package name="com.asher.pojo"/>
    </typeAliases>

</configuration>

8、编写bean配置文件applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?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:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--导入配置文件-->
    <context:property-placeholder location="db.properties"></context:property-placeholder>
    <!--    配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!--    关联MyBatis-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="mybatis-config.xml"></property>
        <property name="mapperLocations" value="classpath:com/asher/dao/*.xml"></property>
    </bean>

<!--    配置userMapper获取sqlSession,sqlSessionFactory-->
    <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="com.asher.dao.UserMapper"></property>
        <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
    </bean>

    <bean id="userMapperImpl" class="com.asher.dao.Impl.UserMapperImpl">
        <property name="userMapper" ref="userMapper"></property>
    </bean>

    <bean id="userServiceImpl" class="com.asher.service.Impl.userServiceImpl">
        <property name="userMapperImpl" ref="userMapperImpl"></property>
    </bean>

</beans>

9、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.asher.test;

import com.asher.pojo.User;
import com.asher.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = {"classpath:applicationContext.xml"})
public class MyTest {
    @Autowired
    private UserService userService;

    @Test
    public void test() {
        //  添加用户
        int i=userService.addUser(new User(4, "asher", "1234567"));
        System.out.println(i);
        // 删除用户
        int j =userService.deleteUser(4);
        System.out.println(j);

        //查询所有用户
        List<User> users=userService.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
    }
}

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

建立此博客主要用途：
分享知识、学习笔记、
技术探讨、好的文章收藏整理

在本博客中如果涉及到版权问题
请联系QQ:1583881877

如果对文章中有更好的看法，
请在留言区留下您宝贵的意见呦！！