Mybatis笔记记

1、简介

（1）mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。
（2）mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。
（3）最后mybatis框架执行sq并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

2、持久化和持久层

2.1 持久化

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

• 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。

• JDBC就是一种持久化机制。文件IO也是一种持久化机制。

• 在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

  为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

• 内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。

• 内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。

 2.2 持久层

• 完成持久化工作的代码块 .  ---->  dao层 【DAO (Data Access Object)  数据访问对象】

• 大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。

• 不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.

• 与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】

3、开发步骤

① 添加MyBatis的坐标

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.42</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

② 创建user数据表
③ 编写User实体类
④ 编写映射文件UserMapper.xml（一般命名为实体+Mapper.xml）

<?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">
<!--该文件为mybatis中的mapper接口编写里面的方法提供对应的sql语句（namespace对应接口的地址）-->
<mapper namespace="com.mapper.DrugMapper">
        <!--id是命名空间DrugMapper类里面的方法名字，resultType是指查询到的结果集封装到Drug对象类型-->
		<select id="QueryByNameCS" resultType="Drug">
				select * from druginfo where `drugname`=#{drugname} and `changshang`=#{changshang}
		</select>	
</mapper>

⑤ 编写核心文件SqlMapConfig.xml

    <!--数据源环境-->
    <environments default="developement"><!--默认数据源环境-->
        <!--配置数据源环境-->
        <environment id="developement">
            <!--配置数据源管理器-->
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/itheima/mapper/UserMapper.xml"></mapper>
    </mappers>

⑥ 编写测试类

4、CRUD参数的传递

根据 密码 和 名字 查询用户

思路一：适用注解@Param直接在方法中传递参数

1、在接口方法的参数前加 @Param属性

//通过密码和名字查询用户
User selectUserByNP(@Param("username") String username,@Param("pwd") Stringpwd);

2、Sql语句编写的时候，直接取@Param中设置的值即可，不需要单独设置参数类型

<select id="selectUserByNP" resultType="com.kuang.pojo.User">
   select * from user where name = #{username} and pwd = #{pwd}
</select>

思路二：使用万能的Map

1、在接口方法中，参数直接传递Map；

User selectUserByNP2(Map<String,Object> map);

2、编写sql语句的时候，需要传递参数类型，参数类型为map

<select id="selectUserByNP2" parameterType="map"resultType="com.kuang.pojo.User">
select * from user where name = #{username} and pwd = #{pwd}
</select>

3、在使用方法的时候，Map的 key 为 sql中取的值即可，没有顺序要求！

Map<String, Object> map = new HashMap<String, Object>();
map.put("username","小明");
map.put("pwd","123456");
User user = mapper.selectUserByNP2(map);

总结：如果参数过多，我们可以考虑直接使用Map实现，如果参数比较少，直接传递参数即可

注意：

• 所有的xml文件都有其规定的顺序

• Mybatis进行增删改需要提交事务，不然执行的时候数据库是没有变化的 

  解决方法（两种）：在openSession() 的括号里写true, 设定自动提交事务。或者是在代码中加入sqlSession.commit()

• 接口所有的普通参数，尽量都写上@Param参数，尤其是多个参数时，必须写上！

5、配置解析

5.1 核心对象

5.1.1 SqlSessionFactory

1. 它是单个数据库映射关系经过编译后的内存镜像，其主要作用是创建SqlSession。SqlsessionFactory对象的实例可以通过SqlSessionFactoryBuild对象来构建，这里用到了建造者模式。
2. SqlSessionFactory对象是线程安全的，它一旦被创建，在整个应用执行期间都会存在。如果多次创建同一个数据库的SqlSessionFactory，那么此数据库的资源很容易被耗尽。所以，通常每一个数据库都只会对应一个SqlSessionFactory，所以在构建SqlSessionFactory时，建议使用单列模式。

5.1.2 SqlSession

1. 它是应用程序与持久层之间执行交互操作的一个单线程对象，其主要作用是执行持久化操作，相当于connection和数据库进行交互的，和数据库的一次会话，就应该创建一个新的SqlSession。SqlSession对象包含了数据库的所有执行SQL操作的方法。
2. 每一个线程都应该有一个自己的SqlSession实例，并且该实例是不能共享的。同时SqlSession实例也是线程不安全的，因此其使用范围最好在一次请求或一个方法，并且使用完应及时关闭。
3. sqlSession由SqlSessionFactory通过openSession()方法创建，这里用到了工厂模式
4. SqlSession的getMapper(Class<T> type)方法会返回Mapper接口的代理对象（这里用到了代理模式），该对象关联了SqlSession对象，可以使用该对象直接调用方法操作数据库。参数type是Mapper的接口类型。

5.2 <properties>属性

• 作用：引用外部属性，可以进行动态替换
• 用${} 去出配置文件中的值。

如果属性在不只一个地方进行了配置，那么 MyBatis 将按照下面的顺序来加载：

• 在 properties 元素体内指定的属性首先被读取。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的是 properties 属性中指定的属性。

5.3 <typeAliases>别名配置

  1.  类型别名是为 Java 类型设置一个短的名字。它只和 XML 配置有关，存在的意义仅在于用来减少类完全限定名的冗余。

<!--配置别名,注意顺序-->
<typeAliases>
   <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

当这样配置时，User可以用在任何使用com.kuang.pojo.User的地方。

  2.  也可以指定一个包名，默认别名为类名，MyBatis 会在包名下面搜索需要的 Java Bean，比如:

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

每一个在包 com.kuang.pojo 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。比如 domain.blog.Author 的别名为 author；

3.  若有注解，则别名为其注解值。见下面的例子：

@Alias("user")
public class User {
  ...
}

可以去官网查看一下Mybatis默认的一些类型别名！

5.4 <settings>

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

• 比如：数据库字段是不区分大小写的，那么我们在数据库字段中命名一个学生编号为stu_id，在javabean中命名为stuId，按正常情况下我们需要去sql语句给stu_id字段重命名为stuId，但是如果我们开启驼峰命名规则，stu_id就会默认转化为stuId。只需要在<settings>设置如下：

<settings>      
    <!--开启自动驼峰命名-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

• 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。

<settings>
    <!--标准的日志工厂实现-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

5.5 <environments>环境配置（了解就行）

• MyBatis 可以配置成适应多种环境
• 不过要记住：尽管可以配置多个环境，但每个SqlSessionFactory 实例只能选择一种环境。
• 学会使用配置多套运行环境！
• Mybatis默认的事务管理器就是JDBC，连接池：POOLED
• 后来事务管理器和数据源都交给spring来做

5.6 <mappers>元素

写好的sql映射文件需要使用mappers注册进来。

单个注册

• url：可以从磁盘或者网络路径引用
• resource：在类路径下找sql文件
• class：直接使用接口的全类名（需要将xml和dao接口放在同一目录下（可以在resource下创建和src的dao接口一样的包名存放xml文件，这也算是同一目录），而且文件名和接口名一致）

批量注册，注册包下的所有映射文件（需要将xml和dao接口放在同一目录下（可以在resource下创建和src的dao接口一样的包名存放xml文件，这也算是同一目录），而且文件名和接口名一致）

<!--批量注册 name:dao所在的包-->
<package name="com.zyk" />

6、属性名和字段名不一致问题

首先：

（1）User类

public class User {

   private int id;  //id
   private String name;   //姓名
   private String password;   //密码和数据库不一样！
   
   //构造
   //set/get
   //toString()
}

（2）数据库user的密码属性为pwd！ 

分析：

• select * from user where id = #{id} 可以看做

  select  id,name,pwd  from user where id = #{id}

• mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】

解决方案

方案一：为列名指定别名 , 别名和java实体类的属性名一致 .（不推荐）

<select id="selectUserById" resultType="User">
  select id , name , pwd as password from user where id = #{id}
</select>

方案二：使用结果集映射->ResultMap 【推荐】

<resultMap id="UserMap" type="User">
   <!-- id为主键 -->
   <id column="id" property="id"/>
   <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
   <result column="name" property="name"/>
   <result column="pwd" property="password"/>
</resultMap>

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
</select>

7、ResultMap

自动映射

• resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来。

• 实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的长达数千行的代码。

• ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

你已经见过简单映射语句的示例了，但并没有显式指定 resultMap。比如：

<select id="selectUserById" resultType="map">
select id , name , pwd
  from user
  where id = #{id}
</select>

上述语句只是简单地将所有的列映射到 HashMap 的键上，这由 resultType 属性指定。虽然在大部分情况下都够用，但是 HashMap 不是一个很好的模型。你的程序更可能会使用 JavaBean 或 POJO（Plain Old Java Objects，普通老式 Java 对象）作为模型。

ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。

手动映射

1、返回值类型为resultMap

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
</select>

2、编写resultMap，实现手动映射！

<resultMap id="UserMap" type="User">
   <!-- id为主键 -->
   <id column="id" property="id"/>
   <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
   <result column="name" property="name"/>
   <result column="pwd" property="password"/>
</resultMap>

如果世界总是这么简单就好了。但是肯定不是的，数据库中，存在一对多，多对一的情况，我们之后会使用到一些高级的结果集映射，association，collection这些!

8、日志

8.1日志工厂

为什么需要日志工具？

如果一个 数据库相关的操作出现了问题，我们可以根据输出的SQL语句快速排查问题。

对于以往的开发过程，我们会经常使用到debug模式来调节，跟踪我们的代码执行过程。但是现在使用Mybatis是基于接口，配置文件的源代码执行过程。因此，我们必须选择日志工具来作为我们开发，调节程序的工具。

实现日志的几种工具

Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：

• SLF4J

• Apache Commons Logging

• Log4j 2

• Log4j（掌握）

• JDK logging

• STDOUT_LOGGING（掌握）

具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。

8.2 STDOUT_LOGGING标准日志实现

在mybatis_config.xml文件设置使用此日志即可

<settings>
       <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

8.3 Log4j

简介

• Log4j是Apache的一个开源项目

• 通过使用Log4j，我们可以控制日志信息输送的目的地：控制台，文本，GUI组件....

• 我们也可以控制每一条日志的输出格式；

• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

使用步骤

1、导入log4j的包

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
</dependency>

 2、配置文件log4j.properties编写

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3、在mybatis_config.xml设置日志实现

<settings>
   <setting name="logImpl" value="LOG4J"/>
</settings>

 4、在程序中使用Log4j进行输出！

//注意导包：org.apache.log4j.Logger
static Logger logger = Logger.getLogger(MyTest.class);

@Test
public void selectUser() {
   logger.info("info：进入selectUser方法");
   logger.debug("debug：进入selectUser方法");
   logger.error("error: 进入selectUser方法");
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   List<User> users = mapper.selectUser();
   for (User user: users){
       System.out.println(user);
  }
   session.close();
}

5、测试，看控制台输出！

• 使用Log4j 输出日志

• 可以看到还生成了一个日志的文件 【需要修改file的日志级别】

9、#{}和${}的区别（面试问题）

1. #{}为参数占位符，即预编译处理；${}是字符串替换，即sql拼接。
2. 变量替换后，#{} 对应的变量自动加上单引号 '' ；变量替换后，${} 对应的变量不会加上单引号 ''
3. 使用#{}可以有效的防止 SQL 注入，提高系统安全性。
4. Mybatis 在处理#{}时，会将 sql 中的#{}替换为?号，调用 PreparedStatement 的 set 方法来赋值；
5. Mybatis 在处理${}时，就是把${}替换成变量的值。
6. 能用 #{} 的地方就用 #{}，不用或少用 ${}
7. 表名作参数时，必须用 ${}。如：select * from ${tableName}
8. order by 时，必须用 ${}。如：select * from t_user order by ${columnName}
9. 使用 ${} 时，要注意何时加或不加单引号，即 ${} 和 '${}'

#{} 和 ${} 的实例：假设传入参数为 1

（1）开始

a）#{}：select * from t_user where uid=#{uid}
b）${}：select * from t_user where uid= '${uid}'

（2）然后

a）#{}：select * from t_user where uid= ?
b）${}：select * from t_user where uid= '1'

（3）最后
a）#{}：select * from t_user where uid= '1'
b）${}：select * from t_user where uid= '1'

10、多对一处理

多对一的理解：

• 多个学生对应一个老师

• 如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！

10.1 第一种方式（按查询嵌套处理）

StudentMapper.xml

<?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.dao.StudentMapper">

    <!--思路：
        1、查询出所有学生的信息
        2、根据查询出来的学生的tid，寻找对应的老师
    -->

    <select id="getStudent" resultMap="studentTeacher">
        select * from student
    </select>
    <resultMap id="studentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独处理 对象：association 集合：collection-->
        <!--association关联属性 property属性名 javaType属性类型 column在“多”的一方的表中的列名-->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <!--
       这里传递过来的id，只有一个属性的时候，下面可以写任何值。
       association中column多参数配置：
           column="{key=value,key=value}"
           其实就是键值对的形式，key是传给下个sql的取值名称（也就是getTeacher的sql语句#{}里的名称），value是片段一（也就是getStudent里相应的字段名）中sql查询的字段名。
   -->
    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id=#{tid};
    </select>
</mapper>

10.2 第二种方式（按结果嵌套处理）

<?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.dao.StudentMapper">

    <!--
    按查询结果嵌套处理
    思路：
       1. 直接查询出结果，进行结果集的映射
    -->
    <select id="getStudent1" resultMap="studentTeacher2">
        select s.id as sid,s.name as sname,t.id as tid,t.name as tname 
        from student s,teacher t 
        where s.tid=t.id;
    </select>
    <resultMap id="studentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <!--关联对象property 关联对象在Student实体类中的属性-->
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
            <result property="id" column="tid"/>
        </association>
    </resultMap>
</mapper>

11. 多对一处理

按照结果嵌套处理

ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型！

TeacherMapper.xml

<?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.dao.TeacherMapper">
    <select id="getTeacher" resultMap="teacherStudent">
        select s.id sid,s.name sname,t.name tname,t.id tid
        from student s,teacher t
        where s.tid=t.id and t.id=#{tidd}
    </select>

    <resultMap id="teacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

小结

JavaType和ofType都是用来指定对象类型的

• JavaType是用来指定pojo中属性的类型

• ofType指定的是映射到list集合属性中pojo的类型。

12. 动态sql语句

12.1 <where>和<if>

<where>元素：官方给的解释是只会在至少有一个子元素的条件返回SQL子句的情况下才去插入“WHERE”子句。而且，若语句的开头为“AND”或“OR"，where元素也会将它们去除。也就是说如果没有满足的if语句（子元素），就不会插入where语句进入sql；如果只有一个子元素（比如下面的title满足）满足，那么会把开头的AND去掉。

<if>元素就是像java里的判断语句一样

    <select id="findBlog" resultType="blog">
        select * from blog
        <where>
            <if test="state !=null">
                state = #{state}
            </if>
            <if test="title !=null">
                AND title = #{title}
            </if>
            <if test="author !=null and author.name !=null">
                AND authorName like #{author.name}
            </if>
        </where>
    </select>

12.2 <choose>

• 有时我们不想应用到所有的条件语句，而只想从中择其一项。针对这种情况，MyBatis 提供了choose元素，它有点像Java中的switch 语句。
• 相比于<if>元素，<choose>元素最多只能满足一个子元素。

    <select id="queryBlogChoose" parameterMap="map" resultType="blog">
        select * from blog where
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                author = #{author}
            </when>
            <otherwise>
                views = #{view}
            </otherwise>
        </choose>
    </select>

12.3 <sql>

一般是用在封装sql语句的公共部分，比如12.1的if片段在其他地方也有用到，那么就可以把这部分抽取出来，12.1的代码也就可以转换成下面这样的代码

    <sql id="if-title-author">
        <if test="state !=null">
            state = #{state}
        </if>
        <if test="title !=null">
            AND title = #{title}
        </if>
        <if test="author !=null and author.name !=null">
            AND authorName like #{author.name}
        </if>
    </sql>

    <select id="findBlog" resultType="blog">
        select * from blog
        <where>
            <include refid="if-title-author"></include>
        </where>
    </select>

注意事项： 

• 最好基于单表来定义SQL片段！
• 不要存在where标签 

12.4 <set>

set元素会动态前置SET关键字，同时也会删掉无关的逗号，但是注意不会帮你添加逗号！！

总结

动态SQL就是指根据不同的条件生成不同的SQL语句

本文大部分内容都摘自狂神说公众号