开发记录-排序

最新推荐文章于 2022-08-14 16:13:13 发布
最新推荐文章于 2022-08-14 16:13:13 发布
阅读量432 收藏
点赞数
分类专栏： 开发记录 文章标签： java 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b_x9520/article/details/119904715
版权

排序

针对查询出数据列表或树形结构数据后，对数据进行移动并更新移动后位置。还有很多优化空间，有更好的，可以分享下，共同进步。

1、列表排序

/**
     * 列表 排序方法
     * <p>
     * 适用范围,列表形式，操作一次 上移一位 或下一位
     *
     * @param primaryKeyValue         主键id数据
     * @param upDown                  上移或下移标识
     * @param andList                 where条件中name=key部分参数
     * @param classSortName           实体类中排序字段名称
     * @param databasesSortName       数据库中排序字段数据
     * @param classPrimaryKeyName     主实体类中键名称
     * @param databasesPrimaryKeyName 数据库中主键名称
     * @param clazz                   实体类class
     * @return 是否
     */
    public static boolean listSortUtil(Object primaryKeyValue, Integer upDown, List<Map<String, Object>> andList,
                                       String classSortName, String databasesSortName,
                                       String classPrimaryKeyName, String databasesPrimaryKeyName,
                                       Class<? extends Serializable> clazz) {
        //拼接 where 中过滤条件
        StringBuilder where = splicingWhere(andList);

        //获取Mapper
        BaseMapper baseMapper = getClassMapper(clazz);

        //根据主键id数据查询对应数据
        Object instance = baseMapper.selectByPrimaryKey(primaryKeyValue);
        if (null == instance) {
            Asserts.fail(ResultEnum.PARAM_ERROR.getCode(), "id有误");
        }
        //获取关键信息
        String keyObject = JSON.toJSONString(instance);
        JSONObject keyJsonObject = JSON.parseObject(keyObject);
        //排序序号数据
        Object sortValue = keyJsonObject.get(classSortName);

        //-1上移1位
        if (-1 == upDown) {
            //查询移动的数据的上一条数据
            Object instance1 = baseMapper.queryInfoByCondition(
                    where.append("and").append(" ").append(databasesSortName)
                            .append(" < '").append(sortValue)
                            .append("' ORDER BY").append(" ").append(databasesSortName).append(" ")
                            .append("DESC limit 0,1").toString());
            if (null == instance1) {
                Asserts.fail(ResultEnum.PARAM_ERROR.getCode(), "已是第一位");
            }
            String string = JSON.toJSONString(instance1);
            JSONObject jsonObject = JSON.parseObject(string);
            //上一条数据主键id数据
            Object primaryKeyValue1 = jsonObject.get(classPrimaryKeyName);
            //上一条数据排序序号数据
            Object sortValue1 = jsonObject.get(classSortName);
            //两条数据排序序号替换并更新
            Integer integer = baseMapper.updateInfoByKey(
                    "set " + databasesSortName + " = '" + sortValue + "' where " + databasesPrimaryKeyName + " = '" + primaryKeyValue1 + "'");
            if (null == integer || 0 == integer) {
                Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新失败");
            }
            Integer integer1 = baseMapper.updateInfoByKey(
                    "set " + databasesSortName + " = '" + sortValue1 + "' where " + databasesPrimaryKeyName + " = '" + primaryKeyValue + "'");
            if (null == integer1 || 0 == integer1) {
                Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新失败");
            }
        }
        //1下移1位
        if (1 == upDown) {
            //查询移动的数据的下一条数据
            Object instance1 = baseMapper.queryInfoByCondition(
                    where.append("and").append(" ").append(databasesSortName)
                            .append(" > '").append(sortValue)
                            .append("' ORDER BY").append(" ").append(databasesSortName).append(" ")
                            .append("ASC limit 0,1").toString());
            if (null == instance1) {
                Asserts.fail(ResultEnum.PARAM_ERROR.getCode(), "已是最后一位");
            }
            String string = JSON.toJSONString(instance1);
            JSONObject jsonObject = JSON.parseObject(string);
            //下一条数据主键id数据
            Object primaryKeyValue1 = jsonObject.get(classPrimaryKeyName);
            //下一条数据排序序号数据
            Object sortValue1 = jsonObject.get(classSortName);
            //两条数据排序序号替换并更新
            Integer integer = baseMapper.updateInfoByKey(
                    "set " + databasesSortName + " = '" + sortValue + "' where " + databasesPrimaryKeyName + " = '" + primaryKeyValue1 + "'");
            if (null == integer || 0 == integer) {
                Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新失败");
            }
            Integer integer1 = baseMapper.updateInfoByKey(
                    "set " + databasesSortName + " = '" + sortValue1 + "' where " + databasesPrimaryKeyName + " = '" + primaryKeyValue + "'");
            if (null == integer1 || 0 == integer1) {
                Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新失败");
            }
        }
        return true;
    }

2、树形排序

/**
     * 树形 排序方法
     * <p>
     * 适用范围，树形形式，可上下拖动，合并，插入
     *
     * @param sortDTO                    排序dto
     * @param classPidName               pid实体类名
     * @param databasesPidName           pid数据库名
     * @param classSortName              sort实体类名
     * @param databasesSortName          sort数据库名
     * @param classGradeName             层级深度实体类名
     * @param databasesGradeName         层级深度数据库名
     * @param classPrimaryKeyName        主键实体类名
     * @param databasesPrimaryKeyName    数据库实体类名
     * @param classAssociationIdName     关联id实体类名
     * @param databasesAssociationIdName 数据库关联id实体类名
     * @param clazz                      实体类class
     * @return 是否
     */
    public static boolean treeSortUtil(SortDTO sortDTO, String classPidName, String databasesPidName,
                                       String classSortName, String databasesSortName,
                                       String classGradeName, String databasesGradeName,
                                       String classPrimaryKeyName, String databasesPrimaryKeyName,
                                       String classAssociationIdName, String databasesAssociationIdName,
                                       Class<? extends Serializable> clazz) {
        BaseMapper baseMapper = getClassMapper(clazz);

        //移动数据主键id
        String keyId = sortDTO.getKeyId();
        //被移动数据主键id
        String keyId1 = sortDTO.getMoveKeyId();
        //根据主键id数据查询对应数据
        Object instance = baseMapper.selectByPrimaryKey(keyId);
        if (null == instance) {
            Asserts.fail(ResultEnum.PARAM_ERROR.getCode(), "id有误");
        }
        //获取关键信息
        String keyObject = JSON.toJSONString(instance);
        JSONObject keyJsonObject = JSON.parseObject(keyObject);
        //排序序号数据
        Object sortValue = keyJsonObject.get(classSortName);
        Object pidValue = keyJsonObject.get(classPidName);

        Object instance1 = baseMapper.selectByPrimaryKey(keyId1);
        if (null == instance1) {
            Asserts.fail(ResultEnum.PARAM_ERROR.getCode(), "id有误");
        }
        //获取关键信息
        String keyObject1 = JSON.toJSONString(instance1);
        JSONObject keyJsonObject1 = JSON.parseObject(keyObject1);
        //排序序号数据
        Object sortValue1 = keyJsonObject1.get(classSortName);
        Object pidValue1 = keyJsonObject1.get(classPidName);

        //是否合并
        Boolean isNotMerge = sortDTO.getIsNotMerge();

        //关联id
        String associationId1 = null;
        if (null != classAssociationIdName) {
            associationId1 = (String) keyJsonObject1.get(classAssociationIdName);
        }

        //跨层级移动
        int grade = 0;
        int grade1 = 0;
        if (null != classGradeName) {
            grade = (int) keyJsonObject.get(classGradeName);
            grade1 = (int) keyJsonObject1.get(classGradeName);
        }
        //判断是否是跨层移动
        if (pidValue.equals(pidValue1) && !isNotMerge) {
            //同层级移动
            //是否插入数据
            Boolean isInsert = sortDTO.getIsInsert();
            if (null != isInsert && isInsert) {
                String sortSql = "where " + databasesPidName + " = '" + pidValue1 + "'";
                if (null != databasesAssociationIdName) {
                    sortSql = sortSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                Integer maxSort = baseMapper.queryMaxSortByCondition(sortSql);
                if (null == maxSort) {
                    maxSort = 0;
                }
                sortValue = maxSort + 1;

                String sql = "set " + databasesSortName + " = '" + sortValue + "'";
                if (null != databasesGradeName) {
                    sql = sql + " , " + databasesGradeName + " = '" + grade1 + "'";
                }
                if (null != databasesAssociationIdName) {
                    sql = sql + " , " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                sql = sql + " where " + databasesPrimaryKeyName + " = '" + keyId + "'";

                Integer integer = baseMapper.updateInfoByKey(sql);
                if (null == integer || 0 == integer) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "插入数据失败");
                }

                if (null != classGradeName) {
                    //移动数据中 下一层数据 深度是否需要调整
                    //需调整 查询数据 递归
                    recursionNodeGrade(clazz, baseMapper, classPidName, keyId, classAssociationIdName, associationId1,
                            classPrimaryKeyName, databasesPrimaryKeyName, databasesGradeName, grade1);
                }
            }
            //移动行 上移
            if ((int) sortValue > (int) sortValue1) {
                String upSql = "where " + databasesPidName + " = '" + pidValue + "'";
                if (null != databasesAssociationIdName) {
                    upSql = upSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                upSql = upSql + " and " + databasesSortName + " between '" + sortValue1 + "' and '" + ((int) sortValue - 1) + "'";
                //列表数据被下移
                Integer i = baseMapper.updateDownSortByCondition(upSql);
                if (null == i || 0 == i) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "原列表数据移动失败");
                }
            }
            //移动行 下移
            if ((int) sortValue < (int) sortValue1) {
                String downSql = "where " + databasesPidName + " = '" + pidValue + "'";
                if (null != databasesAssociationIdName) {
                    downSql = downSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                downSql = downSql + " and " + databasesSortName + " between '" + ((int) sortValue + 1) + "' and '" + sortValue1 + "'";
                //列表数据被上移
                Integer i = baseMapper.updateUpSortByCondition(downSql);
                if (null == i || 0 == i) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "原列表数据移动失败");
                }
            }
            int i = baseMapper.updateInfoByKey(
                    " set " + databasesSortName + " = '" + sortValue1 +
                            "' where " + databasesPrimaryKeyName + " = '" + keyId + "'");
            if (i == 0) {
                Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新移动数据移动失败");
            }
        } else {
            //判断是否合并
            if (isNotMerge) {
                //合并 移动数据放在最后一位
                Integer maxSort = baseMapper.queryMaxSortByCondition("where " + databasesPidName + " = '" + keyId1 + "'");
                if (null == maxSort) {
                    maxSort = 0;
                }
                String sql = "set " + databasesPidName + " = '" + keyId1 + "' , ";
                if (null != databasesGradeName) {
                    sql = sql + databasesGradeName + " = '" + (grade1 + 1) + "' , ";
                }
                sql = sql + databasesSortName + " = '" + (maxSort + 1) + "' where " + databasesPrimaryKeyName + " = '" + keyId + "'";

                int i = baseMapper.updateInfoByKey(sql);
                if (i == 0) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新移动数据移动失败");
                }
                if (null != classGradeName) {
                    //移动数据中 下一层数据 深度是否需要调整
                    if (grade != (grade1 + 1)) {
                        //需调整 查询数据 递归
                        recursionNodeGrade(clazz, baseMapper, classPidName, keyId, classAssociationIdName, associationId1,
                                classPrimaryKeyName, databasesPrimaryKeyName, databasesGradeName, grade1 + 1);
                    }
                }
                String upSql = "where " + databasesPidName + " = '" + pidValue + "'";
                if (null != databasesAssociationIdName) {
                    upSql = upSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                upSql = upSql + " and " + databasesSortName + " >= '" + sortValue + "'";
                //移动数据原列表 排序序号调整 上移
                baseMapper.updateUpSortByCondition(upSql);
            } else {
                //不合并
                //更新被移动数据列表 排序序号调整 下移
                String downSql = "where " + databasesPidName + " = '" + pidValue1 + "'";
                if (null != databasesAssociationIdName) {
                    downSql = downSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                downSql = downSql + " and " + databasesSortName + " >= '" + sortValue1 + "'";

                Integer down = baseMapper.updateDownSortByCondition(downSql);
                if (null == down || 0 == down) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新移动数据移动失败");
                }
                //更新移动数据信息
                String sql = "set " + databasesPidName + " ='" + pidValue1 + "' , "
                        + databasesSortName + " = '" + sortValue1 + "'";
                if (null != databasesGradeName) {
                    sql = sql + " , " + databasesGradeName + " = '" + grade1 + "'";
                }
                sql = sql + " where " + databasesPrimaryKeyName + " = '" + keyId + "'";
                int j = baseMapper.updateInfoByKey(sql);
                if (j == 0) {
                    Asserts.fail(ResultEnum.RESULT_ERROR.getCode(), "更新移动数据失败");
                }
                if (null != classGradeName) {
                    //移动数据中 下一层数据 深度是否需要调整
                    if (grade != grade1) {
                        //需调整 查询数据 递归
                        recursionNodeGrade(clazz, baseMapper, classPidName, keyId, classAssociationIdName, associationId1,
                                classPrimaryKeyName, databasesPrimaryKeyName, databasesGradeName, grade1);
                    }
                }

                String upSql = "where " + databasesPidName + " = '" + pidValue + "'";
                if (null != databasesAssociationIdName) {
                    upSql = upSql + " and " + databasesAssociationIdName + " = '" + associationId1 + "'";
                }
                upSql = upSql + " and " + databasesSortName + " >= '" + sortValue + "'";
                //移动数据原列表 排序序号调整 上移
                baseMapper.updateUpSortByCondition(upSql);
            }
        }
        return true;
    }

总体代码

import *.SortDTO;
import *.Asserts;
import *.BaseMapper;
import *.ResultEnum;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import tk.mybatis.mapper.entity.Example;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

/**
 * @Author: byxu
 * @DATE: 2021/6/28 15:42
 * <p>
 * 排序方法
 */
@Component
public class SortUtils implements ApplicationContextAware {
    /**
     * 获取mapper
     */
    private static ApplicationContext applicationContext;

    /**
     * 列表 排序方法
     * <p>
     * 适用范围,列表形式，操作一次 上移一位 或下一位
     *
     * @param primaryKeyValue         主键id数据
     * @param upDown                  上移或下移标识
     * @param andList                 where条件中name=key部分参数
     * @param classSortName           实体类中排序字段名称
     * @param databasesSortName       数据库中排序字段数据
     * @param classPrimaryKeyName     主实体类中键名称
     * @param databasesPrimaryKeyName 数据库中主键名称
     * @param clazz                   实体类class
     * @return 是否
     */
    public static boolean listSortUtil(Object primaryKeyValue, Integer upDown, List<Map<String, Object>> andList,
                                       String classSortName, String databasesSortName,
                                       String classPrimaryKeyName, String databasesPrimaryKeyName,
                                       Class<? extends Serializable> clazz) {
                                       代码在上部分
        return true;
    }

    /**
     * 树形 排序方法
     * <p>
     * 适用范围，树形形式，可上下拖动，合并，插入
     *
     * @param sortDTO                    排序dto
     * @param classPidName               pid实体类名
     * @param databasesPidName           pid数据库名
     * @param classSortName              sort实体类名
     * @param databasesSortName          sort数据库名
     * @param classGradeName             层级深度实体类名
     * @param databasesGradeName         层级深度数据库名
     * @param classPrimaryKeyName        主键实体类名
     * @param databasesPrimaryKeyName    数据库实体类名
     * @param classAssociationIdName     关联id实体类名
     * @param databasesAssociationIdName 数据库关联id实体类名
     * @param clazz                      实体类class
     * @return 是否
     */
    public static boolean treeSortUtil(SortDTO sortDTO, String classPidName, String databasesPidName,
                                       String classSortName, String databasesSortName,
                                       String classGradeName, String databasesGradeName,
                                       String classPrimaryKeyName, String databasesPrimaryKeyName,
                                       String classAssociationIdName, String databasesAssociationIdName,
                                       Class<? extends Serializable> clazz) {
                                       代码在上部分
        return true;
    }

    /**
     * 递归 修改各层级深度值
     *
     * @param clazz                   实体类class
     * @param classPidName            pid实体类名
     * @param keyId                   主键id
     * @param baseMapper              mapper
     * @param classPrimaryKeyName     实体类主键名称
     * @param databasesPrimaryKeyName 数据库主键名称
     * @param databasesGradeName      数据库深度主键名称
     * @param grade                   深度
     */
    private static void recursionNodeGrade(Class<? extends Serializable> clazz, BaseMapper baseMapper,
                                           String classPidName, Object keyId,
                                           String classAssociationIdName, String associationId,
                                           String classPrimaryKeyName, String databasesPrimaryKeyName,
                                           String databasesGradeName, int grade) {

        baseMapper.updateInfoByKey("set " + databasesGradeName + " = " + grade +
                " where " + databasesPrimaryKeyName + " = '" + keyId + "'");

        Example example = new Example(clazz);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo(classPidName, keyId);
        if (null != classAssociationIdName) {
            criteria.andEqualTo(classAssociationIdName, associationId);
        }
        List list = baseMapper.selectByExample(example);
        if (0 == list.size()) {
            return;
        }
        for (Object object : list) {
            //获取关键信息
            String keyObject1 = JSON.toJSONString(object);
            JSONObject keyJsonObject1 = JSON.parseObject(keyObject1);
            //主键id
            Object primaryKey = keyJsonObject1.get(classPrimaryKeyName);
            recursionNodeGrade(clazz, baseMapper, classPidName, primaryKey, classAssociationIdName, associationId,
                    classPrimaryKeyName, databasesPrimaryKeyName, databasesGradeName, grade + 1);
        }
    }

    /**
     * 拼接 where 中过滤条件
     *
     * @param andList 条件集合 key=value
     * @return where条件
     */
    private static StringBuilder splicingWhere(List<Map<String, Object>> andList) {
        StringBuilder where = new StringBuilder("where 1 = 1 ");
        for (Map<String, Object> map : andList) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                where.append(" ")
                        .append("and").append(" ").append(key).append(" ")
                        .append("=").append(" ").append("'").append(value).append("'").append(" ");
            }
        }
        return where;
    }

    /**
     * 获取对应实体类的Mapper
     *
     * @param clazz 实体类class
     * @return mapper
     */
    private static BaseMapper getClassMapper(Class<? extends Serializable> clazz) {
        String simpleClassName = clazz.getSimpleName();
        String mapperName = StrUtil.lowerFirst(simpleClassName) + "Mapper";
        BaseMapper baseMapper = null;
        try {
            baseMapper = (BaseMapper) applicationContext.getBean(mapperName);
        } catch (Exception e) {
            Asserts.fail("没有获取到" + clazz.getSimpleName() + "相应的mapper");
        }
        return baseMapper;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SortUtils.applicationContext = applicationContext;
    }
}

其他部分

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
@Data
@ApiModel("树形 排序DTO")
public class SortDTO {

    @ApiModelProperty(value = "是否插入(默认false)")
    private Boolean isInsert;

    @ApiModelProperty(value = "是否合并(默认false)", required = true)
    @NotNull
    private Boolean isNotMerge;

    @ApiModelProperty(value = "当前主键id", required = true)
    @NotEmpty
    private String keyId;

    @ApiModelProperty(value = "被移动主键id", required = true)
    @NotEmpty
    private String moveKeyId;
}

import cn.gydata.smartBidDoc.result.ResultEnum;
public class Asserts {
    public static void fail(String message) {
        throw new ApiException(message);
    }

    public static void fail(ResultEnum resultEnum) {
        throw new ApiException(resultEnum.getCode(), resultEnum.getMsg());
    }

    public static void fail(Integer code, String message) {
        throw new ApiException(code, message);
    }
}

import *.MyQueryMapper;
import *.MyUpdateMapper;
import tk.mybatis.mapper.common.ConditionMapper;
import tk.mybatis.mapper.common.IdsMapper;
import tk.mybatis.mapper.common.Mapper;
public interface BaseMapper<T> extends Mapper<T>, IdsMapper<T>, ConditionMapper<T>,
        MyQueryMapper<T>, MyUpdateMapper<T> {
}

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.SelectProvider;
import tk.mybatis.mapper.annotation.RegisterMapper;
@RegisterMapper
public interface MyQueryMapper<T> {

    /**
     * 根据条件查询sort 最大值
     *
     * @param value 条件
     * @return 最大值
     */
    @SelectProvider(type = MyQueryProvider.class, method = "dynamicSQL")
    Integer queryMaxSortByCondition(@Param("value") String value);


    /**
     * 根据自定义条件查询数据，查询数据
     *
     * @param value 条件
     * @return 数据
     */
    @SelectProvider(type = MyQueryProvider.class, method = "dynamicSQL")
    T queryInfoByCondition(@Param("value") String value);
}

import org.apache.ibatis.mapping.MappedStatement;
import tk.mybatis.mapper.mapperhelper.MapperHelper;
import tk.mybatis.mapper.mapperhelper.MapperTemplate;
import tk.mybatis.mapper.mapperhelper.SqlHelper;
public class MyQueryProvider extends MapperTemplate {

    public MyQueryProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }

    /**
     * 根据条件查询sort 最大值
     *
     * @param ms
     * @return
     */
    public String queryMaxSortByCondition(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        sql.append("SELECT ");
        sql.append("MAX(sort)");
        sql.append(SqlHelper.fromTable(entityClass, tableName(entityClass)));
        sql.append("${value}");
        return sql.toString();
    }

    /**
     * 根据自定义条件查询数据
     *
     * @param ms
     * @return
     */
    public String queryInfoByCondition(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        setResultType(ms, entityClass);
        StringBuilder sql = new StringBuilder();
        sql.append(SqlHelper.selectAllColumns(entityClass));
        sql.append(SqlHelper.fromTable(entityClass, tableName(entityClass)));
        sql.append("${value}");
        return sql.toString();
    }
}

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.UpdateProvider;
import tk.mybatis.mapper.annotation.RegisterMapper;
@RegisterMapper
public interface MyUpdateMapper<T> {

    /**
     * 根据条件更新sort值
     * 上移一位
     *
     * @param value 条件
     * @return 条数
     */
    @UpdateProvider(type = MyUpdateProvider.class, method = "dynamicSQL")
    Integer updateUpSortByCondition(@Param("value") String value);

    /**
     * 根据条件更新sort值
     * 下移一位
     *
     * @param value 条件
     * @return 条数
     */
    @UpdateProvider(type = MyUpdateProvider.class, method = "dynamicSQL")
    Integer updateDownSortByCondition(@Param("value") String value);

    /**
     * 根据主键id 更新相关值
     *
     * @param value 条件
     * @return 影响行数
     */
    @UpdateProvider(type = MyUpdateProvider.class, method = "dynamicSQL")
    Integer updateInfoByKey(@Param("value") String value);
}

import org.apache.ibatis.mapping.MappedStatement;
import tk.mybatis.mapper.mapperhelper.MapperHelper;
import tk.mybatis.mapper.mapperhelper.MapperTemplate;
import tk.mybatis.mapper.mapperhelper.SqlHelper;
public class MyUpdateProvider extends MapperTemplate {
    public MyUpdateProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }

    /**
     * 根据条件更新sort值
     * 上移一位
     *
     * @param ms
     * @return
     */
    public String updateUpSortByCondition(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        sql.append(SqlHelper.updateTable(entityClass, tableName(entityClass)));
        sql.append("set sort = sort -1 ");
        sql.append("${value}");
        return sql.toString();
    }

    /**
     * 根据条件更新sort值
     * 下移一位
     *
     * @param ms
     * @return
     */
    public String updateDownSortByCondition(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        sql.append(SqlHelper.updateTable(entityClass, tableName(entityClass)));
        sql.append("set sort = sort +1 ");
        sql.append("${value}");
        return sql.toString();
    }

    /**
     * 根据主键id 更新相关值
     *
     * @param ms
     * @return
     */
    public String updateInfoByKey(MappedStatement ms) {
        Class<?> entityClass = getEntityClass(ms);
        StringBuilder sql = new StringBuilder();
        sql.append(SqlHelper.updateTable(entityClass, tableName(entityClass)));
        sql.append("${value}");
        return sql.toString();
    }
}

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@AllArgsConstructor
@NoArgsConstructor
public enum ResultEnum {
    /**成功处理*/
    RESULT_SUCCESS(200,"处理成功"),
    /**处理业务失败*/
    RESULT_ERROR(500,"处理错误"),
    /** 返回值 */
    private int code;
    /** 返回消息 */
    private String msg;
}

搞定了。

byxu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java用tkmapper分组查询_借助tk的通用mapper实现在mybatis中使用Example进行查询的几种方式...
weixin_36053019的博客
03-02 1234
如下列举四种方式，但是不止四种哦。其中weekend方式需要升级jdk到1.8及以上。废话不代码！首先定义数据库表映射类：public class MybatisDemo {private Long id;private Long count;private String name;public Long getId() {return id;}public Long getCount() {re...
两种排序方法
tkzc_csk的博客
09-14 228
题目描述 考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符串的排序方法： 1.根据字符串的字典序排序。例如： “car” &amp;amp;lt; “carriage” &amp;amp;lt; “cats” &amp;amp;lt; “doggies &amp;amp;lt; “koala” 2.根据字符串的长度排序。例如： “car” &amp;amp;lt; “cats” &amp;amp;lt; “koala” &
TK.Mapper多条件复杂查询
weixin_45415885的博客
07-06 892
TK.Mapper多条件复杂查询使用tkmapper实现复杂的多条件查询 使用tkmapper实现复杂的多条件查询 使用场景： 比如查询某个用户的订单状态=1或者等于2的订单列表。 SQL语句： select * from order where user_id="10001" and (status == '1' or status == '2'); 代码实现 Example example = new Example(Order.class); Example.Criteria criteria
通用Mapper
孙霸天的专栏
07-30 1348
概述 通用Mapper都可以极大的方便开发人员。可以随意的按照自己的需要选择通用方法，还可以很方便的开发自己的通用方法。 极其方便的使用MyBatis单表的增删改查。 支持单表操作，不支持通用的多表联合查询。 使用 如果你使用 Maven，只需要添加如下依赖： <dependency> <groupId>tk.mybatis&lt...
通用mapper使用
a1694375032的博客
10-11 381
一、pom坐标 <!-- 统一管理jar包版本 --> <properties> <mapper.starter.version>2.0.2</mapper.starter.version> </properties> <!-- 通用Mapper启动器 --> <dependency> &...
matlab开发-排序财务数据库日期
08-26
在MATLAB中，开发涉及处理财务数据库的程序是一项常见的任务，特别是当需要对大量日期和数值数据进行排序和分析时。本项目的核心是"排序财务数据库日期"，它旨在实现两个财务数据数组（日期和对应的数值）的升序排序...
React-react拖动排序组件
08-14
在React开发中，拖动排序组件是一个非常实用的功能，它允许用户通过拖放操作来直观地改变元素的顺序。在本篇文章中，我们将深入探讨如何使用React构建一个可排序列表的拖动排序组件，以及涉及的相关技术点。 首先，...
JavaScript-使用javascript开发的排序算法-sorting.zip
最新发布
02-25
在这个"JavaScript-使用javascript开发的排序算法-sorting.zip"压缩包中，很可能是包含了各种常见的排序算法实现，比如冒泡排序、插入排序、选择排序、快速排序、归并排序以及堆排序等。 1. **冒泡排序**：冒泡排序...
ios-排序.zip
07-11
快速排序是一种常用的高效排序算法，其基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到整个序列有序。...
详解Java常用排序算法-归并排序
08-26
在实际开发中，归并排序常用于对大规模数据进行排序，例如对数据库记录进行排序、对文件进行排序等。同时，归并排序也可以与其他排序算法结合使用，以提高排序效率和稳定性。 归并排序是一种高效、稳定的排序算法，...
tkmybatis使用example.setOrderByClause进行排序和多个排序字段时的使用
Java小皮孩
12-13 1万+
当排序单个字段时的使用方法 example.setOrderByClause("user_type ASC"); //根据用户类型升序排序输出 运行sql大概是这样的 SELECT ... FROM tab_sy_user order by user_type ASC 当排序多个字段时的使用方法，中间用逗号隔开 查询结果先按字段的顺序执行排序，如果条件相同，继续按照下一个字段进行条件排序，直到最后一个字段排序完成。 //首先根据user_type升序ASC排序，如果有条件相同的，在按照lev
tkMapper之使用Weekend拼接条件进行条件查询
itigoitie的博客
06-28 1802
tkMapper之使用Weekend拼接查询条件进行查询数据库表
TkMybatis常用方法
buhuikaifa的博客
08-14 1275
1.查询⽅法List selectAll();
springBoot中 tk.mybatis的Example使用
qq_38719039的博客
05-28 1万+
1. 数据查询Example example = new Example(CcompareccicModel.class); Criteria criteria = example.createCriteria(); @Override public PageList&lt;RiskasesmtComment&gt; findAuditResult(Integer pageInde...
MyBatis插件使用--通用Mapper
weixin_34407348的博客
02-14 365
原文链接：MyBatis插件使用--通用Mapper 通用Mapper可以简化CRUD操作，不必单独为每一Mapper指定CRUD接口所需jar包mapper-3.3.9.jar,persistence-api-1.0.jar XML配置 在spring配置文件中配置: <!-- 配置通用Mapper --> ...
通用mapper的使用
nylic的博客
09-28 2万+
使用通用Mapper，不需要再写mapper.xml配置文件，多数时候，连接口方法都不需要了，大大提高了开发效率。
tk通用mapper的配置与使用
我能在河边钓一整天的鱼
02-28 1232
目录 通用mapper的使用步骤 1.引入依赖 2.刷新你的maven依赖 3.配置mapper，继承tkmapper 4.在实体类上表明主键和主键返回策略 5.启动类上增加mapper扫描注解 通用mapper的使用步骤 1.引入依赖 基本需要跟数据库打交道的依赖也一并引了，版本我单独放在父工程的pom中了。 <depende...
mybatis mapper orderby like
legend_x的专栏
07-07 2932
criteria.andFTerminalLike("%"+req.getfTerminal()+"%"); example.setOrderByClause("xx asc");
mybatis中的mapper接口文件以及example类的实例函数以及详解
热门推荐
hins
04-08 2万+
##Example example = new ##Example(); example.setOrderByClause("字段名 ASC"); //升序排列，desc为降序排列。 example.setDistinct(false)//去除重复，boolean型，true为选择不重复的记录。 Criteria criteria = new Example().createCriteria();

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值