Mybatis学习笔记02

Mybatis 开发流程图

基于代理DAO实现CRUD操作（使用xml配置）

使用要求：

持久层接口和持久层接口的映射配置必须在相同的包下

持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名

SQL 语句的配置标签 <select>, <insert>, <delete>, <update> 的 id 属性必须和持久层接口的方法名相同。

1. 持久层接口中的方法

com\conv\dao\IUserDao.java

package com.conv.dao;

import com.conv.domain.User;

import java.util.List;

public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();

    /**
     * 保存用户
     * @param user
     */
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

    /**
     *  根据id删除用户
     * @param id
     */
    void deleteUser(Integer id);

    /**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();
}

2. 用户映射配置文件中的配置

com\conv\dao\IUserDao.xml

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace是Dao的全限定类名-->
<mapper namespace="com.conv.dao.IUserDao">
    <!--配置查询所有-->
    <!--id是dao的方法名称，不能随便写-->
    <select id="findAll" resultType="com.conv.domain.User">
        select * from user;
    </select>

    <!--保存用户-->
    <!--新增用户后，同时还要返回当前新增用户的 id 值，因为 id 是由数据库的自动增长来实现的，所以就相 当于我们要在新增后将自动增长 auto_increment 的值返回-->
    <insert id="saveUser" parameterType="com.conv.domain.User">
        <!-- 配置插入操作后，获取插入数据的id -->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username, birthday, sex, address) values (#{username},#{birthday},#{sex},#{address});
    </insert>

    <!--更新用户-->
    <update id="updateUser" parameterType="com.conv.domain.User">
        update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id = #{id};
    </update>

    <!--删除用户-->
    <!--parameterType可以写Integer、INT、java.lang.Integer（不区分大小写）-->
    <delete id="deleteUser" parameterType="Integer">
        delete from user where  id = #{uid}
    </delete>

    <!--根据id查询用户-->
    <select id="findById" parameterType="Int" resultType="com.conv.domain.User">
        select * from user where id = #{uid}
    </select>

    <!--根据名称模糊查询用户信息-->
    <select id="findByName" parameterType="string" resultType="com.conv.domain.User">
        <!-- 常用  -->
        <!--select * from user where username like #{uname}-->

        <!--  不常用，会造成Sql注入 -->
        select * from user where username like '%${value}%';
    </select>
    
    <!--查询总用户数-->
    <select id="findTotal" resultType="int">
        select count(id) from user ;
    </select>

</mapper>

细节：
1. resultType 属性
  
  用于指定结果集的类型
2. parameterType 属性
  
  用于指定传入参数的类型，
  
  若传入的是基本类型：我们可以直接写类型名称，也可以使用包名 . 类名的方式，如 Integer 类型，可以写Integer、INT、java.lang.Integer等，不区分大小写
  
  若传入的是实体类类型，目前我们只能使用全限定类名。
  
  究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，而我们的是实体类并没有注册别名，所以必须写全限定类名
3. sql 语句中使用#{}字符
  
  它代表占位符，相当于原来 jdbc 部分所学的 ?，都是用于执行语句时替换实际的数据。
  
  具体的数据是由 #{} 里面的内容决定的。
4. #{} 中内容的写法
  根据数据类型的不同，写法也有所不同，当保存方法的参数的数据类型是：
  1. 基本类型：此处可以随意写
  2. User 对象：此处要写 User 对象中的属性名称。它用的是 ognl 表达式。
  ognl 表达式：
  
  它是 apache 提供的一种表达式语言，全称是：Object Graphic Navigation Language 对象图导航语言它是按照一定的语法格式来获取数据的。
  
  语法格式就是使用 #{对象.对象} 的方式
  
  比如：我们获取用户的名称：
  - 类中的写法：user.getUsername()
  - ONGL表达式的写法：user.username
  #{user.username} 它会先去找 user 对象，然后在 user 对象中找到 username 属性，并调用 getUsername()方法把值取出来。
  
  mybatis 中为什么能直接写 username，而不是 user. 呢？
  
  但是我们在 parameterType 属性上指定了实体类名称，所以可以省略 user. 而直接写 username。

3. 添加测试类中的测试方法

com\conv\test\MybatisTest.java

package com.conv.test;

public class MybatisTest {
    private InputStream in;
    private SqlSession session;
    IUserDao userDao;

    @Before //用于在测试方法执行之前执行
    public void init() throws IOException {
        //1. 读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2. 获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3. 获取SqlSession对象
        session = factory.openSession();
        //4. 获取dao的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After  //用于在测试方法执行之后执行
    public void destroy() throws IOException {
        // 提交事务
        // 若没有此句，打开 Mysql 数据库发现并没有修改任何记录，原因是什么？ 
        // 这一点和 jdbc 是一样的，我们在实现增删改时一定要去控制事务的提交
        // 可以使用: session.commit();来实现事务提交
        session.commit();
        // 关闭资源
        session.close();
        in.close();
    }

    /**
       * 测试查询所有
       *
       * @throws IOException
       */
    @Test
    @Ignore
    public void testFinfAll() throws IOException {
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
       * 测试新增用户
       */
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("saveuser");
        user.setAddress("湖北武汉");
        user.setSex("男");
        user.setBirthday(new Date());

        //执行保存方法
        System.out.println("保存之前：" + user);
        userDao.saveUser(user);
        System.out.println("保存之后：" + user);
    }

    /**
       * 测试更新操作
       */
    @Test
    @Ignore
    public void testUpdate() {
        User user = new User();
        user.setId(51);
        user.setUsername("testUpdate");
        user.setAddress("北京市顺义区");
        user.setSex("女");
        user.setBirthday(new Date());

        //执行更新方法
        userDao.updateUser(user);
    }

    /**
       * 测试删除操作
       */
    @Test
    @Ignore
    public void testDelete() {
        //执行更新方法
        userDao.deleteUser(71);
    }

    /**
       * 测试查询操作
       */
    @Test
    @Ignore
    public void testFindOne() {
        //执行方法
        User user = userDao.findById(51);
        System.out.println(user);
    }

    /**
       * 测试模糊查询操作
       */
    @Test
    @Ignore
    public void testFindByName() {
        //执行方法
        //        List<User> users = userDao.findByName("%小%");
        List<User> users = userDao.findByName("小");
        users.forEach(System.out::println);
    }

    /**
       * 测试查询总记录条数
       */
    @Test
    @Ignore
    public void testFindTotal() {
        //执行方法
        int count = userDao.findTotal();
        System.out.println(count);
    }

}

注意

和 JDBC 一样，我们在实现增删改时一定要去控制事务的提交

在 mybatis 中可以使用 session.commit(); 来实现事务提交

模糊查询的两种方法

<!--根据名称模糊查询用户信息-->
<select id="findByName" parameterType="string" resultType="com.conv.domain.User">
    <!-- 常用  -->
    select * from user where username like #{uname};

    <!--  不常用，会造成Sql注入 -->
    <!--select * from user where username like '%${value}%';-->
</select>

结论

这两种方式的实现效果是一样的，但执行的语句是不一样的。

select * from user where username like #{uname};`

对应的查询方法需要加上%：

List<User> users = userDao.findByName("%小%");

在控制台输出的执行 SQL 语句如下：

Preparing: select * from user where username like ?
Parameters: %小%(String)

使用的是 Preparedstatement，不会造成 SQL 注入问题
select * from user where username like '%${value}%';

对应的方法无需加%：

List<User> users = userDao.findByName("小");

在控制台输出的执行 SQL 语句如下：

Preparing: select * from user where username like ‘%小%’;

Parameters:

即直接拼接 SQL，容易造成 SQL 注入问题
如图：

`#{}` 与 `${}` 的区别

#{} 表示一个占位符号

通过 #{} 可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换， #{}可以有效防止 sql 注入。 #{} 可以接收简单类型值或 pojo 属性值。如果 parameterType 传输单个简单类型值，#{} 括号中可以是 value 或其它名称。

${} 表示拼接 sql 串

通过 ${} 可以将 parameterType 传入的内容拼接在 sql中且不进行 jdbc 类型转换， ${}可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，**${} 括号中只能是 value**（源码中指定了读取的 key 的名字就是 value，所以我们在绑定参数时就只能叫 value 的名字）

Mybatis 与 JDBC 编程的比较

数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。解决：

在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。
Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。

解决：

将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。
向 Sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应。解决：

Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的类型。
对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对象解析比较方便。

解决：

Mybatis自动将 sql执行结果映射至 java 对象，通过statement中的resultType 定义输出结果的类型。

Mybatis 的参数深入

使用说明

SQL 语句传参，使用标签的 parameterType 属性来设定。

该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）；

同时也可以使用实体类的包装类，本章节将介绍如何使用实体类的包装类作为参数传递。

注意事项

基本类型和 String 我们可以直接写类型名称，也可以使用包名 . 类名的方式，例如：java.lang.String

实体类类型，目前我们只能使用全限定类名。

究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，而我们的是实体类并没有注册别名，所以必须写全限定类名

传递 pojo 包装对象

开发中通过 pojo 传递查询条件，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中。

QueryVo.java

package com.conv.domain;

public class QueryVo {
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

持久层接口 IUserDao.java

/**
* 根据 queryVo 中的条件查询用户
* @param vo
* @return
*/
List<User> findUserByVo(QueryVo vo);

持久层接口的映射文件 com\conv\dao\IUserDao.xml

<!--根据 queryVo 中的条件查询用户-->
<select id="findUserByVo" parameterType="com.conv.domain.QueryVo" resultType="com.conv.domain.User">
    select * from user where username like #{user.username};
</select>

测试包装类作为参数

/**
* 测试使用QureyVo作为查询条件
*/
@Test
public void testFindByVo() {
    //执行方法
    QueryVo vo = new QueryVo();
    User user = new User();
    user.setUsername("%王%");
    vo.setUser(user);

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

    users.forEach(System.out::println);
}

数据库列名和 pojo 中的属性名不一致的情况

假设数据库中的列名为：

id, username, birthday, sex, address

pojo 中的属性名为：

userId, userName, userBirthday, userSex, userAddress

1. 使用别名查询

<!-- 配置查询所有操作 --> 
<select id="findAll" resultType="com.itheima.domain.User">
    select id as userId, username as userName, birthday as userBirthday, sex as userSex, address as userAddress from user
</select>

2. 使用 resultMap

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。

在 select 标签中使用 resultMap 属性指定引用即可。

同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

<!-- 建立 User 实体和数据库表的对应关系
type 属性：指定实体类的全限定类名  
id 属性：给定一个唯一标识，是给查询 select 标签引用用的。
-->
<resultMap type="com.itheima.domain.User" id="userMap">
    <id column="id" property="userId"/>
    <result column="username" property="userName"/>
    <result column="sex" property="userSex"/>
    <result column="address" property="userAddress"/>
    <result column="birthday" property="userBirthday"/>
</resultMap> 
<!--
id 标签：用于指定主键字段 
result 标签：用于指定非主键字段 
column 属性：用于指定数据库列名 
property 属性：用于指定实体类属性名称
-->

映射配置

<!-- 配置查询所有操作 -->
<!-- resultyMap 属性是上面的 id 属性的值 -->
<select id="findAll" resultMap="userMap">
    select * from user
</select>

测试结果

/**
     * 测试查询所有
     *
     * @throws IOException
     */
@Test
public void testFinfAll() {
    List<User> users = userDao.findAll();
    for (User user : users) {
        System.out.println(user);
    }
}

SqlMapConfig.xml 配置文件

properties（属性）

在使用 properties 标签配置时，我们可以采用两种方式指定属性配置。

在标签内部配置连接数据库的信息

<configuration>
    <properties>
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/learn?serverTimezone=GMT%2B8&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="4869"/>
    </properties>


    <!--配置环境-->
    <environments default="mysql">
        <!--配置myslq的环境-->
        <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>
    
</configuration>

通过属性引用外部配置文件信息

在 resources下定义 jdbcConfig.properties 文件

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/learn?serverTimezone=GMT%2B8
username=root
password=4869

properties 标签配置

<!--配置连接数据库的信息
    resource 属性：用于指定 properties 配置文件的位置，要求配置文件必须在类路径下
-->
<properties resource="jdbcConfig.properties"/>

或：

<!--配置连接数据库的信息
    url 属性：
        URL：Uniform Resource Locator 统一资源定位符
            是按照 URL 的写法来写地址（协议 主机 端口 URI）
        URI：Uniform Resource Identifier 统一资源标识符
            它是在应用中可以唯一定位一个资源的位置
        它是可以在 web 应用中唯一定位一个资源的路径
-->
<properties url="file:///E:/MySpace/IntelliJ IDEA/Mybatis_02/src/main/resources/jdbcConfig.properties"/>

typeAliases（类型别名）

typeAlias 单个别名自定义

<!--  使用 typeAliases 配置别名，它只能配置 domain 中类的别名 -->
<typeAliases>
    <!-- typeAlias 用于配置别名，type 属性指定的是实体类全限定类名，alias 属性指定别名，当指定了别名就不再区分大小写 -->
    <typeAlias type="com.conv.domain.User" alias="user"/>
</typeAliases>

package 批量别名自定义

1 2	<!-- 用于指定要配置别名的包，当指定后，该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写 --> <package name="com.conv.domain"/>

mappers（映射器）

<mapper resource=" " />

1 2	<!--使用相对于类路径的资源--> <mapper resource="com/conv/dao/IUserDao.xml"/>

<mapper class=" " />

注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中

1 2	<!--使用 mapper 接口类路径--> <mapper class="com.conv.dao.IUserDao"/>

<package name=""/>