一个在高压访问下，能承受很高峰值的访问并发才能称得上是一个好的网站，那么作为一个程序员，当你搭建好你的网站之后，你应该怎么测试你的网站并发访问量呢？

Apache Benchmark(简称ab) 是Apache安装包中自带的压力测试工具 ，简单易用。 使用起来非常的简单和方便。 不仅仅是可以apache服务器进行网站访问压力测试，还可以对其他类型的服务器进行压力测试。 比如nginx,tomcat,等



> 使用方式： ab -n 100 -c 100 http//:localhost:8080/xxxx

-n 请求数

-c 并发数量

localhost/ 压测url 域名后面要带上一个斜杠否则会报url无效

ab命令会创建多个并发访问线程，模拟多个访问者同时对某一URL地址进行访问。它的测试目标是基于URL的，因此，它既可以用来测试apache的负载压力，也可以测试nginx、lighthttp、tomcat、IIS等其它Web服务器的压力。

ab命令对发出负载的计算机要求很低，它既不会占用很高CPU，也不会占用很多内存。但却会给目标服务器造成巨大的负载，其原理类似CC攻击。自己测试使用也需要注意，否则一次上太多的负载。可能造成目标服务器资源耗完，严重时甚至导致死机。

![image.png](https://img.hacpai.com/file/2020/01/image-b103451f.png)

在Mac下可以直接使用，自带ab

在Linux下，如果是CentOS7

```bash
yum -y install httpd-tools
```

Windows下需要下载

![mark](https://img.zouchanglin.cn///20200202/s5VFREdHtQVL.png)

使用Apache-ab进行接口压测

1、在IDEA工具中开发代码

2、代码打成jar包

3、部署到Linux服务器上

4、如果用Docker(编写Dockerfile文件)

5、构建镜像

6、运行容器

现在使用IDEA集成Docker实现一键打包部署



1、Docker开启远程访问

修改Docker服务文件

```bash
vim /lib/systemd/system/docker.service
```

修改这一行

```bash
/usr/bin/dockerd-current -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock \
```

![mark](https://img.zouchanglin.cn///20200202/KtyowOyO5WDb.png)
2、重新加载配置文件

```bash
systemctl daemon-reload
```

3、重启Docker服务

```bash
systemctl restart docker
```

4、查看端口是否开启

```bash
netstat -nlpt
```

5、关闭防火墙

```bash
systemctl stop firewalld.service
```

6、禁止防火墙开机启动

```bash
systemctl disable firewalld.service
```

7、直接curl看看是否生效

```bash
curl http://127.0.0.1:2375/info
```

![mark](https://img.zouchanglin.cn///20200202/TvgYY7wFLwSN.png)

在IDEA中配置
![mark](https://img.zouchanglin.cn///20200202/l3XN0NnlJrV7.png)
![mark](https://img.zouchanglin.cn///20200202/POgGDx2FnnGU.png)
![mark](https://img.zouchanglin.cn///20200202/wtlEmDpmCkGY.png)
![mark](https://img.zouchanglin.cn///20200202/O8Mjbq1PXcbz.png)
传统过程中,打包、部署、上传到Linux、 编写Dockerfile、 构建镜像、创建容器运行。

而在持续集成过程中,项目工程一般使用Maven编译打包,然后生成镜像,通过镜像上线,能够大大提供上线效率,同时能够快速动态扩容，快速回滚,着实很方便。docker-maven-plugin 插件就是为了帮助我们在Maven工程中,通过简单的配置,自动生成镜像并推送到仓库中。

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> 
    </parent>
    <groupId>edu.xpu</groupId>
    <artifactId>docker</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>docker</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        
        <docker.image.prefix>zouchanglin</docker.image.prefix>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    
                    <imageName>${docker.image.prefix}/${project.artifactId}</imageName>
                    
                    <imageTags>
                        <imageTag>latest</imageTag>
                    </imageTags>
                    
                    <baseImage>java</baseImage>
                    
                    <maintainer>zouchanglin zchanglin3@gmail.com</maintainer>
                    
                    <workdir>/ROOT</workdir>
                    <cmd>["java", "-version"]</cmd>
                    <entryPoint>["java", "-jar", "${project.build.finalName}.jar"]</entryPoint>

                    
                    
                    
                    <dockerHost>http://192.168.70.128</dockerHost>

                    
                    <resources>
                        <resource>
                            <targetPath>/ROOT</targetPath>
                            
                            <directory>${project.build.directory}</directory>
                            
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
                <executions>
                    
                    <execution>
                        <id>build-image</id>
                        <phase>package</phase>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
```


如果用上述maven插件则会构造出这样的Dockerfile文件
```dockerfile
FROM java

MAINTAINER zouchanglin zchanglin3@gmail.com

WORKDIR /ROOT

ADD /ROOT/docker-0. 0.1-SNAPSHOT. jar /ROOT/

ENTRYPOINT ["java", "-jar", "docker-0.0. 1-SNAPSHOT. jar"]

CMD ["java", "-version"]
```
接下来使用命令构建镜像

mvn clean package docker:build

然后通过IDEA操作Docker去生成容器即可



绑定Docker命令道Maven各个阶段

我们可以绑定Docker命令到Maven各个阶段，我们可以把Docker分为buld、tag、 push ,然后分别绑定Maven的package、deploy 阶段，我们只需要执行mvn dep loy就可以完成整个build、tag、push操作了，当我们执行mvn build 就只完成build、tag 操作。

现在我们可以在mvn package的时候就完成镜像的打包
```xml
<executions>
 
	<execution>
	    <id>build-image</id>
    	<phase>package</phase>
    	<goals>
    		<goal>build</goal>
    	</goals>
    </execution>
</executions>
```

IDEA集成Docker实现一键打包部署

# Golang的优势和特点

* 可直接编译成机器码，不依赖其他库，glibc 的版本有一-定要求，部署就是扔一个文件上去就完成了
* 静态类型语言，但是有动态语言的感觉，静态类型的语言就是可以在编译的时候检查出来隐藏的大多数问题，动态语言的感觉就是有很多的包可以使用，写起来的效率很高。
* 语言层面支持并发，这个就是Go最大的特色，天生的支持并发。Go就是基因里面支持的并发，可以充分的利用多核，很容易的使用并发。
* 内置runtime，支持垃圾回收，这属于动态语言的特性之一吧，虽然目前来说GC(内存垃圾回收机制)不算完美，但是足以应付我们所能遇到的大多数情况，特别是Go1.1之后的GC
* 简单易学，Go语言的作者都有C的基因，那么Go自然而然就有了C的基因，那么Go关键字是25个，但是表达能力很强大，几乎支持大多数你在其他语言见过的特性:继承、重载、对象等
* 丰富的标准库，Go目前已经内置了大量的库，特别是网络库非常强大。
* 内置强大的工具，Go语言里面内置了很多工具链，最好的应该是gofmt工具，自动化格式化代码，能够让团队review变得如此的简单，代码格式一模一样，想不一样都很困难
* 跨平台编译，如果你写的Go代码不包含cgo，那么就可以做到window系统编译linux的应用，如何做到的呢? Go引用了plan9的代码，这就是不依赖系统的信息。
* 内嵌C支持，Go里面也可以直接包含C代码，利用现有的丰富的C库。



# Go适合用来做什么
* 服务器编程，以前你如果使用C或者C++做的那些事情，用Go来做很合适，例如处理日志、数据打包、虚拟机处理、文件系统等。

* 分布式系统，数据库代理器等。

* 网络编程，这一块目前应用最广，包括Web应用、API 应用、下载应用。

* 内存数据库，如google开发的groupcache, couchbase 的部分组件。

* 云平台，目前国外很多云平台在采用Go开发，CloudFoundy的部分组件，前VMare的技术总监自己出来搞的apcera云平台。


# golang开发环境搭建

下载 go1.13.6.windows-amd64.msi 下载地址是https://dl.google.com/go/go1.13.6.windows-amd64.msi
一路Next安装别有中文路径即可

![mark](https://img.zouchanglin.cn///20200202/9ro3AyTybG19.png)

入门成功
![mark](https://img.zouchanglin.cn///20200202/8KczoLKYfaHc.png)



另外还可以下载Go 的IDE，直接用LiteIDE就行了

 https://studygolang.com/pkgdoc  这里是golang的文档

比如我们可以查找fmt包

![mark](https://img.zouchanglin.cn///20200202/xsTynlBvacgK.png)


# golang简单语法

* 左括号和函数名称同行
* go语言以包作为管理单位，调用函数大部分需要导包
* 每个文件必须先声明包
* 程序必须有一个main包才能运行
* 注释和Java相同，`// `和`/**/`
* 导了包必须要使用，否则出错



# golang的包管理方式

一个包（文件夹）下之恩那个有一个main函数，在IDE的情况下

如果是非要放在一个包，可以直接go run **.go

如果需要一个可执行程序，那么可以go build xxx.go

# 关键字和常量

![mark](https://img.zouchanglin.cn///20200202/8RyM9aM5PPH8.png)


# 变量的使用

声明了变量必须要使用，只声明，没有初始化的变量默认为0

同一个{ }里，变量名是唯一的

![mark](https://img.zouchanglin.cn///20200202/wCkt2hEeWEM1.png)


直接看这段代码吧，比较好懂一点

```go
package main

import "fmt"
//注释
func main() {
	//声明变量默认为0
	var a int
	fmt.Println("a =", a)

	//同时声明多个变量
	var b, c int
	fmt.Println("b =", b, ",c =", c)

	//声明时赋值
	var d int = 10
	fmt.Println("d =", d)

	//先声明，再赋值
	var e int
	e = 20
	fmt.Println("e =", e)

	//类型自动推导
	f := "I' am string"
	fmt.Println("f =", f)

	//%T用于打印变量的类型
	fmt.Println("Type is %T=", f)
	fmt.Printf("Type is %T\n", f)
	fmt.Printf("Type is %T\n", a)

	//类型自动推导只能用于初始化那一次
	g := 100
	fmt.Println("g =", g)

	//g:= "a str"     -> error
	//fmt.Println("g =", g)
	g = 200
	//g = "a str" 赋值时改变类型 -> error

	//和C语言的printf()一样的
	fmt.Printf("%d %d %s", a, g, f)
	//fmt.Println()只是简单的拼接，不能使用%T去打印类型之类的信息，但是fmt.Printf()却可以
}
```

下面是一个变量交换的例子

```go
func main(){
	//-------------01----------
	//交换两个变量的值
	var a0 int = 10
	var b0 int = 20

	var tmp int = a0
	a0 = b0
	b0 = tmp
	fmt.Printf("a0=%d, b0=%d\n", a0, b0)

	//-------------02----------
	a1 := 10
	b1 := 20

	tmp1 := a1
	a1 = b1
	b1 = tmp1
	fmt.Printf("a1=%d, b1=%d\n", a1, b1)

	//-------------03----------
	a2, b2 := 10, 20
	a2, b2 = b2, a2
	fmt.Printf("a2=%d, b2=%d\n", a2, b2)

	//-------------04----------
	a3, b3, c3 := 10, 20, 30
	a3, b3, c3 = c3, a3, b3
	fmt.Printf("a3=%d, b3=%d, c3=%d\n", a3, b3, c3)
}
```

匿名变量

![mark](https://img.zouchanglin.cn///20200202/OcrNI6x6NrJ8.png)


比如下面这样的

![mark](https://img.zouchanglin.cn///20200202/r0Kbited4Oiu.png)


# 常量的使用

变量声明为var、常量声明为const

![mark](https://img.zouchanglin.cn///20200202/isHLye0Mi3kQ.png)


注意常量的类型自动推导不能使用 `:=` 

而且常量定义完了可以不使用，变量必须使用

# 多个变/常量的声明

```go
package main

import "fmt"

func main() {
	a, b := 10, 10.25

	fmt.Printf("a = %d, b = %f \n", a, b)
	fmt.Println("b =", b)

	//一次声明多个变量
	var (
		c int
		d float64
	)
	c = 10
	d = 99.99
	fmt.Printf("c = %d, d = %f \n", c, d)

	//一次声明多个变量并赋值
	var (
		e int = 10
		f float64 = 30.00
	)
	fmt.Printf("e = %d, f = %f \n", e, f)

	//一次声明多个常量
	const (
		g int = 10
		h int = 20
	)
    
	//一次声明多个常量并自动推导类型
	const (
		i = 10
		j = 20
	)
	fmt.Printf("g = %d, h = %d \n", g, h)
}
```

# 枚举的使用

```go
package main

import "fmt"

func main() {

    //iota给常量赋值使用
	const (
		a = iota
		b = iota
		c = iota
	)

	fmt.Printf("a=%d, b=%d, c=%d", a, b, c) //a=0, b=1, c=2
}
```

iota 是一个常量自动生成器，每隔一行自动加一

iota遇到const，则重置为0

```go
package main

import (
	"fmt"
)

func main() {

	const (
		a = iota
		b = iota
		c = iota
	)

	fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c) // a=0, b=1, c=2

	//iota遇到const重置为0
	const d  = iota
	fmt.Printf("d=%d\n", d) // d=0

	//如果是同一行，值都一样
	const e, f, g = iota, iota, iota
	fmt.Printf("e=%d, f=%d, g=%d\n", e, f, g) // e=0, f=0, g=0

	const (
		h, i, j = iota, iota, iota
	)
	fmt.Printf("h=%d, i=%d, j=%d\n", h, i, j) // h=0, i=0, j=0

	const (
		k = iota
		l, m = iota, iota
		n = iota
	)
	fmt.Printf("k=%d, l=%d, m=%d, n=%d\n", k, l, m, n) // k=0, l=1, m=1, n=2
}
```

# golang基本数据类型

![mark](https://img.zouchanglin.cn///20200202/G9zsdlj1pp42.png)


```go
package main

import "fmt"

func main() {

	//-----bool类型----------
	var a = false
	fmt.Println(a) //false

	b := true
	fmt.Println(b) //true

	var c bool
	fmt.Println(c) //false

	//-----浮点类型----------

	var d = 3.14 //这样赋值默认是float64
	fmt.Println(d)
	fmt.Printf("%T\n", d)

	var e float32
	fmt.Println(e)
	fmt.Printf("%T\n", e)

	f := 10.00 //这样赋值默认是float64
	fmt.Println(f)
	fmt.Printf("%T\n", f)

	//-----字符类型----------
	var a1 byte
	a1 = 'a'
	fmt.Println(a1) //97
	fmt.Printf("a1=%d,  a1=%c\n", a1, a1) //a1=97,  a1=a
	fmt.Printf("%T\n", a1)

	b1 := 'A'
	fmt.Printf("b1 = %c\n", b1)
	fmt.Printf("b1 = %c\n", b1 + ('a'-'A'))

	//-----字符串类型----------
	a2 := "Tim"
	fmt.Println(a2)
	// len()测字符串长度
	fmt.Println(len(a2))

	//打印字符串中的某一个字符
	fmt.Printf("a2[2] = %c\n", a2[2]) //a2[2] = m
	//fmt.Printf("a2[3] = %c", a2[3]) error 越界

	//-----复数类型----------
	a3 := 2.1 + 3i
	fmt.Println(a3) //(2.1+3i)

	var b3 complex128 = 2.5 + 3i
	fmt.Println(b3) //(2.5+3i)

	//通过内建函数取实部和虚部
	fmt.Println("实部 real(b3) =", real(b3), "虚部 imag(b3) =", imag(b3))
	//实部 real(b3) = 2.5 虚部 imag(b3) = 3
}
```

## 格式化输出

![mark](https://img.zouchanglin.cn///20200202/ABBAv30fXB6a.png)


## 键盘输入

```go
package main

import "fmt"

func main() {
	var name string;
	fmt.Scanf("%s", &name) //手动输入格式
	fmt.Scan(&name) //自动匹配格式

	fmt.Printf("name=%s\n", name)
}
```

## 类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。

```go
package main

import "fmt"

func main() {
	var a byte = 'A'

	//类型转换
	var b int = int(a)

	fmt.Printf("%T\n", a) //uint8
	fmt.Printf("%T\n", b) //int
}
```

## 类型别名

```go
package main

import "fmt"


func main() {
	type bigint int64

	var a bigint = 100
	fmt.Printf("%T\n", a) //main.bigint

	//一次取多个别名
	type (
		long int64
		char byte
	)

	var b char = 'A'
	var c long = 100
	fmt.Printf("b=%c, type=%T\n", b, b) //b=A, type=main.char
	fmt.Printf("c=%d, type=%T\n", c, c) //c=100, type=main.long
}
```

# golang的运算符

和c语言一样，*取值，&取地址

在go语言中，一元运算符拥有最高的优先级，二元运算符的运算方向均是从左至右。

![mark](https://img.zouchanglin.cn///20200202/4I2BQQE9kIaT.png)


# golang流程控制

## if if..else

```go
package main

import "fmt"

func main() {

	//简单的if语句判断
	var name string
	name = "ABC"
	if name == "ABC" {
		fmt.Println("相等")
	}

	//if支持一个初始化语句
	if a := 10; a == 10{
		fmt.Println("a==10")
	}

	//if多分支
	name = "AAA"
	if name == "ABC" {
		fmt.Println("相等")
	}else {
		fmt.Println("不相等")
	}


	name = "CCC"
	if name == "ABC" {
		fmt.Println("name=ABC")
	}else if name == "AAA" {
		fmt.Println("name=AAA")
	}else if name == "BBB" {
		fmt.Println("name=BBB")
	}else {
		fmt.Println("Other")
	}
}
```

## switch

```go
package main

import "fmt"

func main() {
	a := 12
	switch a {
	case 10:
		fmt.Println("a=10")
	case 20:
		fmt.Println("a=20")
	case 30:
		fmt.Println("a=30")
	default:
		fmt.Println("Default")
	}
}
```

可以看出没有写break，go语言保留了break关键字，不写break，默认也包含break

fallthrough 关键字的作用：不跳出switch，还要执行紧随其后的一个分支

![mark](https://img.zouchanglin.cn///20200202/qaU0PfTudHWO.png)


```go
func main() {
	//同样的，switch也是支持一个初始化语句的
	switch a := 10; a {
	case 10:
		fmt.Println("a=10")
	case 20:
		fmt.Println("a=20")
	case 30:
		fmt.Println("a=30")
	default:
		fmt.Println("Default")
	}
}
```

switch可以没有条件

```go
package main

import "fmt"

func main() {

	var score int
	//switch可以没有条件
	switch {
	case score > 90:
		fmt.Println("优秀")
	case score > 60 && score <= 90:
		fmt.Println("及格")
	default:
		fmt.Println("不及格")
	}
}
```

## for

```go
package main

import "fmt"

func main() {
	num := 0
	for i:=1; i<= 100; i++{
		num += i
	}
	fmt.Printf("num=%d\n", num) //5050
    
    //死循环的写法
    for{
        //TDDO...
    }
}
```

## range

关键字range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值:

支持string、array、slice、map

```go
package main

import "fmt"

func main() {
    
	str := "GoLand"
	//01 传统写法
	for i:=0; i<len(str); i++{
		fmt.Printf("%c ",str[i])
	}
	fmt.Println()

	//02 迭代写法
	for i := range str{
		fmt.Printf("%c ",str[i])
	}
	fmt.Println()

	//range返回两个值，一个是index、一个是元素本身
	//支持string、array、slice、map
	for i, data := range str{
		fmt.Printf("%d-%c\n",i, data)
	}
}
```

## goto

和C语言的一样的：

![mark](https://img.zouchanglin.cn///20200202/1RN6UjLr7nGF.png)

Golang编程入门

Nginx在CentOS上安装可以使用yum或源码安装，推荐使用源码安装的方式，因为yum的版本比较旧，而且使用源码可以自定义功能，方便业务的上的使用，源码安装需要提前准备标准的编译器和依赖即可。下面记录一下如何编译安装Nginx，避免在安装时各种缺少依赖库的情况！



# 安装Nginx

1、安装gcc编译器

```bash
yum -y install gcc
```

2、nginx的http模块使用pcre来解析正则表达式，所以需要安装pcre库

```bash
yum install -y pcre pcre-devel
```

3、 nginx使用zlib对http包的内容进行gzip，所以需要安装zlib

```bash
yum install -y zlib zlib-devel
```

4、openssl是nginx的https模块需要的，所以需要安装openssl

```bash
yum install -y openssl openssl-devel
```

5、下载Nginx源码包

```bash
wget http://nginx.org/download/nginx-1.9.9.tar.gz
```

6、把压缩包解压缩到 /usr/local下

```bash
tar -zxvf  nginx-1.9.9.tar.gz
mv nginx-1.9.9 /usr/local/
```

7、进入/usr/local/nginx-1.9.9

```bash
cd /usr/local/nginx-1.9.9
```

8、编译安装

```bash
./configure

make

make install
```

9、安装完成不想配置环境变量的话可以建立软链接

```bash
ln -s /usr/local/nginx/sbin/nginx /usr/local/bin/nginx
```

10、配置文件的修改

```bash
cp /usr/local/nginx/conf/nginx.conf /usr/local/nginx/conf/nginx.conf.back
vim /usr/local/nginx/conf/nginx.conf
```



# 启动/停止

1、启动

```bash
nginx
```

2、 快速停止

```bash
nginx -s stop
```

3、正常停止

```bash
nginx -s quit
```

4、重新加载配置文件

```bash
nginx -s reload
```



# 配置HTTPS

上面讲述了如何编译安装Nginx，要想用HTTPS， 我们只需要在原有的基础上添加ssl模块就行了

来到解压目录

```
cd /usr/local/nginx-1.9.9
```

```bash
./configure --with-http_ssl_module

make
```

停止Nginx

```bash
nginx -s stop
```

把之前的nginx先备份一下，然后把新的程序复制过去覆盖之前的即可

```
cp /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.bak

cp objs/nginx /usr/local/nginx/sbin/nginx
```

接下来配置证书

![mark](https://img.zouchanglin.cn///20200203/1h2j8EyUrJtw.png)

解压后得到两个文件，放在服务器的任意目录

![mark](https://img.zouchanglin.cn///20200203/WVe422kK1PcT.png)

接下来就是修改Nginx的配置文件

```nginx
#user  nobody;
user root;
worker_processes  2;

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  zouchanglin.cn;
		return 301 https://zouchanglin.cn;
        
    }
	# HTTPS server
    server {
        listen       443;
        server_name  zouchanglin.cn;
		
		ssl on;
        ssl_certificate      /root/nginx.crt;
        ssl_certificate_key  /root/nginx.key;

        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;

        ssl_ciphers  HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers  on;

        location / {
            root   /root/hexo/public;
            index  index.html index.htm;
        }
    }
}
```

注意 ssl on; 这个配置一定要加上！

CentOS7编译安装Nginx

## 0、浏览器跨域问题

看到浏览器报Access-Control-Allow-Origin毫无疑问了，看来是跨域问题

![mark](https://img.zouchanglin.cn///20200202/2n3Iw8bl3nIN.png)


CORS是一种访问机制，英文全称是Cross-Origin Resource Sharing，即我们常说的跨域资源共享，通过在服务器端设置响应头，把发起跨域的原始域名添加到Access-Control-Allow-Origin 即可

浏览器端：发送AJAX请求前需设置通信对象XHR的withCredentials 属性为true。

服务器端：设置Access-Control-Allow-Credentials为true。

两个条件缺一不可，否则即使服务器同意发送Cookie！



`Access-Control-Allow-Methods` 表示允许哪些跨域请求的提交方式。（例如GET/POST）

`Access-Control-Allow-Headers`  表示跨域请求的头部的允许范围。

`Access-Control-Expose-Headers` 表示允许暴露哪些头部信息给客户端。

`Access-Control-Max-Age` 表示预检请求的最大缓存时间。

## 1、返回新的CorsFilter

这是一种全局跨域的方式

在任意配置类，返回一个新的CorsFilter Bean，并添加映射路径和具体的CORS配置信息。

```java
package edu.xpu.cors.config;

@Configuration
public class GlobalCorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        //1.添加CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
          //放行哪些原始域
          config.addAllowedOrigin("*");
          //是否发送Cookie信息
          config.setAllowCredentials(true);
          //放行哪些原始域(请求方式)
          config.addAllowedMethod("*");
          //放行哪些原始域(头部信息)
          config.addAllowedHeader("*");
          //暴露哪些头部信息（因为跨域访问默认不能获取全部头部信息）
          config.addExposedHeader("*");

        //2.添加映射路径
        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);

        //3.返回新的CorsFilter.
        return new CorsFilter(configSource);
    }
}
```

## 2、重写WebMvcConfigurer

在任意配置类，返回一个新的WebMvcConfigurer Bean，并重写其提供的跨域请求处理的接口，目的是添加映射路径和具体的CORS配置信息。

```java
package edu.xpu.cors.config;

@Configuration
public class GlobalCorsConfig {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            //重写父类提供的跨域请求处理的接口
            public void addCorsMappings(CorsRegistry registry) {
                //添加映射路径
                registry.addMapping("/**")
                        //放行哪些原始域
                        .allowedOrigins("*")
                        //是否发送Cookie信息
                        .allowCredentials(true)
                        //放行哪些原始域(请求方式)
                        .allowedMethods("GET","POST", "PUT", "DELETE")
                        //放行哪些原始域(头部信息)
                        .allowedHeaders("*")
                        //暴露哪些头部信息（因为跨域访问默认不能获取全部头部信息）
                        .exposedHeaders("Header1", "Header2");
            }
        };
    }
}
```