连接池及事物控制

mybatis连接池提供了3种方式的配置：
配置的位置：
主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。
type属性的取值：
POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。
JNDI 采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。
注意：如果不是web或者maven的war工程，是不能使用的。
我们课程中使用的是tomcat服务器，采用连接池就是dbcp连接池。

    <properties resource="db.properties"></properties>

    <!--使用typeAliases配置别名，它只能配置domain中类的别名 -->
    <typeAliases>
        <package name="com.lmw.domain"></package>
    </typeAliases>

    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="jdbc"></transactionManager>
            <dataSource type="pooled">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

3、mybatis中的事务

什么是事务

事务的四大特性ACID

不考虑隔离性会产生的3个问题

解决办法：四种隔离级别

一、什么是事务

事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。可以理解为：更新数据库中各种数据项的程序执行单元。就比如：同一根绳上的蚂蚱，要活一起活，要死一起死。

二、事务的四个特性

事务的四个特性为原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持续性（Durability）,简称为ACID

1、原子性：操作要么都发生，要么都不发生。

2、一致性：事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是不一致的状态。

3、隔离性：一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

4、持续性：也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

三、不考虑隔离性会导致的三个问题

1、脏读：脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

2、不可重复读：一个事务两次读取同一行的数据，结果得到不同状态的结果，中间正好另一个事务更新了该数据，两次结果相异，不可被信任。通俗来讲就是：事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。

3、幻读（虚读）：一个事务执行两次查询，第二次结果集包含第一次中没有或某些行已经被删除的数据，造成两次结果不一致，只是另一个事务在这两次查询中间插入或删除了数据造成的。通俗来讲就是：例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读

四、解决办法（四种隔离级别）

1、Read Uncommited（读取未提交内容）

读未提交，顾名思义，就是一个事务可以读取另一个未提交事务的数据。但是，读未提交产生了脏读，采用读提交可以解决脏读问题

2、Read Commited（读取提交内容）

读提交，顾名思义，就是一个事务要等另一个事务提交后才能读取数据。读提交，若有事务对数据进行更新（UPDATE）操作时，读操作事务要等待这个更新操作事务提交后才能读取数据，可以解决脏读问题。但在这个事例中，出现了一个事务范围内两个相同的查询却返回了不同数据，这就是不可重复读。但是，读提交两次查询会产生不同的查询结果，就会造成不可重复读问题，采用重复读可以解决此问题。

3、Repeatable Read（重复读）

重复读，就是在开始读取数据（事务开启）时，不再允许修改操作。重复读可以解决不可重复读问题。应该明白的一点就是，不可重复读对应的是修改，即UPDATE操作。但是可能还会有幻读问题。因为幻读问题对应的是插入INSERT操作，而不是UPDATE操作。采用Serializable可以解决幻读问题

4、Serializable（可串行化）

Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

【注意】

1、大多数数据库默认的事务隔离级别是Read committed，比如Sql Server , Oracle。Mysql的默认隔离级别是Repeatable read。

2、隔离级别的设置只对当前链接有效。对于使用MySQL命令窗口而言，一个窗口就相当于一个链接，当前窗口设置的隔离级别只对当前窗口中的事务有效；对于JDBC操作数据库来说，一个Connection对象相当于一个链接，而对于Connection对象设置的隔离级别只对该Connection对象有效，与其他链接Connection对象无关。

3、设置数据库的隔离级别一定要是在开启事务之前。

它是通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚

//1、
        sqlSession = factory.openSession(true);
//2、
        sqlSession = factory.openSession();
        sqlSession.commit();

动态sql语句

    if,where,foreach
<select id="findSuserByCondition" parameterType="suser" resultMap="suserMap">
        SELECT * FROM suser
        <where>
            <if test="sname != null">
                and  Sname = #{sname}
            </if>
            <if test="snumbername != null">
                and Snumbername = #{snumbername}
            </if>
        </where>
    </select>

<select id="findSuserInIds" resultMap="suserMap" parameterType="queryvo" >
      select * from suser
      <where>
          <if test="snumbernames != null and snumbernames.size()>0">
              <foreach collection="snumbernames" open="and snumbername in (" close=")" item="sno" separator=",">
                  #{sno}
              </foreach>
          </if>
      </where>
    </select>

    choose when 标签 条件判断
        <select id="queryAccountByKey2" parameterType="map" resultType="account">
            SELECT * FROM account where 1=1
            <choose>
                <when test="aname != null and aname != ''">
                    and aname like '%${aname}%'
                </when>
                <when test="money != null and money != ''">
                    and money > #{money};
                </when>
                <otherwise>
                    and createTime > '2020-06-23'
                </otherwise>
            </choose>
        </select>

    set标签
        <update id="updateUserById" parameterType="user">
            update user
                <set>
                    <if test="userName!=null">
                        userName=#{userName},
                    </if>
                    <if test="userPwd!=null">
                        userPwd=#{userPwd},
                    </if>
                </set>
            where id=#{id}
        </update>

    自定义 trim 元素
        可以自定义前缀后缀标签是 where 或 set   以及 可以自定义处理的 前缀后缀拼接符  and   ,
        
        <select id="queryAccountByKey4" parameterType="map" resultType="account">
            SELECT * FROM account
            <trim prefix="where" prefixOverrides="and">
                <if test="aname != null and aname != ''">
                    and aname like '%${aname}%'
                </if>
                <if test="money != null and money != ''">
                    and money > #{money};
                </if>
            </trim>
        </select>

多表操作

表之间的关系有几种：
一对多
多对一
一对一
多对多

举例：
    用户和订单就是一对多
    订单和用户就是多对一
        一个用户可以下多个订单
        多个订单属于同一个用户
    人和身份证号就是一对一
        一个人只能有一个身份证号
        一个身份证号只能属于一个人
    老师和学生之间就是多对多
        一个学生可以被多个老师教过
        一个老师可以交多个学生
特例：
    如果拿出每一个订单，他都只能属于一个用户。
    所以Mybatis就把多对一看成了一对一。   

mybatis中的多表查询：

            一对多
    示例：用户和账户
        一个用户可以有多个账户
        一个账户只能属于一个用户（多个账户也可以属于同一个用户）
    步骤：
        1、建立两张表：用户表，账户表
            让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
        2、建立两个实体类：用户实体类和账户实体类
            让用户和账户的实体类能体现出来一对多的关系
        3、建立两个配置文件
            用户的配置文件
            账户的配置文件
        4、实现配置：
            当我们查询用户时，可以同时得到用户下所包含的账户信息
            当我们查询账户时，可以同时得到账户的所属用户信息

            多对多
    示例：用户和角色
        一个用户可以有多个角色
        一个角色可以赋予多个用户
    步骤：
        1、建立两张表：用户表，角色表
            让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
        2、建立两个实体类：用户实体类和角色实体类
            让用户和角色的实体类能体现出来多对多的关系
            各自包含对方一个集合引用
        3、建立两个配置文件
            用户的配置文件
            角色的配置文件
        4、实现配置：
            当我们查询用户时，可以同时得到用户所包含的角色信息
            当我们查询角色时，可以同时得到角色的所赋予的用户信息

1对1

//  实体类  1对1关系映射
    private User user;


    <!--定义封装account和user的resultMap-->
    <resultMap id="accountUser" type="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--1对1关系映射，配置封装user的内容-->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </association>
    </resultMap>

    <!-- 查询客户-->
    <select id="findAll"  resultMap="accountUser">
        select a.*,u.username,u.address from account a,user u where a.uid=u.id;
    </select>

1对多

//  1对多关系映射
    private List<Account> accounts;

<resultMap id="userAccountMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="birthday" column="birthday"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <!--配置User的accounts集合-->
        <collection property="accounts" ofType="account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
        </collection>
    </resultMap>

    <!-- 查询客户-->
    <select id="findAll"  resultMap="userAccountMap">
        SELECT u.*,a.id as aid,a.uid,a.money FROM user u left join account a on u.id=a.uid;
    </select>

多对多

//    多对多的关系映射
    private List<User> users;

    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="birthday" column="birthday"></result>
            <result property="sex" column="sex"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from  role r
          left outer join user_role ur on r.id = ur.rid
          left outer join user u on u.id = ur.uid;
    </select>