mybatis帮助程序猿省去了很多工作了，需要结合好BaseDao与BaseService，这里就提供下我所使用的BaseXXX。
前提，mybatis的映射文件是采用mybatis-generator自动生成的（）
1、BaseDao，我们知道在mybatis与SpringMVC结合的时候，Dao层只需要写interface即可，剩下的实现工作将由mybatis自动为我们实现，这个BaseDao省去interface这层，采用SpringMvc的@Repository标签进行注入管理，上代码：
import java.io.S
import java.lang.reflect.InvocationTargetE
import java.util.HashM
import java.util.L
import java.util.M
import org.apache.commons.beanutils.PropertyU
import org.apache.ibatis.session.RowB
import org.apache.ibatis.session.SqlSessionF
import org.mybatis.spring.support.SqlSessionDaoS
import org.springframework.beans.factory.annotation.A
import org.springframework.stereotype.R
import com.alibaba.dubbo.common.utils.CollectionU
import com.github.pagehelper.PageH
import com.github.pagehelper.PageI
import com.ivan.core.util.GenericsU
//分页Form
import com.ivan.core.util.page.PageF
@Repository("baseDao")
public class BaseDao&T, PK extends Serializable& extends SqlSessionDaoSupport implements Serializable {
private static final long serialVersionUID = 8633838L;
private final String POSTFIX = "Dao";
private final String _INSERT = ".insert";
private final String _INSERTSELECTIVE = ".insertSelective";
private final String _SELECTBYPRIMARYKEY = ".selectByPrimaryKey";
private final String _UPDATEBYPRIMARYKEY = ".updateByPrimaryKey";
private final String _UPDATEBYPRIMARYKEYSELECTIVE = ".updateByPrimaryKeySelective";
private final String _DELETEBYPRIMARYKEY = ".deleteByPrimaryKey";
@Autowired
public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
super.setSqlSessionFactory(sqlSessionFactory);
/*GenericsUtils为工具类，请见下方代码
泛型获得XXXEntity，将其转换为XXXEntityDao，具体操作替换掉Entity变成XXXDao，对应Mapper.xml中的namespace命名
@SuppressWarnings({ "unchecked", "rawtypes" })
public String getNampSpace() {
Class&T& clazz = (Class)GenericsUtils.getSuperClassGenricType(this.getClass());
String simpleName = clazz.getSimpleName() + POSTFIX;
return simpleN
public int insert(T entity) {
return getSqlSession().insert(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _INSERT, entity);
public int insertSelective(T record) {
return getSqlSession().insert(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _INSERTSELECTIVE, record);
public T selectByPrimaryKey(PK id) {
return getSqlSession().selectOne(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _SELECTBYPRIMARYKEY, id);
public int updateByPrimaryKey(T record) {
return getSqlSession().update(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _UPDATEBYPRIMARYKEY, record);
public int updateByPrimaryKeySelective(T record) {
return getSqlSession().update(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _UPDATEBYPRIMARYKEYSELECTIVE, record);
public int deleteByPrimaryKey(PK id) {
return getSqlSession().delete(
(this.getNampSpace().contains("Entity") ? this.getNampSpace().replace("Entity", "")
: this.getNampSpace()) + _DELETEBYPRIMARYKEY, id);
@SuppressWarnings({ "rawtypes", "unchecked" })
public PageInfo&T& pageFind(String statementKey, PageForm pageForm, Object parameter,
Boolean isSimplePage) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
Map params = new HashMap();
if (parameter != null) {
if (parameter instanceof Map) {
params.putAll((Map) parameter);
Map parameterObject = PropertyUtils.describe(parameter);
params.putAll(parameterObject);
PageHelper.startPage(pageForm.getPage(), pageForm.getRows());
List&T& list = getSqlSession().selectList(statementKey, params);
PageInfo&T& pageInfo = new PageInfo(list);
return pageI
@SuppressWarnings({ "rawtypes", "unchecked" })
public List&T& findTop(int top, String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
Map params = new HashMap();
if (parameter != null) {
if (parameter instanceof Map) {
params.putAll((Map) parameter);
Map parameterObject = PropertyUtils.describe(parameter);
params.putAll(parameterObject);
List&T& list = getSqlSession().selectList(statementKey, params, new RowBounds(0, top));
public T findTopOne(String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
List&T& list = findTop(1, statementKey, parameter);
return CollectionUtils.isEmpty(list) ? null : list.get(0);
@SuppressWarnings({ "rawtypes", "unchecked" })
public &M& PageInfo&M& pageFindModel(String statementKey, PageForm pageForm, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
Map params = new HashMap();
if (parameter != null) {
if (parameter instanceof Map) {
params.putAll((Map) parameter);
Map parameterObject = PropertyUtils.describe(parameter);
params.putAll(parameterObject);
PageHelper.startPage(pageForm.getPage(), pageForm.getRows());
List&M& list = getSqlSession().selectList(statementKey, params);
PageInfo&M& pageInfo = new PageInfo(list);
return pageI
2、泛型工具类，GenericsUtils：
import java.lang.reflect.F
import java.lang.reflect.M
import java.lang.reflect.ParameterizedT
import java.lang.reflect.T
import java.util.ArrayL
import java.util.L
import java.util.R
import javax.servlet.http.HttpS
import org.springframework.web.context.request.RequestContextH
import org.springframework.web.context.request.ServletRequestA
* 泛型工具类
* @author &a href="http://www.blogjava.net/lishunli/"
target="_jeecg"&ShunLi&/a&
* @notes Created on &br&
Revision of last commit:$Revision: 1.1 $&br&
Author of last commit:$Author: ghp $&br&
Date of last commit:$Date:
16:48:17 +0800 (周一, 25 一月 2010)
public class GenericsUtils {
* 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport&Buyer&
* @param clazz
clazz 需要反射的类,该类必须继承范型父类
* @param index
泛型参数所在索引,从0开始.
* @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
public static Class getSuperClassGenricType(Class clazz, int index) {
Type genType = clazz.getGenericSuperclass();// 得到泛型父类
// 如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.class
if (!(genType instanceof ParameterizedType)) {
return Object.
// 返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends
// DaoSupport&Buyer,Contact&就返回Buyer和Contact类型
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index &= params.length || index & 0) {
throw new RuntimeException("你输入的索引" + (index & 0 ? "不能小于0" : "超出了参数的总数"));
if (!(params[index] instanceof Class)) {
return Object.
return (Class) params[index];
* 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport&Buyer&
* @param clazz
clazz 需要反射的类,该类必须继承泛型父类
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(Class clazz) {
return getSuperClassGenricType(clazz, 0);
* 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map&String, Buyer& getNames(){}
* @param Method
method 方法
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
@SuppressWarnings("unchecked")
public static Class getMethodGenericReturnType(Method method, int index) {
Type returnType = method.getGenericReturnType();
if (returnType instanceof ParameterizedType) {
ParameterizedType type = (ParameterizedType) returnT
Type[] typeArguments = type.getActualTypeArguments();
if (index &= typeArguments.length || index & 0) {
throw new RuntimeException("你输入的索引" + (index & 0 ? "不能小于0" : "超出了参数的总数"));
return (Class) typeArguments[index];
return Object.
* 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map&String, Buyer& getNames(){}
* @param Method
method 方法
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
@SuppressWarnings("unchecked")
public static Class getMethodGenericReturnType(Method method) {
return getMethodGenericReturnType(method, 0);
* 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map&String,
* Buyer& maps, List&String& names){}
* @param Method
method 方法
* @param int index 第几个输入参数
* @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
@SuppressWarnings("unchecked")
public static List&Class& getMethodGenericParameterTypes(Method method, int index) {
List&Class& results = new ArrayList&Class&();
Type[] genericParameterTypes = method.getGenericParameterTypes();
if (index &= genericParameterTypes.length || index & 0) {
throw new RuntimeException("你输入的索引" + (index & 0 ? "不能小于0" : "超出了参数的总数"));
Type genericParameterType = genericParameterTypes[index];
if (genericParameterType instanceof ParameterizedType) {
ParameterizedType aType = (ParameterizedType) genericParameterT
Type[] parameterArgTypes = aType.getActualTypeArguments();
for (Type parameterArgType : parameterArgTypes) {
Class parameterArgClass = (Class) parameterArgT
results.add(parameterArgClass);
* 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map&String, Buyer&
* maps, List&String& names){}
* @param Method
method 方法
* @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
@SuppressWarnings("unchecked")
public static List&Class& getMethodGenericParameterTypes(Method method) {
return getMethodGenericParameterTypes(method, 0);
* 通过反射,获得Field泛型参数的实际类型. 如: public Map&String, Buyer&
* @param Field
field 字段
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
@SuppressWarnings("unchecked")
public static Class getFieldGenericType(Field field, int index) {
Type genericFieldType = field.getGenericType();
if (genericFieldType instanceof ParameterizedType) {
ParameterizedType aType = (ParameterizedType) genericFieldT
Type[] fieldArgTypes = aType.getActualTypeArguments();
if (index &= fieldArgTypes.length || index & 0) {
throw new RuntimeException("你输入的索引" + (index & 0 ? "不能小于0" : "超出了参数的总数"));
return (Class) fieldArgTypes[index];
return Object.
* 通过反射,获得Field泛型参数的实际类型. 如: public Map&String, Buyer&
* @param Field
field 字段
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回
&code&Object.class&/code&
@SuppressWarnings("unchecked")
public static Class getFieldGenericType(Field field) {
return getFieldGenericType(field, 0);
* 根据实体得到实体的所有属性
* @param objClass
* @throws ClassNotFoundException
public static String[] getColumnNames(String objClass) throws ClassNotFoundException {
String[] wageStrArray =
if (objClass != null) {
Class class1 = Class.forName(objClass);
Field[] field = class1.getDeclaredFields();// 这里便是获得实体Bean中所有属性的方法
StringBuffer sb = new StringBuffer();
for (int i = 0; i & field. i++) {// 这里不多说了
sb.append(field[i].getName());
// 这是分割符 是为了去掉最后那个逗号
// 比如 如果不去最后那个逗号 最后打印出来的结果是 "id,name,"
// 去了以后打印出来的是 "id,name"
if (i & field.length - 1) {
sb.append(",");
// split(",");这是根据逗号来切割字符串使字符串变成一个数组
wageStrArray = sb.toString().split(",");
return wageStrA
return wageStrA
public static Object[] field2Value(Field[] f, Object o) throws Exception {
Object[] value = new Object[f.length];
for (int i = 0; i & f. i++) {
value[i] = f[i].get(o);
* returns the current http session object
* @return session
public HttpSession getSession() {
HttpSession session=
ServletRequestAttributes attr = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
HttpSession contextSess = attr == null ? session : attr.getRequest().getSession(true);
return contextS
* 得到实体类
* @param objClass 实体类包含包名
public static
Class getEntityClass(String objClass){
Class entityClass =
entityClass = Class.forName(objClass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return entityC
* 定义字符集
private static char[] chars = { '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
'y', 'z', 'A', 'B','C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
//72个字符集
* @param passLength
随机密码长度
* @param count
随机密码个数
* @return 随机密码数组
public static String getPasswords(int passLength) {
String passwords = "";// 新建一个长度为指定需要密码个数的字符串数组
Random random = new Random();
StringBuilder password = new StringBuilder("");// 保存生成密码的变量
for (int m = 1; m &= passL m++) {// 内循环 从1开始到密码长度 正式开始生成密码
password.append(chars[random.nextInt(62)]);// 为密码变量随机增加上面字符中的一个
passwords = password.toString();// 将生成出来的密码赋值给密码数组
3、BaseService接口，为什么这层要选择接口来实现呢？有很多需要前后分离的应用，暴露的服务就是接口暴露Service层，所以采用接口。
import java.io.S
import java.lang.reflect.InvocationTargetE
import java.util.L
@SuppressWarnings("hiding")
public interface BaseService&T, Serializable& {
public int insert(T record);
public int insertSelective(T record);
public T selectByPrimaryKey(String id);
public int updateByPrimaryKey(T record);
public int updateByPrimaryKeySelective(T record);
public int deleteByPrimaryKey(String id);
public List&T& findTop(int top, String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodE
public T findTopOne(String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodE
4、BaseService接口的实现类BaseServiceImpl，需要注入BaseDao（其中必须对BaseDao进行set，否则无法获取具体泛型）
import java.io.S
import java.lang.reflect.InvocationTargetE
import java.util.L
import org.springframework.beans.factory.annotation.A
import com.alibaba.dubbo.config.annotation.S
import com.ivan.api.base.BaseS
import com.ivan.base.BaseD
public abstract class BaseServiceImpl&T& implements BaseService&T, Serializable&{
@Autowired
private BaseDao&T, Serializable& baseD
public BaseDao&T, Serializable& getBaseDao() {
return baseD
public void setBaseDao(BaseDao&T, Serializable& baseDao) {
this.baseDao = baseD
public int insert(T entity) {
return baseDao.insert(entity);
public int insertSelective(T record) {
return baseDao.insertSelective(record);
public T selectByPrimaryKey(String id) {
return baseDao.selectByPrimaryKey(id);
public int updateByPrimaryKey(T record) {
return baseDao.updateByPrimaryKey(record);
public int updateByPrimaryKeySelective(T record) {
return baseDao.updateByPrimaryKeySelective(record);
public int deleteByPrimaryKey(String id) {
return baseDao.deleteByPrimaryKey(id);
public List&T& findTop(int top, String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
return baseDao.findTop(top, statementKey, parameter);
public T findTopOne(String statementKey, Object parameter) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
return baseDao.findTopOne(statementKey, parameter);
5、Mapper.xml文件的定义，需要注意的是namespace的命名，会通过这个命名找到具体的mapper文件，进行数据的操作。
&?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="UserDao" &
&resultMap id="BaseResultMap" type="com.ivan.entity.UserEntity" &
&id column="id" property="id" jdbcType="VARCHAR" /&
&result column="name" property="name" jdbcType="VARCHAR" /&
&result column="age" property="age" jdbcType="INTEGER" /&
&/resultMap&
&sql id="Base_Column_List" &
id, name, age
&select id="selectAll" resultMap="BaseResultMap"&
&include refid="Base_Column_List" /&
&select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="String" &
&include refid="Base_Column_List" /&
where id = #{id,jdbcType=INTEGER}
&delete id="deleteByPrimaryKey" parameterType="String" &
delete from user
where id = #{id,jdbcType=INTEGER}
&insert id="insert" parameterType="com.ivan.entity.UserEntity" &
insert into user (id, name, age
values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER}
&insert id="insertSelective" parameterType="com.ivan.entity.UserEntity" &
insert into user
&trim prefix="(" suffix=")" suffixOverrides="," &
&if test="id != null" &
&if test="name != null" &
&if test="age != null" &
&trim prefix="values (" suffix=")" suffixOverrides="," &
&if test="id != null" &
#{id,jdbcType=VARCHAR},
&if test="name != null" &
#{name,jdbcType=VARCHAR},
&if test="age != null" &
#{age,jdbcType=INTEGER},
&update id="updateByPrimaryKeySelective" parameterType="com.ivan.entity.UserEntity" &
update user
&if test="name != null" &
name = #{name,jdbcType=VARCHAR},
&if test="age != null" &
age = #{age,jdbcType=INTEGER},
where id = #{id,jdbcType=VARCHAR}
&update id="updateByPrimaryKey" parameterType="com.ivan.entity.UserEntity" &
update user
set name = #{name,jdbcType=VARCHAR},
age = #{age,jdbcType=INTEGER}
where id = #{id,jdbcType=VARCHAR}
6、具体的使用方法：
a、定义UserDao：
@Repository("userDao")
public class UserDao extends BaseDao&UserEntity, Serializable&{
private static final long serialVersionUID = 6322571L;
}b、定义UserService接口
public interface UserService extends BaseService&UserEntity, Serializable&{
c、实现UserService接口
public class UserServiceImpl extends BaseServiceImpl&UserEntity& implements UserService{
d、调用UserService接口
@Controller
@RequestMapping("/user")
public class UserController {
@SuppressWarnings("unused")
private static final Logger logger = LoggerFactory.getLogger(UserController.class);
@Reference
private UserService userS
以上，可以整合到前几篇关于dubbo的工程中。
mybatis-basedao的实现
package com.yangwei.shop.
import java.util.HashM
import java.util.L
import java.util.Map...
通用DAO之MyBatis封装，封装通用的增删改查（二）
曾经发过一篇文章，大概写的就是阿海多么多么厉害，见到某位同事在Hibernate的基础上封装了一下，就以一己之力开发什么什么框架，最后写了个超大的一坨的事。
那么，后续篇来了。阿海不是自负之人，当之...
Mybatis 进行简单通用的封装
配置文件当Spring和Mybatis集成时，可以利用通配符的形式注册Mapper配置文件
MyBatis通用dao和通用service
更新于，增加了第三种方法
##更新于，第三种方法方法改进，service实现上不需要加泛型
使用通用dao和通用service可以减少...
mybatis BaseDao封装
mybatis BaseDao封装
(菜鸟来动手-第四天)SSM整合之BaseService,BaseDao
前面已经实现了SSM的整合, 但是在实际开发中,很多模块都会有增删改查操作.将这些共用操作抽取个公用的出来,能少很多事.
1.实现baseDao
2.实现baseService
3.具体模块实现
基于mybatis封装的持久层。目前只完美支持mysql
此框架只是为了解决mybatis少写xml和sql。
链接地址点击打开链接
如果这里面的满足不了你的需求，你可以用mybatis的MapperScannerConfigurer 继续原...
BaseDao的封装
import java.io.S
import java.util.L
import org.hibernate.criterion.DetachedCriteria...
mybatis 基于泛型dao设计
1，用户分页的参数类
[java] view
package hwt.U
import java.util.Ma...
使用注解反射实现BaseDao(代替XML配置)
java 注解 代替 XML配置
没有更多推荐了，扫一扫体验手机阅读
Spring Boot集成MyBatis实现通用Mapper
<span type="1" blog_id="2163593" userid='
5篇文章，6267人气，0粉丝
运维开发全攻略
￥51.0049人订阅
大数据时代的微服务之路
￥51.00525人订阅}