Mybatis框架（4） —— 手动编写持久层实现类实现CRUD操作

其他 2020-02-16 11:26:02 阅读次数: 0

简介

  • MyBatis环境搭建 的方式在前面已经详细的介绍过了，本文仍然通过映射配置文件，但不再使用代理持久层接口实现类的方式，而是使用手动编写持久层实现类的方式来进行MySQL数据库的CRUD操作。
  • 创建持久层接口实现类的方式在实际开发中并不常用，所以我会将本文的主题放在与使用代理持久层实现类方法的比较上。
  • 改变的内容主要是测试类和持久层接口实现类。

目录结构

  • src/main
    • java
      • cn/water/dao
        • impl
          • UserDaoImpl.java（持久层实现类）
        • UserDao.java（持久层接口）
      • cn/water/domain
        • User.java（实体类）
      • resources
        • cn/water/dao
          • UserDao.xml（映射配置文件）
        • SqlMapConfig.xml（MyBatis主配置文件）
  • src/tese
    • java
      • cn/water/test
        • MybatisTest.java（测试文件）

持久层接口

UserDao.java

package cn.water.dao;

import cn.water.domain.User;

import java.util.List;

public interface UserDao {

    /** 添加用户 */
    void add(User user);

    /** 更新用户 */
    void update(User user);

    /** 删除用户 */
    void delete(Integer id);

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

    /** 查询单个用户 */
    User findOne(Integer id);

    /** 根据姓名模糊查询 */
    List<User> findByName01(String name);
    List<User> findByName02(String name);

    /** 查询所有用户的数量 */
    Integer findTotal();

    /** 添加用户 + 返回ID */
    /*Integer addReturnID(User user);*/

    /** 根据QueryVo对象的条件，模糊查询 */
    /*List<User> findByQueryVO(QueryVo queryVo);*/
}

映射配置文件

UserDao.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="cn.water.dao.UserDao">

            <!-- 添加用户 -->
                <!-- 参数类型 JavaBean，占位符 = 成员变量名的小写形式 -->
            <select id="add" parameterType="cn.water.domain.User" >
                INSERT INTO user VALUES ( #{id}, #{username}, #{birthday}, #{sex}, #{address} ) ;
            </select>

            <!-- 更新用户 -->
            <select id="update" parameterType="cn.water.domain.User">
                UPDATE user SET
                    username = #{username},
                    birthday = #{birthday},
                    sex = #{sex},
                    address = #{address}
                WHERE
                    id = #{id} ;
            </select>

            <!-- 删除用户 -->
                <!-- 参数类型 基本类型，占位符 = 方法参数名称 -->
            <select id="delete" parameterType="INT" >
                DELETE FROM user WHERE id = #{id};
            </select>

            <!-- 查询所有 -->
            <select id="findAll" resultType="cn.water.domain.User">
                SELECT * FROM user;
            </select>

            <!-- 查询单个用户 -->
            <select id="findOne" parameterType="INT" resultType="cn.water.domain.User">
                SELECT * FROM user WHERE id = #{id} ;
            </select>

            <!-- 根据姓名模糊查询 -->
            <select id="findByName01" parameterType="java.lang.String" resultType="cn.water.domain.User">
                SELECT * FROM user WHERE username LIKE #{username};
            </select>
            <select id="findByName02" parameterType="java.lang.String" resultType="cn.water.domain.User">
                SELECT * FROM user WHERE username LIKE '%${value}%';
            </select>

            <!-- 查询所有用户的数量 -->
            <select id="findTotal" resultType="INT" >
                SELECT COUNT(*) FROM user;
            </select>


        </mapper>

持久层实现类

UserDaoImp.java

package cn.water.dao;

import cn.water.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.After;

import java.util.List;

public class UserDaoImp implements UserDao {

    /** 私有成员变量 */
    private SqlSessionFactory factory;
    private SqlSession session;

    /** 带参构造 */
    /* 初始化操作： factory 和 session */
    public UserDaoImp(SqlSessionFactory factory){
        this.factory = factory;
        session = factory.openSession();
    }

    /** 销毁操作 */
    /* 释放资源 */
    @After
    public void destroy() {
        session.close();
    }



    /** 添加用户 */
    public void add(User user){
        session.insert("cn.water.dao.UserDao.add", user);
        session.commit();
    };

    /** 更新用户 */
    public void update(User user){
        session.update("cn.water.dao.UserDao.update", user);
        session.commit();
    };

    /** 删除用户 */
    public void delete(Integer id){
        session.delete("cn.water.dao.UserDao.delete", id);
        session.commit();

    };

    /** 查询所有用户 */
    public List<User> findAll(){
        return session.selectList("cn.water.dao.UserDao.findAll");
    };

    /** 查询单个用户 */
    public User findOne(Integer id){
        return session.selectOne("cn.water.dao.UserDao.findOne", id);
    };

    /** 根据姓名模糊查询 */
    public List<User> findByName01(String name){
        return session.selectList("cn.water.dao.UserDao.findByName01", name);
    };
    public List<User> findByName02(String name){
        return session.selectList("cn.water.dao.UserDao.findByName02", name);
    };

    /** 查询所有用户的数量 */
    public Integer findTotal(){
        return session.selectOne("cn.water.dao.UserDao.findTotal");
    };


}

测试类

Test.java

package cn.water.test;

import cn.water.dao.UserDao;
import cn.water.dao.UserDaoImp;
import cn.water.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.List;


public class UserTest {

    /* 成员变量 */
    private InputStream inputStream;
    private SqlSession session;
    private UserDao dao;

    /* 初始化操作 */
    @Before
    public void init() throws IOException {
        /* 加载 MyBatis配置文件 */
        inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        /* 获取 工厂类 */
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        /* 获取 持久层实现类 */
        dao = new UserDaoImp(factory);
    }

    /* 销毁操作 */
    @After
    public void destroy() throws IOException {
        inputStream.close();
    }


    /** 添加用户 */
    @Test
    public void test01(){
        dao.add( new User(100,"ADD",new Date(),"男","UserDao") );
    }

    /** 更新用户 */
    @Test
    public void test02(){
        dao.update( new User(100,"UPDATE",new Date(),"男","UserDao") );
    }

    /** 删除用户 */
    @Test
    public void test03(){
        dao.delete(100);
    }

    /** 查询所有用户 */
    @Test
    public void test04(){
        for (User user : dao.findAll()) {
            System.out.println(user);
        }
    }

    /** 查询单个用户 */
    @Test
    public void test05(){
        System.out.println( dao.findOne(41) );
    }


    /** 根据用户模糊查询 */
    @Test
    public void test06(){
        // LIKE #{username} 使用的是PreparedStatement对象
        List<User> userList1 = dao.findByName01("%王%");
        // LIKE '%${value}%' 使用的是Statement对象
        List<User> userList2 = dao.findByName02("王");
        /* 输出 */
        for (User user : userList1) {
            System.out.println("1--"+user);
        }
        for (User user : userList2) {
            System.out.println("2--"+user);
        }
    }

    /** 查询所有用户的数量 */
    @Test
    public void test07(){
        System.out.println( dao.findTotal() );
    }


}

ProxyDao vs MyDao

  • ProxyDao 和 MyDao 的具体区别在于：
    • 当我们使用代理持久层实现类的方式时，代理对象会帮我们增强代码去调用 selectList方法；
    • 但是当我们使用手动编写持久层实现类的方式时，我们就需要自己去编写实现类实现方法去调用 selectList方法了。
  • 而且我们不难发现，都是实现同一个功能，在测试类中 ProxyDao 比 MyDao 多了2行代码。但恐怖的是，MyDao 比 ProxyDao 多了一个类。

ProxyDao

测试类

/* 1.加载 MyBatis配置文件 */
inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
/* 2.获取 工厂类 */
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

/* 3.获取 产品类 */
session = factory.openSession();
/* 4.获取 代理对象 */
dao = session.getMapper(UserDao.class);
/* 5.调用方法 */
dao.add( new User(100,"ADD",new Date(),"男","UserDao") );
/* 6.提交事务 */
session.commit();

/* 7.释放资源 */
session.close();
inputStream.close();

MyDao

测试类

/* 1.加载 MyBatis配置文件 */
inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
/* 2.获取 工厂类 */
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

/* 3.获取 持久层实现类 */
dao = new UserDaoImp(factory);

/* 5.调用方法 */
dao.add( new User(100,"ADD",new Date(),"男","UserDao") );

/* 7.释放资源 */
inputStream.close();

实现类

/* 5.调用方法 */
session.insert("cn.water.dao.UserDao.add", user);
/* 6.提交事务 */
session.commit();

/* 7.释放资源 */
session.close();

实现CRUD操作

  • 本章节抛开了获取代理持久层实现类或持久层实现类的代码，以便直接显示 ProxyDao 和 MyDao 的具体区别。
  • 我们可以明显的看出 MyDao 代码的臃肿，所以这也是为什么手动编写持久层实现类的方法在实际编程中不受欢迎的原因了。

思维导图

在这里插入图片描述

添加用户

ProxyDao

  • 测试类
    dao.add( new User(100,"ADD",new Date(),"男","UserDao") );
    session.commit();

MyDao

  • 测试类
    dao.add( new User(100,"ADD",new Date(),"男","UserDao") );
  • 实现类
public void add(User user){
    session.insert("cn.water.dao.UserDao.add", user);
    session.commit();
};

更新用户

ProxyDao

  • 测试类
    dao.update( new User(100,"UPDATE",new Date(),"男","UserDao") );
    session.commit();

MyDao

  • 测试类
    dao.update( new User(100,"UPDATE",new Date(),"男","UserDao") );
  • 实现类
public void update(User user){
    session.update("cn.water.dao.UserDao.update", user);
    session.commit();
};

删除用户

ProxyDao

  • 测试类
    dao.delete(100);
    session.commit();

MyDao

  • 测试类
    dao.delete(100);
  • 实现类
public void delete(Integer id){
    session.delete("cn.water.dao.UserDao.delete", id);
    session.commit();
};

查找所有用户

ProxyDao

  • 测试类
    for (User user : dao.findAll()) {
        System.out.println(user);
    }

MyDao

  • 测试类
    for (User user : dao.findAll()) {
        System.out.println(user);
    }
  • 实现类
public List<User> findAll(){
    return session.selectList("cn.water.dao.UserDao.findAll");
};

查询单个用户

ProxyDao

  • 测试类
    System.out.println( dao.findOne(41) );

MyDao

  • 测试类
    System.out.println( dao.findOne(41) );
  • 实现类
public User findOne(Integer id){
    return session.selectOne("cn.water.dao.UserDao.findOne", id);
};

根据姓名模糊查询

ProxyDao

  • 测试类
	List<User> userList1 = dao.findByName01("%王%");
    List<User> userList2 = dao.findByName02("王");

    for (User user : userList1) {
        System.out.println("1--"+user);
    }
    for (User user : userList2) {
        System.out.println("2--"+user);
    }

MyDao

  • 测试类
	List<User> userList1 = dao.findByName01("%王%");
    List<User> userList2 = dao.findByName02("王");

    for (User user : userList1) {
        System.out.println("1--"+user);
    }
    for (User user : userList2) {
        System.out.println("2--"+user);
    }
  • 实现类
public List<User> findByName01(String name){
    return session.selectList("cn.water.dao.UserDao.findByName01", name);
};

public List<User> findByName02(String name){
    return session.selectList("cn.water.dao.UserDao.findByName02", name);
};

查询所有用户数量

ProxyDao

  • 测试类
    System.out.println( dao.findTotal() );

MyDao

  • 测试类
    System.out.println( dao.findTotal() );
  • 实现类
public Integer findTotal(){
    return session.selectOne("cn.water.dao.UserDao.findTotal");
};

执行过程（思维流图）

查询方法

在这里插入图片描述

增删改方法

在这里插入图片描述

water1127
发布了68 篇原创文章 · 获赞 2 · 访问量 1920
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_40981851/article/details/104191870
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022