【问题来源】【必填】【可选问题来源：某地12345新建AICC项目】【问题简要】：UAP与第三方软交换sip中继对接，SCE通过重定向cell转到第三方软交换，比如uap分机为8001，was被叫配置为1001，流程为重定向GSL，重定向的号码为2001，8001呼叫1001，重定向到2001至第三方平台，第三方平台收到呼叫信息：主叫8001，被叫2001                        现在第三方平台想要收到原始的被叫号码1001，uap或者was要怎么设置才能实现这个需求【AICC解决方案版本】【AICC可选择版本：AICC 8.15.0】【UAP可选择版本：UAP9600 V100R005C00SPC026】【CTI可选择版本：ICD V300R008C23】【期望解决时间】越快越好

各位大佬们最近有在找工作的吗？行情咋样啊，想先了解一下情况。

function working_version_num() does not exist

 在初学Java的时候，一般我们都会从基本的数据类型开始学习，而在基本数据类型中，我认为double类型是比较难理解的，并且在以后的学习或工作中，在double类型数据这遇到的坑也是极多的。例如下面的这样一个程序public static void main(String[] args) {  System.out.println(2.0-1.1);  }  很多人会认为上面的程序会打印出0.9，但实际上，它打印的却是0.8999999999999999，这是为什么呢？  首先介绍一下，十进制小数是怎么转换为二进制数的，举个例子3.75  首先取出3.75的小数部分0.75，将其乘以要转换的进制的进制数，在这里也就是2，乘以2后得到结果1.5，取1.5的整数部分作为二进制小数的小数部分的第一位，再取1.5的小数部分0.5,乘以2后得到1.0，将1.0的整数部分1作为小数部分的第二位。以此类推，直到最后得到值0或形成无限循环。3.75转换为二进制数就是11.11；  但是我们知道在Java中double类型的数据占8个字节，所以对于无限循环的二进制小数我们只能取到它的近似值，就比如说1.1。  下面自己写了一个将double类型的数转换为二进制的程序public static void main(String[] args) {  doubleToBinary(3.75000000);  doubleToBinary(173.8125);  doubleToBinary(1.10);  }/**  * 10任何次负幂都不能精确地被表示为一个长度有限的二进制数  * @param d  */public static void doubleToBinary(double d) {    // 获得double类型的整数部分  int intPart = (int) d;  String tempStr = d + "";    // 获得double类型数的字符串形式的小数部分  String decimalPartStr = tempStr.substring(tempStr.indexOf("."));  BigDecimal decimal = new BigDecimal(decimalPartStr);    // 获得小数点后面的位数  int precision = decimal.precision();    // 最终的小数部分二进制字符串  String decimalPartBinary = decimalPartToBinary(Double.parseDouble(decimalPartStr), precision);  System.out.println(Integer.toBinaryString(intPart) + "." + decimalPartBinary);  }/**  * 将小数部分转换为二进制字符串  * @param decimalPart 小数部分  * @param precision   原始数的小数部分位数  * @return*/public static String decimalPartToBinary(double decimalPart, int precision) {    // 转换为整型  long decimalPartLong = (long) (Math.pow(10, precision) * decimalPart);  String temp = "";    int i = 0;    while (precision > 0 && i   decimalPartLong = decimalPartLong * 2;  temp += (int) (decimalPartLong / Math.pow(10, precision));        //取得除第一位之后的数，并转换为字符串  String str = (long) (decimalPartLong % Math.pow(10, precision)) + "";        if (str.charAt(str.length() - 1) == '0' && str.length() != 1) {            //去掉数最后面的0  decimalPartLong = Long.parseLong(str.substring(0, str.length() - 1));  } else {  decimalPartLong = Long.parseLong(str);  }        if (decimalPartLong == 0) {            break;  }  ++i;  precision = (decimalPartLong + "").length();  }    return temp;  }  上面程序中的main方法输出的值为11.1110101101.11011.0001100110011001100110011001100110011001100110011001100110011001  通过上面的程序，我们很容易看到测试数据1.10在小数部分是无限循环的，1.10并不能精确地表示为一个double，因此它在Java中被表示为最接近它的double值。既然Java中是对double不能精确表示的数以近似值去存储的，那么在一些需要精确计算的地方就有可能出现错误，甚至产生意想不到的结果。比如说在业务中经常碰到的货币计算。那么如何解决这个问题呢？  1.使用执行精确小数运算的BigDecimalAPI，但这里要说明一点，最好(一定)要用BigDecimal(String val)构造方法，而不要使用BigDecimal(double val)，因为BigDecimal(double val)构造方法将会使用它的参数val的精确值返回一个BigDecimal，比如new BigDecimal(1.1)将会返回一个表示1.100000000000000088817841970012523233890533447265625的BigDecimal。  2.使用整数类型进行计算，比如说int或long。将2.0元转换为200分去计算，这样System.out.println((200-110)+ "分")将会打印出正确的结果90分。  总而言之呢，在需要精确计算的地方要避免使用float和double的数据。如果上面的程序有错的地方，请指出，共同学习，谢谢。  作者：Jadyn  链接：https://www.jianshu.com/p/82688c94c58c 

2023年2月论坛问题合集1.Gauss DB 查询数据库全量表的行信息问题cid:link_1华为云serverless函数的vCPU是如何配置的？cid:link_2调用CMS 接口获取技能组队列实时监控指标，无法获取数据 cid:link_3hive客户端中执行add jar提示没有权限 cid:link_4预测在线服务报408的4205错误cid:link_5登录失败，错误码：50331748cid:link_6怎么通过定制方式把高德地图的最大显示层级放大 cid:link_7刚刚绑定域名，手机访问网站就显示网站有违法和违规内容这个怎么办，这样可以通过公安备案吗？cid:link_8登录iClient客户端，使用登录中的ip及端口号+接口文档里的接口地址，访问超时cid:link_9新手，调用华为云obs的SDK代码怎么整啊，有没有大佬教一下，有偿，装的eclipsecid:link_0播放输入V9.0无法收号cid:link_10下载WeAutomate完，安装驱动时，怎么也导入不了chrome的驱动https://bbs.huaweicloud.com/forum/thread-0223111236431889032-1-1.html

一、在注册或者使用chatGPT之前要做的准备工作。1、首先要做的，是开启全局代理。2、进入chatGPT网址：  Access denied (openai.com)  cid:link_03、没有账号的朋友还得准备虚拟短信验证码的网址： https://sms-activate.org/cn​4、有账号的朋友直接登录就行了。以上就是所有的准备工作。二、chatGPT注册过程及使用过程中报错解决方法。1、Access denied，报错1020    (发生在注册时，或者之前已经注册好，而且能使用，但现在突然报这种错误)这个错误是一个比较常见的错误。有朋友说，准备注册账号，但是进入上面的chatGPT网址，报了这个错误，这是因为你没有开启全局代理就直接访问，这是不行的，这样永远访问不了。  还有朋友说，我准备注册个账号，全局代理也开了，但是还是报这个错误，这就跟你的全局代理有关系，这个时候你就需要换其它的全局代理了。还有朋友说，我买了一个账号，但是现在登录不了，显示这个错误，这还是跟你的全局代理有关系。还有朋友说，我之前用的好好的，账号也已经注册好了，但是现在突然显示这个错误，还是一样，还是跟代理有关。综上，第一个错误的解决方法是，更换全局代理，越冷门的反而越好用。2、not  available  in  your  country（发生在注册时，或者之前已经注册好，而且能使用，但现在突然报这种错误）这个错误也是一个比较常见的错误。有朋友说，自己在sign up也就是注册账号的时候，出现了这个错误，这个错误出现的原因有两个，第一个是你没有开启全局代理或者代理不行；第二个是cookie的问题，可以在浏览器设置，cookie选项中删除全部cookie尝试；第三个原因是浏览器的问题，这个时候你可以尝试用无痕打开网页；这是可行的一个方法。还有朋友说，自己之前已经注册过账号了，并且也开启全局代理了，但是这几天登录的时候，突然显示这个错误，解决方法还是跟上面一样的三种方法。还有朋友说，我是在注册过程中，已经在sms上接收到验证码了，但是，把验证码填进去，给我显 示这个报错，这是因为你之前用港澳台或国内ip登录过了，不管什么设备，请勿使用港澳台及内地ip登录，否则不进行java操作，无论怎么换站点，永远都显示not available在你浏览器的地址栏输入javascript:     冒号后面复制以下以下这一段编码window.localStorage.removeItem(Object.keys(window.localStorage).find(i=>i.startsWith(‘@@auth0spajs’)))回车清理浏览器cookie重启重启完先全局连非港澳台ip不然就换设备，代理用全局综上，第二个错误的解决方法是，更换全局代理，或者浏览器使用无痕模式，或者在你浏览器的地址栏输入javascript:     冒号后面复制以下以下这一段编码window.localStorage.removeItem(Object.keys(window.localStorage).find(i=>i.startsWith(‘@@auth0spajs’)))回车清理浏览器cookie重启重启完先全局连非港澳台代理3、chatgpt is at capacity right now（发生在注册时，或者之前已经注册好，而且能使用，但现在突然报这种错误）这个错误也是一个比较常见的错误。大家都说这个错误没办法解决，因为这是服务器本身的问题，但我想说的是，也是有解决的办法的，那就是“挤进”服务器。如何“挤进去”呢？疯狂刷新网页，你会留意到刷新的时候能出来登录界面，只要在这个时候停下来就行了。综上，此问题解决方法是，疯狂刷新网页，即可“挤进服务器”。4、报404 502   错误这个错误解决很简单，重新进一下网址就好了。5、Signup is currently unavailable, please try again later.（出现在注册账号的时候）这个错误出现的大多数原因是，网易163邮箱用不了了，大家选择QQ邮箱注册，或者微软跟谷歌账号。总结以上就是chatGPT使用及注册过程中常见的一些错误的解决方法。转载自https://www.jb51.net/article/274727.htm

 缓冲流概述 缓冲流介绍:  缓冲流也称为高效流、或者高级流。之前学习的字节流和字符流可以称为原始流。  作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能   缓冲流分为: 字节缓存输入流、字节缓冲输出流、字符缓冲输入流、字符缓冲输出流   字节缓冲流 字节缓冲输入流：BufferedInputStream，提高字节输入流读取数据的性能，读写功能上与原始流相比并无变化。  字节缓冲输出流：BufferedOutputStream，提高字节输出流读取数据的性能，读写功能上与原始流相比并无变化。  字节缓冲流性能优化原理:  字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。  字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。  将原始流包装为缓冲流的构造器如下:  构造器    说明 BufferedInputStream(InputStream is)    可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道，从而提高字节输入流读数据的性能 BufferedOutputStream(OutputStream os)    可以把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能 public static void main(String[] args) throws Exception {     // 创建原始字节输入流     InputStream is = new FileInputStream("/Users/chenyq/Documents/test.txt");     // 创建原始字节输出流     OutputStream os = new FileOutputStream("/Users/chenyq/Documents/test1.txt");      // 将低级的字节输入流包装为高级的缓存输入流     InputStream bis = new BufferedInputStream(is);     // 将低级的字节输出流包装为高级的缓存输出流     OutputStream bos = new BufferedOutputStream(os); } 读写功能和之前原始流的读写并无区别:  public static void main(String[] args) {     try (             // 创建原始字节输入流             InputStream is = new FileInputStream("/Users/chenyq/Documents/test.txt");             // 创建原始字节输出流             OutputStream os = new FileOutputStream("/Users/chenyq/Documents/test1.txt");              // 将低级的字节输入流包装为高级的缓存输入流             InputStream bis = new BufferedInputStream(is);             // 将低级的字节输出流包装为高级的缓存输出流             OutputStream bos = new BufferedOutputStream(os);     ) {         // 文件拷贝: 读写操作         byte[] arr = new byte[1024];         int len;         while ((len = bis.read(arr)) != -1) {             bos.write(arr, 0, len);         }     } catch(Exception e) {         e.printStackTrace();     } } 字符缓存流 字符缓存输入流  字符缓冲输入流：实现类BufferedReader。  作用：提高字符输入流读取数据的性能，除此之外多了按照行读取数据的功能。  字符缓存输入流构造器如下:  构造器    说明 BufferedReader(Reader r)    可以把低级的字符输入流包装成一个高级的缓冲字符输入流管道，从而提高字符输入流读数据的性能 public static void main(String[] args) throws Exception {     // 创建原始字符输入流     Reader r = new FileReader("/Users/chenyq/Documents/test.txt");     // 将原始字符输入流包装为字符缓存输入流     Reader br = new BufferedReader(r); } 字符原始输入流的方法字符缓存输入流同样适用:  public static void main(String[] args) {     try (             // 创建原始字符输入流             Reader r = new FileReader("/Users/chenyq/Documents/test.txt");             // 将原始字符输入流包装为字符缓存输入流             Reader br = new BufferedReader(r);             ){         // 读取文件         char[] arr = new char[1024];         int len;         while ((len = br.read(arr)) != -1) {             String res = new String(arr, 0, len);             System.out.println(res);         }     } catch (Exception e) {         e.printStackTrace();     } } 字符缓存输入流在原有的方法上新增了方法:  方法    说明 readLine()    读取一行数据, 并返回该行内容的字符串，无行可读返回null 按行读取: 普通方法  public static void main(String[] args) {     try (             Reader r = new FileReader("/Users/chenyq/Documents/test.txt");             BufferedReader br = new BufferedReader(r);             ){          // 读取第一行         System.out.println(br.readLine());      } catch (Exception e) {         e.printStackTrace();     } } 按行读取: 循环方法  public static void main(String[] args) {     try (             Reader r = new FileReader("/Users/chenyq/Documents/test.txt");             BufferedReader br = new BufferedReader(r);             ){          String res;         while ((res = br.readLine()) != null) {             System.out.println(res);         }      } catch (Exception e) {         e.printStackTrace();     } } 字符缓存输出流:  字符缓冲输出流：实现类BufferedWriter。  作用：提高字符输出流写取数据的性能，除此之外多了换行功能  字符缓存输出流构造器如下:  构造器    说明 BufferedWriter(Writer w)    可以把低级的字符输出流包装成一个高级的缓冲字符输出流管道，从而提高字符输出流写数据的性能 public static void main(String[] args) throws Exception {     Writer w = new FileWriter("/Users/chenyq/Documents/test.txt");     // 将原始字符输出流包装为缓冲输出流     Writer bw = new BufferedWriter(w); } 字符缓存输出流新增功能:  当然原生输输出流的功能同样可以使用  方法    说明 newLine()    换行操作 public static void main(String[] args) {     try (             Writer w = new FileWriter("/Users/chenyq/Documents/test.txt", true);             BufferedWriter bw = new BufferedWriter(w);             ){         // 定义一个字符数组         char[] arr = {'我', '爱', 'C', 'h', 'i', 'n', 'a'};         // 定义一个字符串         String str = "我爱学习Java";          // 写入一个字符         bw.write('我');         bw.write(98);         // 换行         bw.newLine();          // 写入一个字符数组         bw.write(arr);         // 换行         bw.newLine();          // 写入字符数组的一部分         bw.write(arr, 1, 3);         // 换行         bw.newLine();          // 写入一个字符串         bw.write(str);         // 换行         bw.newLine();          // 写入一个字符串的一部分         bw.write(str, 0, 4);         // 换行         bw.newLine();     } catch (IOException e) {         throw new RuntimeException(e);     } } ———————————————— 版权声明：本文为CSDN博主「学全栈的灌汤包」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/m0_71485750/article/details/127601905 

 一、前言介绍：         随着社会的发展和科学技术的进步，互联网技术越来越受欢迎。网络传播的生活方式逐渐受到广大人民群众的喜爱。越来越多的互联网爱好者开始在互联网上满足他们的基本需求，同时逐渐进入各个用户的生活起居。互联网具有许多优点，例如便利性，速度，高效率和低成本。因此，类似于驾校管理，满足用户工作繁忙的需求，不仅是方便用户随时查看信息的途径，而且还能提高管理效率。本文首先以驾校管理过程的基本问题作为研究对象。在开发系统之前，我们对现有状况进行了详细的调查和分析。最后，我们利用计算机技术开发了一套完整合适的驾校管理。该系统的实现主要优势是：该系统主要采用计算机技术开发，它方便快捷；系统可以通过管理员界面查看系统所涉及的驾校管理所有信息管理。          驾校管理软件是一款方便、快捷、实用的信息服务查询软件。随着智能网络在全球市场的不断普及以及各种智能平台的使用，作为中国主流智能的技术开发系统，自然需要这样的软件来满足更多用户的需求和体验。系统的开发与人们的日常需求相关，如通过管理系统获取到个人中心、学员管理、驾校教练管理、预约教练管理、预约教练管理、评价教练管理、考试成绩管理、考试通知管理、报考信息管理、练车通知管理、预约练车管理、驾考套餐管理、报名信息管理、车辆信息管理等信息详细情况，了解最新资讯信息等。  二、主要技术：  2.1  Spring Boot框架介绍：         Spring框架是Java平台上的一种开源应用框架，提供具有控制反转特性的容器。尽管Spring框架自身对编程模型没有限制，但其在Java应用中的频繁使用让它备受青睐，以至于后来让它作为EJB（EnterpriseJavaBeans）模型的补充，甚至是替补。Spring框架为开发提供了一系列的解决方案，比如利用控制反转的核心特性，并通过依赖注入实现控制反转来实现管理对象生命周期容器化，利用面向切面编程进行声明式的事务管理，整合多种持久化技术管理数据访问，提供大量优秀的Web框架方便开发等等。Spring框架具有控制反转（IOC）特性，IOC旨在方便项目维护和测试，它提供了一种通过Java的反射机制对Java对象进行统一的配置和管理的方法。Spring框架利用容器管理对象的生命周期，容器可以通过扫描XML文件或类上特定Java注解来配置对象，开发者可以通过依赖查找或依赖注入来获得对象。Spring框架具有面向切面编程（AOP）框架，SpringAOP框架基于代理模式，同时运行时可配置；AOP框架主要针对模块之间的交叉关注点进行模块化。Spring框架的AOP框架仅提供基本的AOP特性，虽无法与AspectJ框架相比，但通过与AspectJ的集成，也可以满足基本需求。Spring框架下的事务管理、远程访问等功能均可以通过使用SpringAOP技术实现。Spring的事务管理框架为Java平台带来了一种抽象机制，使本地和全局事务以及嵌套事务能够与保存点一起工作，并且几乎可以在Java平台的任何环境中工作。  2.2 MYSQL数据库：                 数据库是系统开发过程中不可或缺的一部分。 在WEB应用方面，MySQL AB开发了一个具有很大优势的MySQL关系数据库管理系统。 MySQL可以将数据存储在不同的表中，这非常灵活，并且还可以提高系统在实际应用中的速度。 数据库访问最常用于标准SQL语言，MySQL用于SQL语言，因此它具有高度兼容性。数据库的操作是必不可少的，包括对数据库表的增加、删除、修改、查询等功能。现如今，数据库可以分为关系型数据库和非关系型数据库，Mysql属于关系性数据库，Mysql数据库是一款小型的关系型数据库，它以其自身特点：体积小、速度快、成本低等，Mysql数据库是目前最受欢迎的开源数据库。          在WEB应用技术中， Mysql数据库支持不同的操作系统平台，虽然在不同平台下的安装和配置都不相同，但是差别也不是很大，Mysql在Windows平台下两种安装方式，二进制版和免安装版。安装完Mysql数据库之后，需要启动服务进程，相应的客户端就可以连接数据库，客户端可通过命令行或者图形界面工具登录数据库。  三、系统设计： 3.1 系统架构设计： ​  3.2 登录时序图设计： ​  四、功能截图：  4.1 登录注册：  4.2 前端页面： 4.2.1 系统首页：   4.2.2 教练模块：   4.2.3 考试须知：   4.2.4 预约练车：   4.2.5 车辆信息：  4.2.6 系统公告信息：  4.2.7 个人中心模块：   4.2.8 用户后台模块：  4.3 后端管理：  4.3.1 教练管理：  4.3.2 考试通知：  4.3.3 报名管理：  4.3.4 车辆信息：  4.3.5 系统公告等  五、代码实现：     /**  * 登录相关  */ @RequestMapping("users") @RestController public class UserController{          @Autowired     private UserService userService;          @Autowired     private TokenService tokenService;       /**      * 登录      */     @IgnoreAuth     @PostMapping(value = "/login")     public R login(String username, String password, String captcha, HttpServletRequest request) {         UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));         if(user==null || !user.getPassword().equals(password)) {             return R.error("账号或密码不正确");         }         String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());         return R.ok().put("token", token);     }          /**      * 注册      */     @IgnoreAuth     @PostMapping(value = "/register")     public R register(@RequestBody UserEntity user){ //        ValidatorUtils.validateEntity(user);         if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {             return R.error("用户已存在");         }         userService.insert(user);         return R.ok();     }       /**      * 退出      */     @GetMapping(value = "logout")     public R logout(HttpServletRequest request) {         request.getSession().invalidate();         return R.ok("退出成功");     }          /**      * 密码重置      */     @IgnoreAuth     @RequestMapping(value = "/resetPass")     public R resetPass(String username, HttpServletRequest request){         UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));         if(user==null) {             return R.error("账号不存在");         }         user.setPassword("123456");         userService.update(user,null);         return R.ok("密码已重置为：123456");     }          /**      * 列表      */     @RequestMapping("/page")     public R page(@RequestParam Map<String, Object> params,UserEntity user){         EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();         PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));         return R.ok().put("data", page);     }       /**      * 列表      */     @RequestMapping("/list")     public R list( UserEntity user){            EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();           ew.allEq(MPUtil.allEQMapPre( user, "user"));          return R.ok().put("data", userService.selectListView(ew));     }       /**      * 信息      */     @RequestMapping("/info/{id}")     public R info(@PathVariable("id") String id){         UserEntity user = userService.selectById(id);         return R.ok().put("data", user);     }          /**      * 获取用户的session用户信息      */     @RequestMapping("/session")     public R getCurrUser(HttpServletRequest request){         Long id = (Long)request.getSession().getAttribute("userId");         UserEntity user = userService.selectById(id);         return R.ok().put("data", user);     }       /**      * 保存      */     @PostMapping("/save")     public R save(@RequestBody UserEntity user){ //        ValidatorUtils.validateEntity(user);         if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {             return R.error("用户已存在");         }         userService.insert(user);         return R.ok();     }       /**      * 修改      */     @RequestMapping("/update")     public R update(@RequestBody UserEntity user){ //        ValidatorUtils.validateEntity(user);         UserEntity u = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername()));         if(u!=null && u.getId()!=user.getId() && u.getUsername().equals(user.getUsername())) {             return R.error("用户名已存在。");         }         userService.updateById(user);//全部更新         return R.ok();     }       /**      * 删除      */     @RequestMapping("/delete")     public R delete(@RequestBody Long[] ids){         userService.deleteBatchIds(Arrays.asList(ids));         return R.ok();     } }      @Configuration public class InterceptorConfig extends WebMvcConfigurationSupport{          @Bean     public AuthorizationInterceptor getAuthorizationInterceptor() {         return new AuthorizationInterceptor();     }          @Override     public void addInterceptors(InterceptorRegistry registry) {         registry.addInterceptor(getAuthorizationInterceptor()).addPathPatterns("/**").excludePathPatterns("/static/**");         super.addInterceptors(registry);     }          /**      * springboot 2.0配置WebMvcConfigurationSupport之后，会导致默认配置被覆盖，要访问静态资源需要重写addResourceHandlers方法      */     @Override     public void addResourceHandlers(ResourceHandlerRegistry registry) {         registry.addResourceHandler("/**")         .addResourceLocations("classpath:/resources/")         .addResourceLocations("classpath:/static/")         .addResourceLocations("classpath:/admin/")         .addResourceLocations("classpath:/front/")           .addResourceLocations("classpath:/public/");         registry.addResourceHandler("/upload/**").addResourceLocations("file:D:/work/");           super.addResourceHandlers(registry);     } }  ———————————————— 版权声明：本文为CSDN博主「java李杨勇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/weixin_39709134/article/details/128781905 

大佬们，这么多数据，按照我目前的方式很慢啊，有没有其他好的快速的方法 。

 1 jetson 查看方法  官方新推出 jtop 工具，专门用来查看 jetson 的 CPU、GPU 等信息，使用方法也很简单 安装方法 sudo -H pip install jetson-stats 使用方法，直接在命令行输入 jtop 就会有显示输出  对于 Xavier NX 和 AGX 设备，还有 DLA 硬件可以调用，实现加速功能，但目前还没有一个比较好的方式来查看其占用情况，只能看到其是否被调用，如下 cat /sys/devices/platform/host1x/15880000.nvdla0/power/runtime_status   #DLA0 cat /sys/devices/platform/host1x/158c0000.nvdla1/power/runtime_status   #DLA1 如果想要持续观察，可以结合 watch 指令，比如 1s 输出一次 watch -n 1 "cat /sys/devices/platform/host1x/15880000.nvdla0/power/runtime_status"   #DLA0 watch -n 1 "cat /sys/devices/platform/host1x/158c0000.nvdla1/power/runtime_status"   #DLA1 -----------------------以下为旧版本内容，可以不再使用------------------- 内存 free -m 系统内核 uname -a CPU信息 lscpu USB设备 lsusb CPU占用情况 sudo apt-get install htop htop  CPU 百分比中有不同的颜色，颜色含义如下 蓝色：显示低优先级进程使用的CPU的百分比。 绿色：显示普通用户拥有的进程使用的CPU的百分比。 红色：显示系统进程使用的CPU的百分比。 青色：显示Steal时间使用的CPU的百分比。 GPU 使用情况 sudo tegrastats 会输出如下所示的内容，注意一定要加sudo，否则输出的信息不完整 RAM 1920/7851MB (lfb 1131x4MB) cpu [9%@345,off,off,9%@345,13%@345,13%@345] EMC 6%@1600 APE 150 NVDEC 1164 GR3D 7%@114 具体含义为 RAM  就是内存占用 cpu  当然就是CPU占用率了，TX2一共6个核，显示每核的占用情况 EMC – external memory controller, 就是外存控制器    单位  bus%@MHz AVP – audio/video processor, TX2 自带的音频视频ASIC处理器  单位 processor%@MHz NVDEC – NVIDIA video decoder engine,  TX2 带有视频编解码hevc的加速器   %MHz GR3D – GPU, processor，      GPU的主频      %@MHz 2 dGPU 查看方法 对于dGPU 设备，如 2080，TITAN V，T4 等大卡，NVIDIA自带了一个nvidia-smi的命令行工具，会显示显存使用情况：  $ nvidia-smi 显示结果如下   但是只能输出一次结果，我们在训练数据的时候，想实时观察 GPU 的利用情况，因此需要添加一个定时输出的功能。这时候就需要用到 watch 命令，来周期性地执行 nvidia-smi 命令了。  watch 的基本用法是：  $ watch [options]  command 最常用的参数是 -n， 后面指定是每多少秒来执行一次命令。  我们设置每 1s 显示 GPU 使用情况：  $ watch -n 1 nvidia-smi 显示结果如下   实现了周期性显示 GPU 利用情况的功能，CPU 显示仍可以用 htop 指令实现 

1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。 流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 JavaIO模型  : Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。 2.数据流的基本概念 数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。 “流是磁盘或其它外围设备中存储的数据的源点或终点。” 在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？ 在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛: 标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。 流是个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。 总结的基本概念如下： 1) 数据流： 一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。【从内存数据的流向进行划分】2) 输入流(Input  Stream)： 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道 3) 输出流： 程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。 采用数据流的目的就是使得输出输入独立于设备。 Input  Stream不关心数据源来自何种设备(键盘，文件，网络) Output  Stream不关心数据的目的是何种设备(键盘，文件，网络 3 数据流分类： 流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种： 1)  字节流：数据流中最小的数据单元是字节 2)  字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。 Java I/O主要包括如下几个层次，包含三个部分： 1.流式部分：IO的主体部分； 2.非流式部分：主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类； 3.其他类：文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。 主要的类如下： 1. File(文件特征与管理)：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。 2. InputStream(二进制格式操作)：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。 3. OutputStream(二进制格式操作)：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。 Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。 4. Reader(文件格式操作)：抽象类，基于字符的输入操作。 5. Writer(文件格式操作)：抽象类，基于字符的输出操作。 6. RandomAccessFile(随机文件操作)：它的功能丰富，可以从文件的任意位置进行存取(输入输出)操作。 5. 非流式文件类--File类 在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。 作用：File类主要用于命名文件、查询文件属性和处理文件目录。 public    class   File   extends Object implements Serializable,Comparable {} File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数： 1)File (String   pathname) 例:File  f1=new File("FileTest1.txt"); //创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt 2)File (String  parent  ,  String child) 例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意：D:\\dir1目录事先必须存在，否则异常 3)File (File    parent  , String child) 例:File  f4=new File("\\dir3"); File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建 一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。 1)public boolean exists( ) 判断文件或目录是否存在 2)public boolean isFile( ) 判断是文件还是目录 3)public boolean isDirectory( ) 判断是文件还是目录 4)public String getName( ) 返回文件名或目录名 5)public String getPath( ) 返回文件或目录的路径。 6)public long length( ) 获取文件的长度 7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有： 1) public boolean renameTo( File newFile );    重命名文件 2) public void delete( );   删除文件 3)  public boolean mkdir( ); 创建目录 例子： import java.io.File; 02. import java.io.IOException; 03. public class TestFile { 04.     public static void main(String args[]) throws IOException { 05.         File dir = new File("\\root"); 06.         File f1 = new File(dir, "fileOne.txt"); 07.         File f2 = new File(dir, "fileTwo.java"); 08.         // 文件对象创建后，指定的文件或目录不一定物理上存在 09         if (!dir.exists()) 10.            dir.mkdir(); 11.         if (!f1.exists()) 12.             f1.createNewFile(); 13.         if (!f2.exists()) 14.             f2.createNewFile(); 15.         System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath()); 16.         System.out.println("f1 Canread=" + f1.canRead()); 17.         System.out.println("f1's len= " + f1.length()); 18.         String[] FL; 19.         int count = 0; 20.         FL = dir.list(); 21.         for (int i = 0; i  22.             count++; 23.             System.out.println(FL[i] + "is in \\root"); 24.         }  25.         System.out.println("there are" + count + "file in //root"); 26.     } 27. 28. } 说明：File类的方法: (1) exists()测试磁盘中指定的文件或目录是否存在 (2) mkdir()创建文件对象指定的目录(单层目录) (3) createNewFile()创建文件对象指定的文件 (4) list()返回目录中所有文件名字符串 6. Java.IO流类库 1. io流的四个基本类 java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流： 基本数据流的I/O 输入/输出 字节流 字符流 输入流 Inputstream Reader 输出流 OutputStream Writer Java中其他多种多样变化的流均是由它们派生出来的: JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。 在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定功能 7. io流的具体分类 一、按I/O类型来总体分类 1. Memory 1)从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream 2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream 2.Pipe管道：实现管道的输入和输出(进程间通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream 3.File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream 4.ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream 5.DataConversion数据流 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型，字节，整数和浮点数))：DataInputStream、DataOutputStream 6.Printing 包含方便的打印方法 ：PrintWriter、PrintStream 7.Buffering缓冲  在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream 8.Filtering 滤流，在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream 9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream 10.Counting计数  在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream 11.Peeking Ahead 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream 12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换(Stream到Reader,Writer的转换类)：InputStreamReader、OutputStreamWriter  二、按数据来源(去向)分类： 1、File(文件)： FileInputStream, FileOutputStream, FileReader, FileWriter 2、byte[]：ByteArrayInputStream, ByteArrayOutputStream 3、Char[]: CharArrayReader, CharArrayWriter 4、String: StringBufferInputStream, StringReader, StringWriter 5、网络数据流：InputStream, OutputStream, Reader, Writer ———————————————— 原文链接：https://blog.csdn.net/weixin_36377930/article/details/114186351 

 MySql中json类型的使用 MySQL从5.7.8起开始支持JSON字段，这极大的丰富了MySQL的数据类型。也方便了广大开发人员。但MySQL并没有提供对JSON对象中的字段进行索引的功能，至少没有直接对其字段进行索引的方法。本文将介绍利用MySQL 5.7中的虚拟字段的功能来对JSON对象中的字段进行索引。 一、使用json的目的 1、可以直接过滤记录 2、可以直接update，而无须先读取 3、可以在一条SQL中完成多条纪录的修改！ 4、通过json类型，完美的实现了表结构的动态变化 5、通过计算生成列且在该列上建立索引。提高查询效率 二、开始使用 1.建表 建表语句如下： CREATE TABLE `msg_info` (   `id` int(10) unsigned NOT NULL,   `message` json NOT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 2.插入数据 insert into msg_info values (1,'{"name":"zhangsan","phone":"13752763211"}'); insert into msg_info values (2,'{"name":"lisi","phone":"13752763222"}'); 3.查询更新操作 1、过滤记录 select * from    msg_info where message->'$.phone'='13752763211'; 2、查询json内指定字段 select message->'$.name' from    msg_info; # 这样查询出来的字段是带双引号的，使用如下语句可去除双引号，也可以使用关键字JSON_UNQUOTE select message->>'$.name' from    msg_info; 3、直接更新json串内的字段内容  UPDATE msg_info set message = JSON_SET(message, '$.name', 'lili') WHERE id = 1; # 为json串添加字段 update msg_info set message = JSON_INSERT(message, '$.age', 30) WHERE id = 1; 3.动态扩展字段 1、为json添加虚拟字段  ALTER TABLE msg_info  ADD v_phone  varchar (12) GENERATED ALWAYS  AS (JSON_UNQUOTE(message->'$.phone' ));  2、为虚拟字段创建索引，提高查询效率  # 通过执行计划可以查看创建索引前后的变化 ALTER TABLE msg_info ADD INDEX idx_phone(v_phone); mybatis存取mysql中的json mysql 5.7后新增了一个json类型字段，以往json入库都是转字符串，取到前端造成了不少困扰。今天就做了个小例子把这个整合到ssm例子中。  这边也顺便说下如果idea在启动tomcat客户端控制台出现乱码处理办法  这边也顺便说下如果idea在启动tomcat客户端控制台出现乱码处理办法 打开idea安装目录-bin 用记事本打开idea.exe.vmoptions和idea64.exe.vmoptions文件 在文件后面添加一行：-Dfile.encoding=UTF-8  好了进入正题 第一步先配置一个typehandler,代码如下  import java.sql.CallableStatement; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException;   import org.apache.ibatis.type.BaseTypeHandler; import org.apache.ibatis.type.JdbcType; import org.codehaus.jackson.map.ObjectMapper; import org.codehaus.jackson.map.SerializationConfig.Feature; import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;   /**  * mapper里json型字段到类的映射。  * 用法一:  * 入库：#{jsonDataField, typeHandler=com.adu.spring_test.mybatis.typehandler.JsonTypeHandler}  * 出库：  * <resultMap>  * <result property="jsonDataField" column="json_data_field" javaType="com.xxx.MyClass" typeHandler="com.adu.spring_test.mybatis.typehandler.JsonTypeHandler"/>  * </resultMap>  *  * 用法二：  * 1）在mybatis-config.xml中指定handler:  *      <typeHandlers>  *              <typeHandler handler="com.adu.spring_test.mybatis.typehandler.JsonTypeHandler" javaType="com.xxx.MyClass"/>  *      </typeHandlers>  * 2)在MyClassMapper.xml里直接select/update/insert。  *  */ public class JsonTypeHandler<T extends Object> extends BaseTypeHandler<T> {     private static final ObjectMapper mapper = new ObjectMapper();     private Class<T> clazz;       public JsonTypeHandler(Class<T> clazz) {         if (clazz == null) throw new IllegalArgumentException("Type argument cannot be null");         this.clazz = clazz;     }       @Override     public void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {         ps.setString(i, this.toJson(parameter));     }       @Override     public T getNullableResult(ResultSet rs, String columnName) throws SQLException {         return this.toObject(rs.getString(columnName), clazz);     }       @Override     public T getNullableResult(ResultSet rs, int columnIndex) throws SQLException {         return this.toObject(rs.getString(columnIndex), clazz);     }       @Override     public T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {         return this.toObject(cs.getString(columnIndex), clazz);     }       private String toJson(T object) {         try {             return mapper.writeValueAsString(object);         } catch (Exception e) {             throw new RuntimeException(e);         }     }       private T toObject(String content, Class<?> clazz) {         if (content != null && !content.isEmpty()) {             try {                 return (T) mapper.readValue(content, clazz);             } catch (Exception e) {                 throw new RuntimeException(e);             }         } else {             return null;         }     }     static {         mapper.configure(Feature.WRITE_NULL_MAP_VALUES, false);         mapper.setSerializationInclusion(Inclusion.NON_NULL);     } mapper代码 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"         "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.cm.dao.UserDao">       <resultMap id="user" type="com.cm.model.UserModel">         <id column="id" jdbcType="NUMERIC" property="id"/>         <result column="name" jdbcType="VARCHAR" property="name"/>         <result column="age" jdbcType="NUMERIC" property="age"/>         <result column="hobby" jdbcType="NUMERIC" property="hobby" typeHandler="com.cm.mybaits.JsonTypeHandler"/>       </resultMap>     <select id="getAllUsers" resultMap="user">         select * from user     </select>           <insert id="addUser">         <!--ignore忽略自动增长的主键id-->         insert ignore into user (name, age, hobby) values (#{id}, #{name} ,#{hobby, typeHandler=com.cm.mybaits.JsonTypeHandler})     </insert>       这边有个坑是mysql 驱动一定要5.1.40，不然取出来的json中文是乱码。虽然说是低于5.1.36会乱码，但是我试了5.1.6还是乱码。    <update id="updateUser">         update user set name=#{name} where id=#{id}     </update>       <delete id="deleteUser" parameterType="String">         delete from user where id=#{id}     </delete>       <select id="getUser" resultType="UserModel">         select * from user where id = #{id}     </select> </mapper> mysql表结构 　 插入的测试代码 效果预览 入库 取数据 这边有个坑是mysql 驱动一定要5.1.40，不然取出来的json中文是乱码。虽然说是低于5.1.36会乱码，但是我试了5.1.6还是乱码。  <dependency>     <groupId>mysql</groupId>     <artifactId>mysql-connector-java</artifactId>     <version>5.1.40</version> </dependency> 文章知识点与官方知识档案匹配，可进一步学习相关知识 ———————————————— 原文链接：https://blog.csdn.net/qq_43842093/article/details/122612071 

 最近用到了el-tree控件，主要是数据的格式，按照官网的数据格式来就可以显示节点的树形结构了。 代码参考很多 这里给出一个比较好的链接：https://blog.csdn.net/qq_36956154/article/details/79893876 代码说明在注释里写的很详细了已经，这里不再叙述说明。至于为什么抽取成这种格式的数据，那是因为ElementUI-tree规定的数据格式，你想要用这个控件，就必须按照他们规定的这个格式 来。 数据格式如下： Controller代码  @RequestMapping("/cateList")     @ResponseBody     public List<TbCategory> cateList() {         // 整体思路：         // 1、取得所有数据、放入集合List1 （tbCategories）         // 2、将List1所有数据都放入到map（treeMap）中：元素id为键，元素本身对象为值         // 3、取得顶层节点放入集合List2中（resultList）         // 4、遍历List1中的所有数据，通过数据的parentId为键在map中取值         //      1）如果能取到，则说明该元素有父节点         //           1、判断该父节点下的childList中是否有已经子节点         //              1、若无：则创建一个集合，将子节点放入         //              2、若有：则直接将子节点放入即可         // 5、把放好的数据放回到map中         // 6、返回List2（resultList）          // 注意：整个过程将所有数据取出放入list2（resultList）,返回的也是    //list2         List<TbCategory> tbCategories = categoryService.cateList();         List<TbCategory> resultList = new ArrayList<TbCategory>(); // 存贮顶层的数据         Map<Object ,Object> treeMap = new HashMap();         Object itemTree;          for(int i = 0;i<tbCategories.size() && !tbCategories.isEmpty();i++){             itemTree = tbCategories.get(i);             treeMap.put(tbCategories.get(i).getNodeId(),tbCategories.get(i));// 把所有的数据都放到map中         } // 这里也可以用另一种方法，就是拿到集合里的每个元素的父id去数据库中查询，但是，这样与数据库的交互次数就太多了   // 遍历map得到顶层节点（游离节点也算作顶层节点）         for(int i =0;i<tbCategories.size();i++){             // 优点1：整个方法，只查询了一次数据库             // 优点2：不用知道顶层节点的id           if(!treeMap.containsKey(tbCategories.get(i).getParentId())){                 // 我们在存储的时候就是将元素的id为键，元素本身为值存入的                 // 以元素的父id为键，在map里取值，若取不到则，对应的元素不存在，即没有父节点，为顶层节点或游离节点                 // 将顶层节点放入list集合                 resultList.add(tbCategories.get(i));             }         }         // 循环数据，将数据放到该节点的父节点的children属性中         for(int i =0 ;i<tbCategories.size()&& !tbCategories.isEmpty();i++){             // 数据库中，若一个元素有子节点，那么，该元素的id为子节点的父id             //treeMap.get(tbCategories.get(i).getParentId()); // 从map集合中找到父节点             TbCategory category = (TbCategory)treeMap.get(tbCategories.get(i).getParentId());             if(category!=null ){ // 不等于null，也就意味着有父节点                 // 有了父节点，要判断父节点下存贮字节点的集合是否存在，然后将子节点放入                 if(category.getChildList() == null){                     // 判断一个集合是否被创建用null：表示结合还没有被分配内存空间(即还没有被创建)，内存大小自然为null                     // 用集合的size判断集合中是否有元素，为0，没有元素（集合已经被创建），                     category.setChildList(new ArrayList<TbCategory>());                 }                 category.getChildList().add(tbCategories.get(i)); // 添加到父节点的ChildList集合下                 // 这一步其实可以不要，因为我们修改了数据（添加了子节点，然后在将元素放入到map中，                 // 若键相同，map会自动覆盖掉相同的键值对，达到更新map集合中的数据的目的），但是我们                 // 这里只是从map中取值，而并不关心值的子节点（子节点是对象本身自己封装的。这里我们知道                 // 元素从查询后放入map,父节点放入list，然后通过键来在map中取得对象，之后再将修改过的对象重新放入map当中                 // ,我们并没有直接操作list,但是在list中对象的值却是已经修改过了，这就是对象的引用传递，同一个引用对象是通过                 // 地址值来操作对象的，即有不同的引用，但是对象中的属性是已经通过引用的操作而改变的，所以这里一旦修改过后，无论是map中还是list中，再次取值时都已经是更改过后的值了）                 treeMap.put(tbCategories.get(i).getParentId(),category);  // 把放好的数据放回到map中             }         }       return resultList;     } 实体类：   private Long nodeId;     private String categoryName;     private Long parentId;     private Long childId;     private List<T> childList; 以上数据都在后台封装好了，前台直接获取数据显示即可  <el-tree :data="treeList"               :props="defaultProps"               @node-click="handleNodeClick"               node-key="nodeId"               show-checkbox=true>     </el-tree> js:  defaultProps:{                 children: 'childList',                 label: 'categoryName' // 这里的名字要和你封装的数据中的节点的名字一样             } // 点击事件   handleNodeClick: function (data) {                console.log("没做处理");             } 方法抽取 /// 上面的方法虽然也能用，但是想把这个方法抽取成一个通用的方法，以后再写的时候就可以直接调取该方法了。抽取的过程中还是遇到了很多的问题的。 例如实体类A是对应数据库中存储节点的表的实体类，但是，实体类中是不存在setChildList、getChildList集合这些方法的。我就把这些存贮信息的字段写在了一个工具类里面，然后方法也在该工具类里。这样返回的时候就要返回一个装有该工具类的一个集合了。还有一个问题就是该工具类中都需要那些字段？因为是一棵树，所以我们需要节点id,几点的父id，节点的名称，以及存储子节点的集合，如果想要更多的数据，可以添加一个 T data泛型，该泛型直接将原本存储节点的实体类对象存储进来。这样所有的数据就都整齐了，数据结构也就完整了。 contrell代码： 因为我们想抽取一个公用的方法，那么参数的类型就是不确定的，即传入的list中元素的类型是不固定的，所以要用到泛型。上面说过了，我们要拿到节点id,父id，以及节点的名称赋值给工具类中对应的字段。但是既然是用泛型，所以就不知道对象类型，所以我们在工具类中是点不出相应的方法来取到值的，我们就要用到反射，反射的知道类中具体的字段或者方法的名字来取值，所以我们在controller来调用工具类的时候就要，将节点id、父id和节点名称传入。当然了还要传入从后台查询到了装有数据的list集合。 contreller代码如下所示： @RequestMapping("/cateList") @ResponseBody public List<TreeUtils> cateList() throws Exception{        List<TbCategory> tbCategories = categoryService.cateList();        List<TreeUtils> treeList = TreeUtils.getTreeList(tbCategories,"nodeId", "parentId", "categoryName");          return treeList;     } 工具类： // 抽取方法的时候要考虑一个问题，即，返回一个集合，集合中有父节点和字节点，父节点和字节点的类型一定要统一， // 即这里返回的是一个装有TreeUtils类型的集合，那么集合里的父节点和子节点一定都得是TreeUtils类型的  public class TreeUtils<T> {      private Integer id;           // 节点id     private Integer parentId;    // 父节点     private String name;         // 节点名称 ,返回给前台的是一个装有TreeUtils的集合的数据，所以在前台显示数据的时候，el-tree的lable的名字的和这个一样     private List<TreeUtils> childList;  // 父节点中存放子节点的集合     private T data;              //  节点数据 方法  /**      * @param listData   // 从数据库中查询的数据      * @return      */     public static List<TreeUtils> getTreeList(List<?> listData ,String id,String parentId,String categoryName) throws Exception{          List<TreeUtils> resultList = new ArrayList<TreeUtils>();  // 最终返回的结果        Map<Integer ,Object> map = new HashMap<Integer,Object>();          for(int i =0;i<listData.size() && !listData.isEmpty();i++){              // 写一个与该方法差不多的方法，将得到TreeUtils的代码抽取出来             // 也可以将listData集合整个转换成装有TreeUtils的集合x，然后再循环x             TreeUtils treeUtils = new TreeUtils();             treeUtils.setId(Integer.parseInt(TreeUtils.getFileValue(listData.get(i),id).toString())); // id              // 返回值为Object无法直接转换成Integer,先toString，再转换成Integer。这里的返回值写成Object是因为多种类型字段的值都可以用该方法             treeUtils.setParentId(Integer.parseInt(TreeUtils.getFileValue(listData.get(i),parentId).toString())); // 父id             treeUtils.setName(TreeUtils.getFileValue(listData.get(i),categoryName).toString());  // 节点名             //System.out.println("节点名为+"+TreeUtils.getFileValue(listData.get(i),categoryName).toString());             treeUtils.setData(listData.get(i));   // data:原对象中的所有属性，无children              // 通过反射得到每条数据的id将数据封装的map集合中，id为键，元素本身为值             map.put(treeUtils.getId(),treeUtils);              // 将所有顶层元素添加到resultList集合中             //if( 0 == treeUtils.getParentId()){              //   resultList.add(treeUtils);            // }         } // 得到所有的顶层节点，游离节点也算作顶层节点 // 优点一，不用知道等级节点的id // 优点而，只查询了一次数据库         for(int i =0;i<listData.size();i++){             if(!map.containsKey(Integer.parseInt(TreeUtils.getFileValue(listData.get(i),parentId).toString()))){                 resultList.add((TreeUtils) map.get(Integer.parseInt(TreeUtils.getFileValue(listData.get(i),id).toString())));             }         }         for(int i =0;i<listData.size() && !listData.isEmpty();i++){             TreeUtils obj = (TreeUtils)map.get(Integer.parseInt(TreeUtils.getFileValue(listData.get(i), parentId).toString()));             if(obj != null){                 if(obj.getChildList() == null){                     obj.setChildList(new ArrayList());                 }                 obj.getChildList().add(map.get(Integer.parseInt(TreeUtils.getFileValue(listData.get(i),id).toString())));             }         }         return resultList;     } 反射的方法 /**      * 通过反射得到的数据类型的也是不一定的，所以这里我们返回值为Object      * Object是无法直接转为Integer,现将Object转为String，然后再将String转为Integer      * @param item      * @param fileName      * @return      */     public static Object  getFileValue(Object item,String fileName) throws Exception {         Class<?> aClass = item.getClass();         Field file = aClass.getDeclaredField(fileName); // 得到所有字段包括私有字段         file.setAccessible(true); // 取消访问限制         return file.get(item);    // 这里就体现出反射的意思了，我们通常都是通过对象拿到字段，这里是通过字段，将类的字节码对象为参数传入，来得到值     } ps：抽取方法遇到了很多的问题，其中的T,?等泛型还只是会简单的用，并不熟练，以后要多加学习。 ———————————————— 原文链接：https://blog.csdn.net/java_xxxx/article/details/81099437 

 File.createNewFile和 File.createTempFile比较和区别 File 的 createNewFile() 方法： createNewFile()；返回值为 boolean； File file = new File("D:\\test\\1.txt"); boolean res = file.createNewFile(); if(!res)System.out.println("创建失败！");  如果D:/test 目录下没有 1.txt文件，则创建该文件； 如果没有test目录，直接抛出异常; 如果1.txt已经存在，那么文件创建失败。  可以得知，createNewFile() 方法，根据抽象路径创建一个新的空文件，当抽象路径指定的文件存在时，创建失败。  File 的 createTempFile() 方法  该方法有两种调用方式：  在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。  createTempFile(String prefix, String suffix)； 方法默认的保存路径为：C:\Documents and Settings\Administrator\Local Settings\Temp 。 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。 createTempFile(String prefix, String suffix, File directory)； createTempFile() 方法，在指定的目录下创建一个temp文件，directory 类型为File ，如果路径不存在，则创建失败。 3.删除方法   //立即删除文件    file.delete();  //在JVM退出时删除文件    file.deleteOnExit(); 总结：临时文件能够使用默认路径，可以避免存在创建文件是因为路径错误导致创建文件失败的问题。 如果需求中需要创建一个临时文件，这个临时文件可能作为存储使用，但在程序运行结束后需要删除文件，可以使用deleteOnExit方法 ———————————————— 原文链接：https://blog.csdn.net/lp15203883326/article/details/83783433 

单表的查询并根据时间分页 1、yml或者properties中配数据源，配自己的数据库就好。  mybatis-plus:   mapper-locations: ../mapper/*.xml   configuration:     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  //这个是为了在控制台打印SQL语句。 2、导入Mybatis-Plus的依赖，我这里使用的是3.4.0的版本，这里一定要注意依赖的版本号，3.4.0以后，分页插件的配置进行了更新。这里强调一下，如果自带分页插件失效，先检查版本和配置。          <!--MyBatis-plus配置-->         <dependency>             <groupId>com.baomidou</groupId>             <artifactId>mybatis-plus-boot-starter</artifactId>             <version>3.4.0</version>         </dependency> 3、新建一个config，这个config写Mybatis-Plus的插件配置，MP的插件配置有很多，这里单说一下分页的配置。  /**  *    注意@MapperScan，使用springboot的话，启动类是要扫描数据层的，如果仅用的是MP对数据      *    库操作，启动类里面的@MapperScan是不用写的，只写这里就好。  *  */   @Configuration @MapperScan("com.tiktang.dao") public class MybatisPlusConfig {     /**      * IPage的分页使用的是拦截器，属于物理分页，好处就是处理大量数据时，查询速度快。      *    有兴趣的同学可以看看什么是物理分页和逻辑分页。      * @return      */     @Bean     public MybatisPlusInterceptor mybatisPlusInterceptor() {         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();         //向Mybatis过滤器链中添加分页拦截器         interceptor.addInnerInterceptor(new                                  PaginationInnerInterceptor(DbType.MYSQL));         return interceptor;     }       @Bean     public ConfigurationCustomizer configurationCustomizer() {         return configuration -> configuration.setUseDeprecatedExecutor(false);     } } 4、单表的实体类entity对象，自己数据库中的字段，此步进行了省略。  5、程序的步骤，我一般习惯先写Mapper.xml，Mapper，service，serviceImpl，controller。按这个步骤来说，首先要先写的是Mapper.xml，但是是单表操作，又是用MP框架，就不用再写Mapper.xml了。  6、Mapper  //News为实体类 @Repository public interface NewsMapper extends BaseMapper<News> {   } 7、service  //News为实体，page为当前页，pageSize是一页多少个 public interface NewsService {       IPage<News> queryNewsList(Integer page, Integer pageSize); } 8、serviceImpl  @Service public class NewsServiceImpl implements NewsService {          @Autowired     private NewsMapper newsMapper;       @Override     public IPage<News> queryNewsList(Integer page, Integer pageSize) { //      Page<News> page1 = new Page<>(page,pageSize);         //这里进行了时间排序         QueryWrapper<News> queryWrapper = new QueryWrapper<>();         queryWrapper.orderByDesc("news_time");         //MP自带的selectPage方法，有兴趣的同学，可以看一下源码         IPage<News> iPage = newsMapper.selectPage(new Page<>(page, pageSize),          queryWrapper);         return iPage;     }   } 9、controller     @GetMapping("/newsList")     public Result<News> queryNewsList(@RequestParam Integer page,                                     @RequestParam Integer pageSize){         IPage<News> iPage = newsService.queryNewsList(page, pageSize);         return Result.ok().data("iPage",iPage);     } Result是我自己封装的结果集，有时间会再写一下关于返回统一结果集的内容。 到此单表查询分页并根据时间排序就完成。     @GetMapping("/getCompanyInvest")     public Result getCompanyInvest(@RequestParam String companyId,                                    @RequestParam Integer currentPage,                                    @RequestParam Integer pageNumber){         QueryWrapper<CompanyInvest> queryWrapper = new QueryWrapper<>();         queryWrapper.eq("company_id",companyId);         Page<CompanyInvest> page = new Page<>(currentPage,pageNumber);         IPage<CompanyInvest> companyInvestIPage = companyInvestMapper.selectPage(page,queryWrapper);         Map<String,Object> map = new HashMap<>();         map.put("公司投资信息的子页面",companyInvestIPage);         return Result.ok().data(map);  }———————————————— 原文链接：https://blog.csdn.net/qq_42405688/article/details/119967684