工作个人总结01

薄弱知识点总结

设计思路相关知识点

1.在设计东西的时候，考虑问题要全面

2.问题当前可能会出现的问题，问题以后可能会出现的问题

3.设计表结构的时候，尽量避免一些无用字段，

例如：原型图上的展示信息是一些节点的个数，设计表的时候应该把我们拿到的数据存到表里面而不是设计几个放节点个数的字段，这样放的数据以后有什么新需求了，可以直接取了。

4.设计表结构的同时，其实就是在脑子里面捋了一遍，代码的编写过程，如果有什么不清楚的，要牢记一定要提出来，这样不会浪费时间，如果不清楚的话，是没办法做好逻辑的。

JSON相关知识点

JSON格式具有良好的可读和便于快速编写的特性。

JSON里面的数据都是以键值对的方式存储的，

JSON的语法规则很简单，总结起来有：

数组（Array）用的是方括号（[]）表示。

对象（Object）用大括号表示（{}）表示。

名称/值对（name/value）组合成数组或者是对象

名称（name）放在双引号中，值（value）有字符串，数组，布尔值，null，对象和数组。并列的数据之间用英文的都逗号分隔。例如：

{
	"name": "小琛",
	"avg": "21"
}

JSON相关操作的方法：

这是不用hutool的情况下，引入：json-lib-2.4-jdk15 这个包，操作：

	<dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
        <classifier>jdk15</classifier>
    </dependency>

Map<String,String> map1 = new HashMap<String,String>();
map1.put("name","zhangchen");
map1.put("avg", "123");
//Map转换为json对象
//方法一：转换为带有key值的json对象
JSONObject json0 = new JSONObject();
//往JSONObject里面put值
json0.put("mapJson", map1);
System.out.println("json0"+json0);
//方法二：转化为不带有key值的json对象
JSONObject json1 = JSONObject.fromObject(map1);
//Map对象转化为json数组
JSONArray mapArr = JSONArray.fromObject(map1);

或者引入 ：fastjson依赖，操作：

Map<String,String> map1 = new HashMap<String,String>();
        map1.put("name","zhangchen");
        map1.put("avg", "123");

        //将map转成jsonobject对象
        String s = JSON.toJSONString(map1); //map先转成json字符串
        JSONObject object = JSON.parseObject(String.valueOf(s)); //把转成的json字符串放进去转成jsonObject对象
        System.out.println(object);
        //取数据
        System.out.println(object.get("name"));
        System.out.println(object.getString("name"));

        //将map转成jsonarray数组(思路：不是转成数组，而是在最后把jsonobject对象添加到里面去)
        String a = JSON.toJSONString(map1);
        JSONObject object1 = JSONObject.parseObject(a);
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(object1);
        System.out.println(jsonArray);  //取数组
        //取数组下标为0的数据
        System.out.println(jsonArray.get(0));

或者**使用hutool工具包：**操作：

Map<String,String> map1 = new HashMap<String,String>();
        map1.put("name","zhangchen");
        map1.put("avg", "123");

        //将map转成jsonobject对象
        String s = JSONUtil.toJsonStr(map1); //map先转成json字符串
        JSONObject object = JSONUtil.parseObj(s); //把转成的json字符串放进去转成jsonObject对象
        System.out.println(object);
        //取数据
        System.out.println(object.get("name"));
        System.out.println(object.getStr("name"));

        //将map转成jsonarray数组(思路：不是转成数组，而是在最后把jsonobject对象添加到里面去)
        String a = JSONUtil.toJsonStr(map1);//map先转成json字符串
        JSONObject object1 = JSONUtil.parseObj(a);
        JSONArray jsonArray = new JSONArray();
        jsonArray.add(object1);
        System.out.println(jsonArray);  //取数组
        //取数组下标为0的数据
        System.out.println(jsonArray.get(0));

基础类型及循环知识点

关于BigDecimal类，比较陌生，关于这个类的定义，自己的理解是：可以作用于较大的浮点类型，常用的float和double类型的精度比较低。

//BigDecimal类的精度比较高，加减乘除的精度也很高。
//加法：add（）
//减法：subtract（）
//乘法：multiply（）
//除法：divide（）
//这些是常用方法。
//BigDecimal类的精度有多高？float和double类型的精度有多高？
//1.float的精度为6-7位有效数字，double的精度为15-16位,BigDecimal的精度是大于16位的。
//2.BigDecimal构造方法有三种：
    new BigDecimal(double val)  //不建议用
    new BigDecimal(int val)
    new BigDecimal(String val)
//第一种会造成数据不准，因为double的值是不准确的，假如我们定义了一个值为1.05，实际值可能是大于也可能小于1.05，只是表面上是1.05，会造成数据不准确。
//另外两种是推荐使用的。
    	BigDecimal a = new BigDecimal(1.01);	//double类型
        BigDecimal b = new BigDecimal(1.02);
        BigDecimal c = new BigDecimal("1.01");	//String类型
        BigDecimal d = new BigDecimal("1.02");
        System.out.println(a.add(b));
        System.out.println(c.add(d));
		//结果为：
		2.0300000000000000266453525910037569701671600341796875		//double类型的值
		2.03														//String类型的值

		//先定义一个数组，存放一些数据
        String[] str = {"hello","world","hi"};
        //首先使用普通循环，遍历其中数据
        //i为下标，起始下标为0，下标的长度必须小于数组的长度，循环完成之后，下标加1。（错误点）如果下标小于数组长度写成了小于等于，会造成下标越界的错误
        for (int i = 0; i < str.length; i++){
            //输出在本次循环中，当前下标对应的值
            System.out.println(str[i]);
        }
        //使用增强for循环
        for (String s : str){
            //可以直接取到值
            System.out.println(s);
        }

局部变量知识点

		//先定义一个数组，存放一些数据
        String[] str = {"hello","world","hi"};
        //定义一个变量用于接收循环的值
        String a = "";
        //使用普通循环拼接值
        for (int i = 0; i < str.length; i++){
            //（错误写法）这种情况，会导致输出为空，
            // 因为，a在循环里面作为局部变量，拼接完之后没有进行赋值操作，在外面定义的值是不会发生变化的。
            // 所以会导致输出结果为空，
            // 这是个注意点，一定要记得在循环里面拼接完后，要附上值。
            a.concat(str[i]);
            //正确写法
            a = a.concat(str[i] + ",");
            //但是我们拼接完之后输出的结果，最后一个字段后面也有，
            //所以我们要做判断，如果当前下标小于数组的长度-1，因为下标识从0开始的，这时候还是要拼接，
            // 如果不小于或者等于的情况下，那我们就不拼，了
            if (i < str.length - 1){
                a = a.concat(str[i] + ",");
            }else {
                a = a.concat(str[i]);
            }
        }
        System.out.println(a);

        //-------------------------------------------
        //使用增强型for循环，首先我们需要定义一个下标，因为增强循环没有下标
        String[] str = {"hello","world","hi"};
        int i = 0;
        //定义一个变量用于接收循环的值
        String a = "";
        //当第一次循环完后才能之后，把下标+1
        for (String s : str){
            //判断下标是否小于数组的长度-1，是就拼，
            //不是就不拼了
            if (i < str.length - 1){
                a = a.concat(s + ",");
            }else {
                a = a.concat(s);
            }
            //循环结束下标+1
            i++;
        }
        //输出结果
        System.out.println(a);

        //-------------------------------------------
        //另一种方法，解释判断拼接完的字符串的结尾是不是以，结尾。，如果是就只取下标0-拼接字符的长度-1，把最后一个，舍弃。
	   //这种方式是在不使用其他的工具类的情况下，比较简单的方式了
        String[] str = {"hello","world","hi"};
        //定义一个变量用于接收循环的值
        String a = "";
	    //定义一个变量，模拟set值的过程
        String b = "";
        for (String s : str){
            //直接拼接
            a = a.concat(s + ",");
        }
		//判断结尾是不是以，结尾
        if (a.endsWith(",")){
            b = a.substring(0 , a.length() - 1);
        }
        System.out.println(b);

项目相关注解知识点

//阻止单个定时任务并发，意思就是不能并发执行一个job
@DisallowConcurrentExecution 
//打印相关日志注解
@Slf4j
//依赖注入注解
//跟@Autowired用法相似，都是依赖注入，只是@AutoWried按by type自动注入，而@Resource默认按byName自动注入。
@Resource 
//把普通的类实例化到spring容器中
@Component 
//定时任务注解
@SneakyThrows
//事务相关注解
@Transactional
//标注在方法或类上，当前会话必须具有指定角色标识才能通过校验
@SaCheckRole("xxx")

关于中间件和数据库的一些操作知识点

中间件：金蝶

关于金蝶的操作的话，就是根据接口拿数据，把数据里面的默写字段，进行计算后去告警策略表里面去找一下符合条件的那一条告警数据，然后放到m3里和redis里面。

数据库：达梦

具体操作的话跟中间件的操作一样。

注意点：

1.拿过来的数据有很多数据是null的，开始商量的是给null的值附上0值，后来感觉不可以，后来明白，只要数据里面有为null值的就不管他了，直接忽略。

2.关于存m3的时候，当时被迷住了，存m3的时候应该是放几个参数

put(String metrics, Map<String, String> tags, Long timestamp, double value);
metrics：就类似于跟数据库里的表名一样，起个名字。
tags：是用于区分存的这条数据是属于哪个节点的数据(类似于id字段一样，用于区分数据属于哪里)。
timestamp：时间戳（秒级的）存数据的时间
value：存的数据（注：只能存数字）

3.关于m3的一些聚合函数的使用，到现在也没有找到相应的使用方法，官方文档没有使用方法。

4.关于m3的存入问题：

//例如：有一个数据，是这样，我们要存到m3的话不可以一次存两个指标，只能分开存read存一个，write存一个，
"io_speed": {
        "read_speed": "0",
        "write_speed": "25805"
             }
//例如这样才存，起个名字，tags放条件，秒级的时间戳，double类型的值，读和写必须要分开，不然没法存。   
 put("readSpeed", Map<String, String> tags, Long timestamp, double read_speed);
 put("writeSpeed", Map<String, String> tags, Long timestamp, double write_speed);

java Stream流的用法和含义

1.stream流是什么？为什么要用它？可以解决什么问题？

java定义的stream是什么？

支持数据处理操作的一个（source）资源中的元素序列。我们拆开理解。

元素序列：可以理解为我们操作的集合，数组，等等中的所有元素。

（source）资源：就是集合，数组等等存放元素的实例。

数据处理操作：就是具体stream接口里面有的方法了，具体在代码练习中体现。

为什么用它呢？

个人理解：因为在我们的日常开发中，我们使用的最多的数据结构就是集合，但是我们在处理集合中的大量数据时就必须要面对一个性能问题，要考虑很多之后进行代码编写，可能效果还不如人意，所以有了stream流，

好处可以让我们使用的时候：代码更简洁，处理逻辑比较绕的需求时也能根据提供的方法用极少的代码搞定。编写的代码也更加的具有复用性，而且写的代码不需要考虑多线程的问题，stream底层已经处理好了。

能解决什么问题？

它专注于对容器对象进行各种非常方便的，高效的聚合操作，或者大批量数据操作，由于借助于java8中新出现的lambda表达式极大地提高了编程效率和程序可读性，同时，提供了串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核优势，使用fork/join并行方式来拆分任务和加速处理过程。

2.具体用法怎么使用，具体方法的含义是什么？

//首先创建一个测试类我们这里设置成Employee类，添加几个属性，赋值到list中，测试stream流操作
List<Employee> list888 = new ArrayList<>();
        list888.add(new Employee(102, "李四", 59, 6666.66));
        list888.add(new Employee(101, "王三1", 18, 9123.99));
        list888.add(new Employee(101, "王三2", 18, 9876.99));
        list888.add(new Employee(101, "王三3", 18, 8765.12));
        list888.add(new Employee(101, "王三4", 18, 8888.34));
        list888.add(new Employee(101, "王三5", 18, 8123.99));
        list888.add(new Employee(103, "王五", 28, 9123.33));
        list888.add(new Employee(104, "王六1", 17, 7777.77));
        list888.add(new Employee(104, "王六2", 17, 7777.77));
        list888.add(new Employee(104, "王六3", 17, 7777.77));
        list888.add(new Employee(104, "王六4", 17, 7777.77));
        list888.add(new Employee(104, "赵六1", 8, 7777.77));
        list888.add(new Employee(104, "赵六2", 17, 7777.77));
        list888.add(new Employee(105, "田七", 38, 0.55));
//统计员工的最高薪资、平均薪资、薪资之和。
//最高薪资
System.out.println(list888.stream().max(Comparator.comparing(Employee::getGongzi)));
//平均薪资
System.out.println(list888.stream().collect(Collectors.averagingDouble(Employee::getGongzi)));
//薪资之和
System.out.println(list888.stream().mapToDouble(Employee::getGongzi).sum());
//将员工按薪资从高到低排序，同样薪资者年龄小者在前。
List<String> aaa = list888
                .stream().sorted(Comparator.comparing(Employee::getGongzi))
                .map(Employee::getName)
                .collect(Collectors.toList());
System.out.println("按工资升序排序：" + aaa);//从小到大

List<String> bbb = list888
                .stream().sorted(Comparator.comparing(Employee::getGongzi).reversed())
                .map(Employee::getName)
                .collect(Collectors.toList());
System.out.println("按工资降序排序：" + bbb);//从大到小,根据reversed()方法，可以将自然排序反过来就变成了降序

List<String> ccc = list888.stream()
                .sorted(Comparator.comparing(Employee::getGongzi).reversed().thenComparing(Employee::getAge))
                .map(Employee::getName).collect(Collectors.toList());
System.out.println("先按工资降序排序再按年龄升序排序：" + ccc);

//统计员工的最高薪资、平均薪资、薪资之和。
        //最高薪资
        System.out.println(list888.stream().max(Comparator.comparing(Employee::getGongzi)) + "-+++++++++++++++++-");
        //平均薪资
        System.out.println(list888.stream().collect(Collectors.averagingDouble(Employee::getGongzi)) + "-++++++++++++++++++++++++++++++-");
        //薪资之和
        System.out.println(list888.stream().mapToDouble(Employee::getGongzi).sum() + "--++++++++++++++++++++++++++++++--");

        //将员工按薪资从高到低排序，同样薪资者年龄小者在前。
        List<String> aaa = list888.
                stream().sorted(Comparator.comparing(Employee::getGongzi))
                .map(Employee::getName)
                .collect(Collectors.toList());

        List<String> bbb = list888
                .stream().sorted(Comparator.comparing(Employee::getGongzi).reversed())
                .map(Employee::getName)
                .collect(Collectors.toList());

        List<String> ccc = list888.stream()
                .sorted(Comparator.comparing(Employee::getGongzi).reversed().thenComparing(Employee::getAge))
                .map(Employee::getName).collect(Collectors.toList());

        System.out.println("按工资升序排序：" + aaa);//从小到大
        System.out.println("按工资降序排序：" + bbb);//从大到小,根据reversed()方法，可以将自然排序反过来就变成了降序
        System.out.println("先按工资降序排序再按年龄升序排序：" + ccc);

        //将员工按年龄分类，将员工按薪资是否高于8000分为两部分。   //分组：partitioningBy(填写lambda表达式取条件字段)
        Map<Boolean, List<Employee>> ddd = list888.stream()
                .collect(Collectors.partitioningBy(e -> e.getGongzi() > 8000));
        Map<Boolean, List<Employee>> eee = list888.stream()
                .collect(Collectors.partitioningBy(e -> e.getAge() > 18));
        System.out.println("工资高于8000的员工信息：" + ddd);     //false是不超过8000的组，true是超过的组
        System.out.println("年龄大于18岁的员工信息：" + eee);     //false是不超过18岁的组，true是超过的组

        //按员工工资过滤低于8000的员工信息。 //过滤filter(填写lambda表达式取条件字段)
        List fff = list888.stream()
                .filter(e -> e.getGongzi() < 8000).collect(Collectors.toList());
        System.out.println("工资低于8000的员工信息：" + fff);

云桌面的定义及理解

云桌面又被称之为桌面虚拟化，云电脑，是替代传统电脑的一种新模式，用户采用云桌面之后，不用再购买电脑主机也不用担心电脑里面的配置，比如CPU，内存，硬盘这些东西全在后端的服务器中可以虚拟出来，单台性能高的服务器可以虚拟出1-50台不等的虚拟主机，前端的设备主流采用的是瘦客户机（电视机的机盒），连接显示器和键鼠，用户安装客户端后通过特定的协议去访问服务器上的虚拟主机实现交互操作达到与电脑一致的体验。云桌面也手机，平板，等等智能设备进行访问，也是移动办公的最新解决方案。安全性也比较高，因为云桌面可以全程数据不离开服务器，从而提高系统安全性。

VMP集群：逻辑概念，当前系统所有的管理节点，宿主机，虚拟机等一些东西组成集群。

主机：指宿主机，虚拟机运行于宿主机之上。

虚拟机：虚拟化主机，运行着一些桌面环境和非桌面环境。

终端用户：访问、使用虚拟机（桌面）的终端，一般是办公一体机。

化，云电脑，是替代传统电脑的一种新模式，用户采用云桌面之后，不用再购买电脑主机也不用担心电脑里面的配置，比如CPU，内存，硬盘这些东西全在后端的服务器中可以虚拟出来，单台性能高的服务器可以虚拟出1-50台不等的虚拟主机，前端的设备主流采用的是瘦客户机（电视机的机盒），连接显示器和键鼠，用户安装客户端后通过特定的协议去访问服务器上的虚拟主机实现交互操作达到与电脑一致的体验。云桌面也手机，平板，等等智能设备进行访问，也是移动办公的最新解决方案。安全性也比较高，因为云桌面可以全程数据不离开服务器，从而提高系统安全性。

VMP集群：逻辑概念，当前系统所有的管理节点，宿主机，虚拟机等一些东西组成集群。

主机：指宿主机，虚拟机运行于宿主机之上。

虚拟机：虚拟化主机，运行着一些桌面环境和非桌面环境。

终端用户：访问、使用虚拟机（桌面）的终端，一般是办公一体机。