myatbis的一个好的封装

package com.pj.project4sp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.pj.project4sp.public4mapper.PublicMapper;
import com.pj.project4sp.public4mapper.PublicService;

/**
 * 公共Mapper 与 公共Service
 * @author kong
 *
 */
@Component
public class SP {

    /**
     * 公共Mapper
     */
    public static PublicMapper publicMapper;
    /**
     * 公共Service
     */
    public static PublicService publicService;                

    // 注入
    @Autowired
    public void setBean(
            PublicMapper publicMapper,
            PublicService publicService
            ) {
        SP.publicMapper = publicMapper;
        SP.publicService = publicService;
    }

}

package com.pj.project4sp.public4mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import com.pj.utils.so.SoMap;

/**
 * 公用Mapper，封装一些常见的Mapper操作，避免某些及其简单的逻辑也要写一堆xml方法
 * @author kong
 * 更新于2020-12-1 新增部分方法
 *
 */
@Mapper
public interface PublicMapper {

    // ------------------------ 一些工具方法 ------------------------

    /**
     * 返回上一句SQL插入的自增主键值
     * @return
     */
    public long getPrimarykey();

    // ------------------------ 新增SQL相关 ------------------------

    // ------------------------ 删除SQL相关 ------------------------

    /**
     * 根据id删除一条记录
     * @param tableName 表名字
     * @param id id值
     * @return
     */
    public int deleteById(
            @Param("tableName")String tableName,
            @Param("id")Object id
            ); 

    /**
     * 根据指定列指定值删除一条记录
     * @param tableName 表名
     * @param whereName 条件列
     * @param whereValue 条件列值
     * @return
     */
    public int deleteBy(
            @Param("tableName")String tableName,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    /**
     * 根据id列表批量删除
     * @param tableName 表名字
     * @param ids id列表
     * @return
     */
    public int deleteByIds(
            @Param("tableName")String tableName,
            @Param("ids")List<?> ids
            ); 

    /**
     * 根据指定列指定值删除多条记录
     * @param tableName 表名
     * @param whereName 条件列名
     * @param whereList 条件列值
     * @return
     */
    public int deleteByWhereList(
            @Param("tableName")String tableName,
            @Param("whereName") String whereName,
            @Param("whereList") List<?> whereList
            );

    // ------------------------ 修改SQL相关 ------------------------

    /**
     * 指定表的指定字段增加指定值，可以为负值
     * @param tableName 表名字
     * @param columnName 列值
     * @param num 增加的值
     * @param id id值
     * @return
     */
    public int columnAdd(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("num") long num,
            @Param("id") Object id
            );

    /**
     * 指定表的指定字段增加指定值，可以为负值
     * @param tableName 表名字
     * @param columnName 列名字
     * @param num 增加的值
     * @param ids id列表
     * @return
     */
    public int columnAddByIds(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("num") long num,
            @Param("ids") List<?> ids
            );

    /**
     * 指定表的指定字段更新为指定值,根据指定id
     * @param tableName 表名子
     * @param columnName 列名
     * @param value 值
     * @param id id值
     * @return
     */
    public int updateColumnById(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("value") Object value,
            @Param("id") Object id
            );

    /**
     * 指定表的指定字段更新为指定值,根据指定id列表
     * @param tableName 表名子
     * @param columnName 列名
     * @param value 值
     * @param ids id值
     * @return
     */
    public int updateColumnByIds(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("value") Object value,
            @Param("ids") List<?> ids
            );

    /**
     * 指定表的指定字段更新为指定值, 根据指定列的指定值
     * @param tableName 表名
     * @param columnName 列名
     * @param columnValue 列值
     * @param whereName 条件列名
     * @param whereValue 条件列值
     * @return
     */
    public int updateColumnBy(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("columnValue") Object columnValue,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    /**
     * 指定表的指定字段SoMap集合更新为指定值,根据指定id
     * @param tableName 表名
     * @param soMap 要修改的列
     * @param id id值
     * @return
     */
    public int updateBySoMapById(
            @Param("tableName") String tableName,
            @Param("soMap") SoMap soMap,
            @Param("id") Object id
            );

    /**
     * 指定表的指定字段SoMap集合更新为指定值,指定列的指定值
     * @param tableName 表名子
     * @param soMap 要修改的列
     * @param whereName 条件列值
     * @param whereValue 条件列值
     * @return
     */
    public int updateBySoMapBy(
            @Param("tableName") String tableName,
            @Param("soMap") SoMap soMap,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    // ------------------------ 查询SQL相关 ------------------------

    /**
     * 获取指定表的指定字段值,根据id值
     * @param tableName 表名
     * @param columnName 列名
     * @param id id值
     * @return
     */
    public String getColumnById(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("id") Object id
            );

    /**
     * 获取指定表的指定字段值,并转化为long,根据id值
     * @param tableName 表名
     * @param columnName 列名
     * @param id id值
     * @return
     */
    public long getColumnByIdToLong(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("id") Object id
            );

    /**
     * 获取指定表的指定字段值,根据指定条件(whereName=whereValue)
     * @param tableName 表名
     * @param columnName 列名
     * @param whereName 条件列名
     * @param whereValue 条件列值
     * @return
     */
    public String getColumnByWhere(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    /**
     * 获取指定表的指定字段值列表,并转化为long, 根据指定条件(whereName=whereValue)
     * @param tableName 表名
     * @param columnName 列名
     * @param whereName 条件列名
     * @param whereValue 条件列值
     * @return
     */
    public List<Long> getColumnListToLongByWhere(
            @Param("tableName") String tableName,
            @Param("columnName") String columnName,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    /**
     * 获取指定表的count数据,根据指定条件(whereName=whereValue)
     * @param tableName 表名
     * @param whereName 条件列名
     * @param whereValue 条件列值
     * @return
     */
    public long getCountBy(
            @Param("tableName") String tableName,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
    );

    // ------------------------ 查询集合SQL相关 ------------------------

    /**
     * 获取指定表的全部字段全部数据转化为Map
     * @param tableName 表名子
     * @return
     */
    public List<SoMap> getListMap(@Param("tableName") String tableName);

    /**
     * 获取指定表的全部字段全部数据转化为Map, 根据指定条件(whereName=whereValue)
     * @param tableName 表名字
     * @param whereName 条件列名
     * @param whereValue 条件列值
     * @return
     */
    public List<SoMap> getListMapByWhere(
            @Param("tableName") String tableName,
            @Param("whereName") String whereName,
            @Param("whereValue") Object whereValue
            );

    /**
     * 获取指定表的全部字段全部数据转化为Map, 根据指定条件(id=id)
     * @param tableName 表名子
     * @param id id值
     * @return
     */
    public List<SoMap> getListMapById(
            @Param("tableName") String tableName,
            @Param("id") Object id
            );

}

<?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.pj.project4sp.public4mapper.PublicMapper">

    <!-- ======================== 一些工具方法 ======================== -->

    <!-- 返回上一句SQL插入的自增主键值 -->
    <select id="getPrimarykey" resultType="long">
        SELECT @@identity
    </select>

    <!-- ======================== 新增SQL相关 ======================== -->

    <!-- ======================== 删除SQL相关 ======================== -->

    <!-- 删除一条记录，指定表名，id -->
    <delete id="deleteById">
        delete from ${tableName} where id = #{id}
    </delete>

    <!-- 根据指定列指定值删除一条记录，// 参数: 表名、条件列表、条件列值  -->
    <delete id="deleteBy">
        delete from ${tableName} where ${whereName} = #{whereValue}
    </delete>

    <!-- 删除一条记录，指定表名，id列表 -->
    <delete id="deleteByIds">
        delete from ${tableName}
        where id in
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </delete>

    <!-- 根据指定列指定值删除多条记录  -->
    <delete id="deleteByWhereList">
        delete from ${tableName}
        where ${whereName} in
        <foreach collection="whereList" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </delete>

    <!-- ======================== 修改SQL相关 ======================== -->

    <!-- 指定表的指定字段加num（可以小于0 ）,根据指定id -->
    <update id="columnAdd">
        update ${tableName} set
        ${columnName} = IFNULL(${columnName}, 0) + #{num}
        where id = #{id};
    </update>

    <!-- 指定表的指定字段增加指定值，可以为负值  -->
    <update id="columnAddByIds">
        update ${tableName} set
        ${columnName} = ${columnName} + #{num}
        where id in
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </update>

    <!-- 指定表的指定字段更新为指定值,根据指定id -->
    <update id="updateColumnById">
        update ${tableName} set
        ${columnName} = #{value}
        where id = #{id}
    </update>

    <!-- 指定表的指定字段更新为指定值,根据指定id列表 -->
    <update id="updateColumnByIds">
        update ${tableName} set
        ${columnName} = #{value}
        where id in
        <foreach collection="ids" item="id" open="(" separator="," close=")">
            #{id}
        </foreach>
    </update>

    <!-- 指定表的指定字段更新为指定值, 根据指定列的指定值 -->
    <update id="updateColumnBy">
        update ${tableName} set
        ${columnName} = #{columnValue}
        where ${whereName} = #{whereValue}
    </update>

    <!-- 指定表的指定字段SoMap集合更新为指定值,根据指定id   -->
    <update id="updateBySoMapById">
        update ${tableName} set
        <foreach collection="soMap.entrySet()" item="value"  index="key" separator=",">
            ${key} = #{value}
        </foreach>
        where id = #{id}
    </update>

    <!-- 指定表的指定字段SoMap集合更新为指定值,根据指定id   -->
    <update id="updateBySoMapBy">
        update ${tableName} set
        <foreach collection="soMap.entrySet()" item="value"  index="key" separator=",">
            ${key} = #{value}
        </foreach>
        where ${whereName} = #{whereValue}
    </update>

    <!-- ======================== 查询SQL相关 ======================== -->

    <!-- 获取指定表的指定字段值,根据id值 -->
    <select id="getColumnById" resultType="String">
        select ${columnName} from ${tableName}
        where id = #{id}
    </select>

    <!-- 获取指定表的指定字段值,并转化为long,根据id值  -->
    <select id="getColumnByIdToLong" resultType="long">
        select ${columnName} from ${tableName}
        where id = #{id}
    </select>

    <!-- 获取指定表的指定字段值,根据指定条件(whereName=whereValue) -->
    <select id="getColumnByWhere" resultType="String">
        select ${columnName} from ${tableName}
        where ${whereName} = #{whereValue}
    </select>

    <!-- 获取指定表的指定字段值列表,并转化为long, 根据指定条件(whereName=whereValue) -->
    <select id="getColumnListToLongByWhere" resultType="long">
        select ${columnName} from ${tableName}
        where ${whereName} = #{whereValue}
    </select>

    <!-- 获取指定表的count数据,根据指定条件(whereName=whereValue) -->
    <select id="getCountBy" resultType="long">
        select count(*) from ${tableName}
        where ${whereName} = #{whereValue}
    </select>

    <!-- ======================== 查询集合SQL相关 ======================== -->

    <!-- 获取指定表的全部字段全部数据 -->
    <select id="getListMap" resultType="somap">
        select * from ${tableName}
    </select>

    <!-- 获取指定表的全部字段全部数据转化为Map, 根据指定条件(whereName=whereValue) -->
    <select id="getListMapByWhere" resultType="somap">
        select * from ${tableName}
        where ${whereName} = #{whereValue}
    </select>

    <!-- 获取指定表的全部字段全部数据转化为Map, 根据指定条件(id=id) -->
    <select id="getListMapById" resultType="somap">
        select * from ${tableName}
        where id = #{id}
    </select>

</mapper>