工具类代码

2021-09-03

后端

mybatis plus的查询语句

1	User user = userMapper.selectOne(new QueryWrapper <User>().lambda().eq(User::getId, id));

复制值

1	BeanUtils.copyProperties(原对象, 新对象, "忽略字段"); //只要属性匹配，源类和目标类不必匹配，甚至可以相互派生

时间

获取当前时间

//new Date()    得到Date类型
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
System.out.println(df.format(new Date()));// new Date()为获取当前系统时间

//Calendar.getInstance().getTime()  得到Date类型
SimpleDateFormat df= new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z");
Date date = new Date(System.currentTimeMillis());
System.out.println(df.format(date));
注：此方法会根据我们的系统时间返回当前值，因为世界各地的时区是不一样的

//System.currentTimeMillis()   得到long类型
Calendar calendar = Calendar.getInstance(); // gets current instance of the calendar    
SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss"); 
System.out.println(formatter.format(calendar.getTime()));

java8之后
//LocalDate.now()     得到LocalDate类型 只有年月日，没有具体时间
LocalDate date = LocalDate.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy"); 
System.out.println(date.format(formatter));

//LocalTime.now()  得到LocalTime类型，只有具体时间，没有年月日

//LocalDateTime.now() 得到LocalDateTime类型。是Java中最常用的Date / Time类
LocalDateTime dateTime = LocalDateTime.now(); // gets the current date and time
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss"); 
System.out.println(dateTime.format(formatter));

hutool工具
//DateUtil.now() 得到String类型
String time = DateUtil.now();

关于时间的转换

1、LocalDateTime可以做日期的加减很方便
2、OffsetDateTime计算00:00:00及23:59:59很方便

//Date转LocalDateTime
		// 方法一
        LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        // 方法二
        return LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        
//LocalDateTime转Date
		return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());

//时间字符串String转LocalDateTime
		return LocalDateTime.parse(dateStr, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

//Date转OffsetDateTime
		// 方法一
        OffsetDateTime offsetDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toOffsetDateTime();
        // 方法二
        return ZonedDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault()).toOffsetDateTime();

		OffsetDateTime offsetDateTime = ZonedDateTime.ofInstant
            (new Date().toInstant(), ZoneId.systemDefault()).toOffsetDateTime();
		//2021-09-05T11:43:09.697+08:00
        OffsetDateTime with = offsetDateTime.with(LocalTime.MAX);
		//2021-09-05T23:59:59.999999999+08:00
        OffsetDateTime  endDateTime = offsetDateTime.with(LocalTime.MIN);
		//2021-09-05T00:00+08:00

//OffsetDateTime转Date
		return Date.from(offsetDateTime.atZoneSameInstant(ZoneId.systemDefault()).toInstant());

//OffsetDateTime转LocalDateTime
		return LocalDateTime.ofInstant(offsetDateTime.atZoneSameInstant(ZoneId.systemDefault()).toInstant(), ZoneId.systemDefault());

//获取整点时间  10点48返回10点
		LocalDateTime dateTime = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
        return Date.from(LocalDateTime.of(dateTime.toLocalDate(), LocalTime.of(dateTime.getHour(), 0, 0)).atZone(ZoneId.systemDefault()).toInstant());

//LocalDateTime 转 时间戳（秒级）
		 1.// 获得当前时间
        LocalDateTime localDateTime = LocalDateTime.now();
        // 将当前时间转为时间戳
        long second = localDateTime.toEpochSecond(ZoneOffset.ofHours(8));
        System.out.println(second);
		
		2.// 获得当前时间
        LocalDateTime localDateTime = LocalDateTime.now();
        // 将当前时间转为时间戳
        long second = localDateTime.toInstant(ZoneOffset.ofHours(8)).getEpochSecond();
        System.out.println(second);

		3. // 获得当前时间
        LocalDateTime localDateTime = LocalDateTime.now();
        // 将当前时间转为时间戳（毫秒级）
        long milliseconds = localDateTime.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
        System.out.println(milliseconds / 1000);

//时间戳 转LocalDateTime
		1.//获得时间戳
        long second = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).getEpochSecond();
        // 将时间戳转为当前时间
        LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(second, 0, ZoneOffset.ofHours(8));
        System.out.println(localDateTime);

        2.//获得时间戳
        long milliseconds = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        // 将时间戳转为当前时间
        LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(milliseconds / 1000, 0, ZoneOffset.ofHours(8));
        System.out.println(localDateTime);

        3.//获得时间戳
        long milliseconds = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        // 将时间戳转为当前时间
        LocalDateTime localDateTime = Instant.ofEpochMilli(milliseconds).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
        System.out.println(localDateTime);

//时间戳转LocalDate
		//获得时间戳
        long milliseconds = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        // 将时间戳转为当前时间
        LocalDate localDate = Instant.ofEpochMilli(milliseconds).atZone(ZoneOffset.ofHours(8)).toLocalDate();
        System.out.println(localDate);

 		//获得时间戳
        long seconds = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).getEpochSecond();
        // 将时间戳转为当前时间
        LocalDate localDate = Instant.ofEpochSecond(seconds).atZone(ZoneOffset.ofHours(8)).toLocalDate();
        System.out.println(localDate);

//LocalDate 转 时间戳
		LocalDate localDate = LocalDate.now();
        //获得时间戳
        long seconds = localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().getEpochSecond();
        System.out.println(seconds);

        LocalDate localDate = LocalDate.now();
        //获得时间戳
        long seconds = localDate.atStartOfDay(ZoneOffset.ofHours(8)).toInstant().toEpochMilli();
        System.out.println(seconds);

两个List集合求交集、并集和差集

public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("a");
        stringList.add("b");
        stringList.add("c");
        stringList.add("i");
        stringList.add("j");
        stringList.add("a");
 
        //一、求交集
        //方法1：直接通过retainAll直接过滤
        List<String> stringList1 =  new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        stringList1.retainAll(stringList);
        System.out.println("交集1: " + stringList1);
        //交集1: [a, b, c]
 
        //方法2：通过过滤掉存在于stringList的数据
        List<String> stringList1_2 = new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        List<String> strings = stringList1_2.stream()
                .filter(item -> stringList.contains(item))
                .collect(toList());
        System.out.println("交集2：" + strings);
 		//交集2：[a, b, c]
 
        //二、并集
        //有重并集 addAll
        List<String> stringList2 =  new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        stringList2.addAll(stringList);
        System.out.println("并集: " + stringList2);
 		//并集: [a, b, c, d, e, f, g, h, a, b, c, i, j, a]
 		
        //无重并集 removeAll和addAll
        List<String> stringList2_2 =  new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        List<String> stringList_1 =  new ArrayList<>(Arrays.asList("a,b,c,i,j,a".split(",")));
        stringList2_2.removeAll(stringList_1);
        stringList_1.addAll(stringList2_2);
        System.out.println("无重并集: " + stringList_1);
        //无重并集: [a, b, c, i, j, a, d, e, f, g, h]
 
        //三、求差集
        //方法1：直接使用removeAll()方法
        List<String> stringList3 =  new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        stringList3.removeAll(stringList);
        System.out.println("差集1: " + stringList3);
        //差集1: [d, e, f, g, h]
 
        //方法2：通过过滤掉不存在于stringList的数据，然后和本数组进行交集处理
        List<String> stringList3_2 = new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        stringList3_2.retainAll(stringList3_2.stream()
                .filter(item -> !stringList.contains(item))
                .collect(toList()));
        System.out.println("差集2：" + stringList3_2);
 		//差集2：[d, e, f, g, h]
}

list赋值问题

如果使用了赋值方式，如 list1 = list0 ，然后 list1.retainAll(list2) 或者 list1.removeAll(list2)其实list0的值也变化了。因为lis1和list0指向了同一个地址

List<String> s1 = new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        List<String> s2 = s1;
        System.out.println("s1地址和s2是否相等（是否为同一个对象）: " + (s1 == s2));
        s2.remove("g");
        s2.remove("h");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
        
s1地址和s2是否相等（是否为同一个对象）: true
s1: [a, b, c, d, e, f]
s2: [a, b, c, d, e, f]

而如果使用 List list1= new ArrayList<>(list0);

List<String> s1 = new ArrayList<>(Arrays.asList("a,b,c,d,e,f,g,h".split(",")));
        List<String> s2 = new ArrayList<>(s1);
        System.out.println("s1地址和s2是否相等（是否为同一个对象）: " + (s1 == s2));
        s2.remove("g");
        s2.remove("h");
        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
        s1地址和s2是否相等（是否为同一个对象）: false
        
s1地址和s2是否相等（是否为同一个对象）: false
s1: [a, b, c, d, e, f, g, h]
s2: [a, b, c, d, e, f]

我们在使用 removeAll() 方法时，有时候会遇到报错或者失效的情形，比如List中是一个一个对象类，且没有重写过equals和hashCode方法，就会带来这种不相等的情况，从而导致失效

addAll

arraycopy

clone

Arrays.copyOf

for

前后端接口

传递参数

GET

前端：
this.$request.get('/gatewayInfo/' + this.form.gatewayNum)
后端：
	@GetMapping("/gatewayInfo/{gatewayNum}")
	public R getGatewayInfo(@PathVariable String gatewayNum) throws UserNotExistException {
    	return deviceInfoService.getGatewayByGatewayNum(gatewayNum);
	}

前端：
let tel =this.myform.tel;
this.$request.get(`/login/${tel}`)
后端：
    @GetMapping("/login/{tel}")
    public R loginVerifycode(@PathVariable(value = "tel") String tel) throws ClientException {
        return loginService.getLoginVerifyCode(tel);
    }

前端：
this.$request.get("/ticket?url=" + url)
后端：
	@GetMapping("/ticket")
    public R getTicket(String url) {
    }
    
前端：    
this.$request.get(`/shop/order/buy?productId=` + this.productId)
后端：
 	@GetMapping("/buy")
    public R getOrderProductDTO(@RequestParam Integer productId) {
        return productOrderDetailService.getOneOrderProductDTO(productId);
    }

POST

前端：
this.$request.post("/login", this.myform)
后端：
    @PostMapping("/login")
    public R doLogin(@RequestBody LoginDTO loginDTO) throws UserNotExistException {
        return loginService.loginAdmin(loginDTO);
    }

前端：
this.$request.post('/gateway/addGateway', {gatewayName: this.virtualGatewayName,orderSn: this.orderSn})
后端：
 @PostMapping("/addGateway")
 public R addGateway(@RequestBody GatewayDTO gatewayDTO) throws UserNotExistException {
        return gatewayService.addGateway(gatewayDTO);
}

发送post请求的工具方法

    public static String sendPost(String url, String data) {
        String response = "";
        try {
            HttpPost post = new HttpPost(url);
            //设置请求头
            post.setHeader("Content-Type", "application/json");
            post.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36");
			
            //设置请求体
            StringEntity s = new StringEntity(data, "utf-8");
            s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
            post.setEntity(s);

            // 发送请求
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
            CloseableHttpResponse closeableHttpResponse = closeableHttpClient.execute(post);

            // 获取响应输入流
            InputStream contentInputStream = closeableHttpResponse.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(contentInputStream, "utf-8"));
            StringBuilder stringBuilder = new StringBuilder();
            String line;
            while (null != (line = reader.readLine())) {
                stringBuilder.append(line).append("\n");
            }
            contentInputStream.close();

            response = stringBuilder.toString();
        } catch (Exception e) {
            log.error("后端发送POST出错：{}", e.toString());
        }
        return response;
    }
    
//发送带head的post请求
    public static String sendPost(String url, String data, String authorization) {
        String response = "";
        String contentType = "application/json";
        try {
            //设置参数
            HttpPost post = new HttpPost(url);
            post.setHeader("Content-Type", contentType);
            post.setHeader("Authorization", authorization);
            post.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36");
            post.setEntity(new StringEntity(data, "utf-8"));

            // 发送请求
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            CloseableHttpClient closeableHttpClient = httpClientBuilder.build();
            CloseableHttpResponse closeableHttpResponse = closeableHttpClient.execute(post);

            // 获取响应输入流
            InputStream contentInputStream = closeableHttpResponse.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(contentInputStream, "utf-8"));
            StringBuilder stringBuilder = new StringBuilder();
            String line;
            while (null != (line = reader.readLine())) {
                stringBuilder.append(line).append("\n");
            }
            contentInputStream.close();

            response = stringBuilder.toString();
        } catch (Exception e) {
            log.error("后端发送POST出错：{}", e.toString());
        }
        return response;
    }

发送GET请求的工具方法

	public static String doGet(String url) throws IOException {
        StringBuilder json = new StringBuilder();
        String lines;
        URL getUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();
        try (InputStream inputStream = connection.getInputStream();
             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
             BufferedReader reader = new BufferedReader(inputStreamReader)) {
            connection.connect();
            while (null != (lines = reader.readLine())) {
                json.append(lines);
            }
        }
        if (null != connection) {
            connection.disconnect();
        }
        return json.toString();
    }

//发送带head的get请求
    public static String doGet(String url, String authorization) throws IOException {
        StringBuilder json = new StringBuilder();
        String lines;
        URL getUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();
        connection.setRequestProperty("Authorization", authorization);
        try (InputStream inputStream = connection.getInputStream();
             InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
             BufferedReader reader = new BufferedReader(inputStreamReader)) {
            connection.connect();
            while (null != (lines = reader.readLine())) {
                json.append(lines);
            }
        }
        if (null != connection) {
            connection.disconnect();
        }
        return json.toString();
    }

获取请求者ip的工具方法

public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

正则

对非法字符校验

if(new RegExp("[^a-zA-Z0-9\_\u4e00-\u9fa5]","i").test(this.name)){
          this.$toast.fail('用户名中包含非法字符');
          this.name=""
}

手机号的正则表达式

1
2
3

/^[1][3-9][0-9]{9}$/
/^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/
/^1[3456789]\d{9}$/

前端

localStorage

创建缓存:localStorage.setItem('userInfo', userInfo);

读取缓存:localStorage.getItem('doEdit', this.doEdit);

清除所有缓存:localStorage.clear();

清楚指定缓存:localStorage.removeItem('userinfo');

用ES6的类来封装，写一个function给localStorage设置过期时间：

引入这个class可以参考：https://blog.csdn.net/zgh0711/article/details/80432609

本质就是写一个js文件，然后main.js中import ，将它挂载到 vue 对象的原型上

//先 import 引入
import {storage} from './utils/storage'
//阻止显示在生产环境下的不必要的额外消息（这些消息开发时便于调试，生产环境下没有用处）
Vue.config.productionTip = false;
//将 myUtils 挂载到 vue 的原型上
Vue.prototype.storage = new storage();

在组件中可以直接调用相应的方法

this.storage.setItem({
      name:"name",
      value:"XXX",
      expires: "",
    })

写好的class：

export class storage{
        constructor(name){
            this.name = 'storage';
        }
        //设置缓存
        setItem(params){
            let obj = {
                name:'',
                value:'',
                expires:"",
                startTime:new Date().getTime()//记录何时将值存入缓存，毫秒级
            }
            let options = {};
            //将obj和传进来的params合并
            Object.assign(options,obj,params);
            if(options.expires){
            //如果options.expires设置了的话
            //以options.name为key，options为值放进去
                localStorage.setItem(options.name,JSON.stringify(options));
            }else{
            //如果options.expires没有设置，就判断一下value的类型
               	let type = Object.prototype.toString.call(options.value);
               	//如果value是对象或者数组对象的类型，就先用JSON.stringify转一下，再存进去
                if(type == '[object Object]'){
                    options.value = JSON.stringify(options.value);
                }
                if(type == '[object Array]'){
                    options.value = JSON.stringify(options.value);
                }
                localStorage.setItem(options.name,options.value);
            }
        }
        //拿到缓存
        getItem(name){
            //需要先判空
            if(!item) return false;
            let item = localStorage.getItem(name);
            //先将拿到的试着进行json转为对象的形式
            try{
                item = JSON.parse(item);
            }catch(error){
            //如果不行就不是json的字符串，就直接返回
                item = item;
            }
            //如果有expires的值，说明设置了失效时间
            if(item.expires){
                let date = new Date().getTime();
                //何时将值取出减去刚存入的时间，与item.expires比较，如果大于就是过期了，如果小于或等于就还没过期
                if(date - item.startTime > item.expires){
                //缓存过期，清除缓存，返回false
                    localStorage.removeItem(name);
                    return false;
                }else{
                //缓存未过期，返回值
                    return item.value;
                }
            }else{
            //如果没有设置失效时间，直接返回值
                return item;
            }
        }
        //移出缓存
        removeItem(name){
            localStorage.removeItem(name);
        }
        //移出全部缓存
        clear(){
            localStorage.clear();
        }
    }

修改密码

修改mysql

登录到mysql mysql -uroot -p原密码 –>

本地密码：set password for root@'localhost' = password('新密码');

远程连接密码：set password for root@'%' = password('新密码');

修改redis

找到redis.conf配置文件 –>requirepass 新密码 –>重启redis

修改linux服务器

以root身份登录 –> passwd root –>输入新密码 –>确认密码 –> 新密码重新登录