maven的用法

1、maven简介

官网： http://maven.apache.org/

http://mvnrepository.com/中寻找

1.1 完成一个java项目，需要做哪些工作

1.分析项目要做什么，知道项目有哪些组成部分。 2.设计项目，通过哪些步骤，使用哪些技术。需要多少人， 多长的时间。 3.组建团队，招人， 购置设备，服务器， 软件， 笔记本。 4.开发人员写代码。 开发人员需要测试自己写代码。 重复多次的工作。 5.测试人员，测试项目功能是否符合要求。 测试开发人员提交代码-如果测试有问题–需要开发人员修改–在提交代码给测试 –测试人员在测试代码-如果还有问题-在交给开发人员-开发人员在提交-在测试 直到-测试代码通过。

1.2 传统开发项目的问题，没有使用maven【meivn】管理的项目

1）很多模块，模块之间有关系， 手工管理关系，比较繁琐。 2）需要很多第三方功能， 需要很多jar文件，需要手工从网络中获取各个jar 3）需要管理jar的版本， 你需要的是mysql.5.1.5.jar 拿你不能给给一个mysql.4.0.jar 4）管理jar文件之间的依赖， 你的项目要使用a.jar 需要使用b.jar里面的类。 必须首先获取到b.jar才可以， 然后才能使用a.jar.

a.jar需要b.jar这个关系叫做依赖， 或者你的项目中要使用mysql的驱动， 也可以叫做项目依赖mysql驱动。 a.class使用b.class， a依赖b类

1.3 需要改进项目的开发和管理，需要maven

​ 1）maven可以管理jar文件 ​ 2）自动下载jar和他的文档，源代码 ​ 3）管理jar直接的依赖， a.jar需要b.jar ， maven会自动下载b.jar ​ 4）管理你需要的jar版本 ​ 5）帮你编译程序，把java编译为class ​ 6）帮你测试你的代码是否正确。 ​ 7）帮你打包文件，形成jar文件，或者war文件 ​ 8）帮你部署项目

2、 构建：项目的构建

构建是面向过程的，就是一些步骤，完成项目代码的编译，测试，运行，打包，部署等等，maven支持的构建包括有：

1.清理， 把之前项目编译的东西删除掉，我新的编译代码做准备。 2.编译， 把程序源代码编译为执行代码， java-class文件 批量的，maven可以同时把成千上百的文件编译为class。 javac 不一样，javac一次编译一个文件。 3.测试， maven可以执行测试程序代码，验证你的功能是否正确。 批量的，maven同时执行多个测试代码，同时测试很多功能。 4.报告， 生成测试结果的文件， 测试通过没有。 5.打包， 把你的项目中所有的class文件，配置文件等所有资源放到一个压缩文件中。 这个压缩文件就是项目的结果文件， 通常java程序，压缩文件是jar扩展名的。 对于web应用，压缩文件扩展名是.war 6.安装， 把5中生成的文件jar，war安装到本机仓库 7.部署， 把程序安装好可以执行。

3、 maven核心概念

①POM ： 一个文件 名称是pom.xml , pom翻译过来叫做项目对象模型。 maven把一个项目当做一个模型使用。控制maven构建项目的过程，管理jar依赖。

②约定的目录结构 ： maven项目的目录和文件的位置都是规定的。

③坐标 ： 是一个唯一的字符串，用来表示资源的。

④依赖管理 ： 管理你的项目可以使用jar文件

⑤仓库管理（了解） ：你的资源存放的位置

⑥生命周期 (了解) ： maven工具构建项目的过程，就是生命周期。 ⑦插件和目标（了解）：执行maven构建的时候用的工具是插件 ⑧继承 ⑨聚合

讲maven的使用，先难后易的。 难是说使用maven的命令，完成maven使用 ， 在idea中直接使用maven，代替命令。

4、maven工具的安装和配置

1）需要从maven的官网下载maven的安装包 apache-maven-3.3.9-bin.zip 2）解压安装包，解压到一个目录，非中文目录。 子目录 bin :执行程序，主要是mvn.cmd conf :maven工具本身的配置文件 settings.xml 3）配置环境变量 在系统的环境变量中，指定一个M2_HOME的名称， 指定它的值是maven工具安装目录，bin之前的目录

​ M2_HOME=D:\work\maven_work\apache-maven-3.3.9

再把M2_HOME加入到path之中，在所有路径之前加入 %M2_HOME%\bin;

4）验证，新的命令行中，执行mvn -v

注意：需要配置JAVA_HOME ，指定jdk路径

C:\Users\Administrator>mvn -v 出现如下内容，maven安装，配置正确。 Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:4 Maven home: D:\work\maven_work\apache-maven-3.3.9 Java version: 1.8.0_40, vendor: Oracle Corporation Java home: C:\java\JDK8-64\jre Default locale: zh_CN, platform encoding: GBK OS name: “windows 7”, version: “6.1”, arch: “amd64”, family: “dos”

4.1 maven约定的目录结构，约定是大家都遵循的一个规则

每一个maven项目在磁盘中都是一个文件夹（项目-Hello）

每一个maven项目在磁盘中都是一个文件夹（项目-Hello） Hello/ —/src ——/main #放你主程序java代码和配置文件 ———-/java #你的程序包和包中的java文件 ———-/resources #你的java程序中要使用的配置文件

​ ——/test #放测试程序代码和文件的（可以没有） ​ ———-/java #测试程序包和包中的java文件

​ ———/resources #测试java程序中要使用的配置文件

	 ---/pom.xml  #maven的核心文件（maven项目必须有）

4.2 通过mvn compile 编译src/main目录下的所有java文件

  1）为什么要下载
	   maven工具执行的操作需要很多插件（java类--jar文件）完成的
	2）下载什么东西了
	    jar文件--叫做插件--插件是完成某些功能

	3）下载的东西存放到哪里了。
	    默认仓库（本机仓库）：
       C:\Users\（登录操作系统的用户名）Administrator\.m2\repository



	Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/maven-plugin-parameter-documenter-2.0.9.pom

   https://repo.maven.apache.org ：中央仓库的地址


	执行mvn compile， 结果是在项目的根目录下生成target目录（结果目录），
	maven编译的java程序，最后的class文件都放在target目录中


	

4.3 设置本机存放资源的目录位置(设置本机仓库)：

 1. 修改maven的配置文件， maven安装目录/conf/settings.xml
    先备份 settings.xml

2.   修改 <localRepository>  指定你的目录（不要使用中文目录）

​ D:\work\maven_work\maven_repository

5、maven仓库

 1）仓库是什么： 仓库是存放东西的， 存放maven使用的jar 和 我们项目使用的jar
     > maven使用的插件（各种jar）
	  > 我项目使用的jar(第三方的工具)

  2）仓库的分类
     >本地仓库， 就是你的个人计算机上的文件夹，存放各种jar
	  >远程仓库， 在互联网上的，使用网络才能使用的仓库
	      ①：中央仓库，最权威的， 所有的开发人员都共享使用的一个集中的仓库，
			      https://repo.maven.apache.org ：中央仓库的地址
			②：中央仓库的镜像：就是中央仓库的备份， 在各大洲，重要的城市都是镜像。

			③：私服，在公司内部，在局域网中使用的， 不是对外使用的。

  3）仓库的使用，maven仓库的使用不需要人为参与。 
       
		开发人员需要使用mysql驱动--->maven首先查本地仓库--->私服--->镜像--->中央仓库

6、pom：项目对象模型，是一个pom.xml文件

    1）坐标：唯一值， 在互联网中唯一标识一个项目的
	  <groupId>公司域名的倒写</groupId>
     <artifactId>自定义项目名称</artifactId>
     <version>自定版本号</version>

	   https://mvnrepository.com/ 搜索使用的中央仓库， 使用groupId 或者 artifactId作为搜索条件
	 

	  2） packaging： 打包后压缩文件的扩展名，默认是jar ，web应用是war 
	      packaging 可以不写， 默认是jar


	 3) 依赖
	    dependencies 和dependency ，相当于是 java代码中import

		 你的项目中要使用的各种资源说明， 比我的项目要使用mysql驱动

		 <dependencies>
			<!--依赖  java代码中 import -->
		  <dependency>           (这样指定依赖项之后,如果在本机仓库中找到这个											jar包,加到你的项目中就可以使用了)
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.9</version>
		 </dependency>
	 
     </dependencies>

	  4）properties：设置属性

	  5）build ： maven在进行项目的构建时， 配置信息，例如指定编译java代码使用的jdk的版本等

坐标

Maven把 任何一个 插件 都作为 仓库中 的一个项目进行管理 用 一组 (三个 )向量 组成的坐标 来 表示。 坐标 在仓库 中 可以 唯一定位一个 Maven项目。 groupId 组织名 ，通常是 公司或组织域名倒序 +项目名 artifactId 模块名 ，通常是工程名 version 版本号 需要特别指出的是， 项目在仓库中的位置是由坐标来决定的： groupId、 artifactId和 version决定项目在仓库中 的路径， artifactId和 version决定 jar包的名称

这样可以定位到你拥有的那个jar包，原先定义的那些类都可以来使用,其他项目中就可以使用仓库中的资源

依赖

一个 Maven项目正常运行 需要其它项目的支持， Maven会根据坐标 自动 到 本地 仓库中进行查找。 对于程序员自己的 Maven项目需要进行安装，才能保存到仓库中。 不用 不用maven的时候所有的的时候所有的jar都不是你的，需要去各个地方下载拷贝，用了都不是你的，需要去各个地方下载拷贝，用了maven所有的所有的jar包都是你的，想包都是你的，想要谁，叫谁的名字就行。要谁，叫谁的名字就行。maven帮你下载。帮你下载。 pom.xml加入依赖的方式：

log4j日志依赖
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
junit单元测试依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>

7、maven的生命周期

对项目的构建是建立在生命周期模型上的， 它明确定义项目生命 周期各个阶段， 并且对于每一个阶段提供相对应的命令，对开发者而言仅仅需要掌握 一小堆 的 命令 就可以 完成 项目 各个阶段的构建工作。

构建项目时按照生命周期顺序构建，每一个阶段都有特定的插件来完成。不论现在要执行生命周期中的哪个阶段，都是从这个生命周期的最初阶段开始的。 对于我们程序员而言，无论我们要进行哪个阶段的构建，直接执行相应的命令即可，无需担心它前边阶段是否构建， Maven都会自动构建。这也就是 Maven这种自动化构建工具给我们带来的好处。

8、Maven的常用命令

Maven对所有的功能都提供相对应的命令，要想知道 maven都 有哪些命令，那要看 maven有哪些功能。 一开 始就跟大家说了， maven三大功能： 管理依赖、构建项目、管理项目信息。 管理依赖，只需要声明就可以自 动到仓库下载；管理项目信息其实就是生成一个站点文档，一个命令就可以解决，最后再说；那 maven功能的 主体其实就是项目构建。 Maven提供一个项目构建的模型，把编译、测试、打包、部署等都对应成一个个的生命周期阶段， 并对 每一个阶段提供相应的命令，程序员只需要掌握一小堆命令，就可以完成项目的构建过程。 mvn clean 清理 (会删除原来编译和测试的目录，即 target目录，但是已经 install到仓库里的包不会删除 )

mvn compile 编译主程序 (会在当前目录下生成一个 target,里边存放编译主程序之后生成的字节码文件 )

mvn test-compile 编译测试程序 (会在当前目录下生成一个 target,里边存放编译测试程序之后生成的字节码文件 )

mvn test 测试 (会生成一个目录 surefire reports，保存测试结果 )

mvn package 打包主程序 (会编译、编译测试、测试、并且按照 pom.xml配置把主程序打包生成 jar包或者 war包 )

mvn install 安装主程序 (会把本工程打包，并且按照本工程的坐标保存到本地仓库中 )

mvn deploy 部署主程序 (会把本工程打包，按照本工程的坐标保存到本地库中，并且还会保存到私服仓库中。 还会自动把项目部署到 web容器中 )。 注意：执行以上命令必须在命令行进入pom.xml所在目录！

9、Maven的插件

maven过程构建周期，由maven的插件plugin来执行完成

官方插件说明：http://maven.apache.org/plugins/

在项目根目录下执行:mvn clean install

常用插件

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven compiler plugin</artifactId> <version>3.8.13.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>

10、在idea中配置maven

1、在idea中设置maven，让idea和maven结合使用

idea中内置了maven，一般不使用内置的，因为用内置修改maven的设置不方便

使用自己安装的maven，需要覆盖idea中的默认的设置，让idea指定maven安装位置信息

setting配置当前

配置的入口 ①：配置当前工程的设置， file–settings —Build, Excution,Deployment–Build Tools –Maven

			   Maven Home directory: maven的安装目录
					User Settings File :  就是maven安装目录conf/setting.xml配置文件
					Local Repository :    本机仓库的目录位置

					   --Build Tools--Maven--Runner  
						  VM Options : -DarchetypeCatalog=internal
						  JRE: 你项目的jdk


                    -DarchetypeCatalog=internal , maven项目创建时，会联网下载模版文件，
						  比较大， 使用-DarchetypeCatalog=internal，不用下载， 创建maven项目速度快。



	            ②：配置以后新建工程的设置， file--other settings--Settings for New Project

为以后工程配置

其他步骤一样

11、idea新建maven工程

11.1 创建maven版java工程

File—>New—>Modual…:

11.2 填写maven工程坐标

11.3 填写工程名和存储路径

11.4 改变pom.xml中编译Java的版本

<properties>
  <!--设置你的文件编码-->
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <!--编译java代码使用的jdk版本--><!--改成1.8-->
  <maven.compiler.source>1.8</maven.compiler.source>
  <!--你的java项目应该运行在什么样的jdk版本-->
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

11.5 pom.xml里面插件可以不写，这个idea为了方便你进行配置写上去的，如果不要，可以删除

12、idea创建web工程

12.1 创建Maven版web工程

file->new->Module:

12.2 设置module信息

12.3 设置所使用的maven

12.4 填写maven工程名称和存储路径‘

12.5 创建后视图

12.6 把文件夹标识为源码文件夹

12.7 pom.xml添加依赖

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
  <scope>provided</scope>
</dependency>
<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>jsp-api</artifactId>
  <version>2.1</version>          
  <scope>provided</scope>
</dependency>

进行配置

12.8 怎么让src也可以创建jsp页面

12.9 web项目打包

把打包的项目放在

然后

发现生成

用http://localhost:8080/myweb/访问

13、导入工程

13.1 新建一个空的project作为工作空间

13.2 在项目结构中导入或移除module

File–>project Structure

13.3 选择要导入的Module

13.4 选择导入的方式

13.5 配置导入的jdk

14、依赖管理

provided表示已经提供，比如说servled类你设置了依赖，但是servletd在tomcat服务器已经有了，因此在部署的时候不需要用到这个包。

runtime：runtime依赖在运行和测试系统的时候需要，但在编译的时候不需要。比如：jdbc的驱动包。由于运行时需要所以runtime范围的依赖会被打包。

15、maven常用设置

15.1 全局变量

在Maven的 pom.xml文件中， ，用于定义全局变量， POM中通过 ${property_name}的形式引用变量的值。 定义全局变量：

自定义的属性，1.在<properties> 通过自定义标签声明变量（标签名就是变量名）
                 2.在pom.xml文件中的其它位置，使用 ${标签名} 使用变量的值

自定义全局变量一般是定义 依赖的版本号， 当你的项目中要使用多个相同的版本号，
先使用全局变量定义， 在使用${变量名}

<properties>
<spring.version>4.3.10.RELEASE</spring.version>
</properties>

引用全局变量

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring context</artifactId>
<version>${spring.version}</version>
</dependency>

maven系统采用的变量：

<properties>
<maven.compiler.source>1.8</maven.compiler.source> 源码编译 jdk版本
<maven.compiler.target>1.8</maven.compiler.target> 运行代码的 jdk版本
<project.build.sourceEncoding>UTF 8</project.build.sourceEncoding> 项目构建使用的编码，避免中文乱
码
<project.reporting.outputEncoding>UTF 8</project.reporting.outputEncoding> 生成报告的编码
</properties>

15.2 指定资源位置

译结果分别放到了 target/classes和 targe/test classes目录中，但是这两个目录中的其他文件都会被忽略掉，如果需 要把 src目录下的文件包放到 target/classes目录，作为输出的 jar一部分。需要指定资源文件位置。 以下内容放到 标签中。

<build>
	<resources>
	<resource>
	<directory>src/main/java</directory><!--所在的目录-->
	<includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
	<include>**/*.properties</include>
	<include>**/*.xml</include>
	</includes>
	<!-—filtering 选项 false 不启用过滤器， *.property 已经起到过滤的作用了 -->
	<filtering>false</filtering>
	</resource>
	</resources>
  </build>

16、添加tomcat7的插件

 <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>8080</port>
          <path>/</path>
        </configuration>
        <!--此时点击idea最右侧Maven Projects，
就可以看到我们新添加的tomcat7插件
双击tomcat7插件下tomcat7:run命令直接运行项目-->
       </plugin>
    </plugins>

注意不同版本的tomcat需要搭配不同的servlet

通过插件配置怎么进行debug

17、添加阿里云镜像

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
	 <!-- 阿里云仓库 -->
    <mirror>
        <id>alimaven</id>
        <mirrorOf>central</mirrorOf>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
    </mirror>
 
 
    <!-- 中央仓库1 -->
    <mirror>
        <id>repo1</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name for this Mirror.</name>
        <url>http://repo1.maven.org/maven2/</url>
    </mirror>
 
 
    <!-- 中央仓库2 -->
    <mirror>
        <id>repo2</id>
        <mirrorOf>central</mirrorOf>
        <name>Human Readable Name for this Mirror.</name>
        <url>http://repo2.maven.org/maven2/</url>
    </mirror>
  </mirrors>

18、idea创建模板

18.1 setting找到live Templates

19 继承

19.1 为什么需要继承机制

由于非compile范围的依赖信息是不能在“依赖链”中传递的，所以有需要的工程只能单独配置。例如：

此时如果项目需要将各个模块的junit版本统一为4.9，那么到各个工程中手动修改无疑是非常不可取的。使用继承机制就可以将这样的依赖信息统一提取到父工程模块中进行统一管理。

19.2 创建父工程

创建父工程和创建一般的Java工程操作一致，唯一需要注意的是：打包方式处要设置为pom。

19.3 在子工程中引用父工程

… … … 从当前目录到父项目的pom.xml文件的相对路径

com.atguigu.maven Parent 0.0.1-SNAPSHOT ../Parent/pom.xml

此时如果子工程的groupId和version如果和父工程重复则可以删除。

19.4 在父工程中管理依赖

将Parent项目中的dependencies标签，用dependencyManagement标签括起来

junit junit 4.9 test

在子项目中重新指定需要的依赖，删除范围和版本号

junit junit

20 聚合

20.1 为什么要使用聚合

将多个工程拆分为模块后，需要手动逐个安装到仓库后依赖才能够生效。修改源码后也需要逐个手动进行clean操作。而使用了聚合之后就可以批量进行Maven工程的安装、清理工作。

20.2 如何配置聚合

在总的聚合工程中使用modules/module标签组合，指定模块工程的相对路径即可

../Hello ../HelloFriend ../MakeFriends

redis

概念：redis是一款高性能的NOSQL系列的非关系型数据库

1.1 什么是NOSQL

NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

1.1.1 NOSQL和关系型数据库比较

优点： 1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。

2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。

3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。

4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。

缺点： 1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。 2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。 3）不提供关系型数据库对事务的处理。

1.1.2 非关系型数据库的优势

1）性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。 2）可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。

1.1.3 关系型数据库的优势：

1）复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。 2）事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

1.1.4 总结

关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库， 让NoSQL数据库对关系型数据库的不足进行弥补。 一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据

1.2 主流的NOSQL产品

• 键值(Key-Value)存储数据库 相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB 典型应用： 内容缓存，主要用于处理大量数据的高访问负载。 数据模型： 一系列键值对 优势： 快速查询 劣势： 存储的数据缺少结构化 • 列存储数据库 相关产品：Cassandra, HBase, Riak 典型应用：分布式的文件系统 数据模型：以列簇式存储，将同一列数据存在一起 优势：查找速度快，可扩展性强，更容易进行分布式扩展 劣势：功能相对局限 • 文档型数据库 相关产品：CouchDB、MongoDB 典型应用：Web应用（与Key-Value类似，Value是结构化的） 数据模型： 一系列键值对 优势：数据结构要求不严格 劣势： 查询性能不高，而且缺乏统一的查询语法 • 图形(Graph)数据库 相关数据库：Neo4J、InfoGrid、Infinite Graph 典型应用：社交网络 数据模型：图结构 优势：利用图结构相关算法。 劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

1.3 什么是Redis

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下： 1) 字符串类型 string 2) 哈希类型 hash 3) 列表类型 list 4) 集合类型 set 5) 有序集合类型 sortedset

1.3.1 redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等） • 聊天室的在线好友列表 • 任务队列。（秒杀、抢购、12306等等） • 应用排行榜 • 网站访问统计 • 数据过期处理（可以精确到毫秒) • 分布式集群架构中的session分离

1.4 下载安装

1. 官网：https://redis.io 2. 中文网：http://www.redis.net.cn/ 3. 解压直接可以使用： * redis.windows.conf：配置文件 * redis-cli.exe：redis的客户端 * redis-server.exe：redis服务器端 * redis-server.exe redis.windows.conf在redis文件夹的页面下cmd后输入前面命令

1.5 命令操作

1.5.1 redis的数据结构

redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构

value的数据结构：

1. 字符串类型 string
2. 哈希类型 hash ： map格式
3. 列表类型 list ： linkedlist格式。支持重复元素
4. 集合类型 set ： 不允许重复元素
5. 有序集合类型 sortedset：不允许重复元素，且元素有顺序

key

字符串类型string的存储

1.存储：set key value

127.0.0.1:6379> set username zhangsan

2.获取: get key

127.0.0.1:6379> get username

3.删除: del key

127.0.0.1:6379> del age (integer) 1

哈希类型 hash的存储

1. Redis  hash 是一个键值对集合
   

2. Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
   

3. 类似Java里面的Map<String,Object>
   

4. 分析一个问题: 现有一个JavaBean对象，在Redis中如何存?
   

l 第一种方案: 用户ID为key ,VALUE为JavaBean序列化后的字符串

​

缺点: 每次修改用户的某个属性需要，先反序列化改好后再序列化回去。开销较大

l 第二种方案: 用户ID+属性名作为key, 属性值作为Value.

​

缺点: 用户ID数据冗余

l 第三种方案: 通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化和并发修改控制的问题

​

5. 常用操作
   

1.存储：hset key field value

127.0.0.1:6379> hset myhash username lisi (integer) 1 127.0.0.1:6379> hset myhash password 123 (integer) 1

2、获取：

		* hget key field: 获取指定的field对应的值
			127.0.0.1:6379> hget myhash username
			"lisi"
		* hgetall key：获取所有的field和value
			127.0.0.1:6379> hgetall myhash
			1) "username"
			2) "lisi"
			3) "password"
			4) "123"
			
	3. 删除： hdel key field
		127.0.0.1:6379> hdel myhash username
		(integer) 1

列表类型list 的存储（允许重复）

1. 单键多值
   

2. Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。
   

3. 它的底层实际是个**双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差**
   

4.  ![image-20210126221511069](/imgs/image-20210126221511069.png)
   

​

5. 常用操作
   

可以添加一个元素到列表的头部（左边）或者尾部（右边）

1、添加:

		1. lpush key value: 将元素加入列表左表
			
		2. rpush key value：将元素加入列表右边
			
			127.0.0.1:6379> lpush myList a
			(integer) 1
			127.0.0.1:6379> lpush myList b
			(integer) 2
			127.0.0.1:6379> rpush myList c
			(integer) 3

2、获取：

		* lrange key start end ：范围获取
			127.0.0.1:6379> lrange myList 0 -1
			1) "b"
			2) "a"
			3) "c"

3、删除：

		* lpop key： 删除列表最左边的元素，并将元素返回
		* rpop key： 删除列表最右边的元素，并将元素返回

集合类型set的存储：不允许重复元素

1. Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的
   

2. Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表,所以添加，删除，查找的复杂度都是O(1)。
   

3. 常用操作
   

	1. 存储：sadd key value
		127.0.0.1:6379> sadd myset a
		(integer) 1
		127.0.0.1:6379> sadd myset a
		(integer) 0
	2. 获取：smembers key:获取set集合中所有元素
		127.0.0.1:6379> smembers myset
		1) "a"
	3. 删除：srem key value:删除set集合中的某个元素	
		127.0.0.1:6379> srem myset a
		(integer) 1

有序集合类型sortedset:不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

1. Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。不同之处是有序集合的每个成员都关联了一个评分（score） ，这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。
   

2. 因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。
   

3. 常用操作
   

4. 思考: 如何利用zset实现一个文章访问量的排行榜?
   
    1. 存储：zadd key score value
    	127.0.0.1:6379> zadd mysort 60 zhangsan
    	(integer) 1
    	127.0.0.1:6379> zadd mysort 50 lisi
    	(integer) 1
    	127.0.0.1:6379> zadd mysort 80 wangwu
    	(integer) 1
    2. 获取：zrange key start end [withscores]
    	127.0.0.1:6379> zrange mysort 0 -1
    	1) "lisi"
    	2) "zhangsan"
    	3) "wangwu"
   
    	127.0.0.1:6379> zrange mysort 0 -1 withscores
    	1) "zhangsan"
    	2) "60"
    	3) "wangwu"
    	4) "80"
    	5) "lisi"
    	6) "500"
    3. 删除：zrem key value
    	127.0.0.1:6379> zrem mysort lisi
    	(integer) 1
   

1.6 Redis的相关配置

1. 计量单位说明,大小写不敏感

2. include 类似jsp中的include，多实例的情况可以把公用的配置文件提取出来

3. ip地址的绑定 bind  默认情况bind=127.0.0.1只能接受本机的访问请求  不写的情况下，无限制接受任何ip地址的访问  生产环境肯定要写你应用服务器的地址  如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的相应

4. tcp-backlog  可以理解是一个请求到达后至到接受进程处理前的队列.  backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列  高并发环境tcp-backlog 设置值跟超时时限内的Redis吞吐量决定

5. timeout 一个空闲的客户端维持多少秒会关闭，0为永不关闭。

6. tcp keepalive 对访问客户端的一种心跳检测，每个n秒检测一次，官方推荐设置为60秒

7. daemonize 是否为后台进程

8. pidfile 存放pid文件的位置，每个实例会产生一个不同的pid文件

9. log level 四个级别根据使用阶段来选择，生产环境选择notice 或者warning

10. log level 日志文件名称

11. syslog 是否将Redis日志输送到linux系统日志服务中

12. syslog-ident 日志的标志

13. syslog-facility 输出日志的设备

14. database 设定库的数量 默认16

15. security 在命令行中设置密码

16. maxclient 最大客户端连接数
17. maxmemory 设置Redis可以使用的内存量。一旦到达内存使用上限，Redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。如果Redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”， 那么Redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。
18. Maxmemory-policy  volatile-lru：使用LRU算法移除key，只对设置了过期时间的键  allkeys-lru：使用LRU算法移除key  volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键  allkeys-random：移除随机的key  volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key  noeviction：不进行移除。针对写操作，只是返回错误信息
19. Maxmemory-samples 设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小。 一般设置3到7的数字，数值越小样本越不准确，但是性能消耗也越小。

1.7 持久化

RDB

1. 在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。
   

2. 备份是如何执行的
   

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

3. 关于fork
   

在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术”，一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

4. RDB保存的文件
   

在redis.conf中配置文件名称，默认为dump.rdb

​

5. RDB文件的保存路径
   

默认为Redis启动时命令行所在的目录下,也可以修改

6. RDB的保存策略
   

​

7. 手动保存快照
   

save: 只管保存，其它不管，全部阻塞

bgsave:按照保存策略自动保存

8. RDB的相关配置
   

l stop-writes-on-bgsave-error yes

当Redis无法写入磁盘的话，直接关掉Redis的写操作

l rdbcompression yes

进行rdb保存时，将文件压缩

l rdbchecksum yes

在存储快照后，还可以让Redis使用CRC64算法来进行数据校验，但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能

9. RDB的备份 与恢复
   

l 备份:先通过config get dir 查询rdb文件的目录 , 将*.rdb的文件拷贝到别的地方

l 恢复: 关闭Redis，把备份的文件拷贝到工作目录下,启动redis,备份数据会直接加载。

10. RDB的优缺点

l 优点: 节省磁盘空间,恢复速度快.

l 缺点: 虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。 在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就

  会丢失最后一次快照后的所有修改

1. redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。
	2. redis持久化机制：
		1. RDB：默认方式，不需要进行配置，默认就使用这种机制
			* 在一定的间隔时间中，检测key的变化情况，然后持久化数据
			1. 编辑redis.windwos.conf文件
				#   after 900 sec (15 min) if at least 1 key changed
				save 900 1
				#   after 300 sec (5 min) if at least 10 keys changed
				save 300 10
				#   after 60 sec if at least 10000 keys changed
				save 60 10000
				
			2. 重新启动redis服务器，并指定配置文件名称
				D:\JavaWeb2018\day23_redis\资料\redis\windows-64\redis-2.8.9>redis-server.exe redis.windows.conf	
			
	

AOF

1. 以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来(读操作不记录)，只许追加文件但不可以改写文件，Redis启动之初会读取该文件重新构建数据，换言之，Redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。
   

2. AOF默认不开启，需要手动在配置文件中配置
   
                      ![image-20210127221340676](/imgs/image-20210127221340676.png)        
   

3. 可以在redis.conf中配置文件名称，默认为 appendonly.aof
   

   

AOF文件的保存路径，同RDB的路径一致

4. AOF和RDB同时开启，redis听谁的？
   

5. AOF文件故障备份
   

AOF的备份机制和性能虽然和RDB不同, 但是备份和恢复的操作同RDB一样，都是拷贝备份文件，需要恢复时再拷贝到Redis工作目录下，启动系统即加载

6. AOF文件故障恢复
   

如遇到AOF文件损坏，可通过

redis-check-aof –fix appendonly.aof 进行恢复

7. AOF同步频率设置
   

   

l 始终同步，每次Redis的写入都会立刻记入日志

l 每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。

l 把不主动进行同步，把同步时机交给操作系统。

8. Rewrite
   

l AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制,当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集.可以使用命令bgrewriteaof。

l Redis如何实现重写

AOF文件持续增长而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，遍历新进程的内存中数据，每条记录有一条的Set语句。重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照有点类似。

l 何时重写

重写虽然可以节约大量磁盘空间，减少恢复时间。但是每次重写还是有一定的负担的，因此设定Redis要满足一定条件才会进行重写。

 ![image-20210127221356872](/imgs/image-20210127221356872.png)

系统载入时或者上次重写完毕时，Redis会记录此时AOF大小，设为base_size,如果Redis的AOF当前大小>= base_size +base_size*100% (默认)且当前大小>=64mb(默认)的情况下，Redis会对AOF进行重写。

9. AOF的优缺点
   

l 优点:

备份机制更稳健，丢失数据概率更低。

可读的日志文本，通过操作AOF稳健，可以处理误操作。

l 缺点:

比起RDB占用更多的磁盘空间

恢复备份速度要慢

每次读写都同步的话，有一定的性能压力。

2. AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
		1. 编辑redis.windwos.conf文件
			appendonly no（关闭aof） --> appendonly yes （开启aof）
			
			# appendfsync always ： 每一次操作都进行持久化
			appendfsync everysec ： 每隔一秒进行一次持久化
			# appendfsync no	 ： 不进行持久化

1.8 jedis

如果redis在虚拟机上面

1. 使用Windows环境下Eclipse连接虚拟机中的Redis注意事项
   

l 禁用Linux的防火墙：Linux(CentOS7)里执行命令 ： systemctl stop firewalld.service

l redis.conf中注释掉bind 127.0.0.1 ,然后 protect-mode no。

然后jedis中的地址改成连接虚拟机上面的网络地址

jedis：一款java操作redis数据库的工具

使用步骤：

1、下载jedis的jar包

2、使用

1.8.1 jedis中操作string

set

get

public class JedisTest {
    public static void main(String[] args) {

        //Jedis localhost = new Jedis("localhost", 6379);
        //1、获取连接(如果使用无参构造，默认使用new Jedis("localhost", 6379);)
        Jedis jedis = new Jedis();
        //2、存储
        jedis.set("xiaodidi", "12321");
        //3、获取
        String xiaodidi = jedis.get("xiaodidi");
        System.out.println(xiaodidi);
        //存进去一个字符串，20秒以后销毁,常用于：比如发一个连接，提示20秒之内有效，超过这个时间无效
        jedis.setex("actioncode", 20, "heeh");

        //关闭连接
        jedis.close();
    }
}

1.8.2 Jedis中操作hash：map格式

hset

hget

hgetAll

				//1. 获取连接
		        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
		        //2. 操作
		        // 存储hash
		        jedis.hset("user","name","lisi");
		        jedis.hset("user","age","23");
		        jedis.hset("user","gender","female");
		
		        // 获取hash
		        String name = jedis.hget("user", "name");
		        System.out.println(name);


		
		        // 获取hash的所有map中的数据
		        Map<String, String> user = jedis.hgetAll("user");
		
		        // keyset
		        Set<String> keySet = user.keySet();
		        for (String key : keySet) {
		            //获取value
		            String value = user.get(key);
		            System.out.println(key + ":" + value);
		        }
		
		        //3. 关闭连接
		        jedis.close();

1.8.3 jedis中操作list:linkedlist格式

lpush/rpush

lpop/rpop

lrange start end:范围获取

//1. 获取连接
		        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
		        //2. 操作
		        // list 存储
		        jedis.lpush("mylist","a","b","c");//从左边存
		        jedis.rpush("mylist","a","b","c");//从右边存
		
		        // list 范围获取
		        List<String> mylist = jedis.lrange("mylist", 0, -1);
		        System.out.println(mylist);
		        
		        // list 弹出
		        String element1 = jedis.lpop("mylist");//c
		        System.out.println(element1);
		
		        String element2 = jedis.rpop("mylist");//c
		        System.out.println(element2);
		
		        // list 范围获取
		        List<String> mylist2 = jedis.lrange("mylist", 0, -1);
		        System.out.println(mylist2);
		
		        //3. 关闭连接
		        jedis.close();

1.8.4 jedis操作set：不允许重复元素

sadd

smembers:获取所有元素

				//1. 获取连接
		        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
		        //2. 操作


		
		        // set 存储
		        jedis.sadd("myset","java","php","c++");
		
		        // set 获取
		        Set<String> myset = jedis.smembers("myset");
		        System.out.println(myset);
		
		        //3. 关闭连接
		        jedis.close();

1.8.5 有序集合类型 sortedset:不允许重复元素，且元素有顺序

zadd

zrange

//1. 获取连接
		        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
		        //2. 操作
		        // sortedset 存储
		        jedis.zadd("mysortedset",3,"亚瑟");
		        jedis.zadd("mysortedset",30,"后裔");
		        jedis.zadd("mysortedset",55,"孙悟空");
		
		        // sortedset 获取
		        Set<String> mysortedset = jedis.zrange("mysortedset", 0, -1);
		
		        System.out.println(mysortedset);


		
		        //3. 关闭连接
		        jedis.close();

1.9 jedis工具类的编写

package com.atguigu.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class JedisUtils {
    private static JedisPool jedisPool;
    static{
        InputStream resourceAsStream = JedisPool.class.getClassLoader().getResourceAsStream("jedis.properties");
        Properties properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));
        jedisPoolConfig.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
        jedisPool = new JedisPool(jedisPoolConfig,properties.getProperty("host"),Integer.parseInt(properties.getProperty("port")));



    }
    public static Jedis getjedisPool() {
        return jedisPool.getResource();
    }
}

测试代码

public static void main(String[] args) {

        //Jedis localhost = new Jedis("localhost", 6379);
        //1、获取连接(如果使用无参构造，默认使用new Jedis("localhost", 6379);)
        Jedis jedis = JedisUtils.getjedisPool();
        jedis.hset("myMap", "xiao", "gege");
        String hget = jedis.hget("myMap", "xiao");
        System.out.println(hget);
        jedis.hset("myMap", "gege", "didi");
        Map<String, String> myMap = jedis.hgetAll("myMap");
        System.out.println(myMap);

        

        //关闭连接
        jedis.close();
    }

1.10 jedis的案例(用ajax和json和sql加redis的省份下拉列表)

index.html中的代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- 上述3个meta标签*必须*放在最前面，任何其他内容都*必须*跟随其后！ -->
    <title>Bootstrap 101 Template</title>

    <!-- Bootstrap -->
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <!-- jQuery (necessary for Bootstrap's JavaScript plugins) -->
    <script src="js/jquery-3.3.1.min.js"></script>
    <!-- Include all compiled plugins (below), or include individual files as needed -->
    <script src="js/bootstrap.min.js"></script>

    <script>
        $(function () {

            //发送ajax请求，加载所有省份数据
            $.getJSON("provinceServlet",{},function (data) {
                console.log(data);
                //[{"id":1,"name":"北京"},{"id":2,"name":"上海"},{"id":3,"name":"广州"},{"id":4,"name":"陕西"}]
                var $province = $("#province");

                $(data).each(function () {
                    console.log(this);
                    $("<option>'"+this.name+"'</option>").appendTo($province)
                })


            });


        });




    </script>

</head>
<body>




<select id="province" class="form-control">
    <option>--请选择省份--</option>

</select>
<script>
    var jsjf = {"name":"1q231"}
</script>

</body>
</html>

service里面的代码

package cn.itcast.service.impl;

import cn.itcast.dao.ProvinceDao;
import cn.itcast.dao.impl.ProvinceDaoImpl;
import cn.itcast.domain.Province;
import cn.itcast.jedis.util.JedisPoolUtils;
import cn.itcast.service.ProvinceService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import redis.clients.jedis.Jedis;

import java.util.List;

public class ProvinceServiceImpl implements ProvinceService {
    //声明dao
    private ProvinceDao dao = new ProvinceDaoImpl();

    @Override
    public List<Province> findAll() {
        return dao.findAll();
    }

    /**
        使用redis缓存
     */

    @Override
    public String findAllJson() {
        //1.先从redis中查询数据
        //1.1获取redis客户端连接
        Jedis jedis = JedisPoolUtils.getJedis();
        String province_json = jedis.get("province");

        //2判断 province_json 数据是否为null
        if(province_json == null || province_json.length() == 0){
            //redis中没有数据
            System.out.println("redis中没数据，查询数据库...");
            //2.1从数据中查询
            List<Province> ps = dao.findAll();
            //2.2将list序列化为json
            Gson gson = new Gson();
            try {
                province_json = gson.toJson(ps);
            } catch (Exception e) {
                e.printStackTrace();
            }

            //2.3 将json数据存入redis
            jedis.set("province",province_json);
            //归还连接
            jedis.close();

        }else{
            System.out.println("redis中有数据，查询缓存...");
        }


        return province_json;
    }
}

Servlet程序

 @WebServlet("/provinceServlet")
public class ProvinceServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       /* //1.调用service查询
        ProvinceService service = new ProvinceServiceImpl();
        List<Province> list = service.findAll();
        //2.序列化list为json
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(list);*/

        //1.调用service查询
        ProvinceService service = new ProvinceServiceImpl();
        String json = service.findAllJson();


        System.out.println(json);
        //3.响应结果
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(json);

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

1.11 redis在linux的安装

把安装包放到/opt目录下面,tar -zxvf 文件 解压文件,进入redis-3.2.5文件下面，执行

make命令,可能会报错误,因为是由c语言编写的

yum install gcc

yum install gcc-c++

注意：如果第一次报错，没有安装成功，当下载好了文件,再次执行make命令，会报错，因为原先有残留文件，因此，运行make distclean之后再make

1.11.1 详细步骤:

1. 下载获得redis-3.2.5.tar.gz后将它放入我们的Linux目录/opt
   

2. 解压命令:tar -zxvf redis-3.2.5.tar.gz
   

3. 解压完成后进入目录:cd redis-3.2.5
   

4. 在redis-3.2.5目录下执行make命令
   

l 运行Make命令时出现错误,提示 gcc：命令未找到 ,原因是因为当前Linux环境中并没有安装gcc 与 g++ 的环境

5. 安装gcc与g++
   

l 能上网的情况:

yum install gcc

yum install gcc-c++

l 不能上网[建议]

参考Linux课程中«03_在VM上安装CentOS7»中的第40步骤

6. 重新进入到Redis的目录中执行 make distclean后再执行make 命令.
   

7. 执行完make后，可跳过Redis test步骤，直接执行 make install
   

1.11.2 查看默认安装路径/usr/local/bin

1. Redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何(服务启动起来后执行)
   

2. Redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲
   

3. Redis-check-dump：修复有问题的dump.rdb文件
   

4. Redis-sentinel：Redis集群使用
   

5. redis-server：Redis服务器启动命令
   

6. redis-cli：客户端，操作入口
   

1.11.3 Redis的启动

1. 默认前台方式启动 
   

l 直接执行redis-server 即可.启动后不能操作当前命令窗口

2. 推荐后台方式启动
   

l 拷贝一份redis.conf配置文件到其他目录，例如根目录下的myredis目录 /myredis

l 修改redis.conf文件中的一项配置 daemonize 将no 改为yes，代表后台启动

l 执行配置文件进行启动 执行 redis-server /myredis/redis.conf

1.11.4 客户端的访问

1. 使用redis-cli 命令访问启动好的Redis
   

l 如果有多个Redis同时启动，则需指定端口号访问 redis-cli -p 端口号

2. 测试验证,通过 ping 命令 查看是否 返回 PONG
   

1.11.4 关闭Redis服务

1. 单实例关闭 
   

l 如果还未通过客户端访问，可直接 redis-cli shutdown

l 如果已经进入客户端,直接 shutdown即可.

2. 多实例关闭
   

l 指定端口关闭 redis-cli -p 端口号 shutdown

1.11.5 Redis默认16个库

1)Redis默认创建16个库，每个库对应一个下标，从0开始

通过客户端连接后默认进入到0号库，推荐只使用0号库

2）使用命令select库的下标，来切换数据库，例如select 8

1.11.6 Redis的单线程+多路IO复用技术

1. 多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。
   

2. Memcached 是 多线程 + 锁. 
   

Redis 是 单线程 + 多路IO复用.

1.12 Redis事务

1.12.1 Redis中事务的定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断

Redis事务的主要作用就是串联多个命令防止别的命令插队

1.12.2 multi,exec,discard

1. 从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，至到输入Exec后，Redis会将之前的命令队列中的命令依次执行。**注意：只要在Exec中，如果又命令执行失败，不会导致其他其他命令执行**
   

2. 组队的过程中可以通过discard来放弃组队。 
   

1.12.3 事务中的错误处理

1)组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消

2)如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚

1.12.4 Redis事务的使用

1)WATCH key[key….]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。注意：只要开启watch，无论还有没有开启事务，进行第一次事务的时候之前或者之后如果watch的key发生遍化exec的结果都为null

1. unwatch
   

取消 WATCH 命令对所有 key 的监视。

如果在执行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行 UNWATCH 了。

2. 三特性
   

l 单独的隔离操作

事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

l 没有隔离级别的概念

队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在“事务内的查询要看到事务里的更新，在事务外查询不能看到”这个让人万分头痛的问题

l 不保证原子性

Redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

1.12.5 Redis事务秒杀案例

 @RequestMapping("seckill")
    public void seckill(HttpServletResponse response,@RequestParam("itemId") String itemId) throws IOException {

        Jedis jedis = new Jedis("192.168.241.168",6379);
        //用来监听key为itemId的事件,只要事件的值变化了，其他事务的执行就取消
        jedis.watch(itemId);

        jedis.incr("1001number");

        int s = Integer.parseInt(jedis.get(itemId));


        if (s > 0) {
            //这个用来执行事务,减少一个
            //建立一个multi的事务
            Transaction multi = jedis.multi();
            multi.decr(itemId);
            //提交事务
            List<Object> exec = multi.exec();
            if (exec == null || exec.size() == 0) {
                System.out.println("秒杀失败");
                response.getWriter().write("false");
            } else {
                System.out.println("秒杀成功");
                response.getWriter().write("true");
            }


        } else {
            System.out.println("秒杀失败");

        }

    }

1.12.6 模拟高并发执行

1) 秒杀并发模拟 ab工具

l CentOS6 默认安装 ,CentOS7需要手动安装

l 联网: yum install httpd-tools

无网络: 进入cd /run/media/root/CentOS 7 x86_64/Packages

   顺序安装

           apr-1.4.8-3.el7.x86_64.rpm

        apr-util-1.5.2-6.el7.x86_64.rpm

        httpd-tools-2.4.6-67.el7.centos.x86_64.rpm  

l ab –n 请求数 -c 并发数 -p 指定请求数据文件

-T “application/x-www-form-urlencoded” 测试的请求

ab -n 1000 -c 200 -p myRequest -T “application/x-www-form-urlencoded” 192.168.241.1:8080/firstssm3/seckill

myRequest里面写你的请求，注意后面一定要带&

itemId=1001&

1.12.7 LUA脚本（可以高效实现redis的超卖问题)

l LUA脚本

Lua 是一个小巧的脚本语言，Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数，Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为开发独立应用程序的语言，而是作为嵌入式脚本语言。

很多应用程序、游戏使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。这其中包括魔兽争霸地图、魔兽世界、博德之门、愤怒的小鸟等众多游戏插件或外挂

l LUA脚本在Redis中的优势

将复杂的或者多步的redis操作，写为一个脚本，一次提交给redis执行，减少反复连接redis的次数。提升性能。

LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作

但是注意redis的lua脚本功能，只有在2.6以上的版本才可以使用。

l 利用lua脚本淘汰用户，解决超卖问题。

1.13 Redis主从复制

1.13.1 什么是主从复制

主从复制，就是主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主。

1.13.2 主从复制的目的

1. 读写分离，性能扩展
   

2. 容灾快速恢复
   

3.  ![image-20210128110839536](/imgs/image-20210128110839536.png)
   

1.13.3 主从配置

1. 原则: 配从不配主
   

2. 步骤: 准备三个Redis实例，一主两从
   

   拷贝多个redis.conf文件include

   开启daemonize yes

   Pid文件名字pidfile

   指定端口port

   Log文件名字

   Dump.rdb名字dbfilename

   Appendonly 关掉或者换名字

3. info replication 打印主从复制的相关信息
   

4. slaveof <ip> <port>  成为某个实例的从服务器
   

1.13.4 实际操作

写一个配置文件

include /myredis/redis.conf
pidfile /var/run/redis6379.pid
port 6379
dbfilename dump6379.rdb
Appendonly no

复制三个取不同名字，最好用redis+端口号命名

把配置文件里面的端口号进行替换

redis-server 你刚刚进行的配置文件 （用来开启不同的三个服务)

然后进入客户端

redis-cli -h 127.0.0.1 -p 6379

redis-cli -h 127.0.0.1 -p 6380

redis-cli -h 127.0.0.1 -p 6381

然后再6380和6381的服务端

slaveof 127.0.0.1 6379(成为端口号为6379的从服务器)

info replication 查看关系

注意：如果主机被切断了，重新回来，数据还是在的

		**如果从机被切断了，重新回来，但是需要在slaveof 127.0.0.1 6379,才会变成从服务器**

1.13.5 薪火相传模式演示

1. 上一个slave可以是下一个slave的Master，slave同样可以接收其他slaves的连接和同步请求，那么该slave作为了链条中下一个的master, 可以有效减轻master的写压力,去中心化降低风险.
   

   中途变更转向:会清除之前的数据，重新建立拷贝最新的

   风险是一旦某个slave宕机，后面的slave都没法备份

   ​

​

2. 反客为主(小弟上位)
   

当一个master宕机后，后面的slave可以立刻升为master，其后面的slave不用做任何修改。

用 slaveof no one 将从机变为主机。

配置:

在6381服务器上面slaveof 127.0.0.1 6380 ,可以间接同步主服务器

如果主服务器down了，那么6380服务器只要slaveof no one 就可升级为主服务器

1.13.6 哨兵模式

反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库.

​

配置哨兵

l 调整为一主二从模式

l 自定义的/myredis目录下新建sentinel.conf文件

l 在配置文件中填写内容

sentinel monitor mymaster 127.0.0.1 6379 1

      其中mymaster为监控对象起的服务器名称， 1 为 至少有多少个哨兵同意迁移的

      数量。

l 启动哨兵

执行redis-sentinel /myredis/sentinel.conf

1.14 配置集群

1.14.1 安装ruby环境

1）能上网：

执行yum install ruby

执行yum install rubygems

注意：用yum中的rubygems版本过低，后面可能会报错

因此用javaanzhuangbao中的redis-gems3.2.0

复制到/opt中，然后通过gem install –local redis-3.2.0.gem

进行安装

1.14.2 准备6个Redis实例

1. 准备6个实例 6379,6380,6381,6389,6390,6391
   

   拷贝多个redis.conf文件

   开启daemonize yes

   Pid文件名字

   指定端口

   Log文件名字

   Dump.rdb名字

   Appendonly 关掉或者换名字

2. 再加入如下配置
   

cluster-enabled yes 打开集群模式

cluster-config-file nodes-端口号.conf 设定节点配置文件名

cluster-node-timeout 15000 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换

include /myredis/redis.conf
pidfile "/var/run/redis6379.pid"
port 6379
dbfilename "dump6379.rdb"
appendonly no
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000

1.14.3 合体

1. 将6个实例全部启动，nodes-端口号.conf文件都生成正常
   

2. 合体
   

l 进入到 cd /opt/redis-3.2.5/src

l 执行

./redis-trib.rb create --replicas 1 192.168.241.168:6379 192.168.241.168:6380 192.168.241.168:6381 192.168.241.168:6382 192.168.241.168:6383  192.168.241.168:6384

l 注意: IP地址修改为当前服务器的地址，端口号为每个Redis实例对应的端口号.

1.14.4 集群操作

1. 以集群的方式进入客户端
   

redis-cli -c -p 端口号

2. 通过cluster nodes 命令查看集群信息
   
                    ![image-20210128153208222](/imgs/image-20210128153208222.png)       
   

3. redis cluster 如何分配这六个节点
   

一个集群至少要有三个主节点。

选项 –replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。

分配原则尽量保证每个主数据库运行在不同的IP地址，每个从库和主库不在一个IP地址上。

4. 什么是slots 
   

l 一个 Redis 集群包含 16384 个插槽（hash slot）， 数据库中的每个键都属于这 16384 个插槽的其中一个， 集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽， 其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和 。

l 集群中的每个节点负责处理一部分插槽。 举个例子， 如果一个集群可以有主节点， 其中：

节点 A 负责处理 0 号至 5500 号插槽。

节点 B 负责处理 5501 号至 11000 号插槽。

节点 C 负责处理 11001 号至 16383 号插槽

5. 在集群中录入值
   

l 在redis-cli每次录入、查询键值，redis都会计算出该key应该送往的插槽，如果不是该客户端对应服务器的插槽，redis会报错，并告知应前往的redis实例地址和端口.

l redis-cli客户端提供了 –c 参数实现自动重定向。

如 redis-cli -c –p 6379 登入后，再录入、查询键值对可以自动重定向。

l 不在一个slot下的键值，是不能使用mget,mset等多键操作。

l 可以通过{}来定义组的概念，从而使key中{}内相同内容的键值对放到一个slot中去

6. 查询集群中的值
   

l CLUSTER KEYSLOT 计算键 key 应该被放置在哪个槽上。

l CLUSTER COUNTKEYSINSLOT 返回槽 slot 目前包含的键值对数量

l CLUSTER GETKEYSINSLOT 返回 count 个 slot 槽中的键

7. 故障恢复
   

l 如果主节点下线？从节点能否自动升为主节点？

l 会。

l 主节点恢复后，主从关系会如何？

l 原先的主节点变从节点。

l 如果所有某一段插槽的主从节点都当掉，redis服务是否还能继续?

redis.conf中的参数 cluster-require-full-coverage

不能

1.14.5 集群的jedis开发

    public static void main(String[] args) {
    
        HashSet<HostAndPort> hostAndPorts = new HashSet<>();
        hostAndPorts.add(new HostAndPort( "192.168.241.168",6379));
        JedisCluster jedis = new JedisCluster(hostAndPorts);
        String set = jedis.set("xiao", "gegehaoshuai");
        System.out.println(jedis.get("xiao"));
        System.out.println(jedis.get("mars"));
    }
}

1.14.6 Redis集群的优缺点

l 优点

实现扩容

分摊压力

无中心配置相对简单

l 缺点

多键操作是不被支持的

多键的Redis事务是不被支持的。lua脚本不被支持。

由于集群方案出现较晚，很多公司已经采用了其他的集群方案，而代理或者客户端分片的方案想要迁移至redis cluster，需要整体迁移而不是逐步过渡，复杂度较大。

Linux

0 总结和一些操作

1 tee命令的用法

tee [-ai][--help][--version][文件...]

参数：

• -a或–append 　附加到既有文件的后面，而非覆盖它．
• -i或–ignore-interrupts 　忽略中断信号。
• –help 　在线帮助。
• –version 　显示版本信息。

表示在文件中写入’我是’同时按abc结束(也可以把-去掉)

//一般配合管道符使用
sh -c 'exec mysqldump --all-databases -uroot -p"123456"' | tee /test

2 $ 和 | 的用法

$的用法

 docker rmi -f $(docker images -qa)
$(docker images -qa)代表先在容器中取出

| 的用法

比如查找命令

ps -ef | grep 3306

代表把ps -ef 查询出来的所有内容通过放到 grep 3306 里面来执行

3 < > « » 的用法

< 的用法 和 cat a.txt 用法相同

«的用法定义结束标志

[tee命令的用法那里有](##1 tee命令的用法)

1 >的用法

覆盖输出到文本

会把文本中的内容覆盖

sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /c.txt

将查询出来的命令里面的所有内容存放到/c.txt文件中去

echo "信息" > test.asc

2 »的用法

追加

linux常用快捷键

第1章 vm的安装和linux的安装

1.1 vm的安装

一直点击下一步最后到

许可证 5A02H-AU243-TZJ49-GTC7K-3C61N

点击完成

1.2 虚拟机的安装

当使用桥接方式，会和主机在同一个网段，会出现ip地址不够用的情况，同时会被其他任何一台主机访问到linux，会出现不安全的情况

使用桥接模式，会自动分配当前ip地址，如果和别的电脑自动分配的ip地址相同，就会出现不能用的情况

当使用NAT网络转换模式 当使用虚拟机的时候，虚拟机会给我们使用两个虚拟网卡，其中的一个一定是和你的linux在同一个网段的，通信主机上的那个虚拟网卡，就可以使用虚拟网卡和主机进行通信了，所以虚拟机虽然不在同一个网段，但是可以通过虚拟网卡和主机进行通信‘

虚拟网卡里面的ip地址一定和linux相同

当使用仅主机模式网络的时候linux会和你所在的主机公用一个网络，相当于只和主机连接，linux不能上网

1.3 安装linux

点击开启虚拟机

点击完成跳转手动分区

/boot 内含启动文件和内核。 启动文件：用于决断你需要启动哪个百操作系统或者启动哪个内核。 内核：简单的讲，程序与硬件度间的桥梁，你使用应用程序通过内核，控制整个计算机。

你所设置的文件系统不一样，它所能存储的文件类型也不一样

ext2,ext3 创建的文件数量有限

当linux内存不够用的时候，会把swap当成内存进行使用，在linux万物皆是文件

相当于虚拟内存

点击安装

同时需要安装xftp和Xshell

第2章 xftp的用法和xshell的用法

xftp的用法

注意用户名和密码需要和linux一致,否则连接失败

xshell的用法

第3章 linux文件系统

3.1 Linux文件与目录结构

第4章 VI、VIM编辑器

VI、VIM是Linux系统命令下的文本编辑器

通过命令vi文件名 或者是vim文件名来使用

4.1 三种模式

一般模式（默认模式）

1 通过vi或者是vim打开文档后默认进入到一般模式，该模式下主要负责查看和一些基础的修剪工作

2 常用的操作

编辑模式

1 在一般模式下通过字母i、a、o进入到编辑模式，进入后左下角会有【插入】的字样，如想退出编辑模式，需要按下【ESC】按键

2 常用的操作

命令模式

在一般模式下输入/或者：进入命令模式，命令模式一般用于存盘、退出VIM、显示行号，搜索、批量替换等操作

常用的操作

4.2 三种模式之间的切换关系

4.3 VI、VIM键盘图

第5章 常用命令

5.1 基本命令

pwd 显示当前工作目录的绝对路径

pwd:print working directory 打印工作目录

1．基本语法

pwd （功能描述：显示当前工作目录的绝对路径）

2．案例实操

​ （1）显示当前工作目录的绝对路径

[root@hadoop101 ~]# pwd

/root

ls 列出目录的内容

ls:list 列出目录内容

1．基本语法

ls [选项] [目录或是文件]

2．选项说明

​ 表1-8 选项说明

3．显示说明

每行列出的信息依次是： 文件类型与权限 链接数 文件属主 文件属组 文件大小用byte来表示 建立或最近修改的时间 名字

4．案例实操

​ （1）查看当前目录的所有内容信息

[atguigu@hadoop101 ~]$ ls -al

总用量 44

drwx——. 5 atguigu atguigu 4096 5月 27 15:15 .

drwxr-xr-x. 3 root root 4096 5月 27 14:03 ..

drwxrwxrwx. 2 root root 4096 5月 27 14:14 hello

-rwxrw-r–. 1 atguigu atguigu 34 5月 27 14:20 test.txt

cd 切换目录

cd:Change Directory切换路径

1．基本语法

​ cd [参数]

2．参数说明

表1-9 参数说明

3．案例实操

（1）使用绝对路径切换到root目录

[root@hadoop101 ~]# cd /root/

（2）使用相对路径切换到“公共的”目录

[root@hadoop101 ~]# cd 公共的/

（3）表示回到自己的家目录，亦即是 /root 这个目录

[root@hadoop101 公共的]# cd ~

（4）cd- 回到上一次所在目录

[root@hadoop101 ~]# cd -

（5）表示回到当前目录的上一级目录，亦即是 “/root/公共的”的上一级目录的意思；

[root@hadoop101 公共的]# cd ..

mkdir 创建一个新的目录

mkdir:Make directory 建立目录

1．基本语法

​ mkdir [选项] 要创建的目录

2．选项说明

表1-10 选项说明

3．案例实操

（1）创建一个目录

[root@hadoop101 ~]# mkdir xiyou

[root@hadoop101 ~]# mkdir xiyou/mingjie

（2）创建一个多级目录

[root@hadoop101 ~]# mkdir -p xiyou/dssz/meihouwang

rmdir 删除一个空的目录

rmdir:Remove directory 移动目录

1．基本语法：

​ rmdir 要删除的空目录

2．案例实操

​ （1）删除一个空的文件夹

[root@hadoop101 ~]# rmdir xiyou/dssz/meihouwang

touch 创建空文件

1．基本语法

​ touch 文件名称

2．案例实操

[root@hadoop101 ~]# touch xiyou/dssz/sunwukong.txt

cp 复制文件或目录

1．基本语法

cp [选项] source dest （功能描述：复制source文件到dest）

2．选项说明

表1-11 选项说明

3．参数说明

表1-12 参数说明

4．经验技巧

​ 强制覆盖不提示的方法：\cp

5．案例实操

（1）复制文件

[root@hadoop101 ~]# cp xiyou/dssz/suwukong.txt xiyou/mingjie/

（2）递归复制整个文件夹

[root@hadoop101 ~]# cp -r xiyou/dssz/ ./

rm 移除文件或目录

1．基本语法

rm [选项] deleteFile （功能描述：递归删除目录中所有内容）

2．选项说明

表1-13 选项说明

\3. 案例实操

（1）删除目录中的内容

[root@hadoop101 ~]# rm xiyou/mingjie/sunwukong.txt

（2）递归删除目录中所有内容

[root@hadoop101 ~]# rm -rf dssz/

mv 移动文件与目录或重命名

1．基本语法

​ （1）mv oldNameFile newNameFile （功能描述：重命名）

​ （2）mv /temp/movefile /targetFolder （功能描述：移动文件）

2．案例实操

（1）重命名

[root@hadoop101 ~]# mv xiyou/dssz/suwukong.txt xiyou/dssz/houge.txt

（2）移动文件

[root@hadoop101 ~]# mv xiyou/dssz/houge.txt ./

cat 查看文件内容

查看文件内容，从第一行开始显示。

1．基本语法

​ cat [选项] 要查看的文件

2．选项说明

表1-14

3．经验技巧

一般查看比较小的文件，一屏幕能显示全的。

4．案例实操

​ （1）查看文件内容并显示行号

[atguigu@hadoop101 ~]$ cat -n houge.txt

more 文件内容分屏查看器

more指令是一个基于VI编辑器的文本过滤器，它以全屏幕的方式按页显示文本文件的内容。more指令中内置了若干快捷键，详见操作说明。

1．基本语法

​ more 要查看的文件

2．操作说明

表1-15 操作说明

3．案例实操

​ （1）采用more查看文件

[root@hadoop101 ~]# more smartd.conf

less 分屏显示文件内容

​ less指令用来分屏查看文件内容，它的功能与more指令类似，但是比more指令更加强大，支持各种显示终端。less指令在显示文件内容时，并不是一次将整个文件加载之后才显示，而是根据显示需要加载内容，对于显示大型文件具有较高的效率。

1．基本语法

​ less 要查看的文件

2．操作说明

表1-16 操作说明

4．案例实操

​ （1）采用less查看文件

[root@hadoop101 ~]# less smartd.conf

echo

echo输出内容到控制台

\1. 基本语法

​ echo [选项] [输出内容]

选项：

-e： 支持反斜线控制的字符转换

\2. 案例实操

[atguigu@hadoop101 ~]$ echo “hello\tworld”

hello\tworld

[atguigu@hadoop101 ~]$ echo -e “hello\tworld”

hello world

head 显示文件头部内容

head用于显示文件的开头部分内容，默认情况下head指令显示文件的前10行内容。

\1. 基本语法

head 文件 （功能描述：查看文件头10行内容）

head -n 5 文件 （功能描述：查看文件头5行内容，5可以是任意行数）

2．选项说明

表1-18

3．案例实操

​ （1）查看文件的头2行

[root@hadoop101 ~]# head -n 2 smartd.conf

tail 输出文件尾部内容

tail用于输出文件中尾部的内容，默认情况下tail指令显示文件的后10行内容。

\1. 基本语法

（1）tail 文件 （功能描述：查看文件后10行内容）

（2）tail -n 5 文件 （功能描述：查看文件后5行内容，5可以是任意行数）

（3）tail -f 文件 （功能描述：实时追踪该文档的所有更新）

2． 选项说明

表1-19

3．案例实操

（1）查看文件头1行内容

[root@hadoop101 ~]# tail -n 1 smartd.conf

（2）实时追踪该档的所有更新

[root@hadoop101 ~]# tail -f houge.txt

> 覆盖 和 » 追加

1．基本语法

（1）ll >文件 （功能描述：列表的内容写入文件a.txt中（覆盖写））

（2）ll »文件 （功能描述：列表的内容追加到文件aa.txt的末尾）

（3）cat 文件1 > 文件2 （功能描述：将文件1的内容覆盖到文件2）

（4）echo “内容” » 文件

2．案例实操

（1）将ls查看信息写入到文件中

[root@hadoop101 ~]# ls -l>houge.txt

（2）将ls查看信息追加到文件中

[root@hadoop101 ~]# ls -l»houge.txt

（3）采用echo将hello单词追加到文件中

[root@hadoop101 ~]# echo hello»houge.txt

ln 软链接

软链接也成为符号链接，类似于windows里的快捷方式，有自己的数据块，主要存放了链接其他文件的路径。

1．基本语法

ln -s [原文件或目录] [软链接名] （功能描述：给原文件创建一个软链接）

2．经验技巧

删除软链接： rm -rf 软链接名，而不是rm -rf 软链接名/

查询：通过ll就可以查看，列表属性第1位是l，尾部会有位置指向。

3．案例实操

​ （1）创建软连接

[root@hadoop101 ~]# mv houge.txt xiyou/dssz/

[root@hadoop101 ~]# ln -s xiyou/dssz/houge.txt ./houzi

[root@hadoop101 ~]# ll

lrwxrwxrwx. 1 root root 20 6月 17 12:56 houzi -> xiyou/dssz/houge.txt

（2）删除软连接

[root@hadoop101 ~]# rm -rf houzi

（3）进入软连接实际物理路径

[root@hadoop101 ~]# ln -s xiyou/dssz/ ./dssz

[root@hadoop101 ~]# cd -P dssz/

history 查看已经执行过历史命令

1．基本语法

​ history （功能描述：查看已经执行过历史命令）

2．案例实操

​ （1）查看已经执行过的历史命令

[root@hadoop101 test1]# history

时间日期类

date 显示当前时间

1．基本语法 （1）date （功能描述：显示当前时间） （2）date +%Y （功能描述：显示当前年份） （3）date +%m （功能描述：显示当前月份） （4）date +%d （功能描述：显示当前是哪一天） （5）date “+%Y-%m-%d %H:%M:%S” （功能描述：显示年月日时分秒） 2．案例实操 （1）显示当前时间信息 [root@hadoop101 ~]# date 2017年 06月 19日 星期一 20:53:30 CST （2）显示当前时间年月日 [root@hadoop101 ~]# date +%Y%m%d 20170619 （3）显示当前时间年月日时分秒 [root@hadoop101 ~]# date "+%Y-%m-%d %H:%M:%S" 2017-06-19 20:54:58

date 显示非当前时间

1．基本语法 （1）date -d ‘1 days ago’ （功能描述：显示前一天时间） （2）date -d ‘-1 days ago’ （功能描述：显示明天时间） 2．案例实操 （1）显示前一天 [root@hadoop101 ~]# date -d '1 days ago' 2017年 06月 18日 星期日 21:07:22 CST （2）显示明天时间 [root@hadoop101 ~]#date -d '-1 days ago' 2017年 06月 20日 星期日 21:07:22 CST

date 设置系统时间

1．基本语法 date -s 字符串时间 尚硅谷大数据技术之 Linux ————————————————————————————— 更多 Java –大数据 –前端 –python 人工智能资料下载，可百度访问：尚硅谷官网 2．案例实操 （1）设置系统当前时间 [root@hadoop101 ~]# date -s "2017-06-19 20:52:18"

cal 查看日历

1．基本语法 cal [选项] （功能描述：不加选项，显示本月日历） 2．选项说明 表1-22 选项 功能 具体某一年 显示这一年的日历 3．案例实操 （1）查看当前月的日历 [root@hadoop101 ~]# cal （2）查看2017年的日历 [root@hadoop101 ~]# cal 2017

第5章 压缩和解压类

5.1 gzip/gunzip 压缩

1．基本语法

gzip 文件 （功能描述：压缩文件，只能将文件压缩为*.gz文件）

gunzip 文件.gz （功能描述：解压缩文件命令）

2．经验技巧

（1）只能压缩文件不能压缩目录

（2）不保留原来的文件

3．案例实操

（1）gzip压缩

[root@hadoop101 ~]# ls

test.java

[root@hadoop101 ~]# gzip houge.txt

[root@hadoop101 ~]# ls

houge.txt.gz

（2）gunzip解压缩文件

[root@hadoop101 ~]# gunzip houge.txt.gz

[root@hadoop101 ~]# ls

houge.txt

5.2 zip/unzip 压缩

1．基本语法

zip [选项] XXX.zip 将要压缩的内容 （功能描述：压缩文件和目录的命令）

unzip [选项] XXX.zip （功能描述：解压缩文件）

2．选项说明

表1-29

表1-30

3．经验技巧

zip 压缩命令在window/linux都通用，可以压缩目录且保留源文件。

4．案例实操

（1）压缩 1.txt 和2.txt，压缩后的名称为mypackage.zip

[root@hadoop101 opt]# touch bailongma.txt

[root@hadoop101 ~]# zip houma.zip houge.txt bailongma.txt 

 adding: houge.txt (stored 0%)

 adding: bailongma.txt (stored 0%)

[root@hadoop101 opt]# ls

houge.txt  bailongma.txt houma.zip 

（2）解压 mypackage.zip

[root@hadoop101 ~]# unzip houma.zip 

Archive: houma.zip

 extracting: houge.txt        

 extracting: bailongma.txt    

[root@hadoop101 ~]# ls

houge.txt  bailongma.txt houma.zip 

（3）解压mypackage.zip到指定目录-d

[root@hadoop101 ~]# unzip houma.zip -d /opt

[root@hadoop101 ~]# ls /opt/

5.3 tar 打包

1．基本语法

tar [选项] XXX.tar.gz 将要打包进去的内容 （功能描述：打包目录，压缩后的文件格式.tar.gz）

2．选项说明

表1-31

3．案例实操

（1）压缩多个文件

[root@hadoop101 opt]# tar -zcvf houma.tar.gz houge.txt bailongma.txt

houge.txt

bailongma.txt

[root@hadoop101 opt]# ls

houma.tar.gz houge.txt bailongma.txt

（2）压缩目录

[root@hadoop101 ~]# tar -zcvf xiyou.tar.gz xiyou/

xiyou/

xiyou/mingjie/

xiyou/dssz/

xiyou/dssz/houge.txt

（3）解压到当前目录

[root@hadoop101 ~]# tar -zxvf houma.tar.gz

（4）解压到指定目录

[root@hadoop101 ~]# tar -zxvf xiyou.tar.gz -C /opt

[root@hadoop101 ~]# ll /opt/

时间日期类

1．基本语法

date [OPTION]… [+FORMAT]

2．选项说明

表1-20

3．参数说明

表1-21

date 显示当前时间

1．基本语法

​ （1）date （功能描述：显示当前时间）

​ （2）date +%Y （功能描述：显示当前年份）

（3）date +%m （功能描述：显示当前月份）

（4）date +%d （功能描述：显示当前是哪一天）

​ （5）date “+%Y-%m-%d %H:%M:%S” （功能描述：显示年月日时分秒）

2．案例实操

（1）显示当前时间信息

[root@hadoop101 ~]# date

2017年 06月 19日 星期一 20:53:30 CST

（2）显示当前时间年月日

[root@hadoop101 ~]# date +%Y%m%d

20170619

（3）显示当前时间年月日时分秒

[root@hadoop101 ~]# date “+%Y-%m-%d %H:%M:%S”

2017-06-19 20:54:58

date 显示非当前时间

1．基本语法

（1）date -d ‘1 days ago’ （功能描述：显示前一天时间）

（2）date -d ‘-1 days ago’ （功能描述：显示明天时间）

2．案例实操

（1）显示前一天

[root@hadoop101 ~]# date -d ‘1 days ago’

2017年 06月 18日 星期日 21:07:22 CST

（2）显示明天时间

[root@hadoop101 ~]#date -d ‘-1 days ago’

2017年 06月 20日 星期日 21:07:22 CST

date 设置系统时间

1．基本语法

​ date -s 字符串时间

2．案例实操

​ （1）设置系统当前时间

[root@hadoop101 ~]# date -s “2017-06-19 20:52:18”

cal 查看日历

1．基本语法

cal [选项] （功能描述：不加选项，显示本月日历）

2．选项说明

表1-22

3．案例实操

（1）查看当前月的日历

[root@hadoop101 ~]# cal

（2）查看2017年的日历

[root@hadoop101 ~]# cal 2017

第6章 添加硬盘

查看所有设备挂载情况

命令：lsblk或者lsblk -f

如何添加一块硬盘

1 .虚拟机插硬盘

2 .分区

3 .格式化

5 .挂载

虚拟机插入新硬盘

在【虚拟机】菜单中，选择【设置】，然后设备列表里添加硬盘，然后一路【下一步】中间只有选择磁盘大小的地方需要修改，直到完成，然后重启系统

进行分区

分区命令 fdisk /dev/sdb

​ 开始对/sdb分区

m 显示命令列表

p 显示磁盘

n 新增分区

d 删除分区

w 写入并退出分区

分区步骤如下: 开始分区后输入n，新增分区，然后选择p ，分区类型为主分区。两次回车默认剩余全部空间。最后输入w写入分区并退出，若不保存退出输入q。

格式化磁盘

mkfs -t ext4 /dev/sdb1

挂载

将一个分区和一个目录联系起来（相当于u盘）

mount 设备名称 挂载目录

例如：mount /dev/sdb1 /newdisk

umount 设备名称或者 挂载目录

例如：umount /dev/sdb1 或者umount /newdisk

注意：用命令行挂载重启后会失效

永久挂载

通过修改/etc/fstab实现挂载

添加完成后执行mount -a 即刻生效

/etc/fatab文件参数介绍

第一列：磁盘设备文件或者该设备的Label或者UUID

第二列: 设备的挂载点，就是你要挂载到哪个目录下

第三列: 磁盘文件系统的格式，

​ 包括ext2、ext3、reiserfs、nfs、vfat等

第四列: 文件系统的参数 ，defaults代表同时具有

​ rw,suid,dev,exec,auto,nouser,async等默认参数的设置

第五列: 能否被dump备份命令作用

​ 0 代表不要做dump备份

​ 1 代表要每天进行dump的操作

​ 2 代表不定日期的进行dump操作

第六列: 是否检验扇区

​ 0 不要检验

​ 1 最早检验（一般根目录会选择）

​ 2 1级别检验完成之后进行检验

/dev/sdb1 newDisk                    ext4    defaults        0 0

注意配置完成需要mount -a

磁盘情况查询

df -h 查询系统整体磁盘使用情况

du -h /目录

​ 查询指定目录的磁盘占用情况，默认为当前目录

​ -s 只当目录占用大小汇总

​ -h 带计量单位

​ -a 含文件

​ –max-depth=1 子目录深度

​ -c 列出明细的同时，增加汇总值

​ 例： du -ach –max-depth=1 /opt

第7章 网络配置和修改ip

查看网络IP和网关

5.1 查看网络IP和网关

1．查看虚拟网络编辑器，如图1-95所示

​

图1-95 查看虚拟网络编辑器

2．修改ip地址，如图1-96所示

图1-96 修改ip地址

3．查看网关，如图1-97所示

图1-97 查看网关

\4. 查看windows环境的中VMnet8网络配置，如图1-98所示

图1-98 windows中VMnet8网络配置

ifconfig 查看网络配置

通过图形化页面进行网络配置

用命令行的方式进行网络配置

命令行的方式 vi /etc/sysconfig/network-scripts/ifcfg-ens33

加入BOOTPROTO=static

#IP地址

IPADDR=192.168.1.100

#网关

GATEWAY=192.168.1.2

#域名解析器

DNS1=192.168.1.2

DEVICE=eth0  #接口名（设备,网卡）

​     BOOTPROTO=none  # IP的配置方法[none|static|bootp|dhcp]（引导时不使用协

​                            议|静态分配IP|BOOTP协议|DHCP   协议）

​     BROADCAST=192.168.1.255  #广播地址  

​     HWADDR=00:0C:2x:6x:0x:xx  #MAC地址 

​     IPADDR=192.168.1.23    #IP地址

​     NETMASK=255.255.255.0   # 网络掩码 

​     NETWORK=192.168.1.0    #网络地址 

​     ONBOOT=yes        #系统启动的时候网络接口是否有效（yes/no）

​     TYPE=Ethernet       #网络类型（通常是Ethemet）

systemctl restart network

重启网络服务

第8章 进程类

ps(process)

ps显示的信息选项

1. ps -aux
   

-a : 显示当前总段的所有进行信息

-u : 以用户的格式显示进程信息

-x : 显示后台进程运行的参数

l 详细内容解释

ps –aux|grep xxx

System V展示风格

USER：用户名称

PID：进程号

%CPU：进程占用CPU的百分比

%MEM：进程占用物理内存的百分比

VSZ：进程占用的虚拟内存大小（单位：KB）

RSS：进程占用的物理内存大小（单位：KB）

TT：终端名称,缩写

STAT：进程状态，其中S-睡眠，s-表示该进程是会话的先导进程，N-表示进程拥有比普通优先级更低的优先级，R-正在运行，D-短期等待，Z-僵死进程，T-被跟踪或者被停止等等

STARTED：进程的启动时间

TIME：CPU时间，即进程使用CPU的总时间

COMMAND：启动进程所用的命令和参数，如果过长会被截断显示

2. ps -ef
   

ps -ef是以全格式显示当前所有的进程

-e 显示所有进程。-f 全格式。

ps -ef|grep xxx

是BSD风格

UID：用户ID

PID：进程ID

PPID：父进程ID

C：CPU用于计算执行优先级的因子。数值越大，表明进程是CPU密集型运算，执行优先级会降低；数值越小，表明进程是I/O密集型运算，执行优先级会提高

STIME：进程启动的时间

TTY：完整的终端名称

TIME：CPU时间

CMD：启动进程所用的命令和参数

3. kill pid  杀死指定pid对应的进程.
   

-9： 强行杀死进程

4） killall

•killall name 通过进程名称杀死进程

第9章 服务类

注册在系统中的标准化程序

有方便统一的管理方式（常用的方法）

service 服务名 start

service 服务名 stop

service 服务名 restart

service 服务名 reload

service 服务名 status

查看服务的方法 /etc/init.d/服务名

通过chkconfig命令设置自启动

查看服务chkconfig –list|grep xxx

chkconfig –level 5 服务名 on

运行级别:

开机 -> bios ->/boot -> init进程 -> 运行级别 -> 运行级对应的服务

查看默认级别 vi /etc/inittab

linux系统有7种运行级别（runlevel):常用的是级别3和5

运行级别0：系统停机状态，系统默认运行级别不能设为0，否则不能正常启动

运行级别1：单用户工作状态，root权限，用于系统维护，禁止远程登陆

运行级别2：多用户状态(没有NFS)，不支持网络

运行级别3：完全的多用户状态(有NFS)，登陆后进入控制台命令行模式

运行级别4：系统未使用，保留

运行级别5：X11控制台，登陆后进入图形GUI模式

运行级别6：系统正常关闭并重启，默认运行级别不能设为6，否则不能正常启动

2）systemctl(CentOS7)

注册在系统中的标准化程序

有方便统一的管理方式（常用的方法

​ systemctl start 服务名(xxxx.service)

​ systemctl restart 服务名(xxxx.service)

​ systemctl stop 服务名(xxxx.service)

​ systemctl reload 服务名(xxxx.service)

​ systemctl status 服务名(xxxx.service)

查看服务的方法 /usr/lib/systemd/system

查看服务的命令

​ systemctl list-unit-files

systemctl list-unit-files |grep firewalld 查看防火墙的服务

​ systemctl –type service

通过systemctl 命令设置自启动

​ 自启动 systemctl enable xxxx.service

​ 不自启动 sysyemctl disable xxxx.service

运行级别

​ 开机 -> bios ->/boot -> systemd进程 -> 运行级别 -> 运行级对应的服务

查看默认级别 : vim /etc/linittab

第10章 查看端口号占用情况

netstat

查看系统的网络情况

-an 按一定顺序排列输出

-p 显示哪个进程在调用

netstat -anp|grep 8080 查看占用8080端口

第11章 Linux用户与权限管理

useradd 添加新用户

1．基本语法

​ useradd 用户名 （功能描述：添加新用户）

​ useradd -g 组名 用户名 （功能描述：添加新用户到某个组）

2．案例实操

​ （1）添加一个用户

[root@hadoop101 ~]# useradd tangseng

[root@hadoop101 ~]#ll /home/

passwd 设置用户密码

1．基本语法

​ passwd 用户名 （功能描述：设置用户密码）

2．案例实操

​ （1）设置用户的密码

[root@hadoop101 ~]# passwd tangseng

id 查看用户是否存在

1．基本语法

​ id 用户名

2．案例实操

​ （1）查看用户是否存在

[root@hadoop101 ~]#id tangseng

cat /etc/passwd 查看创建了哪些用户

1）基本语法

[root@hadoop101 ~]# cat /etc/passwd

su 切换用户

su: swith user 切换用户

1．基本语法

su 用户名称 （功能描述：切换用户，只能获得用户的执行权限，不能获得环境变量）

su - 用户名称 （功能描述：切换到用户并获得该用户的环境变量及执行权限）

2．案例实操

​ （1）切换用户

[root@hadoop101 ~]#su tangseng

[root@hadoop101 ~]#echo $PATH

/usr/lib64/qt-3.3/bin:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin

[root@hadoop101 ~]#exit

[root@hadoop101 ~]#su - tangseng

[root@hadoop101 ~]#echo $PATH

/usr/lib64/qt-3.3/bin:/usr/local/bin:/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/tangseng/bin

userdel 删除用户

1．基本语法

​ （1）userdel 用户名 （功能描述：删除用户但保存用户主目录）

（2）userdel -r 用户名 （功能描述：用户和用户主目录，都删除）

2．选项说明

表1-23

3．案例实操

（1）删除用户但保存用户主目录

[root@hadoop101 ~]#userdel tangseng

[root@hadoop101 ~]#ll /home/

（2）删除用户和用户主目录，都删除

[root@hadoop101 ~]#useradd zhubajie

[root@hadoop101 ~]#ll /home/

[root@hadoop101 ~]#userdel -r zhubajie

[root@hadoop101 ~]#ll /home/

who 查看登录用户信息

1．基本语法

​ （1）whoami （功能描述：显示自身用户名称）

（2）who am i （功能描述：显示登录用户的用户名）

2．案例实操

​ （1）显示自身用户名称

[root@hadoop101 opt]# whoami

（2）显示登录用户的用户名

[root@hadoop101 opt]# who am i

sudo 设置普通用户具有root权限

1．添加atguigu用户，并对其设置密码。

[root@hadoop101 ~]#useradd atguigu

[root@hadoop101 ~]#passwd atguigu

2．修改配置文件

[root@hadoop101 ~]#vi /etc/sudoers

修改 /etc/sudoers 文件，找到下面一行(91行)，在root下面添加一行，如下所示：

## Allow root to run any commands anywhere

root  ALL=(ALL)   ALL

atguigu  ALL=(ALL)   ALL

或者配置成采用sudo命令时，不需要输入密码

## Allow root to run any commands anywhere

root   ALL=(ALL)   ALL

atguigu  ALL=(ALL)   NOPASSWD:ALL

修改完毕，现在可以用atguigu帐号登录，然后用命令 sudo ，即可获得root权限进行操作。

3．案例实操

​ （1）用普通用户在/opt目录下创建一个文件夹

[atguigu@hadoop101 opt]$ sudo mkdir module

[root@hadoop101 opt]# chown atguigu:atguigu module/

usermod 修改用户

1．基本语法

usermod -g 用户组 用户名

2．选项说明

表1-24

3．案例实操

（1）将用户加入到用户组

[root@hadoop101 opt]#usermod -g root zhubajie

groupadd 新增组

1．基本语法

groupadd 组名

2．案例实操

​ （1）添加一个xitianqujing组

[root@hadoop101 opt]#groupadd xitianqujing

groupdel 删除组

1．基本语法

groupdel 组名

2．案例实操

​ （1）删除xitianqujing组

[root@hadoop101 opt]# groupdel xitianqujing

groupmod 修改组

1．基本语法

groupmod -n 新组名 老组名

2．选项说明

表1-25

3．案例实操

​ （1）修改atguigu组名称为atguigu1

[root@hadoop101 ~]#groupadd xitianqujing

[root@hadoop101 ~]# groupmod -n xitian xitianqujing

cat /etc/group 查看创建了哪些组

1．基本操作

[root@hadoop101 atguigu]# cat /etc/group

第12章 文件权限管理

1. 再说 ls -l
   

l 0-9位说明

第0位确定文件类型(d, - , l , c , b)

第1-3位确定所有者（该文件的所有者）拥有该文件的权限。—User

第4-6位确定所属组（同用户组的）拥有该文件的权限，—Group

第7-9位确定其他用户拥有该文件的权限 —Other

l 作用到文件

​ [ r ]代表可读(read): 可以读取,查看

​ [ w ]代表可写(write): 可以修改,但是不代表可以删除该文件,删除一个文件的前提条件 是对该文件所在的目录有写权限，才能删除该文件.

​ [ x ]代表可执行(execute):可以被系统执行

l 作用到目录

​ [ r ]代表可读(read): 可以读取，ls查看目录内容

​ [ w ]代表可写(write): 可以修改,目录内创建+删除+重命名目录

​ [ x ]代表可执行(execute):可以进入该目录

2. chmod
   

l 第一种方式：+ 、-、= 变更权限

​ u:所有者 g:所有组 o:其他人

a:所有人(u、g、o的总和)

​ chmod u=rwx,g=rx,o=x 文件目录名

​ chmod o+w 文件目录名

​ chmod a-x 文件目录名

l 第二种方式：通过数字变更权限

​ r=4 w=2 x=1 rwx=4+2+1=7

chmod u=rwx,g=rx,o=x 文件目录名

​ 相当于 chmod 751 文件目录名

3. chown
   

chown newowner file 改变文件的所有者

chown newowner:newgroup file 改变用户的所有者和所有组

-R 如果是目录 则使其下所有子文件或目录递归生效

4. chgrp
   

chgrp newgroup file 改变文件的所有组

第13章 rpm与yum

rpm

1. RPM（RedHat Package Manager），Rethat软件包管理工具，类似windows里面的setup.exe
   

是Linux这系列操作系统里面的打包安装工具，它虽然是RedHat的标志，但理念是通

用的。

2. 查询已安装的rpm列表 rpm –qa|grep xx
   

3. rpm包的名称：firefox-52.5.0-1.el7.centos.x86_64
   

​ 名称:firefox

​ 版本号：52.6.0-1

​ 适用操作系统: el7.centos.x86_64

​ 表示centos7.x的64位系统。

4. 安装rpm
   

​ rpm –ivh rpm的包名

​ -i 安装 install

​ -v 查看信息

​ -h 查看进度条

5. 卸载rpm
   

rpm -e RPM软件包

yum

YUM（全称为 Yellow dog Updater, Modified）是一个在Fedora和RedHat以及CentOS中的Shell前端软件包管理器。基于RPM包管理，能够从指定的服务器自动下载RPM包并且安装，可以自动处理依赖性关系，并且一次安装所有依赖的软件包，无须繁琐地一次次下载、安装，如图1-163所示

​

图1-163 YUM概述

1．基本语法

​ yum [选项] [参数]

2．选项说明

表1-52

3．参数说明

表1-53

4．案例实操实操

​ （1）采用yum方式安装firefox

[root@hadoop101 ~]#yum -y install firefox.x86_64

修改网络YUM源

默认的系统YUM源，需要连接国外apache网站，网速比较慢，可以修改关联的网络YUM源为国内镜像的网站，比如网易163。

1．前期文件准备

（1）前提条件linux系统必须可以联网

（2）在Linux环境中访问该网络地址：http://mirrors.163.com/.help/centos.html，在使用说明中点击CentOS6->再点击保存，如图1-164所示

图1-164 下载CentOS6

（3）查看文件保存的位置，如图1-165，1-166所示

图1-165 图1-166

在打开的终端中输入如下命令，就可以找到文件的保存位置。

[atguigu@hadoop101 下载]$ pwd

/home/atguigu/下载

2．替换本地yum文件

​ （1）把下载的文件移动到/etc/yum.repos.d/目录

[root@hadoop101 下载]# mv CentOS6-Base-163.repo /etc/yum.repos.d/

（2）进入到/etc/yum.repos.d/目录

[root@hadoop101 yum.repos.d]# pwd

/etc/yum.repos.d

（3）用CentOS6-Base-163.repo替换CentOS-Base.repo

[root@hadoop101 yum.repos.d]# mv CentOS6-Base-163.repo CentOS-Base.repo

3．安装命令

（1）[root@hadoop101 yum.repos.d]#yum clean all

（2）[root@hadoop101 yum.repos.d]#yum makecache

yum makecache就是把服务器的包信息下载到本地电脑缓存起来

4．测试

[root@hadoop101 yum.repos.d]#yum list | grep firefox

[root@hadoop101 ~]#yum -y install firefox.x86_64

第14章 搭建开发环境

首先通过xftp5复制文件到虚拟机opt目录上面

14.1 安装JDK

1. 将JDK解压缩到opt目录下
   

2. 配置环境变量 , vim /etc/profile
   

JAVA_HOME=/opt/jdk1.8.0_152

PATH=/opt/jdk1.8.0_152/bin:$PATH

export JAVA_HOME PATH

3. 配置完成后执行如下操作
   

安装完成注销重新登录一下

source /etc/profile

重启系统[最靠谱]

(注意如果javac没有效果是因为虚拟机只安装了jre没有安装)

yum install java-devel 安装原生的就行了

14.2 安装Tomcat

1. 解压缩到/opt
   

注意环境变量一定要配置正确，否则无法启动

2. 进入到Tomcat目录下的bin目录中,启动tomcat  ./startup.sh
   

14.3 安装MySql

14.3.1 检查工作(卸载mariadb和检查tmp文件夹权限)

l CentOS6

rpm -qa|grep -i mysql

如果存在mysql-libs的旧版本包如下：

请先执行卸载命令：rpm -e –nodeps mysql-libs

l CentOS7

rpm -qa|grep -i mariadb

如果存在如下：

请先执行卸载命令：rpm -e –nodeps mariadb-libs （nodeps 把关联的文件全部去掉）

l 检查/tmp文件夹权限

​ 执行 ：chmod -R 777 /tmp (-R代表目录下全部文件都生效)

14.3.2 安装MySQL

l 拷贝安装包到opt目录下

MySQL-client-5.5.54-1.linux2.6.x86_64.rpm

MySQL-server-5.5.54-1.linux2.6.x86_64.rpm

l 执行如下命令进行安装

rpm -ivh MySQL-client-5.5.54-1.linux2.6.x86_64.rpm

rpm -ivh MySQL-server-5.5.54-1.linux2.6.x86_64.rpm

1. 检查安装是否成功
   

l 安装完成后查看MySQL的版本

执行 mysqladmin –-version，如果打印出消息，即为成功

或者通过rpm查询

​ rpm –qa|grep –i mysql（-i 表示忽略大小写）

2. MySQL服务的启停
   

启动: service mysql start

停止: service mysql stop

3. 设置root用户的密码
   

mysqladmin -u root password ‘123123’

4. 登录MySQL
   

mysql -uroot -p123123

5. 建库
   

create database 库名

6. 建表
   

create table 表名 （字段名 字段类型（长度）约束 …）

7）字符集问题

查看字符集 show variables like ‘character%’;

查看MySQL的安装位置

修改字符集

将/usr/share/mysql/中的my-huge.cnf拷贝到/etc/下,改名为my.cnf（）

mv my-huge.cnf /etc/
mv my-huge.cnf my.cnf

​ tips：mysql启动时，会优先读取/etc/my.cnf文件

vim my.cof

在[client] [musqld] [mysql]中添加相关的字符集设置

[client]

default-character-set=utf8

[mysqld]

character_set_server=utf8

character_set_client=utf8

collation-server=utf8_general_ci

[mysql]

default-character-set=utf8

重启MySQL服务，查看字符集

查看某个数据库的编码

show create database mydb;

service mysql restart

​ 修改库的字符集

​ alter database 库名 character set ‘utf8’

​ 修改表的字符集

​ alter table 表名 convert to character set ‘utf8’;

(注意：原先写的数据库无法在进行修改)

8. 远程访问

l MySQL默认的root用户只允许本机登录，远程通过SQLyog工具不能登录.

l 查看MySQL mysql库中的用户表

列显示: select * from user\G;

查询常用字段: select host,user,password,select_priv from mysql.user;

l 创建可以远程访问的root用户并授予所有权限

grant all privileges on * . * to root@’%’ identified by ‘123123‘;

然后使用这个刷新

flush privileges

l 修改用户的密码

修改当前用户的密码

set password =password(‘123456’)

修改某个用户的密码

​ update mysql.user set password=password(‘123456’) where user=‘li4’;

l 注意: 所有通过user表的修改,必须使用flush privileges 命令才能生效.

第15章 修改主机名称

5.3.1 hostname 显示和设置系统的主机名称

\1. 基本语法

hostname （功能描述：查看当前服务器的主机名称）

\2. 案例实操

​ （1）查看当前服务器主机名称

[root@hadoop100 桌面]# hostname

5.3.2 修改主机名称

\1. 修改linux的主机映射文件（hosts文件）

（1）进入Linux系统查看本机的主机名。通过hostname命令查看

[root@hadoop100 桌面]# hostname

hadoop100

（2）如果感觉此主机名不合适，我们可以进行修改。通过编辑/etc/hostname文件

[root@hadoop100 桌面]# vim /etc/hostname

文件中内容

localhost.localdomain

（3）打开此文件后，可以看到主机名。修改此主机名为我们想要修改的主机名hadoop100。

（4）保存退出。

（5）打开/etc/hosts

[root@hadoop100 桌面]# vim /etc/hosts

添加如下内容

192.168.241.100 hadoop100 192.168.241.101 hadoop101 192.168.241.102 hadoop102 192.168.241.103 hadoop103 192.168.241.104 hadoop104 192.168.241.105 hadoop105 192.168.241.106 hadoop106 192.168.241.107 hadoop107 192.168.241.108 hadoop108

（6）并重启设备，重启后，查看主机名，已经修改成功

\2. 修改window7的主机映射文件（hosts文件）

​ （1）进入C:\Windows\System32\drivers\etc路径

​ （2）打开hosts文件并添加如下内容

192.168.241.100 hadoop100 192.168.241.101 hadoop101 192.168.241.102 hadoop102 192.168.241.103 hadoop103 192.168.241.104 hadoop104 192.168.241.105 hadoop105 192.168.241.106 hadoop106 192.168.241.107 hadoop107 192.168.241.108 hadoop108

\3. 修改window10的主机映射文件（hosts文件）

（1）进入C:\Windows\System32\drivers\etc路径

（2）拷贝hosts文件到桌面

​ （3）打开桌面hosts文件并添加如下内容

(注意你的主机名是什么就是什么)

192.168.241.100 hadoop100 192.168.241.101 hadoop101 192.168.241.102 hadoop102 192.168.241.103 hadoop103 192.168.241.104 hadoop104 192.168.241.105 hadoop105 192.168.241.106 hadoop106 192.168.241.107 hadoop107 192.168.241.108 hadoop108

（4）将桌面hosts文件覆盖C:\Windows\System32\drivers\etc路径hosts文件

测试：（相当于添加了Hadoop和192.168.241.100的映射关系,相当于localhost 就是 127.0.0.1）

第16章 crond系统定时任务

16.1 croud服务管理

重新启动crond服务

[root@hadoop101 ~]# service crond restart

16.2 crontab定时任务设置

1．基本语法

crontab [选项]

2．选项说明

3．参数说明

[root@hadoop101 ~]# crontab -e

（1）进入crontab编辑界面。会打开vim编辑你的工作。

* * * * * 执行的任务

表1-47

（2）特殊符号

表1-48

（3）特定时间执行命令

表1-49

4．案例实操

​ （1）每隔1分钟，向/root/bailongma.txt文件中添加一个11的数字

*/1 * * * * /bin/echo ”11” » /root/bailongma.txt

shell命令

Shell是一个命令行解释器，它接受应用程序/用户命令，然后调用操作系统内核

Shell还是一个功能相当强大的编程语言，易编写，易调试，灵活性强.

Linux提供的Shell解析器有：

[atguigu@hadoop101 ~]$ cat /etc/shells 

/bin/sh

/bin/bash

/sbin/nologin

/bin/dash

/bin/tcsh

/bin/csh

2. bash和sh的关系

[atguigu@hadoop101 bin]$ ll | grep bash

-rwxr-xr-x. 1 root root 941880 5月 11 2016 bash

lrwxrwxrwx. 1 root root   4 5月 27 2017 sh -> bash

3）Centos默认的解析器是bash

[atguigu@hadoop102 bin]$ echo $SHELL

/bin/bash

1 Shell 脚本入门

1.1 脚本格式

​ 脚本以#!/bin/bash开头（指定解析器）

1.2 第一个Shell脚本：helloworld

（1）需求： 创建一个Shell脚本，输出helloworld

（2）案例实操：

[atguigu@hadoop101 datas]$ touch helloworld.sh
[atguigu@hadoop101 datas]$ vi helloworld.sh

在helloworld.sh中输入如下内容
#!/bin/bash
echo "helloworld"

（3）脚本的常用执行方式

第一种：采用bash或sh+脚本的相对路径或绝对路径（不用赋予脚本+权限）

sh+脚本的相对路径

[atguigu@hadoop101 datas]$ sh helloworld.sh 
Helloworld

sh+脚本的绝对路径

[atguigu@hadoop101 datas]$ sh /home/atguigu/datas/helloworld.sh 
helloworld

bash+脚本的相对路径

[atguigu@hadoop101 datas]$ bash helloworld.sh 
Helloworld

bash+脚本的绝对路径

[atguigu@hadoop101 datas]$ bash /home/atguigu/datas/helloworld.sh 
Helloworld

第二种，采用输入脚本的绝对路径或相对路径执行脚本（必须具有可执行权限+x)

(a)首先要赋予helloworld.sh脚本的+x权限

[atguigu@hadoop101 datas]$ chmod +x helloworld.sh

(b)执行脚本

相对路径

[atguigu@hadoop101 datas]$ ./helloworld.sh 
Helloworld

绝对路径

[atguigu@hadoop101 datas]$ /home/atguigu/datas/helloworld.sh 
Helloworld

注意：第一种执行方法，本质是bash解析器帮你执行脚本，所有脚本本身不需要执行权限，第二种执行方法，本质是脚本需要自己执行，所以需要执行权限

2 变量

2.1 系统预定义变量

常用预定义变量

$HOME,$PWD,$SHELL,$USER等

案例实操：

（1）查看系统变量的值

[atguigu@hadoop101 datas]$ echo $HOME
/home/atguigu

(2)显示当前Shell中所有变量：set

[atguigu@hadoop101 datas]$ set   // ($相当于#)
BASH=/bin/bash
BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()

2.2 自定义变量

1**）基本语法**

（1）定义变量：变量=值

（2）撤销变量：unset 变量

（3）声明静态变量：readonly变量，注意：不能unset

2**）变量定义规则**

（1）变量名称可以由字母、数字和下划线组成，但是不能以数字开头，环境变量名建议大写。

（2）等号两侧不能有空格

（3）在bash中，变量默认类型都是字符串类型，无法直接进行数值运算。

（4）变量的值如果有空格，需要使用双引号或单引号括起来。

3**）案例实操**

（1）定义变量A

[atguigu@hadoop101 datas]$ A=5

[atguigu@hadoop101 datas]$ echo $A

5

（2）给变量A重新赋值

[atguigu@hadoop101 datas]$ A=8

[atguigu@hadoop101 datas]$ echo $A

8

（3）撤销变量A

[atguigu@hadoop101 datas]$ unset A

[atguigu@hadoop101 datas]$ echo $A

（4）声明静态的变量B=2，不能unset

[atguigu@hadoop101 datas]$ readonly B=2

[atguigu@hadoop101 datas]$ echo $B

2

[atguigu@hadoop101 datas]$ B=9

-bash: B: readonly variable

（5）在bash中，变量默认类型都是字符串类型，无法直接进行数值运算

[atguigu@hadoop102 ~]$ C=1+2

[atguigu@hadoop102 ~]$ echo $C

1+2

（6）变量的值如果有空格，需要使用双引号或单引号括起来

[atguigu@hadoop102 ~]$ D=I love banzhang

-bash: world: command not found

[atguigu@hadoop102 ~]$ D="I love banzhang"

[atguigu@hadoop102 ~]$ echo $D

I love banzhang

（7）可把变量提升为全局环境变量，可供其他Shell程序使用

export 变量名

[atguigu@hadoop101 datas]$ vim helloworld.sh 

在helloworld.sh文件中增加echo $B

#!/bin/bash

 

echo "helloworld"

echo $B

 

[atguigu@hadoop101 datas]$ ./helloworld.sh 

Helloworld

发现并没有打印输出变量B的值。

[atguigu@hadoop101 datas]$ export B

[atguigu@hadoop101 datas]$ ./helloworld.sh 

helloworld

2
export B 就可以使用了

2.3 特殊变量

1**）基本语法**

$n （功能描述：n为数字，$0代表该脚本名称，$1-$9代表第一到第九个参数，十以上的参数，十以上的参数需要用大括号包含，如${10}）

2**）案例实操**

[atguigu@hadoop101 datas]$ touch parameter.sh 

[atguigu@hadoop101 datas]$ vim parameter.sh

 

\#!/bin/bash

echo "$0 $1  $2"

 

[atguigu@hadoop101 datas]$ chmod 777 parameter.sh

 

[atguigu@hadoop101 datas]$ ./parameter.sh cls xz

./parameter.sh cls  xz

3.3.2 $#

1**）基本语法**

$# （功能描述：获取所有输入参数个数，常用于循环）。

2**）案例实操**

[atguigu@hadoop101 datas]$ vim parameter.sh

#!/bin/bash

echo "$0 $1  $2"

echo $#

 

[atguigu@hadoop101 datas]$ chmod 777 parameter.sh

 

[atguigu@hadoop101 datas]$ ./parameter.sh cls xz

parameter.sh cls xz 

2

3.3.3 $*、$@

1**）基本语法**

$* （功能描述：这个变量代表命令行中所有的参数，$*把所有的参数看成一个整体）

$@ （功能描述：这个变量也代表命令行中所有的参数，不过$@把每个参数区分对待）

2**）案例实操**

[atguigu@hadoop101 datas]$ vim parameter.sh

 

\#!/bin/bash

echo "$0 $1  $2"

echo $#

echo $*

echo $@

 

[atguigu@hadoop101 datas]$ bash parameter.sh 1 2 3

parameter.sh 1  2

3

1 2 3

1 2 3

3.3.4 $？

1**）基本语法**

$？ （功能描述：最后一次执行的命令的返回状态。如果这个变量的值为0，证明上一个命令正确执行；如果这个变量的值为非0（具体是哪个数，由命令自己来决定），则证明上一个命令执行不正确了。）

2**）案例实操**

判断helloworld.sh脚本是否正确执行

[atguigu@hadoop101 datas]$ ./helloworld.sh 

hello world

[atguigu@hadoop101 datas]$ echo $?

0

3 运算符

1**）基本语法**

“$((运算式))”或“$[运算式]”
expr +,-,\*,/,%   加 减 乘 除 取余

2**）案例实操：**

计算（2+3）X4的值

[atguigu@hadoop101 datas]# S=$[(2+3)*4]

[atguigu@hadoop101 datas]# echo $S
或者
[root@hadoop101 datas]# expr `expr 2 + 3` \* 4
20

计算（2+3）的值

[root@hadoop101 datas]# expr 2 + 3
5

4 条件判断

1)基本语法

(1)test condition

(2)[condition] (注意condition前后要有空格)

注意：条件非空即为true，【atguigu]返回true，【】返回false

2)常用判断条件

（1）两个整数之间比较

== 字符串比较

-lt 小于（less than）

-le 小于等于（less equal）

-eq 等于（equal）

-gt 大于（greater than）

-ge 大于等于（greater equal）

-ne 不等于（Not equal）

（2）按照文件权限进行判断

-r 有读的权限（read）

-w 有写的权限（write）

-x 有执行的权限（execute）

（3）按照文件类型进行判断

-f 文件存在并且是一个常规的文件（file）

-e 文件存在（existence）

-d 文件存在并是一个目录（directory）

3)案例实操

（1）23是否大于等于22

[root@hadoop101 ~]# [ 23 -ge 22 ] && echo "江豪迪最帅"
江豪迪最帅

（2）helloworld.sh是否具有写的权限

[root@hadoop101 datas]# [ -x helloworld.sh ] && echo "有执行权限"
有执行权限

(3) 判断helloworld.sh是否存在

[root@hadoop101 datas]# [ -e helloworld.sh ] && echo "文件存在"
文件存在

4）多条件判断（&& 表示前一条命令执行成功时，才执行后一条命令，|| 表示上一条命令执行失败后，才执行下一条命令）

[root@hadoop101 datas]# [ -d helloworld.sh ] || echo "不是目录"
不是目录

5 流程控制（重点）

5.1 if判断

if [ 条件判断式 ];then

程序

fi

或者

if [ 条件判断式 ]

then

程序

elif [ 条件判断式 ]

​ then

​ 程序

else

​ 程序

fi

​ 注意事项：

（1）[ 条件判断式 ]，中括号和条件判断式之间必须有空格

（2）if后要有空格

案例实操：

输入一个数，如果是1就输出输入的数字是1，如果输入的数字是2，就输入输入的数字是2，如果输入的数字是别的，就输出，输入的个数不是1也不是2

#!/bin/bash
if [ $1 -eq 1 ]
then
        echo "输入的数是1"
elif [ $1 -eq 2 ]
then
        echo "输入的数是2"
else
        echo "输入的数不是1也不是2"
fi

5.2 case语句

基本语法

case $变量名 in

“值1”）

如果变量的值等于值1，则执行程序1

;;

“值2”）

如果变量的值等于值2，则执行程序2

;;

…省略其他分支…

*）

如果变量的值都不是以上的值，则执行此程序

;;

esac

注意事项：

（1）case行尾必须为单词“in”，每一个模式匹配必须以右括号“）”结束。

（2）双分号“;;”表示命令序列结束，相当于java中的break。

（3）最后的“*）”表示默认模式，相当于java中的default。

案例实操

#!/bin/bash
case $1 in
1)
echo "小迪迪最帅"
;;
2)
echo "小迪迪天下第一帅"
;;
*)
echo "小迪迪变成一个土豪"
esac

5.3 for循环

for (( 初始值;循环控制条件;变量变化 )) do 程序 done

案例实操

(1)从1加到100

#!/bin/bash
s=0
for ((i=0;i<=100;i++))
do
        s=$[$s+$i]
done
echo $s

（2)比较$*和$@区别

$*和$@都表示传递给函数或脚本的所有参数，不被双引号“”包含时，都以$1 $2 …$n的形式输出所有参数

当它们被双引号“”包含时，“$*”会将所有的参数作为一个整体，以“$1 $2 …$n”的形式输出所有参数；“$@”会将各个参数分开，以“$1” “$2”…”$n”的形式输出所有参数。

#!/bin/bash
for i in $*
do
echo $i
done
for i in $@
do
echo $i
done
for i in "$*"
do
echo $i
done
for i in "$@"
do
echo $i
done

输出结果

[root@hadoop101 datas]# bash test3.sh 1 2 3 4 5
1
2
3
4
5
1
2
3
4
5
1 2 3 4 5
1
2
3
4
5

5.4 while循环

基本语法

while [ 条件判断式 ]

do

程序

done

案例实操 从1加到100

#!/bin/bash
a=0
b=1
while [ $b -le 100 ]
do
        a=$[$a+$b]
        b=$[$b+1]
done
echo $a
               

6 read读取控制台输入

基本语法

​ read(选项)(参数)

​ 选项：

​ -p:指定读取值时的提示符

​ -t:指定读取值时等待的时间（秒)

​ 参数:

​ 变量:指定读取值的变量名

案例实操

​ 提示7秒内，读取控制台输入的名称

#!/bin/bash
read -t 5 -p "请输入你的用户名" name
echo $name

7 函数

7.1 系统函数