使用到的一些工具类

已于 2022-03-02 17:52:01 修改
阅读量614 收藏 1
点赞数 1
分类专栏： 随笔 工具类 文章标签： java
于 2021-07-22 17:28:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyf1996/article/details/119004718
版权

一些挺不错的工具类

1.自己整合的querywrapper工具类


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.time.LocalDateTime;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * @author Administrator
 */
public class QueryWrapperUtils {
        private static Pattern linePattern = Pattern.compile("_(\\w)");

        /** 下划线转驼峰 */
        public static String lineToHump(String str) {
            str = str.toLowerCase();
            Matcher matcher = linePattern.matcher(str);
            StringBuffer sb = new StringBuffer();
            while (matcher.find()) {
                matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
            }
            matcher.appendTail(sb);
            return sb.toString();
        }

        /** 驼峰转下划线(简单写法，效率低于{@link #humpToLine2(String)}) */
        public static String humpToLine(String str) {
            return str.replaceAll("[A-Z]", "_$0").toLowerCase();
        }

        private static Pattern humpPattern = Pattern.compile("[A-Z]");

        /** 驼峰转下划线,效率比上面高 */
        public static String humpToLine2(String str) {
            Matcher matcher = humpPattern.matcher(str);
            StringBuffer sb = new StringBuffer();
            while (matcher.find()) {
                matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
            }
            matcher.appendTail(sb);
            return sb.toString();
        }

        public static void main(String[] args) {
            String lineToHump = lineToHump("f_parent_no_leader");
            System.out.println(lineToHump);
            // fParentNoLeader
            System.out.println(humpToLine(lineToHump));
            // f_parent_no_leader
            System.out.println(humpToLine2(lineToHump));
            // f_parent_no_leader
        }


        /**
        *
        * @Description
        * 1.clazz类型参数返回该类型的QueryWrapper，条件为dto参数中的属性，null值不构建条件.
        * 2.其中String类型默认是用模糊查询，需要精准匹配请在属性后面加上大写的“EQ”，特定的order属性作为排序的字段名.
        * 3.其中Boolean类型为排序判断，true倒序，false升序,并且order为空的时候不做排序,并且需要提供getFlag方法.
        * 4.其中时间类型是LocalDateTime，如果需要区间，会判断属性是否以大写的“START”或者“END”结尾进行大于开始时间，小于结束时间查询.
        * 5.其中布尔类型或者其他基本类型都需要使用包装类
        * @Author  DengYiFan
        * @Param  [clazz  任意类, dto  条件参数实体类]
        * @Return    com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<T>
        *
        */
    public static <T> QueryWrapper<T> getQueryWrapper(Class<T> clazz,Object dto) {
        QueryWrapper<T> wrapper = new QueryWrapper<>();
        Field[] field = dto.getClass().getDeclaredFields();
        boolean flag = true;
        String order = null;
        for (int j = 0; j < field.length; j++) {
            try {
                String fieldName = field[j].getName();
                String name = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                String type = field[j].getGenericType().toString();
                Method m = dto.getClass().getMethod("get" + name);
                Object value = m.invoke(dto);
                if (value != null) {
                    switch (type) {
                        case "class java.lang.String":
                            if (StringUtils.isBlank((String)value)){
                                break;
                            }
                            if ("order".equals(fieldName)){
                                order = (String) value;
                                break;
                            }
                            if (fieldName.endsWith("EQ")){
                                wrapper.eq(humpToLine2(fieldName.substring(0,fieldName.length()-2)),(String) value);
                                break;
                            }
                            wrapper.like(humpToLine2(fieldName), (String) value);
                            break;
                        case "class java.lang.Integer":
                            wrapper.eq(humpToLine2(fieldName), (Integer) value);
                            break;
                        case "class java.lang.Short":
                            wrapper.eq(humpToLine2(fieldName), (Short) value);
                            break;
                        case "class java.lang.Double":
                            wrapper.eq(humpToLine2(fieldName), (Double) value);
                            break;
                        case "class java.lang.Boolean":
                            flag = (boolean) value;
                            break;
                        case "class java.time.LocalDateTime":
                            if (fieldName.endsWith("START")){
                                wrapper.gt(humpToLine2(fieldName.substring(0,fieldName.length()-5)),(LocalDateTime) value);
                                break;
                            }
                            if (fieldName.endsWith("END")){
                                wrapper.lt(humpToLine2(fieldName.substring(0,fieldName.length()-3)),(LocalDateTime) value);
                                break;
                            }
                            wrapper.eq(humpToLine2(fieldName), (LocalDateTime) value);
                            break;
                        default:break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (order != null){
            if (flag){
                wrapper.orderByDesc(QueryWrapperUtils.humpToLine2(order));
            }else {
                wrapper.orderByAsc(QueryWrapperUtils.humpToLine2(order));
            }
        }
        return wrapper;
    }

    /**
     *
     *  @Date: 2021/7/27 13:43
     *  @Description: 此方法同上，不做泛型限制
     */
    public static  QueryWrapper getGeneralQuery(Object dto) {
        QueryWrapper wrapper = new QueryWrapper<>();
        Field[] field = dto.getClass().getDeclaredFields();
        boolean flag = true;
        String order = null;
        for (int j = 0; j < field.length; j++) {
            try {
                String fieldName = field[j].getName();
                String name = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                String type = field[j].getGenericType().toString();
                Method m = dto.getClass().getMethod("get" + name);
                Object value = m.invoke(dto);
                if (value != null) {
                    switch (type) {
                        case "class java.lang.String":

                            if (StringUtils.isBlank((String)value)){
                                break;
                            }
                            if ("order".equals(fieldName)){
                                order = (String) value;
                                break;
                            }
                            if (fieldName.endsWith("EQ")){
                                wrapper.eq(humpToLine2(fieldName.substring(0,fieldName.length()-2)),(String) value);
                                break;
                            }
                            wrapper.like(humpToLine2(fieldName), (String) value);
                            break;
                        case "class java.lang.Integer":
                            wrapper.eq(humpToLine2(fieldName), (Integer) value);
                            break;
                        case "class java.lang.Short":
                            wrapper.eq(humpToLine2(fieldName), (Short) value);
                            break;
                        case "class java.lang.Double":
                            wrapper.eq(humpToLine2(fieldName), (Double) value);
                            break;
                        case "class java.lang.Boolean":
                            flag = (boolean) value;
                            break;
                        case "class java.time.LocalDateTime":
                            if (fieldName.endsWith("START")){
                                wrapper.gt(humpToLine2(fieldName.substring(0,fieldName.length()-5)),(LocalDateTime) value);
                                break;
                            }
                            if (fieldName.endsWith("END")){
                                wrapper.lt(humpToLine2(fieldName.substring(0,fieldName.length()-3)),(LocalDateTime) value);
                                break;
                            }
                            wrapper.eq(humpToLine2(fieldName), (LocalDateTime) value);
                            break;
                        default:
                            break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (order != null){
            if (flag){
                wrapper.orderByDesc(QueryWrapperUtils.humpToLine2(order));
            }else {
                wrapper.orderByAsc(QueryWrapperUtils.humpToLine2(order));
            }
        }
        return wrapper;
    }

}

2.String工具类

import org.apache.commons.lang3.StringEscapeUtils;
import java.io.UnsupportedEncodingException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
 * @author ThinkGem
 * @version 2013-05-22
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

	public static String lowerFirst(String str){
		if(StringUtils.isBlank(str)) {
			return "";
		} else {
			return str.substring(0,1).toLowerCase() + str.substring(1);
		}
	}

	public static String upperFirst(String str){
		if(StringUtils.isBlank(str)) {
			return "";
		} else {
			return str.substring(0,1).toUpperCase() + str.substring(1);
		}
	}

	/**
	 * 替换掉HTML标签方法
	 */
	public static String replaceHtml(String html) {
		if (isBlank(html)){
			return "";
		}
		String regEx = "<.+?>";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(html);
		String s = m.replaceAll("");
		return s;
	}

	/**
	 * 缩略字符串（不区分中英文字符）
	 * @param str 目标字符串
	 * @param length 截取长度
	 * @return
	 */
	public static String abbr(String str, int length) {
		if (str == null) {
			return "";
		}
		try {
			StringBuilder sb = new StringBuilder();
			int currentLength = 0;
			for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
				currentLength += String.valueOf(c).getBytes("GBK").length;
				if (currentLength <= length - 3) {
					sb.append(c);
				} else {
					sb.append("...");
					break;
				}
			}
			return sb.toString();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return "";
	}

	/**
	 * 缩略字符串（替换html）
	 * @param str 目标字符串
	 * @param length 截取长度
	 * @return
	 */
	public static String rabbr(String str, int length) {
        return abbr(replaceHtml(str), length);
	}


	/**
	 * 转换为Double类型
	 */
	public static Double toDouble(Object val){
		if (val == null){
			return 0D;
		}
		try {
			return Double.valueOf(trim(val.toString()));
		} catch (Exception e) {
			return 0D;
		}
	}

	/**
	 * 转换为Float类型
	 */
	public static Float toFloat(Object val){
		return toDouble(val).floatValue();
	}

	/**
	 * 转换为Long类型
	 */
	public static Long toLong(Object val){
		return toDouble(val).longValue();
	}

	/**
	 * 转换为Integer类型
	 */
	public static Integer toInteger(Object val){
		return toLong(val).intValue();
	}

}

3.代码生成器（需要引入pom依赖，已经放在注解里了）

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class GeneratorDemo {
    @Test
    public void testGenerator() {
        //1. 全局配置
        GlobalConfig config = new GlobalConfig();
        config.setActiveRecord(true) // 是否支持AR模式
                .setAuthor("作者") // 作者
                .setOutputDir("D:/java/code") // 生成路径
                .setFileOverride(true)  // 文件覆盖
                .setIdType(IdType.ASSIGN_ID) // 主键策略
                .setEnableCache(false) //是否开启二级缓存
                .setServiceName("%sService")  // 设置生成的service接口的名字的首字母是否为I
                // IEmployeeService
                .setBaseResultMap(true)
                .setBaseColumnList(true);

        //2. 数据源配置
        DataSourceConfig dsConfig = new DataSourceConfig();
        dsConfig.setDbType(DbType.MYSQL)  // 设置数据库类型
                .setDriverName("com.mysql.cj.jdbc.Driver")
                .setUrl("jdbc:mysql:")
                .setUsername("root")
                .setPassword("123");

        //3. 策略配置
        StrategyConfig stConfig = new StrategyConfig();
        List<TableFill> tableFillList = new ArrayList<>();
        tableFillList.add(new TableFill("createTime", FieldFill.INSERT));
        tableFillList.add(new TableFill("updateTime", FieldFill.UPDATE));
        stConfig.setCapitalMode(true) //全局大写命名
//                .setDbColumnUnderline(true)  // 指定表名 字段名是否使用下划线
                .setNaming(NamingStrategy.underline_to_camel) // 数据库表映射到实体的命名策略
                /*.setTablePrefix("tab_")
                .setInclude("tab_user")*/  // 生成的表
                .setEntityLombokModel(true)
                .setVersionFieldName("version")
                .setLogicDeleteFieldName("isDelete")
                .setTableFillList(tableFillList);
//                .setSuperEntityClass("BaseEntity")
//                .setSuperEntityColumns("appId", "version", "isDelete", "createTime", "createBy", "updateTime", "updateBy");

        //4. 包名策略配置
        PackageConfig pkConfig = new PackageConfig();
        pkConfig.setParent("com.aa.bb")
                .setMapper("mapper")
                .setService("service")
                .setController("web")
                .setEntity("entity")
                .setXml("mapper");

        //5. 整合配置
        AutoGenerator ag = new AutoGenerator();

        ag.setGlobalConfig(config)
                .setDataSource(dsConfig)
                .setStrategy(stConfig)
                .setPackageInfo(pkConfig);
        //6. 执行
        ag.execute();
        /**
         /**

         <dependency>
         <groupId>org.apache.velocity</groupId>
         <artifactId>velocity-engine-core</artifactId>
         <version>2.0</version>
         </dependency>
         <dependency>
         <groupId>com.baomidou</groupId>
         <artifactId>mybatis-plus-generator</artifactId>
         <version>3.3.1.tmp</version>
         <scope>test</scope>
         </dependency>

         <dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.0.29</version>
         </dependency>


         <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.38</version>
         </dependency>

         */
         */
    }
    }
诡迹
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis-plus QueryWrapper条件查询器
12-15
文章链接：https://blog.csdn.net/liuting52001/article/details/111220596
如何是用queryWrapper
weixin_35749440的博客
01-03 353
您好，QueryWrapper是MyBatis Plus中的一个工具类，用于生成SQL语句。使用QueryWrapper需要指定实体类的类型，然后通过调用各种方法来构建查询条件，最后调用getSqlSegment方法来获取生成的SQL片段。 例如，假设我们有一个用户表，想要根据用户名和年龄范围查询用户列表，代码可能如下所示： QueryWrapper<User> queryWrappe...
【精品】将查询对象转换成MyBatisPlus中的QueryWrapper
哈
10-01 1673
上面大量的转换代码，不仅写起来烦琐，而且也不优雅。
优雅地实现MyBatisPlus中的多条件查询，只需两行代码。
最新发布
qq_41266196的博客
10-25 385
MyBatisPlus框架已经为我们做了很多工作，但在复杂的多条件查询中，我们经常需要构建查询条件来进行数据库查询，特别是当查询条件多、变化频繁时。它通过反射获取对象中的所有字段及其值，然后为非null值的字段构建查询条件。：在多个方法或服务中，我们经常需要检查对象的每个字段，然后根据字段值构建查询条件。旨在解决上述问题，通过自动化构建查询条件，简化开发过程，减少出错机会，并提供更加一致和可维护的代码。方法，我们可以轻松地基于实体类对象构建查询条件，简化了多条件查询的复杂性，使代码更加简洁易读。
工具类的一些整合
08-29
各种工具类
Rabbitmq工具类，java工具类RabbitmqUtil
10-29
这些参数可以根据项目需求进行配置，确保工具类可以连接到正确的RabbitMQ服务器。 2. **创建通道(Channel)**：在RabbitMQ中，通道是执行操作的实体，它是轻量级的，比创建连接更节省资源。`RabbitmqUtil`会提供一个...
Android开发常用工具类
08-27
以下是一些Android开发常用的工具类及其核心知识点： 1. **字符串处理工具类**： - `StringUtils`：包含了对字符串的各种操作，如空判断、格式化、拼接、查找替换等。例如，`isNullOrEmpty()`方法用于检查字符串...
Android快速开发系列 10个常用工具类 程序源码
09-05
在Android应用开发中，工具类（Utils）是程序员经常使用的辅助模块，它们包含了一系列静态方法，用于处理各种常见的任务，从而提高代码的复用性和可维护性。本资源"Android快速开发系列 10个常用工具类 程序源码...
JAVA单例MongoDB工具类
12-22
经常对MongoDB进行一些常用操作，为了方便起见将这些常用操作合并到一个工具类中，方便自己开发使用。 　没用Spring Data、Morphia等框架是为了减少学习、维护成本，另外自己直接JDBC方式的话可以更方便的控制操作...
MybatisPlus--QueryWrapper
weixin_45822542的博客
12-20 5332
QueryWrapper wrapper介绍 Wrapper ： 条件构造抽象类，最顶端父类 AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件 QueryWrapper ： Entity 对象封装操作类，不是用lambda语法 UpdateWrapper ： Update 条件封装，用于Entity对象更新操作 AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。 Lambda
使用Mybatisplus时-动态构建QueryWrapper：自定义注解+反射
猪之仆的博客
02-01 2319
如果您在项目使用过mybatisplus，想必有过这样的麻烦，mybatisplus中条件是通过QueryWrapper进行封装，根据不同的业务来确定使用哪种操作符，比如eq,ge,lt等等。比如我们具有相近业务的条件使用同一个条件对象，这样一来就会产生一种非常臃肿的代码结构，并且每增加一个条件，都会牵扯QueryWrapper构造条件的改动，比如下面这样的情形： 只要改动PlFinanceCondition这个条件属性，这个条件的封装就会随之更新，耦合强亦不优雅。为了解决这个问题，我的优化方案为：自
LambdaQueryWrapper与QueryWrapper的使用
不愧是暮言的博客
05-25 7801
在Mybatis-plus框架中，LambdaQueryWrapper和QueryWrapper是两个非常常用的类。它们用于快速简便地查询数据库。LambdaQueryWrapper是Mybatis-plus 3.0.7版本之后推出的一个查询工具类，它采用lambda表达式构建SQL查询语句，可以快速、简便地完成CRUD等操作。
QueryWrapper模糊查询匹配多个字段
热门推荐
weixin_45121502的博客
05-09 4万+
平常使用QueryWrapper进行查询的时候会用到QueryWrapper.like进行模糊查询，但是这样只能匹配一个字段，如果想模糊匹配多个字段呢？ 错误的方式： wrapper.like("name", keywords); wrapper.or(); wrapper.like("address", keywords); 这样的话会出现错误，这个or不会给加上括号，如果存在and条件的话，就会出现以下情况 SELECT * FROM Student WHERE del_status='0' AND
Springboot 使用 MybatisPlus LambdaQueryWrapper 构造器和注解自定义SQL
泡泡的博客
09-25 7836
MyBatis-Plus 是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，MyBatis 可以无损升级为MyBatis-Plus，只需要更换一下pom依赖即可。1、强大的条件构造器：单表查询不需要写SQL语句2、支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错。
Mybatis-plus 动态条件查询QueryWrapper的使用
wounler的博客
07-04 1万+
Mybatis-plus 动态条件查询QueryWrapper的使用
Mybatis-plus工具类 自动填充QueryWrapper进行高级查询
qq_36008278的博客
06-25 2088
现在只支持QueryWrapper的eq和like功能 后续拓展SqlAnnotation的注解值 可以进行其他匹配 先看实体类 public class EnrollmentRecord implements Serializable { private static final long serialVersionUID = 1L; @TableId(value = "id", type = IdType.AUTO) private Integer id; @Api
Mybatis plus强大的条件构造器QueryWrapper条件构造器基础方法解释
toString的博客
05-27 1575
一、条件构造器关系介绍 介绍 ： 上图绿色框为抽象类abstract 蓝色框为正常class类，可new对象 黄色箭头指向为父子类关系，箭头指向为父类 wapper介绍 ： Wrapper ： 条件构造抽象类，最顶端父类，抽象类中提供4个方法西面贴源码展示 AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件 AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column...
MybatisPlus使用QueryWrapper类实现条件查询
weixin_45059962的博客
05-11 4741
MybatisPlus使用QueryWrapper类实现条件查询，调用QueryWrapper类的各种方法，并传入相关参数，可以实现条件查询。 @Test public void testmp() { // 创建QueryWrapper类的对象 QueryWrapper<UserInfo> wrapper = new QueryWrapper<>(); // 设定wrapper // ge表>= // gt表&gt
android怎么使用别人的工具类
05-24
1. 将该工具类文件复制到你的Android项目中的合适位置，一般放在 src/main/java 目录下的包名对应的文件夹中。 2. 在你的代码中引用该工具类，可以使用 import 语句将其导入，例如：import ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值