2.Mybatis-02 基于代理 Dao 实现 CRUD 操作

2021-02-19 本文已影响0人 AlexDing

主要内容

基于代理 Dao 实现 CRUD 操作
Mybatis 的结果封装
SqlMapConfig.xml配置文件

1、持久层接口和持久层接口的映射配置必须在相同的包下
2、持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名
3、 SQL 语句的配置标签<select>,<insert>,<delete>,<update>的 id 属性必须和持久层接口的方法名相同。

1 根据 ID 查询

1.1 在持久层IUserDao接口中添加 findById 方法

User findById(Integer userId);

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

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

细节：

resultType 属性：用于指定结果集的类型。
parameterType 属性：用于指定传入参数的类型。
sql 语句中使用#{}字符：它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。具体的数据是由#{}里面的内容决定的。
#{}中内容的写法：由于数据类型是基本类型，所以此处可以随意写。

1.3 在测试类添加测试

@Test
    public void test2() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行查询方法
        User user = iuserDao.findById(41);
        System.out.println(user);
        //7.释放资源
        session.close();
        inputStream.close();
    }

2 保存操作

2.1 在持久层IUserDao接口中添加新增方法

int saveUser(User user);

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

<!-- 保存用户-->
    <insert id="saveUser" parameterType="com.ding.domain.User">
        insert into user(username,birthday,sex,address)
        values(#{username},#{birthday},#{sex},#{address})
    </insert>

细节：

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

2.3 添加测试类中的测试方法

@Test
    public void test3() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行保存方法
        User user = new User();
        user.setUsername("modify User property");
        user.setAddress("北京市顺义区");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存操作之前： "+user);
        iuserDao.saveUser(user);
        System.out.println("保存操作之后： "+user);
        //6.1提交事务
        session.commit();
        //7.释放资源
        session.close();
        inputStream.close();
    }

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

2.4 问题扩展：新增用户 id 的返回值

新增用户后，同时还要返回当前新增用户的 id 值，因为 id 是由数据库的自动增长来实现的，所以就相
当于我们要在新增后将自动增长 auto_increment 的值返回。

    <!-- 保存用户-->
    <insert id="saveUser" parameterType="com.ding.domain.User">
        <!-- 配置保存时获取插入的 id -->
        <selectKey keyColumn="id" keyProperty="id" resultType="int">
            select last_insert_id();
        </selectKey>
        insert into user(username,birthday,sex,address)
        values(#{username},#{birthday},#{sex},#{address})
    </insert>

2.3 用户更新

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

int updateUser(User user);

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

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

2.3.3 加入更新的测试方法

@Test
    public void test4() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行保存方法
        //1.根据 id 查询
        User user = iuserDao.findById(43);
        //2.更新操作
        user.setAddress("北京市顺义区");
        int res = iuserDao.updateUser(user);
        System.out.println(res);
        //6.1提交事务
        session.commit();
        //7.释放资源
        session.close();
        inputStream.close();
    }

2.4 用户删除

2.4.1 在持久层IUserDao接口中添加删除方法

int deleteUser(Integer userId);

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

<!-- 删除用户 -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{uid}
    </delete>

2.4.3 加入删除的测试方法

 @Test
    public void test5() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行保存方法
        int res = iuserDao.deleteUser(51);
        System.out.println(res);
        //6.1提交事务
        session.commit();
        //7.释放资源
        session.close();
        inputStream.close();
    }

2.5 用户模糊查询

2.5.1 在持久层IUserDao接口中添加模糊查询方法

List<User> findByName(String username);

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

<!-- 根据名称模糊查询 -->
    <select id="findByName" resultType="com.ding.domain.User" parameterType="String">
        select * from user where username like #{username}
    </select>

2.5.3 加入模糊查询的测试方法

@Test
    public void test6() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行保存方法
        List<User> users = iuserDao.findByName("%王%");
        for(User user : users){
            System.out.println(user);
        }
        //6.1提交事务
        session.commit();
        //7.释放资源
        session.close();
        inputStream.close();
    }

2.6 查询使用聚合函数

2.6.1 在持久层IUserDao接口中添加模糊查询方法

int findTotal();

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

<!-- 查询总记录条数 -->
    <select id="findTotal" resultType="int">
        select count(*) from user;
    </select>

2.6.3 加入聚合查询的测试方法

@Test
    public void test7() throws Exception {
        //1.读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建 SqlSessionFactory 的构建者对象
        SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
        //3.使用构建者创建工厂对象 SqlSessionFactory
        SqlSessionFactory factory = factoryBuilder.build(inputStream);
        //4.使用 SqlSessionFactory 生产 SqlSession 对象
        SqlSession session = factory.openSession();
        //5.使用 SqlSession 创建 dao 接口的代理对象
        IUserDao iuserDao = session.getMapper(IUserDao.class);
        //6.使用代理对象执行方法
        int res = iuserDao.findTotal();
        System.out.println(res);
        //6.1提交事务
        session.commit();
        //7.释放资源
        session.close();
        inputStream.close();
    }

2.7 Mybatis 与 JDBC 编程的比较

1.数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
解决：在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。
2.Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大， sql 变动需要改变 java 代码。
解决：将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。
3.向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应。
解决：Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的
类型。
4.对结果集解析麻烦， sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对象解析比较方便。
解决：Mybatis 自动将 sql 执行结果映射至 java 对象，通过 statement 中的 resultType 定义输出结果的
类型。

3.0 Mybatis 的结果封装

1.0 实体类属性和数据库表的列名不一致

实体类属性

private Integer userId;
private String userName;
private Date userBirthday;
private String userSex;
private String userAddress;

修改映射配置

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

2.0 resultMap 结果类型

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。
在 select 标签中使用 resultMap 属性指定引用即可。

2.1 定义 resultMap

<!-- 建立 User 实体和数据库表的对应关系
        type 属性：指定实体类的全限定类名
        id 属性：给定一个唯一标识，是给查询 select 标签引用用的。
     -->
    <resultMap type="com.ding.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 属性：用于指定实体类属性名称

2.2 映射配置

<!-- 配置查询所有操作 -->
<select id="findAll" resultMap="userMap">
    select * from user
</select>

4.0 SqlMapConfig.xml配置文件

1 配置内容

1.1 SqlMapConfig.xml 中配置的内容和顺序

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

2 properties（属性）

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

2.1 第一种

<properties>
        <property name="jdbc.driver" value="com.mysql.jdbc.Driver"/>
        <property name="jdbc.url" value="jdbc:mysql://localhost:3306/test"/>
        <property name="jdbc.username" value="root"/>
        <property name="jdbc.password" value="root"/>
    </properties>

2.2 第二种

2.2.1 在 classpath 下定义 db.properties 文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password= root

2.2.2 properties 标签配置

<!-- 配置连接数据库的信息
        resource 属性：用于指定 properties 配置文件的位置，要求配置文件必须在类路径下
        resource="jdbcConfig.properties"
        url 属性：
        URL： Uniform Resource Locator 统一资源定位符
        http://localhost:8080/mystroe/CategoryServlet URL
        协议 主机 端口 URI
        URI： Uniform Resource Identifier 统一资源标识符
        /mystroe/CategoryServlet
        它是可以在 web 应用中唯一定位一个资源的路径
     -->
    <properties url=file:///D:/IdeaProjects/day02_eesy_01mybatisCRUD/src/main/resources/jdbcConfig.properties">
    </properties>

2.3 此时我们的 dataSource 标签就变成了引用上面的配置

<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>

3 typeAliases（类型别名）

在前面我们讲的 Mybatis 支持的默认别名，我们也可以采用自定义别名方式来开发。

3.1 自定义别名：

在 SqlMapConfig.xml 中配置：

<typeAliases>
<!-- 单个别名定义 -->
<typeAlias alias="user" type="com.ding.domain.User"/>
<!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->
<package name="com.ding.domain"/>
<package name="其它包"/>
</typeAliases>

4 mappers（映射器）

4.1 <mapper resource=" " />

使用相对于类路径的资源
如： <mapper resource="com/ding/dao/IUserDao.xml" />

4.2 <mapper class=" " />

使用 mapper 接口类路径
如： <mapper class="com.ding.dao.UserDao"/>

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

4.3 <package name=""/>

注册指定包下的所有 mapper 接口
如： <package name="cn.ding.mybatis.mapper"/>