
**go连接mysql为什么需要 import _ "github.com/go-sql-driver/mysql"**

go中import _的作用只执行引入包的init函数，那么go-sql-driver/mysql 的init函数又做了什么，在`database/sql` 中的`drivers map[string]driver.Driver`注册引擎 mysql => MySQLDriver{}

```go
// go-sql-driver/mysql/driver.go
func init() {
	sql.Register("mysql", &MySQLDriver{})
}
```


**SetMaxIdleConns/SetMaxOpenConns/SetConnMaxLifetime 设置的值有什么用呢？**

- db.maxLifetime 连接从创建开始存活的时间，mysql默认tcp连接的超时时间 8h
- db.maxOpen 打开的连接最大数量，超过该数量后，query会被阻塞等待可用连接
- db.maxIdle 空闲池维持的最大连接数量

**sql.Open为什么只需要一次调用即可?**

1. 加载驱动程序 go-sql-driver/mysql
2. 初始化DB数据结构
3. 构造创建连接channel/重置连接channel

这里并有实际去和数据建立连接，也没有对数据库连接的参数校验，只是初始化了DB结构体，DB结构体中已经包含了连接池 freeConn []*driverConn, 没有必要多次调用open，全局维护一个DB即可，如果需要验证 账户密码/网络是否能通信，需要调用ping来检测。

```go
type DB struct {
	waitDuration int64 // 统计每次链接的等待时间

	connector driver.Connector

	// 已经关闭的连接数量
	numClosed uint64

	mu sync.Mutex

	freeConn     []*driverConn               // 空闲池
	connRequests map[uint64]chan connRequest // 等待连接队列，当前连接达到maxOpen时，就无法不在创建连接，创建一个请求的channel入队列并等待并阻塞当前goroutine
	nextRequest  uint64                      // connRequests[] 指向下一个坑位
	numOpen      int                         // 正在使用的连接数量

	// channel 通过此channel来接受建立新的session连接
	// DB.connectionOpener for select 接收channel
	openerCh          chan struct{}
	resetterCh        chan *driverConn       // 重置session以便其他query复用当前session
	closed            bool                   // 标记是否已经关闭链接
	dep               map[finalCloser]depSet //
	lastPut           map[*driverConn]string // 调试用
	maxIdle           int                    // 维持的最大空闲连接数，小于等于0使用defaultMaxIdleConns（2)
	maxOpen           int                    // 维持的最大连接数，0无限制
	maxLifetime       time.Duration          // 连接可以重用的最长时间
	cleanerCh         chan struct{}
	waitCount         int64 // 等待连接的总数
	maxIdleClosed     int64 // 由于空闲而连接的总数
	maxLifetimeClosed int64 // 连接存活时间超过maxLifetime而关闭的时间

	stop func() // 取消接收 建立连接channel(openerCh)/重置session channel(resetterCh)
}
```



**如果获取数据连接池的状态？当前的连接总数，SetMaxOpenConns/SetMaxIdleConns的数量是否合适。**

使用db.Stats可以查看当前连接池的一些状态,这边返回了一个DBStats结构体，一起看下:

```go
type DBStats struct {
	MaxOpenConnections int // 打开的最大连接数，包含已经关闭了的连接

	// 连接池状态
	OpenConnections int // 当前建立连接的数量，包括正在使用和空闲的数量
	InUse           int // 正在使用的连接数
	Idle            int // 已建立连接，空闲中的连接数

	// 统计
	WaitCount         int64         // 等待连接的总数，这里需要着重关注一下
	WaitDuration      time.Duration // query持续等待连接的总时长
	MaxIdleClosed     int64         // 达到SetMaxIdleConns，而关闭的连接数量
	MaxLifetimeClosed int64         // 达到SetConnMaxLifetime. 而关闭的连接数量
}
```

- WaitCount  着重关注一下，看下是不是有慢查询阻塞了可用的连接数量
- MaxIdleConns设置的过小，而请求数过多导致，会导致MaxIdleClosed比较大，WaitCount也会比较大

注意：db.Stats不要调用过于频繁，它会对整个DB连接池加锁，过于频繁有一定开销。



**DB.Ping()做了哪些事情？DB是如何从连接池中获取一个可用的连接的？**

1. 获取连接，可以复用连接 （cachedOrNewConn）
2. 获取一个可用的连接 driverConn
   1. 复用空闲池中freeConn已有的连接
      1. 从空闲池中移除第一个连接conn
      2. 这期间都是有锁的，freeConn是一个切片，是并发不安全的
      3. 该连接是否在生命周期内 lifetime -- db.SetLifeTime设置的tcp连接存活时间
         - 本连接过了生命周期，返回 driver.ErrBadConn
      4. 返回此conn
   2. db.SetMaxOpenConns设置了最大打开的连接数，且当前打开的连接已经达到最大数
      1. 创建一个等待请求，放入等待队列，阻塞当前goroutine
      2. 等待超时使用context取消，或者等待直到获取可用的连接
         - ctx取消后还是获取到了连接，放回空闲池
      3. 获取到可用连接，统计本次阻塞时长，可以注意到如果DB.Stats().WaitDuration大了以后问题就很严重了
         - 如果本连接过了生命周期，返回 driver.ErrBadConn
      4. 返回此Conn
   3. 封装driver返回的connect到driverConn
      1. 标记driverConn inUse使用中
      2. 记录连接创建时间createdAt
      3. db指向连接池
      4. 真正底层的连接

源码小细节：

- 移除切片第一个元素：`copy(db.freeConn, db.freeConn[1:])`
- 删除map中的元素:  delete(db.connRequests, reqKey)
- map[key]interface: 也可以使用channel做为key
- 生命周期判断：createdAt.Add(lifetime).Before(time.now()) 

- 参观一下context的用法

```go
select {
// 这里留取消的口
case <-ctx.Done():
  select {
  // 之前我们分析过select尽量不要加default，单那是for select结构，会造成自旋锁，长期占用M不释放
  // 如果这里不用default它就阻塞一直等待req channel中有connect，这里并不是为了等待，只是为了清理一下channel的connect，防止孤儿connect
  default:
	case ret, ok := <-req:
		//...
  }
  return nil, ctx.Err()
case ret, ok := <-req:
  // ...
  return ret.conn, ret.err
}

// 我们在外面如何控制超时呢？
fun bar(){
  t := time.After(10)
  ctx := context.Background()
  res := make(chan struct{})
  go func() {
    ci, _ := conn(ctx)
    res<-ci
  }()
  select {
  case <-t:
    ctx.Done()
  case ci := <-res:
    if ci != nil {

    }
  }
}
```



go数据库连接池



# npm publish: react component/react hook component

 [![npm](https://img.shields.io/npm/v/npm-publish-react-component)](https://www.npmjs.com/package/npm-publish-react-componentr) [![npm](https://img.shields.io/npm/l/npm-publish-react-component)](https://www.npmjs.com/package/npm-publish-react-component) ![react supported](https://img.shields.io/badge/React-%5E16.8.0-blue.svg)

已经成功发布 [react 天气组件](https://www.npmjs.com/package/react-tencent-weather) , 以及  [npm publis react demo ](https://www.npmjs.com/package/npm-publish-react-component) 简单实例，此文就是基于此demo

完整代码已经发到 Github:  [https://github.com/douyacun/npm-publish-react-component](https://github.com/douyacun/npm-publish-react-component) 

误区：

1. npm 发布的react包是源码还是编译后的代码？ 编译后的代码
2. npm 如何在本地测试已经打包的代码？npm link, 这个后续详细讲
3. npm 打包以后 css 文件如何处理？webpack配置，js文件和css文件打包到一个文件
4. npm 发布的react包如何支持服务端渲染？css单独打包，import

概要：

1. package.json 配置
2. webpack 配置, 支持服务端渲染
3. [npm](https://www.npmjs.com/package/npm-publish-react-component)  账号，npm link，npm publish，
4. ISSUE

体验:

```bash
git clone https://github.com/douyacun/npm-publish-react-component.git
npm install
npm start
```

目录：

```
.
├── LICENSE
├── babel.config.json
├── example
│   ├── index.html
│   ├── index.js
│   └── webpack.config.js
├── lib
│   ├── index.js
│   └── index.js.LICENSE.txt
├── package.json
├── src
│   ├── index.css
│   └── index.js
└── webpack.config.js
```



# package.json 配置

1. git init初始化，指定origin仓库，接下来npm会帮忙初始化号git相关的字段

2. `npm init` 初始化 package.json，里面的信息都填写一下，这是搜到这个包的关键，尤其是是keywords

3. 安装一下react打包需要的插件, react/babel/webpack

```
npm install react react-dom --save
npm install @babel/core @babel/preset-env @babel/preset-react babel-loader --save-dev
npm install webpack webpack-cli webpack-dev-server --save-dev
```

4. bable配置文件 `babel.config.json`

```json
{
  "presets": [
    "@babel/preset-env",
    "@babel/preset-react"
  ]
}
```

完整 的 `package.json` 

```json
{
  "name": "npm-publish-react-component", // 重要! npm install <?> 包名，全局唯一
  "version": "1.0.0", // 版本号，每次发布累加一
  "description": "npm发包流程", // seo 三剑客
  "main": "lib/index.js",// 重要！import Demo from "npm-publish-react-component" 就是引入main指定的文件～
  "keywords": [
    "npm publish",
    "npm发布",
    "react组件",
    "react component"
  ],// seo 三剑客
  "scripts": {
    "start": "webpack serve --config example/webpack.config.js",
    "build": "webpack"
  },
  "author": "douyacun",
  "license": "MIT",
  "dependencies": {
    "react": "^17.0.1",
    "react-dom": "^17.0.1"
  },
  "devDependencies": {
    "@babel/core": "^7.12.10",
    "@babel/preset-env": "^7.12.11",
    "@babel/preset-react": "^7.12.10",
    "babel-loader": "^8.2.2",
    "css-loader": "^5.0.1",
    "html-webpack-plugin": "^4.5.1",
    "style-loader": "^2.0.0",
    "webpack": "^5.11.1",
    "webpack-cli": "^4.3.1",
    "webpack-dev-server": "^3.11.1"
  },
  "directories": {
    "example": "example",
    "lib": "lib"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/douyacun/npm-publish-react-component.git"
  },
  "bugs": {
    "url": "https://github.com/douyacun/npm-publish-react-component/issues"
  },
  "homepage": "https://github.com/douyacun/npm-publish-react-component#readme"
}

```

- dependencies 会在npm install <your package>时自动安装
- devDependencies 本地安装时需要用到，打包用的肯定放在devDependencies里面
- peerDependencies 重要！我是用 react hook 写的组件，是react 16.8.4里提供的功能，这里react必须要大于16.8.4的版本

# webpack 配置

1. 配置入口文件 

```
entry: './src/index.js', // 打包哪个文件
```

2. 配置输出目录，文件名，这个要对应到 `package.json`  **main** 文件

```
output: {
    path: path.join(__dirname, '../lib/'), // 输出到哪
    filename: 'index.js', // 输出的文件名字
    libraryTarget: 'umd', // 重要！
}
"main": "lib/index.js"
```

3. `libraryTarget` :  很重要，意味着我们打包出来的js文件可以在什么环境使用～ <a name="libraryTarget"></a>

这里罗列一下各个选项的含义：

- var [默认]:  分配给一个变量值

```js
var MyLibrary = _entry_return_;
// 在一个单独的 script……
MyLibrary.doSomething();
```

- this： 分配给this变量

```
this["MyLibrary"] = _entry_return_;

// 在一个单独的 script……
this.MyLibrary.doSomething();
MyLibrary.doSomething(); // 如果 this 是 window
```

- window： 当 library 加载完成，入口起点的返回值将分配给 window 对象。

```js
window["MyLibrary"] = _entry_return_;

window.MyLibrary.doSomething();
```

- golbal: 分配给 `global` 对象的这个属性下。一般用在node环境中

```js
global["MyLibrary"] = _entry_return_;

global.MyLibrary.doSomething();
```

- commonjs： 分配给 exports 对象。这个名称也意味着，模块用于 CommonJS 环境：这是我们需要的～～～

```js
exports["MyLibrary"] = _entry_return_;

require("MyLibrary").doSomething();
```

- amd：必须是支持define/require的环境引入

```js
define([], function() {
  return _entry_return_; // 此模块返回值，是入口 chunk 返回的值
});
```

- umd：混编，支持 commonJs/global/amd的环境: 这是我们需要的～～～

```
(function webpackUniversalModuleDefinition(root, factory) {
  if(typeof exports === 'object' && typeof module === 'object')
    module.exports = factory();
  else if(typeof define === 'function' && define.amd)
    define([], factory);
  else {
    var a = factory();
    for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
  }
})(typeof self !== 'undefined' ? self : this, function() {
  return _entry_return_; // 此模块返回值，是入口 chunk 返回的值
});
```

4. react/css 编译规则

完整 `webpack.config.json`

```js
const path = require('path');

module.exports = {
    entry: './src/index.js', // 打包哪个文件
    output: {
        path: path.join(__dirname, '../lib/'), // 输出到哪
        filename: 'index.js', // 输出的文件名字
        libraryTarget: 'commonjs2', // 重要！
    },
    externals: { // 重要！Minified React error #321 https://github.com/facebook/react/issues/16029
        react: {
            commonjs: 'react',
            commonjs2: 'react',
            amd: 'react',
            root: 'React',
        },
        'react-dom': {
            commonjs: 'react-dom',
            commonjs2: 'react-dom',
            amd: 'react-dom',
            root: 'ReactDOM',
        },
    },
    resolve: {
        extensions: ['.js', '.jsx']
    },
    mode: "production",
    module: {
        rules: [
            {
                test: /\.css$/,
                use: ["style-loader", "css-loader"] // style-loader 会把css与js文件打包在一个文件中
            },
            {
                test: /\.jsx?$/,
                exclude: /node_modules/,
                use: ["babel-loader"]
            }
        ]
    },
    performance: {
        hints: "warning", // 枚举
        hints: "error", // 性能提示中抛出错误
        hints: false, // 关闭性能提示
        maxAssetSize: 200000, // 整数类型（以字节为单位）
        maxEntrypointSize: 400000, // 整数类型（以字节为单位）
        assetFilter: function (assetFilename) {
            // 提供资源文件名的断言函数
            return assetFilename.endsWith('.css') || assetFilename.endsWith('.js');
        }
    }
}
```

服务端渲染:

```js
const path = require('path');
const TerserJSPlugin = require('terser-webpack-plugin');
const ExtractCssChunks = require('extract-css-chunks-webpack-plugin');
const OptimizeCSSAssetsPlugin = require('optimize-css-assets-webpack-plugin');

module.exports = {
    output: {
        path: path.join(__dirname, '../lib/ssr/'),
        filename: 'index.js',
        libraryTarget: 'commonjs2',
    },
    optimization: {
        minimizer: [new TerserJSPlugin({}), new OptimizeCSSAssetsPlugin({})],
    },
    plugins: [new ExtractCssChunks({filename: 'index.css',})],
    module: {
        rules: [
            {
                test: /\.css$/,
                use: [ExtractCssChunks.loader, "css-loader"]
            },
            {
                test: /\.jsx?$/,
                exclude: /node_modules/,
                use: ["babel-loader"]
            }
        ]
    }
}
```

其他配置复用上面的配置，使用了2个插件将css单独出一个文件出来，否则服务端渲染时会报：`document is not defined`,

- ExtractCssChunks
- OptimizeCSSAssetsPlugin

这样引入组件时就需要单独引入js文件和css文件：

```js
import React from 'react';
import ReactDOM from 'react-dom';
import Weather from 'react-tencent-weather/lib/ssr/index.js';
import 'react-tencent-weather/lib/ssr/index.css';

ReactDOM.render(
    <div><Weather province="上海" city="上海" /></div>,
    document.getElementById('root')
)
```



# [npm](https://www.npmjs.com/)  账号，npm link，npm publish，

**1. 注册npm账号**

去 [https://www.npmjs.com/](https://www.npmjs.com/) 注册一个账号就ok了

- 在项目目录下 npm login
- 输入 Username/Password/Email: (this IS public)

在此注意！： npm是否使用淘宝或其他镜像代理

```bash
npm config list
```

如果使用了的话，注视掉

```bash
vim .npmrc

//registry=https://registry.npm.taobao.org/
```

使用npm build打包一下出来js文件，npm包发布的是webpack babel编译后的文件～

```js
npm build
```

打包完成后肯定要测试一下的对吧

**2. 本地测试打包文件 npm link**

`npm link` 会把当前目录 软链 到全局路径下

```bash
➜  npm-publish-react-component git:(master) ✗ npm link
npm notice created a lockfile as package-lock.json. You should commit this file.
removed 262 packages in 3.534s

52 packages are looking for funding
  run `npm fund` for details

/Users/liuning/.nvm/versions/node/v12.19.0/lib/node_modules/npm-publish-react-component -> /Users/liuning/Documents/github/npm-publish-react-component
```

 `npm link npm-publish-react-component` 将 全局路径下的 `npm-publish-react-component` 包软链到当前目录下的 `node_modules` <a name="link"></a>

```bash
➜  npm-publish-react-component git:(master) ✗ npm link npm-publish-react-component
/Users/liuning/Documents/github/npm-publish-react-component/node_modules/npm-publish-react-component -> /Users/liuning/.nvm/versions/node/v12.19.0/lib/node_modules/npm-publish-react-component -> /Users/liuning/Documents/github/npm-publish-react-component
```

我们就可以直接在example/index.js中直接import使用

```react
import React from 'react';
import ReactDOM from 'react-dom';
import Demo from 'npm-publish-react-component';

ReactDOM.render(
    <div><Demo name="douyacun"/></div>,
    document.getElementById('root')
)
```

删除 `package-lock.json`  `npm start` 要确保 使用的webpack使用的配置文件是测试的配置，最好区分 测试/正式 环境



# ISSUE

**1. 引入包报错: `React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: object.`**

```
react.development.js:220 Warning: React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: object. You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.

Uncaught Error: Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: object. You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.
```

这个就是webpack没有指定:  `libraryTarget` 导致，[详细在看一下上面我们罗列的选项](#libraryTarget)



**2. 引入包报错：`Uncaught ReferenceError: module is not defined`**

```js
import React from 'react';
import ReactDOM from 'react-dom';
import Demo from 'douyacun-react-demo';

ReactDOM.render(
    <div><Demo name="douyacun"/></div>,
    document.getElementById('root')
)
```

报错：

![module is not defined](/images/blog/1/react/assert/image-20210109163631455.png)

1. 这里是因为package.json没有定义 main 入口文件，import 不知道默认引入哪个文件
2. example 本地测试环境配置的测试环境，没有入口文件，确认是否指向 example/index.js。



**3. npm run build 报错 Cannot find module 'pkg-dir'**

这个是因为:  npm link 在 node_module [创建软链导致的](#link)

解决方案：

```
npm install
```



**4. import react组件时报错：Uncaught Error: Minified React error #321**

如果react组件中使用了hook，useState/useEffect 就会导致这个问题，react官方给出的解决方案：[https://github.com/facebook/react/issues/16029](https://github.com/facebook/react/issues/16029)

原因是因为两次引入了react

```
➜  npm-publish-react-component git:(master) ✗ npm run build

> npm-publish-react-component@1.0.0 build /Users/liuning/Documents/github/npm-publish-react-component
> webpack

{ javascriptModule: false }
asset index.js 8.28 KiB [compared for emit] [minimized] (name: main) 1 related asset
runtime modules 931 bytes 4 modules
orphan modules 326 bytes [orphan] 1 module
cacheable modules 19.6 KiB
  modules by path ./node_modules/ 16.8 KiB
    modules by path ./node_modules/react/ 6.48 KiB
      ./node_modules/react/index.js 190 bytes [built] [code generated]
      ./node_modules/react/cjs/react.production.min.js 6.3 KiB [built] [code generated]    <----- 这里将 react 也打包进去了～
    ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js 6.67 KiB [built] [code generated]
    ./node_modules/object-assign/index.js 2.06 KiB [built] [code generated]
    ./node_modules/css-loader/dist/runtime/api.js 1.57 KiB [built] [code generated]
  modules by path ./src/ 2.85 KiB
    ./src/index.js + 1 modules 2.49 KiB [built] [code generated]
    ./node_modules/css-loader/dist/cjs.js!./src/index.css 368 bytes [built] [code generated]
webpack 5.12.2 compiled successfully in 1092 ms
```

解决方法：

```json
externals: { // 重要！Minified React error #321 https://github.com/facebook/react/issues/16029
  react: {
    commonjs: 'react',
    commonjs2: 'react',
    amd: 'react',
    root: 'React',
  },
  'react-dom': {
    commonjs: 'react-dom',
    commonjs2: 'react-dom',
    amd: 'react-dom',
    root: 'ReactDOM',
  },
}
```





为了发布一个react npm package，在此默默的抹了2把泪～

npm publish: react component/react hook component


![134245504_789637481968571_8633124284968352778](/images/blog/1/golang/assert/134245504_789637481968571_8633124284968352778.jpg)

博客支持github、gg登录，github虽然偶尔能访问成功，但大部分是timeout，gg直接不用说



最初我的解决方案是从阿里云租一台轻量级香港的服务器每月25元，持续了有大半年。但是实在没有别的用途，我又有其他代理可以访问。最近就决定释放阿里云的轻量级服务器了。



关于我是如何通过阿里云服务器代理访问国外服务的，代码放在gtihub上: https://github.com/douyacun/gproxy

支持http代理  、文件下载代理：https://github.com/douyacun/gproxy/blob/master/internal/controllers/request.go



go也是支持通过 socks5 和 http 代理访问的:

# http代理

正确的http代理使用姿势

```go
proxy, _ := url.Parse("http://127.0.0.1:1081")
clt := http.Client{
  Timeout: 5 * time.Second,
  Transport: &http.Transport{
    Proxy:           http.ProxyURL(proxy),  // 使用代理请求
    TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // 跳过https证书资格验证
  },
}
resp, err := clt.Get(fmt.Sprintf("http://www.google.com/ping?sitemap=%s", sitemapUrl))
```

go http提供了2个函数:

```go
// 使用环境变量: HTTP_PROXY,HTTPS_PROXY
func ProxyFromEnvironment(req *Request) (*url.URL, error)
// 指定端口
func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)
```



# Socks5 代理

http代理直接使用http包即可完成，不过socks5就得用: [golang.org/x/net/proxy](https://pkg.go.dev/golang.org/x/net/proxy#Dialer)

```go
package main

import (
	"crypto/tls"
	"fmt"
	"golang.org/x/net/proxy"
	"io/ioutil"
	"log"
	"net/http"
	"time"
)

func main() {
	dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:1080", nil, proxy.Direct)
	if err != nil {
		log.Fatalf("socks5 init err: %s", err.Error())
		return
	}
	clt := http.Client{
		Timeout: 5 * time.Second,
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
			Dial:            dialer.Dial,
		},
	}
	resp, err := clt.Get("https://www.google.com")
	if err != nil {
		log.Fatalf("ping google sitemap err: %s", err.Error())
		return
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		log.Fatalf("curl google failed~")
		return
	}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("google response body read err: %s", err.Error())
	}
	fmt.Println(string(body))
	return
}
```

结果是可以正常返回的，服务器是在北京的。

![image-20210103211632721](/images/blog/1/golang/assert/image-20210103211632721.png)

如果你想问我梯子是如何搭的话，可以邮箱(douyacun@gmail.com)联系我，不公开讨论！



解决: 在服务上使用代理访问github、google

go代理: http/socks5 proxy


react 服务端渲染 cookie 有2个问题：

1. [服务端执行的代码如何拿到cookie并解析透穿给后端接口，后端又如何设置cookie？](#服务端cookie透传)
2. [浏览器执行的代码如何读取cookie？](#客户端读取cookie)



# 服务端cookie透传

明白next的渲染流程很重要：

浏览器打开页面 -> node服务请求后端接口 -> node服务渲染页面 并响应



node服务透传cookie给后端接口：此时cookie只能从request中取的cookie:  [nextjs文档](https://nextjs.org/docs/api-reference/data-fetching/getInitialProps)

```react
Article.getInitialProps = async ({ req, query }) => {
    // 文章详情
    const { article, statusCode, errMessage } = await GET({
        url: `/api/article/${id}`,
        headers: {
            Cookie: req.headers.cookie
        }
    }).then(resp => {
        return {article: resp.data, statusCode: resp.code, errMessage: resp.message}
    })
    return { article: article, statusCode: statusCode, errMessage: errMessage }
}
```



后端设置cookie：

- 如果是node服务请求的后端接口，此时的node服务就相当于nginx一样的代理请求，需要将响应的cookie透传给浏览器

```react
import React from "react";
import {GET} from '../src/request';

function Demo ({data}) {
    return (
        <div>
            {data}
        </div>
    )
}

Demo.getInitialProps = async ({ req, query, res }) => {
    let cookie;
    const {data, code, message} = await GET({url: "http://douyacun.io/api/helper/demo", noCheck: true}).
    then((resp) => {
        res.setHeader("set-cookie", resp.headers["set-cookie"]);
        return resp.data
    }).
    then((data) => {
        return data
    })
    return {data: data}
}

export default Demo
```

GET 是封装的 axios，axios 的response不是node原生的 [response](https://github.com/axios/axios#response-schema)，而nextjs的res是node原生的[response](https://nodejs.org/api/http.html#http_class_http_serverresponse)，这里需要注意一下使用的请求库

**重点是：明白node服务渲染，其实是一层代理服务**

- 如果是浏览器客户端请求的后端接口，response是可以直接被浏览器读取到的，就不需要我们做什么事情了。



# 客户端读取cookie

客户端请求接口会有2个cookie问题：

1. 跨域请求携带cookie
2. 如何读取并解析cookie

### 跨域请求携带cookie

原理是一致的，先header请求服务端，验证服务端是否支持跨域，以及支持的域名：

```http
Access-Control-Allow-Origin: https://www.douyacun.com
```

> 这里一定要明确指定域名，否则请求还是无法携带cookie的

axios 需要指定：

```http
withCredentials: true
```



### 浏览器读取并解析cookie

用户信息存cookie的原因是不安全，也不建议的。当然前提用户信息存在隐私数据，解决方案是存在session中，cookie只是存session id。

我的博客cookie只存 昵称和ID。如何确保cookie不被篡改呢？cookie，对数据进行签名，签名使用的key是存储在服务端里。如果有更高的安全需求的，请移步～

重点：**react服务端渲染，cookie是存在浏览器上的，确保代码是在浏览器客户端上执行的才能读取到对吧**

```react
import React from 'react';
import { parseCookies } from 'nookies'

function Demo() {
    const [user, setUser] = React.useState({})
    // 首次加载
    React.useEffect(() => {
        const all = parseCookies();
        if (all.douyacun) {
            setUser(JSON.parse(all.douyacun));
        }
    }, [])
  return (<div>Hello {user.name}.</div>)
}

export default demo
```

[React.useEffect的用法](https://zh-hans.reactjs.org/docs/hooks-reference.html#useeffect), 需要注意的是:

> 默认情况下，effect 将在每轮渲染结束后执行，但你可以选择让它 [在只有某些值改变的时候](https://zh-hans.reactjs.org/docs/hooks-reference.html#conditionally-firing-an-effect) 才执行。
>
> 如果想执行只运行一次的 effect（仅在组件挂载和卸载时执行），可以传递一个空数组（`[]`）作为第二个参数。这就告诉 React 你的 effect 不依赖于 props 或 state 中的任何值，所以它永远都不需要重复执行，解析cookie只需要一次就够了～



nextjs getInitialProps 是在服务端执行的代码，可以通过 request.header 获取到 cookie 透传给后端接口

react服务端渲染: cookie如何透传给后端，后端如何设置cookie

react服务端渲染: markdown


[TOC]

# 左右布局

定义父框`root`  左视图 `left`，点击移动区 `resizer`，右试图 `right`，建议使用flex布局

![image-20201228233232732](/images/blog/1/react/assert/image-20201228233232732.png)

```css
root: {
  	height: "100%",
  	width: "100%",
}
left: {
    width: "70%"
},
resizer: {
  	userSelect: "none",
    display: "flex",
    backgroundColor: "#fafbfd",
    width: 14,
    cursor: "ew-resize",
    alignItems: "center",
    justifyContent: "center",
    border: "0.5px solid rgba(0, 0, 0, 0.07)",
},
right: {
  	width: "30%",
}
```

```html
<div className={classes.root} onMouseMove={mouseMoveHandler}>
  <div className={classes.left} style={{ width: leftWidth + "%", userSelect: userSelect }} ref={leftRef}>
		左
  </div>
  <div className={classes.resizer} onMouseDown={mousedownHandler}>︙</div>
  <div className={classes.right} style={{ width: rightWidth + "%" }}>
		右
  </div>
</div>
```

`resizer` 鼠标悬浮时一定是这个样式  <--> 的

如何实现左右移动呢？

1. 只有在`resizer` 区域内鼠标左键按下时，才可以左右移动
2. 鼠标左键抬起时，结束左右移动
3. 左视图宽度，鼠标移动时： [left.width = e.clientX / screen.width * 100] 鼠标x轴 -> 浏览器左边 的距离/窗口的宽度  * 100% 就是 `left` 的百分比
4. 右视图宽度，[right.width = 100 - left.width - resizer.width/screen.width] 窗口宽度 - 左视图宽度 - 移动区宽度 = 右视图宽度



### resizer 订阅 `mouseDown`

在resizer按下鼠标时，才可以左右移动，加锁:

```react
const [canMove, setCanMove] = React.useState(false) // 聊天框：是否移动
```

 `mouseDown`时，容易选中左右的文字体验感很差, 避免鼠标按下时选中文字，加锁：

```react
const [userSelect, setUserSelect] = React.useState("text")
```

处理函数:

```react
// 聊天框：开启移动
const mousedownHandler = (e) => {
  setCanMove(true)
  setUserSelect("none");
}
```

### document 订阅 `mouseup`

只能在document上订阅，不能确定最后鼠标的位置是在哪个元素上

```react
// 订阅聊天框宽度
React.useEffect(() => {
  document.addEventListener("mouseup", mouseUpHandler);
  return () => {
    document.removeEventListener("mouseup", mouseUpHandler);
  }
}, [])
```

首先`React.useEffect`,第二个参数空代表，不管state如何变化，此函数只会加载一次，类似init state。返回闭包组件卸载时执行移除document.onMouseUp的订阅

鼠标抬起后本次调整结束，持久化当前边框位置，下次再进来就不需要重新调整了:

```react
// 聊天框：结束移动
const mouseUpHandler = () => {
  setCanMove(false)
  setUserSelect("text");
  // 持久化聊天宽度
  localStorage.setItem(DiscussLeftWidth, leftWidth);
  localStorage.setItem(DiscussRightWidth, rightWidth);
}
```

### root 订阅 `mousemove`

首先获取窗口的宽度:

```react
const [screenWidth, setScreenWidth] = React.useState(100); // 聊天框：当前窗口宽度，计算左右比例

React.useEffect(() => {
 	 setScreenWidth(document.body.clientWidth);
}, [])
```

鼠标在`root` 元素内移动时，计算左右边框的百分比，为了避免鼠标移动重载次数过多导致的卡顿，加锁：

```react
const [lockResize, setLockResize] = React.useState(false); // 聊天框：加载锁，不要设置太快了
```

root 订阅鼠标移动

```react
const mouseMoveHandler = (e) => {
  if (canMove) {
    let lw = (e.clientX / screenWidth * 100).toFixed(3)
    let rw = (100 - lw - 1).toFixed(3);
    if (!lockResize && lw > 50 && (screenWidth - e.clientX) > 300) {
      setLeftWidth(lw)
      setRightWidth(rw)
      setLockResize(true)
      // 10毫秒以后释放该锁
      setTimeout(() => { setLockResize(false) }, 10)
    }
  }
}
```

# 滚动条样式

默认的滚动条样式时很粗的，中间加了 `resizer`以后就太丑了，滚动条必须瘦下来才行：

```css
left: {
  overflowY: "scroll",
  padding: 10,
  "&::-webkit-scrollbar": {
    width: 4,
  	// height: 16 只能设置宽度，长度浏览器会自动根据div长度调整
  },
  "&::-webkit-scrollbar-thumb": {
    backgroundColor: "rgba(105, 112, 125, 0.5)" // 滚动条背景色
  }
},
```

- `::-webkit-scrollbar` — 整个滚动条.
- `::-webkit-scrollbar-button` — 滚动条上的按钮 (上下箭头).
- `::-webkit-scrollbar-thumb` — 滚动条上的滚动滑块.
- `::-webkit-scrollbar-track` — 滚动条轨道.
- `::-webkit-scrollbar-track-piece` — 滚动条没有滑块的轨道部分.
- `::-webkit-scrollbar-corner` — 当同时有垂直滚动条和水平滚动条时交汇的部分.
- `::-webkit-resizer` — 某些元素的corner部分的部分样式(例:textarea的可拖动按钮).

![image-20201229003702633](/images/blog/1/react/assert/image-20201229003702633.png)

























































































react 移动边框


[toc]

通过数据结构、实现原理、读写操作来了解go hashmap

# 数据结构

![](/images/blog/1/golang/assert/go-map.jpg)

hash有2个关键数据结构: `hmap` `bmap`

**hmap:  `runtime/map.go`**

```go
type hmap struct {
	count     	int 
	flags     	uint8
	B         	uint8  
	noverflow 	uint16 
	hash0     	uint32 
	buckets    	unsafe.Pointer 
	oldbuckets 	unsafe.Pointer
	nevacuate  	uintptr
	extra 		*mapextra 
}
```

-   `count`  元素数量
-   `B`  2^B个buckets桶
-   `noverflow` buckets溢出桶的数量，近似值
-   `buckets` 桶
-   `oldbuckets` 扩容时指向原buckets桶

**bmap: `runtime/map.go`  `cmd/compile/internal/gc/reflect.go`**

```go
type bmap struct {
    topbits 	[8]uint8
    keys 		[8]keytype
    elems 		[8]elemtype
    pad 		uintptr
    overflow	uintptr
}
```

哈希表中桶的真正结构其实是在编译期间运行的函数 `bmap` 中被『动态』创建的， 代码在`cmd/compile/internal/gc/reflect.go`

-   `topbits` 存储hash值的高8位，通过比对高8位减少键值对访问次数以提高性能
-   `keys` / `elems` 数组

-   `pad` 内存对齐
-   `overflow` 溢出桶，map存储数据过多时使用

# 实现原理

时间复杂度: O(1)

hash函数和hash冲突解决方法

**hash函数**

实现哈希表的关键点在于如何选择哈希函数，哈希函数的选择在很大程度上能够决定哈希表的读写性能，在理想情况下，哈希函数应该能够将不同键映射到不同的索引上，这要求**哈希函数输出范围大于输入范围**，但是由于键的数量会远远大于映射的范围，所以在实际使用时，这个理想的结果是不可能实现的。

**hash冲突**

开放寻址法：对数组中的元素依次比较键值对是否存在于数组

拉链法： 使用数组加上链表

![](/images/blog/1/golang/assert/hashmap-拉链法.png)

# 读写操作

**读**

![](/images/blog/1/golang/assert/go-map-get.jpg)

-   计算出key的hash
-   用最后的“B”位来确定在哪个桶（“B”就是前面说的那个，B为4，就有16个桶，0101用十进制表示为5，所以在5号桶）
-   根据key的前8位快速确定是在哪个格子（额外说明一下，在bmap中存放了每个key对应的tophash，是key的前8位）
-   最终还是需要比对key完整的hash是否匹配，如果匹配则获取对应value
-   如果都没有找到，就去下一个overflow找

**写**

-   通过key的后“B”位确定是哪一个桶
-   通过key的前8位快速确定是否已经存在
-   最终确定存放位置，如果8个格子已经满了，没地方放了，那么就重新创建一个bmap作为溢出桶连接在overflow

**扩容**

条件：

-   装载因子大于6.5
-   溢出桶 大于15个

```go
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	...
	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
		hashGrow(t, h)
		goto again
	}
	...
}
```

方式：

-   等量扩容
-   翻倍扩容



知道map数据结构长什么样才能知道是怎么访问的, 冲突时如何解决的

go基础数据结构 hashmap数据结构与实现原理


[toc]

# redis延迟高问题解决思路

延迟是 客户端从发出命令与客户端接收命令的回复之间的最大延迟，通常redis的处理时间是非常低的，但是存在高延迟的某些条件

解决思路：
1. 确保没有慢执行的命令，通过redis慢查询日志查看
2. 对于EC2用户，EC2是基于HVM，否则fork太慢了
3. 禁用transparent_hugepage，`echo never > /sys/kernel/mm/transparent_hugepage/enabled`, 然后重启redis
4. 可能存在与redis无关的内在延迟，`redis-cli --intrinsic-latency 100`, 需要redis-server服务器上运行
5. aof/rdb 持久化 性能/延迟的权衡
   1. AOF+fsync 总是很慢，不推荐使用
   2. AOF+fsync+everysec 每秒执行一次，推荐(也可能会造成阻塞的问题,[当执行bgrewrite对aof进程归并优化时，redis出现被阻塞的问题](./持久化.md#1))
   3. AOF+fsync+everysec+no-appendfsync-no-write 主进程不调用fsync()操作，最长不超过30秒，推荐
   4. AOF+fsync never
   5. RDB 配置触发save条件

## 网络和通信引起的延迟
1Gbit/s的网络延迟大约为200us，uninx域套接字的延迟低至30us，如果在同一个服务器可以用unix_socket加速，redis启用unix_socket

`redis.conf`
```conf
unixsocket /var/run/redis/redis.sock
unixsocketperm 777
```
php 连接redis
```php
$redis->connect('/var/run/redis/redis.sock');
```
解决方案：
- 优先选择物理机托管服务器
- 不要系统的连接/断开服务器
- 如果客户端与服务器位于同一主机上，使用域套接字
- 尽量使用MSET/MGET批量操作
- redis不适合绑定在单个cpu上,bgsave/aof重写会抢占主进程的时间

## redis单线程特性
redis主要使用单线程设计，多路复用为客户端的请求提供服务，所有请求都是安装顺序提供

## 慢查询导致的延迟
单线程的结果是，当有慢查询时所有其他客户端将等待该请求完成

如果有慢查询时必须的可以放在salve上执行所有慢查询

查看慢查询日志
```shell
slowlog get 2
```
sort\lrem\sunion\keys 这些都慢查询命令，用scan代替keys

## fork生成的延迟
开启RDB和AOF重写，redis必须fork后台进程，fork操作可能会阻塞主进程，fork涉及到复制大量对象，尤其对于使用虚拟内存机制的页表
linux/64，内存为4kb每页，每个进程存储一个页表，对于24G内存的redis实例需要(24GB/4kb)*8=48M,每次fork都会分配和复制48M内存

## transparent_hugepage 引起的延迟
transparent_hugepage linux内核尽可能的尝试分配2M的页大小给程序使用，内核空间在内存中自身是2M对齐的，目的是减少内核TLB的压力(cpu使用的一小块关联内存)，如果内存没有2M的连续大小的空间可分配，内核会回退到分配4kB

禁用transparent_hugepage[](/linux/页缓存.md#pdflush)
```shell
echo never > /sys/kernel/mm/transparent_hugepage/enabled
```
strace只显示慢速系统调用:
```shell
sudo strace -f -p $(pidof redis-server) -T -e trace=fdatasync,write 2>&1 | grep -v '0.0' | grep -v unfinished
```

## swap内存交换引起的延迟
- redis使用的内存比可用内存多
- 某些进程产生了大量的读取和写入I/O，因为文件是会被缓存的，会增加内核压力增大文件内存缓存，产生内存交换，包括RDB和AOF

[vmstat](/article/e1880e6c796784f4050a840eca951acc)
```shell
[root@00h ~]# vmstat 5
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  0      0  93016  16576 212056    0    0    81   151    1   11  2  0 98  0  0
 0  0      0  92892  16588 212116    0    0    44     0  288  591  1  0 98  1  0
 0  0      0  92892  16616 212068    0    0    28     0  322  663  0  1 99  0  0
 0  0      0  92892  16628 212084    0    0    12     0  326  650  1  1 98  0  0
^C
```
swap si/so 为0,说明swap没有内存交换活动

[iostat](/article/df4581492d33ab6b1f812d111d7fa37c)
```shell
[www@00h www.00h.tv]$ iostat -xk 1
Linux 3.10.0-957.1.3.el7.x86_64 (00h) 	06/15/2019 	_x86_64_	(1 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           1.54    0.00    0.43    0.20    0.00   97.83

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vda               0.16     1.14    1.58    1.71    81.23   150.43   140.57     0.04   10.98   14.13    8.08   0.97   0.32
```
如果延迟问题是由于redis内存在磁盘上交换造成，需要降低系统内存压力，增加更多的内存

## AOF和磁盘I/O造成的延迟
AOF有两个系统调用：

write：将数据写入aof文件，产生阻塞的情况：1. 当系统缓冲区已满 2. 系统正在将缓冲区的内容写入到文件

fdatasync: 刷新内核文件缓冲区的文件到磁盘上，相比fsync要[高效](/article/5346fecbca9c98ddeb6290c06a5a9a36#性能)

redis可以配置3种fsync：
- appendfysnc=no redis不执行fsync，再次配置中，唯一的延迟源是write
- appendfsync=everysec redis每秒执行一次，使用不同的线程，如果fsync仍在进行中，redis使用缓冲区将write调用延迟两秒（如果fsync正在针对同一文件进行，write会在Linux上阻塞），如果fsync占用时间太长，redis最终也会执行write
- appendfsync=always 每次写入都执行fsync，这种情况下性能一般非常低

可以使用[strace](/article/7d9e2f0f4ab362e48dc2f538427987bd)查看进程对fdatasync/write的调用
```
sudo strace -p $(pidof redis-server) -T -e trace=fdatasync，write
```

## redis过期产生的延迟
redis使key过期的方式：
- 惰性淘汰：在key请求时，判断key是否失效，失效就淘汰
- 定时策略：每隔100毫秒检测一次

redis没100毫秒会启动一个serverCron来执行定期淘汰策略
- `ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP` 移除所有已过期的键
- 如果发现超过25%的键过期，会重复执行

正常情况下,`ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP`默认情况下设置为20，每秒执行10次，通常每秒只有200个密钥主动过期，每秒200个key过期对redis实例是没有影响的，
然而算法是自适应的，如果发现该组采样key中发现超过25%的key已经过期，该算法会循环，如果数据库有超过25%的key可以在同一秒过期，并且这些key占当前key的25%

# 延迟监控 & 慢查询日志
设置延迟阀值(单位：毫秒)，只有超过阀值的事件才会被记录成为延迟峰值，根据需要设置
```conf
config set latency-monitor-threshold 100
```

redis慢查询配置:

-   slowlog-log-slower-than 单位毫秒，默认10毫秒，超过的会被记录，对于高OPS的场景可以设置为1毫秒
-   Slowly-max-len 最多纪录多少条, 线上可设置为1000条以上

获取慢查询日志：

```redis
slowlog get [n]
```

# redis测量延迟工具

```shell
[work@cpc-dev01 ~]$ redis-cli -p 6379 --intrinsic-latency 100
Max latency so far: 1 microseconds.
Max latency so far: 3 microseconds.
Max latency so far: 4 microseconds.
Max latency so far: 5 microseconds.
Max latency so far: 9 microseconds.
Max latency so far: 13 microseconds.
Max latency so far: 17 microseconds.
Max latency so far: 28 microseconds.
Max latency so far: 110 microseconds.
Max latency so far: 159 microseconds.
Max latency so far: 548 microseconds.
^C
685295282 total runs (avg latency: 0.1459 microseconds / 145.92 nanoseconds per run).
Worst run took 3755x longer than the average latency.
```
这个命令要在服务器上运行

# latency 查看延迟信息
- `latency latest` 最新延迟事件
- `latency history command` 从事件时间序列中获取原始数据非常有用
- `latency reset` 不带参数，重置所有事件
- `latency graph command` 生成ASCII图形
```shell
#
|
|
|_

11
77
mm
```
这个图要竖着看，17m 代表17分钟前发生

# 延迟诊断 
`latency history`

# 推荐阅读
- [Redis latency problems troubleshooting](https://redis.io/topics/latency)


# 总结
1. 有时候也需要注意一下redis服务器的流量负载情况，由于redis本身的高性能服务，可能会出现直接把服务器带宽打满的情况
2. 注意请求的复杂度，建议将O(n)的甚至是更复杂的操作，排序，多键操作等指令转化放在redis slave上
   - 案例1: 项目推送模块redis优化，将ZREVRANGE(O(log(N)+M)， N 为有序集的基数，而 M 为结果集的基数)操作转换为list(O(1))的操作，QPS从5000上升到6500
   - 在线用户统计模块，包含了大量的keys的遍历操作，取消keys操作以后，吞吐量回升
3. 不必要的操作,`EXISTS`、`DEL`这样的操作，很多场景下是不需要的，QPS不必要的情况，取消这些可以提升有效用户请求的数量
   - XX项目点播项目redis实例，平均存在37%的EXISTS请求，每次GET、ZRANG、HMGET前都会执行，用于判断是否存在，redis对这些不存在的key都会提示，可以直接取消EXISTS请求
   - XX项目推送业务redis实例中存在25.5%的DEL操作，占据40%的时间，后将key直接设置过期时间
   - 具体案例具体分析，存在必有其道理
4. IO优化，主要是redis快照和AOF产生的，根据数据的主要成读来设置快照频率，或者快照值在slave上发生
5. CPU的使用频率，redis是单线程作业，除了分离业务、读写分离。`keepalive + twemproxy` 也能有效提升redis的CPU利用率

redis_延迟高问题解决思路_'latency_monitor_threshold'


kafka的应用场景

- 实时日志聚合，支持高容量事件流
- 处理大量的数据积压，支持来自离线系统的周期性数据加载
- 处理低延迟分发，分区，分布式，以及实时处理



### 如何处理大量的数据积压？

熟知的mysql是通过B+树来持久化到磁盘的，查找数据需要从磁盘读取并构建B+树内存数据结构。而Kafka则是：使用linux文件系统和pagecache，放弃内存数据结构

- 即使进程维护了内存数据结构，该数据也可能会被复制到操作系统的 pagecache 中，事实上所有内容都被存储了两份。

- 通过自动访问所有空闲内存将可用缓存的容量至少翻倍，并且通过存储紧凑的字节结构而不是独立的对象，有望将缓存容量再翻一番。 这样使得32GB的机器缓存容量可以达到28-30GB,并且不会有额外的 GC 负担
- 保持 内存cache 和 文件系统之间一致性逻辑，不需要做过多的转化。

- 简单的读写文件，读写操作不会相互影响。数据的大小不在会影响性能。可以无限量的使用物理硬盘，价格便宜，容量充足。可以充分解决大量的数据积压难题



### 如何在1秒内接收并持久化这1亿条数据呢？

存储问题解决了，面临的问题：大量的I/O和字节拷贝

I/O操作主要是 客户端与服务端的消息传递，服务端的数据持久化。

将多个消息打包成一组消息块，一次请求发送一组消息，服务端接收，consumer每次获取多组消息块，大量的I/O操作将不在是主要的性能问题，其实主要矛盾是在服务带宽问题上。producer/broker/consumer 三者使用二进制数据传输，producer 和 consumer 之间使用相同的压缩算法也可以极大的节省带宽问题

sendfile 将数据从 pagecache 直接发送到网络，这样避免重新复制数据。



每秒1亿条数据，保存7天，kafka是如何处理的？


[toc]

# 安装

**zookeeper** 下载地址: [http://zookeeper.apache.org/releases.html#download](http://zookeeper.apache.org/releases.html#download)

解压：`tar -zxvf kafka_2.12-2.6.0.tgz`

运行：`./bin/zkServer.sh --config conf start`

> --config 指的是配置目录



**kafka** 下载地址: [https://kafka.apache.org/downloads](https://kafka.apache.org/downloads)

解压：`tar -zxvf kafka_2.12-2.6.0.tgz`

运行：`./bin/kafka-server-start.sh config/server.properties`

# 配置

**kafka配置：**

`kakfa-configs.sh` 可以对kafka配置查看或修改

别名： 每次敲这么多命令很烦

`alias kconfigs="~/Documents/kafka/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092"`

查看:  --describe

`kconfigs --describe --entity-type [topics/clients/users/brokers/broker-loggers] --all`

- brokers
  - log.dirs：指定文件存储目录, 多个逗号分隔，建议目录指定不同的磁盘
    - 提升读写性能，多个磁盘同时读写的性能更高
    - 故障转移：Failover 1.1 版本添加
  - listeners：通过什么协议访问kafka服务，内网服务指定
  - advertised.listeners：外网访问kafka服务指定
  - log.retension.hours=168：记录保留时长 默认7天（hours/minutes/ms）
  - log.retension.bytes=1073741824：可用磁盘大小 默认 128G， -1不限制
  - zookeeper.connect=localhost:2181：zookeeper连接地址
  - auto.create.topics.enable: false topic不存在时是否自动创建（建议显示配置false）
  - unclean.leader.election.enblae: false 允许落后的副本参与leader选举（建议显示配置false）
  - auto.leader.rebalance.enable: false 定期leader选举，正常服务的leader到期也会被替换掉（建议显示配置false）
- topics
  - retension.hours 保留时长
  - retension.bytes 为该Topic预留多大的磁盘空间，-1无限使用磁盘空间
- users
- clients
- broker-loggers

修改：--alter

`kconfigs --alter --entity-type topics --entity-name test --add-config max.message.bytes=104858800`

- --alter：代表修改
- --entity-type: 代表上面这5中实例
- --entity-name: 指定那个broker（broker.id）, topic (topic.name)
- --add-config: --help 可以查看支持实时修改的配置

**JVM配置**：

- 堆大小(heap size)配置：建议6G  环境变量
  - `export KAFKA_HEAP_OPTS=--Xms6g  --Xmx6g`
- 垃圾回收：G1收集器 
  - `export  KAFKA_JVM_PERFORMANCE_OPTS= -server -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:InitiatingHeapOccupancyPercent=35 -XX:+ExplicitGCInvokesConcurrent -Djava.awt.headless=true`

**系统配置**:

- 文件描述符限制：`ulimit -n`
  - `/etc/security/limits.conf` 
    - `soft nofile 102400`
    - `hard nofile 104800`
- 文件系统类型： xfs 性能较好
- swap内存：建议配置成1，方便报警
- 脏页刷新时间：默认5秒

- 磁盘大小
  - 新增消息数
  - 消息留存时间
  - 平均消息大小
  - 备份数
  - 是否启用压缩

# 本地集群

本地运行多个实例，需要指定不同的端口，和broker.id, 创建多个server.propertie，指定端口

```
config/server-1.properties:
  broker.id=1
  listeners=PLAINTEXT://:9093
  log.dir="～/Documents/kafka/data1"
```

```
config/server-2.properties:
  broker.id=2
  listeners=PLAINTEXT://:9094
  log.dir="~/Documents/kafka/data2"
```

启动：

```shell
./bin/zookeeper-server-start.sh -daemon config/zookeeper.properties 
./bin/kafka-server-start.sh -daemon config/server.properties
./bin/kafka-server-start.sh -daemon config/server1.properties 
./bin/kafka-server-start.sh -daemon config/server2.properties 
```

创建：3副本/1分区 topic

> alias ktopics="~/Documents/kafka/bin/kafka-topics --bootstrap-server localhost:9092,localhost:9093,localhost:9094"

```shell
ktopics --create --replication-factor 3 --partitions 1 --topic test
```

查看：topic状态

```shell
ktopics --descibe --topic test

Topic: test	PartitionCount: 1	ReplicationFactor: 3	Configs: segment.bytes=1073741824
	Topic: test	Partition: 0	Leader: 3	Replicas: 2,3,1	Isr: 3,1,2
```

# kafka 分区策略 & 压缩算法

分区策略是决定生产者将消息发送到哪个分区的算法

常见的分区策略:

1. 轮询策略，能保证消息尽可能分配到不同的分区上 
2. 随机策略，随机返回小于partition的数，不能保证均匀性，适用及其性能不一的情形
3. hash策略，具有相同key的消息会保证在同一个分区中，这样可以保证消息的前后顺序

go语言包：[github.com/Shopify/sarama](https://pkg.go.dev/github.com/Shopify/sarama)  提供了这3种分区策略的实现

**轮询:** `func NewRoundRobinPartitioner(topic string) Partitioner`

**随机:** `func NewRandomPartitioner(topic string) Partitioner`

**hash:** `func NewHashPartitioner(topic string) Partitioner`

**指定分区** `func NewManualPartitioner(topic string) Partitioner`



压缩：

保证Producer 和 Consumer 压缩算法一致

```go
const (
	//CompressionNone no compression
	CompressionNone CompressionCodec = iota
	//CompressionGZIP compression using GZIP
	CompressionGZIP
	//CompressionSnappy compression using snappy
	CompressionSnappy
	//CompressionLZ4 compression using LZ4
	CompressionLZ4
	//CompressionZSTD compression using ZSTD
	CompressionZSTD
)
```

吞吐量： LZ4 > Snappy > zstd > GZIP

压缩比：zstd > LZ4 > GZIP > Snappy

CPU:  各算法差不多压缩时 Snappy 算法使用的 CPU 较多, 解压缩时 GZIP 算法可能使用更多的 CPU



# FAQs

**如何保证消息不丢失?**

producer: 

1. 消息发送异常处理, [sarama](https://github.com/Shopify/sarama)提供了2种发送消息的方式，sync/async，同步如果发送失败会返回error，异步提供了 `Errors() <-chan *ProducerError` 接口来处理错误
2. 消息发送异常重试, `config.Producer.Retry`, 默认是 3次
3. `config.Producer.RequiredAcks=WaitForAll` 所有副本都接受到消息，该消息才算做提交
   1. `NoResponse RequiredAcks = 0`
   2. `WaitForLocal RequiredAcks = 1`
   3. `WaitForAll RequiredAcks = -1`

broker:

1. `unclean.leader.election.enable=false` 控制落后台太多的broker不参加leader选举
2. `replication.factor >= 3` 副本数量不要少于3份
3. `min.insync.replicas >= 1` 消息最少写入多少个副本才算做已提交，正式环境中建议>=3
4. `replication.factor > min.insync.replicas`  如果2着相等，只要有1个副本挂掉，整个分区就无法工作了

consumer:

1. 先消费，在更新位移, `cfg.Consumer.Offsets.AutoCommit.Enable = false` 默认是自动提交的
