基于tkmybatis写通用的统计接口

最新推荐文章于 2023-12-09 00:53:37 发布
最新推荐文章于 2023-12-09 00:53:37 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 后端 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29648139/article/details/118342129
版权

上一篇博客我们已经了解到了基于tkmybatis封装常用的增删改查接口【链接地址】，接下来我们来讲一下怎么封装通用的统计接口。

1 MyDefineGroupByMapper

import org.apache.ibatis.annotations.SelectProvider;
import tk.mybatis.mapper.annotation.RegisterMapper;
import tk.mybatis.mapper.entity.GroupByExample;
import tk.mybatis.mapper.provider.MyDefineGroupByProvider;

import java.util.List;
import java.util.Map;

/**
 * @description:
 * @author:wanzh
 * @date:2021/6/29
 */
@RegisterMapper
public interface MyDefineGroupByMapper<T> {

    @SelectProvider(type = MyDefineGroupByProvider.class, method = "dynamicSQL")
    List<Map<String,Object>> selectGroupByExample(GroupByExample example);
}

2 MyDefineGroupByProvider

import org.apache.ibatis.mapping.MappedStatement;
import tk.mybatis.mapper.mapperhelper.GroupBySqlHelper;
import tk.mybatis.mapper.mapperhelper.MapperHelper;
import tk.mybatis.mapper.mapperhelper.MapperTemplate;
import tk.mybatis.mapper.mapperhelper.SqlHelper;

/**
 * @description:
 * @author:wanzh
 * @date:2021/6/29
 */
public class MyDefineGroupByProvider extends MapperTemplate {
    public MyDefineGroupByProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }
    public String selectGroupByExample(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        setResultType(ms, entityClass);
        //开始拼sql
        StringBuilder sql = new StringBuilder("SELECT ");
        sql.append(GroupBySqlHelper.getGroupByColumns(entityClass));
        sql.append(SqlHelper.fromTable(entityClass, tableName(entityClass)));
        sql.append(SqlHelper.exampleWhereClause());
        sql.append(GroupBySqlHelper.getGroupBy());
        sql.append(SqlHelper.exampleOrderBy(entityClass));
        sql.append(SqlHelper.exampleForUpdate());
        return sql.toString();
    }

    @Override
    protected void setResultType(MappedStatement ms, Class<?> entityClass) {
        //一定要重写该方法，不然会返回当前实体类所有字段
    }
}

3 GroupBySqlHelper

/**
 * @description:
 * @author:wanzh
 * @date:2021/6/28
 */
public class GroupBySqlHelper {

    public static String getGroupByColumns(Class<?> entityClass){
        StringBuilder sb = new StringBuilder();
        sb.append("<choose>");
        sb.append("<when test=\"_parameter.selectedColumns != null \">");
        sb.append("${_parameter.selectedColumns}");
        sb.append("</when>");
        sb.append("<otherwise>");
        sb.append(SqlHelper.exampleSelectColumns(entityClass));
        sb.append("</otherwise>");
        sb.append("</choose>");
        return sb.toString();
    }

    public static String getGroupBy(){
        StringBuilder sb = new StringBuilder();
        sb.append("<if test=\"_parameter.groupByClause != null \">");
        sb.append(" GROUP BY ${_parameter.groupByClause}");
        sb.append("</if>");
        return sb.toString();
    }
}

4 GroupByExample

public class GroupByExample extends Example {

    private String groupByClause;

    private String selectedColumns;

    public GroupByExample(Class<?> entityClass) {
        super(entityClass);
    }

    public GroupByExample(Class<?> entityClass, boolean exists) {
        super(entityClass, exists);
    }

    public GroupByExample(Class<?> entityClass, boolean exists, boolean notNull) {
        super(entityClass, exists, notNull);
    }

    public String getGroupByClause() {
        return groupByClause;
    }

    public String getSelectedColumns() {
        return selectedColumns;
    }

    public void setSelectedColumns(String selectedColumns) {
        this.selectedColumns = selectedColumns;
    }

    public void setGroupByClause(String groupByClause) {
        this.groupByClause = groupByClause;
    }
}

5 RequestParamUtils

public class RequestParamUtils {

    private static final String FIELD_SPILT = "_";
    private static final String SQL_LIKE_CONTACT_STR = "%";
    private static final String REQUEST_PARAM_ERROR = "请求参数格式无效";

    /**
     * 处理请求参数
     * @param obj
     * @return
     */
    public static GroupByExample handlerGroupRequestParam(Object obj) {
        Map<String, String> propertyMap = EntityHelper.getColumns(obj.getClass()).stream().collect(Collectors.toMap(EntityColumn::getProperty, EntityColumn::getColumn));
        GroupByExample example = new GroupByExample(obj.getClass());
        GroupByExample.Criteria criteria = example.createCriteria();
        HttpServletRequest request =
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Map<String, String[]> parameterMap = new HashMap(request.getParameterMap());
        String[] orders = parameterMap.remove("sortField");
        String[] isDesc = parameterMap.remove("isDesc");
        String[] groupFields = parameterMap.remove("groupByField");
        String[] groupSelectFields = parameterMap.remove("groupSelectField");

        boolean flag = false;
        for (Iterator iter = parameterMap.entrySet().iterator(); iter.hasNext();) {
            Map.Entry element = (Map.Entry) iter.next();
            String key = String.valueOf(element.getKey());
            String[] values = (String[])element.getValue();
            if(key.contains(FIELD_SPILT) &&  handlerRequestParam(key, values, criteria)){
                flag = true;
            }
        }
        if(!flag){
            example = new GroupByExample(obj.getClass());
        }
        orderRequestParam(example, orders, isDesc);
        groupRequestParam(example, groupFields, groupSelectFields,propertyMap);
        return example;
    }
    public static void orderRequestParam(Example example,String[] orderArr,String[] isDescArr){
        int len = isDescArr == null ? 0 : isDescArr.length;
        if(orderArr != null){
            for(int i = 0; i < orderArr.length; i++){
                Boolean isDesc = Boolean.parseBoolean(i < len ? isDescArr[i] : "false");
                if(isDesc){
                    example.orderBy(orderArr[i]).desc();
                }else{
                    example.orderBy(orderArr[i]).asc();

                }
            }
        }
    }

    private static void groupRequestParam(GroupByExample example, String[] groupFields, String[] groupSelectFields, Map<String, String> propertyMap) {
        if(groupFields == null || groupFields.length == 0){
            throw new BaseException("统计字段不能为空");
        }
        List<String> fieldList = new ArrayList<>();
        StringBuilder groupByClauseSb = new StringBuilder();
        StringBuilder groupByFieldSb = new StringBuilder();
        for(String str : groupFields){
            if(!propertyMap.containsKey(str)){
                throw new BaseException("当前实体类不包含此属性:"+str);
            }
            fieldList.add(propertyMap.get(str));
            groupByClauseSb.append(","+propertyMap.get(str));
            groupByFieldSb.append(","+propertyMap.get(str)+" AS "+str);
        }
        example.setGroupByClause(groupByClauseSb.toString().substring(1));
        if(groupSelectFields != null && groupSelectFields.length > 0){
            for(int i = 0; i < groupSelectFields.length; i++){
                String groupSelectField = groupSelectFields[i];
                String[] split = groupSelectField.split(FIELD_SPILT);
                if(split.length < 2){
                    throw new BaseException("存在不合法的统计字段:"+groupSelectField);
                }
                String property = split[0];
                if(!propertyMap.containsKey(property)){
                    throw new BaseException("当前实体类不包含此属性:"+property);
                }
                String type = split[1];
                GroupType instance = GroupType.getInstance(type);
                if(instance == null){
                    throw new BaseException("存在不合法的统计字段:"+groupSelectField);
                }
                if(split.length == 3){
                    groupByFieldSb.append(","+type+"("+propertyMap.get(property)+") as "+ split[2]);
                }else{
                    groupByFieldSb.append(","+type+"("+propertyMap.get(property)+") as "+ type.toLowerCase());
                }
            }
        }
        example.setSelectedColumns(groupByFieldSb.toString().substring(1));

    }

    /**
     * 处理请求参数
     * @param obj
     * @return
     */
    public static Example handlerRequestParam(Object obj) {
        Example example = new Example(obj.getClass());
        Example.Criteria criteria = example.createCriteria();
        HttpServletRequest request =
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Map<String, String[]> parameterMap = new HashMap(request.getParameterMap());
        String[] orders = parameterMap.remove("sortField");
        String[] isDescs= parameterMap.remove("isDesc");
        boolean flag = false;
        for (Iterator iter = parameterMap.entrySet().iterator(); iter.hasNext();) {
            Map.Entry element = (Map.Entry) iter.next();
            String key = String.valueOf(element.getKey());
            String[] values = (String[])element.getValue();
            if(key.contains(FIELD_SPILT) &&  handlerRequestParam(key, values, criteria)){
                flag = true;
            }
        }
        if(!flag){
            example = new Example(obj.getClass());
        }
        orderRequestParam(example, orders, isDescs);
        return example;
    }

  

    private static boolean handlerRequestParam(String key, String[] values,Example.Criteria criteria){
        try {
            int index = key.lastIndexOf(FIELD_SPILT);
            String field = key.substring(0,index);
            String opVal = key.substring(index + 1);
            int size = criteria.getCriteria().size();
            if(opVal.length() > 1){
                String type = opVal.substring(0, 1);
                opVal = opVal.substring(1);
                QueryOP queryOP = QueryOP.getByVal(opVal);
                Optional<List<String>> lists = Optional.ofNullable(queryOP)
                        .map(QueryOP::supports)
                        .map(Arrays::asList);
                if(lists.isPresent() && lists.get().contains(type)){
                    if(queryOP != QueryOP.IS_NULL && queryOP != QueryOP.NOTNULL){
                        if(!isNotNull(values)){
                            return false;
                        }
                    }
                    switch (queryOP){
                        case EQUAL:
                           criteria.andEqualTo(field, getValue(values[0], type));
                            break;
                        case NOT_EQUAL:
                           criteria.andNotEqualTo(field, getValue(values[0], type));
                            break;
                        case LESS:
                           criteria.andLessThan(field, getValue(values[0], type));
                            break;
                        case GREAT:
                            criteria.andGreaterThan(field, getValue(values[0], type));
                            break;
                        case LESS_EQUAL:
                            criteria.andLessThanOrEqualTo(field, getValue(values[0], type));
                            break;
                        case GREAT_EQUAL:
                            criteria.andGreaterThanOrEqualTo(field, getValue(values[0], type));
                            break;
                        case LIKE:
                            criteria.andLike(field,SQL_LIKE_CONTACT_STR+getValue(values[0], type)+SQL_LIKE_CONTACT_STR);
                            break;
                        case LEFT_LIKE:
                           criteria.andLike(field,SQL_LIKE_CONTACT_STR+getValue(values[0], type));
                            break;
                        case RIGHT_LIKE:
                           criteria.andLike(field,getValue(values[0], type)+SQL_LIKE_CONTACT_STR);
                            break;
                        case IS_NULL:
                            criteria.andIsNull(field);
                            break;
                        case NOTNULL:
                            criteria.andIsNull(field);
                            break;
                        case IN:
                           criteria.andIn(field,getValues(values,type));
                            break;
                        case NOT_IN:
                           criteria.andNotIn(field,getValues(values,type));
                            break;
                        case BETWEEN:
                            criteria.andBetween(field, getValue(values[0], type), getValue(values[1], type));
                            break;
                        case NOT_BETWEEN:
                           criteria.andNotBetween(field, getValue(values[0], type), getValue(values[1], type));
                            break;
                        case JSONB_EXIST:
                            criteria.andJSONExist(field,getValue(values[0], type));
                             break;
                        default:
                    }

                }
            }
            return  criteria.getCriteria().size() > size;
        }catch (Exception e){
            log.error(REQUEST_PARAM_ERROR,e);
            return false;
        }
    }


    private static Object getValue(String val , String type){
        switch (type){
            case "N":
                return Long.parseLong(val);
            case "D":
                return DateUtil.parse(val).toJdkDate();
            case "B":
                return Boolean.parseBoolean(val);

        }
        return val;
    }

    private static List getValues(String[] values , String type){
        List list = new ArrayList();
        for(String str : values){
            list.add(getValue(str, type));
        }

        return list;
    }

    public static boolean isNotNull(String[] values){
        if(values == null || values.length == 0 || (values.length == 1 && values[0].equals(""))){
            return false;
        }
        return true;
    }
}

7 BaseController

//在BaseController新增方法，BaseController参考上篇文章
@PostMapping("/findGroupByExample")
	public RestResponse<List> findGroupByExample(T t) {
		GroupByExample example = handlerGroupRequestParam(t);
		List<Map<String,Object>> list = baseService.findGroupByExample(example);
		return RestResponse.buildSuccessData(list);
	}

8. TestController

@RestController
public class TestController {



    @Autowired
    private TaskWorkOrderMapper taskWorkOrderMapper;




    @PostMapping("testGroupBy")
    public RestResponse testGroupBy(TaskWorkOrder taskWorkOrder){
        GroupByExample example = RequestParamUtils.handlerGroupRequestParam(taskWorkOrder);
        List<Map<String,Object>> list = taskWorkOrderMapper.selectGroupByExample(example);
        return RestResponse.buildSuccessData(list);
    }

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9 GroupBy

public enum GroupType {
        COUNT,
        SUM,
        MAX,
        MIN;


    public static GroupType getInstance(String name){
        if(StringUtils.isEmpty(name)){
            return null;
        }
        GroupType[] values = values();
        for(GroupType val : values){
            if(val.name().equals(name)){
                return val;
            }
        }
        return  null;
    }
}
呆呆槑呆呆
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java用tkmapper分组查询_mybatis example group by count 分组求和 - java分组求和
weixin_33472998的博客
03-02 4265
一、简单说明本以为mybatis的example可以搞定group by，后面看到说不行于是曲线救国，直接查出一个list，然后再用java对数据进行操作不过话说回来，这样写是比写sql麻烦一点，但是个人感觉这样效率会高一点(未做对比测试)二、需求说明查出数据库中，过去30天，每个用户(merId)每天的发送条数改进版，在1的基础上，加上所有日期的统计信息，对应日期没记录也加上三、所用技术概要jo...
TK.mybatis使用详情
weixin_44992843的博客
11-09 1096
TkMybatis 什么是TKMybatis， TKMybatis是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql 即能完成单表操作 基本步骤 引入TkMybatis的Maven依赖 <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper</artifa.
【已解决】Mybatis 实现 Group By 动态分组查询
华仔仔的博客
08-29 7878
🎉工作中遇到这样一个需求场景：实现一个统计查询，要求可以根据用户在前端界面筛选的字段进行动态地分组统计。，可能是一个字段、多个字段或者不进行分组查询，这都是由用户在前端决定的。
java分组求和实例_mybatis example group by count 分组求和 - java分组求和
weixin_42515990的博客
02-25 3849
一、简单说明本以为mybatis的example可以搞定group by，后面看到说不行于是曲线救国，直接查出一个list，然后再用java对数据进行操作不过话说回来，这样写是比写sql麻烦一点，但是个人感觉这样效率会高一点(未做对比测试)二、需求说明查出数据库中，过去30天，每个用户(merId)每天的发送条数改进版，在1的基础上，加上所有日期的统计信息，对应日期没记录也加上三、所用技术概要jo...
实用编程技巧：MybatisPlus结合groupby实现分组和sum求和
乐于分享，共同成长
12-09 8056
实用编程技巧：MybatisPlus结合groupby实现分组和sum求和
tk.mybatis扩展通用接口使用详解
08-25
tk.mybatis 是一个基于 MyBatis 和 MyBatis-Plus 的扩展框架，它提供了一系列的工具类和注解，简化了日常的 CRUD 操作。在实际的项目开发中，特别是涉及到逻辑删除等特定业务需求时，tk.mybatis 提供的通用接口可能...
TkMybatis通用Mapper逆向工程代码生成工具
08-06
TkMybatis通用Mapper逆向工程代码生成工具是Java开发中的一个高效实用的工具，它基于Maven项目构建，主要用于简化数据库表与Java实体类、Mapper接口及XML映射文件之间的同步工作。通过此工具，开发者可以自动生成...
spring-boot+tk.mybatis通用mapper
08-25
tk.mybatis通用Mapper允许我们创建一个基础的Mapper接口，该接口继承自`tk.mybatis.mapper.common.Mapper<T>`，其中T代表实体类。通过这个接口，我们可以直接调用基本的CRUD方法，无需编写SQL语句。 5. **实体类和...
基于TkMyBatis的通用Mapper的二次封装 主要讲Id的生成策略
最新发布
02-02
修改源码涉及的步骤可能包括：理解TkMyBatis的源码结构，定位到ID生成相关的接口或类，如`tk.mybatis.mapper.common.Mapper`中的`insert`方法，然后实现自己的ID生成逻辑，并将其注入到Mapper接口中。 此外，项目还...
tkmybatis.rar
08-20
《SpringBoot整合TkMybatis：实现高效优雅的CRUD操作》 在当今的软件开发领域，SpringBoot以其轻量级、快速启动和丰富的生态成为Java开发者首选的微服务框架。而Mybatis作为一款优秀的持久层框架，因其灵活的SQL...
tk.mybatis - 使用 Example 类进行条件查询
业精于勤荒于嬉
07-22 4294
tk.mybatis 使用 Example 进行条件查询
【Mybatis】TKMybatis 介绍和使用
m0_67401499的博客
03-24 4094
目录 一、什么是 TKMybatis 二、TKMybatis 使用 2.1 Springboot 项目中加入依赖 2.2?使用讲解 2.2.1 实体类中使用 2.2.2 dao中使用 2.2.3 Service 层中使用 2.3 实际案例 2.3.1 dao 层使用 2.3.2 service 层使用 一、什么是 TKMybatis TKMybatis 是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql
tkmybatis详细教程（一篇就明白）
热门推荐
dgh112233的博客
05-28 5万+
tkmybatis 是对底层 sql 进行了抽象封装，不需要考虑 sql 怎么写，只需要按照逻辑思维，遵循 tkmybatis 的语法即可实现数据库操作。 本文适合对springboot项目结构有一定了解的读者。 本文的项目基础是一个demo项目（多模块的）。 1. 配置 1、添加 tkmybatis 的依赖 <dependency> <groupId>tk.mybatis</groupId>
Tk-Mybatis(通用mybatis)简单使用
m0_50677223的博客
08-25 2087
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Tk-Mybatis二、多条件查询操作 前言 使用Mybatis时，最大的问题是，要写大量的重复SQL语句在xml文件中，除了特殊的业务逻辑SQL语句之外，还有 大量结构类似的增删改查SQL。而且，当数据库表结构改动时，对应的所有SQL以及实体类都需要更改。这大量增 加了程序员的负担。避免重复书写CRUD映射的框架有两个 通用mybatis（tk mybatis） mybatis plus 一、Tk-Mybatis 1
TkMybatis用法总结
击水三千里的专栏
11-06 5176
自定义SQL写法 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; @Autowired protected NamedParameterJdbcTemplate namedJdbcTemplate; MapSqlParameterSource mapSqlParameterSourc...
tkmbatis 日志_TKmybatis的框架介绍及使用方法
weixin_35866747的博客
12-30 605
最近项目使用了SpringBoot+TKMytis框架，期间遇到一些问题，顺便记一下。一、框架配置配置的话非常简单，我用的是SpringBoot,直接引入：tk.mybatismapper-spring-boot-starter2.0.3-beta1tk.mybatismapper4.0.0Mybatis的以及分页插件等就不写了。创建一个BaseMapperpublic interface Bas...
tk-mybatis和mybatisplus使用和区别
weixin_44722237的博客
11-29 1万+
概念： 使用Mybatis时，最大的问题是，要写大量的重复SQL语句在xml文件中，除了特殊的业务逻辑SQL语句之外，还有 大量结构类似的增删改查SQL。而且，当数据库表结构改动时，对应的所有SQL以及实体类都需要更改。 这大量增 加了程序员的负担。避免重复书写CRUD映射的框架有两个 通用mybatis（tk mybatis） mybatis plus，通能更加强大 一.tk-mybatis的使用 1.tk-mybatis需要引入启动器，直接引入即可。 pom.xml中引入如下内容
MyBaties的SUM映射问题
游士的博客
06-20 4359
当我们根据类别进行统计，返回的数据类型为HashMap<String,Object>，获取数值类型，容易报java.math.BigDecimal cannot be cast to java.lang.Integer 场景如下： // Mapper层 <select id="selectInfoByTest" resultType="map"> SELECT...
TKMybatis 介绍
05-20
TKMybatis是一款基于Mybatis框架的增强工具，它提供了一系列的通用Mapper接口和通用Service接口，可以帮助开发者快速地进行数据持久化操作。 通用Mapper接口是一组基于Mybatis的Mapper接口的抽象化，可以通过简单的配置和继承来实现对单表的基本增删改查操作。通用Service接口则是基于通用Mapper接口的进一步封装，提供了常用的业务逻辑方法，如分页查询、批量插入、批量更新等，可以实现更加便捷的数据操作。 除此之外，TKMybatis还提供了一些常用的插件，如分页插件、乐观锁插件、逻辑删除插件等，可以帮助开发者快速解决一些常见的问题。 总之，TKMybatis是一款非常实用的Mybatis增强工具，可以大大提高开发效率和代码重用性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值