# 前提
很多时候我们会查询一个列表，然后对列表过滤分组，构建一个key对应特定的几个列表的情况出现，java中要写比较多的代码，其实可以使用mysql直接构建出一对多的json结构，然后将json返回，java中只需要将这个json转成一个对象即可



# 业务
下面例子都是不创建新对象直接转换成map使用，如果创建新对象那么json转成对象的速度会更快，也会更方便。比如
```java
        List<String> serieData=baseMapper.getCheckTrainTaskNumByTrain(req,robNames);
        for (String s : serieData) {
            seriesReq r= JSON.parseObject(s,seriesReq.class);
            series.add(r);
        }
        Map<String, Object> result = new HashMap<>();
        result.put("xAxis", xAxis);
        result.put("series", series);
        return result;
    }
```

```java
//String接受json对象
public Map<String, Object> test(Request req){
        List<Map<String,Object>> dataList=new ArrayList<>();
        List<String> list = baseMapper.getCheckFaultNum(req);
        for (String s: list) {
            JSONObject jsonObject=JSON.parseObject(s);
            Map<String,Object> map=jsonObject.getInnerMap();
            List<Object> listobj=JSON.parseArray((String) map.get("list"),Object.class);
            map.put("list", listobj);
            dataList.add(map);
        }
        return Collections.singletonMap("data",dataList);
}
//JSONObject接受json对象
public Map<String, Object> test(Request req){
        List<Map<String,Object>> dataList=new ArrayList<>();
        List<JSONObject> list = baseMapper.getCheckFaultNum(req);
        for (JSONObject jsonObject : list) {
            String value=(String)jsonObject.get("result");//这个result就是sql里面json对象的别名
            JSONObject o= JSON.parseObject(value);
            Map<String, Object> res=o.getInnerMap();
            List<Object> listobj=JSON.parseArray((String) map.get("list"),Object.class);
            map.put("list", listobj);
            dataList.add(res);
        }
        return Collections.singletonMap("data",dataList);
}

//字符串接受jsonArray
public Map<String, Object> test(Request req){
        List<Map<String,Object>> dataList = new ArrayList<>();
        String str = baseMapper.getCheckFaultNum(req);
        JSONArray jsonArray=JSON.parseArray(str);
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject obj = JSONObject.parseObject((String) jsonArray.get(i));
            Map<String, Object> res=o.getInnerMap();
            List<Object> listobj=JSON.parseArray((String) map.get("list"),Object.class);
            map.put("list", listobj);
            dataList.add(res);
        }
        return Collections.singletonMap("data",dataList);
}
//直接使用阿里巴巴的JSONArray对象不能直接接受数据库返回的jsonArray，只能采用string的方式接受了
```

# SQL
```xml
<select id="getCheckFaultNum" resultType="com.alibaba.fastjson.JSONObject">
        SELECT JSON_OBJECT(
        'name', '总数',
        'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
        ), '[]')
        ) AS result
        FROM         ( SELECT
        DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
        COUNT(*) AS totalFaults

        FROM
        product_abnormal_v a
        <where>
            a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
            and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
            and a.fault_status!=2
            and a.task_status=6
            and a.check_mode=0
        </where>
        GROUP BY
        DATE_FORMAT(a.check_time, '%Y-%m-%d'))item
        <if test="req.trainNo != null and req.trainNo != ''">
            union all
            SELECT JSON_OBJECT(
            'name',#{req.trainNo},
            'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
            ), '[]')
            ) AS result
            FROM         ( SELECT
            DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
            COUNT(*) AS totalFaults

            FROM
            product_abnormal_v a
            <where>
                a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
                and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
                and a.fault_status!=2
                and a.task_status=6
                and a.check_mode=0
                and a.vehicle_no=#{req.trainNo}
            </where>
            GROUP BY
            DATE_FORMAT(a.check_time, '%Y-%m-%d'))item
        </if>
</select>
```

```xml
<select id="getCheckFaultNum" resultType="java.lang.String">
        SELECT JSON_OBJECT(
        'name', '总数',
        'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
        ), '[]')
        ) AS result
        FROM         ( SELECT
        DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
        COUNT(*) AS totalFaults

        FROM
        product_abnormal_v a
        <where>
            a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
            and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
            and a.fault_status!=2
            and a.task_status=6
            and a.check_mode=0
        </where>
        GROUP BY
        DATE_FORMAT(a.check_time, '%Y-%m-%d'))item
        <if test="req.trainNo != null and req.trainNo != ''">
            union all
            SELECT JSON_OBJECT(
            'name',#{req.trainNo},
            'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
            ), '[]')
            ) AS result
            FROM         ( SELECT
            DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
            COUNT(*) AS totalFaults

            FROM
            product_abnormal_v a
            <where>
                a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
                and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
                and a.fault_status!=2
                and a.task_status=6
                and a.check_mode=0
                and a.vehicle_no=#{req.trainNo}
            </where>
            GROUP BY
            DATE_FORMAT(a.check_time, '%Y-%m-%d'))item

        </if>
</select>
```

```xml
<select id="getCheckFaultNum" resultType="java.lang.String">
        select JSON_ARRAYAGG(it.result) as array
        from (
        SELECT JSON_OBJECT(
        'name', '总数',
        'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
        ), '[]')
        ) AS result
        FROM         ( SELECT
        DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
        COUNT(*) AS totalFaults

        FROM
        product_abnormal_v a
        <where>
            a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
            and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
            and a.fault_status!=2
            and a.task_status=6
            and a.check_mode=0
        </where>
        GROUP BY
        DATE_FORMAT(a.check_time, '%Y-%m-%d'))item
        <if test="req.trainNo != null and req.trainNo != ''">
            union all
            SELECT JSON_OBJECT(
            'name',#{req.trainNo},
            'list', COALESCE(JSON_ARRAYAGG(
            JSON_OBJECT(
                'totalFaults', item.totalFaults,
                'checkDate', item.checkDate
            )
            ), '[]')
            ) AS result
            FROM         ( SELECT
            DATE_FORMAT(a.check_time, '%Y-%m-%d')  AS checkDate,
            COUNT(*) AS totalFaults

            FROM
            product_abnormal_v a
            <where>
                a.check_time <![CDATA[>=]]>  #{req.startDate,jdbcType=DATE}
                and a.check_time <![CDATA[<=]]> #{req.endDate,jdbcType=DATE}
                and a.fault_status!=2
                and a.task_status=6
                and a.check_mode=0
                and a.vehicle_no=#{req.trainNo}
            </where>
            GROUP BY
            DATE_FORMAT(a.check_time, '%Y-%m-%d'))item

        </if>
        ) it
    </select>
```

Mysql中构建JSON并查询使用

# 下载
    docker pull easysoft/zentao:latest
    
[官方下载](https://www.zentao.net/downloads.html)
# 安装
## 快速部署-内部数据库
```
docker run \
--name zentao \
-p 80:80 \
--mac-address 02:42:ac:11:00:00 \
-v /data/zentao:/data \
-e MYSQL_INTERNAL=true \
-d easysoft/zentao:latest

```



通过设置 MYSQL_INTERNAL=true 会启动内置的MySQL服务, 默认用户名为 root,密码是 123456

## 普通部署-外部数据库
网络分配、redis相关内容不是必须的，不需要的话就不用配置，禅道运行命令里把相关内容删除即可，redis主要是用来作为Session配置，这是[官网文档](https://www.zentao.net/book/zentaopms/docker-1111.html#10) [文档](https://www.zentao.net/book/zentaopmshelp/405.html)
### 创建网络
```
#docker network create --subnet=[ip范围] [网络驱动名] 
docker new work create --subnet=172.172.172.0/24 zentao-net
```
### 拉取redis mysql
```
docker pull redis
docker pull mysql:5.7
```
### 启动
```
# 运行redis
docker run -d --restart=always --name redis  -p 6379:6379 -d redis:latest
# 运行mysql
docker run -d --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -e MYSQL_DATABASE=zentao mysql:5.7
```

运行禅道
端口含义zentao内网的80->映射到外部宿主机的8088 ,服务器ip：8088
```
docker run -d --rm --name zentao \
--link mysql \
--link redis \
-e MYSQL_INTERNAL=false \
-e ZT_MYSQL_HOST=mysql \
-e ZT_MYSQL_PORT=3306 \
-e ZT_MYSQL_USER=root \
-e ZT_MYSQL_PASSWORD=pass4you \
-e ZT_MYSQL_DB=zentao \
-e PHP_SESSION_TYPE=redis \
-e PHP_SESSION_PATH=tcp://redis:6379 \
-v /data/zentao:/data \
-p 8088:80 \
--network=zentao-net \
--ip 172.172.172.1 \
easysoft/zentao:latest

```
```
docker run -d --rm --name zentao \
--link mysql \
--link redis \
-e MYSQL_INTERNAL=false \
-e ZT_MYSQL_HOST=mysql \
-e ZT_MYSQL_PORT=3306 \
-e ZT_MYSQL_USER=root \
-e ZT_MYSQL_PASSWORD=pass4you \
-e ZT_MYSQL_DB=zentao \
-e PHP_SESSION_TYPE=redis \
-e PHP_SESSION_PATH=tcp://redis:6379 \
-v /data/zentao:/data \
-p 8088:80 \
easysoft/zentao:latest
```
```
docker run -d --rm --name zentao \
--link mysql \
-e MYSQL_INTERNAL=false \
-e ZT_MYSQL_HOST=mysql \
-e ZT_MYSQL_PORT=3306 \
-e ZT_MYSQL_USER=root \
-e ZT_MYSQL_PASSWORD=pass4you \
-e ZT_MYSQL_DB=zentao \
-v /data/zentao:/data \
-p 8088:80 \
easysoft/zentao:latest
```

Docker部署禅道

# 简介
Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。
编排容器，一键部署多个容器

# 下载安装
github源

    curl -SL https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

DaoCloud源

    curl -L http://get.daocloud.io/docker/compose/releases/download/v2.29.2/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

## 赋予执行权限
    sudo chmod +x /usr/local/bin/docker-compose
## 建立软连接
    sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
## 查看docker版本
    docker-compose --version

# 使用
    mkdir -p /usr/local/testcompose
    cd /usr/local/testcompose
    vi docker-compose.yml
    



示例安装gitea和mysql粘贴配置文件
```
 
version: "3"
 
networks:
  gitea:
    external: false
 
services:
  server:
    image: gitea/gitea:latest
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - DB_TYPE=mysql
      - DB_HOST=db:3306
      - DB_NAME=gitea
      - DB_USER=gitea
      - DB_PASSWD=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"
    depends_on:
      - db
 
  db:
    image: mysql:5.7
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=gitea
      - MYSQL_USER=gitea
      - MYSQL_PASSWORD=gitea
      - MYSQL_DATABASE=gitea
    networks:
      - gitea
    volumes:
      - ./mysql:/var/lib/mysql
```
启动 conponse

    docker-compose up -d
    
    
输入localhost:3000就可以进入gitea配置界面

## docker-conponse编写规则
```
version: '3'#第一层：compose的版本号
services:   #第二层：服务配置信息
  mysql1:   #服务名
    image: mysql  #该服务所基于的镜像名
    environment:  #该服务的环境变量
      MYSQL_ROOT_PASSWORD: "ut.123456"
    ports:        #该服务的暴露端口
      - "3306:3306"
    container_name: "mysql1" #容器名
    networks: #该服务所加入的网络段
      - dev
    volumes:  #挂载数据卷
      - /platform/mysql/conf:/etc/my.cnf.d/my.cnf
      - /platform/mysql/data:/var/lib/mysql:rw"
    depends_on: #顺序
        - db #db服务启动后才会启动这个配置
networks:     #第三层：网络环境
  dev:
    driver: bridge

```

## conponse常用命令
```
# 构建或重建服务
docker-compose build 容器名或者id
# 命令帮助
docker-compose help 
# 杀掉容器
docker-compose kill 容器名或者id
#显示容器的输出内容
docker-compose logs 
# 打印绑定的开放端口
docker-compose port 端口号
# 显示容器
docker-compose ps 
# 拉取服务镜像
docker-compose pull 镜像名
# 重启服务
docker-compose restart 
# 删除停止的容器
docker-compose rm

#运行一个一次性命令
docker-compose run 
#设置服务的容器数目
docker-compose scale 
#开启服务
docker-compose start 
#停止服务
docker-compose stop 

# 创建并启动容器
docker-compose up 

更多命令可以查看帮助 `docker-compose -h`和`docker compose COMMAND --help`

```

Docker-Componse使用

IDEA一键部署Docker应用

一、基础知识
------

### 1.1 Linux系统的文件结构

```
/bin        二进制文件，系统常规命令
/boot       系统启动分区，系统启动时读取的文件
/dev        设备文件
/etc        大多数配置文件
/home       普通用户的家目录
/lib        32位函数库
/lib64      64位库
/media      手动临时挂载点
/mnt        手动临时挂载点
/opt        第三方软件安装位置
/proc       进程信息及硬件信息
/root       临时设备的默认挂载点
/sbin       系统管理命令
/srv        数据
/var        数据
/sys        内核相关信息
/tmp        临时文件
/usr        用户相关设定
```

### 1.2 Linux系统命令行的含义

```
示例：root@app00:~# 
root    //用户名，root为超级用户
@       //分隔符
app00   //主机名称
~       //当前所在目录，默认用户目录为~，会随着目录切换而变化，例如：（root@app00:/bin# ，当前位置在bin目录下）
#       //表示当前用户是超级用户，普通用户为$，例如：（"yao@app00:/root$" ，表示使用用户"yao"访问/root文件夹）
```

### 1.3 命令的组成

```
示例：命令 参数名 参数值
```

二、基础操作
------

### 2.1 关闭系统

```
(1)立刻关机
  shutdown -h now 或者 poweroff
(2)两分钟后关机
  shutdown -h 2
```



### 2.2 关闭重启

```
(1)立刻重启
  shutdown -r now 或者 reboot
(2)两分钟后重启
  shutdown -r 2 
```

### 2.3 帮助命令（help）

```
  ifconfig  --help     //查看 ifconfig 命令的用法
```

### 2.4 命令说明书（man）

```
  man shutdown         //打开命令说明后，可按"q"键退出
```

### 2.5 切换用户（su）

```
  su yao               //切换为用户"yao",输入后回车需要输入该用户的密码
  exit                 //退出当前用户
```

三、目录操作
------

### 3.1 切换目录（cd）

```
  cd /                 //切换到根目录
  cd /bin              //切换到根目录下的bin目录
  cd ../               //切换到上一级目录 或者使用命令：cd ..
  cd ~                 //切换到home目录
  cd -                 //切换到上次访问的目录
  cd xx(文件夹名)       //切换到本目录下的名为xx的文件目录，如果目录不存在报错
  cd /xxx/xx/x         //可以输入完整的路径，直接切换到目标目录，输入过程中可以使用tab键快速补全
```

### 3.2 查看目录（ls）

```
  ls                   //查看当前目录下的所有目录和文件
  ls -a                //查看当前目录下的所有目录和文件（包括隐藏的文件）
  ls -l                //列表查看当前目录下的所有目录和文件（列表查看，显示更多信息），与命令"ll"效果一样
  ls /bin              //查看指定目录下的所有目录和文件 
```

### 3.3 创建目录（mkdir）

```
  mkdir tools          //在当前目录下创建一个名为tools的目录
  mkdir /bin/tools     //在指定目录下创建一个名为tools的目录
```

### 3.3 删除目录与文件（rm）

```
  rm 文件名              //删除当前目录下的文件
  rm -f 文件名           //删除当前目录的的文件（不询问）
  rm -r 文件夹名         //递归删除当前目录下此名的目录
  rm -rf 文件夹名        //递归删除当前目录下此名的目录（不询问）
  rm -rf *              //将当前目录下的所有目录和文件全部删除
  rm -rf /*             //将根目录下的所有文件全部删除【慎用！相当于格式化系统】
```

### 3.4 修改目录（mv）

```
  mv 当前目录名 新目录名        //修改目录名，同样适用与文件操作
  mv /usr/tmp/tool /opt       //将/usr/tmp目录下的tool目录剪切到 /opt目录下面
  mv -r /usr/tmp/tool /opt    //递归剪切目录中所有文件和文件夹
```

### 3.5 拷贝目录（cp）

```
  cp /usr/tmp/tool /opt       //将/usr/tmp目录下的tool目录复制到 /opt目录下面
  cp -r /usr/tmp/tool /opt    //递归剪复制目录中所有文件和文件夹
```

### 3.6 搜索目录（find）

```
  find /bin -name 'a*'        //查找/bin目录下的所有以a开头的文件或者目录
```

### 3.7 查看当前目录（pwd）

```
  pwd                         //显示当前位置路径
```

四、文件操作
------

### 4.1 新增文件（touch）

```
   touch  a.txt         //在当前目录下创建名为a的txt文件（文件不存在），如果文件存在，将文件时间属性修改为当前系统时间
```

### 4.2 删除文件（rm）

```
  rm 文件名              //删除当前目录下的文件
  rm -f 文件名           //删除当前目录的的文件（不询问）
```

### 4.3 编辑文件（vi、vim）

```
  vi 文件名              //打开需要编辑的文件
  --进入后，操作界面有三种模式：命令模式（command mode）、插入模式（Insert mode）和底行模式（last line mode）
  命令模式
  -刚进入文件就是命令模式，通过方向键控制光标位置，
  -使用命令"dd"删除当前整行
  -使用命令"/字段"进行查找
  -按"i"在光标所在字符前开始插入
  -按"a"在光标所在字符后开始插入
  -按"o"在光标所在行的下面另起一新行插入
  -按"："进入底行模式
  插入模式
  -此时可以对文件内容进行编辑，左下角会显示 "-- 插入 --""
  -按"ESC"进入底行模式
  底行模式
  -退出编辑：      :q
  -强制退出：      :q!
  -保存并退出：    :wq
  ## 操作步骤示例 ##
  1.保存文件：按"ESC" -> 输入":" -> 输入"wq",回车     //保存并退出编辑
  2.取消操作：按"ESC" -> 输入":" -> 输入"q!",回车     //撤销本次修改并退出编辑
  ## 补充 ##
  vim +10 filename.txt                   //打开文件并跳到第10行
  vim -R /etc/passwd                     //以只读模式打开文件
```

### 4.4 查看文件

```
  cat a.txt          //查看文件最后一屏内容
  less a.txt         //PgUp向上翻页，PgDn向下翻页，"q"退出查看
  more a.txt         //显示百分比，回车查看下一行，空格查看下一页，"q"退出查看
  tail -100 a.txt    //查看文件的后100行，"Ctrl+C"退出查看
```

五、文件权限
------

### 5.1 权限说明

```
  文件权限简介：'r' 代表可读（4），'w' 代表可写（2），'x' 代表执行权限（1），括号内代表"8421法"
  ##文件权限信息示例：-rwxrw-r--
  -第一位：'-'就代表是文件，'d'代表是文件夹
  -第一组三位：拥有者的权限
  -第二组三位：拥有者所在的组，组员的权限
  -第三组三位：代表的是其他用户的权限
```

### 5.2 文件权限

```
  普通授权    chmod +x a.txt    
  8421法     chmod 777 a.txt     //1+2+4=7，"7"说明授予所有权限
```

六、打包与解压
-------

### 6.1 说明

```
  .zip、.rar        //windows系统中压缩文件的扩展名
  .tar              //Linux中打包文件的扩展名
  .gz               //Linux中压缩文件的扩展名
  .tar.gz           //Linux中打包并压缩文件的扩展名
```

### 6.2 打包文件

```
  tar -zcvf 打包压缩后的文件名 要打包的文件
  参数说明：z：调用gzip压缩命令进行压缩; c：打包文件; v：显示运行过程; f：指定文件名;
  示例：
  tar -zcvf a.tar file1 file2,...      //多个文件压缩打包
```

### 6.3 解压文件

```
  tar -zxvf a.tar                      //解包至当前目录
  tar -zxvf a.tar -C /usr------        //指定解压的位置
  unzip test.zip             //解压*.zip文件 
  unzip -l test.zip          //查看*.zip文件的内容 
```

七、其他常用命令
--------

### 7.1 find

```
  find . -name "*.c"     //将目前目录及其子目录下所有延伸档名是 c 的文件列出来
  find . -type f         //将目前目录其其下子目录中所有一般文件列出
  find . -ctime -20      //将目前目录及其子目录下所有最近 20 天内更新过的文件列出
  find /var/log -type f -mtime +7 -ok rm {} \;     //查找/var/log目录中更改时间在7日以前的普通文件，并在删除之前询问它们
  find . -type f -perm 644 -exec ls -l {} \;       //查找前目录中文件属主具有读、写权限，并且文件所属组的用户和其他用户具有读权限的文件
  find / -type f -size 0 -exec ls -l {} \;         //为了查找系统中所有文件长度为0的普通文件，并列出它们的完整路径
```

### 7.2 whereis

```
  whereis ls             //将和ls文件相关的文件都查找出来
```

### 7.3 which

```
  说明：which指令会在环境变量$PATH设置的目录里查找符合条件的文件。
  which bash             //查看指令"bash"的绝对路径
```

### 7.4 sudo

```
  说明：sudo命令以系统管理者的身份执行指令，也就是说，经由 sudo 所执行的指令就好像是 root 亲自执行。需要输入自己账户密码。
  使用权限：在 /etc/sudoers 中有出现的使用者
  sudo -l                              //列出目前的权限
  $ sudo -u yao vi ~www/index.html    //以 yao 用户身份编辑  home 目录下www目录中的 index.html 文件
```

### 7.5 grep

```
  grep -i "the" demo_file              //在文件中查找字符串(不区分大小写)
  grep -A 3 -i "example" demo_text     //输出成功匹配的行，以及该行之后的三行
  grep -r "ramesh" *                   //在一个文件夹中递归查询包含指定字符串的文件
```

### 7.6 service

```
  说明：service命令用于运行System V init脚本，这些脚本一般位于/etc/init.d文件下，这个命令可以直接运行这个文件夹里面的脚本，而不用加上路径
  service ssh status      //查看服务状态 
  service --status-all    //查看所有服务状态 
  service ssh restart     //重启服务 
```

### 7.7 free

```
  说明：这个命令用于显示系统当前内存的使用情况，包括已用内存、可用内存和交换内存的情况 
  free -g            //以G为单位输出内存的使用量，-g为GB，-m为MB，-k为KB，-b为字节 
  free -t            //查看所有内存的汇总
```

### 7.8 top

```
  top               //显示当前系统中占用资源最多的一些进程, shift+m 按照内存大小查看
```

### 7.9 df

```
  说明：显示文件系统的磁盘使用情况
  df -h            //一种易看的显示
```

### 7.10 mount

```
  mount /dev/sdb1 /u01              //挂载一个文件系统，需要先创建一个目录，然后将这个文件系统挂载到这个目录上
  dev/sdb1 /u01 ext2 defaults 0 2   //添加到fstab中进行自动挂载，这样任何时候系统重启的时候，文件系统都会被加载 
```

### 7.11 uname

```
  说明：uname可以显示一些重要的系统信息，例如内核名称、主机名、内核版本号、处理器类型之类的信息 
  uname -a
```

### 7.12 yum

```
  说明：安装插件命令
  yum install httpd      //使用yum安装apache 
  yum update httpd       //更新apache 
  yum remove httpd       //卸载/删除apache 
```

### 7.13 rpm

```
  说明：插件安装命令
  rpm -ivh httpd-2.2.3-22.0.1.el5.i386.rpm      //使用rpm文件安装apache 
  rpm -uvh httpd-2.2.3-22.0.1.el5.i386.rpm      //使用rpm更新apache 
  rpm -ev httpd                                 //卸载/删除apache 
```

### 7.14 date

```
  date -s "01/31/2010 23:59:53"   ///设置系统时间
```

### 7.15 wget

```
  说明：使用wget从网上下载软件、音乐、视频 
  示例：wget http://prdownloads.sourceforge.net/sourceforge/nagios/nagios-3.2.1.tar.gz
  //下载文件并以指定的文件名保存文件
  wget -O nagios.tar.gz http://prdownloads.sourceforge.net/sourceforge/nagios/nagios-3.2.1.tar.gz
```

### 7.16 ftp

```
   ftp IP/hostname    //访问ftp服务器
   mls *.html -       //显示远程主机上文件列表
```

### 7.17 scp

```
	scp /opt/data.txt  192.168.1.101:/opt/    //将本地opt目录下的data文件发送到192.168.1.101服务器的opt目录下
```

八、系统管理
------

### 8.1 防火墙操作

```
  service iptables status      //查看iptables服务的状态
  service iptables start       //开启iptables服务
  service iptables stop        //停止iptables服务
  service iptables restart     //重启iptables服务
  chkconfig iptables off       //关闭iptables服务的开机自启动
  chkconfig iptables on        //开启iptables服务的开机自启动
  ##centos7 防火墙操作
  systemctl status firewalld.service     //查看防火墙状态
  systemctl stop firewalld.service       //关闭运行的防火墙
  systemctl disable firewalld.service    //永久禁止防火墙服务
```

### 8.2 修改主机名（CentOS 7）

```
  hostnamectl set-hostname 主机名
```

### 8.3 查看网络

```
  ifconfig
```

### 8.4 修改IP

```
  修改网络配置文件，文件地址：/etc/sysconfig/network-scripts/ifcfg-eth0
  ------------------------------------------------
  主要修改以下配置：  
  TYPE=Ethernet               //网络类型
  BOOTPROTO=static            //静态IP
  DEVICE=ens00                //网卡名
  IPADDR=192.168.1.100        //设置的IP
  NETMASK=255.255.255.0       //子网掩码
  GATEWAY=192.168.1.1         //网关
  DNS1=192.168.1.1            //DNS
  DNS2=8.8.8.8                //备用DNS
  ONBOOT=yes                  //系统启动时启动此设置
  -------------------------------------------------
  修改保存以后使用命令重启网卡：service network restart
```

### 8.5 配置映射

```
  修改文件： vi /etc/hosts
  在文件最后添加映射地址，示例如下：
   192.168.1.101  node1
   192.168.1.102  node2
   192.168.1.103  node3
  配置好以后保存退出，输入命令：ping node1 ，可见实际 ping 的是 192.168.1.101。
```

### 8.6 查看进程

```
  ps -ef         //查看所有正在运行的进程
```

### 8.7 结束进程

```
  kill pid       //杀死该pid的进程
  kill -9 pid    //强制杀死该进程   
```

### 8.8 查看链接

```
  ping IP        //查看与此IP地址的连接情况
  netstat -an    //查看当前系统端口
  netstat -an | grep 8080     //查看指定端口
  
  telnet ip 端口  //查看端口是否开放
```

### 8.9 快速清屏

```
  ctrl+l        //清屏，往上翻可以查看历史操作
```

### 8.10 远程主机

```
  ssh IP       //远程主机，需要输入用户名和密码
```

本文转自 <https://blog.csdn.net/m0_46422300/article/details/104645072>，如有侵权，请联系删除。