（8）Mybatis————基于代理DAO 实现CRUD操作和配置详解

灰太狼 2023-02-19 03:29 47阅读 0赞

1， 基于代理 Dao 实现 CRUD 操作

*  1.1，保存操作并获取主键 id
 *  1.2，更新操作
 *  1.3，删除操作
 *  1.4，查询操作
 *  1.5，\#\{\} 与 $\{\} 的区别
 *  1.6，Mybatis 与 JDBC 编程的比较

2， Mybatis 的参数深入

*  2.1，parameterType 配置参数
 *  2.2，传递 pojo 包装对象

3，Mybatis 的输出结果封装

*  3.1，resultType 配置结果类型
 *  3.2，resultMap 结果类型

4，Mybatis 传统 DAO 层开发

5，mybatis-config.xml 配置文件

*  5.1，mybatis-config.xml 中配置的内容和顺序
 *  5.2，properties（属性）
 *  5.3，typeAliases（类型别名）
 *  5.4，mappers （映射器）

> #### 基于代理 Dao 实现 CRUD 操作 ####

1，保存操作并获取主键 id

保存单条数据并获取主键 id

*  在持久层接口中添加新增方法：

/** * 保存用户 * @param user * @return 影响数据库记录行数 */
    int saveUser(User user);

*  在用户的映射配置文件中 配置：

<update id="saveUser" parameterType="com.zhou.entity.User">
        
        <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(id,name,password,address)
        values(#{ id},#{ name},#{ password},#{ address})
    </update>

*  `parameterType` 属性：代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。
 *  sql 语句中使用`#{}`字符：它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。具体的数据是由`#{}`里面的内容决定的。
 *  `#{}`中内容的写法：  
    由于我们保存方法的参数是 一个 User 对象，此处要写 User 对象中的属性名称，它用的是 `ognl` 表达式。
 *  `ognl` 表达式：
    
    它是 `apache` 提供的一种表达式语言，全称是：`Object Graphic Navigation Language` 对象图导航语言它是按照一定的语法格式来获取数据的。语法格式就是使用 `#{对象.对象}`的方式，`#{user.name}`它会先去找 `user` 对象，然后在 `user` 对象中找到 `name` 属性，并调用`getName()`方法把值取出来。但是我们在 `parameterType` 属性上指定了实体类名称，所以可以省略 `user`，而直接写 `name`。
 *  测试类：

private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;
    
    @Before//在测试方法执行之前执行
    public void init() throws IOException { 
        //1.读取配置文件
        in = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }
    
    @After//在测试方法执行完成之后执行
    public void destory() throws IOException { 
        session.commit();
        //6.释放资源
        session.close();
        in.close();
    }
    
    @Test
    public void saveUserTest(){ 
    
        /** * 在实现增删改时一定要去控制事务的提交: session.commit();来实现事务提交 */
        User user = new User(null, "Tommey周", "123123", "北京市海淀区");
        System.out.println("保存前User：" + user);
        int count = userDao.saveUser(user);
        System.out.println("保存前User：" + user +"影响的行数：" + count);
    }

保存多条数据并获取主键 id

*  在持久层接口中添加 批量保存方法

/** * 批量保存用户，返回主键id列表 * @param lists * @return 影响数据库记录行数 */
    int saveUserList(List<User> lists);

*  在用户的映射配置文件中配置

<insert id="saveUserList" useGeneratedKeys="true" keyProperty="id" parameterType="java.util.ArrayList">
        insert into user(id,name,password,address)
        values
        <foreach collection="list" item="user" index="index"  separator=",">
        (
            null,
            #{ user.name, jdbcType=VARCHAR},
            #{ user.password, jdbcType=VARCHAR},
            #{ user.address, jdbcType=VARCHAR}
            )
        </foreach>
    </insert>

*  测试类

@Test
    public void saveUserListTest() { 
        List<User> list = new ArrayList<User>();
        User user1 = new User(null, "Tommey1", "123123", "北京市海淀区");
        list.add(user1);
        User user2 = new User(null, "Tommey2", "123123", "北京市海淀区");
        list.add(user2);
        User user3 = new User(null, "Tommey3", "123123", "北京市海淀区");
        list.add(user3);
        System.out.println("保存前的数据：" + Arrays.asList(list));
        int count = userDao.saveUserList(list);
        System.out.println("保存后的数据：" + Arrays.asList(list) + "影响的行数：" + count);
    }

2，更新操作

单条数据更新

*  在持久层接口中添加更新方法

/** * 根据id查询 * @param userId * @return */
    User queryUserById(Integer userId);
    
    /** * 更新用户 * @param user * @return 影响数据库记录的行数 */
    int updateUserByUser(User user);

*  在用户的映射配置文件中配置

<update id="updateUserByUser" parameterType="com.zhou.entity.User">
        update user set
        <if test="name != null and name.trim!='' ">
            name = #{ name},
        </if>
        <if test="password != null and password.trim!='' ">
            password = #{ password},
        </if>
        <if test="address != null and address.trim!='' ">
            address = #{ address}
        </if>
        where id = #{ id}
    </update>
    
    <select id="queryUserById" resultType="com.zhou.entity.User" parameterType="integer">
        select * from user where id = #{ userId}
    </select>

*  测试类：

@Test
    public void updateUserTest(){ 
    
        /** * 在实现增删改时一定要去控制事务的提交: session.commit();来实现事务提交 */
        User queryUser = userDao.queryUserById(15);
        System.out.println("修改前的User：" + queryUser);
        User user = new User(15, "Tommey", "123123", "修改后");
        int count = userDao.updateUserByUser(user);
        System.out.println("修改后的User：" + user +"影响的行数：" + count);
    }

批量数据更新，注意：需要在db链接url后面带一个参数allowMultiQueries=true

*  `jdbc:mysql://localhost:3306/test?allowMultiQueries=true`，要是没有修改则会报错，报错信息如下：

.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: You have an error in your

*  在持久层接口中添加批量数据更新方法

/** * 批量id查询用户 * @param userId * @return */
    List<User> queryUserByBatchId(List<Integer> userId);
    
    /** * 批量更新用户 * @param userList * @return 影响数据库记录的行数 */
    int updateUserByBatchUser(List<User> userList);

*  在用户的映射配置文件中配置

<select id="queryUserByBatchId" resultType="com.zhou.entity.User">
        select * from user where id in
        <foreach item="id" collection="list" index="index" open="(" separator="," close=")" >
            #{ id}
        </foreach>
    </select>
    
    <update id="updateUserByBatchUser" parameterType="java.util.ArrayList">
        <foreach collection="list" item="item" index="index" open="" close="" separator=";">
            update user
            <set>
                <if test="item.name != null">
                    name = #{ item.name, jdbcType=VARCHAR},
                </if>
                <if test="item.password != null">
                    password = #{ item.password, jdbcType=VARCHAR},
                </if>
                <if test="item.address != null">
                    address = #{ item.address, jdbcType=VARCHAR}
                </if>
            </set>
            where id = #{ item.id, jdbcType=INTEGER}
        </foreach>
    </update>

*  测试类：

@Test
    public void updateBatchUserTest() { 
        List<Integer> idList = new ArrayList<Integer>();
        idList.add(7);
        idList.add(8);
        idList.add(9);
        List<User> userList = userDao.queryUserByBatchId(idList);
        System.out.println("修改前的User：" + userList);
        for (User user: userList) { 
            user.setName("Tommey周"+ user.getId());
        }
        int count = userDao.updateUserByBatchUser(userList);
        System.out.println("修改后的User：" + userList + "影响的行数：" + count);
    }

3，删除操作

*  在持久层接口中添加更新方法：

/** * 根据 id 删除用户 * @param userId * @return */
    int deleteUserByUserId(Integer userId);

*  在用户的映射配置文件中配置

<delete id="deleteUserByUserId" parameterType="java.lang.Integer">
        delete from user where id = #{ userId}
    </delete>

*  测试类：

@Test
    public void deleteUserByUserIdTest(){ 
        int count = userDao.deleteUserByUserId(15);
        System.out.println("影响的行数：" + count);
    }

4，查询操作

模糊查询

*  在持久层接口中添加 模糊查询的方法：

/** * 根据姓名模糊查询 * @param name * @return */
        List<User> queryByLikeName(String name);

*  在用户的映射配置文件中配置（注意：$\{value\}是固定的不可更改）,也可写成 CONCAT(’%’,\#\{name\},’%’)

<select id="queryByLikeName" resultType="com.zhou.entity.User">
        select * from user where name like '%${value}%'
    </select>

*  模糊查询的`${value}` 源码分析
    
     *  在 `TextSqlNode`类源码中指定了读取的 `key` 的名字就是`”value”`，所以我们在绑定参数时就只能叫 `value` 的名字  
        了

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0_size_16_color_FFFFFF_t_70]

使用聚合函数查询

*  在持久层接口中添加 模糊查询的方法：

/** * 查询总记录条数 * @return */
    int queryTotal();

*  在用户的映射配置文件中配置：

<select id="queryTotal" resultType="int">
        select count(*) from user
    </select>

*  测试类：

@Test
    public void queryTotalTest(){ 
        Integer count = userDao.queryTotal();
        System.out.println("总记录数为：" + count);
    }

5，\#\{\} 与 $\{\} 的区别

*  `#{}` 表示一个占位符号
    
     *  通过`#{}`可以实现 `preparedStatement` 向占位符中设置值，自动进行 `java` 类型和 `jdbc` 类型转换，`#{}`可以有效防止 `sql` 注入。 `#{}`可以接收简单类型值或 `pojo` 属性值。 如果 `parameterType` 传输单个简单类型值，`#{}`括号中可以是 `value` 或其它名称。
 *  `${}` 表示拼接 `sql` 串
    
     *  通过`${}`可以将 `parameterType` 传入的内容拼接在 `sql`中且不进行 `jdbc` 类型转换， `${}`可以接收简单类型值或 `pojo` 属性值，如果 `parameterType` 传输单个简单类型值，`${}`括号中只能是 `value`。

6，Mybatis 与 JDBC 编程的比较

①，数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。解决：在 `SqlMapConfig.xml` 中配置数据链接池，使用连接池管理数据库链接。

②，Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。解决：将 Sql 语句配置在 `XXXmapper.xml` 文件中与 java 代码分离。

③，向sql语句传参数麻烦，因为sql语句的where 条件不一定，可能多也可能少，占位符需要和参数对应。解决：Mybatis自动将 java 对象映射至 sql 语句，通过 `statement` 中的 `parameterType` 定义输入参数的类型。

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

> #### Mybatis 的参数深入 ####

1，parameterType 配置参数

*  使用说明：
    
    SQL 语句传参，使用标签的 `parameterType` 属性来设定。该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类。
 *  注意事项：
    
    基本类型和 `String` 我们可以直接写类型名称 ，也可以使用包名 `.` 类名的 方式 ，例如 ：`java.lang.String`。实体类类型，目前我们只能使用全限定类名。究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，而我们的是实体类并没有注册别名，所以必须写全限定类名。
 *  在mybatis 的官方文档的说明，[点击此处查看][Link 1]

<table> 
 <thead> 
  <tr> 
   <th>别名</th> 
   <th>类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>_byte</td> 
   <td>byte</td> 
  </tr> 
  <tr> 
   <td>_long</td> 
   <td>long</td> 
  </tr> 
  <tr> 
   <td>_short</td> 
   <td>short</td> 
  </tr> 
  <tr> 
   <td>_int</td> 
   <td>int</td> 
  </tr> 
  <tr> 
   <td>_integer</td> 
   <td>int</td> 
  </tr> 
  <tr> 
   <td>_double</td> 
   <td>double</td> 
  </tr> 
  <tr> 
   <td>_float</td> 
   <td>float</td> 
  </tr> 
  <tr> 
   <td>_boolean</td> 
   <td>boolean</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>String</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>integer</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
  <tr> 
   <td>date</td> 
   <td>Date</td> 
  </tr> 
  <tr> 
   <td>decimal</td> 
   <td>BigDecimal</td> 
  </tr> 
  <tr> 
   <td>bigdecimal</td> 
   <td>BigDecimal</td> 
  </tr> 
  <tr> 
   <td>object</td> 
   <td>Object</td> 
  </tr> 
  <tr> 
   <td>map</td> 
   <td>Map</td> 
  </tr> 
  <tr> 
   <td>hashmap</td> 
   <td>HashMap</td> 
  </tr> 
  <tr> 
   <td>list</td> 
   <td>List</td> 
  </tr> 
  <tr> 
   <td>arraylist</td> 
   <td>ArrayList</td> 
  </tr> 
  <tr> 
   <td>collection</td> 
   <td>Collection</td> 
  </tr> 
  <tr> 
   <td>iterator</td> 
   <td>Iterator</td> 
  </tr> 
 </tbody> 
</table>

2，传递 pojo 包装对象

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

/** * 查询条件对象 */
    @Data
    @AllArgsConstructor
    @ToString
    public class QueryUser implements Serializable { 
    
        private String key;
        private  User user;
    }

*  编写持久层接口

/** * 根据 QueryUser 中的条件查询用户 */
    List<User> queryByQueryUser(QueryUser queryUser);

*  持久层接口的映射文件

<select id="queryByQueryUser" resultType="com.zhou.entity.User" parameterType="com.zhou.entity.QueryUser">
        select * from user where address = #{ key} and name like concat('%',#{ user.name},'%');
    </select>

*  测试类

@Test
    public void queryByQueryUserTest() { 
        QueryUser queryUser = new QueryUser("北京市海淀区",new User(1,"1","",""));
        List<User> userList = userDao.queryByQueryUser(queryUser);
        userList.stream().forEach(System.out::println);
    }

> #### Mybatis 的输出结果封装 ####

1，resultType 配置结果类型

*  resultType 属性可以指定结果集的类型，它支持基本类型和实体类类型。需要注意的是，它和 parameterType 一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须使用全限定类名。例如：我们的实体类此时必须是全限定类名，同时，当是实体类名称时，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装。
 *  示例代码：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0_size_16_color_FFFFFF_t_70 1]
 *  运行后，发现`uPassword`为空，解决方法 --> 定义`resultMap`标签

2，resultMap 结果类型

*  `resultMap` 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。在 select 标签中使用 `resultMap` 属性指定引用即可。同时 `resultMap` 可以实现将查询结果映射为复杂类型的 `pojo`，比如在查询结果映射对象中包括 `pojo` 和 `list` 实现一对一查询和一对多查询。
 *  定义 resultMap：
    
    `id` 标签：用于指定主键字段  
    `result` 标签：用于指定非主键字段  
    `column` 属性：用于指定数据库列名  
    `property` 属性：用于指定实体类属性名称

<resultMap type="com.zhou.entity.User" id="userMap">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="address" property="uAddress"/>
        <result column="password" property="uPassword"/>
    </resultMap>
    
    <select id="queryUserList" resultMap="userMap">
        SELECT * FROM user
    </select>

> #### Mybatis 传统 DAO 层开发 ####

使用 Mybatis 开发 Dao，通常有两个方法，即原始 Dao开发方式和 Mapper 接口代理开发方式。而现在主流的开发方式是接口代理开发方式，这种方式总体上更加简便。

*  Mybatis 实现 DAO 的传统开发方式
 *  持久层 Dao 接口：

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

*  持久层 Dao 实现类：

@Override
        public List<User> findAll() { 
            //1，使用工厂创建SqlSession对象
            SqlSession openSession = factory.openSession();
            //2，使用session执行查询所有方法
            List<User> users = openSession.selectList("com.zhou.dao.IUserDao.findAll");
            openSession.close();
            return users;
        }

*  持久层映射配置

<select id="findAll" resultType="com.zhou.entity.User">
        select * from user
    </select>

*  测试类

@Test
    public void findAllTest() { 
        List<User> users = userDao.findAll();
        for(User user : users) { 
            System.out.println(user);
        }
    }

> #### mybatis-config.xml 配置文件 ####

1，mybatis-config.xml 中配置的内容和顺序

*  properties （属性）–property
 *  settings（全局配置参数）–setting
 *  typeAliases （类型别名）–typeAliase --package
 *  typeHandlers（类型处理器）
 *  objectFactory（对象工厂）
 *  plugins（插件）
 *  environments（环境集合属性对象）–environment（环境子属性对象）—transactionManager（事务管理）—dataSource（数据源）
 *  mappers （映射器）–mapper --package

2，properties （属性）

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

*  第二种：  
    `classpath` 下定义 `db.properties` 文件

<properties url="file:///D:/ide项目/Test/MybatisDemo/src/main/resources/db.properties">
        
    </properties>
    
    
    <environments default="mysql">
        
        <environment id="mysql">
            
            <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>

3，typeAliases（类型别名）

*  在 mybatis-config.xml 中配置：

<typeAliases>
            
    
            
            <package name="com.zhou.entity"/>
        </typeAliases>

4，mappers （映射器）

*  `<mapper resource=" " />`：使用相对于类路径的资源

*  `<mapper class=" " />`：使用 mapper 接口类路径

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

*  `<package name=""/>`：注册指定包下的所有 mapper 接口

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

--------------------

[下一章，（9）Mybatis————分析dao实现类的执行过程，代理dao的执行过程，常用的标签以及查询语句][9_Mybatis_dao_dao]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200619111041476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0,size_16,color_FFFFFF,t_70
[Link 1]: https://mybatis.org/mybatis-3/zh/configuration.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200623082702834.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTMwMDA0,size_16,color_FFFFFF,t_70
[9_Mybatis_dao_dao]: https://blog.csdn.net/qq_41530004/article/details/106941390