Mybatis(二)

1.10.7 创建一个测试类StudentMapperTest.java(test包下面)
    junit单元测试: 允许程序，不需要写main方法，而直接去运行测试函数。
    在测试函数上添加 @Test 注解，
    导入junit-4.7.jar包，然后右键运行程序即可。

    package test;
    import java.io.InputStream;
    import java.util.Date;

    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 org.junit.Test;

    import com.briup.mappers.StudentMapper;
    import com.briup.pojo.Student;

    public class StudentMapperTest {
        
        @Test
        public void test_insert(){
            
            try {
                InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
                SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
                SqlSession sqlSession = sqlSessionFactory.openSession();
                
                StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
                Student s = new Student(1,"tom","123@briup.com",new Date());
                studentMapper.insertStudent(s);
                sqlSession.commit();
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
    }

1.10.8 运行成功后会在控制台中看到log4j日志输出的这个程序运行的相关信息

1.10.9 对mybatis的一些基本封装
    每次读取配置文件,产生一个工厂对象SqlSessionFactory,然后再生成出SqlSession对象,这个过程虽然并不复杂,但是也都是一些重复的代码流程,所以我们可以对其进行一个简单的封装:
    package com.briup.utils;

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

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

    public class MyBatisSqlSessionFactory {
        private static SqlSessionFactory sqlSessionFactory;
        
        public static SqlSessionFactory getSqlSessionFactory(){
            if(sqlSessionFactory == null){
                InputStream inputStream = null;
                try {
                    inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
                    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e.getCause());
                }
            }
            return sqlSessionFactory;
        }
        
        public static SqlSession openSession() { 
            return openSession(false); 
        }
        public static SqlSession openSession(boolean autoCommit) { 
            return getSqlSessionFactory().openSession(autoCommit); 
        }
        
    }

    之后每次使用的时候只需要调用该类中的静态方法openSession即可
    上面的代码可简写为: //注意事务是自动提交还是手动提交
    MyBatisSqlSessionFactory.openSession().getMapper(StudentMapper.class).insertStudent(s);
    
    *******************************************************
    注意:xml文件中写的sql语句,最后面不要写分号,否则会报错误,ORA-00911: 无效字符
    *******************************************************

1.10.11 实现修改功能
    第一步，在StudentMapper.xml文件中添加sql语句
    //标签 就使用update
    //注意id要和接口方法名对应  parameterType和方法形参对应,没有返回值
    <update id="updateStudent" parameterType="Student"> 
        update students
        set  
        //注意，具体值一定要和Student类里面属性名相对应
        name=#{name},email=#{email},dob=#{dob}
        where stud_id=#{studId}
    </update>

    第二步，到StudentMapper接口中添加updateStudent(Student s)方法；
    参数类型、返回值类型要和xml文件一致

    第三步，在测试文件中，获取到映射接口对象mapper，然后直接用mapper调用updateStudent(s)方法即可。
        
        
1.10.12 实现删除功能

第二天内容

二 mybatis配置详解
MyBatis最关键的组成部分是SqlSessionFactory，我们可以从中获取SqlSession， 并执行映射的SQL语句。SqlSessionFactory对象可以通过基于XML的配置信息或者JavaAPI创建。
而mybatis-config.xml配置文件就是SqlSessionFactory生成的基础。

2.1 使用xml配置Mybatis
    构建SqlSessionFactory最常见的方式是基于XML配置。下面的 mybatis-config.xml展示了一个典型的MyBatis配置文件的样子:
    <?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> 
      <properties resource="application.properties"> 
        <property name="username" value="db_user" /> 
        <property name="password" value="verysecurepwd" /> 
      </properties> 
      <settings> 
        <setting name="cacheEnabled" value="true" /> 
      </settings> 
      <typeAliases> 
        <typeAlias alias="Student" type="com.briup.pojo.Student" /> 
        <package name="com.briup.pojo" /> 
      </typeAliases> 
      <typeHandlers> 
        <typeHandler handler="com.mybatis3.typehandlers.PhoneTypeHandler" /> 
        <package name="com.briup.typehandlers" /> 
      </typeHandlers> 
      <environments default="development"> 
        <environment id="development"> 
          <transactionManager type="JDBC" /> 
          <dataSource type="POOLED"> 
            <property name="driver" value="${jdbc.driverClassName}" /> 
            <property name="url" value="${jdbc.url}" /> 
            <property name="username" value="${jdbc.username}" /> 
            <property name="password" value="${jdbc.password}" /> 
          </dataSource> 
        </environment> 
        <environment id="production"> 
          <transactionManager type="MANAGED" /> 
          <dataSource type="JNDI"> 
            <property name="data_source" value="java:comp/jdbc/MyBatisDemoDS" /> 
          </dataSource> 
        </environment> 
      </environments> 
      <mappers> 
        <mapper resource="com/briup/mappers/StudentMapper.xml" /> 
        <mapper url="file:///D:/mybatisdemo/mappers/StudentMapper.xml" /> 
        <mapper class="com.briup.mappers.StudentMapper" /> 
      </mappers> 
    </configuration> 

2.1.1 environments元素
    environments是配置mybatis当前工作的数据库环境的地方。
    整体结构为:
        <environments default="db1">
            <environment id="db1">
                四要素
                事务管理方式
            </environment>
            
            <environment id="db2">
                四要素
                事务管理方式
            </environment>
            
            ...
        </environments>
    MyBatis支持配置多个dataSource环境，可以将应用部署到不同的环境上，如DEV【开发环境】，TEST【测试环境】，QA【质量评估环境】,UAT【用户验收环境】,PRODUCTION【生产环境】，可以通过将默认environments的【default属性】设置成想要的environment的id值。

    有时候，我们可能需要在相同的应用下使用多个数据库,比如我们可能有【shoppingcart】数据库来存储所有的【订单明细】；使用【reports】数据库存储【订单明细】的合计，用作报告。(也就是如果系统在运行期间如果有切换数据库环境的需求,mybatis中也可以很轻松的实现).
    如果你的【应用】需要连接【多个数据库】，你需要将每个数据库配置成独立的环境，并且为每一个数据库创建一个SqlSessionFactory
    例如:
    <environments default="shoppingcart"> 
      <!-- 第一个数据库 用来存放明细 -->
      <environment id="shoppingcart"> 
        <transactionManager type="MANAGED" /> 
        <dataSource type="JNDI"> 
          <property name="data_source" value="java:comp/jdbc/ShoppingcartDS" /> 
        </dataSource> 
      </environment> 
      
      <!-- 第二个数据库 用来查询报表 -->
      <environment id="reports"> 
        <transaction Managertype="MANAGED" /> 
        <dataSource type="JNDI"> 
          <property name="data_source" value="java:comp/jdbc/ReportsDS" /> 
        </dataSource> 
      </environment> 
    </environments> 

    我们可以为以上每个环境创建一个SqlSessionFactory
    java代码: 
    inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
    //默认的环境
    defaultSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //统计明细的环境 代码内部【通过参数】可以【切换数据库】
    cartSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "shoppingcart"); 

    //统计报表的环境
    reportSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "reports");
    
    注意:对于environments,我们可以在其中配置多个environment子元素,同时还需要在environment中配置dataSource和transactionManager元素。

2.1.2 transcationManager
    事务管理器，取值JDBC或MANAGED
        JDBC表示手动控制
        MANAGED被服务器管理

2.1.3 dataSource元素
    dataSource表示的是【数据源】:至少会包括该连接数据库的各种信息
    【注意： 在Java里面，数据源是一个对象】
    <dataSource type="POOLED"> 
        <property name="driver" value="${jdbc.driverClassName}" /> 
        <property name="url" value="${jdbc.url}" /> 
        <property name="username" value="${jdbc.username}" /> 
        <property name="password" value="${jdbc.password}" /> 
    </dataSource> 

    dataSource的类型type属性可以配置成其内置类型之一，如【UNPOOLED，POOLED，JNDI(web使用)】。
    如果将类型设置成UNPOOLED，MyBatis会为每一个数据库操作创建一个新的连接，使用完了并关闭它，该方式适用于只有小规模数量并发用户的简单应用程序上。
 
    如果将属性设置成POOLED，MyBatis会【创建】一个【数据库连接池】，连接池中的一个连接将会被用作数据库操作。一旦数据库操作完成，MyBatis会将此连接返回给连接池。在开发或测试环境中，经常使用此种方式。
    【注意 理解数据库连接池的概念】
  
    如果将类型设置成JNDI(Java Naming and Directory Interface , 【Java命名和目录接口】, 是SUN公司提供的一种标准的Java命名系统接口)，MyBatis从在应用服务器向配置好的JNDI数据源dataSource获取数据库连接。在生产环境中，优先考虑这种方式。

类里面attribute和property区别
attribute为数据成员
property是get/set方法后面那个词，比如getMyName()，就是MyName。

数据库连接池
弄个池子，预先创建出来多个数据库连接对象，用户使用时，直接从池子里面拿一个出来，使用完成后不要关闭，而是将连接对象放回池子。

JNDI(web部分使用，暂不关注)
使用JNDI会把四要素配置到数据库里面。
我们可以使用一个目录形式的东西，用来传递数据。
使用tomcat配合JNDI,将数据放到某个路径下，用户就可以通过路径获取数据。

properties
定义变量VALUE="name"，在xml文件中使用${VALUE}

2.1.3 transactionManager元素 :事务管理器
MyBatis支持两种类型的事务管理器：JDBC 和 MANAGED.
JDBC事务管理器的使用，是在【jdbc程序】负责管理数据库连接的生命周期（提交、回退等等）的时候。如果将TransactionManager 属性设置成JDBC，MyBatis内部将使用JdbcTransactionFactory类创建TransactionManager。例如，部署到ApacheTomcat的应用程序，需要应用程序自己管理事务。
MANAGED 事务管理器的使用，是在【应用服务器】负责管理数据库连接生命周期的时候。如果将TransactionManager属性设置成MANAGED时，MyBatis内部使用ManagedTransactionFactory 类创建事务管理器TransactionManager。
例如，当一个Java EE的【应用程序部署】在类似JBoss，WebLogic，GlassFish应用【服务器】上时，它们会使用EJB进行应用服务器的事务管理能力。在这些管理环境中，你可以使用MANAGED事务管理器。
注：【Managed 是托管】的意思，即我们编写的应用程序本身不去管理事务，而是把事务管理交给应用所在的服务器进行管理。

2.1.4 properties元素
作用是 定义变量。
这个标签必须是configuration中【最前面的子标签】。
属性配置元素properties可以【定义变量】，从而将配置值写死到mybatis-config.xml中,也可以具体到一个属性文件中,并且使用属性文件的key名作为占位符.
在上述的配置中，我们将数据库连接属性配置到了application.properties文件中，并且为driver，URL等属性使用了占位符.

在applications.properties文件中配置数据库连接参数，如下所示：
    jdbc.driverClassName=oracle.jdbc.driver.OracleDriver 
    jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:XE
    jdbc.username=test 
    jdbc.password=test

在mybatis-config.xml文件中，为属性使用application.properties文件中定义的占位符：
    <!-- 读取application.properties文件中的数据key-value的形式 -->
    <properties resource="application.properties">
    <!-- 注意:applications.properties【文件中优先级高】 -->
      <property name="jdbc.username" value="briup" /> 
      <property name="jdbc.password" value="briup" /> 
    </properties> 

<environments default="development"> 
    <environment id="development"> 
      <transactionManager type="JDBC" /> 
      <dataSource type="POOLED"> 
        <property name="driver" value="${jdbc.driverClassName}" /> 
        <property name="url" value="${jdbc.url}" /> 
        <property name="username" value="${jdbc.username}" /> 
        <property name="password" value="${jdbc.password}" /> 
      </dataSource> 
    </environment> 
</environments>

2.1.5 typeAliases元素
类型别名，放在properties后面。
1.这个标签里面的typeAlias标签可以定义别名，会在【映射文件】中使用。如果没有定义别名，那必须使用【全限定名】。

2.其【子标签package】可以为包下所有类定义别名。
    别名默认就是类名。
    
3.使用注解 可以 和package配合 定义别名
    @Alias("stu") 
    class Student { ... }
    
注意：别名【不区分大小写】。
在SQLMapper配置文件中，对于resultType和parameterType属性值，我们需要使用JavaBean 的【完全限定名】。
例如:
<select id="findStudentById" parameterType="int"  
    resultType="com.briup.pojo.Student"> 
        SELECT STUD_ID AS ID, NAME, EMAIL, DOB  
        FROM STUDENTS WHERE STUD_ID=#{Id} 
</select> 
<update id="updateStudent" parameterType="com.briup.pojo.Student"> 
    UPDATE STUDENTS  
        SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob}  
        WHERE STUD_ID=#{id} 
</update> 

注:parameterType表示将来调用这个sql语句的时候所传的参数的类型(参数值或者参数对象里面的属性值 用来替换sql语句中的占位符)
resultType表示将来调用这个sql语句的时候所返回的结果的类型(方便mybatis给我们自动封装结果集)

这里我们为resultType和parameterType属性值设置为Student类型的完全限定名：com.briup.com.Student

我们可以为完全限定名取一个别名（alias），然后就可以在需要使用完全限定名的地方使用别名，而不是到处使用完全限定名。如下例子所示，为完全限定名起一个别名：
<typeAliases> 
  <typeAlias alias="Student" type="com.briup.pojo.Student" /> 
  <typeAlias alias="Teacher" type="com.briup.pojo.Teacher" /> 
</typeAliases> 

然后在SQLMapper映射文件中, 如下使用Student的别名：
<select id="findStudentById" parameterType="int" resultType="Student"> 
    SELECT STUD_ID AS ID, NAME, EMAIL, DOB  
    FROM STUDENTS WHERE STUD_ID=#{id} 
</select> 
<update id="updateStudent" parameterType="Student"> 
    UPDATE STUDENTS  
        SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob}  
    WHERE STUD_ID=#{id} 
</update> 

你可以不用为每一个JavaBean单独定义别名,你可以为配置出需要取别名的类的所在的包(package)，MyBatis会自动扫描包内定义的类，然后分别为每个类注册一个小写字母开头的简单类名形式的别名。如下所示：
<typeAliases> 
  <package name="com.briup.pojo" /> 
</typeAliases> 
如果Student.java和 Teacher.java 定义在com.briup.pojo包中，则 com.briup.pojo.Student的别名会被注册为student。而com.briup.pojo.Teacher别名将会被注册为teacher

还有另外一种方式为JavaBeans起别名，使用【注解 @Alias 】
@Alias("stu")    配合给包起别名使用
public class Student{
    ....
} 
@Alias注解将会覆盖配置文件中的<typeAliases>定义。

2.1.6 typeHandlers元素: 类型处理器
需要写在【typeAliase后面】。
我们执行Sql语句通过ps语句实现，ps会设置？值，类型处理器帮ps找到对应的set方法，到底是选择setInt,setString或setDate...

注意：类型处理器默认可以处理基本的数据类型，对应的包装类，uitl.Date,sql.Date等，但无法默认处理【自定义类型】。
当MyBatis将一个Java对象作为输入参数执行INSERT语句操作时，它会创建一个PreparedStatement对象，并且使用setXXX()方法对占位符设置相应的参数值 。这里，XXX可以是Int，String，Date 等 Java对象属性类型的任意一个。示例如下：
<insert id="insertStudent" parameterType="Student"> 
    INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB)  
    VALUES(#{studId},#{name},#{email},#{dob}) 
</insert> 

为执行这个语句，MyBatis将采取以下一系列动作：
创建一个有占位符的PreparedStatement接口，如下：
Prepared Statement ps = 
    connection.prepareStatement("INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) VALUES(?,?,?,?)"); 
检查Student对象的属性studId的类型，然后使用合适setXXX方法去设置参数值。这里studId是integer类型，所以会使用setInt()方法：ps.setInt(1,student.getStudId()); 

类似地，对于name和email属性都是String类型MyBatis使用setString()方法设置参数。
至于dob属性, MyBatis会使用setDate()方法设置dob处占位符位置的值。
MyBaits会将java.util.Date类型转换为java.sql.Timestamp并设值：
    ps.setTimestamp(4, new Timestamp((student.getDob()).getTime())); 

但MyBatis是怎么知道对于Integer类型属性使用setInt()和String类型属性使用setString()方法呢？其实MyBatis是通过使用类型处理器typeHandlers来决定这么做的。

MyBatis对于以下的类型使用内建的类型处理器：所有的【基本数据类型】、基本类型的【包裹类型】、 byte[]、java.util.Date、java.sql.Date、java,sql.Time、java.sql.Timestamp、java枚举类型等。所以当MyBatis发现属性的类型属于上述类型，他会使用对应的类型处理器将值设置到PreparedStatement中，同样地，当SQL结果集封装成java类对象的时候，也有类似的过程。

那如果有一个【自定义的类型】，怎么存储存储到数据库呢？示例如下：假设表STUDENTS 有一个 PHONE 字段，类型为 VARCHAR2(15)，而 Student类有一个自定义类型属性 
alter table students add phone varchar2(15);
alter table students drop column phone;

java代码:
PhoneNumber 类定义类型的 phoneNumber 属性。

    public class PhoneNumber{ 
        private String countryCode; 
        private String stateCode; 
        private String number; 
        public PhoneNumber(){ 
        } 
        
        //"110-119-120"
        public PhoneNumber(String str) {
            if(str != null) {
                String[] arr = str.split("-");
                this.countryCode = arr[0];
                this.stateCode = arr[1];
                this.number = arr[2];
            }
        }
        
        public PhoneNumber(String countryCode, String stateCode, String number) { 
            this.countryCode = countryCode; 
            this.stateCode = stateCode; 
            this.number = number; 
        } 
        
        public String getAsString() { 
            return countryCode + "-" + stateCode + "-" + number; 
        } 
        // Setters and getters 
    } 
     
    public class Student{ 
        private Integer id; 
        private String name; 
        private String email; 
        private PhoneNumber phone; 
        // Setters and getters 
    } 

    
    xml配置:
    <insert id="insertStudent" parameter Type="Student"> 
        insert into students(name,email,phone) 
        values(#{name},#{email},#{phone}) 
    </insert> 

    这里，参数对象中的属性phone的值需要传递给#{phone}；而参数对象的属性phone是 PhoneNumber类型。但是，MyBatis 并不知道该怎样来处理这个类型的对象。
    为了让MyBatis明白怎样处理这个自定义的Java对象类型，如PhoneNumber，我们可以创建一个自定义的类型处理器,MyBatis提供了抽象类【BaseTypeHandler<T>】 ，我们可以继承此类创建自定义类型处理器。
    代码如下所示:
        package com.briup.typehandlers;

        import java.sql.CallableStatement;
        import java.sql.PreparedStatement;
        import java.sql.ResultSet;
        import java.sql.SQLException;

        import org.apache.ibatis.type.BaseTypeHandler;
        import org.apache.ibatis.type.JdbcType;

        import com.briup.pojo.PhoneNumber;

        public class PhoneTypeHandler extends BaseTypeHandler<PhoneNumber>{

            //遇到PhoneNumber参数的时候应该如何在ps中设置值
            @Override
            public void setNonNullParameter(PreparedStatement ps, int index, PhoneNumber phone, JdbcType jdbcType)
                    throws SQLException {
                ps.setString(index, phone.getAsString());
            }

            //查询中遇到PhoneNumber类型的应该如何封装(使用列名封装)
            @Override
            public PhoneNumber getNullableResult(ResultSet rs, String columnName) throws SQLException {
                String str = rs.getString(columnName);
                return new PhoneNumber(str);
            }

            //查询中遇到PhoneNumber类型的应该如何封装(使用列的下标)
            @Override
            public PhoneNumber getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
                return new PhoneNumber(rs.getString(columnIndex));
            }

            //CallableStatement使用中遇到了PhoneNumber类型的应该如何封装
            @Override
            public PhoneNumber getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
                return new PhoneNumber(cs.getString(columnIndex));
            }

        }
    
    注意:使用ps.setString()和rs.getString()方法是 :因为在数据库的表中phone列是VARCHAR类型。

    最后一旦我们实现了自定义的类型处理器，我们需要在mybatis-config.xml中注册它：
    <?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> 
        <properties resource="application.properties" /> 
        <typeHandlers> 
            <typeHandler handler="com.briup.typehandlers.PhoneTypeHandler" /> 
        </typeHandlers> 
    </configuration> 
    注册PhoneTypeHandler后, MyBatis就能够将Phone类型的对象值存储到VARCHAR类型的列上。

2.1.7 settings元素: 全局参数设置

注意:大多数情况下，【这些参数使用它们的默认值即可】
为满足应用特定的需求，MyBatis默认的全局参数设置可以被覆盖掉，如下所示：
<settings>
  <setting name="cacheEnabled" value="true" /> 
  <setting name="lazyLoadingEnabled" value="true" /> 
  <setting name="multipleResultSetsEnabled" value="true" /> 
  <setting name="useColumnLabel" value="true" /> 
  <setting name="useGeneratedKeys" value="false" /> 
  <setting name="autoMappingBehavior" value="PARTIAL" /> 
  <setting name="defaultExecutorType" value="SIMPLE" /> 
  <setting name="defaultStatementTimeout" value="25000" /> 
  <setting name="safeRowBoundsEnabled" value="false" /> 
  <setting name="mapUnderscoreToCamelCase" value="false" /> 
  <setting name="localCacheScope" value="SESSION" /> 
  <setting name="jdbcTypeForNull" value="OTHER" /> 
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hash Code ,to String" /> 
  <setting name="proxyFactory" value="JAVASSIST" /> 
  <setting name="aggressiveLazyLoading" value="true" /> 
  <setting name="logImpl" value="LOG4J " /> 
  <setting name="logPrefix" value="LOG4J " /> 
  <setting name="callSettersOnNulls" value="false " /> 
</settings> 


<settings>
  <!-- 这个配置使全局的映射器启用或禁用 【缓存】 -->
  <setting name="cacheEnabled" value="true" />

  <!-- 全局启用或禁用【延迟加载】。当禁用时，所有关联对象都会即时加载 -->
  <setting name="lazyLoadingEnabled" value="true" />

  <!-- 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动才有效） -->
  <setting name="multipleResultSetsEnabled" value="true" /> 

  <!-- 使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动 -->
  <setting name="useColumnLabel" value="true" /> 

  <!-- 允许JDBC支持【id自动生成】。需要适合的驱动。 -->
  <setting name="useGeneratedKeys" value="false" /> 

  <!-- 指定MyBatis如何【自动映射】列到 列/属性值。PARTIAL只会自动映射简单、没有嵌套的结果。FULL会自动映射任意复杂的结果（嵌套的或其他情况） -->
  <setting name="autoMappingBehavior" value="PARTIAL" />
  
  <!-- 配置默认的执行器。SIMPLE执行器没有什么特别之处。REUSE执行器重用预处理语句。BATCH【执行器】重用语句和批量更新 -->
  <setting name="defaultExecutorType" value="SIMPLE" /> 

  !-- 设置【超时时间】，它决定驱动等待一个数据库响应的时间 -->
  <setting name="defaultStatementTimeout" value="25000" /> 
  
  <!-- 在嵌套语句中使用【分页功能】（RowBounds），默认false -->
  <setting name="safeRowBoundsEnabled" value="false" /> 

  <!-- 是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。默认false -->
  <setting name="mapUnderscoreToCamelCase" value="false" /> 

  <!-- MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。 -->
  <setting name="localCacheScope" value="SESSION" /> 

  <!-- 当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。 -->
  <setting name="jdbcTypeForNull" value="OTHER" />

  <!-- 指定对象的哪个方法【触发一次延迟加载】。 -->
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode ,toString" /> 

  <!-- CGLIB | JAVASSIST 默认JAVASSIST(MyBatis 3.3 or above)  -->
  <!-- 指定 Mybatis 创建具有延迟加载能力的对象所用到的【代理工具】。 -->
  <setting name="proxyFactory" value="JAVASSIST" /> 
  <!-- 当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载。 -->
  <setting name="aggressiveLazyLoading" value="true" /> 
    
  <!-- 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。 -->
  <setting name="logImpl" value="LOG4J " /> 

  <!-- 指定 MyBatis 增加到日志名称的前缀。值可以是任意字符串 -->
  <setting name="logPrefix" value="LOG4J " /> 

  <!-- 指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。 默认false-->
  <setting name="callSettersOnNulls" value="false " /> 
</settings>

2.1.8 mappers元素: SQL映射
在mybatis-config.xml文件中通过mapper标签可以【配置SQLMapper文件路径】。
<mappers>

<mapper resource="com/briup/mappers/StudentMapper.xml" />
<mapper url="file:///D:/mybatisdemo/app/mappers/StudentMapper.xml" />

  <!-- 如果使用了【注解方式】配置映射的Sql语句 -->
  <mapper class="com.briup.mappers.StudentMapper" /> 
  <package name="com.briup.mappers" /> 
</mappers> 

以上每一个<mapper> 标签都可以从不同类型的资源中加载映射mapper：
    resource属性用来指定在classpath中的mapper文件
    url属性用来通过完全文件系统路径或者web中url地址来指向mapper文件
    class属性用来指向一个mapper接口
    package属性用来指向可以找到Mapper接口的包名

2.2 使用Java API配置MyBatis
【了解内容】,因为有了灵活的配置配置文件,这个方式几乎不用
MyBatis的SqlSessionFactory接口除了使用基于XML的配置创建外也可以通过JavaAPI编程式地被创建。每在XML中配置的元素，都可以编程式的创建。
因为mybatis框架读取了我们配置的mybatis-config.xml中配置信息之后,然后利用这些信息去执行代码创建出我们需要的SqlSessionFactory,再从而进一步得到sqlSession,最后再进行各种数据库操作。
所以其实我们完全可以不去配置任何信息直接把信息写在代码中,然后在按着之前的顺序创建出我们需要的SqlSessionFactory,再从而进一步得到sqlSession,最后再进行各种数据库操作。只是这样做再大多数时候都会降低代码的灵活性,所以我们基本上接触的框架都是有相应的配置文件的.

例如:使用Java API创建SqlSessionFactory对象,之前是读取配置文件之后再创建,现在是自己把信息写到代码中,然后再创建该对象.

public static SqlSessionFactory getSqlSessionFactory() { 
    SqlSessionFactory sqlSessionFactory = null; 
    try { 
        //获取数据源
        DataSourcedata Source = DataSourceFactory.getDataSource(); 
        //创建事务管理工程
        TransactionFactory transactionFactory = new JdbcTransactionFactory(); 
        //创建数据库连接环境
        Environment environment = new Environment("development", transactionFactory, dataSource); 
        
        //创建根元素
        Configuration configuration = new Configuration(environment); 
        
        //配置别名
        Configuration.getTypeAliasRegistry().registerAlias("student",Student.class); 
        
        //配置类型处理器
        Configuration.getTypeHandlerRegistry().register(PhoneNumber.class, PhoneTypeHandler.class);
        
        //添加映射接口
        Configuration.addMapper(StudentMapper.class); 
        
        //构建会话工厂
        sqlSessionFactory = new SqlSessionFactoryBuilder(). 
        build(configuration); 
    } catch (Exception e) { 
        throw new RuntimeException(e); 
    } 
    return sqlSessionFactory; 
} 

类似的,每个在XML中配置的元素，都可以编程的方式的创建.
注:这里就不一一介绍了，因为绝大多数情况下我们还是不会把配置信息直接写到代码中的

2.3 自定义MyBatis日志
MyBatis里面支持很多种日志，使用内部LoggerFactory作为真正的日志类库使用的门面【门面模式】。其内部的LaggerFactory会将日志记录任务委托给如下所示某一个日志实现，日志记录【优先级】由上到下顺序递减：
SLF4J
Apache Commons Logging
Log4j2
Log4j
JDK logging 【唯一不需要jar包的】
如果MyBatis未发现上述日志记录实现，则MyBatis的日志记录功能无效,如果你的运行环境中，在classpath中有多个可用的日志类库，并且你希望MyBaits使用某个特定的日志实现，你可以通过调用以下其中一个方法：
org.apache.ibatis.logging.LogFactory.useSlf4jLogging();
org.apache.ibatis.logging.LogFactory.useLog4JLogging();
org.apache.ibatis.logging.LogFactory.useLog4J2Logging();
org.apache.ibatis.logging.LogFactory.useJdkLogging();
org.apache.ibatis.logging.LogFactory.useCommonsLogging();
org.apache.ibatis.logging.LogFactory.useStdOutLogging();
注:
如果你想【自定义MyBatis日志】记录，你应该在调用任何其它方法之前调用以上的其中一个方法。

三 使用XML配置SQL映射器(映射文件)
关系型数据库和SQL是经受时间考验和验证的数据存储机制。和其他的ORM 框架如Hibernate不同，【MyBatis鼓励】开发者可以直接【使用数据库】，而不是将其对开发者隐藏，因为这样可以充分发挥数据库服务器所提供的SQL语句的巨大威力。
与此同时，MyBaits【消除】了书写大量【冗余代码】的痛苦，它让使用SQL更容易。在代码里直接嵌套
很差的编码实践，并且维护起来困难。MyBaits使用了映射文件或注解来配置SQL语句。

3.1 映射器文件和映射器接口
我们已经看见了一些在映射器配置文件中配置基本的映射语句，以及怎样使用SqlSession对象调用它们的例子。现在让我们看一下在com.briup.mappers包中的StudentMapper.xml 配置文件内，是如何配置id为”findStudentById”的SQL语句的，代码如下：
<?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.briup.mappers.StudentMapper">
<select id="findStudentById" parameterType="int" resultType="Student">
select stud_id as studId, name, email, dob
from students where stud_id=#{studId}
</select>
</mapper>

我们可以通过下列代码调用findStudentById映射的SQL语句:
public Student findStudentById(Integer studId) {
SqlSession sqlSession = MyBatisSqlSessionFactory.openSession();
try{
Student student = sqlSession.selectOne("com.briup.mappers.StudentMapper.findStudentById", studId);
return student;
}
finally {
sql Session.close();
}
}

调用映射方法的方式一：
我们可以通过字符串（字符串形式为：映射器配置文件所在的包名的【namespace + sql语句id值】，如上，即包名com.briup.mappers.StudentMapper和语句id的值findStudentById组成）调用映射的SQL语句。
但是这种方式【容易出错】，我们【不推荐】使用。你需要检查映射器配置文件中的定义，以保证你的输入参数类型和结果返回类型是有效的。

调用映射方法的方式二：
也就是我们一直在使用的方式，通过session获取mapper对象，然后由mapper对象直接调用映射方法实现功能。
【重点部分:】
MyBatis通过使用映射器Mapper接口提供了更好的调用映射语句的方法。一旦我们通过映射器配置文件配置了映射语句，我们可以创建一个完全对应的一个映射器接口，xml映射文件中的【namespace属性值】和映射接口的【全限定名】需要保持【一致】。
映射器接口中的【方法名】也跟映射器配置文件中【id值】完全对应；
映射方法的【参数类型】和【parameterType属性值】对应；
映射方法【返回值类型】和【returnType属性值】一致。

上述的StudentMapper.xml文件,我们可以创建一个映射器接口StudentMapper.java如下：
     
    package com.briup.mappers; 
    public interface StudentMapper{ 
        Student findStudentById(Integer id); 
    } 
在Student Mapper.xml映射器配置文件中，其名空间namespace应该跟StudentMapper接口的全限定名保持一致。另外，StudentMapper.xml中语句id, parameterType，returnType 应该分别和StudentMapper接口中的方法名，参数类型，返回值相对应。

使用映射器接口我们可以以类型安全的形式调用调用映射语句。如下所示：
     
    public Student findStudentById(Integer studId){ 
        SqlSession sqlSession = MyBatisSqlSessionFactory.openSession();  
        try { 
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class); 

            return student Mapper.findStudentById(studId); 
        } 
        finally { 
            sqlSession.close(); 
        } 
    }

结论：
namespace关键字的用法
情形1： 任何值都可以
使用session对象执行sql语句；

情形2:  必须映射接口的全包名
    使用映射接口对象 执行sql语句。
    
推荐第2种。

3.2 映射语句
建立新的ResultMapper.java ResultMapper.xml文件进行测试。
MyBatis提供了多种元素来配置不同类型的语句，如SELECT，INSERT，UPDATE，DELETE。让我们看看如何具体配置映射语句

3.2.1 INSERT 插入语句
一个INSERT语句可以在<insert>标签元素在映射器XML配置文件中配置，如下所示：
<insert id="insertStudent" parameterType="Student">
INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB,PHONE) VALUES(#{studId},#{name},#{email},#{dob},#{phone})
</insert>

这里我们设置id属性为insertStudent，可以在名空间 com.briup.mapper.StudentMapper.insertStudent中唯一标识该sql语句。parameterType 属性是一个完全限定类名或者是一个类型别名（alias）。

我们可以如下调用这个语句：
    int count =  sqlSession.insert("com.briup.mappers.StudentMapper.insertStudent", student); 

sqlSession.insert() 方法返回执行 INSERT 语句后所影响的行数。

如果不使用命名空间（namespace）和语句 id 来调用映射语句，你可以通过【创建一个映射器Mapper 接口】，并以类型安全的方式调用方法，如下所示：
    package com.briup.mappers; 
    public interface StudentMapper{ 
        int insertStudent(Student student); 
    } 
    
你可以如下调用insertStudent映射语句：
    StudentMapper mapper =  sqlSession.getMapper(StudentMapper.class); 
    int count = mapper.insertStudent(student);

【自动生成主键】:
a.对于主键值可以自动增长的数据库，例如mysql
在上述的INSERT语句中，我们为可以自动生成（auto-generated）主键的列 STUD_ID 插入值。我们可以使用useGeneratedKeys和keyProperty属性让数据库生成auto_increment列的值，并将生成的值设置到其中一个输入对象属性内，如下所示：

    <insert id="insertStudent" parameterType="Student" useGeneratedKeys="true" keyProperty="studId"> 
        INSERT INTO STUDENTS(NAME,EMAIL,DOB,PHONE) VALUES(#{name},#{email},#{DOB},#{phone}) 
    </insert> 
    这里STUD_ID列值将会被数据库自动生成(如mysql)，并且生成的值会被设置到student对象的studId属性上。

b.对于主键值不能够自动增长的数据库，例如oracle
    使用【序列】（SEQUENCE）来生成主键值。假设我们有一个名为my_seq的序列来生成SUTD_ID主键值。使用如下代码来生成主键：
    drop sequence my_seq;
    create sequence my_seq;

    <insert id="insertStudent" parameterType="Student"> 
        <selectKey keyProperty="studId" resultType="int" order="BEFORE"> 
            SELECT my_seq.nextval FROM DUAL 
        </selectKey> 
        INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL, PHONE) 
        VALUES(#{studId},#{name},#{email},#{phone}) 
    </insert> 
    这里我们使用了<selectKey>子元素来生成主键值，并将值保存到Student对象的studId 属性上。属性【order=“before”】表示MyBatis将取得序列的下一个值作为主键值，并且在【执行INSERT语句之前】将值设置到studId属性上。

注意:SelectKey需要注意order属性，像MySQL、SQLServer等一类支持自动增长类型的数据库中，order需要设置为after才会取到正确的值。
像Oracle这样取序列的情况，需要设置为before，否则会报错。

3.2.2 UPDATE 更新语句
一个UPDATE SQL语句可以在<update>元素在映射器XML配置文件中配置，如下所示：
<update id="updateStudent" parameterType="Student">
UPDATE STUDENTS
SET NAME=#{name}, EMAIL=#{email}, PHONE=#{phone}
WHERE STUD_ID=#{studId}
</update>

我们可以如下调用此语句：
    int noOfRowsUpdated = sqlSession.update("com.briup.mappers.StudentMapper.updateStudent", student); 

sqlSession.update()方法返回执行UPDATE语句之后影响的行数。

如果不使用名空间（namespace）和语句id来调用映射语句，你可以通过创建一个映射器Mapper接口，并以类型安全的方式调用方法，如下所示：
 
    package com.briup.mappers; 
    public interface StudentMapper{ 
        int updateStudent(Student student); 
    } 

你可以使用映射器Mapper接口来调用updateStudent语句，如下所示：
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); 
    int noOfRowsUpdated = mapper.updateStudent(student);

3.2.3 DELETE 删除语句
一个Delete SQL语句可以在<delete>元素在映射器XML配置文件中配置，如下所示
<delete id="deleteStudent" parameterType="int">
DELETE FROM STUDENTS
WHERE STUD_ID=#{id}
</delete>

我们可以如下调用此语句：
    int studId = 1; 
    int noOfRowsDeleted = sqlSession.delete("com.briup.mappers.StudentMapper.deleteStudent", studId); 
sqlSession.delete()方法返回 delete 语句执行后影响的行数。

如果不使用名空间（namespace）和语句 id 来调用映射语句，你可以通过创建一个映射器 Mapper 接口，并以类型安全的方式调用方法，如下所示：
    package com.briup.mappers; 
    public interface StudentMapper{ 
      int deleteStudent(int studId); 
    } 
你可以使用映射器Mapper接口来调用updateStudent语句，如下所示：
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); 
    int noOfRowsDeleted = mapper.deleteStudent(studId);

3.2.4 SELECT 查询语句
MyBatis真正强大的功能，在于【映射SELECT查询结果】到java的【各种类型】。
让我们看看一个简单的select查询是如何（在MyBatis中）配置的，如下所示：
<select id="findStudentById" parameterType="int" resultType="Student">
SELECT STUD_ID, NAME, EMAIL, DOB, PHONE
FROM STUDENTS
WHERE STUD_ID=#{studId}
</select>

我们可以如下调用此语句：
    int studId = 1; 
    Student student = sqlSession.selectOne("com.briup.mappers.StudentMapper.findStudentById", studId);

如果不使用名空间（namespace）和语句 id 来调用映射语句，你可以通过创建一个映射器 Mapper 接口，并以类型安全的方式调用方法，如下所示：
    package com.briup.mappers; 
    public interface StudentMapper{ 
        Student findStudentById(Integer studId); 
    }
    
你可以使用映射器Mapper接口来调用 findStudentById 语句，如下所示：
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); 
    Student student = mapper.findStudentById(studId); 

如果你检查Student对象的属性值，你会发现studId属性值并没有被stud_id列值填充。这是因为MyBatis自动对java对象中和【列名匹配的属性】进行填充。这就是为什么name,email和 phone属性被填充而studId属性没有被填充。
解决这一问题，我们可以为列名起一个可以与JavaBean中属性名匹配的【别名】，如下所示：
    <select id="findStudentById" parameterType="int"  
    resultType="Student"> 
        SELECT STUD_ID AS studId,NAME,EMAIL,DOB,PHONE  
            FROM STUDENTS  
        WHERE STUD_ID=#{studId} 
    </select> 

    
MyBatis执行返回多条结果的SELECT语句查询，如下所示：
    <select id="findAllStudents" resultType="Student"> 
        SELECT STUD_ID AS studId,NAME,EMAIL,DOB,PHONE  
        FROM STUDENTS 
    </select>

    List<Student> students =  sqlSession.selectList("com.briup.mappers.StudentMapper.findAllStudents"); 

映射器 Mapper 接口 StudentMapper 可以如下定义：
    package com.briup.mappers; 
    public interface StudentMapper{ 
        List<Student> findAllStudents(); 
    } 

使用上述代码，我们可以如下调用
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class); 
    List<Student> students = mapper.findAllStudents(); 

如果你注意到上述的SELECT映射定义，你可以看到，我们为所有的映射语句中的stud_id 起了别名。我们可以使用ResultMaps，来避免上述的到处重复别名。我们稍后会继续讨论。
除了java.util.List，你也可以使用其他类型的集合类，如Set,Map，以及（SortedSet）。MyBatis 根据集合的类型，会采用适当的集合实现，如下所示：
对于List，Collection，Iterable类型，MyBatis将返回java.util.ArrayList 
    对于Map类型，MyBatis 将返回java.util.HashMap  
    对于Set类型，MyBatis 将返回java.util.HashSet 
    对于SortedSet类型，MyBatis将返回java.util.TreeSet

3.3 结果集映射 ResultMaps
ResultMaps被用来将SELECT语句的结果集映射到java对象的属性中。我们可以定义结果集映射ResultMaps并且在一些SELECT语句上引用resultMap。MyBatis的结果集映射 ResultMaps特性非常强大，你可以使用它将简单的SELECT语句映射到复杂的一对一、一对多关系的SELECT语句上。

3.3.1 简单ResultMap
一个映射了查询结果为Student类型的resultMap定义如下：
<resultMap id="StudentResult" type="com.briup.pojo.Student">
<id property="studId" column="stud_id" />
<result property="name" column="name" />
<result property="email" column="email" />
<result property="phone" column="phone" />
</resultMap>

    <select id="findAllStudents" resultMap="StudentResult"> 
        SELECT * FROM STUDENTS 
    </select> 
    
    <select id="findStudentById" parameterType="int" resultMap="StudentResult"> 
        SELECT * FROM STUDENTS WHERE STUD_ID=#{studId} 
    </select> 

resultMap的id值应该在此名空间内是唯一的,并且type属性是完全限定类名或者是返回类型的别名。
<result>子元素被用来将一个resultset列映射到对象的一个属性中。
<id>元素和<result>元素功能相同，不过<id>它被用来映射到 【唯一标识】属性，用来区分和比较对象（一般和主键列相对应）。
在<select>语句中，我们使用了resultMap属性，而不是resultType属性。当<select>语句中配置了resutlMap属性，MyBatis会使用表中的列名与对象属性 【映射关系】 来填充对象中的属性值。

注意:【resultType】和【resultMap】二者只能用其一，【不能同时使用】。

【a.问题升级】
<select>映射语句中如何将查询【一条】数据填充到HashMap中?
<select id="findStudentById" parameterType="int" resultType="map">
SELECT * FROM STUDENTS
WHERE STUD_ID=#{studId}
</select>
在上述的<select>语句中，我们将resultType配置成【map，即java.util.HashMap的别名】。在这种情况下，结果集的【列名】将会作为Map中的key值，而【列值】将作为Map的value值。

    HashMap<String,Object> studentMap = 
        sqlSession.selectOne("com.briup.mappers.StudentMapper.findStudentById", studId); 
    System.out.println("stud_id :"+studentMap.get("stud_id")); 
    System.out.println("name :"+studentMap.get("name")); 
    System.out.println("email :"+studentMap.get("email")); 
    System.out.println("phone :"+studentMap.get("phone"));

【b.问题再升级】
<select>映射语句中如何将查询【多条】数据填充到HashMap中?
<select id="findAllStudents" resultType="map">
SELECT STUD_ID, NAME, EMAIL, PHONE FROM STUDENTS
</select>

由于resultType=”map”和语句返回多行，则最终返回的数据类型应该是List<Map<String,Object>>，如下所示：

    List<Map<String, Object>> studentMapList = sqlSession.select List("com.briup.mappers.StudentMapper.findAllStudents"); 
    for(Map<String, Object> studentMap : studentMapList) { 
    System.out.println("studId :" + studentMap.get("stud_id")); 
        System.out.println("name :" + studentMap.get("name")); 
        System.out.println("email :" + studentMap.get("email")); 
        System.out.println("phone :" + studentMap.get("phone")); 
    } 


其他实例1:
    <select id="findAllStudents_student" resultType="Student">
        SELECT STUD_ID AS STUDID,NAME,EMAIL,DOB
        FROM STUDENTS
    </select>
对应的接口中的方法,你写什么类型的集合,Mybatis就给你返回什么类型的集合,但是要注意使用SortedSet的时候,Student类需要实现Comparable接口,否则是不能进行排序的
    例如:
    public List<Student> findAllStudents_List();
    或者
    public Set<Student> findAllStudents_Set();
    或者
    public SortedSet<Student> findAllStudents_SortedSet();


其他实例2:
    <select id="findAllName_list" resultType="String">
        SELECT NAME
        FROM STUDENTS
    </select>
    对应的接口中的方法: 把查询到所有名字都放到List集合中并返回
    public List<String> findAllName_list();

    
其他实例3:
    <select id="findCount_int" resultType="int">
        SELECT count(*)
        FROM STUDENTS
    </select>
    对应的接口中的方法: 把查询到的这个值直接返回
    public int findCount_int();
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 219,701评论 6赞 508
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 93,649评论 3赞 396
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 166,037评论 0赞 356
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,994评论 1赞 295
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 68,018评论 6赞 395
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,796评论 1赞 308
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,481评论 3赞 420
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,370评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,868评论 1赞 319
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 38,014评论 3赞 338
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,153评论 1赞 352
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,832评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,494评论 3赞 331
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,039评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,156评论 1赞 272
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,437评论 3赞 373
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 45,131评论 2赞 356

推荐阅读更多精彩内容