java 自我小笔记

//需要将your_name替换为你的名字，change_set_id替换为你的change set的唯一标识符，your_table_name替换为要修改字段名称的表名，old_column_name替换为要修改的字段的旧名称，new_column_name替换为要修改的字段的新名称。
//请注意，当你使用renameColumn change type时，你需要确保在同一个change set中没有其他与该表相
<changeSet author="your_name" id="change_set_id">
    <renameColumn tableName="your_table_name" oldColumnName="old_column_name" newColumnName="new_column_name"/>
</changeSet>

//usePoint.js
import {reactive,onMounted,onBeforeUnmount } from 'vue'
function savePoint(){
    //实现鼠标打点的数据
    let point = reactive({
        x: null,
        y: null
    })
    //实现鼠标点的方法
    const savePoint = (e)=>{
         point.x = e.pageX
         point.y = e.pageY
    } 
    //实现鼠标打点的生命周期钩子
    onMounted(()=>{
        window.addEventListener('click',savePoint)
    })
    onBeforeUnmount(()=>{
        window.removeEventListener('click',savePoint)
    })
    return point
}
export default savePoint

日期区间搜索

       EntityWrapper<TsTaskRegister> entityWrapper = new EntityWrapper<>();
            entityWrapper.eq(TableFieldName.DEL_FLAG, BaseConstants.DelFlag.NORMAL);
            if (StringUtils.isNotBlank(tsTaskRegister.getTaskCode())) {
                entityWrapper.like("TASK_CODE", tsTaskRegister.getTaskCode());
            }
            Calendar calendar = Calendar.getInstance();
            // 将 Date 对象设置到 Calendar 中
            calendar.setTime(tsTaskRegister.getEndTime());
            // 设置时分秒为 23:59:59
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            entityWrapper.between("CREATE_DATE", tsTaskRegister.getStartTime(), calendar.getTime());
            entityWrapper.orderBy("CREATE_DATE");
            PageResult<TsTaskRegister> lsResult = tsTaskRegisterService.queryByPageByOrderWithWrapper(entityWrapper, pagination);

数组转换map

       const map = state.listRowKeys.reduce((acc, item) => {
          acc.set(item, item);
          return acc;
        }, new Map());
        console.log('map',map)

在 Java 后端接收前端传递的 ID 数组参数时，可以使用以下步骤进行处理：

前端使用 POST 方法将 ID 数组作为请求体发送给后端。

后端定义一个接收 ID 数组参数的方法，使用注解 @RequestBody 来接收请求体的内容，并将其转换为对应的 Java 对象。

下面是一个示例代码，演示了如何在 Java 后端接收前端传递的 ID 数组参数：

@RestController
@RequestMapping("/api")
public class YourController {
    @PostMapping("/ids")
    public void handleIds(@RequestBody Long[] ids) {
        // 处理接收到的 ID 数组
        for (Long id : ids) {
            // 进行相应的操作，如数据库查询、业务逻辑处理等
            System.out.println(id);
        }
    }
}
在上述示例代码中，我们使用 @RestController 注解标记控制器类，并使用 @PostMapping 注解定义了一个接收 ID 数组的方法。

在方法参数中，我们使用 @RequestBody 注解来接收请求体中的内容，并将其转换为 Long 类型的数组。

在方法体中，我们对接收到的 ID 数组进行相应的处理。这里只是简单地打印每个 ID，你可以根据实际需求进行其他操作，比如数据库查询、业务逻辑处理等。

请注意，前端请求的内容需要符合后端定义的数据结构，这里假设前端传递的是一个包含 Long 类型的 ID 数组。

你可以根据具体的业务需求和数据结构，在后端进行相应的参数接收和处理。

     //起始跟踪号
        if (wmsTransitTask.getTrackingNumberBegin() != null) {
            wrapper.where("TO_NUMBER(SUBSTR(TRACKING_NUMBER, INSTR(TRACKING_NUMBER, '-') + 1)) > "+wmsTransitTask.getTrackingNumberBegin()+"");
        }
        //结束跟踪号
        if (wmsTransitTask.getTrackingNumberEnd() != null) {
            wrapper.where("TO_NUMBER(SUBSTR(TRACKING_NUMBER, INSTR(TRACKING_NUMBER, '-') + 1)) < " + wmsTransitTask.getTrackingNumberEnd() + "");
        }

根据某个字段qwe-123横线之后数字比较查询

SELECT
	TRACKING_NUMBER
FROM
	WMS_TRANSIT_TASK 
WHERE
	TO_NUMBER ( SUBSTR( TRACKING_NUMBER, INSTR( TRACKING_NUMBER, '-' ) + 1 ) ) <'5.0';

        //多字段排序
        Set<String> sortFields = new HashSet<>();
        if (StringUtils.isNotBlank(pagination.getSortField())) {
            String[] sourceStrArray = StringUtils.split(pagination.getSortField(), ",");
            CollectionUtils.mergeArrayIntoCollection(sourceStrArray, sortFields);
        }
        for (String field : sortFields) {
            String endField = field.substring(field.length() - 1, field.length());
            String startField = field.substring(0, field.length() - 1);
            if ("+".equals(endField)) {
                entityWrapper.orderBy(startField, true);
            } else if ("-".equals(endField)) {
                entityWrapper.orderBy(startField, false);
            }
            if (!endField.equals("+") && !endField.equals("-")) {
                entityWrapper.orderBy("createDate", false);
            }
        }

日期搜索

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if (vWmsShelfPerform.getCreateDate() != null) {
            String date = sdf.format(vWmsShelfPerform.getCreateDate());
            entityWrapper.where("TO_CHAR(CREATE_DATE,'yyyy-MM-dd')={0}", date);
        }

      // 导出 post 请求的导出
      handleExport: () => {
        state.paramsExport = {};
        state.paramsExport = {
          ids: state.selectedRowKeys,
          ...state.searchData,
        };
        excelExport(state.paramsExport).then(response => {
          const blob = new Blob([response], {
            type:
              'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
          }) //保存为xlsx格式的excel文件
          const objectUrl = window.URL.createObjectURL(blob)
          const a = document.createElement('a')
          document.body.appendChild(a)
          a.style = 'display: none'
          a.href = objectUrl
          a.download = '现存量导出'
          a.click()
          document.body.removeChild(a)
        })
      },

    /**
     * 通过正则表达式判断字符串是否为数字
     * @param str
     * @return
     */
    public static boolean isNumber(String str) {
         Pattern pattern = Pattern.compile("-?[0-9]+(\\\\.[0-9]+)?");
        // 通过Matcher进行字符串匹配
        Matcher m = pattern.matcher(str);
        // 如果正则匹配通过 m.matches() 方法返回 true ，反之 false
        return m.matches();
    }

    /**
     * 通用查询方法in
     *
     * @param set     Set集合
     * @param ew      ew条件
     * @param field   查询字段
     * @param service 实现service
     * @param <T>     泛型实体
     * @return
     */
    public static <T> List<T> listWrapperIn(Set<String> set, Wrapper<T> ew, String field, BaseService service) {
        List<T> lists = new ArrayList<>();
        if (CollectionUtils.isEmpty(set)) {
            return lists;
        }
        int maxIN = 1000;
        List<List<String>> idList4Split = CollectionUtils.split(new ArrayList<>(set), maxIN);
        for (List<String> item : idList4Split) {
            EntityWrapper<T> entityWrapper = new EntityWrapper<>();
            entityWrapper = (EntityWrapper<T>) ew.clone();
            entityWrapper.in(field, item);
            List<T> list = service.listByWrapper(entityWrapper);
            if (!CollectionUtils.isEmpty(list)) {
                lists.addAll(list);
            }
        }
        return lists;
    }

vue计算保留小数点两位

Number ((record.taxPrice * record.qty).toFixed(2))

     //由于拆分会有重复行号 根据行号去重
        ArrayList<WmsDeliveryBill> billArrayList = wmsArriveBillList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(WmsDeliveryBill::getBillRowNum))), ArrayList::new)
        );

/**
*根据编码加行号拼接作为key 分组
*/
        Map<String, WmsReceivingDTO> receivingDTOMap = new HashMap<>();
        if (!CollectionUtils.isEmpty(list)) {
            receivingDTOMap = list.stream()
                    .collect(Collectors.toMap(p -> p.getSourceBillCode() + p.getSourceBillRowNum(), a -> a, (k1, k2) -> k1));
        }

    /**
     * 获取头+年月日4位随机数
     * @return
     */
    public static StringBuilder randomCode(String text){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        String format = sdf.format(new Date());
        long round = Math.round((Math.random() + 1) * 1000);
        StringBuilder builder=new StringBuilder();
        builder.append(text);
        builder.append(format);
        builder.append(round);
        return builder;
    }

日期格式校验

    /**
     * 日期格式校验	0000-00-00
     * @param date
     * @return
     */
    boolean timeFormatVerify(String date) {
        if (StringUtils.isNotBlank(date)) {
            String regex = "((\\d{3}[1-9]|\\d{2}[1-9]\\d|\\d[1-9]\\d{2}|[1-9]\\d{3})-(((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01]))|((0[469]|11)(0[1-9]|[12]\\d|30))|(02(0[1-9]|[1]\\d|2[0-8]))))|(((\\d{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))-02-29)";
            boolean matches = date.matches(regex);
            return matches;
        }
        return true;
    }

//实体类自动填充注解，该注解自己new对象的时候无效
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.UPDATE)
//冗余字段
@TableField(exist = false)

sql使用

//模糊搜索
 <if test="null != doctor.name and doctor.name != ''">
                AND wd.`name` LIKE CONCAT ('%', #{doctor.name}, '%')
  </if>

//生日的开始时间-结束时间 计算年龄
(SELECT TIMESTAMPDIFF(YEAR, wp.birthday, CURDATE()))
//求 时间差
TIMESTAMPDIFF（单位，开始时间，结束时间）

//开始时间 结束时间 搜索
<if test="null != order.beginTime">
                AND (DATE_FORMAT(wo.generate_time, '%y-%m-%d-%T') <![CDATA[ >= ]]> DATE_FORMAT(#{order.beginTime},
                '%y-%m-%d-%T'))
            </if>
            <if test="null != order.finishTime">
                AND (DATE_FORMAT(wo.generate_time, '%y-%m-%d-%T') <![CDATA[ <= ]]> DATE_FORMAT(#{order.finishTime},
                '%y-%m-%d-%T'))
 </if>

//MySQL中find_in_set()和in的区别
//可以检索出 目标字段 包含检索内容，逗号分割的目标字段
FIND_IN_SET(检索内容,检索目标)
//in()可以检索 多个目标字段
检索目标 in(内容1,内容2,内容3)

//可空
Dict dict = Optional.ofNullable(dictService.getOne(Wrappers.<Dict>lambdaQuery()
			.eq(Dict::getCode, "wis_positional")
			.eq(Dict::getDictKey, doctorInfo.getPositional()))).orElseGet(Dict::new);
		detail.setPositionalId(dict.getDictValue());

StringUtils.join(messageCustom.getRemindFrequencyList(), ",")  可以将集合转换成字符串 以逗号分割

//集合去重

@Test
public void listDistinctByStreamDistinct() {
  // 1. 对于 String 列表去重
  List<String> stringList = new ArrayList<String>() {{
    add("A");
    add("A");
    add("B");
    add("B");
    add("C");
  }};
  out.print("去重前：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
  stringList = stringList.stream().distinct().collect(Collectors.toList());
  out.print("去重后：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
}
-----------
去重前：AABBC
去重后：ABC

@Test
  public void distinctByProperty2() throws JsonProcessingException {
    // 这里第二种方法我们通过过滤来实现根据对象某个属性去重
    ObjectMapper objectMapper = new ObjectMapper();
    List<Student> studentList = getStudentList();
 
    out.print("去重前        :");
    out.println(objectMapper.writeValueAsString(studentList));
    studentList = studentList.stream().distinct().collect(Collectors.toList());
    out.print("distinct去重后:");
    out.println(objectMapper.writeValueAsString(studentList));
    // 这里我们将 distinctByKey() 方法作为 filter() 的参数，过滤掉那些不能加入到 set 的元素
    studentList = studentList.stream().filter(distinctByKey(Student::getName)).collect(Collectors.toList());
    out.print("根据名字去重后 :");
    out.println(objectMapper.writeValueAsString(studentList));
  }
  ---------------------------------
  
去重前        :[{"stuNo":"001","name":"Tom"},{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
distinct去重后:[{"stuNo":"001","name":"Tom"},{"stuNo":"003","name":"Tom"}]
根据名字去重后 :[{"stuNo":"001","name":"Tom"}]

/**
     * 通过反射判定所需字段是否不能为空
     * @param context 上下文
     * @param cs 类名
     * @param object 带有值的实体类
     * @return true为有必填项为空值
     */
    public static Object checkInfo(String context, Class<?> cs, Object object) throws IllegalAccessException {
        boolean result = false;
        if(null != cs){
            //获取类对象中所有字段
            Field[] declaredFields = cs.getDeclaredFields();
            //遍历每个字段
            for (Field field : declaredFields){
                //判断字段是否有注释     FieldAnnotate
                if(field.isAnnotationPresent(ApiModelProperty.class)){
                    //获得这个字段上所有的注释
                    ApiModelProperty annotation = field.getAnnotation(ApiModelProperty.class);
                    //反射可以访问私有字段
                    field.setAccessible(true);
                    //判断字段是否必填项
                    if(annotation.required()==true){
                        //获取object对象这个Field上的值
                        Object obj = field.get(object);
                        result = obj == null;
                        //判断必填项字段是不是空的
                        if(!result){
                            result = TextUtils.isEmpty(obj.toString());
                        }
                        if(result) {
                            throw new IllegalStateException(annotation.value() + "为空，操作失败！");
                        }
                    }
                }
            }
        }
        return result;
    }

监听器 监听某个参数变化

import { watch, ref} from 'vue';
    //监听数数据变化
    const ref1 = ref(false);
    watch(ref1, (newValue, oldValue) => {
      console.log("监听器更新前：", newValue, "监听器更新后：", oldValue);
      if (oldValue == true) {
        methods.clearSearchData();
      }

		return {
			ref1
		}

ant vue3表格选择框禁用

	getCheckboxProps: checkboxProps,
     checkboxProps: (record) => {
        return {
          disabled: record.status === 'GENERATE',
        };
      },