发表于
字数统计: 106 字 | 阅读时长 ≈ 1 min

使用cat、tail、head组合

1、查看最后100行的数据

1
cat filename | tail -n 100

2、查看100到300行的数据

1
cat filename | head -n 300 | tail -n +100

3、查看文件所有内容

1
cat filename

4、打印文件最后100行的数据

1
cat filename tail -n 100

5、打印文件第100行开始以后的内容

1
cat filename tail -n +100

6、打印前100的内容

1
cat filename head -n 100

发表于
字数统计: 435 字 | 阅读时长 ≈ 2 min

@ApiModel

使用场景

在实体类上边使用，标记类时swagger的解析类

概述

提供有关swagger模型的其它信息，类将在操作中用作类型时自动内省

属性

属性名称 数据类型 默认值 说明
value String 类名 为模型提供备用名称
description String “” 提供详细的类描述
parent Class<?> parent Void.class 为模型提供父类以允许描述继承关系
discriminatory String “” 支持模型继承和多态，使用鉴别器的字段的名称，可以断言需要使用哪个子类型
subTypes Class<?>[] {} 从此模型继承的子类型数组
reference String “” 指定对应类型定义的引用，覆盖指定的任何其他元数据
————————————————

@ApiModelProperty

使用场景

使用在被 @ApiModel 注解的模型类的属性上

概述

添加和操作模型属性的数据

属性

属性名称 数据类型 默认值 说明
value String “” 属性简要说明
name String “” 运行覆盖属性的名称。重写属性名称
allowableValues String “” 限制参数可接收的值，三种方法，固定取值，固定范围
access String “” 过滤属性，参阅:io.swagger.core.filter.SwaggerSpecFilter
notes String “” 目前尚未使用
dataType String “” 参数的数据类型，可以是类名或原始数据类型，此值将覆盖从类属性读取的数据类型
required boolean false 是否为必传参数,false:非必传参数; true:必传参数
position int 0 允许在模型中显示排序属性
hidden boolean false 隐藏模型属性，false:不隐藏; true:隐藏
example String “” 属性的示例值
readOnly boolean false 指定模型属性为只读，false:非只读; true:只读
reference String “” 指定对应类型定义的引用，覆盖指定的任何其他元数据
allowEmptyValue boolean false 允许传空值，false:不允许传空值; true:允许传空值
————————————————

发表于
字数统计: 200 字 | 阅读时长 ≈ 1 min

vi编辑器有三种模式：

命令模式
编辑模式
末行模式
打开 vi 编辑器后首先是命令模式，用i、o、a等进入编辑模式，按esc退出编辑模式，回到命令模式。

在命令模式下输入

:w 表示保存文件但不退出vi
:w file 表示将修改另外保存到file中，不退出vi
:w! 表示强制保存，不推出vi
:wq 表示保存文件并退出vi
:wq! 表示强制保存文件，并退出vi
:q 表示不保存文件，退出vi
:q! 表示不保存文件，强制退出vi
:e! 表示放弃所有修改，从上次保存文件开始再编辑
在命令模式下可以用用ZZ，ZQ这些指令直接保存退出。

发表于
字数统计: 123 字 | 阅读时长 ≈ 1 min

工具 作用
Nexus maven私服
jenkins 自动打包/发布
docker 应用虚拟机
gitlab 源码管理
yearning sql审核
Sonarqube 代码质量审核
maven&&gradle 项目打包工具
kubectl k8s集群操控工具
K8s 项目运行环境
rancher 简化k8s管理工具
apollo配置中心 管理项目集群配置
pinpoint 项目异常运行监控
elk 应用日志收集工具
阿里云slbs 负载均衡
ansible linux命令自动化工具
showdoc 项目文档管理

发表于
字数统计: 2,540 字 | 阅读时长 ≈ 9 min

在现代社会，效率成了随处可见的一个关键词，不管你是什么产业、什么岗位、什么社会角色，追求效率是一件很重要的事情。笔者却有着截然相反的看法：效率越高越好，不一定是件好事。

（声明：对于基本自律能力都不具备的职场“闲人”不属于本文目标群体。）

效率在主流社会中颇受追捧。

工厂追求效率，商业运作追求效率，工作追求效率，学习追求效率……除了春宵一刻之类的美好事物，人们几乎凡事追求效率。

市场总是最诚实——人们对效率的需求，养活了超万亿级的咨询市场。

近来吵得沸沸扬扬的996，以及据说越来越多的初、高中生每天睡眠不足6个小时，这些都跟“效率”有着千丝万缕的关系。

但是，一味追求高效率真的是一件好事吗？

一、消除冗余，效率越高越好？
如果我们想看清一个事物的真面目，那么不要尝试去定义“它是什么”，而是看它的对立面“它不是什么”。

效率的对立面是什么？——冗余

你怎么理解冗余？通俗的话来说就是重复、累赘、多余，看上去不太优雅。

我们计算机科学出身的人对冗余的理解稍微中肯一点。在计算机工程中，冗余是为了保障系统安全可靠性的“备份”设计。

比如你现在看的这篇文章，它的数据有些在沙漠中、有些在草原上甚至深海里，这种分布式冗余设计就是为了某台服务器断电时你还能继续看少加点班。

与计算机工程相反，现代社会更倾向于消除冗余，以此实现把资源（时间、精力、资金等）彻底榨取……不，是价值最大化。

比如有些公司，员工经常加班到深夜，上下班往返家中浪费时间，每天重复如此，从效率视角看，这是一类冗余。

如何消除冗余呢？公司免费安排加班宿舍，提供洗浴环境。今晚加班？别回家了，住公司星级酒店吧。

这可不是瞎编，不少公司还真就这么干。

类似道理，有些中学从“走读制”到“全封闭式管理”（吃住在学校），也是为了尽量消除“来回”冗余。

实际上，我们到处可以看到消除冗余“优化”效率的痕迹。

比如：公司座位布置通常就把高频沟通协作的同项目组人员放在一块，而不是随机分配或“男女搭配干活不累”。如此，经常需要沟通的人就不用来回跑浪费时间。

乍一看，上述改进很好，帮人节省时间，让人更专注于事务中，改进效率、提升业绩。

但是，我们总感觉这种过度效率好像哪里不对劲。

我们的本能并非“胡思乱想”，它还真的颇有渊源——在古代欧洲，只有奴隶的工作才讲究“效率”，原因是奴隶不太被当人看。

哪怕抛开人文主义的视角，现实中效率真的就越高越好么？

二、过度追求效率的弊端
我们以交通运输系统为例：

按照效率最优的观点，道路效率最高的状态应该就是“车水马龙、川流不息”。

但现实是，假设从你家开车到公司，畅通无阻状态是30分钟，那么：

当道路承载量为5%，行车时间为30分钟。
当道路承载量为15%，行车时间为40分钟，略微塞车。
当道路承载量为16.5%，行车时间为60分钟——增加10%车辆导致塞车猛增50%。
当道路承载量达到35%时，整个运输系统完全瘫痪！
可见，随着道路运载效率的上升，整个交通系统的效能先是上升，随后成指数级下降。

与人们盲目追求效率的疯狂相反，大量优秀的人造系统都存在刻意抑制效率的冗余设计。

比如MAC OS，一旦它检测到CPU处于玩命状态太久，就会自动启动某个“空转进程”，强制占据100%CPU，迫使电脑“冷静”，以此保护重要电子元件不受损害。

当然，这些人造系统设计的灵感来源正是大自然，大自然才是鬼斧神工级的设计大师。

比如，自然生态圈在地球上存续超过38亿年，大量物种轮番登台，陆续退出，但作为一个整体，自然生态系统仍繁荣强盛。之所以达此境界，最关键原因就是大自然存在大量冗余结构，能通过“自适应”机制应对不确定性环境的各种冲击。

想象下如果大自然资源处于100%效率运作是什么样？

比如你呼吸的每一口空气都恰好要由108片叶子光合作用提供。系统整体运作必须一环接一环，缝得一针不漏。

万一有人吃多了大蒜放多了个屁，可能就触发多米诺骨牌连锁反应，导致整个生态系统彻底崩溃。

交通系统经常崩溃（塞车、航班延误）正是因为效率太高。

类似道理，我们的生理系统也存在大量冗余设计，比如，人体最重要的生物器官都是“双机热备”而不是“效率最大化”：我们有两个肾脏，大脑分左右脑……最恶劣的情况，其中一半能接替另一半的工作。

我们大脑也是一个特别重视冗余的系统。

一旦它察觉哪里不对劲，比如心脑血管持续处于高压状态，就立马让你感到疲倦犯困或想暴打老板一顿。

这时如果你还是忽视大脑的警告，最严重的情况就可能导致休克甚至……

三、如何在效率与冗余之间保持“综合最优化”
那么就我们关注的工作学习效率问题，我们到底该如何在效率与冗余间保持“综合最优化”？

考虑到个体差异，这里不可能开出类似科学精准量化的模型，但我们能定性描绘效率与成效的曲线关系：

如果一个系统效率太高，那么它可能处于雪崩的边缘。

我们这个社会对效率的追求已经达到病态的程度，我就不谈那些高效工作高效学习之类的给世界添堵了。

反之，结合我自身的工作习惯，我想跟你们分享下“冗余”的好处。我发现以前很多看似很蠢的“冗余”行为无意中给到我很多 “惊喜”。

比如，我发现很多同事记录心得经验，一般会归类安置得井井有条，以方便查阅。

但我又懒又随性，既不对内容归类，记录时也就打开文档直接拉到上次记录的底部写起。这导致我每次翻阅时都会反复把以前的内容刷一遍。按理说，这属于高冗余低效率的行为吧。

但慢慢地我意识到，每次记录新内容时，刷一眼旧内容竟经常会跟新的阅历产生“化学反应”，旧经验在“进化”，同时衍生了新的独创观点。

从现代认知神经科学的视角看，隔段时间“复习”不仅极大提升了长期记忆的保留率，而且，由于“复习”的过程是对旧有经验的“再现”，它跟新经验产生联结，使得经验结构塑造地更丰富（内化，从而更有利于调用）。无形中，看似低效率的冗余行为竟帮了我大忙。

又比如，我经常纵容大脑的“冗余”行为，比如工作压力爆棚的间歇，我就经常喜欢随机翻开唐诗宋词“神游”起来。

就好比刚才，我写这篇文章写得有点累，就随便翻了首唐诗（为更清晰体悟我的感受，此处可慢速一字一字朗读）：

苍苍竹林寺，杳杳钟声晚。荷笠带斜阳，青山独归远。——唐诗刘长卿《送灵澈上人》

赏心悦目神游了大半个小时，大脑满血复活。

或许你觉得我吊儿郎当，但其实「少加点班」不少颇受好评的专题，都是在这些半走神状态中突然冒出来的。

现在回想起来，类似这些“低效率”的奇怪工作（学习）习惯，我从未“戒掉”。

现在城市的孩子们备考，那效率高得像在玩命，但我以前初三的时候刷《三国演义》；高三的时候刷《红楼梦》；最近特别忙，于是我又开始刷《海贼王》……

一个井然有序的系统背后一定存在着冗余。

任何聪明的系统或个人，也一定会充分利用“冗余”来平衡效率过高导致的“负效能”。

又比如企业在关键岗位上基本上都有A/B角“双机热备”的设置，看似多出了“空余”人力，实际上却是保障整个系统的安全运作。

至此，我们也可以看到，现在社会的各种996现象，广大学子们“早出晚归”的高效率学习，从社会系统的视角看，根本就在作死的悬崖上走钢丝。

所以，如果你发现自己明明很努力了，但仍然工作成效低、学习没长进，那么不是因为效率低，恰恰相反是效率太高了！

如果你想活得好一点，活地长命一点，还是赶紧为自己进行一些“冗余”设置吧。

发表于
字数统计: 2,368 字 | 阅读时长 ≈ 13 min

1.引用包 maven

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--xml做数据库工具-->
<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>
<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.1.1</version>
</dependency>
<!-- 阿里的，类转map，map 转类-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.54</version>
</dependency>

2.数据库的xml文件

放到springboot 项目中的文件 taglibrary/src/main/resources/xmldatabase/userxml.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?xml version="1.0" encoding="UTF-8"?>
<RECORDS>
<RECORD>
<id>1</id>
<username>用户名</username>
<deptId>部门</deptId>
<sex>男</sex>
<iconid>头像id</iconid>
<city>北京</city>
<password>password</password>
<onlinestate>状态</onlinestate>
<lastlogintime>最后登录时间</lastlogintime>
<registertime>时间</registertime>
</RECORD>
<RECORD>
<id>2021060715375511</id>
<username>2</username>
<deptId>1</deptId>
<sex>2</sex>
<iconid>2</iconid>
<city>1</city>
<password>2</password>
<onlinestate>2</onlinestate>
<lastlogintime>2</lastlogintime>
<registertime>2</registertime>
</RECORD>
</RECORDS>

3 application 配置xml地址和名称

1
2
xmldatabase.path = D:/ideaWorkspace/work20210607biaoqianku/taglibrary/src/main/resources/xmldatabase/
xmldatabase.userxml = userxml.xml

3 代码

UserxmlDao.java 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
package com.taglibrary.platform.userxml;

import com.alibaba.fastjson.JSON;
import com.taglibrary.commonbase.BaseDao;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

/**
 *
 *
 * @author wjk
 * @date  2021/06/09
 */

@Service
public class UserxmlDao extends BaseDao {

    @Value("${xmldatabase.path}")
    private String xmldatabasePath;
    @Value("${xmldatabase.userxml}")
    private String tableName;

    /**
     * 获取全部数据
     * @return List<Userxml>
     */
    public List<Userxml> getAll() {
        List<Userxml> list = new ArrayList<Userxml>();
        //定义一个reader和HashMap，HashMap是用来返回我们要查询的这个用户的信息的
        SAXReader reader = new SAXReader();
        try {

            //得到user.xml的这个doc
            Document doc = reader.read(new File(xmldatabasePath+tableName));
            //得到所有用户的一个集合userList
            List<Element> userList = doc.selectNodes("//RECORDS/RECORD");
            //得到迭代器，
            Iterator<Element> iter = userList.iterator();

            while (iter.hasNext()) {
                HashMap<String, String> map = new HashMap<String, String>();
                //得到每一个user元素，进行判断
                Element e = iter.next();
                //如果这个user的ID和我们查询的ID一致，则将其所有的信息放入到map当中
                //得到这个user的所有子元素
                List<Element> childElements = e.elements();
                //得到所有子元素的迭代器
                Iterator<Element> childIter = childElements.iterator();
                //如果还有子元素，则
                while (childIter.hasNext()) {
                    //得到子元素，将其信息放入到map当中
                    Element childElement = childIter.next();
                    map.put(childElement.getQName().getName(), childElement.getText());
                }
                Userxml userxml = JSON.parseObject(JSON.toJSONString(map), Userxml.class);
                list.add(userxml);
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.toString());
        }
        return list;
    }
    /**
    * 查询
    * @param Id
    * @return Userxml
    */
    public Userxml getOne(Long Id){
        Userxml userxml = new Userxml();
        List<Userxml> list =  getAll();
            for(int i = 0; i<list.size();i++){
                Userxml userxmltmp = list.get(i);
                if(userxmltmp.getId().toString().equals(Id.toString())){
                userxml = userxmltmp;
                break;
            }
        }
        return userxml;
     };

    /**
    *  增加
    * @param userxml
    * @return Userxml
    */
    public Userxml insert(Userxml userxml){
        try{
            //读取文件
            SAXReader saxReader = new SAXReader();
            Document doc = saxReader.read(new File(xmldatabasePath+tableName));
            //得到跟结点root
            Element root = doc.getRootElement();
            //往根节点添加user元素
            Element element = root.addElement("RECORD");
            //设置element的ID
            element.addAttribute("id", userxml.getId().toString());

            //往user添加各种子元素和设置值
            Element Id = element.addElement("id");
            Id.setText(userxml.getId().toString());
            Element Username = element.addElement("username");
            Username.setText(userxml.getUsername().toString());
            Element Deptid = element.addElement("deptid");
            Deptid.setText(userxml.getDeptid().toString());
            Element Sex = element.addElement("sex");
            Sex.setText(userxml.getSex().toString());
            Element Iconid = element.addElement("iconid");
            Iconid.setText(userxml.getIconid().toString());
            Element City = element.addElement("city");
            City.setText(userxml.getCity().toString());
            Element Password = element.addElement("password");
            Password.setText(userxml.getPassword().toString());
            Element Onlinestate = element.addElement("onlinestate");
            Onlinestate.setText(userxml.getOnlinestate().toString());
            Element Lastlogintime = element.addElement("lastlogintime");
            Lastlogintime.setText(userxml.getLastlogintime().toString());
            Element Registertime = element.addElement("registertime");
            Registertime.setText(userxml.getRegistertime().toString());

            //添加元素结束后往新的文件重新写入doc数据
            XMLWriter output = new XMLWriter(new FileWriter( new File(xmldatabasePath+tableName) ));
            output.write(doc);
            //关闭输出流
            output.close();

        }

        catch(DocumentException e){
            e.printStackTrace();
        }

        catch(IOException e){
            e.printStackTrace();
        }
        return userxml;
    }
    /**
    * 删除
    * @param Id
    * @return Userxml
    */
    public Userxml delete(Long Id){
        Userxml userxml = new Userxml();
        SAXReader reader = new SAXReader();
        try {
            //得到user.xml的Document
            Document doc = reader.read(new File(xmldatabasePath+tableName));
            //得到跟结点
            Element root = doc.getRootElement();
            //得到根节点下的所有user集合
            List<Element> userList = doc.selectNodes("//RECORDS/RECORD");
            //得到迭代器
            Iterator<Element> iter = userList.iterator();
            while(iter.hasNext()){
                HashMap<String, String> map = new HashMap<String, String>();
                //得到user元素
                Element e = iter.next();
                //得到这个user的所有子元素
                List<Element> childElements = e.elements();
                //得到所有子元素的迭代器
                Iterator<Element> childIter = childElements.iterator();
                    //如果还有子元素，则
                    while (childIter.hasNext()) {
                    //得到子元素，将其信息放入到map当中
                    Element childElement = childIter.next();
                    map.put(childElement.getQName().getName(), childElement.getText());
                }
                Userxml userxmlTmp = JSON.parseObject(JSON.toJSONString(map), Userxml.class);
                if(userxmlTmp.getId() == Id){
                    root.remove(e);
                    userxml = userxmlTmp;
                }
            }
            //得到XML的输出流
            XMLWriter output;
            try {
                output = new XMLWriter(new FileWriter( new File(xmldatabasePath+tableName) ));
                //将内存中的doc写入到新文件当中
                output.write(doc);
                //关闭输出流
                output.close();
             } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return userxml;
    }

    /**
    *  修改
    * @param userxml
    * @return userxml
    */
    public Userxml update(Userxml userxml){
        try {
            //得到user.xml文件，将其读取到doc当中
            SAXReader reader = new SAXReader();
            Document doc = reader.read(new File(xmldatabasePath+tableName));
            //得到跟结点root
            Element root = doc.getRootElement();
            //得到根节点TUser下的所有用户，将其存放到userList当中
            List<Element> userList = doc.selectNodes("//RECORDS/RECORD");
            //得到可以访问所有用户的迭代器Iterator
            Iterator<Element> iter = userList.iterator();
            //如果迭代器还有下一个，则取出来
            while(iter.hasNext()){
                HashMap<String, String> map = new HashMap<String, String>();

                //得到user元素
                Element e = iter.next();
                //得到这个user的所有子元素
                List<Element> childElements = e.elements();
                //得到所有子元素的迭代器
                Iterator<Element> childIter = childElements.iterator();
                //如果还有子元素，则
                while (childIter.hasNext()) {
                    //得到子元素，将其信息放入到map当中
                    Element childElement = childIter.next();
                    map.put(childElement.getQName().getName(), childElement.getText());
                }
                Userxml userxmlTmp = JSON.parseObject(JSON.toJSONString(map), Userxml.class);
                if(userxml.getId() == userxmlTmp.getId()){
                    Class cls = userxml.getClass();
                    Field[] fields = cls.getDeclaredFields();
                    for(int i=0; i<fields.length; i++){
                        Field f = fields[i];
                        f.setAccessible(true);
                        Element childElement = e.element(f.getName());
                        try {
                             childElement.setText(f.get(userxml).toString());
                        } catch (IllegalAccessException iae) {
                                                iae.printStackTrace();
                        }
                    }
                }
            }
            //得到XML的输出流
            XMLWriter output;
            try {
                output = new XMLWriter(new FileWriter( new File(xmldatabasePath+tableName) ));
                //将内存中的doc写入到新文件当中
                output.write(doc);
                //关闭输出流
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return userxml;
    }

}

UserxmlController.java 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package com.taglibrary.platform.userxml;

import java.util.List;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.mybatis.logging.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.context.annotation.Scope;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.PrintWriter;
import java.util.List;

import com.taglibrary.commonbase.BaseController;
import com.taglibrary.util.ReturnDataJson;

import com.taglibrary.platform.userxml.Userxml;
import com.taglibrary.platform.userxml.UserxmlService;
/**
 *
 *
 * @author wjk
 * @date  2021/06/09
 */
@Controller
@Scope("request")
@RequestMapping("/userxml")
@Api(value = "", tags = {""})
public class UserxmlController extends BaseController {

    @Resource
    private UserxmlService service;

    @Resource
    private UserxmlDao dao;

    /**
    * 查询（获取全部）
    */
    @RequestMapping(value = "/getAll",method=RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "查询（获取全部）")
    public ReturnDataJson getall() {
        ReturnDataJson res;
        try {
            List<Userxml> list = this.dao.getAll();
            res = this.responseReturnDataJson(true,"成功",list,Long.valueOf(list.size()));
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            res = this.responseReturnDataJson(false,"失败");
        }
        return res;
    }


    /**
    * 查询（根据id）
    */
    @RequestMapping(value = "/detail",method=RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "查询（根据id）")
    public ReturnDataJson detail(@RequestBody Userxml userxml) {
        ReturnDataJson res;
        try {
            Userxml olduserxml= this.dao.getOne(userxml.getId());
            if(olduserxml.getId() == null){
                res = this.responseReturnDataJson(false,"失败","未查询到数据（id="+userxml.getId().toString()+"）");
            } else{
                 res = this.responseReturnDataJson(true,"成功");
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            res = this.responseReturnDataJson(false,"失败");
        }
        return res;
  }
    /**
     * 增加
     **/
    @RequestMapping(value = "/add",method=RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "增加")
    public ReturnDataJson add(@RequestBody Userxml userxml) {
        ReturnDataJson res;
        try {
            Userxml olduserxml= this.dao.getOne(userxml.getId());
            if(olduserxml.getId() == null){
                Userxml newuserxml= this.dao.insert(userxml);
                res = this.responseReturnDataJson(true,"成功",newuserxml);
            } else{
                res = this.responseReturnDataJson(false,"失败","已有数据（id="+olduserxml.getId().toString()+"）");
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            res = this.responseReturnDataJson(false,"失败");
        }
        return res;
    }

    /**
     * 修改
     **/
    @RequestMapping(value = "/update",method=RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "修改（根据id）")
    public ReturnDataJson update(@RequestBody Userxml userxml) {
        ReturnDataJson res;
        try {
            Userxml olduserxml= this.dao.getOne(userxml.getId());
            if(olduserxml.getId() == null){
                res = this.responseReturnDataJson(false,"失败","未查询到数据（id="+userxml.getId().toString()+"）");
            } else{
                Userxml newuserxml= this.dao.update(userxml);
                res = this.responseReturnDataJson(true,"成功",newuserxml);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            res = this.responseReturnDataJson(false,"失败");
        }
        return res;
    }

    /**
     * 删除（根据id）
     **/
    @RequestMapping(value = "/delete",method=RequestMethod.POST)
    @ResponseBody
    @ApiOperation(value = "删除（根据id）")
    public ReturnDataJson delete(@RequestBody Userxml userxml) {
        ReturnDataJson res;
        try {
            Userxml olduserxml= this.dao.getOne(userxml.getId());
            if(olduserxml.getId() == null){
                res = this.responseReturnDataJson(false,"失败","未查询到数据（id="+userxml.getId().toString()+"）");
            } else{
                Userxml newuserxml= this.dao.delete(userxml.getId());
                res = this.responseReturnDataJson(true,"成功");
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            res = this.responseReturnDataJson(false,"失败");
        }
        return res;
    }

}

发表于
字数统计: 688 字 | 阅读时长 ≈ 3 min

常用命令

1.CPU采集命令

1
lscpu

2.内存采集命令

1
free -g

3.GPU信息采集命令

1
lspci | grep -i nvi

4.linux下 挂载硬盘不成功 安装lvm2 文件系统支持操作

1
2
3
4
5
6
7
8
9
10
11
12
yum install lvm2

# 查看pv
pvs
# 查看vg
vgs  
# 查看lv
lvs 
# 创建一个名叫bml的vg卷组
pvcreate /dev/vdb   vgcreate data /dev/vdb 
# 在data卷组里创建一个500G的分区，名字叫gfssysdata
lvcreate -L 500G -n gfssysdata data

5.分盘挂盘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
1.查看磁盘
fdisk -l
2.查看挂载
df -h
3.卸掉挂载
umount /dev/sd<盘符>                  // 注意在卸载前检查目录是否存在价值文件，再卸载

4.先注释掉/etc/fstab中卸载掉的信息
   // 例： #/dev/sdb03     /data     ext4    defaults    0   1  预防分区后自动挂载。

5.删掉磁盘分区
parted -s  /dev/sd<盘符> rm 3         // 3,4 代表第几个分区,这里注意不要删除/根分区或BIOS分区，  一块磁盘情况下1，2一般有根/分区，
parted -s  /dev/sd<盘符> rm 4

6.磁盘分区 按照实际情况进行分区                             // !!超过1T以上的大磁盘不要用fdisk进行分区
parted -s  /dev/sd<盘符>  mkpart primary  100g  300g    // -s指定磁盘  创建一个主分区  从100g开始到300g结束  
parted -s  /dev/sd<盘符>  mkpart primary  300g  1000g   // 预留的盘也要分出来

7.格式化磁盘
mkfs.xfs -f  -n ftype=1 /dev/s<盘符>  // 单独格式化一块xfs格式磁盘，挂/docker-data下存放docker数据
mkfs.ext4 -F /dev/sd<盘符>            // 其他的都格式化成ext4

8.修改/etc/fstab加入以下
/dev/s<盘符>    /mnt              ext4    defaults             0   1          // 作用于日志存储
/dev/s<盘符>    /data             ext4    defaults             0   1          // 作用于工作目录
/dev/s<盘符>    /docker-data      xfs     defaults,prjquota    0   1          // 作用于docker-data，必须是xfs,有prjquota
/dev/s<盘符>    /glusterfs-registry      ext4    defaults      0   1          // 作用于公共镜像仓库
/dev/s<盘符>    /glusterfs-sys-data   ext4    defaults         0   1          // 作用于系统依赖存储
/dev/s<盘符>    /glusterfs-user-data   ext4    defaults        0   1          // 作用于BML平台用户存储

9.创建目录并挂载
mkdir -p /data /docker-data /glusterfs-registry /glusterfs-sys-data /glusterfs-user-data && mount -a

6.md5 验证

1
2
wget http://download.qt.io/archive/qt/4.8/4.8.6/qt-everywhere-opensource-src-4.8.6.tar.gz
md5sum qt-everywhere-opensource-src-4.8.6.tar.gz | cut -d ' ' -f1

将生成的md5指纹和官方给的做对比看是否一样

7.下载文件并且重命名

1
wget -c http://mirrors.163.com/centos/8.1.1911/isos/x86_64/CentOS-8.1.1911-x86_64-dvd1.iso -O CentOS8.iso

7.建立软链接

ln -s /data/bml4.6.0_ais2.3.0_easydata3.0.2/verify_cases/reports /opt/repos/reports

发表于
字数统计: 105 字 | 阅读时长 ≈ 1 min

在node中打断点调试程序不像浏览器那样可直接在浏览器中某一行打断点，那么node该如何打断点调试程序呢？

1.进入我们要执行的node文件 

2.执行 node –inspect-brk  index.js

3.在谷歌浏览器中打开地址：chrome://inspect/#devices  显示页面

4.点击上图中红框中的inspect按钮，进入程序调试界面