Linux

ForeverSmilingSun

于 2024-07-30 17:10:34 发布

阅读量399

点赞数 4

文章标签： linux 算法 c++

本文链接：https://blog.csdn.net/qq_55123488/article/details/135197068

版权

一、环境准备

1.1 安装虚拟机

安装VMware 16。安装虚拟机，就表示虚拟了一台计算机。然后我们就可以在这台计算机上安装操作系统。当然了，操作系统可以是windows、可以是Linux、也可以是Mac OS。这个虚拟机VMWare可以帮助我们模拟一堆硬件。

第一步：双击安装

第二步：点击上图下一步，选择接受协议

第三步：点击上图下一步

第四步：点击上图下一步

第五步：点击上图下一步

第六步：点击上图下一步

第七步：点击安装

第八步：点击完成，桌面上图标

到此虚拟机这个软件就安装成功了！！！！
注意：该软件需要输入密钥，大家自己想办法获取，这个很容易的。

1.2 新建虚拟机

虚拟机软件安装成功之后，就可以新建虚拟机了。一个虚拟机软件可以创建多个虚拟机，一个虚拟机就代表一台新的电脑。新建虚拟机的过程就相当于去电脑商城购买电脑是一样的。

第一步：双击桌面图标，打开虚拟机软件，点击下图中的创建新的虚拟机

第二步：选择自定义安装。了解更详细的过程

第三步：选择硬件兼容性（默认选项即可）

第四步：稍后安装操作系统，只创建一台裸机

第五步：选择操作系统类型

第六步：给你的电脑起个名字，还有它放在哪里

第七步：设置电脑的CPU数量

根据自己的电脑性能没有硬性规定够用就行

第八步：设置内存大小

第九步：指定网络连接方式为NAT

第十步：选择IO控制器类型（默认即可）

第十一步：选择硬盘类型（默认即可）

第十二步：选择创建新的虚拟磁盘

第十三步：指定硬盘容量

第十四步：指定硬盘对应的文件

第十五步：已准备好，查看电脑的配置，感觉不行的话，可以点击下图自定义硬件进行修改配置。

第十六步：点击完成

到此为止相当于你已经购买了一台新电脑了，只不过这个电脑中还没有任何操作系统，只是一台裸机。接下来你需要安装操作系统。

1.3 安装操作系统CentOS Stream

安装操作系统之前，你需要先下载这个操作系统的镜像文件：

这个文件其实就相当于现实生活中的系统盘（光盘）。把这个文件放到虚拟机的DVD当中：

点击确定，如下图：

接下来点击：开启此虚拟机（相当于现实生活中电脑通电）：

按照下面一步一步安装操作系统：

按上下键，移动到：Install CentOS Stream 9，然后回车。

注意：从虚拟机中释放鼠标的组合键是ctrl + alt

正在安装：

语言选择：简体中文，英文不错的话，可以使用英文，都可以

接下来，要处理三件事：

第一个：安装目的地

第二个：设置root密码

第三个：软件选择

安装目的地，默认即可，点击完成：

设置root密码时允许root远程SSH登录：

软件选择：

点击开始安装：

安装中，请稍后：

安装完成后，点击右下角的重启系统即可！！！

1.4 配置系统

点击下图的开始配置：

设置定位服务，这属于隐私，可以打开，也可以关闭：

设置在线账号，这里跳过：

这是开启除了root管理员之外，开启的其他账户：

设置密码：

完成，点击开始使用：

记得查看一下网络是否正常：

1.5 xshell的安装与使用

打开终端输入ifconfig命令查看ip地址

1.6 xftp的安装与使用

二、Java程序员的常用操作

2.1 磁盘管理

Linux和windows在资源管理上有什么区别吗？

windows

打开桌面上的此电脑，映入眼帘的是：C盘D盘F盘。然后不同的磁盘下有不同的目录以及子文件。

linux

linux操作系统采用一个文档树来组织所有的资源。

这棵树的根目录的名字叫做：/

/ 是一个目录名字，是linux操作系统中所有文件的根。

/ 目录下又有很多其他的子目录，比如：dev home lib .....

查看当前所在位置

pwd

列出子文件（查看当前所在的位置下有哪些子文件以及子目录

1.ls

实际上是list单词的缩写。ls可以列出当前所在位置下的子目录以及子文件

注意：这种方式只列出文件或目录的名字。文件或目录更详细的信息没有。

watson@localhost ~]$ ls
公共  模板  视频  图片  文档  下载  音乐  桌面

2. ls -a

-a 是一个ls命令的参数，表示all，所有的意思。

-a 会将当前位置下所有的子文件以及子目录显示出来。包括隐藏文件以及隐藏目录。

注意：在linux操作系统当中凡是目录或者文件的名字是以“.”开头的，它一定是隐藏的。

[watson@localhost ~]$ ls -a
.   公共  视频  文档  音乐  .bash_history  .bash_profile  .cache   .local
..  模板  图片  下载  桌面  .bash_logout   .bashrc        .config  .mozilla

3.ls -l

-l 参数可以列出该文件或目录的更详细的信息

drwxr-xr-x. 2 root root   6  4月 18 10:26 公共
drwxr-xr-x. 2 root root   6  4月 18 10:26 模板
drwxr-xr-x. 2 root root   6  4月 18 10:26 视频
drwxr-xr-x. 2 root root   6  4月 18 10:26 图片
drwxr-xr-x. 2 root root   6  4月 18 10:26 文档
drwxr-xr-x. 2 root root   6  4月 18 10:26 下载
drwxr-xr-x. 2 root root   6  4月 18 10:26 音乐
drwxr-xr-x. 2 root root   6  4月 18 10:26 桌面
-rw-------. 1 root root 993  4月 18 10:23 anaconda-ks.cfg

第一列：d或-

d 表示是一个目录。

-表示是一个文件。

第二列：rwxr-xr-x

这个是该文件权限描述信息。

第三列：2

表示当前目录下有几个直接的子目录（注意：有两个隐藏的目录，分别是：. 和 ..）

第四列：root

这是该目录或文件的拥有者。

第五列：root

这是一个组的名字

表示这个组叫做root组。

root用户属于root组的。

假设：drwxr-xr-x. 2 bjpowernode haha 6 4月 18 10:26 公共。表示bjpowernode用户属于haha组的。

第六列：文件或目录的大小，单位是字节。

第七列：最后修改时间

第八列：文件名

4.ls -al

a和l组合使用

a表示所有，包含隐藏的文件或目录。

表示列出更详细的信息。

al表示列出所有的文件的详细信息。

5.ll

等同于：ls -l

6.ll -a

等同于：ls -al

ls -al /home/bjpowernode

查看/home/bjpowernode目录下所有的子文件以及子目录的详细信息。

切换目录（cd命令：change directory）

cd 用来切换目录

cd怎么用？

cd 路径名

cd .. 回到上级目录

cd / 回到根

cd /home/bjpowernode 切换到 /home/bjpowernode目录下

路径包括：绝对路径和相对路径

绝对路径：以/开始的都是绝对路径

相对路径：没有以 / 开始的都是相对路径。相对路径永远都是相对于当前所在的位置而言。

clear 清屏。

2.2 vi和vim

新建文件

touch命令，用法：

touch Hello.java 表示在当前位置新建一个Hello.java文件

vi概述

vi是Linux操作系统提供一个编辑器。

可以把vi看做一个软件，作用就是编辑文件的。

vi编辑器的使用

第一步：使用vi编辑器打开文件，语法：vi 文件的路径

vi Hello.java（打开当前路径下的Hello.java）

vi /home/bjpowernode/Hello.java（打开/home/bjpowernode目录下的Hello.java文件。）

第二步：vi编辑器为用户准备了两个模式

第一个模式：命令行模式，这个时候键入的都是命令。

第二个模式：编辑模式。这个时候键入的内容都会写入文件。

刚使用vi编辑器打开文件的时候，vi编辑器处于命令模式。输入i命令，可以让模式切换到编辑模式。

命令模式--->编辑模式（键入i命令。i是insert单词的首字母。）

从编辑模式怎么回到命令模式呢？

esc，按一下即可。（你如果分不清现在是编辑模式还是命令模式的话，干脆按一下esc，这样可以保证一定是命令模式，命令模式下可以输入命令。例如：dd命令，可以删除一行。）

第三步：编写完文件之后，要保存，怎么保存？

首先保存一定是在命令模式下进行的。（按esc回到命令模式。）

输入命令

:wq 这是一个命令，这个命令可以保存并退出。

:q! 这是一个命令，这个命令可以强行退出vi编辑器，并且不保存

vi和vim的区别

vim是vi的升级版。vim的功能更加强大。

vim更加适合coding，也就是编码，开发。

vi比较适合编辑普通文件。

vi编辑器也可以创建文件：

第一步：vi abc.txt

第二步：命令行模式下，保存并退出，这个时候文件就会新建。（文件没有就会新建。）

编辑命令

dd：删除光标所在行

yy：复制光标所在行到缓冲区

p：粘贴缓冲区中的内容

gg：光标回到文件第一行

GG：光标回到文件最后一行

^ ：光标移动至当前行的行首

$ ：光标移动至当前行的行尾

/关键字：按斜杠/键，可以输入想搜索的字符，然后确定进行搜索，如果第一次查找的关键字不是想要的，可以一直按 n 键往后查找到想要的关键字为止

o命令：在下一行插入。

x命令：命令行模式下，x命令会删除单个字符。

2.3 文件管理

什么是文件管理？

新建目录、新建文件、删除文件、删除目录、复制文件、移动文件。

新建

1新建目录

mkdir abc （mkdir是新建目录的命令，abc是一个目录名）

mkdir -p a/b/c （-p参数表示，一次创建多重目录）

mkdir -p a/kk/ff （虽然a已经存在了，但是不会报错，直接在a目录下新建kk目录，kk目录下新建ff目录。）

2新建文件

touch 文件名，例如：touch Hello.java 表示在当前目录下新建一个文件Hello.java

touch a.txt b.txt c.txt 一次性在当前目录下，新建多个文件，文件名之间采用空格分隔。

小插曲1：man命令

man命令可以查看某个命令的具体用法，例如：man touch

如果一个命令具体的用法你不知道的话，问那个男人man就行了。

touch [OPTION]... FILE...

解释：touch是命令。[OPTION]...这个位置表示命令参数/命令选项，可以写多个。FILE...表示可以出现多个文件名。

语法中有一个[OPTION]，这个[OPTION]在哪里？在DESCRIPTION中有具体的参数。查看即可。

man命令怎么进行翻页？空格

man命令怎么退出？q

小插曲2：--help，也可以查看一个命令的帮助，一次性列出

touch --help

一次性的全部列出一个命令的所有帮助。

如果一个命令不会用，可以使用：--help，查看一个命令的帮助。

ls -a（列出一个目录下的所有文件/目录，包括隐藏文件）

ls --all（同样可以，和ls -a 效果一样。）

-a 是短参数。--all 是长参数。

删除(rm命令，是remove单词缩写。)

3删除文件

rm 文件名

rm a.txt（删除当前目录下的a.txt文件）。这种方式会询问，是否删除，输入y表示删除，输入n表示不删除。

不想让系统询问你是否删除，怎么进行强行删除呢？

-f 参数可以做到。

rm -f a.txt（强行删除a.txt文件，不询问）

删除多个文件

rm -f b.txt c.txt （删除b.txt和c.txt文件）

rm -f *.java（删除所有.java结尾的文件，模糊匹配的方式。）

4删除目录

        删除目录的时候，必须添加-r参数，这个-r表示删除一个目录，或者递归删除目录下的所有子目录以及子文件。
        rm -r x（删除当前目录下的x目录，以及x目录下所有的子目录），但是这种方式需要用户自己输入y进行确认删除。
        rm -rf x （强行删除x目录以及x目录下所有的子目录，并且不询问。包括子文件也全部删除。）

复制/拷贝（cp命令，是copy单词缩写）

复制文件

cp a.txt aa.txt（复制当前目录下的a.txt文件，粘贴到当前目录下并且生成新文件aa.txt）

cp Hello2.java a/Hello3.java

语法：

cp file1 file2

file1就是被拷贝的文件

file2就是粘贴之后的文件

file1和file2可以添加路径。

cp 被拷贝文件的路径粘贴到哪里的路径

复制目录

-rf （-r递归拷贝，-f强行拷贝）

目录名1 是拷贝源

目录名2 是拷贝到哪里

cp -rf a abc（将当前目录下的a目录拷贝到当前目录下的abc目录当中）

cp -rf /home/bjpowernode/a /home/bjpowernode/x

将/home/bjpowernode/a目录拷贝到/home/bjpowernode/x目录下。

移动（mv命令，是move的缩写）

mv Hello.java x（将当前目录下的Hello.java文件移动到x目录下。）

mv /home/bjpowernode/Hello2.java /home/bjpowernode/x

将/home/bjpowernode/Hello2.java 移动到 /home/bjpowernode/x目录下

2.4 软链接和硬链接

1.软链接

软链接其实就是windows操作系统中的快捷方式。

软链接的作用：方便操作。快捷。。。有些经常被操作的文件，藏的很深，每一次找很麻烦，怎么办，可以给这些经常操作的文件创建软链接。通过软链接快捷的操作目标文件。

软链接和目标文件实际上是两个文件，在软链接中存储的是目标文件的路径。软链接关联的目标文件如果被删除，软链接这个快捷方式也就失效了。

怎么创建软链接呢（在linux当中怎么创建快捷方式呢）？

ln -s hello.java hello2.java

表示给hello.java文件创建一个hello2.java的快捷方式（软链接）

hello.java是目标文件。hello2.java文件是软链接，属于快捷方式

查看文件内容：cat命令

cat hello.java

查看hello.java文件的内容。

文件的inode号

inode是什么？index node（索引节点号）

在linux系统当中，任何一个文件都有inode号。（在linux当中任何一个文件都有索引节点号）

在linux系统当中不是依靠文件名来区分文件的，是依靠inode号来区分文件的。（每一个文件都有自己的inode号，不会重复）

怎么查看一个文件的inode号呢？

ls -i hello.java

通过ls命令加上-i参数可以查看文件的inode号。

[root@localhost ~]# ls -li hello2.java hello.java 【通过测试得知软链接和目标文件是两个完全不同的文件，因为inode号不同】

18371655 lrwxrwxrwx. 1 root root 10 5月 12 11:13 hello2.java -> hello.java

18371348 -rw-r--r--. 1 root root 0 5月 12 11:13 hello.java

2.硬链接

怎么创建硬链接？（把软链接创建过程中的 -s 去掉就是创建硬链接的语法。）

ln hello.java hello2.java【给hello.java文件创建hello2.java硬链接】

hello.java是源文件

hello2.java是硬链接

[root@localhost ~]# ls -li hello.java hello2.java【通过测试得知，hello.java创建出的硬链接hello2.java，这两个的inode号是一样的。】

18371348 -rw-r--r--. 2 root root 0 5月 12 11:17 hello2.java

18371348 -rw-r--r--. 2 root root 0 5月 12 11:17 hello.java

这说明：目标文件和硬链接其实就是同一个文件，因为inode号是一样的。

通过操作硬链接，目标文件会改变吗？操作目标文件，硬链接会改变吗？

硬链接的特点：

主要是用来做：重要文件备份。

目标文件删除之后，硬链接只要在，文件其实就没有被删除。或者说硬链接删除之后，目标文件还在。总结一句话：目标文件或者硬链接只要有一个存在，文件就没有被真正的删除。

硬链接机制和复制粘贴还不一样，复制粘贴之后的文件，修改其中之一，另一个不会变，但是硬链接就不一样了。

2.5 系统命令

1.显示系统当前时间

date

2.切换用户

su 用户名

3.查看系统进程

ps -ef
ps [命令参数] 常用参数：
-e :显示当前所有进程
-f :显示 UID,PPID,C 与 STIME 栏位信息
UID:拥有改程序的用户
PID:程序的进程 id PPID:父进程的 id
C: CPU 使用的资源百分比
STIME :系统启动时间
TTY：登录系统的终端位置（客户端的标识）
TIME:使用掉的 CPU 时间
CMD:进程是有哪些程序启动的

4.kill进程

kill 进程号

kill -9 进程号（强行杀死）

5.重启

reboot

6.关机

shutdown -h now

2.6 网络通讯

1.ifconfig

查看网卡的ip地址。在windows当中是：ipconfig。在linux当中是ifconfig。

2.ping

查看计算机之间是否可以正常通信

语法：

ping ip地址

ping 域名

3.curl

模拟用户访问，模拟浏览器行为。

例如：curl http://www.baidu.com （可以直接查看百度首页的前端代码。）

4.wget

下载资源

wget 资源地址

下载tomcat

wget https://dlcdn.apache.org/tomcat/tomcat-10/v10.0.20/bin/apache-tomcat-10.0.20.tar.gz

2.7 管道和重定向

cat命令：

将文件中所有的内容全部显示出来。

例如：

cat a.txt （显示a.txt中所有内容）

grep命令

在某段内容中搜索

例如：

grep 192 a.txt （在a.txt中搜索192）

管道 |

将前面命令的输出作为后面命令的输入

可以叠加

例如：

ps -ef | grep java

ps -ef | grep systemd | grep color

举例 ps -ef 查看系统进程

使用管道 | 搜索systemd 会把每行包含systemd的内容显示出来如下图

可以多次使用管道符进行叠加进行筛选

重定向：

> 输出（将原文件的内容全部清空之后，再写入。）

>> 追加的方式输出（在原文件的内容的末尾追加写入。）

例如：

ifconfig > b.txt (相当于创建里一个文本b.txt并将网关中的相关信息输入到了b.txt文本中)

ifconfig >> a.txt

管道和重定向综合使用

2.8 文件的压缩和解压缩

tar命令

tar是在linux系统当中完成压缩和解压缩的命令。

压缩后的文件又被称为归档文件。

tar命令的常用参数：

z：指定是否使用gzip压缩方式压缩。（扩展名通常为：tar.gz。特点：速度最快）

j：是否需要用 bzip2 压缩方式压缩。（扩展名通常为：tar.bz2。特点：体积最小）

c：创建压缩（create）

x：解压缩

v：是否在压缩的过程中显示文件（view）

f：指定归档文件名（file）。f参数后面必须紧跟文件名，不能在f参数后面再加其他参数。

t：查看 tarfile 里面的文件

C：指定解压到的具体目录。注意是大写C。

注意：c、x、t，这三个参数不能共存，只能出现一个。

压缩

压缩一个文件

tar -zcvf my.tar.gz log1.txt

压缩多个文件

tar -zcvf mytxt2.tar.gz log1.txt log2.txt log3.txt

tar -zcvf mytxt3.tar.gz *.txt

压缩目录

tar -zcvf mytxt4.tar.gz test 【将test目录压缩为mytxt4.tar.gz】

查看压缩文件（查看归档文件）

tar -tf mytxt.tar.gz

解压

tar -zxvf mytxt.tar.gz 【解压到当前目录下】

tar -zxvf my3.tar.gz -C your【将mytxt.tar.gz压缩包解压到your目录】

2.9 文件内容查看

查看文件内容的常见命令

cat 和 tac

more 和 less

head 和 tail

tailf

cut

echo

sed

grep

13.1 cat命令

用法：cat [选项]... [文件]...
连接所有指定文件并将结果写到标准输出。
如果没有指定文件，则从标准输入读取。

常用选项(可组合使用)：
-n, 对输出的所有行编号
-b, 对输出的所有行编号（不含空白行）
-t, 将制表符(tab)显示为^I
-e, 在每行结束处显示"$"
-s, 当连续空白行数量大于1时，合并为1个空白行

cat命令会一次性将文件的完整内容全部显示出来，不适合大文件。

查看文件所有内容

# 查看当前目录下的HelloWorld.java文件内容
cat HelloWorld.java

# 解释这个命令的原理：
# cat命令的作用是：将读取到的内容输出到某个地方。

# cat HelloWorld.java的意思是什么？
# 读取HelloWorld.java文件中的内容，并且将内容输出到终端。
# cat命令在没有指定输出到哪里的时候，默认输出到终端上。
# cat命令在不指定读取源的时候，默认是从标准输入流当中读取数据。

# cat命令有两个关键位置：
# 第一个位置：从哪读
# 第二个位置：将读到的数据输出到哪里

查看文件所有内容，并且添加行号

# 添加行号空白部分也显示行号
cat -n HelloWorld.java

查看文件所有内容，添加行号，但空白行不加行号

# 添加行号，空白行不加行号
cat -b HelloWorld.java

查看文件所有内容，将制表符显示为^I

# 制表符使用^I显示
cat -t HelloWorld.java

查看文件所有内容，在每行结束处显示"$"

# 每行末尾显示"$"
cat -e HelloWorld.java

查看文件所有内容，合并多个连续的空白行为1个空白行

# 合并多个连续空白行为1个空白行
cat -s HelloWorld.java

一次查看多个文件

# 查看a.txt文件和b.txt文件
cat a.txt b.txt

使用cat命令时：不指定文件

# cat命令不指定文件时，会从标准输入流中读取
cat

使用cat新建文件

# 将标准输入流读取到的数据写入test.txt文件
cat > test.txt

使用cat合并文件

# 将a.txt和b.txt文件进行内容合并，并生成新文件
cat a.txt b.txt > c.txt

加上行号之后输出到另一个文件

cat -n HelloWorld.java > HelloWorld2.java

清空文件内容

cat /dev/null > HelloWorld.java

13.2 tac命令

用法：tac [选项]... [文件]...
将每个指定文件按行倒置并写到标准输出。

如果没有指定文件，或者文件为"-"，则从标准输入读取。

必选参数对长短选项同时适用。
-b 在行前而非行尾添加分隔标志
-r 将分隔标志视作正则表达式来解析
-s 使用指定字符串代替换行作为分隔标志

不常用

tac HelloWorld.java

13.3 more命令

用法：
more [选项] <文件>...

用于查看文件内容。
more命令和cat命令的相同点和不同点：
相同点：more和cat在开始读取文件的时候，都是一次性的将文件全部内容装载到缓存中。
不同点：cat是一次性的全部输出打印。more可以进行部分打印（一屏一屏的打印）。

常用选项：
-u 禁止显示下划线和粗体
-<number> 每个屏幕的行数
+<number> 从行号开始显示文件
+/<pattern> 从匹配的位置前两行开始显示内容
-p 以清除原内容的方式进行翻页。

常用操作：
回车键【显示下一行】
空格键【显示下一页】
ctrl + b 【显示上一页】
= 【显示行号】
:f 【显示文件名的同时显示行号】
q 【退出more命令】

这里有日志文件：log.txt，内容如下：

2021.10.1 zhangsan
2021.10.2 lisi
2021.10.3 wangwu
2021.10.4 zhaoliu
2021.10.5 admin
2021.10.6 zhangsan
2021.10.7 lisi
2021.10.8 wangwu
2021.10.9 zhaoliu
2021.10.10 qianqi
2021.10.11 zhouyu
2021.10.12 huanggai
2021.10.13 zhugeliang
2021.10.14 simayi
2021.10.15 maimaiti
2021.10.16 erdaye
2021.10.17 sandaye
2021.10.18 zhangsan
2021.10.19 lisi
2021.10.20 wangwu
2021.10.21 zhaoliu
2021.10.22 qianqi
2021.10.23 zhoubapi
2021.10.24 doudizhu
2021.10.25 nongmin
2021.10.26 sunwukong
2021.10.27 zhubajie
2021.10.28 shaseng
2021.10.29 wujing
2021.10.30 baigujing
2021.10.31 java
2021.11.1 oracle
2021.11.2 mysql
2021.11.3 jdbc
2021.11.4 servlet
2021.11.5 jsp
2021.11.6 spring
2021.11.7 mybatis
2021.11.8 springmvc
2021.11.9 web
2021.11.10 html
2021.11.11 css
2021.11.12 java
2021.11.13 sun

案例1：从第3行起，查看文件内容。

more +3 log.txt

案例2：每屏显示4条记录。

more -4 log.txt

案例3：从文件中查找"java"字符串的

more +/java log.txt

案例4：查看进程，每5条为一屏，翻屏时清空原内容

ps -ef | more -5 -p

13.4 less命令

less 工具也是对文件或其它输出进行分页显示的工具，应该说是linux正统查看文件内容的工具，功能极其强大。less 的用法比起 more 更加的有弹性。使用less 时，可以使用 [pageup] [pagedown] 等按键的功能来往前往后翻看文件，更容易用来查看一个文件的内容！除此之外，在 less 中可以拥有更多的搜索功能。

用法：
less [选项] 文件

常用选项：
-g 只标志当前搜索到的关键词所在行
-I 忽略搜索时的大小写（注意：是大写I）
-m 显示类似more命令的百分比
-N 显示每行的行号
+num 从第num行开始显示

常用操作：
/字符串：向下搜索“字符串”的功能
?字符串：向上搜索“字符串”的功能

n：重复前一个搜索（与 / 或 ? 有关）
N：反向重复前一个搜索（与 / 或 ? 有关）

y 向前滚动一行
回车键向后滚动一行

u 向前滚动半页
d 向后滚动半页

b 向前翻一页
空格键向后翻一页

g 移动到第一行
ng 移动到指定行（n是行号）
G 移动到最后一行

= 显示详细信息（第几行，共多少行，内容的字节数量等）

v 使用vim编辑器进行编辑

q 退出less 命令

[pagedown] 向下翻动一页
[pageup] 向上翻动一页

less命令标记兴趣点

在感兴趣的位置添加标记：

先按m键 (set mark)

输入标记名称，例如标记名字为：x

需要回到感兴趣的位置时：

先按 ' 键 (goto mark)

输入标记名称 x

less命令实时监控文件动态变化

第一步：在窗口1中执行：less +F log.txt

第二步：在窗口2中执行：ps -ef >> log.txt

注意：log.txt是一个文件名。只有机器自动写入或通过输出重定向写入的才可以被监控。

less命令查看多个文件

less log.txt log2.txt

输入:n 跳转到log2.txt

输入:p 跳转到log.txt

less命令结合管道一起使用

ps -ef | less -N

13.5 head命令

tail命令：显示文件尾部内容。

用法：tail [选项]... [文件]...
显示每个指定文件的最后 10 行并输出至标准输出。

若指定了多个文件，程序会在每段输出的开始添加相应文件名作为头。

参数：
-c 输出前几个字节

-f 随文件增长即时输出新增数据
-n 指定行数

-q 不输出给出文件名的头

13.6 tail命令

tail命令：显示文件尾部内容。

用法：tail [选项]... [文件]...
显示每个指定文件的最后 10 行并输出至标准输出。
若指定了多于一个文件，程序会在每段输出的开始添加相应文件名作为头。

参数：
-c 输出最后几个字节
-f 随文件增长即时输出新增数据
-n 指定行数
-q 不输出给出文件名的头

13.7 nl命令

nl 可以将输出的文件内容自动的加上行号！其默认的结果与 cat -n 有点不太一样， nl 可以将行号做比较多的显示设计，包括位数与是否自动补齐 0 等等的功能。也就是说nl命令是比较专业的显示行号的命令。 用法如下：

nl -b a 所有行添加行号，包括空白行；
nl -b t 给行添加行号，不包括空白行（默认行为，和直接使用 nl 一样效果）；
nl -n ln 行号在自己栏位左侧显示；
nl -n rn 行号在自己栏位的右侧显示；
nl -n rz 显示行号，行号栏位不满时，自动补0 ；
nl -w 行号栏位的占用的位数。

文件内容如下：

public class HelloWorld{
        public static void main(String[] args){
                System.out.println("Hello World");
        }
}

class UserService{
        public void logout(){
                System.out.println("system log out!");
        }
}

执行以下命令：

nl HelloWorld.java

执行结果：

执行以下命令：显示所有行的行号，包括空白行。

nl -b a HelloWorld.java

执行结果：

执行以下命令：显示行号，不包括空白行。（这是一种默认的方式，和“nl HelloWorld.java”效果一样

nl -b t HelloWorld.java

执行以下命令：行号在行号栏位左侧显示

nl -n ln HelloWorld.java

执行结果：

执行以下命令：行号在行号栏位右侧显示

nl -n rn HelloWorld.java

执行结果：

执行以下命令：行号栏位自动补0

nl -n rz HelloWorld.java

执行结果：

执行以下命令：设置栏位的字符数量

nl -n rz -w 3 HelloWorld.java

执行结果：

13.8 tailf命令

与tail -f(实时监控日志文件)不同的是，如果文件不增长，它不会去访问磁盘文件。tailf特别适合那些便携机上跟踪日志文件，因为它能省电，因为减少了磁盘访问。tailf命令不是个脚本，而是一个用C代码编译后的二进制执行文件，某些Linux安装之后没有这个命令。

CentOS系统是不支持该命令的，可以按照以下步骤添加这个命令：

第一步：cd命令切换到/usr/local目录下，新建tailf.c文件，该文件内容如下：

/* tailf.c -- tail a log file and then follow it 
 * Created: Tue Jan  9 15:49:21 1996 by faith@acm.org 
 * Copyright 1996, 2003 Rickard E. Faith (faith@acm.org) 
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a 
 * copy of this software and associated documentation files (the "Software"), 
 * to deal in the Software without restriction, including without limitation 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 * and/or sell copies of the Software, and to permit persons to whom the 
 * Software is furnished to do so, subject to the following conditions: 
 * 
 * The above copyright notice and this permission notice shall be included 
 * in all copies or substantial portions of the Software. 
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE. 
 *  
 * less -F and tail -f cause a disk access every five seconds.  This 
 * program avoids this problem by waiting for the file size to change. 
 * Hence, the file is not accessed, and the access time does not need to be 
 * flushed back to disk.  This is sort of a "stealth" tail. 
 */  
  
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <malloc.h>  
#include <sys/stat.h>  
//#include "nls.h"  
#define _(s) s  
  
static size_t filesize(const char *filename)  
{  
    struct stat sb;  
  
    if (!stat(filename, &sb)) return sb.st_size;  
    return 0;  
}  
  
static void tailf(const char *filename, int lines)  
{  
    char **buffer;  
    int  head = 0;  
    int  tail = 0;  
    FILE *str;  
    int  i;  
  
    if (!(str = fopen(filename, "r"))) {  
    fprintf(stderr, _("Cannot open \"%s\" for read\n"), filename);  
    perror("");  
    exit(1);  
    }  
  
    buffer = malloc(lines * sizeof(*buffer));  
    for (i = 0; i < lines; i++) buffer[i] = malloc(BUFSIZ + 1);  
  
    while (fgets(buffer[tail], BUFSIZ, str)) {  
    if (++tail >= lines) {  
        tail = 0;  
        head = 1;  
    }  
    }  
  
    if (head) {  
    for (i = tail; i < lines; i++) fputs(buffer[i], stdout);  
    for (i = 0; i < tail; i++)     fputs(buffer[i], stdout);  
    } else {  
    for (i = head; i < tail; i++)  fputs(buffer[i], stdout);  
    }  
    fflush(stdout);  
  
    for (i = 0; i < lines; i++) free(buffer[i]);  
    free(buffer);  
}  
  
int main(int argc, char **argv)  
{  
    char       buffer[BUFSIZ];  
    size_t     osize, nsize;  
    FILE       *str;  
    const char *filename;  
    int        count;  
  
    //setlocale(LC_ALL, "");  
    //bindtextdomain(PACKAGE, LOCALEDIR);  
    //textdomain(PACKAGE);  
  
    if (argc != 2) {  
    fprintf(stderr, _("Usage: tailf logfile\n"));  
    exit(1);  
    }  
  
    filename = argv[1];  
  
    tailf(filename, 10);  
  
    for (osize = filesize(filename);;) {  
    nsize = filesize(filename);  
    if (nsize != osize) {  
        if (!(str = fopen(filename, "r"))) {  
        fprintf(stderr, _("Cannot open \"%s\" for read\n"), filename);  
        perror(argv[0]);  
        exit(1);  
        }  
        if (!fseek(str, osize, SEEK_SET))  
                while ((count = fread(buffer, 1, sizeof(buffer), str)) > 0)  
                    fwrite(buffer, 1, count, stdout);  
        fflush(stdout);  
        fclose(str);  
        osize = nsize;  
    }  
    usleep(250000);     /* 250mS */  
    }  
    return 0;  
}

第二步：首先确保当前目录在/usr/local下，如果不在该目录下，请使用cd命令切换到/usr/local。然后编译c语言程序：

[root@localhost local]# gcc -o /usr/bin/tailf tailf.c

出现以上提示信息表示当前系统中没有gcc编译器，需要安装，输入y表示同意安装，再有提示，则继续输入y即可。

第三步：测试tailf命令是否可用，直接输入tailf会出现以下提示，表示tailf命令可以使用了。

tailf命令和“tail -f”一个效果，都是用来实时监控文件变动的。只不过tailf是专业的只负责监控日志文件变化的一个命令。我们来测试一下。

日志文件内容如下：

日志信息第1行
日志信息第2行
日志信息第3行
日志信息第4行
日志信息第5行
日志信息第6行
日志信息第7行
日志信息第8行
日志信息第10行
日志信息第11行
日志信息第12行
日志信息第13行
日志信息第14行
日志信息第15行
日志信息第16行
日志信息第17行
日志信息第18行
日志信息第19行
日志信息第20行

执行以下命令：

tailf localhost.log

执行结果：

可以再开启一个新的命令窗口，然后向日志文件中追加内容，如下：

这时可以看到tailf命令窗口如下：

2.10 Linux用户管理

Linux系统中超级用户是root，通过超级用户root可以创建其它的普通用户，Linux是一个支持多用户的操作系统。在实际使用中，一般会分配给开发人员专属的账户，这个账户只拥有部分权限，如果权限太高，操作的范围过大，一些误操作可能导致系统崩溃，或者数据不安全，所以多用户机制就是一种系统安全策略。在Linux系统中任何一个用户都对应：一个用户名 + 一个口令。用户使用系统时需要输入用户名和口令进行登录，登录成功后就可以进入自己的主目录（主目录就是自己的工作目录）。用户账号管理主要包括以下三方面：

用户组的管理
用户的管理
给用户主目录之外的目录授权

2.10.1 用户组的管理

每个用户都有一个用户组，系统可以对一个用户组中的所有用户进行集中管理。

用户组的管理涉及用户组的添加、修改和删除。

用户组的添加、修改和删除实际上就是对/etc/group文件的更新。

使用root账户查看当前系统的用户组有哪些

cat /etc/group

每一个用户组四部分组成：组名：密码标识：GID：该用户组中的用户列表

查看当前登录的账户属于哪一组

groups

查看某个用户属于哪一组

[root@localhost ~]# groups root

用户组的添加

语法：groupadd [选项] 组名常用选项包括：

-g 可以通过这个选项来指定新用户组的标识号（GID）

groupadd dev1

增加一个组组名dev2 组id101

groupadd -g 101 dev2

其中101是dev2这个组的组号。

用户组的修改

groupmod -g 102 dev2

# 将dev2修改为dev3
groupmod -n dev3 dev2

用户组的删除

# 删除用户组dev3
groupdel dev3

2.10.2 用户的管理

用户管理工作主要涉及到用户的添加、修改和删除。

添加用户 添加用户就是在系统中创建一个新账号，然后为新账号分配用户组、主目录等资源。

语法：useradd [选项] 用户名

选项：

-d 指定新用户的主目录
-g 指定新用户属于哪个组（主组）
-G 可以给新用户添加附加组

没有指定组默认jack为组

[root@localhost ~]# useradd jack

注意：当新建用户时，没有指定组，也没有指定工作目录时：

默认的组名：和自己用户名一样
默认的主目录：/home/用户名

[root@localhost ~]# useradd -d /usr/zhangsan zhangsan

[root@localhost usr]# useradd -d /usr/lisi -g dev -G test lisi

添加lisi用户，该用户的主目录/usr/lisi，所属主组dev（开发组），附加组test（测试组）

设置密码

passwd jack

注意：增加用户就是在/etc/passwd文件中为新用户增加一条记录，同时更新其他系统文件如/etc/shadow, /etc/group等。

通过查看/etc/passwd文件可以看到系统中有哪些用户，例如执行：cat /etc/passwd

以上信息描述了什么？

密码会单独存储在/etc/shadow文件中，例如执行：cat /etc/shadow

可以看到这个密码是通过某种算法进行加密的。

切换用户

[root@localhost ~]# su bjpowernode

[bjpowernode@localhost root]$ su root
密码：
[root@localhost ~]#

注意：从普通用户切换到高级用户需要密码。密码输入时不回显。注意：切换到普通用户之后，该普通用户默认只对自己的“主目录”有权限，主目录之外的目录是没有权限的。

修改用户

修改用户就是对用户名，用户主目录，用户组等进行修改。

语法：usermod [选项] 用户名

-d 指定新用户的主目录
-g 指定新用户属于哪个组（主组）
-G 可以给新用户添加附加组
-l 指定新的用户名（小写的艾路）

zhangsan改为zhangsi

usermod -l zhangsi zhangsan

# -m 选项很重要，当有了这个选项之后，目录不存在时会新建该目录。
usermod -d /usr/zhangsan2 -m zhangsan

把zhangsan用户改到dev1组

usermod -g dev1 zhangsan

锁定zhangsan用户

usermod -L zhangsan

解锁zhangsan用户

usermod -U zhangsan

删除用户

userdel -r zhangsan

-r 选项的作用是连同该用户主目录一块删除。

每个用户只能操作自己的主目录，如果想操作其它主目录，方法如下

第一步：创建目录

mkdir /java

第二步：给目录授权

# -R表示递归设置权限，该目录下所有的子目录以及子文件
chmod -R 775 /java

第三步：创建组

groupadd dev

第四步：把目录赋予组

chgrp -R dev /java

第五步：创建用户

useradd xiaoming

第六步：设置密码

passwd xiaoming

第七步：给用户添加附加组

usermod -G dev xiaoming

2.11 文件权限

2.11.1 文件权限概述

Linux为了保证系统中每个文件的安全，引入了文件权限机制。针对于系统中的每一个文件Linux都可以提供精确的权限控制。它可以做到不同的用户对同一个文件具有不同的操作权利。而通常这个权利包括以下3个：

读的权利（Read，简称r）
写的权利（Write，简称w）
执行的权利（eXecute，简称x）

具体的权限值：rwx（读、写、执行）。这个我们已经知道了。但是上面还提到了“不同的用户对同一个文件可以有不同的权限”中“不同的用户”指的是哪些用户呢？所以这个文件的用户也是包括3类用户：

文件拥有者（User，简称U）：该文件的创建人
同组用户（Group，简称G）：和创建人在同一组的用户
其他组用户（Other，简称O）：和创建人不在同一组的用户

这就是非常著名的UGO模型。也就是说一个文件的权限包括三组：

第一组U：我们可以给文件的创建者设置rwx权限。
第二组G：我们可以给文件创建者的同组人员设置rwx权限。
第三组O：我们可以给和文件创建者不在同一组的人员设置rwx权限。

2.11.2 查看文件权限

采用“ls -l”命令可以查看文件的具体权限，如下：

权限信息在哪里呢？看下图：

每一个文件或目录采用ls -l查看之后，第一个字段描述了文件类型+文件的权限。第一个字段共10个字符：

第1个字符：代表文件的类型，- 代表文件，d代表目录

其实Linux中文件的类型有7种：

- 代表普通文件
d 代表目录
l 代表链接（软链接：快捷方式）
b 块设备（硬盘，软盘等存储设备）
c 字符设备（通常以字节流的方式访问）
p 管道文件（主要用于进程间通讯）
s 套接字文件（主要用于网络通讯）

第2,3,4个字符：代表文件创建者对该文件的权限。

第5,6,7个字符：代表与文件创建者在同一组的用户对该文件的权限。

第8,9,10 个字符：代表其他组人员对该文件的权限。

关于文件权限的9个字符中包含四种字符，分别是：r、w、x、-，他们代表什么含义：

r：读权限
w：写权限
x：执行权限
-：无权限

2.11.3 基于UGO设置文件权限

修改权限的命令是chmod，如果采用UGO方式修改权限的话，大致语法是这样的：

chmod g+w Hello.java

chmod g+w, o+w Hello.java

chmod g-w, o-w Hello.java

我们查看HelloWorld.java文件的权限：

文件拥有者：读和写

同组人员：读

其他组人员：读

我们将文件拥有者的写权限删除：

我们尝试使用vim命令编辑HelloWorld.java文件，当你使用vim编辑时：

发现该文件是只读的，不支持编辑。

我们再把写的权限加上：

再使用vim命令打开该文件：

可以看到，这个时候文件可以编辑了。

2.11.4 基于421设置文件权限

421采用数字来表示不同的权限。

4代表读
2代表写
1代表执行

例如：如果让一个用户读、写、执行权限都有的话，就是4 + 2 + 1 = 7，那么7这个数字就代表rwx的权限都具备。如果是5就表示4+1的组合，表示有r和x的权限。如果是6就表示4+2的组合，表示有r和w的权限。如果是0就表示无任何权限。通过421这几个数字的不同组合来表示不同的权限，那么它有多少种不同的组合呢：

4：r
2：w
1：x
6：r + w
5：r + x
3：w + x
7：r + w + x
0：无权限

也就是说一共8个数字：0 1 2 3 4 5 6 7 那么采用421方式设置权限应该怎么做呢，比如：如何给文件拥有者设置权限，如何给同组人员设置权限，如何给其他组人员设置权限？语法是这样的：

chmod 三个数字文件名

例如：chmod 755 HelloWorld.java

第一个数字7是文件拥有者的权限，第二个数字5是同组人员的权限，第三个数字5是其他组人员的权限。也就是说文件拥有者的权限是rwx，同组人员是r-x，其他组人员是：r-x

再如：chmod 700 HelloWorld.java

表示文件拥有者权限：rwx，同组人员无权限，其他组人员无权限

2.12 软件的安装与卸载

2.12.1 软件安装方式概述

CentOS安装软件的方式主要包括：

源码安装
rpm安装（二进制安装）
yum安装（在线安装）

（一）源码安装：

源码包是指C等语言所开发的源代码文件的一个压缩包，通常压缩为.tar.gz或.tar.bz2。源码通常需要编译器将其编译成二进制文件，如gcc编译器。

优点：

（1）开源，有能力者可以修改源代码；特别是要对某个软件，从头开发时，就特别需要对源码进行解读分析。

（2）可自由选择所需功能；

（3）卸载方便，直接删除目录即可。

（4）对于学习者而言，源码安装更有利于学习者发现软件环境和工具之间所依赖的关系。

缺点：

（1）安装麻烦，需要自行解决工具之间的依赖关系。

（2）某些软件编译过程耗费的时间较长，我曾发生过编译两三天的情况。尤其是在不合适的硬件上，安装大型软件时，最容易折磨人，甚至要考虑系统与硬件的兼容性、配置等问题，系统本身有缺陷，那就更要命了，有时需先修补系统bug【主要是功能不齐全，残缺情况居多】

（3）大型软件编译，对新手来说较为麻烦，所报错误往往超过所能解决的范围，排错过程有可能会把系统给搞崩溃。

（二）rpm安装： RPM包：由Red Hat公司开发的包管理系统，软件的安装、升级、卸载都非常简单和方便。目前很多Linux发行版都在使用这种包管理机制，包括CentOS、Redhat、Fedora等。软件包文件后缀是".rpm"。 DPKG包：由Debian Linux开发出来的包管理机制，主要应用在Debian和Unbuntu系统中。软件包文件后缀是".deb"。

优点：

（1）包安装与管理简单，往往仅通过几个命令即可实现包的安装、升级、查询和卸载。

（2）通常安装速度要比源码安装快很多；

缺点：

（1）二进制文件，看不到源码了，修改和分析源码已不太可能。

（2）模块功能已经被定制，用户功能选择远不如源码灵活；

（3）有时也需要解决依赖性的问题，此时解决依赖性有一定的困难。

（三）yum安装：

yum软件仓库是为了进一步简化RPM管理软件的难度以及自动分析所需软件包及其依赖关系的技术。 yum的关键之处是要有可靠的respository（保证能够连接互联网，还需要保证它是一个互联网上正常可用的仓库）。

它能够从指定服务器自动下载rpm包并安装。yum能够自动解决软件依赖性问题，一次性安装所有依赖的软件包。

2.12.2 yum安装与卸载的相关命令

安装命令：yum -y install SoftwareName

升级命令：yum -y install SoftwareName

升级所有软件：yum -y install

卸载命令：yum remove SoftwareName

列出可安装的软件包：yum list

列出已安装的软件包：yum list installed

查询某个软件包：yum list SoftwareName

根据关键字搜索软件包：yum search Keyword

清除缓存：yum clean all

2.12.3 JDK的安装与配置

从yum仓库中搜索jdk：yum search jdk
安装jdk：yum -y install java-17-openjdk-devel.x86_64
看看jdk的安装目录：
1. which java
2. ls -l /usr/bin/java
3. ls -l /etc/alternatives/java
在/etc/profile文件中配置环境变量：
1. export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-17.0.6.0.9-0.4.ea.el9.x86_64
2. export CLASSPATH=.:$JAVA_HOME/lib
3. export PATH=$PATH:$JAVA_HOME/bin
生效：source /etc/profile

2.12.4 Tomcat服务器的安装与配置

Tomcat是Java语言实现的，因此使用Tomcat服务器的前提是：已经安装并配置了Java环境。
下载Tomcat
1. 官网：Apache Tomcat® - Welcome!
2. 下载tomcat10

3.使用FTP工具将以上压缩包上传到CentOS。

4.解压到当前目录下

5.第三方软件一般存放在/usr/local目录下，使用mv命令tomcat移动到该目录下

6.为了方便配置环境变量，将目录名重命名

现在Tomcat服务器的根路径是：/usr/local/tomcat10

7.配置环境变量

让环境变量生效：

8.启动Tomcat

9.查看服务器IP地址

10.关闭防火墙

11.打开windows上的浏览器，输入地址访问

12.关闭tomcat服务器

服务器关闭之后，重新打开一个全新的浏览器，再次输入访问地址，会发现无法访问了。

2.12.5 MySQL的安装与配置

MySQL8的安装

以下是在CentOS Stream系统上安装MySQL8的步骤：

更新系统软件包

使用以下命令更新CentOS Stream系统上的软件包：

dnf update

安装MySQL8需要更新系统上的软件包是因为MySQL8需要使用一些较新的依赖库和工具，而CentOS Stream默认的软件包版本可能较旧，无法满足MySQL8的要求。更新系统上的软件包可以确保系统中的依赖库和工具版本与MySQL8的要求相匹配，从而保证MySQL8的正常运行。

dnf和yum都是CentOS中的包管理器，它们的作用是安装、升级、删除软件包以及解决软件包依赖关系。它们的区别如下：

语法不同：dnf命令的语法更加简洁，而yum命令的语法相对较长。
性能不同：dnf命令在处理软件包时的性能比yum命令更好，因为dnf使用了更高效的算法。
依赖关系处理不同：dnf命令在处理软件包依赖关系时更加智能，能够自动选择最佳的依赖关系解决方案。
使用的库不同：dnf命令使用了更加现代化的libdnf库，而yum命令使用了较老的yum库。
可用插件不同：dnf命令支持更多的插件，可以实现更多的功能。

总的来说，dnf命令是yum命令的升级版本，它在性能、依赖关系处理和可用插件等方面都更加优秀。

2.添加MySQL Yum存储库

使用以下命令将MySQL Yum存储库添加到系统中：

dnf install https://dev.mysql.com/get/mysql80-community-release-el8-1.noarch.rpm

3.导入mysql公钥

rpm --import https://repo.mysql.com/RPM-GPG-KEY-mysql-2022

4.安装MySQL 8

dnf install mysql-community-server

5.启动MySQL服务

systemctl start mysqld

5.设置MySQL开机自启

systemctl enable mysqld

6.查看root账户的临时密码

grep 'temporary password' /var/log/mysqld.log

7.配置MySQL安全设置

mysql_secure_installation

按照提示输入密码并回答问题，完成安全设置。

8.登录MySQL

mysql -u root -p

完成以上步骤后，您就可以在CentOS Stream系统上安装并使用MySQL 8了。

MySQL8设置字符集

查看MySQL8字符集

在MySQL命令行界面中输入以下命令：

show variables like '%character%';

可以查看MySQL的字符集设置。

2.如果字符集不是utf8，可以在/etc/my.cnf文件中进行配置，在[mysqld]下面添加如下配置：/etc/my.cnf是mysql的配置文件。

[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_general_ci

保存并退出。

3.重启MySQL服务

在终端中输入以下命令：

systemctl restart mysqld

4.再次查看MySQL8的字符集是否为utf8

在MySQL8中为Java程序员创建专属的MySQL用户

首先，以root用户身份登录MySQL：

mysql -u root -p

创建一个新的数据库，例如项目是oa项目，一般创建一个数据库叫做oa：

create database oa;

2.12.6 WEB应用的部署

2.13 netstat查看服务及监听端口

在实际开发中，netstat最常用的操作是查看网络连接情况。通过使用netstat命令，开发人员可以快速了解当前系统上的所有网络连接，包括正在监听的端口、建立的连接、连接状态等信息。这对于排查网络问题和监控系统状态非常有用。另外，netstat还可以用于检查网络安全，例如查看哪些端口正在被占用，是否有不安全的连接等。

以下是netstat命令的常用参数和用法：

1.查看所有的网络连接状态：

netstat -a

连接协议接收发送本机地址外机地址状态

LISTEN 状态：表示该端口已占用，正在监听，连接未建立，等待连接。

ESTABLISHED 状态：表示两台机器正在通信中。在进行安全检查时，尤其要注意这种状态的连接，查看当前连接是否合法。

TIME_WAIT 状态：表示连接已终止。说明端口之前被访问过，但是访问已经结束了。

2.查看所有处于监听状态的连接

netstat -l

3.查看所有TCP连接状态：

netstat -t

4.查看所有UDP连接状态：

netstat -u

5.查看所有处于TIME_WAIT状态的连接：

netstat -o

6.查看指定端口的网络连接状态：

netstat -an | grep 端口号

例如，查看80端口的网络连接状态：

netstat -an | grep :80

2.14 文件搜索

在CentOS中，可以使用以下方式进行文件搜索：

1.Find命令：使用find命令可以在指定目录下搜索文件。可以使用不同的选项来指定搜索的文件类型、大小、修改时间等条件。例如：

find /usr/local -name "catalina.out"

2.Grep命令：使用grep命令可以在指定文件中搜索指定的字符串。例如：

grep "emp" /usr/local/tomcat10/logs/catalina.out

3.Whereis命令：使用whereis命令可以在系统中搜索指定的命令的位置。例如：

whereis startup.sh

4.Which命令：使用which命令也可以在系统中搜索指定的命令的位置。例如：

which command

三、将web应用部署到阿里云

3.1 购买阿里云服务器

注册阿里云账号

购买阿里云服务器

阿里云首页

使用xshell/xftp连接阿里云服务器

默认情况下阿里云服务器的“密码认证”是没有开启的。需要通过修改相关配置，来开启“密码认证”。在阿里云服务器实例中找到如下图的VNC连接：

然后输入用户名root和密码。登录成功之后找到该文件：/etc/ssh/sshd_config

使用vim编辑sshd_config文件中的“passwordAuthcation”，将no修改为yes。

重启sshd服务：service sshd restart

此时采用xshell/xftp就可以使用密码的方式连接阿里云服务器了。

四、shell编程

4.1 Linux系统结构

Linux操作系统是一种开放源代码的类UNIX操作系统，它的结构分为内核、Shell和应用程序三个层次。

1.内核层

内核是Linux系统的核心部分，它负责管理系统各种硬件设备、文件系统、内存管理和进程管理等核心任务。Linux内核设计了良好的模块化结构，可以动态地加载和卸载内核模块，这使得内核可以兼容各种不同的硬件设备和外围设备。

2.Shell层

Shell是Linux系统的命令行解释器，它负责将用户输入的命令解释并执行。Linux系统上有多种Shell，其中最常用的是Bash Shell。Bash Shell 提供了各种丰富的功能和处理能力，如通配符、重定向、管道、变量等等。

3.应用层

应用层是Linux系统上的各种应用程序和服务，包括文本编辑器、图形界面、Web服务器、邮件服务器、数据库服务器等。在Linux系统中，应用程序通常以开放源代码方式呈现，用户可以自由学习和使用，也可以根据需求自己编写、修改或扩展。

4.2 都有哪些shell

Shell被翻译为“壳”。在Linux内核外面包了一个壳。 Shell是一种用于与操作系统进行交互的命令行解释器。它是一种脚本语言，可以通过编写一系列的命令和脚本来执行操作系统的功能和任务。我们在终端中编写的命令都是Shell命令。例如：ls、grep......等。

在Linux系统中，常见的Shell包括以下几种：

Bourne Shell（/bin/sh）：是Unix系统最早的shell程序，由史蒂夫·伯恩斯（Steve Bourne）编写。该shell程序是许多Linux发行版中默认使用的程序。
Bourne-Again SHell（/bin/bash）：是GNU项目的一部分，是Bourne Shell的增强版，目前在大部分Linux发行版中是默认的shell程序。
C Shell （/bin/csh）：是Bill Joy编写的一个具有面向对象设计理念的shell程序，它采用与C语言相似的语法和控制结构。C Shell中的命令提示符为%号。
TENEX C Shell（/bin/tcsh）：是C Shell的增强版，它对历史命令和别名等方面进行了改进，同时也支持C Shell中的所有特性。TENEX C Shell中的命令提示符也为%号。
Korn Shell（/bin/ksh）：是由David Korn编写的shell程序，它是Bourne Shell和C Shell的结合，拥有两种不同的工作模式：交互模式和批处理模式。
Z Shell（/bin/zsh）：是一个功能强大的shell程序，它是Bourne Shell的增强版，具有缩写、自动完成、句法高亮等功能，同时也支持Korn Shell、C Shell以及Bourne Shell的语法和命令。

每种Shell都有其特定的语法和功能，但它们通常都具有共同的基本功能，如变量操作、条件语句、循环语句和命令执行等。

Shell脚本在自动化任务、系统管理、批处理作业等方面非常有用。开发人员和系统管理员可以使用Shell脚本来编写一系列的命令和逻辑，以便自动化执行常见的任务和操作。

在CentOS中，可以使用chsh命令切换默认Shell。chsh命令允许您更改用户的登录Shell。以下是切换Shell的步骤：

查看已安装的Shell。

cat /etc/shells

该命令将打印出系统上已安装的Shell列表。

2. 使用以下命令更改Shell。

chsh -s /bin/zsh

在上面的命令中，`/bin/zsh`是要更改的Shell的路径。请将其替换为您想要使用的Shell路径。

3.输入要更改Shell的用户密码以确认更改。

4.使用以下命令检查Shell是否已更改：

echo $SHELL

此命令将打印新Shell的路径。

注意：只有具有Superuser权限的用户才能切换其他用户的Shell，您可能需要使用`sudo`或者以root用户身份执行上述命令。

4.3 shell的基础语法

4.3.1 注释

单行注释是一行文本，它以井号（#）开头，从该字符开始一直延伸到该行的结束。在此行内，任何内容都会被 Shell 解释器忽略：

# 这是一行注释
echo "Hello, World!" # 这是一行带有注释的代码

Shell 脚本也支持多行注释，这种注释也被称为块注释。块注释在脚本中可以用于分组一系列代码，或将一段代码置于未被执行的状态。在 Bash Shell 中，块注释通常使用以下语法：

: '
这里是注释内容。
可以是多行，直到下面一行的单独引号为止。
'

下面是一个示例，说明这种块注释的使用方法：

#!/bin/bash

: '
这是一个多行注释块。
我们将在这里添加一些注释，并将一些代码放在这里，以防它们被执行。

echo "Hello, World!"
'

echo "这行是被执行的。"

在此示例中，我们使用了一个多行注释块，该块包含我们想要添加的注释和未被执行的代码。通过使用这种方式添加注释，我们可以让脚本更具可读性。

注意：第一行代码的作用是告知系统采用bash解释器执行以下代码。可以省略，如果省略会默认使用当前会话的shell解释器。

4.3.2 变量

当我们在Linux操作系统中使用命令行环境时，Shell变量是非常重要的一个部分。它们可以用来存储和操作数据，从而让我们更加方便地管理文件、程序和系统。在Linux中，有三种类型的Shell变量，包括：

环境变量
本地变量
特殊变量

环境变量

环境变量是Linux操作系统中最常用的变量类型之一。它们是在Shell会话外设置的，可以由多个脚本和进程共享。在Linux中，环境变量没有固定的值，而是在需要时通过脚本或命令进行设置或更新。要查看当前所有环境变量，可以运行以下命令：

printenv

或

env

要设置一个新的环境变量，请使用“export”命令，例如：

export MY_VAR="Hello World"

要使用环境变量，在变量名称前必须加上$符号，例如：

echo $MY_VAR

本地变量

本地变量是一种临时变量，在Shell会话中设置和使用。与环境变量不同，本地变量仅限于当前Shell会话，不会被其他脚本或命令使用。设置本地变量可以使用“=”号操作符，例如：

MY_VAR="Hello World"

类似于环境变量，在使用本地变量时，变量名称前必须加上$符号。例如：

echo $MY_VAR

举例

如下是1.sh文件中的源代码

#!/bin/bash

#定义一个本地变量(注意不能有空格)
name="zhangsan"
age=20
email="zhangsan@126.com"

#打印变量的值
echo $name
echo $age
echo $email

特殊变量

特殊变量是在Shell中预定义的变量名称，具有特殊的含义。这些变量与当前Shell会话有关，可以用于许多不同的用途，包括文件和目录操作、命令历史记录和处理脚本参数等等。以下是常见的一些特殊变量：

$0: 当前脚本的文件名

1. 1.sh脚本文件

#!/bin/bash

#定义一个本地变量(注意不能有空格)
name="zhangsan"
age=20
email="zhangsan@126.com"

#打印变量的值
echo $name
echo $age
echo $email

#使用特殊变量
#打印脚本文件的名字
echo $0

2.执行1.sh脚本文件

$1, $2...: 脚本参数列表中的第1个、第2个参数等等 (例如：./1.sh abc def，在执行这个脚本时，第一个参数abc，第二个参数def。)

$#: 脚本参数的数量
$*: 所有脚本参数的列表
$@: 所有脚本参数的列表（作为独立字符串）
$$: 当前脚本的进程ID号
$?: 上一个命令的退出状态，一个数值。

例如：

#!/bin/bash
echo "The name of this script is: $0"
echo "The first parameter is: $1"
echo "The total number of parameters is: $#"
echo "All parameters are: $@"
echo "The current process ID is: $$"
echo "The last exit status was: $?"

此脚本将输出有关脚本本身和参数的信息。

总结：

在Linux中，Shell变量是非常重要和有用的一部分。使用环境变量、本地变量和特殊变量可以让我们更加精确地控制和管理我们的Linux系统。掌握这些变量类型及其用法，可以让我们更加高效地编写Shell脚本并提高我们的日常工作效率。

4.3.3 控制语句

Shell编程中，控制语句可用于控制程序的执行流程和执行次数，主要包括条件判断和循环。条件判断主要通过if语句来实现，if语句用于检查指定条件是否成立，并根据条件的真或假来执行相应的语句块。循环主要通过for循环、while循环和until循环来实现。循环语句用于反复执行某些语句块，直到满足指定条件为止。

if语句详解

if语句用于检查指定条件是否成立，并根据条件判断的结果执行不同的语句块。if语法格式如下：

if condition 
then
  command1
  command2
  ...
elif condition2 
then
  command3
  command4
  ...
else
  command5
  command6
  ...
fi

其中，condition是要检查的条件，可以是命令、变量、表达式等任何Shell语法，then表示条件成立要执行的语句块，如果有多个条件，可以使用elif语句来添加多个条件，每个条件使用then分别表示要执行的语句块，如果所有条件都不成立，则执行else分支中的语句块。

if语句的执行过程是从上到下依次判断每个条件，如果条件成立，则执行对应的语句块，执行完后跳出if语句。

例题

for循环详解

for循环用于遍历指定列表或值的集合，并执行相应的语句块。for循环语法格式如下：

for var in list
do
  command1
  command2
  ...
done

其中，var是一个临时的变量名，用于存储当前循环的值，list是一个值或者多个带有空格或换行符分隔的值组成的列表。在每一次循环迭代时，var会被list列表中的一个值所替换，直到list中的所有值都被处理完为止。

例题

while循环详解

while循环用于不断执行语句块，直到满足指定条件为止。while循环语法格式如下：

while condition
do
  command1
  command2
  ...
done

其中，condition是要检查的条件，如果条件为真，则执行do语句块中的命令，执行完后再回到while语句中检查条件是否依然为真，如果条件仍为真，则继续执行命令块，否则跳出循环。

注意：在shell编程中 $((...)) 被称为算术扩展运算符，做数学运算的，并且将运算结果返回。$(...)运算符会将结果直接返回。例如：

$((j+1))，如果j是5的话，结果就会返回6 （注意，使用这个运算符的时候，括号里面不能有空格）
$(echo "hello world")，会将"hello world"打印，然后再将"hello world"字符串返回。

举例

until循环详解

until循环用于不断执行语句块，直到满足指定条件为止。和while循环不同的是，直到指定条件为假时才会停止循环。until循环语法格式如下：

until condition
do
  command1
  command2
  ...
done

其中，condition是要检查的条件，如果条件为假，则执行do语句块中的命令，执行完后再回到until语句中检查条件是否依然为假，如果条件仍为假，则继续执行命令块，否则跳出循环。

break和continue语句

break和continue是控制循环的两个重要关键字。

break语句用于跳出当前循环块，例如在for循环和while循环中使用该语句时，可以跳出当前循环并停止迭代。break语句可以嵌套在多重循环中，用于跳出内层循环和外层循环，其语法格式如下：

while condition
do
  command1
  command2
  if condition2 
	then
    break
  fi
  command3
  ...
done

在上述示例中，如果在执行command2时，条件condition2成立，那么会执行break语句，跳出循环块并停止迭代。

continue语句用于跳过本次循环迭代，直接进入下一次的迭代。在for循环和while循环中使用该语句时，可以用于跳过本次迭代，执行下一次迭代。其语法格式如下：

while condition
do
  command1
  command2
  if condition2
  then
    continue
  fi
  command3
  ...
done

在上述示例中，如果在执行command2时，条件condition2成立，那么会执行continue语句，跳过本次迭代，直接进入下一次迭代。

shell中的中括号：[ ]

中括号有两种使用方法：

用于比较操作符：用于比较两个值的大小或者判断两个值是否相等。例如：

-eq: 判断两个值是否相等（equal to），例如[ $a -eq $b ]
-ne: 判断两个值是否不相等（not equal to），例如[ $a -ne $b ]
-lt: 判断左边的值是否小于右边的值（less than），例如[ $a -lt $b ]
-gt: 判断左边的值是否大于右边的值（greater than），例如[ $a -gt $b ]
-le: 判断左边的值是否小于等于右边的值（less than or equal to），例如[ $a -le $b ]
-ge: 判断左边的值是否大于等于右边的值（greater than or equal to），例如[ $a -ge $b ]

在Shell中，比较操作符可以用于中括号[]中，例如:[ $a -eq $b ]。在比较时，要注意两个值之间必须有空格分隔，否则会出现语法错误。

用于测试表达式：用于测试某个表达式是否成立。例如：

-f: 判断某个文件是否存在并且是一个常规文件（regular file），例如[ -f file.txt ]
-d: 判断某个文件是否存在并且是一个目录（directory），例如[ -d dir ]
-z: 判断某个字符串是否为空（zero length），例如[ -z "$str" ]
-n: 判断某个字符串是否非空（not zero length），例如[ -n "$str" ]
-e: 判断某个文件或目录是否存在（exist），例如[ -e file.txt ]

在Shell中，测试表达式也可以用于中括号[]中，例如:[ -f file.txt ]。在多数Linux发行版中，测试表达式可以用中括号[]或者test命令实现，例如:test -f file.txt等价于[ -f file.txt ]。需要注意的是，中括号中的空格很重要，空格缺少会导致语法错误。另外，在使用中括号[]时，要注意变量用双引号括起来，避免空值引起的语法错误。

示例代码

下面是一个示例代码，演示了如何使用if、for、while、until以及break和continue语句：

#!/bin/bash

# 条件判断
if [ -f file.txt ] 
then
  echo "file.txt exists."
elif [ -d dir ] 
then
  echo "dir exists."
else
  echo "file.txt and dir not found."
fi

# for循环
for i in 1 2 3 4 5
do
  echo "The value of i is: $i"
done

# while循环
j=0
while [ $j -lt 5 ]
do
  echo "The value of j is: $j"
  j=$((j+1))
done

# until循环
k=0
until [ $k -ge 5 ]
do
  echo "The value of k is: $k"
  k=$((k+1))
done

# break语句和continue语句
for l in 1 2 3 4 5
do
  if [ $l -eq 3 ] 
	then
    continue
  fi
  echo "The value of l is: $l"
  if [ $l -eq 4 ] 
	then
    break
  fi
done

4.3.4 函数

什么是函数？

在Shell编程中，函数是一种可重用的代码块，可以提高程序的可读性和可维护性。通过定义一个函数，可以把一段代码封装起来，赋予其一个名称，可以在程序的其他部分反复调用。 Shell脚本中的函数非常灵活，可以使用各种Shell语句和命令来编写，如if语句、for循环、while循环等。

定义函数

下面是一个示例函数的定义：

function say_hello() {
  echo "Hello, world!"
}

在上述示例中，我们定义了一个函数名为say_hello，它的执行结果是输出Hello, world!字符串。函数定义的语法格式如下：

function_name() {
    commands
}

使用function关键字来定义函数是可选的。当使用function关键字时，要注意不要加空格，否则会出现语法错误。函数体中可以包含任意数量的命令和语句。

调用函数

成功定义一个函数后，可以在程序的任何地方调用它。只需要使用函数的名称，再加上一对小括号，即可调用函数。例如：

say_hello

上述示例将会调用函数say_hello，执行函数体中的命令，输出Hello, world!字符串。

传递参数

Shell函数也支持传递参数。在调用函数时，可以把参数传递给函数，让函数使用这些参数来完成特定的任务。例如：

function greet() {
  echo "Hello, $1 $2"
}

greet "John" "Doe"

上述示例中，我们定义了一个名为greet的函数，它输入参数$1和$2，并把这些参数用于输出字符串Hello, $1 $2。我们调用greet函数，并把参数"John"和"Doe"传递给它，最终输出Hello, John Doe字符串。

在函数中，参数可以使用$1、$2、$3等占位符来引用。$1表示第一个参数，$2表示第二个参数，以此类推。

示例代码

下面是一个示例代码，演示了如何定义和调用Shell中的函数：

#!/bin/sh

# 定义函数say_hello
say_hello() {
  echo "Hello, world!"
}

# 调用函数say_hello
say_hello

# 定义函数greet
greet() {
  echo "Hello, $1 $2"
}

# 调用函数greet
greet "John" "Doe"

运行上述代码后，会输出如下结果：

Hello, world!
Hello, John Doe

4.3.5 输出重定向(从内存到文件)

在Shell编程中，标准输出是指向终端的输出，而错误输出是指向标准输出的。重定向是一种将输出从一个点重定向到另一个点的方法。在Shell中，可以使用输出重定向来将程序的输出重定向到文件或者另一个命令中。

标准输出重定向

Shell中的标准输出重定向可以将程序的标准输出重定向到一个文件中。在命令中使用符号>和一个文件名，即可将输出重定向到指定的文件中。例如：

ls > files.txt

举例

[root@localhost ~]# ls
1.sh  模板  图片  下载  桌面             b.txt          l.sh
公共  视频  文档  音乐  anaconda-ks.cfg  localhost.log
[root@localhost ~]# ls > files.txt
[root@localhost ~]# cat files.txt
1.sh
公共
模板
视频
图片
文档
下载
音乐
桌面
anaconda-ks.cfg
b.txt
files.txt
localhost.log
l.sh

上述命令将会执行ls命令，并把输出重定向到文件files.txt中。如果files.txt文件不存在，则会创建该文件并写入输出内容。如果文件已经存在，则会覆盖原文件内容。

如果不想覆盖文件，可以使用>>符号来追加输出内容。例如：

ls >> files.txt

上述命令将会执行ls命令，并把输出追加到文件files.txt的末尾。

错误输出重定向

与标准输出重定向类似，Shell中也提供了错误输出重定向的功能。可以使用符号2>和一个文件名来将错误输出重定向到指定文件中。例如：

ls wrong_dir 2> error.txt

上述命令将会执行ls命令，并把错误输出重定向到文件error.txt中。

[root@localhost ~]# ls
1.sh  公共  模板  视频  图片  文档  下载  音乐  桌面  anaconda-ks.cfg  b.txt  files.txt  localhost.log  l.sh
[root@localhost ~]# ls abc
ls: 无法访问 'abc': 没有那个文件或目录
[root@localhost ~]# ls abc > error.log
ls: 无法访问 'abc': 没有那个文件或目录
[root@localhost ~]# ls
1.sh  模板  图片  下载  桌面             b.txt      files.txt      l.sh
公共  视频  文档  音乐  anaconda-ks.cfg  error.log  localhost.log
[root@localhost ~]# cat error.log
[root@localhost ~]# ls abc 2> error.log
[root@localhost ~]# cat error.log
ls: 无法访问 'abc': 没有那个文件或目录

与标准输出类似，在错误输出中使用>>符号可以追加错误输出。例如：

ls wrong_dir 2>> error.txt

上述命令将会执行`ls`命令，并把错误输出内容追加到文件`error.txt`的末尾。

输出复制与分割

在Shell中，可以使用符号|将一个命令的输出作为另一个命令的输入。这种语法被称为管道。管道可以将一个命令的输出传递给另一个命令，使得多个命令可以协作运行。

例如：

ls | grep file | wc -l

上述命令将会执行ls命令并将输出传递给grep命令，将其中包含字符串file的行筛选出来，最后将输出传递给wc -l命令，计算有多少行输出。

示例代码

下面是一个示例代码，演示了Shell中输出重定向的各种用法：

#!/bin/sh

# 标准输出重定向
ls > file_list.txt
# 错误输出重定向
ls wrong_dir 2> error.txt
# 输出复制与分割
ls | grep file | wc -l

运行上述代码后，会在当前目录下生成名为file_list.txt和error.txt的两个文件，并统计ls命令输出包含字符串file的行数。

4.3.6 输入重定向(从文件到内存)

在Shell编程中，输入重定向是一种将指定的输入文件或者另一个命令的输出作为当前程序的输入流的方法。在Shell中，可以使用输入重定向来简化数据输入操作，以便更方便地进行编程。

输入重定向符号

在Shell中，输入重定向使用符号<和文件名来指定输入源。例如：

sort < file.txt

上述命令将会使用sort命令来对文件file.txt进行排序，其中<符号表示将file.txt文件作为输入流传递给sort命令。

[root@localhost ~]# vim num1.txt
[root@localhost ~]# sort < num1.txt
1
2
3
4
5

示例代码

下面是一个示例代码，演示了Shell中输入重定向的各种用法：

#!/bin/sh

# 从文件中读取输入
sort < input.txt > output.txt

# 组合使用输入重定向和管道
# sed 's/foo/bar/' 作用是：将内容中的所有foo替换成bar
cat file1.txt | sed 's/foo/bar/' | sort > result.txt

运行上述代码后，会在当前目录下生成名为output.txt和result.txt的文件。

4.4 实现数据库自动备份

下面是一个用Shell编写的自动备份数据库的脚本，可以根据实际情况进行修改和调整：

#!/bin/bash

# 设置备份目录
backupDir="/home/backup"

# 设置需要备份的数据库名称和用户名、密码
dbUser="root"
dbPass="123456"
dbName="database_name"

# 设置备份文件名，包括日期和时间
backupFile="$backupDir/${dbName}_$(date +%Y%m%d_%H%M%S).sql"

# 执行备份命令
mysqldump -u$dbUser -p$dbPass $dbName > $backupFile

# 压缩备份文件
gzip -f $backupFile

# 删除7天前的备份文件
find $backupDir -mtime +7 -type f -name "${dbName}*.sql.gz" -delete

脚本的实现流程如下：

首先设置备份目录和要备份的数据库的用户名、密码和名称。
然后，设置备份文件名，这里使用了当前日期和时间来命名备份文件。
接下来，使用mysqldump命令备份数据库并将结果重定向到备份文件中。
备份完成后，使用gzip命令将备份文件压缩。
最后，使用find命令删除7天前的备份文件，以避免占用过多磁盘空间。

将这个脚本保存到一个文件中，如backup_db.sh，并添加可执行权限：

chmod +x backup_db.sh

通过编辑crontab文件，可以将这个脚本设置为定期自动运行，比如每天执行一次备份。打开终端，输入：

crontab -e

在文件末尾添加下面的一行：

0 0 * * * /path/to/backup_db.sh

# 20 12 * * * /path/to/backup_db.sh 表示每天12:20会执行一次脚本。

保存并退出crontab文件，这样在每天午夜0点进行自动备份。如果需要调整自动备份的时间，也可以修改crontab文件中的时间字段。

ForeverSmilingSun

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Linux

Linux为了保证系统中每个文件的安全，引入了文件权限机制。针对于系统中的每一个文件Linux都可以提供精确的权限控制。它可以做到不同的用户对同一个文件具有不同的操作权利。而通常这个权利包括以下3个：读的权利（Read，简称r）写的权利（Write，简称w）执行的权利（eXecute，简称x）具体的权限值：rwx（读、写、执行）。这个我们已经知道了。但是上面还提到了“不同的用户对同一个文件可以有不同的权限”中“不同的用户”指的是哪些用户呢？
复制链接

扫一扫