spring+mybatis省去重复工作的增删改查编码模式设计---------有自己实现mybatis的需要

前提：在很多的业务方法上面，很多程序员在SERVICE和DAO层都做着重复的工作，基本上很多时间都浪费在一个基本表的增删改查上边了，所以本次编码模式将避免这种现象，而且保留了每个业务的扩展性

一、设计类图

二、代码

package com.qysxy.product.app.common.dao;

import com.yizhilu.os.core.dao.impl.common.GenericDaoImpl;
import com.yizhilu.os.core.entity.PageEntity;

import java.util.List;

/**
 * @author fuguangli
 * @description 前沿DAO基础实现类
 * @Create date:    2017/3/14
 * @genericity E 泛型实体类
 */
public abstract class AbstractBaseDao<E> extends GenericDaoImpl implements BaseDaoInter<E> {
    private String mapperName = "";

    public void setMapperName(String mapperName) {
        this.mapperName = mapperName;
    }

    public AbstractBaseDao() {
    }


    /**
     * 获取单条数据
     *
     * @param id
     * @return
     */
    @Override
    public E getById(Long id) {
        return this.selectOne(mapperName + ".getById", id);
    }

    /**
     * 获取单条数据
     *
     * @param entity
     * @return
     */
    @Override
    public E get(E entity) {
        return this.selectOne(mapperName + ".get", entity);
    }

    /**
     * 查询数据列表，如果需要分页，请设置分页对象，page不为空
     *
     * @param entity
     * @return
     */
    @Override
    public List findList(E entity, PageEntity page) {
        return this.queryForListPage(mapperName + ".findList", entity, page);
    }

    /**
     * 查询所有数据列表
     *
     * @param entity
     * @return
     */
    @Override
    public List findAllList(E entity) {
        return this.selectList(mapperName + ".findAllList", entity);
    }


    /**
     * 插入数据
     *
     * @param entity
     * @return
     */
    @Override
    public Long insert(E entity) {
        return this.insert(mapperName + ".insert", entity);
    }

    /**
     * 更新数据
     *
     * @param entity
     * @return
     */
    @Override
    public Long update(E entity) {
        return this.update(mapperName + ".update", entity);
    }

    /**
     * 删除数据
     *
     * @param id
     * @return
     * @see public int delete(T entity)
     */
    @Override
    public Long deleteById(Long id) {
        return this.delete(mapperName + ".deleteById", id);
    }

    /**
     * 删除数据
     *
     * @param entity
     * @return
     */
    @Override
    public Long delete(E entity) {
        return this.delete(mapperName + ".delete", entity);
    }

    /**
     * 添加数据 代码创建sql语句
     *
     * @param sql
     */
    @Override
    public int insertBySql(String sql) {
        return this.getSqlSession().insert(mapperName + ".insertBySql", sql);
    }

    /**
     * 更新数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public int updateBySql(String sql) {
        return this.getSqlSession().update(mapperName + ".updateBySql", sql);
    }

    /**
     * 删除数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public int deleteBySql(String sql) {
        return this.getSqlSession().delete(mapperName + ".deleteBySql", sql);
    }

    /**
     * 查找数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public List<E> findBySql(String sql) {
        return this.getSqlSession().selectList(mapperName + ".findBySql", sql);
    }
}

package com.qysxy.product.app.common.dao;

import com.yizhilu.os.core.entity.PageEntity;

import java.util.List;

/**
 * @author fuguangli
 * @description 前沿DAO基础接口
 * @Create date:    2017/3/6
 * @genericity E 泛型实体类
 */
public interface BaseDaoInter<E> {

    /**
     * 获取单条数据
     *
     * @param id
     * @return
     */
    E getById(Long id);

    /**
     * 获取单条数据
     *
     * @param entity
     * @return
     */
    E get(E entity);

    /**
     * 查询数据列表，如果需要分页，请设置分页对象，如：entity.setPage(new Page<E>());
     *
     * @param entity
     * @return
     */
    List findList(E entity, PageEntity page);

    /**
     * 查询所有数据列表
     *
     * @param entity
     * @return
     */
    List<E> findAllList(E entity);


    /**
     * 插入数据
     *
     * @param entity
     * @return
     */
    Long insert(E entity);

    /**
     * 更新数据
     *
     * @param entity
     * @return
     */
    Long update(E entity);

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param id
     * @return
     * @see int delete(E entity)
     */
    Long deleteById(Long id);

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param entity
     * @return
     */
    Long delete(E entity);

    /**
     * 添加数据 代码创建sql语句
     *
     * @param sql
     */
    int insertBySql(String sql);

    /**
     * 更新数据 代码创建sql
     *
     * @param sql
     * @return
     */
    int updateBySql(String sql);

    /**
     * 删除数据 代码创建sql
     *
     * @param sql
     * @return
     */
    int deleteBySql(String sql);

    /**
     * 查找数据 代码创建sql
     *
     * @param sql
     * @return
     */
    List<E> findBySql(String sql);

}

package com.qysxy.product.app.common.service;

import com.qysxy.product.app.common.dao.AbstractBaseDao;
import com.qysxy.product.app.common.dao.BaseDaoInter;
import com.yizhilu.os.core.entity.PageEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author fuguangli
 * @description 前沿基础业务类
 * @Create date:    2017/3/6
 * @genericity D 泛型DAO接口
 * @genericity  E 泛型实体类接口
 */
public abstract class AbstractBaseService<D extends BaseDaoInter<E>, E> implements AbstractBaseServiceInter<E> {
    /**
     * 持久层对象
     */
    @Autowired
    protected D dao;

    /**
     * 获取单条数据
     *
     * @param id
     * @return
     */
    @Override
    public E getById(Long id) {
        return dao.getById(id);
    }

    /**
     * 获取单条数据
     *
     * @param entity
     * @return
     */
    @Override
    public E get(E entity) {
        return dao.get(entity);
    }

    /**
     * 查询数据列表，如果需要分页，请设置分页对象，如：entity.setPage(new Page<E>());
     *
     * @param entity
     * @param page
     * @return
     */
    @Override
    public List findList(E entity, PageEntity page) {
        return dao.findList(entity, page);
    }

    /**
     * 查询所有数据列表
     *
     * @param entity
     * @return
     */
    @Override
    public List<E> findAllList(E entity) {
        return dao.findAllList(entity);
    }

    /**
     * 插入数据
     *
     * @param entity
     * @return
     */
    @Override
    public Long insert(E entity) {
        return dao.insert(entity);
    }

    /**
     * 更新数据
     *
     * @param entity
     * @return
     */
    @Override
    public Long update(E entity) {
        return dao.update(entity);
    }

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param id
     * @return
     * @see int delete(E entity)
     */
    @Override
    public Long deleteById(Long id) {
        return dao.deleteById(id);
    }

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param entity
     * @return
     */
    @Override
    public Long delete(E entity) {
        return dao.delete(entity);
    }

    /**
     * 添加数据 代码创建sql语句
     *
     * @param sql
     */
    @Override
    public int insertBySql(String sql) {
        return dao.insertBySql(sql);
    }

    /**
     * 更新数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public int updateBySql(String sql) {
        return dao.updateBySql(sql);
    }

    /**
     * 删除数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public int deleteBySql(String sql) {
        return dao.deleteBySql(sql);
    }

    /**
     * 查找数据 代码创建sql
     *
     * @param sql
     * @return
     */
    @Override
    public List<E> findBySql(String sql) {
        return dao.findBySql(sql);
    }
}

package com.qysxy.product.app.common.service;

import com.yizhilu.os.core.entity.PageEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author fuguangli
 * @description 前沿基础业务接口
 * @Create date:    2017/3/6
 * @genericity E 实体类
 */
public interface AbstractBaseServiceInter<E> {

    /**
     * 获取单条数据
     *
     * @param id
     * @return
     */
    E getById(Long id);

    /**
     * 获取单条数据
     *
     * @param entity
     * @return
     */
    E get(E entity);

    /**
     * 查询数据列表，如果需要分页，请设置分页对象，如：entity.setPage(new Page<E>());
     *
     * @param entity
     * @return
     */
    List findList(E entity, PageEntity page);

    /**
     * 查询所有数据列表
     *
     * @param entity
     * @return
     */
    List<E> findAllList(E entity);


    /**
     * 插入数据
     *
     * @param entity
     * @return
     */
    Long insert(E entity);

    /**
     * 更新数据
     *
     * @param entity
     * @return
     */
    Long update(E entity);

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param id
     * @return
     * @see int delete(E entity)
     */
    Long deleteById(Long id);

    /**
     * 删除数据（一般为逻辑删除，更新del_flag字段为1）
     *
     * @param entity
     * @return
     */
    Long delete(E entity);

    /**
     * 添加数据 代码创建sql语句
     *
     * @param sql
     */
    int insertBySql(String sql);

    /**
     * 更新数据 代码创建sql
     *
     * @param sql
     * @return
     */
    int updateBySql(String sql);

    /**
     * 删除数据 代码创建sql
     *
     * @param sql
     * @return
     */
    int deleteBySql(String sql);

    /**
     * 查找数据 代码创建sql
     *
     * @param sql
     * @return
     */
    List<E> findBySql(String sql);

}

以上都是公用的接口以及抽象类，接下来上测试接口及测试相关类

package com.qysxy.product.test;

import com.qysxy.product.app.common.dao.BaseDaoInter;

/**
 * @author fuguangli
 * @description 前沿类
 * @Create date:    2017/3/14
 */
public interface TestDao extends BaseDaoInter<TestData> {
}

package com.qysxy.product.test;

import com.qysxy.product.app.common.dao.AbstractBaseDao;
import org.springframework.stereotype.Repository;

/**
 * @author fuguangli
 * @description 前沿测试类
 * @Create date:    2017/3/14
 */
@Repository
public class TestDaoImpl extends AbstractBaseDao<TestData> implements TestDao{
    public TestDaoImpl() {
        //一定要设置父类的命名空间
        super.setMapperName("TestDataMapper");
    }
}

package com.qysxy.product.test;

import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;

/**
 * @author fuguangli
 * @description 前沿类
 * @Create date:    2017/3/14
 */
@Data
@EqualsAndHashCode
public class TestData implements Serializable {
    private Long id;
    private String name;
}

package com.qysxy.product.test;

import com.qysxy.product.app.common.service.AbstractBaseServiceInter;

/**
 * @author fuguangli
 * @description 前沿类
 * @Create date:    2017/3/14
 */


public interface TestService extends AbstractBaseServiceInter<TestData>{
}

package com.qysxy.product.test;

import com.qysxy.product.app.common.service.AbstractBaseService;
import org.springframework.stereotype.Service;

/**
 * @author fuguangli
 * @description 前沿类
 * @Create date:    2017/3/14
 */
@Service
public class TestServiceImpl extends AbstractBaseService<TestDao,TestData> implements TestService {
}

package test;

import com.qysxy.product.test.TestDao;
import com.qysxy.product.test.TestData;
import com.qysxy.product.test.TestService;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author fuguangli
 * @description 前沿模型测试类
 * @Create date:    2017/3/14
 */
public class ModuleTest extends BaseTest {
    @Autowired
    private TestDao testDao;


    @Autowired
    private TestService testService;

    @Test
    public void ge() {
        TestData testData = new TestData();
        testData.setId(2l);
        TestData testData1 = testService.get(testData);
        System.err.println(testData1);
    }
}

package test;


import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 
* @ClassName: BaseTest 
* @Description: 基础测试类（其他测试类直接继承即可）
* @author SuLong
* @date 2017年1月4日  上午10:54:59
 */
@RunWith(SpringJUnit4ClassRunner.class) // 整合
@ContextConfiguration(locations = "classpath:applicationContext.xml") // 加载配置
public class BaseTest {

}

 mybatis映射文件：

<?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="TestDataMapper">

    <sql id="columns">
    id,
    name
  </sql>
    <sql id="properties">
    #{id},
    #{name}
  </sql>
    <resultMap id="testDataResult" type="TestData">
        <result property="id" column="id"></result>
        <result property="name" column="name"></result>
    </resultMap>

    <select id="get" resultMap="testDataResult" parameterType="TestData">
        SELECT *
        FROM test_test
        <where>
            <if test="id!=null and id!=0">
                and id=#{id}
            </if>
            <if test="name!=null and name!=''">
               and name=#{name}
            </if>
        </where>
    </select>

    <select id="getById" resultMap="testDataResult" parameterType="long">
    SELECT *
    FROM test_test a
    WHERE a.id = #{id}
  </select>


    <insert id="insert" parameterType="TestData">
    INSERT INTO test_test(
    id,
    name
    ) VALUES (
    #{id},
    #{name}
    )
  </insert>


    <!--自定义语句-->
    <insert id="insertBySql" parameterType="String">
    ${value}
  </insert>
    <delete id="deleteBySql" parameterType="String">
    ${value}
  </delete>
    <update id="updateBySql" parameterType="String">
    ${value}
  </update>
    <select id="findBySql" parameterType="String" resultType="java.lang.Object">
    ${value}
  </select>
</mapper>

总结：这样的话，保留了spring的依赖注入，同时，也保留了程序代码的扩展性，而且帮助编程人员实现了基本的增删改查