![mark](https://img.zouchanglin.cn///20200207/ecqoKhvvOaPQ.png)

## 什么是康威法则

最开始是一个叫康威的人，他原来是一个程序员，在1967年的时候提出来。康威法则我们认为它是微服务的理论基础。康威法则的原话是这样讲的，**设计系统的组织，其产生的设计和架构等价于组织的组织架构。**



## 康威法则和微服务

为什么这么说呢？今天主要就是介绍康威法则和微服务之间的一个关系。

一个互联公司在刚开始的时候业务量一般是不大的，刚开始的时候他是尝试业务模式能不运行能起来，所以他一开始的时候开发的系统一定是一个简单的单块系统，这个时候他的团队规模不大，一般就几十个人或者是有限的几个。随着业务规模越来越大，团队肯定也会扩大规模，需要两个、三个、甚至几十个团队来协同那么这个时候，如果你的系统架构仍然是单块，然后他就跟分散式的多团队之间产生了一种不匹配的情况。

就所谓的违反了我们的康威法则，该架构它没有反应组织的这个组织架构。这时候就会出现，矛盾协调成本很高，交付效率很低，假如有一个单块的一个大型的服务，但是那有好多个团队，可能有七八个甚至十几个团队围绕的这个单块这个架构进行开发，当其中一个团队对这个单块应用进行了一些升级，而引入一些新的功能往往，需要其他的团队来协作配合，做集成测试，才能够交付。以这个时候团队之间的协调成本很高，有的时候甚至还会产生摩擦。也就是说我们的单块应用和多团队之间产生了一种不匹配的情况，康威法则怎么来解决这个问题？

怎么解决呢？微服务是解决的一个手段，我们把这个单块的这个应用把它拆解出来。拆分成若干个微服务。每个团队负责维护自己的服务，相互之间不干扰。当S1在这个团队在开发它自己的服务的时候，不需要其他的团队都得一起来，或者说这种配合的沟通协商成本比较小，还可以去独立的迭代和交付自己的微服务。那么这个时候就会发现，多团队和多模块之间的这个结构关系又能够映射起来，它符合了康威法则，然后整体的研发的效率，对业务的支持就更高效。

所以介绍的这个即将康威法则法则是这样描述的，设计系统的组织，其产生的设计和架构等价于组织的组织架构，架构师不仅仅要做好技术价格，同时要了解组织的组织架构！

康威法则与微服务

![mark](https://img.zouchanglin.cn///20200206/AgFyrep334cb.png)

本篇主要讲述了微服务架构的组成，每个组件的作用是什么，重点是实现了Eureka Server和Eureka Client的实战演练，总体来说服务注册与发现就是微服务入门的基础，了解并掌握了在SpringCloud体系中的服务注册与发现的组件原理以及使用方法，由于start.spring.io的访问速度实在是不能忍，白天自己编译了整个SpringBoot的初始化器，我直接给出地址了，方便其他的朋友也可以用：

* `http://139.159.234.67:8080`
* `http://zouchanglin.cn:8080`  就是上面的IP地址

如果还是很慢的话，可以下载我编译好的文件（[下载地址]( https://img.zouchanglin.cn/Spring-Initializr.jar )），直接

```
java -jar Spring-Initializr.jar
```

在IDEA自定义初始化器地址填写 http://localhost:8080 即可，注意这个版本是没有Web UI的，只有供三分初始化器使用的JSON串，Web UI几乎不咋用所以没考虑编译进来！



# 简单的微服务架构

微服务架构的基础框架/组件

### 服务注册与发现

服务提供了肯定要注册上来，并且把自己的地址信息表现出来，然后服务的调用方才能从这个组件上发现目标服务

### 服务网关 Service GateWay

服务不但要内部能访问到，而且肯定有一部分服务需要暴露给外界，所以这就是服务网关的通俗理解，服务网关是连接内外的大门，网关会屏蔽后台服务的一些细节，比如后台的程序要升级呀对外用户是无感知的，还有路由的功能，可以将外部的请求反向路由到内部的某个具体的微服务，还可以做一些限流和容错的功能，因为所有请求都会经过网关，所以可以控制流量，监控和日志也可以在这个里完成，用户认证、授权、反爬虫之类都是在服务网关完成的，作用是非常巨大的

### 后端通用服务

也称为中间层服务 Middle Tier Service，把自己注册到服务注册表

### 前端服务

也成为边缘服务 Edge Servcice，从服务注册于发现组件中调用自己想要的后端服务

![mark](https://img.zouchanglin.cn///20200206/NMYG4fPq8mHe.png)

微服务是一种架构，具体实现主要分为阿里系和SpringCloud系，阿里系主要使用Dubbo做服务治理，使用ZK做服务注册中心，在17年左右Dubbo死而复生之后就疯狂的更新，很多公司也在用Dubbo做服务治理；拎一个系列那就是SpringCloud系列，也就是SpringCloud全家桶，Spring Cloud是一个开发工具集，包含多个子项目，利用SpringBoot的开发便利，主要是对Netflix开源组件的进一步封装，基本囊括了微服务所需要的绝大部分功能组件，Spring Cloud简化了分布式应用的开发，需要更加深刻的理解分布式架构的特点！

# 服务注册与发现

SpringCloud Eureka，基于Netflix Eureka做的二次封装，主要有两个组件构成

* Eureka Server 注册中心
* Eureka Client 服务注册

服务端就是供服务注册的服务器，客户端用来简化与服务器的交互，作为轮询负载均衡器，并提供服务的自动切换功能，客户端连接到服务注册中心并维持心跳连接，Eureka就能够监控系统中的服务是否正常工作

## Eureka Server

Eureka这个单词的意思就是找到了，有了的意思

首先是吧SpringBoot和SpringCloud的版本对应起来，否则可能会造成很多意料之外的错误，比如eureka注册了结果找不到服务类啊，比如某些Jar导入不进来啊，等等这些错误，下图是对应关系，SpringCloud的版本名称是按照伦敦地铁站的名字命名的：

![mark](https://img.zouchanglin.cn///20200206/jV2U04T8UC0x.png)

我这里选择的是Finchley的版本

![mark](https://img.zouchanglin.cn///20200206/Iviqn5i8WQxL.png)

接下来需要开启SpringBoot项目中的Eureka Server

只需要在启动类上注解 @EnableEurekaServer 即可，同时，一个Eureka作为Server也作为一个Client，所以需要自己注册自己，需要在配置文件中添加图如下配置（添加spring application name就是为了让注册实例的Name不是UNKOWN）：

```yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8080/eureka

spring:
  application:
    name: eureka
```

启动之后访问localhost:8080即可看到

![mark](https://img.zouchanglin.cn///20200206/IEydyyD6qRSn.png)

但是作为注册中心，我又不想在页面上把它当作一个注册实例，那么添加如下配置

```yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8080/eureka
    register-with-eureka: false
```

因为Eureka的默认端口是8761，所以这里也改一改

```yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
    register-with-eureka: false
spring:
  application:
    name: eureka
    
server:
  port: 8761
```

## Eureka Client

首先通过SpringBoot创建一个工程，选择Eureka Discovery Client，我试过目前最新版只有spring-boot-starter-web也勾上才可以，不然直接启动失败！

![mark](https://img.zouchanglin.cn///20200206/2Ol5OW8J5LWf.png)

接下来在启动类配置@EnableDiscoveryClient，代表这是一个Eureka Client，然后配置文件如下

```yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

spring:
  application:
    name: client-01
```

打开我们之前配置的Eureka Server，因为Eureka Server的地址是 `http://localhost:8761/eureka/` 所以在配置的时候需要配置这个地址，因为你要像Eureka Server去注册，然后给自己起个名字叫做 client-01

接下来先开启Eureka Server，我为了方便启动，直接打成了Jar包，并做成了脚本放在桌面上！

然后启动client-01，然后打开localhost:8761 就看到了Eureka Client

![mark](https://img.zouchanglin.cn///20200206/NfEWjEcpUKNi.png)

![mark](https://img.zouchanglin.cn///20200206/lzzIrmoTz4u0.png)

如果频繁重启Client端，注意到会有这样的问题

![mark](https://img.zouchanglin.cn///20200206/itOCIQ1ffhrc.png)

Eureka Server 和 Eureka Client采用的是心跳检测连接，Server端不会停的检查Client是否存活，会在一定的时间统计Client端的上线率，这个上线率就是一个比例，当低于某个比例的时候就会爆出这样的警告，意思就是Client的上线率太低了，可能某个时间点就不知道你是上线还是下线，那么我就当作你是上线的，俗话讲就叫宁可信其有，不可信其无，实际上是它的一种自我保护模式，在开发环境可以把它关掉，避免显示的是在线但实际上却不在线的情况，所以在开发环境最好是把这种模式给关掉！现在来到Eureka Server端，加入配置：

```yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
    register-with-eureka: false
  server:
    enable-self-preservation: false # 关闭这种自我保护机制
spring:
  application:
    name: eureka

server:
  port: 8761
```

记住生成环境不要做这样的配置，在关闭这种机制之后呢，又会出现这样的警告，无需关闭，它就是告诉我们不建议关闭这个机制，但是开发环境就这样配置很有必要的！

![mark](https://img.zouchanglin.cn///20200206/HaFXc52AQ5wd.png)

服务注册与发现

Java作为一门世界级主流编程语言，有一款高效易用的项目管理工具是Java开发者共同追求的心愿和目标。
先是2000年Ant，后有2004年Maven两个工具的诞生，都在Java市场上取得了巨大的成功。但是二者都有一定的不足和局限性。

![mark](https://img.zouchanglin.cn///20200205/KJPOqeL3Ikfs.png)



## Gradle简介

2012年基于Ant和Maven产生的Gradle，弥补了Ant和Maven的不足，带来了一些更高效的特点。它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，抛弃了基于XML的各种繁琐配置。面向Java应用为主。当前其支持的语言限于Java、Groovy和Scala，计划未来将支持更多的语言。



## Gradle安装配置(Windows版)

很简单，下载之后解压，需要把目录配置到环境变量中：配置 GRADLE_HOME，然后在PATH中添加配置：%GRADLE_HOME%\bin，打开命令行：

![mark](https://img.zouchanglin.cn///20200205/bzBxEhJUzTRD.png)

出现上图即是配置成功

## Gradle和idea集成

对于IDEA 2019.3 无需集成，只要配置了GRADLE_HOME环境变量，一切都是自动的

## Groovy语言简单介绍

![mark](https://img.zouchanglin.cn///20200205/tTLYwGWp90R5.png)

先打开上面的命令行，接下来开始学习groovy编程语言

```groovy
//介绍groovy编程语言
println("hello groovy")

println "hello groovy!"

//groovy定义变量
def i = 18
println "i = " + i

//定义集合类型
def list = ['a', 'b', 'c']

//往list里面添加元素
list << 'd'

//取出第三个元素
println "list.get(3) = " + list.get(3)

//定义一个map
def map = ['name': 'Tim', 'age': 18]
//向map中添加 K-V
map.sex = '男'

println map
```

点击右上角的箭头即可执行

![mark](https://img.zouchanglin.cn///20200205/EeT9nL0FrKH8.png)

Groovy的闭包

```groovy
//介绍groovy的闭包
//闭包的概念：闭包其实就是一段代码块在gradle中把闭包当作参数使用

def b1 = {
    println ("Hello b1")
}

//定一个方法，方法里需要闭包类型的参数
def method1(Closure closure){
    closure()
}

//调用方法method1
method1(b1)	 //输出：Hello b1

//带参数的闭包
def b2 = {
    v ->
        println("Hello ${v}")
}
//定一个方法，方法里需要闭包类型的参数
def method2(Closure closure){
    closure("Tim")
}

method2(b2) //输出：Hello Tim
```

## Gradle仓库的配置

```groovy
plugins {
    id 'java'
}

/**
 * 自己填写的一些信息
 */
group 'xpu.edu'
version '1.0-SNAPSHOT'


sourceCompatibility = 1.8

/**
 * 指定所使用的参数仓库路径
 * mavenCentral()表示使用中央仓库，从中央仓库下载到指定目录
 */
repositories {
    //先从本地仓库寻找依赖，如果没有再从中央仓库下载
    mavenLocal()
    mavenCentral()
    //如果只设置中央仓库，表示直接从中央仓库下载Jar包
}
/**
 * Gradle工程的所有的Jar包的坐标都在dependencies属性内放置的
 * 每个Jar包的坐标都有三个基本元素组成
 * group、name、version 这和maven是一致的
 * testCompile表示该Jar包在测试的时候使用，也就是Jar包的作用域
 * 我们在Gradle里面添加坐标的时候都要添加作用域
 */
dependencies {
    compile group: 'com.alibaba', name: 'fastjson', version: '1.2.58'
   
    compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.19'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}
```

如何设置本地仓库呢？

只需要设置GRADLE_USER_HOME 这个环境变量即可，把GREADLE_USER_HOME环境变量设置到自己本地的Maven仓库路径即可！

## 配置阿里云仓库

```groovy
repositories {
    maven { 
        url "http://maven.aliyun.com/nexus/content/groups/public/" 
    }
}
```

这样配置是对当前工程生效，但是新建Gradle工程后又需要在配置一次

所以需要在Gradle的安装目录下的init.d文件夹里新建一个名称为init.gradle的文件，写入如下内容

```groovy
allprojects {  
    repositories {  
        maven {  
             name "aliyunmaven"  
             url "http://maven.aliyun.com/nexus/content/groups/public/"  
        }
    }
}
```

Gradle的使用和配置

## 工作区介绍

**Go代码必须放在工作区中。** 工作区其实就是一个对应于特定工程的目录，它应包含3个子目录: src目录、pkg目录和bin目录。

* src目录：用于以代码包的形式组织并保存Go源码文件。 (比如: `.go` `.c` `.h` `.s`等)
* pkg目录：用于存放经由go install命令构建安装后的代码包(包含Go库源码文件)的`.a`归档文件
* bin目录：与pkg目录类似，在通过go install命令完成安装后，保存由Go俞令源码文件生成的可执行文件

目录src用于包含所有的源代码，是Go命令行工具一个强制的规则，而pkg和bin则无需手动创建，如果必要Go命令行工具在构建过程中会自动创建这些目录

**需要特别注意的是，只有当环境变量GOPATH中只包含一个工作区的目录路径时，go install命令才会把命令源码安装到当前工作区的bin目录下。若环境变量GOPATH中包含多个工作区的目录路径，像这样执行go install命令就会失效，此时必须设置环境变量GOBIN。**



## GOPATH设置

为了能够构建这个工程，需要先把所需工程的根目录加入到环境变量GOPATH中。否则，即使处于同一工作目录(工作区)，代码之间也无法通过绝对代码包路径完成调用。

在实际开发环境中，工作目录往往有多个。这些工作目录的目录路径都需要添加至GOPATH。当有多个目录时，请注意分隔符，多个目录的时候Windows是分号，Linux 系统是冒号，当有多个GOPATH时，默认会将go get的内容放在第一个目录下。

## 自定义包

所有Go语言的程序都会组织成若干组文件，每组文件被称为一个包。这样每个包的代码都可以作为很小的复用单元，被其他项目引用。

一个包的源代码保存在一个或多个以`.go`为文件后缀名的源文件中，通常一个包所在目录路径的后缀是包的导入路径。



对于一个较大的应用程序，我们应该将它的功能性分隔成逻辑的单元，分别在不同的包里实现。我们创建的的自定义包最好放在GOPATH的src目录下(或者GOPATH src的某个子目录)。

在Go语言中，代码包中的源码文件名可以是任意的。但是，这些任意名称的源码文件都必须以包声明语句作为文件中的第一行，每个包都对应一个独立的名字空间

```go
package calc
```

包中成员以名称首字母大小写决定访问权限

* public 首字母大写，可被包外访问
* private 首字母小写，仅包内成员可以访问

**注意：同一个目录下不能定义不同的package**

## 导入包的方式

```go
package main

import (
	"fmt"
	"os"
)

import "os"
import "fmt"

//推荐使用的导包方式
import (
	"fmt"
	"os"
)


func main() {
	fmt.Println("os.args =", os.Args)
}
```

另一种导包方式（容易导致重名，非常不推荐）

```go
package main

//相当于静态导入
import "os"
import . "fmt"

func main() {
    //无需写fmt
	Println("os.args =", os.Args)
}
```

给包起别名

```go
package main

//导入包起别名
import "os"
import tim "fmt"

func main() {
	tim.Println("os.args =", os.Args)
}
```

有时，用户可能需要导入一个包，但是不需要引用这个包的标识符。在这种情况，可以使用空白标识符`_`来重命名这个导入

```go
import (
	_ "fmt"
)
```

`_` 操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数。

![mark](https://img.zouchanglin.cn///20200204/Apboc2MhaXfr.png)

## main包

在Go语言里，命名为main的包具有特殊的含义。Go语言的编译程序会试图把这种名字的包编译为二进制可执行文件。所有用Go语言编译的可执行程序都必须有一个名叫main的包。一个可执行程序有且仅有一个main 包。

当编译器发现某个包的名字为main 时，它一定也会发现名为main()的函数，否则不会创建可执行文件。main()函数是程序的入口， 所以，如果没有这个函数，程序就没有办法开始执行。程序编译时，会使用声明main包的代码所在的目录的目录名作为二进制可执行文件的文件名。

## main函数和init函数

Go里面有两个保留的函数：init函数(能够应用于所有的package)和main函数(只能应用于package main)。这两个函数在定义时不能有任何的参数和返回值。虽然一个package里面可以写任意多个init函数，但这无论是对于可读性还是以后的可维护性来说，我们都强烈建议用户在一个package中每个文件只写一个init函数。

Go程序会自动调用init(和main)，所以你不需要在任何地方调用这两个函数。每个package中的init函数都是可选的，但package main就必须包含一个main函数。

每个包可以包含任意多个init 函数，这些函数都会在程序执行开始的时候被调用。所有被编译器发现的init函数都会安排在main 函数之前执行。init 函数用在设置包、初始化变量或者其他要在程序运行前优先完成的引导工作。

程序的初始化和执行都起始于main包。如果main包还导入了其它的包，那么就会在编译时将它们依次导入。
有时一个包会被多个包同时导入，那么它只会被导入一次( 例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次)。

当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数(如果有的话)，依次类推。等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数(如果存在的话)，最后执行main函数。下图详细地解释了整个执行过程:

![mark](https://img.zouchanglin.cn///20200204/aTAE63uPaXP1.png)

## go install命令

设置环境变量GOBIN，通过go install 命令可以自动生成pkg、bin目录

## 总结一下

src：放源代码，如果有多个文件或多个包

1、配置GOPATH环境变量， 配置src同级目录的绝对路径
2、自动生成bin或pkg目录，需要使用go install命令。除了要配置GOPATH环境变量，还要配置G0BIN环境变量工
src：放源代码
bin：放可执行程序
pkg：放平台相关的库

Golang工程管理

本文主要记录了Golang的函数定义，可变参数，函数返回值，**函数类型**，**匿名函数和闭包**， 延迟调用，变量的作用域以及如何获取命令行参数，Golang是可以有多个返回值的，这一点能干很多事情，函数类型的主要功能在于回调和多态的实现，就像函数指针一样，用起来也很方便！



## 函数定义

```go
func FuncName(/* 参数列表 */)(o1 type, o2 type /* 返回值类型 */ ){
    
    return v1, v2;
}
```

函数定义说明:

* func: 函数由关键字func开始声明
* FumcName: 函数名称，根据约定，函数名首字母小写即为private，大写即为public
* 参数列表: 函数可以有0个或多个参数，参数格式为:变量名类型，如果有多个参数通过逗号分隔，不支持默认参数
* 返回类型:
  ①上面返回值声明了两个变量名o1和o2(命名返回参数)，这个不是必须，可以只有类型没有变量名
  ②如果只有一个返回值且不声明返回值变量，那么你可以省略，包括返回值的括号
  ③如果没有返回值， 那么就直接省略最后的返回信息
  ④如果有返回值， 那么 必须在函数的内部添加retun语句

```go
package main

import "fmt"

//无参无返回值函数定义
func MyFunc(){
	fmt.Println("MyFunc")
}

//带参无返回值
func MyFunc3(a int){
	a = 999
	fmt.Println(a)
}

//带多个参数无返回值
func MyFunc4(a int, b int)  {
	fmt.Printf("a=%d, b=%d\n", a, b)
}

//参数一样时可以简写
func MyFunc5(a, b int)  {
	fmt.Printf("a=%d, b=%d\n", a, b)
}

//参数一样时可以简写,a、b都是int、e是float64、d、f都是string
func MyFunc6(a, b int, e float64, d, f string)  {
	fmt.Printf("a=%d, b=%d\n", a, b)
}

func main() {
	MyFunc()
	MyFunc2()
	MyFunc3(666)
	MyFunc4(666, 777)
	MyFunc5(666, 777)
}

//无参无返回值函数定义，定义在main之后也OK
func MyFunc2(){
	fmt.Println("MyFunc2")
}
```

## 可变参数

和C语言一样，可变参数放最后，可传可不传

可变参数的参数传递方式，参考MyFunc04，如果是只传一部分，参考MyFunc05、MyFunc06

```go
package main

import "fmt"

//固定参数
func MyFunc01(a, b int)  {

}

//可变参数
func MyFunc02(args ... int)  {
	for i, data := range args {
		fmt.Printf("args[%d]=%d\n", i, data)
	}
}

//固定参数+可变参数
//固定参数必传、可变参数可以为空
//可变参数一定要放在最后
func MyFunc03(a int, b string, args ... int)  {
	fmt.Println("a =", a)
	fmt.Println("b =", b)
	for i, data := range args{
		fmt.Printf("args[%d]=%d\n", i, data)
	}
}

//可变参数的传递
func MyFunc04(args ... int)  {
	MyFunc02(args ...)
}

//可变参数的传递
//特殊情况：比如只想把后面两个参数传递给另外一个函数使用
func MyFunc05(args ... int)  {
	//从args[2]开始(包括本身)，把后面所有元素传过去
	MyFunc02(args[2:] ...)
}

func MyFunc06(args ... int)  {
	//从args[2]开始(不包括本身)，把前面所有元素传过去
	MyFunc02(args[:2] ...)
}

func main() {
	//MyFunc02(11, 22, 33, 44) // OK
	//MyFunc02() // OK
	//MyFunc03(11, "hello", 22, 33)
	MyFunc04(11, 22, 33, 44)
	fmt.Printf("-----------------------------\n")
	MyFunc05(11, 22, 33, 44)
	fmt.Printf("-----------------------------\n")
	MyFunc06(11, 22, 33, 44)
}
```

## 返回值

```go
package main

import "fmt"

//无参有一个返回值
func MyFunc01() int {
	return 100
}

//给返回值起一个变量名(golang的推荐写法)
func MyFunc02() (result int)  {
	return 200
}

//给返回值起一个变量名(golang的推荐写法)
func MyFunc03() (result int)  {
	result = 300
	return
}

func main() {
	a := MyFunc01()
	fmt.Printf("a=%d\n", a)
	b := MyFunc02()
	fmt.Printf("b=%d\n", b)
	c := MyFunc03()
	fmt.Printf("c=%d\n", c)
}
```

多个返回值的情况

```go
package main

import "fmt"

//多个返回值
func MyFunc01() (int, int, int)  {
	return 11, 22, 33
}

//官方推荐写法
func MyFunc02() (a int, b int, c int)  {
	a, b, c = 11, 22, 33
	return
}

func main() {
	_, _, c := MyFunc01()
	fmt.Printf("c=%d\n", c)
	_, b, _ := MyFunc02()
	fmt.Printf("b=%d\n", b)
}
```

多参数多个返回值

```go
package main

import "fmt"

func MaxValue(a, b int) (max, min int) {
	if a > b {
		max = a
		min = b
	}else{
		min = a
		max = b
	}
	return
}

func main() {
	max, _ := MaxValue(11, 22)
	fmt.Printf("max=%d\n", max)
}
```

递归的例子

```go
package main

import "fmt"

func MyFunc01(num int) (ret int)  {
	if num == 1 {
		return 1
	}else {
		return num + MyFunc01(num - 1)
	}
}

func main() {

	num := MyFunc01(100)
	fmt.Printf("num=%d\n", num)
}
```

## 函数类型

函数也是一种数据类型，通过type可以定义它，它的类型就是所有拥有的相同的参数，相同的返回值的一种类型

```go
package main

import "fmt"

func Add(a, b int) (ret int)  {
	return a + b
}

func Sub(a, b int) (ret int)  {
	return a - b
}

//声明一个函数类型
type FuncType func(int, int) int

//多态：多种形态，调用一个接口不同的表现形态，这里相当于把函数类型当作参数传递了
func MyCalc(calc FuncType, a, b int) int {
	return calc(a, b)
}

func main() {
	//传统使用方式
	ret := Add(10, 20)
	fmt.Printf("ret=%d\n", ret)

	//函数类型调用方式
	var myFunc FuncType
	myFunc = Add
	ret = myFunc(20, 30) //等价于Add(20, 30)
	fmt.Printf("ret=%d\n", ret)


	fmt.Printf("Add ret=%d\n", MyCalc(Add, 10, 5)) //15
	fmt.Printf("Sub ret=%d\n", MyCalc(Sub, 10, 5)) //5
}
```

函数类型的应用：回调函数，也就是通过这种传递函数参数的方式实现的

其实底层实现就是函数指针数组

## 匿名函数和闭包

所谓闭包就是一个函数“捕获”了和它在同一作用域的其它常量和变量。这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能够使用这些常量或者变量。**它不关心这些捕获了的变量和常量是否已经超出了作用域，所以只有闭包还在使用它，这些变量就还会存在。**

在Go语言里，所有的匿名函数 (Go语言规范中称之为函数字面量) 都是闭包。匿名函数是指不需要定义函数名的一种函数实现方式，它并不是一个新概念，最早可以回溯到1958年的Lisp语言

```go
package main

import (
	"fmt"
)

func main() {
	//匿名函数，无函数名
	myFunc01 := func() {
		fmt.Printf("hello\n")
	}

	myFunc01()

	//给一个函数类型起别名
	type FuncType func() //无参数无返回值

	var myFunc02 FuncType  = myFunc01
	myFunc02()

	//定义匿名函数并调用
	func() {
		fmt.Printf("hello\n")
	}() //()代表调用此匿名函数

	//带参数的匿名函数
	myFunc03 := func(a, b int) {
		fmt.Printf("a=%d, b=%d\n", a, b)
	}
	myFunc03(10, 20)

	//定义带参数的匿名函数并调用
	func(a, b int) {
		fmt.Printf("a=%d, b=%d\n", a, b)
	}(10, 20)

	//定义匿名函数带参带返回值
	x, y := func(i, j int)(max, min int){
		if i > j {
			max, min = i, j
		}else {
			max, min = j, i
		}
		return
	}(10, 20)
	fmt.Printf("x=%d, y=%d\n", x, y)
}
```

闭包以引用方式捕获外部变量

```go
package main

import "fmt"

func main() {
	a := 10
	s := "hello"

	func(){
		//闭包以引用方式捕获外部变量
		a = 666
		s = "world"
		//内部：a=666, s=world
		fmt.Printf("内部：a=%d, s=%s\n", a, s)
	}()
	//内部：a=666, s=world
	fmt.Printf("内部：a=%d, s=%s\n", a, s)
}
```

闭包的特点

```go
package main

import "fmt"
//函数的返回值是一个匿名函数，返回一个函数类型
func test02() func()int {
	var x = 0
	return func() int {
		x++
		return x * x
	}
}

func main() {
	//函数的返回值是一个匿名函数，返回一个函数类型
	//通过f来调用返回的匿名函数，即调用闭包
	f := test02()
	fmt.Printf("%d\n", f()) // 1
	fmt.Printf("%d\n", f()) // 4
	fmt.Printf("%d\n", f()) // 9
	fmt.Printf("%d\n", f()) // 12
}


func test01() int  {
	//函数调用的时候，x才分配空间
	var x = 0
	x++
	return x * x
	//调用完毕 x释放
}

func main01() {
	fmt.Printf("%d\n", test01()) // 1
	fmt.Printf("%d\n", test01()) // 1
	fmt.Printf("%d\n", test01()) // 1
	fmt.Printf("%d\n", test01()) // 1
}
```

![mark](https://img.zouchanglin.cn///20200204/CO3kAkCgOFhm.png)

所以可以看出变量的声明周期不是由它的作用域决定的，如果有闭包在使用它，那么它的声明周期是由闭包是否还在继续调用决定的！

## 延迟调用 defer

关键字defer用于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行，注意：**defer语句只能出现在函数或者方法的内部**， 文件操作时比较常用

![mark](https://img.zouchanglin.cn///20200204/LbIkiYE4naMK.png)

下面看看多个defer的执行顺序

如果一个函数中有多个defer语句，它们会以LIFO (后进先出)的顺序执行。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执行。

![mark](https://img.zouchanglin.cn///20200204/9g3arNRnkS6d.png)

defer和匿名函数结合使用

![mark](https://img.zouchanglin.cn///20200204/imUIaNUHJmc3.png)

与上面的例子做一个对比

![mark](https://img.zouchanglin.cn///20200204/8jzK9AUK5sgJ.png)

所以很明显可以看出来，defer就是延迟调用，但是不代表延时传参数

## 获取命令行参数

![mark](https://img.zouchanglin.cn///20200204/yTVcjrupa0FO.png)

## 作用域

定义在`{ }` 里面的变量就是局部变量，注意if或者for语句里定义的变量也是属于if或者for语句独有的，执行到变量那句话的时候才分配内存空间，离开作用域内存自动释放

```go
package main

import "fmt"

//定义全局变量
var num = 20

//定义全局变量不能使用类型推导
//num := 30 error

func main() {
	fmt.Println("num =", num)
}
```

不同作用域允许定义同名变量，使用变量的原则，就近原则