mybatis学习日记2

1.mybatis中的连接池

配置的位置：主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是用来表示采用何种连接方式

mybatis连接池提供了3种方式的配置：

UNPOOLED：不使用连接池的数据源（采用传统获取连接的方式，虽然也实现了javax.sql.DataSource接口，但是并没有使用池的思想）
POOLED ：使用连接池的数据源（采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现）
JNDI ：使用 JNDI 实现的数据源（采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到的DataSource对象是不一样的，注意：如果不是web或者maven的war工程，是不能使用的）

2.mybatis中的事务

2.1.什么是事务

事务是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再

分割的操作集合（工作逻辑单元）；

2.2.事物的四大特性ACID

事务具有四个特征，分别足原子性（Atomicity )、一致性（Consistency )、隔离性（Isolation) 和持久性（Durability),简称为事务的ACID特性。

2.2.1.原子性（Atomicity )

事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中，只允许出现以下两种状态之一。

• 全部成功执行。
• 全部不执行。

2.2.2.一致性（Consistency )

事务的一致性是指事务的执行不能破坏数据库数据的完整性和一致性，一个事务在执行之前和执行之后，数据库都必须处于一致性状态。也就是说，事务执行的结果必须是使

数据库从一个一致性状态转变到另一个一致性状态，因此当数据库只包含成功事务提交的结果时，就能说数据库处于一致性状态。而如果数据库系统在运行过程中发生故障，

有些事务尚未完成就被迫中断，这些未完成的事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是不一致的状态。

2.2.3.隔离性（Isolation)

事务的隔离性是指在并发环境中，并发的事务是相互隔离的，一个事务的执行不能被其他事务干扰。也就是说，不同的事务并发操纵相同的数据时，每个事务都有各自完整的

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

2.2.4.持久性（Durability)

事务的持久性也被称为永久性，是指一个事务一旦提交，它对数据库中对应数据的状态变更就应该是永久性的。换句话说，一旦某个事务成功结束，那么它对数据库所做的更

新就必须被永久保存下来——即使发生系统崩溃或机器宕机等故障，只要数据库能够重新启动，那么一定能够将其恢复到事务成功结束时的状态。

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

当多个线程都开启事务操作数据库中的数据时，数据库系统要能进行隔离操作，以保证各个线程获取数据的准确性，如果不考虑事务的隔离性，会发生以下几种问题：

2.3.1脏读

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

当一个事务正在多次修改某个数据，而在这个事务中这多次的修改都还未提交，这时一个并发的事务来访问该数据，就会造成两个事务得到的数据不一致。

2.3.2.不可重复读

不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。

例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。

不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。

在某些情况下，不可重复读并不是问题，比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题，例如对于同一个数据A和B依

次查询就可能不同，A和B就可能打起来了……

2.3.3.虚读（幻读）

幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这

个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一

样，这就是发生了幻读。

幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的

个数）。

参考链接：https://www.cnblogs.com/songanwei/p/9387526.html

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

两种提交方式：

手动提交：在关闭连接之前执行sqlsession.commit（）方法手动提交

自动提交：

3.mybatis的动态SQL语句

3.1.动态SQL之<if>标签

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，如果 username 不同空时还要加入用户名作为条件。这种情

况在我们的多条件组合查询中经常会碰到。

3.1.1.持久层 Dao 接口

/**

根据用户信息，查询用户列表

@param user

@return

*/


List<User> findByUser(User user);

3.1.2. 映射配置文件

<select id="findByUser" resultType="user" parameterType="user">  
    select * from user where 1=1 
 <if test="username!=null and username != '' ">   
     and username like #{username}  
    </if> 
 <if test="address != null">   
     and address like #{address}  
    </if>    
</select>

注意：<if>标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。另外要注意 where 1=1 的作用~！

3.1.3.测试

@Test 
 public void testFindByUser() { 
    
    User u = new User();

    u.setUsername("%王%");

    u.setAddress("%顺义%");

  //执行操作

   List<User> users = userDao.findByUser(u);

    for(User user : users) {

    System.out.println(user);

    }
}

3.2.动态 SQL 之<where>标签

为了简化上面 where 1=1 的条件拼装，我们可以采用<where>标签来简化开发。

3.2.1.持久层 Dao 映射配置

<!-- 根据用户信息查询 -->

<select id="findByUser" resultType="user" parameterType="user">   

     <include refid="defaultSql"></include>   

     <where> 

   <if test="username!=null and username != '' ">  
   
       and username like #{username}   
 
         </if> 

   <if test="address != null">    
 
       and address like #{address}    

         </if>   

     </where>  

</select>

3.3.动态标签之<foreach>标签

3.3.1.实体类编写

public class QueryVo implements Serializable {

   private List<Integer> ids；

   public List<Integer> getIds() {

   return ids;

}

public void setIds(List<Integer> ids) {

  this.ids = ids;

  }

}

3.3.2.持久层 Dao 接口

List<User> findInIds(QueryVo vo);

3.3.3.持久层 Dao 映射配置

<!-- 查询所有用户在 id 的集合之中 --> 

<select id="findInIds" resultType="user" parameterType="queryvo"> 

<!-- select * from user where id in (1,2,3,4,5); --> 

    <include refid="defaultSql"></include> 

       <where>

          <if test="ids != null and ids.size() > 0"> 

          <foreach collection="ids" open="id in ( " close=")" item="uid" separator=","> #{uid} 

          </foreach> 

          </if> 

        </where> 

</select>

<foreach>标签用于遍历集合，它的属性：

collection:代表要遍历的集合元素，注意编写时不要写#{}

open:代表语句的开始部分

close:代表结束部分

item:代表遍历集合的每个元素，生成的变量名

sperator:代表分隔符

3.3.4.编写测试方法

@Test

public void testFindInIds() {

    QueryVo vo = new QueryVo();

    List<Integer> ids = new ArrayList<Integer>();

    ids.add(41);

    ids.add(42);

    ids.add(43);

    ids.add(46);

    ids.add(57);

    vo.setIds(ids); 

   //执行操作

   List<User> users = userDao.findInIds(vo);

   for(User user : users) {

      System.out.println(user);

   }
}

4.Mybatis 中简化编写的 SQL 片段

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的。

4.1定义代码片段

<!-- 抽取重复的语句代码片段 --> 
<sql id="defaultSql"> 
    select * from user 
</sql>

4.2.引用代码片段

<!-- 配置查询所有操作 -->

<select id="findAll" resultType="user"> 

    <include refid="defaultSql"></include> 

</select> 

<!-- 根据 id 查询 -->

<select id="findById" resultType="UsEr" parameterType="int">

    <include refid="defaultSql"></include>
 
      where id = #{uid} 

</select>

5.mybatis的多表查询

表之间的关系严格来说有四种：一对多、多对一、一对一、多对多

举例：

用户和订单就是一对多

订单和用户就是多对一

一个用户可以下多个订单

多个订单属于同一个用户

人和身份证号就是一对一

一个人只能拥有一个省份证号

一个身份证号只能属于一个人

老师和学生就是多对多

一个学生可以被多个老师教过

一个老师可以教多个学生

特例：

如果拿出每一个订单，他都只能属于一个用户

所以mybatis就把多对一看成了一对一

一对多、多对一实例：用户和账户

一个用户可以有多个账户

一个账户只能属于一个用户（多个账户也可以属于同一个用户）

步骤：

建立两张表，用户表，账户表

让用户表和账户表之间具备一对一的关系：需要使用外键，在账户表中添加

建立两个实体类：用户实体类和账户实体类

让用户和账户的实体类也能体现出一对多的关系

3.建立两个配置文件

用户的配置文件和账户的配置文件

4.实现配置

当查询用户时，可以同时得到用户下所包含的账户信息

当查询账户时，可以同时得到账户的所属用户信息

多对多示例：用户和角色

一个用户可以有多个角色

一个角色可以赋予多个用户

步骤：

建立两张表，用户表，角色表

让用户表和角色表之间具备多对多的关系：需要使用中间表，中间表中包含各自的主键，在中间表是外键

建立两个实体类：用户实体类和账户实体类

让用户和角色的实体类也能体现出多对多的关系

各自包含对方一个集合引用

3.建立两个配置文件

用户的配置文件和角色的配置文件

4.实现配置

当查询用户时，可以同时得到用户下所包含的角色信息

当查询角色时，可以同时得到角色的所赋予用户信息

5.1.Mybatis 多表查询之多对一（一对一）

5.1.1.

需求： 查询所有账户信息，关联查询下单用户信息。

注意：因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。

如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

5.1.2.方式一：

5.1.2.1.账户信息的实体类

public class Account implements Serializable {

     private Integer id;

     private Integer uid;

     private Double money;

     public Integer getId() {

        return id;    } 

      public void setId(Integer id) {

        his.id = id;   }

      public Integer getUid() {

       return uid;

       } 

       public void setUid(Integer uid) {

         this.uid = uid;

       }

       public Double getMoney() {

          return money;

       }

       public void setMoney(Double money) {

           this.money = money;

         }

@Override
 public String toString() {

        return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";

   }

}

5.1.2.2.编写 Sql 语句

实现查询账户信息时，也要查询账户所对应的用户信息。

SELECT 

     account.*, 

     user.username, 

     user.address 

FROM 

     account, 

     user 

WHERE account.uid = user.id

5.1.2.3.定义 AccountUser 类

为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信息，所以我们要在定义 AccountUser 类时可以继承 User 类。

public class AccountUser extends Account implements Serializable { 
   private String username;

   private String address;

   public String getUsername() {

   return username;

}

    public void setUsername(String username) {

        this.username = username;

      }

     public String getAddress() {

         return address;

      }
      
       public void setAddress(String address) {

          this.address = address;

}

@Override

public String toString() {

return super.toString() + " AccountUser [username=" + username + ", address=" + address + "]";

      }

}

5.1.2.4.定义账户的持久层 Dao 接口

public interface IAccountDao {

    List<AccountUser> findAll();

}

5.1.2.5.定义配置文件AccountDao.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">

<mapper namespace="com.itheima.dao.IAccountDao">

         <!-- 配置查询所有操作--> 
         <select id="findAll" resultType="accountuser"> 

                select a.*,u.username,u.address from account a,user u where a.uid =u.id; 

          </select>
</mapper>

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型 returnType 的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

5.1.2.6.创建 AccountTest 测试类

@Test

public void testFindAll() {

// 执行操作

List<AccountUser> accountusers = accountDao.findAll(); 

for(AccountUser au : accountusers) {

   System.out.println(au);

}

5.1.2.7.小结：

定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。此方法较为简单，企业中使用普遍。

5.1.3.方法二

使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。

通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的

5.1.3.1修改 Account 类

在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

public class Account implements Serializable {

       private Integer id;

       private Integer uid;

       private Double money;

       private User user; //从表实体应该包含一个主表实体的对象引用

        public User getUser() {

         return user;

         }

        public void setUser(User user) {

           this.user = user;

        }

        public Integer getId() {

           return id;

         }

         public void setId(Integer id) {

             this.id = id;

         }

          public Integer getUid() {

            return uid;

          }

           public void setUid(Integer uid) {

                this.uid = uid;

          }

           public Double getMoney() {

                return money;

            }

            public void setMoney(Double money) {

                   this.money = money;

             }

@Override

public String toString() {

return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";

    }

}

5.1.3.2.修改 AccountDao 接口中的方法

public interface IAccountDao {

 /**

查询所有账户，同时获取账户的所属用户名称以及它的地址信息 * @return

*/

List<Account> findAll(); 
}

注意：第二种方式，将返回值改为了 Account 类型。因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息。

5.1.3.3.重新定义 AccountDao.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"> 

<mapper namespace="com.itheima.dao.IAccountDao">

            <!-- 建立对应关系 --> 

            <resultMap type="account" id="accountMap"> 

                   <id column="aid" property="id"/> 
     
                   <result column="uid" property="uid"/>

                   <result column="money" property="money"/>

                   <!-- 它是用于指定从表方的引用实体属性的 --> 

                   <association property="user" javaType="user">

                         <id column="id" property="id"/> 

                         <result column="username" property="username"/> 

                         <result column="sex" property="sex"/> 

                          <result column="birthday" property="birthday"/>

                          <result column="address" property="address"/> 

                 </association>

         </resultMap>

         <select id="findAll" resultMap="accountMap">   
              
               select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;  

          </select>
 </mapper>

5.1.3.4.在 AccountTest 类中加入测试方法

@Test

public void testFindAll() {

List<Account> accounts = accountDao.findAll();

for(Account au : accounts) {

   System.out.println(au);

   System.out.println(au.getUser());

    }

}

5.2.多表查询之一对多查询

5.2.1.

需求：查询所有用户信息及用户关联的账户信息。

分析：用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。

5.2.2.编写 SQL 语句

SELECT
     u.*, acc.id id, 
     acc.uid, 
          acc.money 
FROM 
    user u 
LEFT JOIN account acc ON u.id = acc.uid

5.2.3.User 类加入 List<Account>

public class User implements Serializable {

       private Integer id;

       private String username;

       private Date birthday;

       private String sex;

       private String address;

//一对多关系映射：主表实体应该包含从表实体的集合引用

        private List<Account> accounts; 
        
        public List<Account> getAccounts() {

                  return accounts;

          }

          public void setAccounts(List<Account> accounts) {

                  this.accounts = accounts;

             }

           public Integer getId() {

                     return id;
 
            }

            public void setId(Integer id) {

                 this.id = id;

              }

            public String getUsername() {

                   return username;

                  }

           public void setUsername(String username) {
 
                      this.username = username;

              }

           public Date getBirthday() {

               return birthday;

           } 

           public void setBirthday(Date birthday) {

                   this.birthday = birthday;

            }

            public String getSex() {

                    return sex;

             }

            public void setSex(String sex) {

                  this.sex = sex;

               }

             public String getAddress() {

               return address;

               } 

             public void setAddress(String address) {

                         this.address = address;
 
              }

@Override

 public String toString() {

return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address=" + address + "]";
       }

 }

5.2.4.用户持久层 Dao 接口中加入查询方法

/**

查询所有用户，同时获取出每个用户下的所有账户信息
 
* @return 

*/
 
List<User> findAll();

5.2.5.用户持久层 Dao 映射文件配置

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

        <resultMap type="user" id="userMap">

                <id column="id" property="id"></id>

                 <result column="username" property="username"/>

                  <result column="address" property="address"/>

                  <result column="sex" property="sex"/>

                   <result column="birthday" property="birthday"/>

                <!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型 --> 

                   <collection property="accounts" ofType="account"> 

                     <id column="aid" property="id"/> 

                     <result column="uid" property="uid"/> 

                     <result column="money" property="money"/>

                        </collection> 

                   </resultMap>

                <!-- 配置查询所有操作 --> 

                  <select id="findAll" resultMap="userMap">

                       select u.*,a.id as aid ,a.uid,a.money from user u left outer join account a on u.id =a.uid 

                   </select> 
       </mapper>

collection：

部分定义了用户关联的账户信息。表示关联查询结果集

property="accList" ：

关联查询的结果集存储在 User 对象的上哪个属性。

ofType="account" ：

指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

5.2.6.测试方法

@Test

public void testFindAll() {

//执行操作

  List<User> users = userDao.findAll();

  for(User user : users) {

    System.out.println("-------每个用户的内容---------"); 
    System.out.println(user);

    System.out.println(user.getAccounts());

  }

}

5.3.Mybatis 多表查询之多对多

通过前面的学习，我们使用 Mybatis 实现一对多关系的维护。多对多关系其实我们看成是双向的一对多关系。

5.3.1.实现 Role 到 User 多对多

5.3.1.1.

需求：实现查询所有对象并且加载它所分配的用户信息。

分析：查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

下面是实现的 SQL 语句：

SELECT 
     r.*,u.id uid, 
     u.username username, 
     u.birthday birthday,
     u.sex sex, 
     u.address address 
FROM 
     ROLE r 
INNER JOIN 
     USER_ROLE ur 
ON ( r.id = ur.rid) 
INNER JOIN 
     USER u 
ON (ur.uid = u.id);

5.3.1.2.编写角色实体类

public class Role implements Serializable { 
     private Integer roleId;    
     private String roleName; 
     private String roleDesc; 
     //多对多的关系映射：一个角色可以赋予多个用户     
    private List<User> users; 
 
    public List<User> getUsers() {
         return users;     } 
 
    public void setUsers(List<User> users) {
         this.users = users;     } 
 
    public Integer getRoleId() {
         return roleId;     } 
 
    public void setRoleId(Integer roleId) {
         this.roleId = roleId;     } 
 
    public String getRoleName() {
         return roleName;     } 
 
    public void setRoleName(String roleName) {
         this.roleName = roleName;     } 
 
    public String getRoleDesc() {
         return roleDesc;     } 
 
    public void setRoleDesc(String roleDesc) {
         this.roleDesc = roleDesc;     } 
 
    @Override     public String toString() {
         return "Role{"+" roleId=" + roleId +", roleName='" + roleName + '\'' +", roleDesc='" + roleDesc + '\'' +'}'; 
              }
}

5.3.1.3.编写 Role 持久层接口

public interface IRoleDao { 
/** 
 * 查询所有角色    
 * @return      
 */     
 List<Role> findAll(); 
 }

5.3.1.4.编写映射文件

<?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.itheima.dao.IRoleDao"> 
      <!--定义 role 表的 ResultMap-->     
      <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 column="id" property="id"></id>             
          <result column="username" property="username"></result>            
          <result column="address" property="address"></result>             
          <result column="sex" property="sex"></result>             
          <result column="birthday" property="birthday"></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> 
  </mapper>

5.3.1.5.编写测试类

@Test

public void testFindAll(){

List<Role> roles = roleDao.findAll();

for(Role role : roles){

System.out.println("---每个角色的信息----");

System.out.println(role);

System.out.println(role.getUsers()); 
       } 
    } 
}

5.3.2.实现 User 到 Role 的多对多

从 User 出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样我们就可以认为 User 与 Role 的多对多关系，可以被拆解成两个一对多关系来实现。

posted @ 2019-12-04 16:38 一个名阅读(173) 评论(0) 编辑收藏举报

刷新页面返回顶部

咸鱼落成