MyBatis中Dao层、Service层以及xml文件的CRUD模板

前言： 在学习Mybatis的各个层的时候会出现大量的重复代码。因此把遇到的CRUD的相关操作写下来，并且有非常详细的注释。后续相关CRUD代码不断增加中。水平有限，有错误或者更好的处理方法欢迎指出。

注意： 虽然有自动代码文件的插件mybatis-generator，不过我觉得在学习中还是需要熟悉相关操作。

主要包括下面四个文件内容：

• Dao层接口模板IBaseDao
• Dao接口对应的xml文件模板
• Service层接口模板IBaseService
• Service层实现子类模板BaseServiceImpl

Dao层接口模板IBaseDao

package com.dao;

import java.util.List;

import java.util.Set;

/**

* DAO接口方法模板，DAO层的参数都用包装类Integer,Long之类的

*

*/

public interface IBaseDao<T> {

/**

* 实现数据的增加操作

*

* @param vo 包含了要增加数据的vo对象

* @return 数据增加成功返回true，否则返回false

*/

boolean doInsert(T vo);

/**

* 实现数据的修改操作，一般是根据ID进行其他字段数据的修改

*

* @param vo 包含了要修改的数据信息，一定要提供有ID内容

* @return 数据修改成功返回true，否则返回false

*/

boolean doUpdate(T vo);

/**

* 实现数据的删除操作，以ID信息来进行删除

*

* @param id 表示要删除的ID

* @return 数据删除成功返回true，否则返回false

*/

boolean doDelete(Integer id);

/**

* 执行数据的批量删除操作，所有要删除的数据以Set集合的形式保存

*

* @param ids 包含了所有要删除的ID，不包含有重复内容

* @return 数据删除成功返回true，否则返回false

*/

boolean doDeleteBatch(Set<Integer> ids);

/**

* 根据ID查询单个对象信息

*

* @param id 要查询的对象ID

* @return 如果表中有数据，则数据以vo类对象的形式返回，如果信息不存在，则返回null

*/

T findById(Integer id);

/**

* 根据ID查询多个对象信息

*

* @param ids 要查询的多个对象ID

* @return 如果表中有数据，则所有数据会封装为vo对象而后利用List集合返回，如果没有数据，那么集合的长度为0（size() == 0）

*/

List<T> findByIds(Set<Integer> ids);

/**

* 根据ID查询所有对象信息

*

* @return 如果表中有数据，则所有数据会封装为vo对象而后利用List集合返回，如果没有数据，那么集合的长度为0（size() == 0）

*/

List<T> findAll();

/**

* 分页进行数据的模糊查询，查询结果以集合的形式返回

* @param currentPage 当前所在页

* @param lineSize 每页显示的数据行数

* @param column 要进行模糊查询的数据列

* @param keyWord 模糊查询的关键字

* @return 如果表中有数据，则所有数据会封装为vo对象而后利用List集合返回，如果没有数据，那么集合的长度为0（size() == 0）

*由于需要使用多种数据类型，所以使用Map集合，由于类型不统一，所以所有value的类型设置为Object。

* 如果传入多个参数有两种处理方法（两种方法的IService接口都一样，传入多个参数，不做改变）：

* （1）每个使用@param注解：首先在IDao接口里面方法的每个参数都添加@param("value"). 然后在对应xml文件之中就不需要写parameterType类型。

* （2）使用Map集合：首先在对应的xml文件里使得parameterType=java.util.Map，最后在IService接口的实现子类当中将每个参数都传入到Map集合之中

*

*/

//List<T> findAllSplit(Integer currentPage,Integer lineSize,String column,String keyWord);

List<T> findAllSplit(Map<String, Object> params);

/**

*进行模糊查询数据量的统计，如果表中没有记录统计的结果就是0

* @param column 要进行模糊查询的数据列

* @param keyWord 模糊查询的关键字

* @return 返回表中的数据量，如果没有数据返回0

*/

Integer getAllcount(Map<String, Object> params);

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94

Dao接口对应的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.dao.IBaseDao">

<insert id="doInsert" parameterType="T">

INSERT INTO table(A,B,C,D,E,F)

VALUES (#{A},#{B},#{C},#{D},#{E},#{F}) ;

</insert>

<update id="doUpdate" parameterType="T">

UPDATE table SET B=#{B},C=#{C},D=#{D},E=#{E},F=#{F}

WHERE A=#{A}

</update>

<delete id="doDelete" parameterType="java.lang.Integer">

DELETE FROM table WHERE A=#{A}

</delete>

<delete id="doDeleteBatch" parameterType="java.util.Set">

DELETE FROM table WHERE A IN (#{X},#{X},#{X},#{X},#{X})

</delete>

<select id="findById" resultMap="T">

SELECT A,B,C,D,E,F FROM table WHERE A=#{A}

</select>

<select id="findByIds" resultMap="T">

SELECT A,B,C,D,E,F FROM table WHERE A IN (#{X},#{X},#{X},#{X},#{X})

</select>

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

SELECT A,B,C,D,E,F FROM table

</select>

<select id="findAllSplit" parameterType="java.util.Map" resultType="T">

SELECT A,B,C,D,E,F FROM table

<where>

<if test="column !=null and keyWord != null">

${column} LIKE #{keyWord}

</if>

</where>

LIMIT #{start},#{lineSize}

</select>

<select id="getAllcount" parameterType="java.util.Map" resultMap="java.lang.Integer">

SELECT COUNT(A) FROM table

<where>

<if test="column !=null and keyWord != null">

${column} LIKE #{keyWord}

</if>

</where>

</select>

</mapper>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54

Service层接口模板IBaseService

package com.service;

import java.util.List;

import java.util.Set;

/**

* Service接口方法模板,Service层的参数都用基本类型int,long之类的 *

*/

public interface IBaseService<T> {

/**

* 实现数据的增加操作，本次调用DAO层的如下方法：

* （1）DAO.findById()方法，判断要增加的数据ID是否已经存在

* （2）DAO.doInsert()方法，如果数据不存在则进行增加操作。

* @param vo 包含了要增加数据的VO对象

* @return 数据增加成功返回true，否则返回false

*/

boolean insert(T vo);

/**

* 实现数据的修改操作，调用DAO.doUpdate()方法

* @param vo 包含了要修改的数据信息，一定要提供有ID内容

* @return 数据修改成功返回true，否则返回false

*/

boolean update(T vo);

/**

* 实现数据的删除操作，以ID信息来进行删除,调用DAO.doDelete()方法

*

* @param id 表示要删除的ID

* @return 数据删除成功返回true，否则返回false

*/

boolean delete(T id);

/**

* 执行数据的批量删除操作，调用DAO.dodeleteBatch()方法

*

* @param ids 包含了所有要删除的ID，不包含有重复内容

* @return 数据删除成功返回true，否则返回false

*/

boolean deleteBatch(Set<int> ids);

/**

* 根据ID查询单个对象信息,调用DAO.findById()方法

*

* @param id 要查询的对象ID

* @return 如果表中有数据，则数据以vo类对象的形式返回，如果信息不存在，则返回null

*/

T getOne(T id);

/**

* 根据ID查询多个对象信息,调用DAO.findByIds()方法

*

* @param ids 要查询的多个对象ID

* @return 如果表中有数据，则所有数据会封装为vo对象而后利用List集合返回，如果没有数据，那么集合的长度为0（size() == 0）

*/

List<T> getMore(Set<int> ids);

/**

* 根据ID查询所有对象信息,调用DAO.findAlld()方法

*

* @return 如果表中有数据，则所有数据会封装为vo对象而后利用List集合返回，如果没有数据，那么集合的长度为0（size() == 0）

*/

List<T> getAll();

/**

* 分页进行数据的模糊查询，查询结果以集合的形式返回,

* （1）调用DAO.findAllSplit()方法，查询出所有的表数据，返回的List

* （2）调用DAO.getAllcount()方法，查询所有的数据量，返回的Integer

* @param currentPage 当前所在页

* @param lineSize 每页显示的数据行数

* @param column 要进行模糊查询的数据列

* @param keyWord 模糊查询的关键字

* @return 返回查询结果，类型为VO类。最后查询完所有封装成List自动返回。

*

*/

List<T> list(int currentPage,int lineSize,String column,String keyWord);

/**

*进行模糊查询数据量的统计，如果表中没有记录统计的结果就是0,调用DAO.getAllcount()方法

* @param column 要进行模糊查询的数据列

* @param keyWord 模糊查询的关键字

* @return 返回表中的数据量，如果没有数据返回0

*/

int getAllcount(String column,String keyWord);

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89

Service层实现子类模板BaseServiceImpl

package com.service.impl;

import com.dao.IBaseDao;

import com.service.IBaseService;

import javax.annotation.Resource;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

/**

* Service层实现子类模板

*

*/

public class BaseServiceImpl<T> implements IBaseService {

@Resource

private IBaseDao baseDao;

@Override

public boolean insert(Object vo) {

return this.baseDao.doInsert(vo);

}

@Override

public boolean update(Object vo) {

return this.baseDao.doUpdate(vo);

}

@Override

public boolean delete(Object id) {

return this.baseDao.doDelete((Integer) id);

}

@Override

public Object getOne(Object id) {

return this.baseDao.findById((Integer) id);

}

@Override

public List getAll() {

return this.baseDao.findAll();

}

@Override

public List list(int currentPage, int lineSize, String column, String keyWord) {

Map<String ,Object> map = new HashMap<String ,Object>();

map.put("column",column);

map.put("keyWord","%" + keyWord + "%");

map.put("currentPage",(currentPage - 1 ) * lineSize);

map.put("lineSize",lineSize);

return this.baseDao.findAllSplit(map);

}

@Override

public int getAllcount(String column, String keyWord) {

Map<String ,Object> map = new HashMap<String ,Object>();

map.put("column",column);

map.put("keyWord",keyWord);

return this.baseDao.getAllcount(map);

}

@Override

public List getMore(Set ids) {

return this.baseDao.findByIds(ids);

}

@Override

public boolean deleteBatch(Set ids) {

return this.baseDao.doDeleteBatch(ids);

}

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75