MyBatiesPlus简化使用

最新推荐文章于 2023-09-15 17:05:14 发布
置顶 最新推荐文章于 2023-09-15 17:05:14 发布
阅读量269 收藏
点赞数 1
分类专栏： mybatis 文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42434115/article/details/106689981
版权

MyBatiesPlus简化使用

Demo

class TUserController{
		User user = new User();
        user.setUserName("lijiajun");
 		QueryWrapper qw = BatisPlusQueryUtil.getQueryWrapper(user, "page", "T1.data_status");
        /*
        //未传递分组信息则获取所有com.ljj.birthdaymanager.utils.ibatis.plus.util的注解
        QueryWrapper qw = BatisPlusQueryUtil.getQueryWrapper(user);
        */

        /*
        //不需要进行逻辑删除校验时，传递isUse：false
        QueryWrapper qw = BatisPlusQueryUtil.getQueryWrapper(user, "list",false);
         */

        /*
        QueryWrapper qw = BatisPlusQueryUtil.getQueryWrapper(user, page);
        */

        //指定逻辑删除校验列为T1.data_status,默认列配置于 logic-delete-column: data_status
        List<User> list = testService.list(qw);
}
@Data
class User{
	@Like(group={"list","getByUserName","page"})
	private String userName;
	
	@Eq(group="list","page")
    @Like(group="likePhone", sourceColumn = "T1.f_phone")
    private String phone;
    
	@Eq(group="login")
    private String password;
}

版本

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>

工具代码

BatisPlusUtilLogic.java

public class BatisPlusUtilLogic {

    /**
     * @description: 携带注解的bean转换为条件构造器
     * @data: 2020/6/11 14:25
     */
    protected static void beanToWrapper(Object object, String group, QueryWrapper queryWrapper){
        Class<?> clz = object.getClass();

        List<Field> fieldList = getFiledsInfo(clz.getName());

        for (Field field : fieldList){

            field.setAccessible(true);
            Annotation[] annotations = field.getAnnotations();
            List<Annotation> annotationList = Arrays.asList(annotations);

            if (annotationList == null || annotationList.isEmpty()) continue;

            Object value = null;
            try {
                value = field.get(object);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            if (value == null) continue;

            if(value instanceof String && "".equals(value)) continue;

            filterField(group, queryWrapper, field, value);
        }
    }

    /**
     * @data: 2020/6/11 14:24
     * @description: 将有效的注解转换为wrapper的条件
     */
    protected static void filterField(String group, QueryWrapper queryWrapper, Field field, Object value) {
        Eq eq = field.getAnnotation(Eq.class);
        Ne ne = field.getAnnotation(Ne.class);
        Gt gt = field.getAnnotation(Gt.class);
        Ge ge = field.getAnnotation(Ge.class);
        Lt lt = field.getAnnotation(Lt.class);
        Le le = field.getAnnotation(Le.class);
        Between between = field.getAnnotation(Between.class);
        NotBetween notBetween = field.getAnnotation(NotBetween.class);
        Like like = field.getAnnotation(Like.class);
        NotLike notLike = field.getAnnotation(NotLike.class);
        LikeLeft likeLeft = field.getAnnotation(LikeLeft.class);
        LikeRight likeRight = field.getAnnotation(LikeRight.class);
        In in = field.getAnnotation(In.class);
        NotIn notIn = field.getAnnotation(NotIn.class);

        if (eq != null && isSameGroup(group, eq.group())) {

            String column = "".equals(eq.sourceColumn()) ?
                    propertyToColumn(field.getName()) : eq.sourceColumn();
            queryWrapper.eq(column, value);

        } else if (ne != null && isSameGroup(group, ne.group())) {

            String column = "".equals(ne.sourceColumn()) ?
                    propertyToColumn(field.getName()) :ne.sourceColumn();
            queryWrapper.ne(column, value);

        } else if (gt != null && isSameGroup(group, gt.group())) {

            String column = "".equals(gt.sourceColumn()) ?
                    propertyToColumn(field.getName()) :gt.sourceColumn();
            queryWrapper.gt(column, value);

        } else if (ge != null && isSameGroup(group, ge.group())) {

            String column = "".equals(ge.sourceColumn()) ?
                    propertyToColumn(field.getName()) :ge.sourceColumn();
            queryWrapper.ge(column, value);

        } else if (lt != null && isSameGroup(group, lt.group())) {

            String column = "".equals(lt.sourceColumn()) ?
                    propertyToColumn(field.getName()) :lt.sourceColumn();
            queryWrapper.lt(column, value);

        } else if (le != null && isSameGroup(group, le.group())) {

            String column = "".equals(le.sourceColumn()) ?
                    propertyToColumn(field.getName()) :le.sourceColumn();
            queryWrapper.le(column, value);

        } else if (between != null && isSameGroup(group, between.group())) {

            String column = "".equals(between.sourceColumn()) ?
                    propertyToColumn(field.getName()) :between.sourceColumn();
            Object objBetween = value;
            List<Object> objectBetweenList = castList(objBetween, Object.class);
            if (objectBetweenList != null)
                queryWrapper.between(column, objectBetweenList.get(0), objectBetweenList.get(1));

        } else if (notBetween != null && isSameGroup(group, notBetween.group())) {

            String column = "".equals(notBetween.sourceColumn()) ?
                    propertyToColumn(field.getName()) :notBetween.sourceColumn();
            Object objBetween = value;
            List<Object> objectBetweenList = castList(objBetween, Object.class);
            if (objectBetweenList != null)
                queryWrapper.notBetween(column, objectBetweenList.get(0), objectBetweenList.get(1));

        } else if (like != null && isSameGroup(group, like.group())) {

            String column = "".equals(like.sourceColumn()) ?
                    propertyToColumn(field.getName()) :like.sourceColumn();
            queryWrapper.like(column, value);

        } else if (notLike != null && isSameGroup(group, notLike.group())) {

            String column = "".equals(notLike.sourceColumn()) ?
                    propertyToColumn(field.getName()) :notLike.sourceColumn();
            queryWrapper.notLike(column, value);

        } else if (likeLeft != null && isSameGroup(group, likeLeft.group())) {

            String column = "".equals(likeLeft.sourceColumn()) ?
                    propertyToColumn(field.getName()) :likeLeft.sourceColumn();
            queryWrapper.likeLeft(column, value);

        } else if (likeRight != null && isSameGroup(group, likeRight.group())) {

            String column = "".equals(likeRight.sourceColumn()) ?
                    propertyToColumn(field.getName()) :likeRight.sourceColumn();
            queryWrapper.likeRight(column, value);

        } else if (in != null && isSameGroup(group, in.group())) {

            String column = "".equals(in.sourceColumn()) ?
                    propertyToColumn(field.getName()) :in.sourceColumn();
            Object obj = value;
            List<Object> objectList = castList(obj, Object.class);
            if (objectList != null)
                queryWrapper.in(column, objectList);

        } else if (notIn != null && isSameGroup(group, notIn.group())) {

            String column = "".equals(notIn.sourceColumn()) ?
                    propertyToColumn(field.getName()) :notIn.sourceColumn();
            Object obj = value;
            List<Object> objectList = castList(obj, Object.class);
            if (objectList != null)
                queryWrapper.notIn(column, objectList);
        }
    }

    /**
     * @description: 判断是否属于该组的数据
     * @data: 2020/6/11 13:58
     */
    protected static boolean isSameGroup(String group, String[] fieldGroups) {
        if (group == null) {
            return true;
        }else if(fieldGroups == null || fieldGroups.length == 0){
            return false;
        }
        List<String> list = Arrays.asList(fieldGroups);
        return list.contains(group);
    }

    /**
     * @data: 2020/6/9 16:44
     * @description: obj to list 容错转换
     *               处理如in一类的多值条件处理
     */
    protected static <T> List<T> castList(Object obj, Class<T> clazz) {
        if (obj == null) return null;

        List<T> result = new ArrayList<T>();
        if(obj instanceof List<?>) {
            for (Object o : (List<?>) obj) {
                result.add(clazz.cast(o));
            }
        }else if(obj instanceof Arrays){
            for (Object o : (Object[]) obj) {
                result.add(clazz.cast(o));
            }
        }else if(obj instanceof String){
            for (Object o :  ((String) obj).split(",")) {
                result.add(clazz.cast(o));
            }
        }else{
            throw new ClassCastException("Only the following types can be supported: List.class, Object[].class, String.class(Joining together',').");
        }

        return result;
    }

    /**
     * @description: 获取所有属性
     * @data: 2020/6/9 16:18
     */
    protected static List<Field> getFiledsInfo(String className) {
        List<Field> list = new ArrayList<>();
        Class<?> clazz = null;
        try {
            clazz = Class.forName(className);
            Field[] fields = clazz.getDeclaredFields();
            list.addAll(Arrays.asList(fields));
            Class<?> superClazz = clazz.getSuperclass();
            if (superClazz != null) {
                Field[] superFields = superClazz.getDeclaredFields();
                list.addAll(Arrays.asList(superFields));
            }
            return list;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @description: 实体属性转表字段
     * @data: 2020/6/9 16:38
     */
    protected static String propertyToColumn(String property) {
        StringBuilder result = new StringBuilder();
        if (property != null && property.length() > 0) {
            // 将第一个字符处理成大写
            result.append(property.substring(0, 1).toUpperCase());
            // 循环处理其余字符
            for (int i = 1; i < property.length(); i++) {
                String s = property.substring(i, i + 1);
                // 在大写字母前添加下划线
                if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
                    result.append("_");
                }
                // 其他字符直接转成大写
                result.append(s.toUpperCase());
            }
        }
        return result.toString();
    }
}
BatisPlusQueryUtil.java
public class BatisPlusQueryUtil extends BatisPlusUtilLogic {

    /**
     * @description: 加入启用状态的过滤
     * @param columns : 表记为启用的列名称
     * @data: 2020/6/11 09:52
     */
    public static void notContainsDel(QueryWrapper queryWrapper,String...columns){
        for (String column : columns) {
            String columnVal = column.trim();
            if ("".equals(columnVal)){
                continue;
            }
            //PropertiesUtil.LOGIC_NOT_DELETE为已启用的标识状态
            queryWrapper.eq(columnVal, PropertiesUtil.LOGIC_NOT_DELETE);
        }
    }

    public static QueryWrapper getQueryWrapper(Object object) throws IllegalAccessException {
       return getQueryWrapper(object,null,true);
    }

    public static QueryWrapper getQueryWrapper(Object object,boolean isUse) throws IllegalAccessException {
       return getQueryWrapper(object,null,isUse);
    }

    public static QueryWrapper getQueryWrapper(Object object, String ...useColumns) throws IllegalAccessException {
       return getQueryWrapper(object,null,true, useColumns);
    }

    public static QueryWrapper getQueryWrapper(Object object,String group, String ...useColumns) throws IllegalAccessException {
       return getQueryWrapper(object,group,true, useColumns);
    }

    public static QueryWrapper getQueryWrapper(Object object,String group) throws IllegalAccessException {
       return getQueryWrapper(object,group,true);
    }

    public static QueryWrapper getQueryWrapper(Object object, String group, boolean isUse,String ...useColumns) throws IllegalAccessException {
        QueryWrapper queryWrapper = new QueryWrapper();
        if (isUse){
            if (useColumns == null || useColumns.length == 0){
            //PropertiesUtil.LOGIC_DELETE_COLUMN为默认的启用标识列列名
                notContainsDel(queryWrapper, PropertiesUtil.LOGIC_DELETE_COLUMN);
            }else{
                notContainsDel(queryWrapper, useColumns);
            }
        }
        if( object != null) {
            beanToWrapper(object, group, queryWrapper);
        }
        return queryWrapper;
    }
}

业务注解


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface NotLike {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface NotIn {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface NotBetween {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Ne {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Lt {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface LikeRight {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface LikeLeft {
    String sourceColumn() default "";
    String[] group() default {};
}


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Like {
    String sourceColumn() default "";
    String[] group() default {};
}


@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Le {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface In {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Gt {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Ge {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Eq {
    String sourceColumn() default "";
    String[] group() default {};
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value= ElementType.FIELD)
public @interface Between {
    String sourceColumn() default "";
    String[] group() default {};
}

急用请复制粘贴, 细看劳烦附上建议

多多指教

瘦肉佩奇
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于使用Mybatisplus自带的selectById和insert方法时的一些问题
09-07
主要介绍了关于使用Mybatisplus自带的selectById和insert方法时的一些问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
Mybatis-Plus详解
互联网底层民工的博客
07-15 4万+
Mybatis-Plus是一个Mybatis（opens new window）的增强工具，在Mybatis的基础上只做增强不做改变，为简化开发。无侵入：只做增强不做改变，引入它不会对现有工程产生影响。 损耗小：启动即会自动注入基本CURD，性能基本无损耗，直接面向对象操作。 强大的CRUD操作：内置通用Mapper、通用Service，仅仅通过少量配置即可实现单表大部分CRUD操作，更有强大的条件构造器，满足各类使用需求。支持Lambda形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需
MyBatis-Plus详解
chat_bot的博客
11-01 8272
MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
Mybatis-Plus 详解
qq_52922453的博客
10-07 1万+
官⽹：或介绍（简称MP）是⼀个MyBatis的增强⼯具，在MyBatis的基础上只做增强不做改变，-为简化开发、提⾼效率⽽⽣。
MyBatis Plus详细教程
热门推荐
code_xiaotian的博客
04-15 13万+
详细介绍了mybatisplus的各个功能，简单又好用！
Spring Cloud集成MyBaties-Plus.pdf
12-22
Spring Cloud集成最新版MyBaties-Plus文档
springboot-mybatisplus 逆向工程
05-06
mybatis-Plus 逆向工程注释清晰
maven构建Spring Mybaties，实现增删改查
05-01
maven构建Spring Mybaties，实现增删改查，maven构建Spring Mybaties，实现增删改查，maven构建Spring Mybaties，实现增删改查
mybatis+Oracle做批量导入时的坑
11-06
Java开发中集成mybatis+orcal做批量操作时会遇到的问题。就想记录一下问题，这里的方法我的是完全可以的
Mybatis-plus---的批量插入
second_place_zyj的博客
04-20 1万+
丝滑的批量操作，我选它insertBatchSomeColumn
MyBatis与MyBatis-Plus的区别？
jakelihua
06-14 1万+
MyBatis的编程风格更加传统，需要定义mapper.xml文件并根据传入的参数使用相应的SQL查询语句，需要实现 Mybatis 提供的各种方法；而MyBatis-Plus是在MyBatis框架上的封装，通过对于增强简化后的API更加方便地进行开发，并且在性能、效率和易用性上都有一定的优化。MyBatis-Plus相比于MyBatis提供了很多额外的功能，例如像条件构造器、代码生成器、分页插件、性能分析拦截器等实用的组件，使得开发者可以轻松快速完成业务逻辑的开发。
Mybatis和Mybatis plus
最新发布
qq_37902466的博客
09-15 3168
如果项目只需进行简单的增删改查操作，追求快速开发和高效率，并且不强调对底层SQL的细节控制，可以选择MyBatis Plus。在这个示例中，通过继承MyBatis Plus提供的IService接口和ServiceImpl类，Service层可以直接使用MyBatis Plus提供的方法来完成单表数据的增删改查操作。在MyBatis Plus中，通过Service层继承Service类和Mapper层继承BaseMapper接口，都可以实现单表数据的增删改查操作。三、MyBatis Plus使用示例。
Mybatis Plus的相关使用教程与扩展
ThinkMore
03-27 1万+
转载出处：点击前往 简介 MyBatis的-PLUS（简称MP）是一个 MyBatis的 的增强工具，在MyBatis的的基础上只做增强不做改变，为简化开发，提高效率而生。 我们的愿景是成为Mybatis最好的搭档，就像Contra Game中的1P，2P，基友搭配，效率翻倍。 特性 无侵入：Mybatis-Plus在Mybatis的基础上进行扩展，只做增强不做改变，引入Myba...
Mybatis-plus 动态条件查询QueryWrapper的使用
wounler的博客
07-04 1万+
Mybatis-plus 动态条件查询QueryWrapper的使用
Mybatis-Plus使用全解
weixin_33850015的博客
08-06 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis 框架 ( 四 ) QueryWrapper
yuanchun的知识整理
09-11 2116
func(i->{ if(条件) { i.条件();.lambda() : 将 QueryWrapper() 转换成 LambdaQueryWrapper() , 就可以使用 Lambda 语法。字段 IN (values.get(0), values.get(1), …字段 NOT IN (values.get(0), values.get(1), ….and() : 相连的条件必须同时满足, 默认都是 and 相连。通过 lambda() 转成 LambdaQueryWrapper()
【Java中间件】mybatis-plus中的like用法总结（like、likeRight、likeLeft）
jayxiaoxionger的博客
03-29 1万+
mybatis-plus中的like、likeRight、likeLeft用法
写一个mybatiesplus
02-19
我可以为你编写一个mybatiesplus示例，你可以按照以下步骤进行操作：1.安装MybatisPlus：将MybatisPlus的jar包添加到你的项目中，并添加其他相关依赖。2.创建MybatisPlus配置文件：在src/main/resources/mybatis-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值