Goldydocs on 菜鸟程序员

01单片机原理图和开发板设计图

Thu, 08 May 2025 00:00:00 +0000

线性表

Thu, 08 May 2025 00:00:00 +0000

1 线性表的特点

线性表中n表示线性表的长度，当n=0时称为空表
对非空线性表的特点是
- 1）存在唯一的一个被称为“第一个”的数据元素
- 2）存在唯一的一个被成为“最后一个”的数据元素
- 3）除第一个元素外每个元素都有且只有一个前驱
- 4）除最后一个元素外每个元素都有且只有一个后继

2 线性表功能定义

InitList (&L) 构造一个空的线性表L。

DestroyList(&L) 如果线性表L已存在。销毁线性表L。

ClearList (&L) 如果线性表L已存在。将L重置为空表。

ListEmpty(L) 如果线性表L已存在。若L为空表，则返回true, 否则返回false。

ListLength(L) 线性表L已存在。返回L中数据元素个数（长度）。

GetElem(L,i,&e) 线性表L巳存在，且1 <= i <= ListLength(L)。用e返回L中第i个数据元素的值。

LocateElem(L,e) 线性表L已存在。返回L中第1个值与e相同的元素在 L中的位置。若这样的数据元素不存在，则返回值为0。

PriorElem(L,cur_e,&pre_e) 线性表L已存在。 cur_e是L的元素且不是第一个，则用pre_e返回其前驱，否则操作失败，pre_e无定义。

NextElem(L,cur_e,&next_e) 线性表L已存在。若cur_e是L的数据元素，且不是最后一个，则用next_e返回其后继，否则操作失败，next_e无定义。

Listinsert(&L,i,e) 线性表L已存在，且1<=i<=ListLength (L) +l。在 L中第i个位置之前插入新的数据元素 e, L的长度加1。
ListDelete(&L,i) 线性表L已存在且非空，且且1<=i<=ListLength (L)。删除L的第i个数据元素，L的长度减1。 TraverseList(L) 线性表L已存在。遍历线性表

3 代码实现

3.1

线性表的顺序表示是使用一组地址连续的存储单元一次存储线性表的数据元素。通常这种存储结构成为顺序表。其特点是，逻辑上相邻的数据元素，其物理次序也是相邻的。例如每个元素占用空间是5，假设从地址0开始，则第1个元素占用0-4号地址，第2个元素将占用5-9号地址
顺序表存储结构如下,一元多项式举例略，

001创建一个名称为nginx的pod

Mon, 01 Jan 0001 00:00:00 +0000

# 通过命令创建一个pod容器
kubectl run nginx --image=docker.io/library/nginx:1.21.6
pod/nginx created

# 查看default命名空间下的pod
kubectl get pod -o wide
 NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
 nginx 1/1 Running 0 17s 172.20.177.22 k8s-192-168-0-19 <none> <none>

# 访问pod
curl 172.20.177.22
<!DOCTYPE html>
 <html>
 <head>
 <title>Welcome to nginx!</title>
 <style>
 html { color-scheme: light dark; }
 body { width: 35em; margin: 0 auto;
 font-family: Tahoma, Verdana, Arial, sans-serif; }
 </style>
 </head>
 <body>
 <h1>Welcome to nginx!</h1>
 <p>If you see this page, the nginx web server is successfully installed and
 working. Further configuration is required.</p>

 <p>For online documentation and support please refer to
 <a href="http://nginx.org/">nginx.org</a>.<br/>
 Commercial support is available at
 <a href="http://nginx.com/">nginx.com</a>.</p>

 <p><em>Thank you for using nginx.</em></p>
 </body>
 </html>

01工厂三兄弟之简单工厂模式(Simple Factory Pattern)

Mon, 01 Jan 0001 00:00:00 +0000

概述

工厂模式是最常用的一类创建型设计模式，通常我们所说的工厂模式是指工厂方法模式，它也是使用频率最高的工厂模式。

本章将要学习的简单工厂模式是工厂方法模式的“小弟”，它不属于GoF 23种设计模式，但在软件开发中应用也较为频繁，通常将它作为学习其他工厂模式的入门。

此外，工厂方法模式还有一位“大哥”——抽象工厂模式。

这三种工厂模式各具特色，难度也逐个加大，在软件开发中它们都得到了广泛的应用，成为面向对象软件中常用的创建对象的工具。

如何构建简单工厂

首先将需要创建的各种不同对象的相关代码封装到不同的类中，这些类称为具体产品类，而将它们公共的代码进行抽象和提取后封装在一个抽象产品类中，每一个具体产品类都是抽象产品类的子类；

然后提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工厂方法，该方法可以根据所传入的参数不同创建不同的具体产品对象；

客户端只需调用工厂类的工厂方法并传入相应的参数即可得到一个产品对象。

定义

简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。

简单工厂模式的要点在于：**当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。**简单工厂模式结构比较简单，其核心是工厂类的设计

结构

角色

**● Factory（工厂角色）：**工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它的返回类型为抽象产品类型Product。

**● Product（抽象产品角色）：**它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

**● ConcreteProduct（具体产品角色）：**它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

在简单工厂模式中，客户端通过工厂类来创建一个产品类的实例，而无须直接使用new关键字来创建对象，它是工厂模式家族中最简单的一员。

在使用简单工厂模式时，首先需要对产品类进行重构，不能设计一个包罗万象的产品类，而需根据实际情况设计一个产品层次结构，将所有产品类公共的代码移至抽象产品类，并在抽象产品类中声明一些抽象方法，以供不同的具体产品类来实现

典型代码

public abstract class Product {

 // 所有产品类的公共业务方法
 public void methodSame() {
 // 公共方法实现
 }

 // 声明抽象业务方法
 public abstract void methodDiff();
}

在具体产品类中实现了抽象产品类中声明的抽象业务方法，不同的具体产品类可以提供不同的实现，典型的具体产品类代码如下所示：

public class ConcreteProductA extends Product{
 @Override
 public void methodDiff() {
 // 业务方法实现
 }
}

public class ConcreteProductB extends Product{
 @Override
 public void methodDiff() {
 // 业务方法实现
 }
}

简单工厂模式的核心是工厂类，在没有工厂类之前，客户端一般会使用new关键字来直接创建产品对象，而在引入工厂类之后，客户端可以通过工厂类来创建产品，在简单工厂模式中，工厂类提供了一个静态工厂方法供客户端使用，根据所传入的参数不同可以创建不同的产品对象，典型的工厂类代码如下所示：

01快速入门

Mon, 01 Jan 0001 00:00:00 +0000

docker compose 部署

cd workdir mkdir -p ./mytb-data ./mytb-logs

services:
 thingsboard:
 image: thingsboard/tb-postgres
 container_name: thingsboard
 restart: always
 ports:
 - "8080:9090"
 - "7070:7070"
 - "1883:1883"
 - "5683-5688:5683-5688/udp"
 volumes:
 - ./mytb-data:/data
 - ./mytb-logs:/var/log/thingsboard

docker compose pull docker compose up -d

浏览器访问 http://domain:8080 默认用户名： tenant@thingsboard.org 默认密码： tenant

源码部署

略

添加设备

单设备添加

单设备添加完全跟图操作即可

导入设备

准备测试数据：新建csv文件，内容如下：

01设计模式概述

Mon, 01 Jan 0001 00:00:00 +0000

设计模式从何而来

与很多软件工程技术一样，模式起源于建筑领域，毕竟与只有几十年历史的软件工程相比，已经拥有几千年沉淀的建筑工程有太多值得学习和借鉴的地方。

那么模式是如何诞生的？让我们先来认识一个人——Christopher Alexander（克里斯托弗.亚历山大），哈佛大学建筑学博士、美国加州大学伯克利分校建筑学教授、加州大学伯克利分校环境结构研究所所长、美国艺术和科学院院士……头衔真多，不过他还有一个“昵称”——模式之父(The father of patterns)。 Christopher Alexander博士及其研究团队用了约20年的时间，对住宅和周边环境进行了大量的调查研究和资料收集工作，发现人们对舒适住宅和城市环境存在一些共同的认同规律，Christopher Alexander在著作《A Pattern Language: Towns, Buildings, Construction》中把这些认同规律归纳为253个模式，对每一个模式(Pattern)都从Context（前提条件）、Theme或Problem（目标问题）、 Solution（解决方案）三个方面进行了描述，并给出了从用户需求分析到建筑环境结构设计直至经典实例的过程模型。

在Christopher Alexander的另一部经典著作《建筑的永恒之道》中，他给出了关于模式的定义：

每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心，通过这种方式，我们可以无数次地重用那些已有的成功的解决方案，无须再重复相同的工作。

这个定义可以简单地用一句话表示：

模式是在特定环境下人们解决某类重复出现问题的一套成功或有效的解决方案。

【A pattern is a successful or efficient solution to a recurring problem within a context】

1990年，软件工程界开始关注ChristopherAlexander等在这一住宅、公共建筑与城市规划领域的重大突破。

最早将模式的思想引入软件工程方法学的是1991-1992年以“四人组(Gang of Four，简称GoF，分别是Erich Gamma, Richard Helm, Ralph Johnson和John Vlissides)”自称的四位著名软件工程学者，他们在1994年归纳发表了23种在软件开发中使用频率较高的设计模式，旨在用模式来统一沟通面向对象方法在分析、设计和实现间的鸿沟。

GoF将模式的概念引入软件工程领域，这标志着软件模式的诞生。

软件模式(Software Patterns)是将模式的一般概念应用于软件开发领域，即软件开发的总体指导思路或参照样板。

软件模式并非仅限于设计模式，还包括架构模式、分析模式和过程模式等，实际上，在软件开发生命周期的每一个阶段都存在着一些被认同的模式。

软件模式是在软件开发中某些可重现问题的一些有效解决方法，软件模式的基础结构主要由四部分构成，包括

问题描述【待解决的问题是什么】
前提条件【在何种环境或约束条件下使用】
解法【如何解决】
效果【有哪些优缺点】

软件模式与具体的应用领域无关，也就是说无论你从事的是移动应用开发、桌面应用开发、Web应用开发还是嵌入式软件的开发，都可以使用软件模式。

在软件模式中，设计模式是研究最为深入的分支，设计模式用于在特定的条件下为一些重复出现的软件设计问题提供合理的、有效的解决方案，它融合了众多专家的设计经验，已经在成千上万的软件中得以应用。 1995年， GoF将收集和整理好的23种设计模式汇编成Design Patterns: Elements of Reusable Object-Oriented Software【《设计模式：可复用面向对象软件的基础》】一书，该书的出版也标志着设计模式正式成为面向对象(Object Oriented)软件工程的一个重要研究分支。

01适配器模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

与电源适配器相似，在适配器模式中引入了一个被称为适配器(Adapter)的包装类，而它所包装的对象称为适配者(Adaptee)，即被适配的类。

适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用。

也就是说：当客户类调用适配器的方法时，在适配器类的内部将调用适配者类的方法，而这个过程对客户类是透明的，客户类并不直接访问适配者类。

因此，适配器让那些由于接口不兼容而不能交互的类可以一起工作。

适配器模式可以将一个类的接口和另一个类的接口匹配起来，而无须修改原来的适配者接口和抽象目标类接口。

定义

适配器模式(Adapter Pattern)：将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。

【注：在适配器模式定义中所提及的接口是指广义的接口，它可以表示一个方法或者方法的集合。】

在适配器模式中，我们通过增加一个新的适配器类来解决接口不兼容的问题，使得原本没有任何关系的类可以协同工作。根据适配器类与适配者类的关系不同，适配器模式可分为对象适配器和类适配器两种，在对象适配器模式中，适配器与适配者之间是关联关系；在类适配器模式中，适配器与适配者之间是继承（或实现）关系。

在实际开发中，对象适配器的使用频率更高

结构

角色

● **Target（目标抽象类）：**目标抽象类定义客户所需接口，可以是一个抽象类或接口，也可以是具体类。

● **Adapter（适配器类）：**适配器可以调用另一个接口，作为一个转换器，对Adaptee和Target进行适配，适配器类是适配器模式的核心，在对象适配器中，它通过继承Target并关联一个Adaptee对象使二者产生联系。

● Adaptee**（适配者类）：**适配者即被适配的角色，它定义了一个已经存在的接口，这个接口需要适配，适配者类一般是一个具体类，包含了客户希望使用的业务方法，在某些情况下可能没有适配者类的源代码。

根据对象适配器模式结构图，在对象适配器中，客户端需要调用request()方法，而适配者类Adaptee没有该方法，但是它所提供的specificRequest()方法却是客户端所需要的。为了使客户端能够使用适配者类，需要提供一个包装类Adapter，即适配器类。这个包装类包装了一个适配者的实例，从而将客户端与适配者衔接起来，在适配器的request()方法中调用适配者的specificRequest()方法。因为适配器类与适配者类是关联关系（也可称之为委派关系），所以这种适配器模式称为对象适配器模式。

典型代码

class Adapter extends Target {
 private Adaptee adaptee; //维持一个对适配者对象的引用
 
 public Adapter(Adaptee adaptee) {
 this.adaptee=adaptee;
 }
 
 public void request() {
 adaptee.specificRequest(); //转发调用
 }
}

案例解析：算法库

Sunny软件公司在很久以前曾开发了一个算法库，里面包含了一些常用的算法，例如排序算法和查找算法，在进行各类软件开发时经常需要重用该算法库中的算法。

Golang单元测试-wire依赖注入

Mon, 01 Jan 0001 00:00:00 +0000

Golang依赖注入框架wire全攻略

在前一阵介绍单元测试的系列文章中，曾经简单介绍过wire依赖注入框架。但当时的wire还处于alpha阶段，不过最近wire已经发布了首个beta版，API发生了一些变化，同时也承诺除非万不得已，将不会破坏API的兼容性。在前文中，介绍了一些wire的基本概况，本篇就不再重复，感兴趣的小伙伴们可以回看一下：搞定Go单元测试（四）—— 依赖注入框架(wire)。本篇将具体介绍wire的使用方法和一些最佳实践。

本篇中的代码的完整示例可以在这里找到：wire-examples

Installing

go get github.com/google/wire/cmd/wire

Quick Start

我们先通过一个简单的例子，让小伙伴们对wire有一个直观的认识。下面的例子展示了一个简易wire依赖注入示例：

$ ls
main.go wire.go

main.go

package main

import "fmt"

type Message struct {
 msg string
}
type Greeter struct {
 Message Message
}
type Event struct {
 Greeter Greeter
}
// NewMessage Message的构造函数
func NewMessage(msg string) Message {
 return Message{
 msg:msg,
 }
}
// NewGreeter Greeter构造函数
func NewGreeter(m Message) Greeter {
 return Greeter{Message: m}
}
// NewEvent Event构造函数
func NewEvent(g Greeter) Event {
 return Event{Greeter: g}
}
func (e Event) Start() {
 msg := e.Greeter.Greet()
 fmt.Println(msg)
}
func (g Greeter) Greet() Message {
 return g.Message
}

// 使用wire前
func main() {
 message := NewMessage("hello world")
 greeter := NewGreeter(message)
 event := NewEvent(greeter)

 event.Start()
}
/*
// 使用wire后
func main() {
 event := InitializeEvent("hello_world")

 event.Start()
}*/

wire.go

Golang单元测试-简单示例

Mon, 01 Jan 0001 00:00:00 +0000

one.go

package unittest

func AddOne(t int32) int32 {
 return t + 1
}

func MinusOne(t int32) int32 {
 return t - 1
}

func MultiAddOne(t int32) int32 {
 t = MinusOne(t)
 t = AddOne(t)
 t = AddOne(t)
 return t
}

one_test.go

package unittest

import (
 "testing"

 . "github.com/agiledragon/gomonkey"
 . "github.com/smartystreets/goconvey/convey"
)

func TestMultiAddOne(t *testing.T) {
 Convey("TestApplyFunc", t, func() {
 Convey("input and output param", func() {
 patches := ApplyFunc(AddOne, func(t1 int32) int32 {
 return 5
 }) //对函数AddOne打桩
 defer patches.Reset()
 patches.ApplyFunc(MinusOne, func(t1 int32) int32 {
 return -2
 }) //对函数MinusOne打桩
 result := MultiAddOne(2) //看好了我调用的是MultiAddOne函数，而MultiAddOne函数内部调用了AddOne和MinusOne。
 So(result, ShouldEqual, 3)
 })
 })
}

Golang单元测试01

Mon, 01 Jan 0001 00:00:00 +0000

搞定Go单元测试（一）——基础原理

单元测试是代码质量的保证。本系列文章将一步步由浅入深展示如何在Go中做单元测试。

Go对单元测试的支持相当友好，标准包中就支持单元测试，在开始本系阅读之前，需要对标准测试包的基本用法有所了解。

现在，我们从单元测试的基本思想和原理入手，一起来看看如何基于Go提供的标准测试包来进行单元测试。

单元测试的难点

1.掌握单元测试粒度

单元测试粒度是让人十分头疼的问题，特别是对于初尝单元测试的程序员。测试粒度做的太细，会耗费大量的开发以及维护时间，每改一个方法，都要改动其对应的测试方法。当发生代码重构的时候那简直就是噩梦（因为你所有的单元测试又都要写一遍了…）。如单元测试粒度太粗，一个测试方法测试了n多方法，那么单元测试将显的非常臃肿，脱离了单元测试的本意，容易把单元测试写成集成测试。

2. 破除外部依赖（mock,stub 技术）

单元测试一般不允许有任何外部依赖（文件依赖，网络依赖，数据库依赖等），我们不会在测试代码中去连接数据库，调用api等。这些外部依赖在执行测试的时候需要被模拟(mock/stub)。在测试的时候，我们使用模拟的对象来模拟真实依赖下的各种行为。如何运用mock/stub来模拟系统真实行为算是单元测试道路上的一只拦路虎。别着急，本文会通过示例来展示如何在Go中使用mock/stub来完成单元测试。

有的时候模拟是有效的方便的。但我们要提防过度的mock/stub，因为其会导致单元测试主要在测模拟对象而不是实际的系统。

Costs and Benefits

在受益于单元测试的好处的同时，也必然增加了代码量以及维护成本（单元测试代码也是要维护的）。下面这张成本/价值象限图很清晰的阐述了在不同性质的系统中单元测试成本和价值之间的关系。

1.依赖很少的简单的代码(左下)

对于外部依赖少，代码又简单的代码。自然其成本和价值都是比较低的。举Go官方库里errors包为例，整个包就两个方法 New()和 Error()，没有任何外部依赖，代码也很简单，所以其单元测试起来也是相当方便。

2. 依赖较多但是很简单的代码（右下）

依赖一多，mock和stub就必然增多，单元测试的成本也就随之增加。但代码又如此简单（比如上述errors包的例子），这个时候写单元测试的成本已经大于其价值，还不如不写单元测试。

3. 依赖很少的复杂代码 (左上)

像这一类代码，是最有价值写单元测试的。比如一些独立的复杂算法（银行利息计算，保险费率计算，TCP协议解析等），像这一类代码外部依赖很少，但却很容易出错，如果没有单元测试，几乎不能保证代码质量。

4.依赖很多又很复杂（右上）

这种代码显然是单元测试的噩梦。写单元测试吧，代价高昂；不写单元测试吧，风险太高。像这种代码我们尽量在设计上将其分为两部分：1.处理复杂的逻辑部分 2.处理依赖部分然后1部分进行单元测试

原文参考：blog.stevensanderson.com/2009/11/04/…

迈出单元测试第一步

1. 识别依赖，抽象成接口

识别系统中的外部依赖，普遍来说，我们遇到最常见的依赖无非下面几种：

网络依赖——函数执行依赖于网络请求，比如第三方http-api，rpc服务，消息队列等等
数据库依赖
I/O依赖（文件）

当然，还有可能是依赖还未开发完成的功能模块。但是处理方法都是大同小异的——抽象成接口，通过mock和stub进行模拟测试。

2. 明确需要测什么

当我们开始敲产品代码的时候，我们必然已经过初步的设计，已经了解系统中的外部依赖以及业务复杂的部分，这些部分是要优先考虑写单元测试的。在写每一个方法/结构体的时候同时思考这个方法/结构体需不需要测试？如何测试？对于什么样的方法/结构体需要测试，什么样的可以不做，除了可以从上面的成本/价值象限图中获得答案外，还可以参考以下关于单元测试粒度要做多细问题的回答：

InfinityFree白嫖攻略

Mon, 01 Jan 0001 00:00:00 +0000

多个网卡时指定注册ip段.md

Mon, 01 Jan 0001 00:00:00 +0000

添加配置项

 cloud:
 inetutils:
 preferred-networks: 192.168.*

方法一：继承Thread

Mon, 01 Jan 0001 00:00:00 +0000


import java.io.IOException;

/**
 * 方法一： 继承Thread
 */
public class M01ExtentThread {

 public static void main(String[] args) throws IOException {
 M01ExtentThread test = new M01ExtentThread();
 MyThread thread1 = test.new MyThread();
 MyThread thread2 = test.new MyThread();
 thread1.setName("线程1");
 thread2.setName("线程2");
 thread1.start();
 thread2.start();
 System.out.println("主线程输出");
 }

 class MyThread extends Thread{
 @Override
 public void run() {
 for(int i = 0; i < 3; i++) {
 System.out.println(Thread.currentThread().getName()+"线程输出"+i);
 }
 }
 }
}

服务端配置

Mon, 01 Jan 0001 00:00:00 +0000

Mapping to JMS

场景： java客户端消费使用openwire协议连接 go客户端使用amqp协议，生产消息，采用默认配置将在java消费端获取到ascii码，是由于消息头不一致造成的使用transport.transformer=jms，将amqp消息头和消息体的编码方式转换成jms的消息头和消息体 java的客户端就可以正确接收到消息了 http://activemq.apache.org/amqp.html

There are three basic conversion strategies that can be used with AMQP and inter-operating with the JMS API.

Strategy	Description
`native`	(Default) Wraps the bytes of the AMQP message into a JMS `BytesMessage` and maps the headers of the AMQP message to headers on the JMS message.
`raw`	Wraps the bytes of the AMQP message into a JMS `BytesMessage`.
`jms`	Maps headers of the AMQP message to JMS message headers and the body of the AMQP message to the JMS body.

Set the transformer transport option on the transportConnector to the desired mapping strategy. For example, to inter-operate with JMS at the payload level, set the transformer option to jms:

汇编语言入门一：环境准备

Mon, 01 Jan 0001 00:00:00 +0000

现阶段，找个方便好使的编程环境还是比较蛋疼的，对于部分想过瘾或者想从学习实践中学习的小伙伴来说，略显蛋疼。不过，仔细琢磨，还是能够自己折腾出一个好用的环境来的。开搞。

环境

Ubuntu
gcc/nasm

也就是说，你先安装一个能正常使用的Ubuntu再说吧，然后顺便熟悉一些相关的概念和操作。

后面若没有特殊说明，那我们讨论的问题都是在这个软件环境下。

环境检查

先打开终端，安装所需软件（注意$开头的才是命令，并且$并不属于命令的一部分）：

$ sudo apt-get install gcc nasm vim gcc-multilib -y

在终端中分别执行which nasm和which gcc，得到如下结果，则表示环境已经安装完毕。

$ which nasm
/usr/bin/nasm
$ which gcc
/usr/bin/gcc

开始第一个程序

在汇编语言环境下，我们先别急着搞什么Hello World，在这里要打印出Hello World还不是一个简单的事情，这也算是初入汇编比较让人不解的地方，成天都在扯什么寄存器寻址啥的，说好的变量分支循环函数呢？

别说话，先按照我的套路把环境配好，程序跑起来了再说。注意，不是Hello World。先亮出第一个程序的C语言等价代码：

int main() {
 return 0;
}

不好意思，大括号没换行。你以为接下来我要gcc -S吗？Too naive。我这可是正宗手工艺，非机械化生产。

说正事，先一股脑啥都不知道地把代码敲完，跑起来再说：

首先准备个文件，暂且叫做first.asm吧，然后把下面的代码搞进去：

global main

main:
 mov eax, 0
 ret

好了程序写完了，你能感受到这里的0就是上面C代码里的0，说明你有学习汇编的天赋。

OK接下来就要编译运行了。来一堆命令先：

$ nasm -f elf first.asm -o first.o
$ gcc -m32 first.o -o first

这下，程序就编译好了，像这样：

如何在pom文件中管理多个环境

Mon, 01 Jan 0001 00:00:00 +0000

dev dev true prod prod test test

完全私有化部署

Mon, 01 Jan 0001 00:00:00 +0000

本说明出自非官方。是个人的搭建经验总结，仅代表个人见解，有问题欢迎讨论

本说明环境基于阿里云ECS ，linux发行版 ubuntu2204， easytier版本 v2.4.5

下载地址请移步官方网站

本说明从共有四个步骤

搭建web管理平台服务
启动私有共享节点
在需要组网的服务器或PC，以web的方式启动服务（Linux 和 Windows 分别进行配置说明）
其他组网工具演示

先下载对应的二进制包： https://github.com/EasyTier/EasyTier/releases

内部存在 easytier-core easytier-web-embed easytier-cli easytier-web（用不到）

1. 搭建web管理平台服务

前置预设：

我的域名假设为 easytier.mydomain.com

使用的可执行文件为 easytier-web-embed

配置参数示意

–config-server-port 22222

–web-server-port 11111

–api-server-port 11111

–api-host http://easytier.mydomain.com:11111

新建文件easytier-web-emdeb.service内容如下

[Unit]
Description=EasyTier Service
After=network.target syslog.target
Wants=network.target

[Service]
Type=simple
ExecStart=${path}/easytier-linux-x86_64/easytier-web-embed \
--db ${path}/easytier-linux-x86_64/web-embed/easytier-web-embed.db \
--file-log-level warn \
--file-log-dir ${path}/easytier-linux-x86_64/web-embed/easytier-web-embed-log \
--config-server-port ${port1} \
--config-server-protocol udp \
--api-server-port ${port2} \
--web-server-port ${port2} \
--api-host http://${domain}:${port2}

[Install]
WantedBy=multi-user.target

因为在配置项中使用到了 ${path}/easytier-linux-x86_64/web-embed

职责链模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

很多情况下，在一个软件系统中可以处理某个请求的对象不止一个，例如SCM系统中的采购单审批，主任、副董事长、董事长和董事会都可以处理采购单，他们可以构成一条处理采购单的链式结构，采购单沿着这条链进行传递，这条链就称为职责链。职责链可以是一条直线、一个环或者一个树形结构，最常见的职责链是直线型，即沿着一条单向的链来传递请求。链上的每一个对象都是请求处理者，职责链模式可以将请求的处理者组织成一条链，并让请求沿着链传递，由链上的处理者对请求进行相应的处理，客户端无须关心请求的处理细节以及请求的传递，只需将请求发送到链上即可，实现请求发送者和请求处理者解耦。

定义

职责链模式(Chain of Responsibility Pattern)：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。

结构图

角色

在职责链模式结构图中包含如下几个角色：

● Handler**（抽象处理者）**：它定义了一个处理请求的接口，一般设计为抽象类，由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象（如结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。

● ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

典型代码

abstract class Handler {
 //维持对下家的引用
protected Handler successor;
 
 public void setSuccessor(Handler successor) {
 this.successor=successor;
 }
 
 public abstract void handleRequest(String request);
}

上述代码中，抽象处理者类定义了对下家的引用对象，以便将请求转发给下家，该对象的访问符可设为protected，在其子类中可以使用。在抽象处理者类中声明了抽象的请求处理方法，具体实现交由子类完成。

具体处理者是抽象处理者的子类，它具有两大作用：

第一是处理请求，不同的具体处理者以不同的形式实现抽象请求处理方法handleRequest()；

第二是转发请求，如果该请求超出了当前处理者类的权限，可以将该请求转发给下家。具体处理者类的典型代码如下：

class ConcreteHandler extends Handler {
 public void handleRequest(String request) {
 if (请求满足条件) {
 //处理请求
 }
 else {
 this.successor.handleRequest(request); //转发请求
 }
 }
}

在具体处理类中通过对请求进行判断可以做出相应的处理。

02点亮LED

Thu, 08 May 2025 00:00:00 +0000

LED

1. 原理图

2. 描述

流水灯模块使用P1 进行IO操作。并使用共地。默认高电平所以需要点亮LED等，就是将P1口地线接通即可。

3. 点亮LED

第一个LED

P1引脚一共8位。此处变量LED设置P1.0（即P1引脚第0位）

#include <reg52.h>

sbit LED = P1^0; // 定义P1.0为LED引脚

void main() {
 LED = 0; // 输出低电平，点亮LED（共地接法）
 while (1); // 保持程序运行
}

同时点亮1 3 5 led

#include <reg52.h>

sbit LED1 = P1^0;
sbit LED3 = P1^2;
sbit LED5 = P1^4;
void main() {
 LED1 = 0;
 LED3 = 0;
 LED5 = 0;
 while (1);
}

#include <reg52.h>

void main() {
 // 0xEA 在二进制表示为 11101010
 P1 = 0xEA; 
 while (1);
}

轮流点亮每一个LED

#include <reg52.h>

unsigned char a;
void delay();

void main() {
 while(1) {
 delay();
 for(a = 0; a < 8; a++) {
 P1 = P1 << 1;
 delay();
 }
 P1 = 0xFF;
 }
}

void delay() {
 int i = 65535;
 while(i--);
}

轮流点亮每一个LED，每次只点亮一个从左向右

这里要用到一个 intrins 的 corl 循环左移 corr 循环右移 nop 空指令

002进入名为nginx的pod

Mon, 01 Jan 0001 00:00:00 +0000

本案例基于案例001

kubectl -it exec nginx -- bash
 root@nginx:/# echo 'Hello K8S' > /usr/share/nginx/html/index.html
 root@nginx:/# exit
 exit

curl 172.20.177.22
 Hello K8S

02边缘测

Mon, 01 Jan 0001 00:00:00 +0000

https://thingsboard.io/docs/edge/getting-started/

新增边缘实例

创建完成后弹出连接方式

关闭连接方式弹窗后。再重新找到连接方式的弹窗

当边缘侧完成连接后，“安装和连接说明” 则变成了 “升级说明”

填写完表单后，此处以docker创建为例

复制docker tag中的docker-compose


services:
 mytbedge:
 restart: always
 image: "thingsboard/tb-edge:4.0.1EDGE"
 ports:
 - "8080:8080"
 - "1883:1883"
 - "5683-5688:5683-5688/udp"
 environment:
 SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/tb-edge
 CLOUD_ROUTING_KEY: 7ea62ac2-fd91-42cf-e234-67b84e9caa74
 CLOUD_ROUTING_SECRET: i8wuwniqc766kh4vch1n
 CLOUD_RPC_HOST: home.anzhongwei.cn
 CLOUD_RPC_PORT: 57070
 CLOUD_RPC_SSL_ENABLED: false
 volumes:
 - tb-edge-data:/data
 - tb-edge-logs:/var/log/tb-edge
 
 postgres:
 restart: always
 image: "postgres:16"
 ports:
 - "5432"
 environment:
 POSTGRES_DB: tb-edge
 POSTGRES_PASSWORD: postgres
 volumes:
 - tb-edge-postgres-data:/var/lib/postgresql/data

volumes:
 tb-edge-data:
 name: tb-edge-data
 tb-edge-logs:
 name: tb-edge-logs
 tb-edge-postgres-data:
 name: tb-edge-postgres-data

使用docker运行起来

02工厂三兄弟之工厂方法模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

简单工厂模式虽然简单，但存在一个很严重的问题。

当系统中需要引入新产品时，由于静态工厂方法通过所传入参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背“开闭原则”，如何实现增加新产品而不影响已有代码？

工厂方法模式应运而生，本文将介绍第二种工厂模式——工厂方法模式。

在简单工厂模式中只提供一个工厂类，该工厂类处于对产品类进行实例化的中心位置，它需要知道每一个产品对象的创建细节，并决定何时实例化哪一个产品类。

简单工厂模式最大的缺点是当有新产品要加入到系统中时，必须修改工厂类，需要在其中加入必要的业务逻辑，这违背了“开闭原则”。

此外，在简单工厂模式中，所有的产品都由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具体产品与工厂类之间的耦合度高，严重影响了系统的灵活性和扩展性，而工厂方法模式则可以很好地解决这一问题。

在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。

定义

工厂方法模式(Factory Method Pattern)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式(Factory Pattern)，又可称作虚拟构造器模式(Virtual Constructor Pattern)或多态工厂模式(Polymorphic Factory Pattern)。工厂方法模式是一种类创建型模式。

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方法，创建具体的产品对象。

结构

角色

**● Product（抽象产品）：**它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。

**● ConcreteProduct（具体产品）：**它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。

**● Factory（抽象工厂）：**在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。

**● ConcreteFactory（具体工厂）：**它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

与简单工厂模式相比，工厂方法模式最重要的区别是引入了抽象工厂角色，抽象工厂可以是接口，也可以是抽象类或者具体类

典型代码

public interface Factory {
 Product factoryMethod();
}

在抽象工厂中声明了工厂方法但并未实现工厂方法，具体产品对象的创建由其子类负责，客户端针对抽象工厂编程，可在运行时再指定具体工厂类，具体工厂类实现了工厂方法，不同的具体工厂可以创建不同的具体产品，其典型代码如下所示：

public class ConcreteFactory implements Factory {
 @Override
 public Product factoryMethod() {
 return new ConcreteProduct();
 }
}

在实际使用时，具体工厂类在实现工厂方法时除了创建具体产品对象之外，还可以负责产品对象的初始化工作以及一些资源和环境配置工作，例如连接数据库、创建文件等。

02面向对象设计原则

Mon, 01 Jan 0001 00:00:00 +0000

概述

对于面向对象软件系统的设计而言，在支持可维护性的同时，提高系统的可复用性是一个至关重要的问题，如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。

在面向对象设计中，可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想，可以从不同的角度提升一个软件结构的设计水平。

面向对象设计原则为支持可维护性复用而诞生，这些原则蕴含在很多设计模式中，它们是从许多设计方案中总结出的指导性原则。

面向对象设计原则也是我们用于评价一个设计模式的使用效果的重要指标之一，在设计模式的学习中，大家经常会看到诸如“XXX模式符合XXX原则”、“XXX模式违反了XXX原则”这样的语句。

最常见的7种面向对象设计原则如下表所示：

设计原则名称	定义	使用频率
单一职责原则(Single Responsibility Principle, SRP)	一个类只负责一个功能领域中的相应职责	★★★★☆
开闭原则(Open-Closed Principle, OCP)	软件实体应对扩展开放，而对修改关闭	★★★★★
里氏代换原则(Liskov Substitution Principle, LSP)	所有引用基类对象的地方能够透明地使用其子类的对象	★★★★★
依赖倒转原则(Dependence Inversion Principle, DIP)	抽象不应该依赖于细节，细节应该依赖于抽象	★★★★★
接口隔离原则(Interface Segregation Principle, ISP)	使用多个专门的接口，而不使用单一的总接口	★★☆☆☆
合成复用原则(Composite Reuse Principle, CRP)	尽量使用对象组合，而不是继承来达到复用的目的	★★★★☆
迪米特法则(Law of Demeter, LoD)	一个软件实体应当尽可能少地与其他实体发生相互作用	★★★☆☆

单一职责原则

单一职责原则是最简单的面向对象设计原则，它用于控制类的粒度大小。单一职责原则定义如下：

单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而且一个类承担的职责过多，就相当于将这些职责耦合在一起，当其中一个职责变化时，可能会影响其他职责的运作，因此要将这些职责进行分离，将不同的职责封装在不同的类中，即将不同的变化原因封装在不同的类中，如果多个职责总是同时发生改变则可将它们封装在同一类中。

单一职责原则是实现高内聚、低耦合的指导方针，它是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，而发现类的多重职责需要设计人员具有较强的分析设计能力和相关实践经验。

下面通过一个简单实例来进一步分析单一职责原则：

例如一个CRM（Customer Relationship Management）客户管理系统）系统中客户信息图形统计模块的初始设计方案

CustomerDataChart类中的方法说明如下：

Golang单元测试02

Mon, 01 Jan 0001 00:00:00 +0000

搞定Go单元测试（二）—— mock框架(gomock)

通过阅读上一篇文章，相信你对怎么做单元测试已经有了初步的概念，可以着手对现有的项目进行改造并开展测试了。学会了走路，我们尝试跑起来，本篇主要介绍gomock测试框架，让我们的单元测试更加有效率。

表格驱动测试方法(Table Driven Tests)

当针对某方法进行单元测试的时候，通常不止写一个测试用例，我们需要测试该方法在多种入参条件下是否都能正常工作，特别是要针对边界值进行测试。通常这个时候表格驱动测试就派上用场了——当你发现你在写测试方法的时候用上了复制粘贴，这就说明你需要考虑使用表格驱动测试来构建你的测试方法了。我们依旧来举个例子：

func TestTime(t *testing.T) {
 testCases := []struct { // 设计我们的测试用例
 gmt string
 loc string
 want string
 }{
 {"12:31", "Europe/Zuri", "13:31"}, // incorrect location name
 {"12:31", "America/New_York", "7:31"}, // should be 07:31
 {"08:08", "Australia/Sydney", "18:08"},
 }
 for _, tc := range testCases { // 循环执行测试用例
 loc, err := time.LoadLocation(tc.loc)
 if err != nil {
 t.Fatalf("could not load location %q", tc.loc)
 }
 gmt, _ := time.Parse("15:04", tc.gmt)
 if got := gmt.In(loc).Format("15:04"); got != tc.want {
 t.Errorf("In(%s, %s) = %s; want %s", tc.gmt, tc.loc, got, tc.want)
 }
 }
}

表格驱动测试方法让我们的测试方法更加清晰和简练，减少了复制粘贴，并大大提高的测试代码的可读性。

还记得上文说单元测试也是需要维护的吗？单元测试也是代码的一部分，也应当被认真对待。记得要用表格驱动测试的方法来组织你的测试用例，同时别忘了像正式代码那样，写上相应的注释。更多参考： github.com/golang/go/w… blog.golang.org/subtests

使用测试框架——gomock

What is gomock?

gomock是Google开源的golang测试框架。或者引用官方的话来说：“GoMock is a mocking framework for the Go programming language”。

方法二实现Runnable接口

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * 方法2实现Runnable接口
 */
public class M02ImplentRunnable {
 public static void main(String[] args) {
 Runnable runnable = new Runnable() {
 @Override
 public void run() {
 for(int i = 0; i < 3; i++) {
 System.out.println("runnablex线程输出"+i);
 }
 }
 };
 new Thread(runnable).start();
 System.out.println("主线程输出");
 }
}

汇编语言入门二：环境有了先过把瘾

Mon, 01 Jan 0001 00:00:00 +0000

上回说到，咱们把环境搭好了，可以开始玩耍汇编了。

寄存器是啥玩意儿？

开始学C的时候，有没有一种感觉，变量？类型？我可是要改变世界的男人，怎么就成天在跟i++较劲啊？这黑框程序还只能用来算数学，跟说好的不一样呢？？？想必后来，见得多了，你的想法也不那么幼稚了吧。

好了，接下来汇编也会给你同样一种感觉的。啥玩意儿？寄存器？寻址？说好的变量类型循环函数呢？。

好了，我想先刻意避开这些晦涩难懂的东西，找到感觉了，再回头来研究条条框框。在此先把基本的几个简单的东西弄熟练，过早引入太多概念容易让人头昏眼花。

这里就说寄存器，通俗地来解释一下。回到上小学的时候，现在有一大堆计算题：

99+10=
32-20=
14+21=
47-9=
87+3=
86-8=
...

正常来讲，要算出这个么多题目，你需要一支笔，一边计算的同时一边把结果写下来。

好了，到这里，我就来做个类比，助你大致理解寄存器是干啥用的。首先，我们把CPU和大脑做一个类比。

你在纸上进行计算的时候，需要不断往纸上写下计算结果，一边在脑子里进行计算。大致过程就像：

1. 在纸上找一个题目，先看清两个数字，并迅速记下来
2. 在脑子里对这两个数字进行计算，计算出的结果也是记在脑子里的
3. 将计算结果写在纸上，继续做下一个题目

好了，这个过程就和计算机执行的过程有几分相似。草稿纸就相当于是个内存，脑子就是CPU。

在计算的时候，你需要知道计算的两个数字，而且还得知道是做什么运算，这些信息都是从草稿纸上看见之后，短暂记忆在脑子里的。

CPU在计算的时候也是一样，需要知道要计算的数据是什么，还得知道是做什么运算，这些信息也需要临时保存在CPU的某个地方。这个地方就是寄存器。

好了到这里，不知道你有没有看明白？也就是说CPU里头的寄存器的作用，就像我们在做计算的时候会临时在脑子里记住数字一样。当然你的脑子能记住不止一个数据，CPU也不止一个寄存器。

为啥C语言里没有说这些？

就是因为写汇编语言的时候，要在有限的寄存器情况下，编写复杂的程序，还要考虑灵活性、性能、正确性等等乱七八糟的问题，对于程序员是一个超级大的负担。

因此有人专门发明了许多更方便好用的“高级语言”，然后还专门写了个配套的程序能够把用这个“高级语言”写的东西翻译成汇编语言，再将汇编语言翻译成机器能执行的指令。其中之一就是C语言。也就是C语言发明出来就是奔着比汇编语言好用的目标去的。所以啊，相比汇编这种繁琐复杂的编程方式，高级语言不知道高级到哪里去了。

那学习汇编语言有用吗？

没有。

开始一顿乱写

好了，先介绍个程序，运行完了能够开心一下：

global main

main:
 mov eax, 1
 mov ebx, 2
 add eax, ebx
 ret

老套路，保存成文件，比如叫做nmb.asm，然后编译运行：

$ nasm -f elf nmb.asm -o nmb.o
$ gcc -m32 nmb.o -o nmb
$ ./nmb ; echo $?
3

如果你能看出来这里面的端倪，说明你是一个聪明伶俐的天才。不就是做了个算术题1+2=3么。

键盘事件编码

Mon, 01 Jan 0001 00:00:00 +0000

event.keycode大全(javascript)


keycode 8 = BackSpace BackSpace 
keycode 9 = Tab Tab 
keycode 12 = Clear 
keycode 13 = Enter 
keycode 16 = Shift_L 
keycode 17 = Control_L 
keycode 18 = Alt_L 
keycode 19 = Pause 
keycode 20 = Caps_Lock 
keycode 27 = Escape Escape 
keycode 32 = space space 
keycode 33 = Prior 
keycode 34 = Next 
keycode 35 = End 
keycode 36 = Home 
keycode 37 = Left 
keycode 38 = Up 
keycode 39 = Right 
keycode 40 = Down 
keycode 41 = Select 
keycode 42 = Print 
keycode 43 = Execute 
keycode 45 = Insert 
keycode 46 = Delete 
keycode 47 = Help 
keycode 48 = 0 equal braceright 
keycode 49 = 1 exclam onesuperior 
keycode 50 = 2 quotedbl twosuperior 
keycode 51 = 3 section threesuperior 
keycode 52 = 4 dollar 
keycode 53 = 5 percent 
keycode 54 = 6 ampersand 
keycode 55 = 7 slash braceleft 
keycode 56 = 8 parenleft bracketleft 
keycode 57 = 9 parenright bracketright 
keycode 65 = a A 
keycode 66 = b B 
keycode 67 = c C 
keycode 68 = d D 
keycode 69 = e E EuroSign 
keycode 70 = f F 
keycode 71 = g G 
keycode 72 = h H 
keycode 73 = i I 
keycode 74 = j J 
keycode 75 = k K 
keycode 76 = l L 
keycode 77 = m M mu 
keycode 78 = n N 
keycode 79 = o O 
keycode 80 = p P 
keycode 81 = q Q at 
keycode 82 = r R 
keycode 83 = s S 
keycode 84 = t T 
keycode 85 = u U 
keycode 86 = v V 
keycode 87 = w W 
keycode 88 = x X 
keycode 89 = y Y 
keycode 90 = z Z 
keycode 96 = KP_0 KP_0 
keycode 97 = KP_1 KP_1 
keycode 98 = KP_2 KP_2 
keycode 99 = KP_3 KP_3 
keycode 100 = KP_4 KP_4 
keycode 101 = KP_5 KP_5 
keycode 102 = KP_6 KP_6 
keycode 103 = KP_7 KP_7 
keycode 104 = KP_8 KP_8 
keycode 105 = KP_9 KP_9 
keycode 106 = KP_Multiply KP_Multiply 
keycode 107 = KP_Add KP_Add

keycode 108 = KP_Separator KP_Separator 
keycode 109 = KP_Subtract KP_Subtract 
keycode 110 = KP_Decimal KP_Decimal 
keycode 111 = KP_Divide KP_Divide 
keycode 112 = F1 
keycode 113 = F2 
keycode 114 = F3 
keycode 115 = F4 
keycode 116 = F5 
keycode 117 = F6 
keycode 118 = F7 
keycode 119 = F8 
keycode 120 = F9 
keycode 121 = F10 
keycode 122 = F11 
keycode 123 = F12 
keycode 124 = F13 
keycode 125 = F14 
keycode 126 = F15 
keycode 127 = F16 
keycode 128 = F17 
keycode 129 = F18 
keycode 130 = F19 
keycode 131 = F20 
keycode 132 = F21 
keycode 133 = F22 
keycode 134 = F23 
keycode 135 = F24 
keycode 136 = Num_Lock 
keycode 137 = Scroll_Lock 
keycode 187 = acute grave 
keycode 188 = comma semicolon 
keycode 189 = minus underscore 
keycode 190 = period colon 
keycode 192 = numbersign apostrophe 
keycode 210 = plusminus hyphen macron 
keycode 211 = 
keycode 212 = copyright registered 
keycode 213 = guillemotleft guillemotright 
keycode 214 = masculine ordfeminine 
keycode 215 = ae AE 
keycode 216 = cent yen 
keycode 217 = questiondown exclamdown 
keycode 218 = onequarter onehalf threequarters 
keycode 220 = less greater bar 
keycode 221 = plus asterisk asciitilde 
keycode 227 = multiply division

keycode 228 = acircumflex Acircumflex 
keycode 229 = ecircumflex Ecircumflex 
keycode 230 = icircumflex Icircumflex 
keycode 231 = ocircumflex Ocircumflex 
keycode 232 = ucircumflex Ucircumflex 
keycode 233 = ntilde Ntilde 
keycode 234 = yacute Yacute 
keycode 235 = oslash Ooblique 
keycode 236 = aring Aring 
keycode 237 = ccedilla Ccedilla 
keycode 238 = thorn THORN 
keycode 239 = eth ETH 
keycode 240 = diaeresis cedilla currency 
keycode 241 = agrave Agrave atilde Atilde 
keycode 242 = egrave Egrave 
keycode 243 = igrave Igrave 
keycode 244 = ograve Ograve otilde Otilde 
keycode 245 = ugrave Ugrave 
keycode 246 = adiaeresis Adiaeresis 
keycode 247 = ediaeresis Ediaeresis 
keycode 248 = idiaeresis Idiaeresis 
keycode 249 = odiaeresis Odiaeresis 
keycode 250 = udiaeresis Udiaeresis 
keycode 251 = ssharp question backslash 
keycode 252 = asciicircum degree 
keycode 253 = 3 sterling 
keycode 254 = Mode_switch

使用event对象的keyCode属性判断输入的键值
eg：if(event.keyCode==13)alert(“enter!”);
键值对应表
A　　0X65 　U 　　0X85
B　　0X66　 V　　 0X86
C　　0X67　 W　　 0X87
D　　0X68　 X 　　0X88
E　　0X69　 Y　　 0X89
F　　0X70　 Z　　 0X90
G　　0X71　 0　　 0X48
H　　0X72　 1　　 0X49
I　　0X73　 2　　 0X50
J　　0X74　 3 　　0X51
K　　0X75　 4 　　0X52
L　　0X76　 5 　　0X53
M　　0X77　 6　　 0X54
N　　0X78 　7 　　0X55
O　　0X79 　8 　　0X56
P　　0X80 　9 　　0X57
Q　　0X81　ESC　　0X1B
R　　0X82　CTRL 　0X11
S　　0X83　SHIFT　0X10
T　　0X84　ENTER　0XD

如果要使用组合键，则可以利用event.ctrlKey，event.shiftKey，event .altKey判断是否按下了ctrl键、shift键以及alt键

交接模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

桥接模式是一种很实用的结构型设计模式，如果软件系统中某个类存在两个独立变化的维度，通过该模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合“单一职责原则”。

与多层继承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。

桥接模式用一种巧妙的方式处理多层继承存在的问题，用抽象关联取代了传统的多层继承，将类之间的静态继承关系转换为动态的对象组合关系，使得系统更加灵活，并易于扩展，同时有效控制了系统中类的个数。

定义

桥接模式(Bridge Pattern)：将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式，又称为柄体(Handle and Body)模式或接口(Interface)模式。

桥接模式的结构与其名称一样，存在一条连接两个继承等级结构的桥。

结构

角色

●Abstraction（抽象类）：用于定义抽象类的接口，它一般是抽象类而不是接口，其中定义了一个Implementor（实现类接口）类型的对象并可以维护该对象，它与Implementor之间具有关联关系，它既可以包含抽象业务方法，也可以包含具体业务方法。

●RefinedAbstraction（扩充抽象类）：扩充由Abstraction定义的接口，通常情况下它不再是抽象类而是具体类，它实现了在Abstraction中声明的抽象业务方法，在RefinedAbstraction中可以调用在Implementor中定义的业务方法。

●Implementor（实现类接口）：定义实现类的接口，这个接口不一定要与Abstraction的接口完全一致，事实上这两个接口可以完全不同，一般而言，Implementor接口仅提供基本操作，而Abstraction定义的接口可能会做更多更复杂的操作。Implementor接口对这些基本操作进行了声明，而具体实现交给其子类。通过关联关系，在Abstraction中不仅拥有自己的方法，还可以调用到Implementor中定义的方法，使用关联关系来替代继承关系。

●ConcreteImplementor（具体实现类）：具体实现Implementor接口，在不同的ConcreteImplementor中提供基本操作的不同实现，在程序运行时，ConcreteImplementor对象将替换其父类对象，提供给抽象类具体的业务操作方法。

典型代码

桥接模式是一个非常有用的模式，在桥接模式中体现了很多面向对象设计原则的思想，包括“单一职责原则”、“开闭原则”、“合成复用原则”、“里氏代换原则”、“依赖倒转原则”等。熟悉桥接模式有助于我们深入理解这些设计原则，也有助于我们形成正确的设计思想和培养良好的设计风格。

在使用桥接模式时，我们首先应该识别出一个类所具有的两个独立变化的维度，将它们设计为两个独立的继承等级结构，为两个维度都提供抽象层，并建立抽象耦合。

通常情况下，我们将具有两个独立变化维度的类的一些普通业务方法和与之关系最密切的维度设计为“抽象类”层次结构（抽象部分），而将另一个维度设计为“实现类”层次结构（实现部分）。

例如：对于毛笔而言，由于型号是其固有的维度，因此可以设计一个抽象的毛笔类，在该类中声明并部分实现毛笔的业务方法，而将各种型号的毛笔作为其子类；

颜色是毛笔的另一个维度，由于它与毛笔之间存在一种“设置”的关系，因此我们可以提供一个抽象的颜色接口，而将具体的颜色作为实现该接口的子类。

在此，型号可认为是毛笔的抽象部分，而颜色是毛笔的实现部分，结构示意图：

如果需要增加一种新型号的毛笔，只需扩展左侧的“抽象部分”，增加一个新的扩充抽象类；如果需要增加一种新的颜色，只需扩展右侧的“实现部分”，增加一个新的具体实现类。扩展非常方便，无须修改已有代码，且不会导致类的数目增长过快。

在具体编码实现时，由于在桥接模式中存在两个独立变化的维度，为了使两者之间耦合度降低，首先需要针对两个不同的维度提取抽象类和实现类接口，并建立一个抽象关联关系。对于“实现部分”维度，典型的实现类接口代码如下所示：

interface Implementor {
 public void operationImpl();
}

在实现Implementor接口的子类中实现了在该接口中声明的方法，用于定义与该维度相对应的一些具体方法。

对于另一“抽象部分”维度而言，其典型的抽象类代码如下所示：

abstract class Abstraction {
 protected Implementor impl; //定义实现类接口对象
 
 public void setImpl(Implementor impl) {
 this.impl=impl;
 }
 
 public abstract void operation(); //声明抽象业务方法
}

在抽象类Abstraction中定义了一个实现类接口类型的成员对象impl，再通过注入的方式给该对象赋值，一般将该对象的可见性定义为protected，以便在其子类中访问Implementor的方法，其子类一般称为扩充抽象类或细化抽象类(RefinedAbstraction)，典型的RefinedAbstraction类代码如下所示：

命令模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

装修新房的最后几道工序之一是安装插座和开关，通过开关可以控制一些电器的打开和关闭，例如电灯或者排气扇。

在购买开关时，我们并不知道它将来到底用于控制什么电器，也就是说，开关与电灯、排气扇并无直接关系，一个开关在安装之后可能用来控制电灯，也可能用来控制排气扇或者其他电器设备。

开关与电器之间通过电线建立连接，如果开关打开，则电线通电，电器工作；

反之，开关关闭，电线断电，电器停止工作。相同的开关可以通过不同的电线来控制不同的电器。

我们可以将开关理解成一个请求的发送者，用户通过它来发送一个“开灯”请求，而电灯是“开灯”请求的最终接收者和处理者。

开关和电灯之间并不存在直接耦合关系，它们通过电线连接在一起，使用不同的电线可以连接不同的请求接收者，只需更换一根电线，相同的发送者（开关）即可对应不同的接收者（电器）。

在软件开发中也存在很多与开关和电器类似的请求发送者和接收者对象，例如一个按钮，它可能是一个“关闭窗口”请求的发送者，而按钮点击事件处理类则是该请求的接收者。

为了降低系统的耦合度，将请求的发送者和接收者解耦，我们可以使用一种被称之为命令模式的设计模式来设计系统，在命令模式中，发送者与接收者之间引入了新的命令对象（类似图1中的电线），将发送者的请求封装在命令对象中，再通过命令对象来调用接收者的方法。本章我们将学习用于将请求发送者和接收者解耦的命令模式。

在软件开发中，我们经常需要向某些对象发送请求（调用其中的某个或某些方法），但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，此时，我们特别希望能够以一种松耦合的方式来设计软件，使得请求发送者与请求接收者能够消除彼此之间的耦合，让对象之间的调用关系更加灵活，可以灵活地指定请求接收者以及被请求的操作。命令模式为此类问题提供了一个较为完美的解决方案。

命令模式可以将请求发送者和接收者完全解耦，发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。

定义

命令模式(Command Pattern)：将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。

结构

角色

● Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。

● ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作(Action)。

● Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。

● Receiver（接收者）：接收者执行与请求相关的操作，它具体实现对请求的业务处理。

命令模式的本质是对请求进行封装，一个请求对应于一个命令，将发出命令的责任和执行命令的责任分割开。每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行相应的操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求如何被接收、操作是否被执行、何时被执行，以及是怎么被执行的。

**命令模式的关键在于引入了抽象命令类，请求发送者针对抽象命令类编程，只有实现了抽象命令类的具体命令才与请求接收者相关联。**在最简单的抽象命令类中只包含了一个抽象的execute()方法，每个具体命令类将一个Receiver类型的对象作为一个实例变量进行存储，从而具体指定一个请求的接收者，不同的具体命令类提供了execute()方法的不同实现，并调用不同接收者的请求处理方法。

典型代码

abstract class Command {
 public abstract void execute();
}

对于请求发送者即调用者而言，将针对抽象命令类进行编程，可以通过构造注入或者设值注入的方式在运行时传入具体命令类对象，并在业务方法中调用命令对象的execute()方法

class Invoker {
 private Command command;
 
 //构造注入
 public Invoker(Command command) {
 this.command = command;
 }
 
 //设值注入
 public void setCommand(Command command) {
 this.command = command;
 }
 
 //业务方法，用于调用命令类的execute()方法
 public void call() {
 command.execute();
 }
}

具体命令类继承了抽象命令类，它与请求接收者相关联，实现了在抽象命令类中声明的execute()方法，并在实现时调用接收者的请求响应方法action()

03数码管

Thu, 08 May 2025 00:00:00 +0000

数码管

静态显示

根据开发板原理图数码管由两个锁存器共同控制

型号为74HC573，接下来看锁存器说明

带上划线的OE，表示低电平有效

所以看表当OE为高电平时，不论LE D 如何输出都是高阻态（用Z表示）

当OE为底电平时，LE为低电平时，此时就锁住了输出值（用Q0 表示）当OE为底电平时，LE为高电平时，此时输出随D口变化而变化也就是连通状态

回到我们的锁存器电路图，OE均接地，所以已经是低电平有效。所以我们要控制的就是LE 让她为高电平就变化锁存器里面的值。之后改成低电平来锁住值。

我们的单片机数码管是8位共阴极数码管 U8锁存器是作为位选，U9 锁存器是段选

段选是表示数码管要显示什么数字位选(位置选择)是表示一个8段数码管（每一个8. 作为一段）那些需要点亮

例如我们要显示从右侧开始 1357段数码管显示数字5

#include <reg52.h>
#include <intrins.h>

void delay(unsigned int z);

sbit DULA = P2^6; // 段选LE控制
sbit WELA = P2^7; // 位选LE控制
unsigned char code leddata[]={ 
 0x3F, //"0"
 0x06, //"1"
 0x5B, //"2"
 0x4F, //"3"
 0x66, //"4"
 0x6D, //"5"
 0x7D, //"6"
 0x07, //"7"
 0x7F, //"8"
 0x6F //"9"

};

void main() {
 DULA = 1;
 P0 = leddata[5];
 DULA = 0;
 
 delay(10);
 WELA = 1;
 P0 = 0x55;
 WELA = 0;
 
 while(1);
}

void delay(unsigned int z) {
 unsigned int x,y;
 for(x = z; x > 0; x--) 
 for(y=0; y<125; y++);
}

另一个例子从0-9 循环显示每次间隔1s

003创建一个名称为nginx的deployment

Mon, 01 Jan 0001 00:00:00 +0000

本案例基于案例001

kubectl create deployment nginx --image=docker.io/library/nginx:1.21.6
 deployment.apps/nginx created

kubectl get deployment -w
 NAME READY UP-TO-DATE AVAILABLE AGE
 nginx 0/1 1 0 15s
 nginx 1/1 1 1 15s

kubectl get pod -o wide
 NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
 # 注意这里pod名称分段 784757bdfb为rs的hash
 nginx-784757bdfb-z6gd6 1/1 Running 0 45s 172.20.177.24 k8s-192-168-0-19 <none> <none>

kubectl scale deployment nginx --replicas=2
 deployment.apps/nginx scaled

kubectl get deployment -w
 NAME READY UP-TO-DATE AVAILABLE AGE
 nginx 1/2 2 1 70s
 nginx 2/2 2 2 75s

kubectl get pod -o wide
 NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
 nginx-784757bdfb-2q58h 1/1 Running 0 25s 172.20.182.149 k8s-192-168-0-11 <none> <none>
 nginx-784757bdfb-z6gd6 1/1 Running 0 85s 172.20.177.24 k8s-192-168-0-19 <none> <none>

ES6语法

Mon, 01 Jan 0001 00:00:00 +0000

声明变量

ES6之前声明变量的方式：var 、 let 、 const

var

变量提升: 声明的变量会提升到函数作用域的顶部

{
 var a = 1;
}
console.log(a);

var 可以声明多次


var a = 1;
var a = 2;
console.log(a);

let

块作用域,具有严格的作用于域

{
 let a = 1;
 console.log(a);
}
console.log(a); // ReferenceError: a is not defined

let 只能声明一次

let a = 1;
let a = 2;
console.log(a); // SyntaxError: Identifier 'a' has already been declared

### const

1. const 声明的变量必须初始化，并且不能被改变
```javascript
const a;
console.log(a); // SyntaxError: Missing initializer in const declaration

const a = 1;
a = 2; // TypeError: Assignment to constant variable.
console.log(a);

解构表达式

数组解构

let arr = [1,2,3];

// 传统用法
// let a = arr[0];
// let b = arr[1];
// let c = arr[2];

// 解构用法
let [a,b,c] = arr;

对象解构

let obj = {
 name: 'zhangsan',
 age: 18
 sex: 'male'
}
// 传统用法
let name = obj.name;
let age = obj.age;
let sex = obj.sex;

// 解构用法
let {name,age,sex} = obj;
console.log(name,age,sex);

字符串扩展

let str = "hello.vue";
console.log(str.startsWith("hello"));//true
console.log(str.endsWith(".vue"));//true
console.log(str.includes("e"));//true
console.log(str.includes("hello"));//true


//多行字符串
let ss = `<div>
 <span>hello world<span>
</div>`;
console.log(ss);

// 2、字符串插入变量和表达式。变量名写在 ${} 中，${} 中可以放入 JavaScript 表达式。

function fun() {
 return "这是一个函数"
}

let info = `我是${abc}，今年${age + 10}了, 我想说： ${fun()}`;
console.log(info);

函数参数优化

默认值

//在ES6以前，我们无法给一个函数参数设置默认值，只能采用变通写法：
function add(a, b) {
 // 判断b是否为空，为空就给默认值1
 b = b || 1;
 return a + b;
}
// 传一个参数
console.log(add(10));


//现在可以这么写：直接给参数写上默认值，没传就会自动使用默认值
function add2(a, b = 1) {
 return a + b;
}
console.log(add2(20));

不定参数

function fun(...values) {
 console.log(values.length)
}
fun(1, 2)      //2
fun(1, 2, 3, 4)  //4

箭头函数

// case1
var print = function (obj) {
    console.log(obj);
}

var print = obj => console.log(obj);
print("hello");

// case2
var sum = function (a, b) {
 c = a + b;
 return a + c;
}
// case2 箭头函数1
var sum2 = (a, b) => a + b;
console.log(sum2(11, 12));
// case2 箭头函数2
var sum3 = (a, b) => {
 c = a + b;
 return a + c;
}
console.log(sum3(10, 20))

// case3 箭头函数+解构
const person = {
 name: "jack",
 age: 21,
 language: ['java', 'js', 'css']
}

// 传统用法
function hello(person) {
 console.log("hello," + person.name)
}

//箭头函数+解构
var hello2 = ({name}) => console.log("hello," +name);
hello2(person); // 直接把包含name属性的一个对象扔进来就行

对象优化

// case1
const person = {
 name: "jack",
 age: 21,
 language: ['java', 'js', 'css']
}

// [
// "name",
// "age",
// "language"
// ]
console.log(Object.keys(person));

// [
// "jack",
// 21,
// [
// "java",
// "js",
// "css"
// ]
// ]
console.log(Object.values(person));

// [
// [
// "name",
// "jack"
// ],
// [
// "age",
// 21
// ],
// [
// "language",
// [
// "java",
// "js",
// "css"
// ]
// ]
// ]
console.log(Object.entries(person));//[Array(2), Array(2), Array(2)]


// case2
const target = { a: 1 };
const source1 = { b: 2 };
const source2 = { c: 3 };

//{a:1,b:2,c:3}
Object.assign(target, source1, source2);

// {
// "a": 1,
// "b": 2,
// "c": 3
// }
console.log(target);

// case3 声明对象简写
const age = 23
const name = "张三"
const person1 = { age: age, name: name }

const person2 = { age, name }
console.log(person2);

// case4 对象的函数属性简写
let person3 = {
 name: "jack",
 // 以前：
 eat: function (food) {
 console.log(this.name + "在吃" + food);
 },
 //箭头函数this不能使用，对象.属性
 eat2: food => console.log(person3.name + "在吃" + food),
 eat3(food) {
 console.log(this.name + "在吃" + food);
 }
}

person3.eat("香蕉");

person3.eat2("苹果")

person3.eat3("橘子");

// case5 对象拓展运算符

// 1、拷贝对象（深拷贝）
let p1 = { name: "Amy", age: 15 }
let someone = { ...p1 }
console.log(someone)  //{name: "Amy", age: 15}

// 2、合并对象
let age1 = { age: 15 }
let name1 = { name: "Amy" }
let p2 = {name:"zhangsan"}
p2 = { ...age1, ...name1 } 
console.log(p2)

map和reduce

数组中新增了map和reduce方法。

Golang单元测试03

Mon, 01 Jan 0001 00:00:00 +0000

搞定Go单元测试（三）—— 断言（testify）

在上一篇，介绍了表格驱动测试方法和gomock测试框架，大大提升了测试效率与质量。本篇将介绍在测试中引入断言（assertion），进一步提升测试效率与质量。

为什么需要断言库

我们先来看看Go标准包中为什么没有断言，官方在FAQ里面回答了这个问题。

golang.org/doc/faq#ass…

总体概括一下大意就是：“Go不提供断言，我们知道这会带来一定的不便，其主要目的是为了防止你们这些程序员在错误处理上偷懒。我们知道这是一个争论点，但是我们觉得这样很coooool~~。”所以，我们引入断言库的原因也很明显了：偷懒，引入断言能为我们提供便利——提高测试效率，增强代码可读性。

testify

在断言库的选择上，我们似乎没有过多的选择，从start数和活跃度来看，基本上是testify一枝独秀。

github.com/stretchr/te…

没有对比就没有伤害，先来看看使用testify之前的测试方法：

func TestSomeFun(t *testing.T){
...
 if v != want {
 t.Fatalf("v值错误，期望值：%s，实际值：%s", want, v)
 }
 if err != nil {
 t.Fatalf("非预期的错误：%s", err)
 }
 if objectA != objectB {
 if objectA.field1 != objectB.field1 {
 // t.Fatalf() field1值错误...bla bla bla
 }
 if objectA.field2 != objectB.field2 {
 // t.Fatalf() field2值错误...bla bla bla
 }
 // 遍历object所有值... bla bla bla
 }
...
}

上述代码充斥着大量if...else..判断，大段错误信息拼装（真·体力活…），运气不好碰到结构体判断要得将其遍历一遍——不直观，低效，实在是不fashion。现在，我们使用 testify来改造一下上面的测试示例：

func TestSomeFun(t *testing.T){
 a := assert.New(t)
...
 a.Equal(v, want)
 a.Nil(err,"如果你还是想输出自己拼装的错误信息，可以传第三个参数")
 a.Equal(objectA, objectB)
...
}

三行搞定，测试含义一目了然——直观，高效，简短，fashion。

总结一下

testify使用简单，提升显著，可谓是用一次就会爱上的懒人神器。在结合表格驱动测试，gomock和testify后，我们已经能写出一手优雅漂亮的单元测试代码了。不过，光测试代码优雅还不够，我们还需要帮main.go也打扮打扮。在下一篇，也是本系列最后一篇文章中，我们将介绍wire依赖注入框架，帮main.go减肥瘦身。

方法三实现Callable接口

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.thread;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。
 *
 * call()方法可以有返回值
 *
 * call()方法可以声明抛出异常
 *
 * Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口。
 * 因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。
 * public interface Future<V> {
 * //视图取消该Future里面关联的Callable任务
 * boolean cancel(boolean mayInterruptIfRunning);
 * //如果在Callable任务正常完成前被取消，返回True
 * boolean isCancelled();
 * //若Callable任务完成，返回True
 * boolean isDone();
 * //返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值
 * V get() throws InterruptedException, ExecutionException;
 * //返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException
 * V get(long timeout, TimeUnit unit)
 * throws InterruptedException, ExecutionException, TimeoutException;
 * }
 *
 * 介绍了相关的概念之后，创建并启动有返回值的线程的步骤如下：
 *
 * 1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例（从java8开始可以直接使用Lambda表达式创建Callable对象）。
 *
 * 2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
 *
 * 3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
 *
 * 4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 */
public class M03ImplementCallable01 {

 public static void main(String[] args) {
 //1. 此处使用的是匿名类方式
// Callable<String> callable = new Callable<String>() {
// public String call() throws Exception {
// for(int i = 0; i < 3; i++) {
// System.out.println("callable线程输出"+i);
// }
// return "返回随机数"+(new Random().nextInt(100));
// }
// };
 //2. 使用静态内部类
 Callable<String> callable = new InnerStaticCallable();
 //3. 使用外部实现类。略
 FutureTask<String> future = new FutureTask<String>(callable);
 Thread thread = new Thread(future);
 thread.start();
 try {
 String resI = future.get();
 System.out.println(resI);
 } catch (InterruptedException ie) {
 ie.printStackTrace();
 } catch (ExecutionException ee) {
 ee.printStackTrace();
 }

 //此种方法可以用， 但是不明确应用场景， 返回资源的值是在new FutureTask中传入的，
 //runnable接口实现直接使用Thread的start方法运行就行，传到FutureTask中有啥用
 Runnable runnable = new Runnable() {
 @Override
 public void run() {
 for(int i = 0; i < 3; i++) {
 System.out.println("Runnable线程输出"+i);
 }
 }
 };
 FutureTask<Integer> target = new FutureTask<>(runnable, 12);
 Thread thread1 = new Thread(target);
 thread1.start();
 try {
 Integer resI1 = target.get();
 System.out.println(resI1);
 } catch (InterruptedException ie) {
 ie.printStackTrace();
 } catch (ExecutionException ee) {
 ee.printStackTrace();
 }
 System.out.println("主线程输出");

 }
 //也可以使用内部类方式
 static class InnerStaticCallable implements Callable<String> {
 @Override
 public String call() {
 for(int i = 0; i < 3; i++) {
 System.out.println("callable线程输出"+i);
 }
 return "返回随机数"+(new Random().nextInt(100));
 }
 }
}

工厂三兄弟之抽象工厂模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。

定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，它是一种对象创建型模式。

在抽象工厂模式中，每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品，这些产品构成了一个产品族

结构

角色

**● AbstractFactory（抽象工厂）：**它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。

**● ConcreteFactory（具体工厂）：**它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

**● AbstractProduct（抽象产品）：**它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。

**● ConcreteProduct（具体产品）：**它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

在抽象工厂中声明了多个工厂方法，用于创建不同类型的产品，抽象工厂可以是接口，也可以是抽象类或者具体类

典型代码

abstract class AbstractFactory {
public abstract AbstractProductA createProductA(); //工厂方法一
public abstract AbstractProductB createProductB(); //工厂方法二
……
}

具体工厂实现了抽象工厂，每一个具体的工厂方法可以返回一个特定的产品对象，而同一个具体工厂所创建的产品对象构成了一个产品族。

对于每一个具体工厂类，其典型代码如下所示：

class ConcreteFactory1 extends AbstractFactory {
 //工厂方法一
public AbstractProductA createProductA() {
 return new ConcreteProductA1();
}
 
//工厂方法二
public AbstractProductB createProductB() {
 return new ConcreteProductB1();
}
 
……
}

与工厂方法模式一样，抽象工厂模式也可为每一种产品提供一组重载的工厂方法，以不同的方式对产品对象进行创建。

汇编语言入门三：是时候上内存了

Mon, 01 Jan 0001 00:00:00 +0000

上回说到了寄存器和指令，这回说下内存访问。开始之前，先来复习一下。

回顾

寄存器

寄存器是在CPU里面
寄存器的存储空间很小
寄存器存放的是CPU马上要处理的数据或者刚处理出的结果（还是热乎的）

指令

传送数据用的指令mov
做加法用的指令add
做减法用的指令sub
函数调用后返回的指令ret

指针和内存

高能预警

高能预警，后面会涉及到一些高难度动作，请提前做好以下准备：

精通2进制和16进制加减法
精通2进制表示与16进制表示之间的关系
精通8位、16位、32位、64位二进制数的16进制表示

举个例子，一个16进制数0BC71820，其二进制表示为：

00001011 11000111 00011000 00100000

你能快速地找到它们之间的对应关系吗？不会的话快去复习吧。

寄存器宽度

现在，为了简便，我们只讨论32位宽的寄存器。也就是说，目前我们讨论的寄存器，它的宽度都是32位的，也就是里面存放了一个32位长的2进制数。

通常，一个字节为8个二进制比特位，那么一个32位长的二进制数，那么它的大小就应该是4个字节。也就是把32位长的寄存器写入到内存里，会覆盖掉四个字节的存储空间。

内存

想必内存大家心里都比较有数，就是暂时存放CPU计算所需的指令和数据的地方。

诶？那前面说好的寄存器呢？寄存器也是类似的功能啊。对的，寄存器有类似功能，理论上一个最小的计算系统只需要寄存器和CPU的计算部件（ALU）就够了。不过，实际情况更加复杂一些，还是拿计算题举例，这次更复杂了：

（这里的例子只够说明寄存器和内存的角色区别，而非出现内存和寄存器这样角色的根本原因）

( 847623785 * 12874873 + 274632 ) / 999 =

好了，这个题目就不像前面的那么简单了，首先你肯定没法直接在脑子里三两下就算出来，还是得需要一个草稿纸了。

计算过程中，你还是会把草稿纸上正在计算的几个数字记在脑子里，然后快速地算完并记下来，然后往草稿纸上写。

最后，在草稿纸上演算完毕后，你会把最终结果写到试卷上。

好了，这里的草稿纸就相当于是内存了。它也充当一个临时记录数据的作用，不过它的容量就比自己的脑子要大得多了，而且一旦你把东西写下来，也就不那么担心忘记了。

诶？我不能多做点寄存器，就不需要单独的内存了呀？是的，理论上是这样，然而，实际上如果多做一点寄存器的话，CPU就要卖$9999999一片了，贵啊（具体原因可以了解SRAM与DRAM）。

也就是说，在计算机系统里，寄存器和内存都充当临时存储用，但是寄存器太小也太少了，内存就能帮个大忙了。

指针

在C语言里面，有个神奇的东西叫做指针，它是初学者的噩梦，也是高手的天堂。

这里不打算给不明白指针的人讲个明白，直接进入正题。首先，内存是一个比较大的存储器，里面可以存放非常非常多的字节。

好了，现在我们来为整个内存的所有字节编号，为了方便，咱们首先考虑按照字节为单位连续编号：

 0 1 2 3 4 5 6 7 ...
......................... ......................
|12|b7|33|e8|66|4c|87|3c| ... |cc|cc|cc|cc|cc|cd|cd|
````````````````````````` ``````````````````````

大概意思一下，你可以想象每一个格子就是一个字节，每个格子都有编号，相邻的格子的编号也是相邻的。这个编号，你就可以理解为所谓的指针或者地址（这里不严格区分指针与地址）。那么当我需要获取某个位置的数据时，那么我们只需要一个编号（也就是地址）就知道在哪些格子里获取数据了，当然，写入数据也是一样的道理。

解释器模式

Mon, 01 Jan 0001 00:00:00 +0000

前言

虽然目前计算机编程语言有好几百种，但有时候我们还是希望能用一些简单的语言来实现一些特定的操作，我们只要向计算机输入一个句子或文件，它就能够按照预先定义的文法规则来对句子或文件进行解释，从而实现相应的功能。例如提供一个简单的加法/减法解释器，只要输入一个加法/减法表达式，它就能够计算出表达式结果，如图18-1所示，当输入字符串表达式为“1 + 2 + 3 – 4 + 1”时，将输出计算结果为3。

我们知道，像C++、Java和C#等语言无法直接解释类似“1+ 2 + 3 – 4 + 1”这样的字符串（如果直接作为数值表达式时可以解释），我们必须自己定义一套文法规则来实现对这些语句的解释，即设计一个自定义语言。在实际开发中，这些简单的自定义语言可以基于现有的编程语言来设计，如果所基于的编程语言是面向对象语言，此时可以使用解释器模式来实现自定义语言。

“1+ 2 + 3 – 4 + 1”都包含了三个语言单位，可以使用如下文法规则来定义：

expression ::= value | operation
operation ::= expression '+' expression | expression '-'  expression
value ::= an integer //一个整数值

该文法规则包含三条语句，第一条表示表达式的组成方式，其中value和operation是后面两个语言单位的定义，每一条语句所定义的字符串如operation和value称为语言构造成分或语言单位，符号“::=”表示“定义为”的意思，其左边的语言单位通过右边来进行说明和定义，语言单位对应终结符表达式和非终结符表达式。如本规则中的operation是非终结符表达式，它的组成元素仍然可以是表达式，可以进一步分解，而value是终结符表达式，它的组成元素是最基本的语言单位，不能再进行分解。

在文法规则定义中可以使用一些符号来表示不同的含义，如使用“|”表示或，使用“{”和“}”表示组合，使用“*”表示出现0次或多次等，其中使用频率最高的符号是表示“或”关系的“|”，如文法规则“boolValue ::= 0 | 1”表示终结符表达式boolValue的取值可以为0或者1。

除了使用文法规则来定义一个语言，在解释器模式中还可以通过一种称之为**抽象语法树(Abstract Syntax Tree, AST)**的图形方式来直观地表示语言的构成，每一棵抽象语法树对应一个语言实例，如加法/减法表达式语言中的语句“1+ 2 + 3 – 4 + 1”，可以通过如下图的抽象语法树表示

在该抽象语法树中，可以通过终结符表达式value和非终结符表达式operation组成复杂的语句，

每个文法规则的语言实例都可以表示为一个抽象语法树，即每一条具体的语句都可以用类似上图所示的抽象语法树来表示，

在图中终结符表达式类的实例作为树的叶子节点，而非终结符表达式类的实例作为非叶子节点，它们可以将终结符表达式类的实例以及包含终结符和非终结符实例的子表达式作为其子节点。

抽象语法树描述了如何构成一个复杂的句子，通过对抽象语法树的分析，可以识别出语言中的终结符类和非终结符类。

概述

解释器模式描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。

网关

Mon, 01 Jan 0001 00:00:00 +0000

网关存在的目的是将已有的IOT系统数据采集到ThingsBoard平台（包括云服务和边缘服务）中

新建网关（云端）

直接下载也可以，

关闭后也可以再找到这个页面进行下载

检查云端mqtt通信端口


services:
 # ThingsBoard IoT Gateway Service Configuration
 tb-gateway:
 image: thingsboard/tb-gateway:3.7-stable
 container_name: tb-gateway
 restart: always

 # Ports bindings - required by some connectors
 # ports:
 # - "5000:5000" # Comment if you don't use REST connector and change if you use another port
 # Uncomment and modify the following ports based on connector usage:
# - "1052:1052" # BACnet connector
# - "5026:5026" # Modbus TCP connector (Modbus Slave)
# - "50000:50000/tcp" # Socket connector with type TCP
# - "50000:50000/udp" # Socket connector with type UDP

 # Necessary mapping for Linux
 extra_hosts:
 - "host.docker.internal:host-gateway"

 # Environment variables
 environment:
 - host=home.anzhongwei.cn
 - port=51883
 - accessToken=H8dfew7StsSLRkwQW0gE

 # Volumes bind
 volumes:
 - tb-gw-config:/thingsboard_gateway/config
 - tb-gw-logs:/thingsboard_gateway/logs
 - tb-gw-extensions:/thingsboard_gateway/extensions

# Volumes declaration for configurations, extensions and configuration
volumes:
 tb-gw-config:
 name: tb-gw-config
 tb-gw-logs:
 name: tb-gw-logs
 tb-gw-extensions:
 name: tb-gw-extensions

运行成功后，网关状态为活动的（Active）

组合模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员对象（可以是容器对象，也可以是叶子对象）并调用执行，牵一而动百，其中使用了递归调用的机制来对整个结构进行处理。由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多数情况下我们希望一致地处理它们，因为对于这些对象的区别对待将会使得程序非常复杂。组合模式为解决此类问题而诞生，它可以让叶子对象和容器对象的使用具有一致性。

定义

组合模式(Composite Pattern)：组合多个对象形成树形结构以表示具有“整体—部分”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，组合模式又可以称为“整体—部分”(Part-Whole)模式，它是一种对象结构型模式。

在组合模式中引入了抽象构件类Component，它是所有容器类和叶子类的公共父类，客户端针对Component进行编程。

结构

角色

**● Component（抽象构件）：**它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

**● Leaf（叶子构件）：**它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

**● Composite（容器构件）：**它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

**组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。**同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

如果不使用组合模式，客户端代码将过多地依赖于容器对象复杂的内部实现结构，容器对象内部实现结构的变化将引起客户代码的频繁变化，带来了代码维护复杂、可扩展性差等弊端。组合模式的引入将在一定程度上解决这些问题。

下面通过简单的示例代码来分析组合模式的各个角色的用途和实现。对于组合模式中的抽象构件角色。

典型代码

abstract class Component {
 public abstract void add(Component c); //增加成员
 public abstract void remove(Component c); //删除成员
 public abstract Component getChild(int i); //获取成员
 public abstract void operation(); //业务方法
}

一般将抽象构件类设计为接口或抽象类，将所有子类共有方法的声明和实现放在抽象构件类中。对于客户端而言，将针对抽象构件编程，而无须关心其具体子类是容器构件还是叶子构件。

如果继承抽象构件的是叶子构件，则其典型代码如下所示：

class Leaf extends Component {
 public void add(Component c) { 
 //异常处理或错误提示 
 } 
 
 public void remove(Component c) { 
 //异常处理或错误提示 
 }
 
 public Component getChild(int i) { 
 //异常处理或错误提示
 return null; 
 }
 
 public void operation() {
 //叶子构件具体业务方法的实现
 } 
}

作为抽象构件类的子类，在叶子构件中需要实现在抽象构件类中声明的所有方法，包括业务方法以及管理和访问子构件的方法，但是叶子构件不能再包含子构件，因此在叶子构件中实现子构件管理和访问方法时需要提供异常处理或错误提示。当然，这无疑会给叶子构件的实现带来麻烦。

004模拟一次deployment的上线发布回滚

Mon, 01 Jan 0001 00:00:00 +0000

root@k8s-192-168-0-17:/home/node1# kubectl create deployment nginx --image=docker.io/library/nginx:1.21.6 --replicas=2
deployment.apps/nginx created
root@k8s-192-168-0-17:/home/node1# kubectl get deployment nginx -o wide -w
NAME READY UP-TO-DATE AVAILABLE AGE CONTAINERS IMAGES SELECTOR
nginx 2/2 2 2 22s nginx docker.io/library/nginx:1.21.6 app=nginx
root@k8s-192-168-0-17:/home/node1# kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-784757bdfb-bs4rt 1/1 Running 0 42s 172.20.182.150 k8s-192-168-0-11 <none> <none>
nginx-784757bdfb-jjmzv 1/1 Running 0 43s 172.20.177.25 k8s-192-168-0-19 <none> <none>
# 注意这里的版本号
root@k8s-192-168-0-17:/home/node1# curl 172.20.182.150/1
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.21.6</center>
</body>
</html>
root@k8s-192-168-0-17:/home/node1# kubectl set image deployment/nginx nginx=docker.io/library/nginx:1.25.1
deployment.apps/nginx image updated
root@k8s-192-168-0-17:/home/node1# kubectl annotate deployment/nginx kubernetes.io/change-cause="image updated to 1.25.1"
deployment.apps/nginx annotated
root@k8s-192-168-0-17:/home/node1# kubectl rollout history deployment nginx
deployment.apps/nginx 
REVISION CHANGE-CAUSE
1 <none>
2 image updated to 1.25.1
# 注意这里的版本号 已经换成 1.25.1 了
root@k8s-192-168-0-17:/home/node1# curl 172.20.182.153/1
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.25.1</center>
</body>
</html>
root@k8s-192-168-0-17:/home/node1# kubectl set image deployments/nginx nginx=nginx:1.21.6
deployment.apps/nginx image updated
root@k8s-192-168-0-17:/home/node1# kubectl annotate deployment/nginx kubernetes.io/change-cause="image updated to 1.21.6"
deployment.apps/nginx annotated
root@k8s-192-168-0-17:/home/node1# kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-796bdc6f77-66hcm 1/1 Running 0 35s 172.20.182.154 k8s-192-168-0-11 <none> <none>
nginx-796bdc6f77-n5wng 1/1 Running 0 49s 172.20.177.29 k8s-192-168-0-19 <none> <none>
# 注意这里的版本号 已经换成 1.21.6 了
root@k8s-192-168-0-17:/home/node1# curl 172.20.182.154/1
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.21.6</center>
</body>
</html>

## 假设我们这次升级版本出现了问题 那么我们查看历史，我们要回滚到1.25.1
root@k8s-192-168-0-17:/home/node1# kubectl rollout history deployment nginx
deployment.apps/nginx 
REVISION CHANGE-CAUSE
1 <none>
2 image updated to 1.25.1
3 image updated to 1.21.6
# --to-revision=2 就是上一步的索引
root@k8s-192-168-0-17:/home/node1# kubectl rollout undo deployment nginx --to-revision=2
deployment.apps/nginx rolled back
# 这里版本号已经回滚到1.25.1
root@k8s-192-168-0-17:/home/node1# curl 172.20.177.30/1
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.25.1</center>
</body>
</html>
# 我们再查询rs
root@k8s-192-168-0-17:/home/node1# kubectl get rs
NAME DESIRED CURRENT READY AGE
nginx-784757bdfb 0 0 0 19m
nginx-796bdc6f77 0 0 0 16m
nginx-79df7c55d7 2 2 2 19m

Golang单元测试04

Mon, 01 Jan 0001 00:00:00 +0000

搞定Go单元测试（四）—— 依赖注入框架(wire)

在第一篇文章中提到过，为了让代码可测，需要用依赖注入的方式来构建我们的对象，而通常我们会在main.go做依赖注入，这就导致main.go会越来越臃肿。为了让单元测试得以顺利进行，main.go牺牲了它本应该纤细苗条的身材。太胖的main.go可不是什么好的信号，本篇将介绍依赖注入框架（wire），致力于帮助main.go恢复身材。

臃肿的main

在main.go中做依赖注入，意味着在初始化代码中我们要管理：

依赖的初始化顺序
依赖之间的关系

对于小型项目而言，依赖的数量比较少，初始化代码不会很多，不需要引入依赖注入框架。但对于依赖较多的中大型项目，初始化代码又臭又长，可读性和维护性变的很差，随意感受一下：

func main() {
 config := NewConfig()
 // db依赖配置
 db, err := ConnectDatabase(config)
 if err != nil {
 panic(err)
 }
 // PersonRepository 依赖db
 personRepository := NewPersonRepository(db)
 // PersonService 依赖配置 和 PersonRepository
 personService := NewPersonService(config, personRepository)
 // NewServer 依赖配置和PersonService
 server := NewServer(config, personService)
 server.Run()
}

实践表明，修改有大量依赖关系的初始化代码是一项乏味且耗时的工作。这个时候，我们就需要依赖注入框架来帮忙，简化初始化代码。

上述代码来自：blog.drewolson.org/dependency-…

使用依赖注入框架——wire

What is wire?

wire是google开源的依赖注入框架。或者引用官方的话来说：“Wire is a code generation tool that automates connecting components using dependency injection”。

github.com/google/wire

Why wire?

除了wire，Go的依赖注入框架还有Uber的dig和Facebook的inject，它们都是使用反射机制来实现运行时依赖注入(runtime dependency injection)，而wire则是采用代码生成的方式来达到编译时依赖注入(compile-time dependency injection)。使用反射带来的性能损失倒是其次，更重要的是反射使得代码难以追踪和调试（反射会令Ctrl+左键失效…）。而wire生成的代码是符合程序员常规使用习惯的代码，十分容易理解和调试。关于wire的优点，在官方博文上有更详细的的介绍： blog.golang.org/wire

mybatisSql语句拼装

Mon, 01 Jan 0001 00:00:00 +0000


<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8" />
 <title>Mybatis Log Helper</title>
 <meta name=viewport content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no" />
 <link rel="shortcut icon" href="" />
 <script src="https://unpkg.com/vue@2.6.11/dist/vue.js"></script>
 <!-- 引入样式 -->
 <link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
 <!-- 引入组件库 -->
 <script src="https://unpkg.com/element-ui/lib/index.js"></script>
 <style>
 #app {
 margin-top: 70px;
 display: flex;
 justify-content: space-evenly;
 align-items: center;
 font-family: "Helvetica Neue", Helvetica, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "微软雅黑", Arial, sans-serif;
 }
 </style>
</head>
<body>
 <div id="app">
 <el-input type="textarea" v-model="pre" placeholder="请复制输入Mybatis打印的日志，须完整Prepareing语句和Parameter语句"
 :rows="28" style="width: 600px"></el-input>
 <el-button type="success" @click="convert" style="height: 60px; width: 80px;">转换</el-button>
 <el-input type="textarea" v-model="res" placeholder="输出结果"
 :rows="28" style="width: 600px"></el-input>
 </div>

 <script type="text/javascript">
 const app = new Vue({
 el: '#app',
 data() {
 return {
 // 原始str
 pre: '',
 // 输出结果
 res: ''
 }
 },
 methods: {
 convert() {
 const str = this.pre
 
 if (str.indexOf('Preparing') == -1 || str.indexOf('Parameters') == -1) {
 this.$message({
 message: '请将Preparing和Parameters语句复制进来',
 type: 'error',
 center: true
 })
 }
 // str为完整的三行或两行SQL 提取预编译语句
 // const prepare = str.substring(str.indexOf('Preparing') + 11, str.indexOf('\n'))
 var prepare=""
 var params=new Array()
 var arr = str.split("\n");
 for(const strItem of arr) {
 if (strItem.indexOf("Preparing") != -1) {
 prepare = strItem.substring(strItem.indexOf('Preparing') + 11)
 // console.log("prepare="+prepare)
 }
 
 if (strItem.indexOf("Parameters") != -1) {
 params.push(strItem.substring(strItem.indexOf('Parameters') + 12))
 // console.log("params["+i+"]="+params[i])
 }
 }


 if(params.length > 1) {
 var placeholder = prepare.substring(prepare.indexOf('( ?')-1)
 console.log(prepare)
 for(let i=0; i < params.length-1;i++) {
 prepare = prepare+','+placeholder
 }
 console.log(prepare)
 } 
 var paramStr = params.join(',')
 // 获取参数,去空格
 paramStr = paramStr.replace(/ /g, '')
 // 参数数组
 const array = paramStr.split(',')
 console.log(array)
 // 循环替换占位符，字符串方式替换每次替换第一个
 array.map(item => {
 youKuoHaoWeiZhi = item.indexOf('(')
 console.log(item+":右侧括号"+youKuoHaoWeiZhi)
 let newValue = ""
 if (youKuoHaoWeiZhi != -1) {
 newValue = item.substring(0, item.indexOf('('))
 console.log(item+":最新值"+newValue)
 // 获取参数类型
 const type = item.substring(item.indexOf('(') + 1, item.indexOf(')'))
 console.log(item+":参数"+type)
 if ('String' === type) {
 newValue = "'" + newValue + "'"
 }
 } else {
 newValue = item
 }
 
 
 
 prepare = prepare .replace('?', newValue)
 })
 
 
 this.res = prepare
 }
 }
 })

 // 返回字符串str中的第n字符串reg在str中的索引值index
 function index(str, reg, n) {
 if (!str || !reg || n <= 0) return -1
 // 先求出第一个，再递归n-1
 if (n === 1) {
 return str.indexOf(reg)
 }
 // 注意n-1的索引后一定要加1，负责会一直是第一个reg的索引
 return str.indexOf(reg, index(str, reg, n - 1) + 1)
 }
 // 测试index函数
 // const str = 'hello world ok'
 // const reg = 'o'
 // console.log(index(str, reg, 3))
 </script>
</body>
</html>

单例模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

定义

单例模式(Singleton Pattern)：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

单例模式有三个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

单例模式是结构最简单的设计模式一，在它的核心结构中只包含一个被称为单例类的特殊类。

结构

角色

● Singleton（单例）：在单例类的内部实现只生成一个实例，同时它提供一个静态的getInstance()工厂方法，让客户可以访问它的唯一实例；为了防止在外部对其实例化，将其构造函数设计为私有；在单例类内部定义了一个Singleton类型的静态对象，作为外部共享的唯一实例。

案例解析1： Windows任务管理器

Windows任务管理器

我们可以做一个这样的尝试，在Windows的“任务栏”的右键弹出菜单上多次点击“启动任务管理器”，看能否打开多个任务管理器窗口？

如果你的桌面出现多个任务管理器，我请你吃饭（注：电脑中毒或私自修改Windows内核者除外）。

通常情况下，无论我们启动任务管理多少次，Windows系统始终只能弹出一个任务管理器窗口，也就是说在一个Windows系统中，任务管理器存在唯一性。

为什么要这样设计呢？我们可以从以下两个方面来分析：

其一，如果能弹出多个窗口，且这些窗口的内容完全一致，全部是重复对象，这势必会浪费系统资源，任务管理器需要获取系统运行时的诸多信息，这些信息的获取需要消耗一定的系统资源，包括CPU资源及内存资源等，浪费是可耻的，而且根本没有必要显示多个内容完全相同的窗口；

其二，如果弹出的多个窗口内容不一致，问题就更加严重了，这意味着在某一瞬间系统资源使用情况和进程、服务等信息存在多个状态，例如任务管理器窗口A显示“CPU使用率”为10%，窗口B显示“CPU使用率”为15%，到底哪个才是真实的呢？这纯属“调戏”用户，给用户带来误解，更不可取。

由此可见，确保Windows任务管理器在系统中有且仅有一个非常重要。

回到实际开发中，我们也经常遇到类似的情况，为了节约系统资源，有时需要确保系统中某个类只有唯一一个实例，当这个唯一实例创建成功之后，我们无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一实例。为了确保对象的唯一性，我们可以通过单例模式来实现，这就是单例模式的动机所在。

下面我们来模拟实现Windows任务管理器，假设任务管理器的类名为TaskManager，在TaskManager类中包含了大量的成员方法，例如构造函数TaskManager()，显示进程的方法displayProcesses()，显示服务的方法displayServices()等，该类的示意代码如下：

class TaskManager
{
 public TaskManager() {……} //初始化窗口
 public void displayProcesses() {……} //显示进程
 public void displayServices() {……} //显示服务
 ……
}

为了实现Windows任务管理器的唯一性，我们通过如下三步来对该类进行重构：

由于每次使用new关键字来实例化TaskManager类时都将产生一个新对象，为了确保TaskManager实例的唯一性，我们需要禁止类的外部直接使用new来创建对象，因此需要将TaskManager的构造函数的可见性改为private，如下代码所示：

 private TaskManager() {……}

将构造函数改为private修饰后该如何创建对象呢？不要着急，虽然类的外部无法再使用new来创建对象，但是在TaskManager的内部还是可以创建的，可见性只对类外有效。因此，我们可以在TaskManager中创建并保存这个唯一实例。为了让外界可以访问这个唯一实例，需要在TaskManager中定义一个静态的TaskManager类型的私有成员变量，如下代码所示：

 private static TaskManager tm = null;

为了保证成员变量的封装性，我们将TaskManager类型的tm对象的可见性设置为private，但外界该如何使用该成员变量并何时实例化该成员变量呢？答案是增加一个公有的静态方法，如下代码所示：

public static TaskManager getInstance()
{
 if (tm == null)
 {
 tm = new TaskManager();
 }
 return tm;
}

在getInstance()方法中首先判断tm对象是否存在，如果不存在（即tm == null），则使用new关键字创建一个新的TaskManager类型的tm对象，再返回新创建的tm对象；否则直接返回已有的tm对象。

迭代器模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

在软件开发中，我们经常需要使用聚合对象来存储一系列数据。

聚合对象拥有两个职责：一是存储数据；二是遍历数据。

从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。

因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。

定义

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

结构

在迭代器模式结构中包含聚合和迭代器两个层次结构，考虑到系统的灵活性和可扩展性，在迭代器模式中应用了工厂方法模式

角色

**● Iterator（抽象迭代器）：**它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

**● ConcreteIterator（具体迭代器）：**它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

**● Aggregate（抽象聚合类）：**它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

**● ConcreteAggregate（具体聚合类）：**它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

典型代码

在迭代器模式中，提供了一个外部的迭代器来对聚合对象进行访问和遍历，迭代器定义了一个访问该聚合元素的接口，并且可以跟踪当前遍历的元素，了解哪些元素已经遍历过而哪些没有。

迭代器的引入，将使得对一个复杂聚合对象的操作变得简单。

下面我们结合代码来对迭代器模式的结构进行进一步分析。在迭代器模式中应用了工厂方法模式，抽象迭代器对应于抽象产品角色，具体迭代器对应于具体产品角色，抽象聚合类对应于抽象工厂角色，具体聚合类对应于具体工厂角色。

在抽象迭代器中声明了用于遍历聚合对象中所存储元素的方法，典型代码如下所示：

interface Iterator {
 public void first(); //将游标指向第一个元素
 public void next(); //将游标指向下一个元素
 public boolean hasNext(); //判断是否存在下一个元素
 public Object currentItem(); //获取游标指向的当前元素
}

在具体迭代器中将实现抽象迭代器声明的遍历数据的方法，如下代码所示：

class ConcreteIterator implements Iterator {
 private ConcreteAggregate objects; //维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
 private int cursor; //定义一个游标，用于记录当前访问位置
 public ConcreteIterator(ConcreteAggregate objects) {
 this.objects=objects;
 }
 
 public void first() { ...... }
 
 public void next() { ...... }
 
 public boolean hasNext() { ...... }
 
 public Object currentItem() { ...... }
}

需要注意的是抽象迭代器接口的设计非常重要，

方法四Executors框架

Mon, 01 Jan 0001 00:00:00 +0000


import java.util.concurrent.*;

/**
 * 1.5后引入的Executor框架的最大优点是把任务的提交和执行解耦。
 * 要执行任务的人只需把Task描述清楚，然后提交即可。
 * 这个Task是怎么被执行的，被谁执行的，什么时候执行的，提交的人就不用关心了。
 * 具体点讲，提交一个Callable对象给ExecutorService（如最常用的线程池ThreadPoolExecutor），将得到一个Future对象，调用Future对象的get方法等待执行结果就好了。
 * Executor框架的内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。
 * 因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，
 * 还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。
 *
 * 关于ExecutorService执行submit和execute的区别
 * 1、接收的参数不一样
 * 2、submit有返回值，而execute没有
 * 3、submit方便Exception处理
 * 如果你在你的task里会抛出checked或者unchecked exception，而你又希望外面的调用者能够感知这些exception并做出及时的处理，那么就需要用到submit，通过捕获Future.get抛出的异常。
 */
public class M04ExccutorCallable {
 public static void main(String[] args) throws ExecutionException, InterruptedException {
 ExecutorService executorService1 = Executors.newSingleThreadExecutor();
 ExecutorService executorService2 = Executors.newSingleThreadExecutor();


 Runnable runnable = new Runnable(){
 @Override
 public void run() {
 for(int i = 0; i < 3; i++) {
 System.out.println("Runnable接口"+i);
 }
 }
 };
 //执行Runnable接口，无返回值
 executorService1.execute(runnable);
 executorService1.shutdown();


 //执行Callable接口，有返回值
 Callable<String> stringCallable = new Callable(){
 @Override
 public String call() throws Exception {
 for(int i = 0; i < 3; i++) {
 System.out.println("Callable接口"+i);
 }
 return "Hello World";
 }
 };
 Future<String> submit2 = executorService2.submit(stringCallable);
 executorService2.shutdown();
 //get操作会造成执行线程的阻塞
 String submit2Res = submit2.get();
 System.out.println(submit2Res);

 System.out.println("main Thread output");
 }
}

汇编语言入门四：打通C和汇编语言

Mon, 01 Jan 0001 00:00:00 +0000

回顾

上回我们把汇编里涉及到的寄存器和内存访问相关的内容说了。先来梳理一下：

寄存器是一些超级小的临时存储器，在CPU里面，存放CPU马上就要用到的数据或者刚处理完的结果
要处理的数据太多，寄存器装不下了，需要更多寄存器，但是这玩意贵啊
内存可以解决上述问题，但是内存相比寄存器要慢，优点是相对便宜，容量也大

插曲：C语言与汇编语言的关系

还有一些疑虑，先暂时解释一下。首先，C语言里编程里，我们从来没有关心过寄存器。汇编语言里突然冒出这么一个东西，学起来好难受。接下来的内容，我们先把C语言和汇编语言的知识，来一次大一统，帮助理解。

首先我们来看一个C语言程序：

int x, y, z;

int main() {
 x = 2;
 y = 3;
 z = x + y;
 return z;
}

考虑到我们的汇编教程才刚开始，我这里尽可能先简化C程序，这样稍后涉及到等价的汇编内容时所需的知识都是前面介绍过的。

保存为test01.c文件，先编译运行这个程序：

（注意，这里的gcc带了一个参数-m32，因为我们要编译出32位（x86）的可执行文件）

$ gcc -m32 test01.c -o test01
$ ./test01 ; echo $?
5

好了，在这里，我们的程序返回了一个值：5。

好的，接下来我们看看如果我们要用汇编实现几乎相同的过程，该怎么做？

首先，三个全局变量：

int x, y, z;

总得有吧。（这里之所以会用全局变量，是考虑到局部变量相关的汇编知识还未介绍，先将就一下，后续再说局部变量的内容）

首先，在C语言里，你可以认为每个变量都会占用一定的内存空间，也就是说，这里的x、y、z分别都占用了一个“整型”也就是4字节的存储空间。

上次我们介绍过在汇编里面访问内存的知识，当然，我们也知道了怎么在数据区划出一定的空间，这次我们就照搬前面提及的方法：

global main

main:
 mov eax, 0
 ret

section .data

x dw 0
y dw 0
z dw 0

这个程序就等价于下面的C代码：

装饰器模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

装饰模式可以在不改变一个对象本身功能的基础上给对象增加额外的新行为，在现实生活中，这种情况也到处存在。

例如一张照片，我们可以不改变照片本身，给它增加一个相框，使得它具有防潮的功能，而且用户可以根据需要给它增加不同类型的相框，甚至可以在一个小相框的外面再套一个大相框。

装饰模式是一种用于替代继承的技术，它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既可以调用待装饰的原有类的方法，还可以增加新的方法，以扩充原有类的功能。

定义

装饰模式(Decorator Pattern)：动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。

在装饰模式中，为了让系统具有更好的灵活性和可扩展性，我们通常会定义一个抽象装饰类，而将具体的装饰类作为它的子类。

结构

角色

● Component（抽象构件）：它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。

● ConcreteComponent（具体构件）：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。

● Decorator（抽象装饰类）：它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。

● ConcreteDecorator（具体装饰类）：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

由于具体构件类和装饰类都实现了相同的抽象构件接口，因此装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任，换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。

装饰模式的核心在于抽象装饰类的设计。

典型代码

class Decorator implements Component {

 private Component component; //维持一个对抽象构件对象的引用
 public Decorator(Component component) { //注入一个抽象构件类型的对象
 this.component=component;
 }
 
 public void operation() {
 component.operation(); //调用原有业务方法
 }
}

在抽象装饰类Decorator中定义了一个Component类型的对象component，维持一个对抽象构件对象的引用，并可以通过构造方法或Setter方法将一个Component类型的对象注入进来，同时由于Decorator类实现了抽象构件Component接口，因此需要实现在其中声明的业务方法operation()，需要注意的是在Decorator中并未真正实现operation()方法，而只是调用原有component对象的operation()方法，它没有真正实施装饰，而是提供一个统一的接口，将具体装饰过程交给子类完成。

在Decorator的子类即具体装饰类中将继承operation()方法并根据需要进行扩展，典型的具体装饰类代码如下：

class ConcreteDecorator extends Decorator{

 public ConcreteDecorator(Component component) {
 super(component);
 }

 public void operation() {
 super.operation(); //调用原有业务方法
 addedBehavior(); //调用新增业务方法
 }

 //新增业务方法
 public void addedBehavior() { 
 ……
 }

}

在具体装饰类中可以调用到抽象装饰类的operation()方法，同时可以定义新的业务方法，如addedBehavior()。

005手动创建一个一定会发生故障推出的pod并跟踪这个pod

Mon, 01 Jan 0001 00:00:00 +0000

```shell
root@k8s-192-168-0-17:~# kubectl run busybox --image=busybox --dry-run=client -o yaml > testHealthz.yaml
root@k8s-192-168-0-17:~# vim testHealthz.yaml

apiVersion: v1
kind: Pod
metadata:
creationTimestamp: null
labels:
 run: busybox
name: busybox
spec:
containers:
- image: busybox
 name: busybox
 resources: {}
 # 添加启动参数模拟启动后10s就以返回码1退出
 args:
 - /bin/sh
 - -c
 - sleep 10; exit 1
dnsPolicy: ClusterFirst
# 将默认的Always 改成 OnFailure
restartPolicy: OnFailure
status: {}

root@k8s-192-168-0-17:~# kubectl apply -f testHealthz.yaml
pod/busybox created

root@k8s-192-168-0-17:~# kubectl get pod -o wide -w
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
busybox 1/1 Running 0 22s 172.20.177.32 k8s-192-168-0-19 <none> <none>
nginx-796bdc6f77-7r5ts 1/1 Running 0 10m 172.20.177.31 k8s-192-168-0-19 <none> <none>
busybox 0/1 Error 0 32s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 1/1 Running 1 (8s ago) 38s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 Error 1 (19s ago) 49s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 CrashLoopBackOff 1 (14s ago) 61s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 1/1 Running 2 (19s ago) 66s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 Error 2 (30s ago) 77s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 CrashLoopBackOff 2 (13s ago) 89s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 1/1 Running 3 (34s ago) 110s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 Error 3 (44s ago) 2m 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 CrashLoopBackOff 3 (16s ago) 2m14s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 1/1 Running 4 (48s ago) 2m46s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 Error 4 (58s ago) 2m56s 172.20.177.32 k8s-192-168-0-19 <none> <none>
busybox 0/1 CrashLoopBackOff 4 (15s ago) 3m10s 172.20.177.32 k8s-192-168-0-19 <none> <none>

# 一直再running error CrashLoopBackOff 并且kubelet会以指数级的退避延迟（10s，20s，40s等）重新启动它们，上限为5分钟
```

005手动创建一个一定会发生故障推出的pod并跟踪这个pod

Mon, 01 Jan 0001 00:00:00 +0000

1. 先准备两个Deployment配置

```yaml
# cat myapp-v1.yaml 是可以通过健康检查

apiVersion: apps/v1
kind: Deployment
metadata:
name: mytest
spec:
replicas: 10 # 这里准备10个数量的pod
selector:
 matchLabels:
 app: mytest
template:
 metadata:
 labels:
 app: mytest
 spec:
 containers:
 - name: mytest
 image: registry.cn-hangzhou.aliyuncs.com/acs/busybox:v1.29.2
 args:
 - /bin/sh
 - -c
 - sleep 10; touch /tmp/healthy; sleep 30000
 readinessProbe:
 exec:
 command:
 - cat
 - /tmp/healthy
 initialDelaySeconds: 10
 periodSeconds: 5

# cat myapp-v2.yaml v2是不能通过检测的 模拟升级发版失败

apiVersion: apps/v1
kind: Deployment
metadata:
name: mytest
spec:
strategy:
 rollingUpdate:
 maxSurge: 35% # 滚动更新的副本总数最大值(以10的基数为例)：10 + 10 * 35% = 13.5 --> 14
 maxUnavailable: 35% # 可用副本数最大值(默认值两个都是25%)： 10 - 10 * 35% = 6.5 --> 7
replicas: 10
selector:
 matchLabels:
 app: mytest
template:
 metadata:
 labels:
 app: mytest
 spec:
 containers:
 - name: mytest
 image: registry.cn-hangzhou.aliyuncs.com/acs/busybox:v1.29.2
 args:
 - /bin/sh
 - -c
 - sleep 30000 # 可见这里并没有生成/tmp/healthy这个文件，所以下面的检测必然失败
 readinessProbe:
 exec:
 command:
 - cat
 - /tmp/healthy
 initialDelaySeconds: 10
 periodSeconds: 5

```

2. 启动myapp-v1.yaml

```shell
kubectl apply -f myapp-v1.yaml
# 别忘了加备注
kubectl annotate deployment/mytest kubernetes.io/change-cause="kubectl apply --filename=myapp-v1.yaml"
# 过一会就会看到pod状态为Running
root@k8s-192-168-0-17:~# kubectl get pod -o wide 
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
mytest-59887f89f5-fq6hv 1/1 Running 0 112s 172.20.182.159 k8s-192-168-0-11 <none> <none>
mytest-59887f89f5-gpsnx 1/1 Running 0 113s 172.20.182.157 k8s-192-168-0-11 <none> <none>
mytest-59887f89f5-gwkmg 1/1 Running 0 113s 172.20.177.33 k8s-192-168-0-19 <none> <none>
mytest-59887f89f5-ltdw9 1/1 Running 0 115s 172.20.182.156 k8s-192-168-0-11 <none> <none>
mytest-59887f89f5-m4vkn 1/1 Running 0 112s 172.20.177.37 k8s-192-168-0-19 <none> <none>
mytest-59887f89f5-m9z2t 1/1 Running 0 112s 172.20.182.160 k8s-192-168-0-11 <none> <none>
mytest-59887f89f5-mq9n6 1/1 Running 0 113s 172.20.177.35 k8s-192-168-0-19 <none> <none>
mytest-59887f89f5-nwsc9 1/1 Running 0 115s 172.20.177.34 k8s-192-168-0-19 <none> <none>
mytest-59887f89f5-pzm68 1/1 Running 0 115s 172.20.177.36 k8s-192-168-0-19 <none> <none>
mytest-59887f89f5-qd74c 1/1 Running 0 113s 172.20.182.158 k8s-192-168-0-11 <none> <none>
```

3. 启动myapp-v2.yaml

```shell
kubectl apply -f myapp-v2.yaml
# 别忘了加备注
kubectl annotate deployment/mytest kubernetes.io/change-cause="kubectl apply --filename=myapp-v2.yaml"
# 过一会查看deployment 输出结果 会稳定在以下结果
root@k8s-192-168-0-17:~# kubectl get deployment mytest
NAME READY UP-TO-DATE AVAILABLE AGE
mytest 7/10 7 7 3m43s
# READY 现在正在运行的只有7个pod
# UP-TO-DATE 表示当前已经完成更新的副本数：即 7 个新副本
# AVAILABLE 表示当前处于 READY 状态的副本数

# 查看pod
root@k8s-192-168-0-17:~# kubectl get pod
NAME READY STATUS RESTARTS AGE
mytest-59887f89f5-fq6hv 1/1 Running 0 5m9s
mytest-59887f89f5-gpsnx 1/1 Running 0 5m10s
mytest-59887f89f5-gwkmg 1/1 Running 0 5m10s
mytest-59887f89f5-ltdw9 1/1 Running 0 5m12s
mytest-59887f89f5-m9z2t 1/1 Running 0 5m9s
mytest-59887f89f5-pzm68 1/1 Running 0 5m12s
mytest-59887f89f5-qd74c 1/1 Running 0 5m10s
mytest-8586c6547d-6sqwt 0/1 Running 0 2m19s
mytest-8586c6547d-b9kql 0/1 Running 0 2m20s
mytest-8586c6547d-cgkrj 0/1 Running 0 2m7s
mytest-8586c6547d-dw6kv 0/1 Running 0 2m18s
mytest-8586c6547d-ht4dq 0/1 Running 0 2m19s
mytest-8586c6547d-v7rh9 0/1 Running 0 2m8s
mytest-8586c6547d-vqn6w 0/1 Running 0 2m7s

# 查看deployment的信息
root@k8s-192-168-0-17:~# kubectl describe deployment mytest
...
Replicas: 10 desired | 7 updated | 14 total | 7 available | 7 unavailable
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal ScalingReplicaSet 5m46s deployment-controller Scaled up replica set mytest-59887f89f5 from 0 to 10
Normal ScalingReplicaSet 2m52s deployment-controller Scaled up replica set mytest-8586c6547d from 0 to 4
Normal ScalingReplicaSet 2m50s deployment-controller Scaled down replica set mytest-59887f89f5 from 10 to 7
Normal ScalingReplicaSet 2m45s deployment-controller Scaled up replica set mytest-8586c6547d from 4 to 7
```

4. 如此我们保证了集群中有7个可用的pod

下面来解析一下整个过程

maxSurge:

规定了滚动更新过程中pod副本数可以超过总副本数的上限。配置项可以是一个具体的数字也可以是一个比例，如果是比例则会向上取整

我们的例子副本总数是10 maxSurge: 35% 所以 10 + 10 * 35% = 13.5 --> 14

所以对mytest这个deployment的副本描述Replicas: 10 desired | 7 updated | 14 total | 7 available | 7 unavailable

10个目标值 7个已经更新 14为最大值 7个可用 7个不可用

maxUnavailable：

控制滚动过程中最大pod不可用数量。同样可以是一个数字也可以是一个比例。如果是比例则向上取整

我们例子中 maxUnavailable：35% 所以 10 - 10 * 35% = 6.5 --> 7

我们本次滚动更新的完整过程为

1） 根据maxSurge得到最大副本数14 所以 先创建4个新版本的pod副本，使副本总数达到14

2） 然后根据maxUnavailable 的到最大不可用数量为7 14-7(最大不可用数)=7(最小可用数) 所以销毁3个旧版本的pod 

3） 3个旧版本pod销毁完成之后，再创建3个新版本pod使总副本数保持14

4） 当新版本pod通过Readiness检测后，会使可用pod副本超过7个

5） 再销毁更多旧pod使可用副本保持7个。

6） 随着旧pod销毁，新pod会自动创建，使副本数保持14

7） 依此类推一直到全部更新完成。

我们的实际情况在第4步卡住了。新的pod无法通过Readiness的检测。

此时在实际生产环境中我们需要rollout undo 来回滚上一个版本保证集群整体

```shell
root@k8s-192-168-0-17:~# kubectl rollout history deployment mytest
deployment.apps/mytest 
REVISION CHANGE-CAUSE
1 kubectl apply --filename=myapp-v1.yaml
2 kubectl apply --filename=myapp-v2.yaml

root@k8s-192-168-0-17:~# kubectl rollout undo deployment mytest --to-revision=1
deployment.apps/mytest rolled back

# 然后 观察全局pod的变化过程
kubectl get pod -w
```

Vue

Mon, 01 Jan 0001 00:00:00 +0000

看看人家的就行了：

汇编语言入门五：流程控制（一）

Mon, 01 Jan 0001 00:00:00 +0000

回顾

前面说到过这样几个内容：

几条简单的汇编指令
寄存器
内存访问

对应到C语言的学习过程中，无非就是这样几个内容：

超级简单的运算
变量

好了，到这里，我们继续接下来的话题，程序中的流程控制。

文中涉及一些汇编代码，建议读者自行编程，通过动手实践来加深对程序的理解。

顺序执行

首先，最简单也最好理解的程序流程，便是从前往后的顺序执行。这个非常简单，还是举出前面的例子：

现在有1000个计算题：

99+10=
32-20=
14+21=
47-9=
87+3=
86-8=
...

需要你一个个地从前往后计算，计算结果需要写在专门的答题卡上。当你每做完一个题，你需要继续做下一个题（这不是废话么）。

那么问题来了，我每次计算完一个题目，回头寻找下一个题目的时候，到底哪一个题是我接下来要计算的呢？

你可能会说：瞄一眼答题卡就知道了呀。这就尴尬了，计算机其实是比较傻的，它可没有“瞄一眼”这样的功能。

那这样的话，如果是自己做1000个题目，为了保证做题的时候每一个动作都不是多余的，有一个比较好的办法，就是强行在脑子里记住刚刚那个题目的位置。一会儿回头的时候，就立马知道该继续做哪个题了。

好了，那对于计算机来说呢？前面说到，你做计算题的时候临时留在脑子里的东西，就对应CPU里寄存器的数据。寄存器就充当了临时记住一些东西的功能。那么，在这里，CPU也是用的这个套路，在内部有一个寄存器，专门用来记录程序执行到哪里了。

CPU中的顺序执行过程

前面已经有了一个初步的结论，CPU里有一个寄存器专门存放“程序执行到哪里了”这样一个信息，而且这么做也是说得过去的，那就是：必须有一个东西记录当前程序执行到的位置，否则CPU执行完一条指令之后，就不知道接下来该干什么了。

在x86体系结构的CPU里面，这个执行位置的信息，是保存在叫做eip的寄存器中的。不过很遗憾，这个寄存器比较特殊，无法通过mov指令进行修改，也就是说，这么写mov eip, 0x233是行不通的。

（不要问我为什么，我也不知道，这都是人做出来的东西，支不支持就看人家的心情。反正Intel的CPU做出来就是这个样子的，你可以认为，Intel在做CPU的时候压根就没支持这个功能，他们觉得做了也没什么卵用。虽然你可能觉得有这个功能不是更好么，但是实际上，有时候刻意对功能施加一些限制，可以减少程序员写代码误操作的机会，eip这个东西，很关键）

好了，介绍完eip的作用之后，再说一下细节的东西。在执行一条指令的时候，eip此时代表的是下一条指令的位置，eip里保存的就是下一条指令在内存中的地址。这样，CPU在执行完成一条指令之后，就直接根据eip的值，取出下一条指令，同时还要修改eip，往eip上加一个指令的长度，让它继续指向后一条指令。

有了这样一个过程，CPU就能自动地去从前往后执行每一条指令了。而且，上述过程是在CPU中自动发生的，你写代码的时候根本不需要关心这个东西，只需要按照自己的思路从前往后写就是了。

好了，这一段更多的是讲故事，明白CPU里面有个eip寄存器，它的功能很专一，就是用来表示程序现在执行到哪儿了。说得精确一点，eip一直都指向下一个要执行的指令，这一点是由CPU自己保证的。总之，只要CPU没坏，它就能给你保证eip的精确。

事情没那么简单

前面说了eip能记住程序执行的位置，那么CPU就能顺溜溜地一路走下去了。然而，世界并不是这么美好。因为：

if( a < 1 ){
 // some code ...
} else if( a >= 10 ) {
 // yi xie dai ma ...
}

实际上有时候我们需要程序有一定的流程控制能力。就是有时候它不是老老实实按照顺序来执行的，中间可能会跳过一些代码，比如上述C代码中的a的值为100的时候。

外观模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

外观模式中，一个子系统的外部与其内部的通信通过一个统一的外观类进行，外观类将客户类与子系统的内部复杂性分隔开，使得客户类只需要与外观角色打交道，而不需要与子系统内部的很多对象打交道。

定义

外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

外观模式又称为门面模式，它是一种对象结构型模式。外观模式是迪米特法则的一种具体实现，通过引入一个新的外观角色可以降低原有系统的复杂度，同时降低客户类与子系统的耦合度。

结构

外观模式没有一个一般化的类图描述，通常使用下图表示：

角色

(1) Facade（外观角色）：在客户端可以调用它的方法，在外观角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的子系统去，传递给相应的子系统对象处理。

(2) SubSystem（子系统角色）：在软件系统中可以有一个或者多个子系统角色，每一个子系统可以不是一个单独的类，而是一个类的集合，它实现子系统的功能；每一个子系统都可以被客户端直接调用，或者被外观角色调用，它处理由外观类传过来的请求；子系统并不知道外观的存在，对于子系统而言，外观角色仅仅是另外一个客户端而已。

典型代码

模式实现外观模式的主要目的在于降低系统的复杂程度，在面向对象软件系统中，类与类之间的关系越多，不能表示系统设计得越好，反而表示系统中类之间的耦合度太大，这样的系统在维护和修改时都缺乏灵活性，因为一个类的改动会导致多个类发生变化，而外观模式的引入在很大程度上降低了类与类之间的耦合关系。引入外观模式之后，增加新的子系统或者移除子系统都非常方便，客户类无须进行修改（或者极少的修改），只需要在外观类中增加或移除对子系统的引用即可。从这一点来说，外观模式在一定程度上并不符合开闭原则，增加新的子系统需要对原有系统进行一定的修改，虽然这个修改工作量不大。

外观模式中所指的子系统是一个广义的概念，它可以是一个类、一个功能模块、系统的一个组成部分或者一个完整的系统。子系统类通常是一些业务类，实现了一些具体的、独立的业务功能，其典型代码如下：

class SubSystemA
{
 public void MethodA()
 {
 //业务实现代码
 }
}
 
class SubSystemB
{
 public void MethodB()
 {
 //业务实现代码
 }
}
 
class SubSystemC
{
 public void MethodC()
 {
 //业务实现代码
 }
}

在引入外观类之后，与子系统业务类之间的交互统一由外观类来完成，在外观类中通常存在如下代码：

线程池

Mon, 01 Jan 0001 00:00:00 +0000


import java.io.IOException;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class TestThreadPoolExecutor {
 /*
 corePoolSize:指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
 当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。
 如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。
 maximumPoolSize:指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
 如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。
 值得注意的是，如果使用了无界的任务队列这个参数就没用了

 执行：
 1、2任务直接压入1、2线程直接创建并执行，
 3任务放入缓冲队列，最大线程数未满，创建新线程执行3任务

 */
 public static void main(String[] args) throws InterruptedException, IOException {
 int corePoolSize = 2;
 int maximumPoolSize = 10;
 long keepAliveTime = 10;
 TimeUnit unit = TimeUnit.SECONDS;
 BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
 ThreadFactory threadFactory = new NameTreadFactory();
 RejectedExecutionHandler handler = new MyIgnorePolicy();
 ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
 workQueue, threadFactory);
 executor.prestartAllCoreThreads(); // 预启动所有核心线程

 for (int i = 1; i <= 10; i++) {
// Thread.sleep(1);
 MyTask task = new MyTask(String.valueOf(i));
 executor.execute(task);
 System.out.println("当前队列数两"+executor.getQueue().size());
 }
 System.out.println(executor.getActiveCount());
 Thread.sleep(10000);
 System.out.println(executor.getActiveCount());
 System.in.read(); //阻塞主线程
 }

 static class NameTreadFactory implements ThreadFactory {

 private final AtomicInteger mThreadNum = new AtomicInteger(1);

 @Override
 public Thread newThread(Runnable r) {
// try {
// Thread.sleep(200);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
 Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
 System.out.println(t.getName() + " has been created");
 return t;
 }
 }

 public static class MyIgnorePolicy implements RejectedExecutionHandler {

 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
 doLog(r, e);
 }

 private void doLog(Runnable r, ThreadPoolExecutor e) {
 // 可做日志记录等
 System.err.println( r.toString() + " rejected");
// System.out.println("completedTaskCount: " + e.getCompletedTaskCount());
 }
 }

 static class MyTask implements Runnable {
 private String name;

 public MyTask(String name) {
 this.name = name;
 }

 @Override
 public void run() {
 try {
 System.out.println(this.toString() + " is running!");
 Thread.sleep(1000); //让任务执行慢点
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }

 public String getName() {
 return name;
 }

 @Override
 public String toString() {
 return "MyTask [name=" + name + "]";
 }
 }
}

原型模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

在使用原型模式时，我们需要首先创建一个原型对象，再通过复制这个原型对象来创建更多同类型的对象。

试想，如果连孙悟空的模样都不知道，怎么拔毛变小猴子呢？

定义

原型模式(Prototype Pattern)：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。

原型模式的工作原理很简单：将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程。

由于在软件系统中我们经常会遇到需要创建多个相同或者相似对象的情况，因此原型模式在真实开发中的使用频率还是非常高的。

原型模式是一种“另类”的创建型模式，创建克隆对象的工厂就是原型类自身，工厂方法由克隆方法来实现。

需要注意的是通过克隆方法所创建的对象是全新的对象，它们在内存中拥有新的地址，通常对克隆所产生的对象进行修改对原型对象不会造成任何影响，每一个克隆对象都是相互独立的。

通过不同的方式修改可以得到一系列相似但不完全相同的对象。

结构

角色

●Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，可以是抽象类也可以是接口，甚至还可以是具体实现类。

● ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。

● Client（客户类）：让一个原型对象克隆自身从而创建一个新的对象，在客户类中只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。

典型代码

原型模式的核心在于如何实现克隆方法，下面将介绍两种在Java语言中常用的克隆实现方法：

通用实现方法

通用的克隆实现方法是在具体原型类的克隆方法中实例化一个与自身类型相同的对象并将其返回，并将相关的参数传入新创建的对象中，保证它们的成员属性相同。示意代码如下所示：

class ConcretePrototype implements Prototype

{

private String attr; //成员属性

public void setAttr(String attr)

{

 this.attr = attr;

}

public String getAttr()

{

 return this.attr;

}

public Prototype clone() //克隆方法

{

 Prototype prototype = new ConcretePrototype(); //创建新对象

 prototype.setAttr(this.attr);

 return prototype;

}

}

思考

中介者模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

如果在一个系统中对象之间的联系呈现为网状结构，如图1所示。

对象之间存在大量的多对多联系，将导致系统非常复杂，这些对象既会影响别的对象，也会被别的对象所影响，这些对象称为同事对象，它们之间通过彼此的相互作用实现系统的行为。

在网状结构中，几乎每个对象都需要与其他对象发生相互作用，而这种相互作用表现为一个对象与另外一个对象的直接耦合，这将导致一个过度耦合的系统。

图1 对象之间存在复杂关系的网状结构

中介者模式可以使对象之间的关系数量急剧减少，通过引入中介者对象，可以将系统的网状结构变成以中介者为中心的星形结构，如图2所示。

在这个星形结构中，同事对象不再直接与另一个对象联系，它通过中介者对象与另一个对象发生相互作用。中介者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因为新对象的引入带来大量的修改工作。

图2 引入中介者对象的星型结构

如果在一个系统中对象之间存在多对多的相互关系，我们可以将对象之间的一些交互行为从各个对象中分离出来，并集中封装在一个中介者对象中，并由该中介者进行统一协调，这样对象之间多对多的复杂关系就转化为相对简单的一对多关系。

通过引入中介者来简化对象之间的复杂交互，中介者模式是“迪米特法则”的一个典型应用。

定义

中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

结构

在中介者模式中，我们引入了用于协调其他对象/类之间相互调用的中介者类，为了让系统具有更好的灵活性和可扩展性，通常还提供了抽象中介者，其结构图如图3所示：

图3 中介者模式结构图

角色

● Mediator**（抽象中介者）：**它定义一个接口，该接口用于与各同事对象之间进行通信。

● ConcreteMediator**（具体中介者）：**它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用。

● Colleague**（抽象同事类）：**它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信。

● ConcreteColleague**（具体同事类）：**它是抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法。

典型代码

中介者模式的核心在于中介者类的引入，在中介者模式中，中介者类承担了两方面的职责：

(1) **中转作用（结构性）：**通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，可通过中介者来实现间接调用。该中转作用属于中介者在结构上的支持。

(2) **协调作用（行为性）：**中介者可以更进一步的对同事之间的关系进行封装，同事可以一致的和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

在中介者模式中，典型的抽象中介者类代码如下所示：

abstract class Mediator {
 protected ArrayList<Colleague> colleagues; //用于存储同事对象
 
 //注册方法，用于增加同事对象
 public void register(Colleague colleague) {
 colleagues.add(colleague);
 }
 
 //声明抽象的业务方法
 public abstract void operation();
}

在抽象中介者中可以定义一个同事类的集合，用于存储同事对象并提供注册方法，同时声明了具体中介者类所具有的方法。在具体中介者类中将实现这些抽象方法，典型的具体中介者类代码如下所示：

备忘录模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，当前很多软件都提供了撤销(Undo)操作，其中就使用了备忘录模式。

定义

备忘录模式(Memento Pattern)：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为型模式，其别名为Token。

结构

角色

**● Originator（原发器）：**它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。

**●Memento（备忘录)：**存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。

**●Caretaker（负责人）：**负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

理解备忘录模式并不难，但关键在于如何设计备忘录类和负责人类。由于在备忘录中存储的是原发器的中间状态，因此需要防止原发器以外的其他对象访问备忘录，特别是不允许其他对象来修改备忘录。

典型代码

下面我们通过简单的示例代码来说明如何使用Java语言实现备忘录模式：

在使用备忘录模式时，首先应该存在一个原发器类Originator，在真实业务中，原发器类是一个具体的业务类，它包含一些用于存储成员数据的属性，典型代码如下所示：

package dp.memento;
public class Originator {
 private String state;
 
 public Originator(){}
 
　　// 创建一个备忘录对象
 public Memento createMemento() {
　　　　return new Memento(this);
 }
 
　　// 根据备忘录对象恢复原发器状态
 public void restoreMemento(Memento m) {
　　　　 state = m.state;
 }
 
 public void setState(String state) {
 this.state=state;
 }
 
 public String getState() {
 return this.state;
 }
}

对于备忘录类Memento而言，它通常提供了与原发器相对应的属性（可以是全部，也可以是部分）用于存储原发器的状态，典型的备忘录类设计代码如下：

汇编语言入门六：流程控制（二）

Mon, 01 Jan 0001 00:00:00 +0000

回顾

前面说到在汇编语言中实现类似C语言if-else if-else这样的结构，

实际上，在汇编里面，我们并不关心if了，取而代之的是两种基本的指令：

比较
跳转

这两种指令即可组成最基本的分支程序结构，虽然跳转指令非常多，但是我们已经有套路了，怎么跳转都不怕了。当然，在编程环境中仅有分支还不够的，我们知道C语言中除了分支结构之外，还有循环这个最基本也是最常用的形式。正好，这也是本节话题的主角。

文中涉及一些汇编代码，建议读者自行编程，通过动手实践来加深对程序的理解。

拆散循环结构

上回说到C语言中if这样的结构，在汇编里对应的是怎么回事，实质上，这就是分支结构的程序在汇编里的表现形式。

实际上，循环结构相比分支结构，本质上，没有多少变化，仅仅是比较合跳转指令的组合的方式与顺序有所不同，所以形成了循环。

当然，这个说法可能稍微拗口了一点。说得简单一点，循环的一个关键特点就是：

程序在往回跳转

细细想，好像有道理哦，如果程序每到一个位置就往前跳转，那就是死循环，如果是在这个位置根据条件决定是否要向前跳转，那就是有条件的循环了。

口说无凭，还是先来分析一下一个C语言的while循环：

(Talk is chip, show your code!)

int sum = 0;
int i = 1;
while( i <= 10 ) {
 sum = sum + i;
 i = i + 1;
}

想必这段程序多数人都非常熟悉了，当年自己第一次学习循环的时候就碰到这个题目，脑子短路了，心里总想着这不就是一个等差数列公式么，题目却强行出现在循环一章的后面，最后结果让人大跌眼睛，这是要我老老实实像SHAB一样去加啊。

跑题了，先大致总结一下这个程序的关键部分到底在干什么：

1. 比较i和10的大小
2. 如果i <= 10则执行代码块，并回到(1)
3. 如果不满足 i <= 10，则跳过代码块

好了，按照这个逻辑，在C语言中不使用循环怎么实现？其实也非常简单：

int sum = 10;
int i = 1;

_start:
if( i <= 10 ) {
 sum = sum + i;
 i = i + 1;
 goto _start;
}

这还不够，我们还得做一次变形，为什么呢？回想一下前面说的分之程序在汇编里的情况：

建造者模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。它关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。

定义

建造者模式(Builder Pattern)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。

建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

结构

角色

● Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

●ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

●Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。

● Director（指挥者）：指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

典型代码

在建造者模式的定义中提到了复杂对象，那么什么是复杂对象？简单来说，复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件，电子邮件包括发件人、收件人、主题、内容、附件等部件，一个典型的复杂对象类代码示例如下：

@Data
class Product  {

 private  String partA; //定义部件，部件可以是任意类型，包括值类型和引用类型

 private  String partB;

 private  String partC;

}

在抽象建造者类中定义了产品的创建方法和返回方法，其典型代码如下：

abstract class Builder {

     //创建产品对象

 protected  Product product=new Product();

 public  abstract void buildPartA();

 public  abstract void buildPartB();

 public  abstract void buildPartC();

     //返回产品对象

 public  Product getResult() {

        return  product;

 }

}

在抽象类Builder中声明了一系列抽象的buildPartX()方法用于创建复杂产品的各个部件，具体建造过程在ConcreteBuilder中实现，此外还提供了工厂方法getResult()，用于返回一个建造好的完整产品。

线程交替执行的实践

Mon, 01 Jan 0001 00:00:00 +0000

只能保证交替执行，至于先输出1 还是先输出A 谁先抢到o锁谁就输出

public class Syncwaitnotify1 {

 public static void main(String[] args) {
 final Object o = new Object();
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();
 new Thread(()->{
 //1. 先拿到o锁
 synchronized (o) {
 for(char c : aI) {
 //2. 执行
 System.out.print(c);
 try {
 o.notify();//唤醒线程队列中得下一个线程， 这里只有两个，就相当于唤醒另一个
 o.wait();//让出锁，重新进入等待队列
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }
 }, "t1").start();

 new Thread(()->{
 //1. 和上面得Thread强锁
 synchronized (o) {
 for(char i : aC) {
 System.out.print(i);
 try {
 o.notify();
 o.wait();
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }

 }, "t2").start();
 }
}

先等待一直等到CountDownLatch计数器为0, 所以这个程序一定先输出A


import java.util.concurrent.CountDownLatch;

public class Syncwaitnotify2 {
 /*
 CountDownLatch latch = new CountDownLatch(n);
 latch.countDown();每执行一次，n-1
 */
 private static CountDownLatch latch = new CountDownLatch(1);

 public static void main(String[] args) {
 final Object o = new Object();
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();
 new Thread(()->{
 try{
 latch.await();
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 //1. 先拿到o锁
 synchronized (o) {
 for(char c : aI) {
 //2. 执行
 System.out.print(c);
 try {
 o.notify();//唤醒线程队列中得下一个线程， 这里只有两个，就相当于唤醒另一个
 o.wait();//让出锁，重新进入等待队列
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }
 }, "t1").start();

 new Thread(()->{
 //1. 和上面得Thread强锁
 synchronized (o) {
 for(char i : aC) {
 System.out.print(i);
 latch.countDown();
 try {
 o.notify();
 o.wait();
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }

 }, "t2").start();


 }
}

通过volatile 实现 volatile是原子操作并且线程可见，也可以保证顺序执行


/**
 * 如果t1先拿到锁，此时t25 = false 在while中不断得会让出锁
 * 等t2拿到锁后， 设置t25=true就可以正常交替执行了
 */
public class Syncwaitnotify3 {

 private static volatile boolean t25 = false;

 public static void main(String[] args) {
 final Object o = new Object();
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();
 new Thread(()->{
 //1. 如果t1先拿到锁
 synchronized (o) {
 //2. 此时t25=false
 while (!t25) {
 try {
 //3. 让出线程， 进入等待队列
 o.wait();
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 for(char c : aI) {
 System.out.print(c);
 try {
 o.notify();//唤醒线程队列中得下一个线程， 这里只有两个，就相当于唤醒另一个
 o.wait();//让出锁，重新进入等待队列
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }
 }, "t1").start();

 new Thread(()->{
 //4. 此时t2后拿到锁
 synchronized (o) {
 for(char i : aC) {
 System.out.print(i);
 t25 = true;
 try {
 o.notify();
 o.wait();
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 o.notify();
 }

 }, "t2").start();


 }
}

指定线程锁，相互唤醒，第一次也使用latch.await(); 保证，和2差不多


import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockCondition {
 public static void main(String[] args) {
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();

 Lock lock = new ReentrantLock();
 Condition conditionT1 = lock.newCondition();
 Condition conditionT2 = lock.newCondition();

 CountDownLatch latch = new CountDownLatch(1);

 new Thread(()->{
 try {
 //1. 启动线程直接进入等待
 latch.await();
 }catch (InterruptedException e) {
 e.printStackTrace();
 }
 lock.lock();
 try {
 for(char c : aI) {
 System.out.print(c);
 conditionT2.signal();
 conditionT1.await();
 }
 conditionT2.signal();
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 lock.unlock();
 }
 }, "t1").start();

 new Thread(()->{
 lock.lock();
 try {
 //2. 线程启动直接进入循环进行输出
 for(char c : aC) {
 System.out.print(c);
 //3. 标记完成
 latch.countDown();
 //4. 唤醒conditionT1队列
 conditionT1.signal();
 conditionT2.await();
 }
 conditionT1.signal();
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 lock.unlock();
 }
 }, "t2").start();
 }
}

LockSupport的实现


import java.util.concurrent.locks.LockSupport;

public class LockSupport1 {
 static Thread t1=null, t2=null;
 public static void main(String[] args) {
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();

 t1 = new Thread(() -> {
 for(char c: aI) {
 LockSupport.park();
 System.out.print(c);
 LockSupport.unpark(t2);
 }
 },"t1");

 t2 = new Thread(() -> {
 for(char c: aC) {


 System.out.print(c);
 LockSupport.unpark(t1);
 LockSupport.park();

 }
 },"t2");

 t1.start();
 t2.start();
 }
}

TransferQueue的实现


import java.util.concurrent.LinkedTransferQueue;

public class TransferQueue1 {
 public static void main(String[] args) {
 char[] aI = "123456789".toCharArray();
 char[] aC = "ABCDEFGHI".toCharArray();
 java.util.concurrent.TransferQueue<Character> queue = new LinkedTransferQueue<>();

 new Thread(() ->{
 try{
 for(char c: aI) {
 System.out.print(queue.take());
 queue.transfer(c);
 }
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }, "t1").start();
 new Thread(() ->{
 try{
 for(char c: aC) {
 queue.transfer(c);
 System.out.print(queue.take());
 }
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }, "t2").start();
 }
}

享元模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

当一个软件系统在运行时产生的对象数量太多，将导致运行代价过高，带来系统性能下降等问题。

例如在一个文本字符串中存在很多重复的字符，如果每一个字符都用一个单独的对象来表示，将会占用较多的内存空间，那么我们如何去避免系统中出现大量相同或相似的对象，同时又不影响客户端程序通过面向对象的方式对这些对象进行操作？享元模式正为解决这一类问题而诞生。

享元模式通过共享技术实现相同或相似对象的重用，在逻辑上每一个出现的字符都有一个对象与之对应，然而在物理上它们却共享同一个享元对象，这个对象可以出现在一个字符串的不同地方，相同的字符对象都指向同一个实例，在享元模式中，存储这些共享实例对象的地方称为享元池(Flyweight Pool)。

我们可以针对每一个不同的字符创建一个享元对象，将其放在享元池中，需要时再从享元池取出。如图

享元模式以共享的方式高效地支持大量细粒度对象的重用，享元对象能做到共享的关键是区分了内部状态(Intrinsic State)和外部状态(Extrinsic State)。

下面将对享元的内部状态和外部状态进行简单的介绍：

内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，内部状态可以共享。如字符的内容，不会随外部环境的变化而变化，无论在任何环境下字符“a”始终是“a”，都不会变成“b”。
外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态通常由客户端保存，并在享元对象被创建之后，需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的。如字符的颜色，可以在不同的地方有不同的颜色，例如有的“a”是红色的，有的“a”是绿色的，字符的大小也是如此，有的“a”是五号字，有的“a”是四号字。而且字符的颜色和大小是两个独立的外部状态，它们可以独立变化，相互之间没有影响，客户端可以在使用时将外部状态注入享元对象中。

正因为区分了内部状态和外部状态，我们可以将具有相同内部状态的对象存储在享元池中，享元池中的对象是可以实现共享的，需要的时候就将对象从享元池中取出，实现对象的复用。通过向取出的对象注入不同的外部状态，可以得到一系列相似的对象，而这些对象在内存中实际上只存储一份。

定义

享元模式(Flyweight Pattern)：运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式，它是一种对象结构型模式。

享元模式结构较为复杂，一般结合工厂模式一起使用，在它的结构图中包含了一个享元工厂类

结构

角色

● Flyweight（抽象享元类）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。

● ConcreteFlyweight（具体享元类）：它实现了抽象享元类，其实例称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。

● UnsharedConcreteFlyweight（非共享具体享元类）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。

● FlyweightFactory（享元工厂类）：享元工厂类用于创建并管理享元对象，它针对抽象享元类编程，将各种类型的具体享元对象存储在一个享元池中，享元池一般设计为一个存储“键值对”的集合（也可以是其他类型的集合），可以结合工厂模式进行设计；当用户请求一个具体享元对象时，享元工厂提供一个存储在享元池中已创建的实例或者创建一个新的实例（如果不存在的话），返回新创建的实例并将其存储在享元池中。

在享元模式中引入了享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，当用户需要对象时，首先从享元池中获取，如果享元池中不存在，则创建一个新的享元对象返回给用户，并在享元池中保存该新增对象。

典型代码

class FlyweightFactory {

 //定义一个HashMap用于存储享元对象，实现享元池
 private HashMap flyweights = newHashMap();

 public Flyweight getFlyweight(String key){
 //如果对象存在，则直接从享元池获取
 if(flyweights.containsKey(key)){
 return(Flyweight)flyweights.get(key);
 }
 //如果对象不存在，先创建一个新的对象添加到享元池中，然后返回
 else {
 Flyweight fw = newConcreteFlyweight();
 flyweights.put(key,fw);
 return fw;
 }
 }
}

享元类的设计是享元模式的要点之一，在享元类中要将内部状态和外部状态分开处理，通常将内部状态作为享元类的成员变量，而外部状态通过注入的方式添加到享元类中。典型的享元类代码如下所示

007在k8s集群内使用nameServer进行网络访问

Mon, 01 Jan 0001 00:00:00 +0000

1. 准备一个svc的yaml配置

apiVersion: v1
kind: Service
metadata:
 creationTimestamp: null
 labels:
 app: web
 name: web
spec:
 ports:
 - port: 80
 protocol: TCP
 targetPort: 80
 selector:
 app: web
status:
 loadBalancer: {}

---

apiVersion: apps/v1
kind: Deployment
metadata:
 labels:
 app: web
 name: web
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 app: web
 template:
 metadata:
 labels:
 app: web
 spec:
 containers:
 - image: nginx:1.21.6
 name: nginx

启动一个工具pod容器并验证

kubectl run -it --rm busybox --image=registry.cn-shanghai.aliyuncs.com/acs/busybox:v1.29.2 -- sh
# --rm的意思是当推出pod容器 sh 时， pod容器会自动删除

/ # wget -q -O- http://web
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Callable捕获异常

Mon, 01 Jan 0001 00:00:00 +0000


import java.util.concurrent.*;

/**
 * Callable捕获异常
 */
public class CallableGetThrow {
 public static void main(String[] args){
 int timeout = 2;
 ExecutorService executor = Executors.newSingleThreadExecutor();
 Boolean result = false;

 Future<Boolean> future = executor.submit(new TaskThread("发送请求"));//将任务提交给线程池

 try {
 System.out.println("try");
 result = future.get(timeout, TimeUnit.SECONDS);//获取结果
 future.cancel(true);
 System.out.println("发送请求任务的返回结果："+result); //2
 } catch (InterruptedException e) {
 System.out.println("线程中断出错。"+e);
 future.cancel(true);// 中断执行此任务的线程
 } catch (ExecutionException e) {
 System.out.println("线程服务出错。");
 future.cancel(true);
 } catch (TimeoutException e) {// 超时异常
 System.out.println("超时。");
 future.cancel(true);
 }finally{
 System.out.println("线程服务关闭。");
 executor.shutdown();
 }
 }

 static class TaskThread implements Callable<Boolean> {
 private String t;
 public TaskThread(String temp){
 this.t= temp;
 }

 /*
 try
 继续执行..........
 发送请求任务的返回结果： true
 线程服务关闭。
 */
// public Boolean call() throws InterruptedException {
// Thread.currentThread().sleep(1000);
// System.out.println("继续执行..........");
// return true;
// }

 /*
 try
 超时。
 线程服务关闭。
 */
// public Boolean call() throws InterruptedException {
// Thread.currentThread().sleep(3000);
// System.out.println("继续执行..........");
// return true;
// }

 /*
 * try
 * start
 * 线程服务出错。
 * 线程服务关闭。
 */
 public Boolean call() throws InterruptedException {
 System.out.println("start");
 throw new InterruptedException();
 }

 }
}

cookie、localStorage和sessionStorage 三者之间的区别以及存储、获取、删除等使用方式

Mon, 01 Jan 0001 00:00:00 +0000

写在前面：

前端开发的时候，在网页刷新的时候，所有数据都会被清空，这时候就要用到本地存储的技术，前端本地存储的方式有三种，分别是cookie，localstorage和sessionStorage ，这是大家都知道的。本文的主要内容就是针对这三者的存放、获取，区别、应用场景。有需要的朋友可以做一下参考，希望可以帮到大家。

本文首发于blog：obkoro1.com 本文版权归作者所有，转载请注明出处。

使用方式：

很多文档都是说了一大堆，后面用法都没有说，先要学会怎么用，不然后面的都是扯淡，所以这里我先把使用方式弄出来。

保存cookie值：

 var dataCookie='110';
 document.cookie = 'token' + "=" +dataCookie; 复制代码

获取指定名称的cookie值

 function getCookie(name) { //获取指定名称的cookie值
// (^| )name=([^;]*)(;|$),match[0]为与整个正则表达式匹配的字符串，match[i]为正则表达式捕获数组相匹配的数组；
var arr = document.cookie.match(new RegExp("(^| )"+name+"=([^;]*)(;|$)"));
if(arr != null) {
 console.log(arr);
 return unescape(arr[2]);
}
return null;
}
 var cookieData=getCookie('token'); //cookie赋值给变量。复制代码

先贴这两个最基础的方法，文末有个demo里面还有如何设置cookie过期时间，以及删除cookie的、

localStorage和sessionStorage:

localStorage和sessionStorage所使用的方法是一样的，下面以sessionStorage为栗子：

var name='sessionData';
var num=120;
sessionStorage.setItem(name,num);//存储数据
sessionStorage.setItem('value2',119);
let dataAll=sessionStorage.valueOf();//获取全部数据
console.log(dataAll,'获取全部数据');
var dataSession=sessionStorage.getItem(name);//获取指定键名数据
var dataSession2=sessionStorage.sessionData;//sessionStorage是js对象，也可以使用key的方式来获取值
 console.log(dataSession,dataSession2,'获取指定键名数据');
sessionStorage.removeItem(name); //删除指定键名数据
 console.log(dataAll,'获取全部数据1');
 sessionStorage.clear();//清空缓存数据：localStorage.clear();
 console.log(dataAll,'获取全部数据2'); 复制代码

使用方式，基本上就上面这些，其实也是比较简单的。大家可以把这个copy到自己的编译器里面，或者文末有个demo，可以点开看看。

代理模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

代理模式是常用的结构型设计模式之一，当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象需要实现相同的接口。

根据代理模式的使用目的不同，代理模式又可以分为多种类型，例如保护代理、远程代理、虚拟代理、缓冲代理等，它们应用于不同的场合，满足用户的不同需求。

近年来，代购已逐步成为电子商务的一个重要分支。

何谓代购，简单来说就是找人帮忙购买所需要的商品，当然你可能需要向实施代购的人支付一定的费用。

代购通常分为两种类型：

一种是因为在当地买不到某件商品，又或者是因为当地这件商品的价格比其他地区的贵，因此托人在其他地区甚至国外购买该商品，然后通过快递发货或者直接携带回来；

还有一种代购，由于消费者对想要购买的商品相关信息的缺乏，自已无法确定其实际价值而又不想被商家宰，只好委托中介机构帮其讲价或为其代买。

代购网站为此应运而生，它为消费者提供在线的代购服务，如果看中某国外购物网站上的商品，可以登录代购网站填写代购单并付款，代购网站会帮助进行购买然后通过快递公司将商品发送给消费者。

在软件开发中，也有一种设计模式可以提供与代购网站类似的功能。由于某些原因，客户端不想或不能直接访问一个对象，此时可以通过一个称之为“代理”的第三者来实现间接访问，该方案对应的设计模式被称为代理模式。

代理模式是一种应用很广泛的结构型设计模式，而且变化形式非常多，常见的代理形式包括远程代理、保护代理、虚拟代理、缓冲代理、智能引用代理等，后面将学习这些不同的代理形式。

定义

代理模式：给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问。

Proxy Pattern: Provide a surrogate or placeholder for another object to control access to it.

代理模式是一种对象结构型模式。在代理模式中引入了一个新的代理对象，代理对象在客户端对象和目标对象之间起到中介的作用，它去掉客户不能看到的内容和服务或者增添客户需要的额外的新服务。

结构

代理模式的结构比较简单，其核心是代理类，为了让客户端能够一致性地对待真实对象和代理对象，在代理模式中引入了抽象层，代理模式结构如图

角色：

**(1) Subject（抽象主题角色）：**它声明了真实主题和代理主题的共同接口，这样一来在任何使用真实主题的地方都可以使用代理主题，客户端通常需要针对抽象主题角色进行编程。

**(2) Proxy（代理主题角色）：**它包含了对真实主题的引用，从而可以在任何时候操作真实主题对象；在代理主题角色中提供一个与真实主题角色相同的接口，以便在任何时候都可以替代真实主题；代理主题角色还可以控制对真实主题的使用，负责在需要的时候创建和删除真实主题对象，并对真实主题对象的使用加以约束。通常，在代理主题角色中，客户端在调用所引用的真实主题操作之前或之后还需要执行其他操作，而不仅仅是单纯调用真实主题对象中的操作。

**(3) RealSubject（真实主题角色）：**它定义了代理角色所代表的真实对象，在真实主题角色中实现了真实的业务操作，客户端可以通过代理主题角色间接调用真实主题角色中定义的操作。

典型代码

代理模式的结构图比较简单，但是在真实的使用和实现过程中要复杂很多，特别是代理类的设计和实现。

抽象主题类声明了真实主题类和代理类的公共方法，它可以是接口、抽象类或具体类，客户端针对抽象主题类编程，一致性地对待真实主题和代理主题，典型的抽象主题类代码如下：

abstract class Subject
{
 public abstract void Request();
}

真实主题类继承了抽象主题类，提供了业务方法的具体实现，其典型代码如下：

class RealSubject extend Subject
{
 public override void Request()
 {
 //业务方法具体实现代码
 }
}

代理类也是抽象主题类的子类，它维持一个对真实主题对象的引用，调用在真实主题中实现的业务方法，在调用时可以在原有业务方法的基础上附加一些新的方法来对功能进行扩充或约束，最简单的代理类实现代码如下：

观察者模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

观察者模式是使用频率最高的设计模式之一，它用于建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应作出反应。

在观察者模式中，发生改变的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个观察者，而且这些观察者之间可以没有任何相互联系，可以根据需要增加和删除观察者，使得系统更易于扩展。

定义

观察者模式(Observer Pattern)：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型\视图（Model/View）模式、源\监听器（Source/Listener）模式或从属者（Dependents）模式。观察者模式是一种对象行为型模式。

结构

观察者模式结构中通常包括观察目标和观察者两个继承层次结构

观察者模式结构图

角色

● Subject（目标）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标可以接受任意数量的观察者来观察，它提供一系列方法来增加和删除观察者对象，同时它定义了通知方法notify()。目标类可以是接口，也可以是抽象类或具体类。

● ConcreteSubject（具体目标）：具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法（如果有的话）。如果无须扩展目标类，则具体目标类可以省略。

● Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法update()，因此又称为抽象观察者。

● ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致；它实现了在抽象观察者Observer中定义的update()方法。通常在实现时，可以调用具体目标类的attach()方法将自己添加到目标类的集合中或通过detach()方法将自己从目标类的集合中删除。

观察者模式描述了如何建立对象与对象之间的依赖关系，以及如何构造满足这种需求的系统。

观察者模式包含观察目标和观察者两类对象，一个目标可以有任意数目的与之相依赖的观察者，一旦观察目标的状态发生改变，所有的观察者都将得到通知。

作为对这个通知的响应，每个观察者都将监视观察目标的状态以使其状态与目标状态同步，这种交互也称为发布\订阅(Publish-Subscribe)。

观察目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅它并接收通知。

典型代码

下面通过示意代码来对该模式进行进一步分析。首先我们定义一个抽象目标Subject，典型代码如下所示：

import java.util.*;
abstract class Subject {
 //定义一个观察者集合用于存储所有观察者对象
protected ArrayList observers<Observer> = new ArrayList();
 
//注册方法，用于向观察者集合中增加一个观察者
 public void attach(Observer observer) {
 observers.add(observer);
}
 
 //注销方法，用于在观察者集合中删除一个观察者
 public void detach(Observer observer) {
 observers.remove(observer);
}
 
 //声明抽象通知方法
 public abstract void notify();
}

具体目标类ConcreteSubject是实现了抽象目标类Subject的一个具体子类，其典型代码如下所示：

汇编语言入门七：函数调用（一）

Mon, 01 Jan 0001 00:00:00 +0000

最近忙了一阵，好几天没更了，不好意思，我来晚了。

转入正题，当在汇编中进行函数调用，是一种什么样的体验？

想象

想象你在计算一个非常复杂的数学题，在算到一半的时候，你需要一个数据，而这个数据需要套用一个比较复杂的公式才能算出来，怎么办？

你不得不把手中的事情停下来，先去套公式、代入数值然后…最后，算出结果来了。

这时候你继续开始攻克这个困难题目的剩下部分。

用脑子想

刚刚说的这个过程，可能有点小问题，尤其是对脑子不太好使的人来说。想象你做题目做到一半的时候，记忆力已经有点不好使了，中间突然停下来去算一个复杂的公式，然后回来，诶？我刚刚算到哪了？我刚刚想到哪了？我刚刚算了些什么结果？

在你工作切换的时候，很容易回头来就忘记了刚刚做的部分事情。这时候，为了保证你套完复杂的公式，把结果拿回来继续算题目的时候不会出差错，你需要把刚才计算题目过程中的关键信息写在纸上。

用CPU想

刚刚去套用一个复杂的公式计算某个数据的情景，就类似在计算机里进行函数调用的情景。

程序需要一个结果，这个结果需要通过一个比较复杂的过程进行计算。这时候，编程人员会考虑将这个独立的复杂过程提取为单独的函数。

而在发生函数调用的时候，CPU就像是先暂停当前所做的事情，转去做那个复杂的计算，算完了之后又跳回来继续整个计算。就像你做题的过程中去套了一个公式计算数据一样。

但是在去套用公式之前，你需要做一些准备。首先，默默记下现在这个题目算到哪一步了，一会套完公式回来接着做；默默记下现在计算出来的一些结果，一会可能还会用到；套用公式需要些什么数据，先记下来，代公式的时候直接代入计算，算出来的结果也需要记在脑子里，回头需要使用。

在CPU里面，也需要这几个过程。

第一个，记下自己现在做事情做到哪里了，一会儿套完公式回来接着做，这也就是CPU在进行函数调用时的现场保存操作，CPU也需要记下自己当前执行到哪里了。

默默记下一些在套用公式的时候需要用到的数据，然后去套公式了。这也就是程序中在调用函数的时候进行参数传递的过程。

然后开始执行函数，等函数执行完了，就需要把结果记下来，回去继续刚才要用到数据的那个地方继续算。这也就是函数调用后返回的动作，这个记下的结果就是返回值。

开撸

说了那么多故事，那么函数调用要干些啥应该就说清楚了。总结一下大概就这么几个事：

保存现场（一会好回来接着做）
传递参数（可选，套公式的时候需要些什么数据）
返回（把计算结果带回来，接着刚才的事）

到这里，我们先来一个事例代码，就着代码去发现函数调用中的套路：

global main

eax_plus_1s:
 add eax, 1
 ret

ebx_plus_1s:
 add ebx, 1
 ret

main:
 mov eax, 0
 mov ebx, 0
 call eax_plus_1s
 call eax_plus_1s
 call ebx_plus_1s
 add eax, ebx
 ret

首先，运行程序，得到结果：3。

008将外部服务纳入到k8s集群网络

Mon, 01 Jan 0001 00:00:00 +0000

先启动一个非k8s集群的服务

# 在任意节点启动一个http服务这里用python3
node1@k8s-192-168-0-17:~$ python3 -m http.server 8088 # 这里启动了8088端口

创建一个svc的yaml

# 注意我这里把两个资源的yaml写在一个文件内，在实际生产中，我们经常会这么做，方便对一个服务的所有资源进行统一管理，不同资源之间用"---"来分隔
apiVersion: v1
kind: Service
metadata:
 name: myhttp
spec:
 ports:
 - name: http-port
 port: 3306 # Service 暴露端口 3306
 protocol: TCP
 type: ClusterIP  # 仅集群内访问

---

apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
 name: myhttp-slice # 指定这个endpointslice的名称
 labels:
 kubernetes.io/service-name: myhttp  # 必须关联Service 关联了哪个svc
addressType: IPv4
ports:
- name: http-port  # 与Service端口名一致
 port: 8088 # 外部服务实际端口 这样旧相当于把8088给了 myhttp 这个svc中名称为http-port的port
 protocol: TCP
endpoints:
- addresses:
 - "192.168.0.17" # 外部http服务IP
 conditions:
 ready: true # 标记端点可用

验证

node1@k8s-192-168-0-17:~$ sudo kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.68.0.1 <none> 443/TCP 5d2h
myhttp ClusterIP 10.68.48.233 <none> 3306/TCP 9s
new-nginx NodePort 10.68.194.158 <none> 81:30759/TCP 4h19m
node1@k8s-192-168-0-17:~$ curl 10.68.48.233:3306
<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Directory listing for /</title>
</head>
<body>
<h1>Directory listing for /</h1>
<hr>
<ul>
<li><a href=".ansible/">.ansible/</a></li>
<li><a href=".bash_history">.bash_history</a></li>
<li><a href=".bash_logout">.bash_logout</a></li>
<li><a href=".bashrc">.bashrc</a></li>
<li><a href=".cache/">.cache/</a></li>
<li><a href=".profile">.profile</a></li>
<li><a href=".ssh/">.ssh/</a></li>
<li><a href=".sudo_as_admin_successful">.sudo_as_admin_successful</a></li>
<li><a href=".viminfo">.viminfo</a></li>
<li><a href=".Xauthority">.Xauthority</a></li>
<li><a href="httpproxy.yaml">httpproxy.yaml</a></li>
<li><a href="nginx-svc.yaml">nginx-svc.yaml</a></li>
<li><a href="nginx.yaml">nginx.yaml</a></li>
<li><a href="planet">planet</a></li>
<li><a href="ubuntu-install-k8s/">ubuntu-install-k8s/</a></li>
</ul>
<hr>
</body>
</html>

备注

这里svc使用的是ClusterIP 如果使用了NodePort

汇编语言入门八：函数调用（二）

Mon, 01 Jan 0001 00:00:00 +0000

回顾

上回说道，x86汇编中专门提供了两个指令call和ret，用于实现函数调用的效果。实际上函数调用就是程序跳转，只是在跳转之前，CPU会保存当前所在的位置（即返回地址），当函数返回时，又可以从调用的位置恢复。返回地址保存在一个叫做“堆栈”的地方，堆栈中可以保存很多个返回地址，同时借助于堆栈的进出逻辑，还能实现函数嵌套、递归等效果。

同时前面还简单地提到了函数调用过程中的参数和返回值的传递过程。实际上，在汇编语言中，函数调用的参数和返回值均可以通过寄存器来传送，只要函数内外相互配合，就可以精确地进行参数和返回值传递。

没那么简单

到这里，看起来好像函数调用的基本要素都有了，但实际上还是有一些问题的。比如说递归调用这样的场景。通过对递归的研究，你也就能明白前面说到的函数调用机制存在什么样致命的问题。

好了，先说下，这部分内容，很关键。

举个例子，通过递归调用来计算斐波那契数列中的某一项，用高级语言编写已经非常容易：

int fibo(int n) {
 if(n == 1 || n == 2) {
 return 1;
 }
 return fibo(n - 1) + fibo(n - 2);
}

我们来进行一波改造，改造成接近汇编的形式：

int fibo(int n) {
 if(n == 1) {
 return 1;
 }
 if(n == 2) {
 return 1;
 }
 int x = n - 1;
 int y = n - 2;
 int a = fibo(x);
 int b = fibo(y);
 int c = a + b;
 return c;
}

拆分成这样之后，就能够比较方便地和汇编对应起来了，再改造一下，把变量名全都换成寄存器名，就能够看得更清楚了（先约定eax寄存器作为函数的第一个参数，通过eax也用来传递返回值）：

状态模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

“人有悲欢离合，月有阴晴圆缺”，包括人在内，很多事物都具有多种状态，而且在不同状态下会具有不同的行为，这些状态在特定条件下还将发生相互转换。就像水，它可以凝固成冰，也可以受热蒸发后变成水蒸汽，水可以流动，冰可以雕刻，蒸汽可以扩散。我们可以用UML状态图来描述H2O的三种状态，如图1所示：

H2O的三种状态（未考虑临界点）

在软件系统中，有些对象也像水一样具有多种状态，这些状态在某些情况下能够相互转换，而且对象在不同的状态下也将具有不同的行为。为了更好地对这些具有多种状态的对象进行设计，我们可以使用一种被称之为状态模式的设计模式

状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，对于客户端而言，无须关心对象状态的转换以及对象所处的当前状态，无论对于何种状态的对象，客户端都可以一致处理。

定义

状态模式(State Pattern)：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

结构

在状态模式中引入了抽象状态类和具体状态类，它们是状态模式的核心，其结构

状态模式结构图

角色

**● Context（环境类）：**环境类又称为上下文类，它是拥有多种状态的对象。由于环境类的状态存在多样性且在不同状态下对象的行为有所不同，因此将状态独立出去形成单独的状态类。在环境类中维护一个抽象状态类State的实例，这个实例定义当前状态，在具体实现时，它是一个State子类的对象。

**● State（抽象状态类）：**它用于定义一个接口以封装与环境类的一个特定状态相关的行为，在抽象状态类中声明了各种不同状态对应的方法，而在其子类中实现类这些方法，由于不同状态下对象的行为可能不同，因此在不同子类中方法的实现可能存在不同，相同的方法可以写在抽象状态类中。

**● ConcreteState（具体状态类）：**它是抽象状态类的子类，每一个子类实现一个与环境类的一个状态相关的行为，每一个具体状态类对应环境的一个具体状态，不同的具体状态类其行为有所不同。

典型代码

在状态模式中，我们将对象在不同状态下的行为封装到不同的状态类中，为了让系统具有更好的灵活性和可扩展性，同时对各状态下的共有行为进行封装，我们需要对状态进行抽象，引入了抽象状态类角色，其典型代码如下所示：

abstract class State {
 //声明抽象业务方法，不同的具体状态类可以不同的实现
 public abstract void handle();
}

在抽象状态类的子类即具体状态类中实现了在抽象状态类中声明的业务方法，不同的具体状态类可以提供完全不同的方法实现，在实际使用时，在一个状态类中可能包含多个业务方法，如果在具体状态类中某些业务方法的实现完全相同，可以将这些方法移至抽象状态类，实现代码的复用，典型的具体状态类代码如下所示：

class ConcreteState extends State {
 public void handle() {
 //方法具体实现代码
 }
}

环境类维持一个对抽象状态类的引用，通过setState()方法可以向环境类注入不同的状态对象，再在环境类的业务方法中调用状态对象的方法，典型代码如下所示：

class Context {
 private State state; //维持一个对抽象状态对象的引用
 private int value; //其他属性值，该属性值的变化可能会导致对象状态发生变化
 
 //设置状态对象
 public void setState(State state) {
 this.state = state;
 }
 
 public void request() {
 //其他代码
 state.handle(); //调用状态对象的业务方法
 //其他代码
 }
}

环境类实际上是真正拥有状态的对象，我们只是将环境类中与状态有关的代码提取出来封装到专门的状态类中。在状态模式结构图中，环境类Context与抽象状态类State之间存在单向关联关系，在Context中定义了一个State对象。在实际使用时，它们之间可能存在更为复杂的关系，State与Context之间可能也存在依赖或者关联关系。

009让pod只在具有指定标签的节点上运行

Mon, 01 Jan 0001 00:00:00 +0000

1. 创建deployment的yaml
```yaml
# 修改好yaml配置
apiVersion: apps/v1
kind: Deployment
metadata:
 creationTimestamp: null
 labels:
 app: nginx
 name: nginx
spec:
 replicas: 2
 selector:
 matchLabels:
 app: nginx
 strategy: {}
 template:
 metadata:
 creationTimestamp: null
 labels:
 app: nginx
 spec:
 containers:
 - image: nginx
 name: nginx
 resources: {}
 nodeSelector: # <--- 这里
 apps/nginx: "true" # <--- 基于这个label来选择
status: {}
```

2. 应用这个配置

```shell
kubectl apply -f node-selector.yaml
```

3. 查看pod, 这时没有节点具有 apps/nginx=true

```shell
node1@k8s-192-168-0-17:~$ sudo kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-756c69b65f-7vfv5 0/1 Pending 0 2m5s <none> <none> <none> <none>
nginx-756c69b65f-8gl9m 0/1 Pending 0 2m4s <none> <none> <none> <none>
```

4. 节点打label

```shell
# 先尝试给主节点打label
kubectl label node k8s-192-168-0-17 apps/nginx=true
kubectl get node k8s-192-168-0-17 --show-labels 
NAME STATUS ROLES AGE VERSION LABELS
k8s-192-168-0-17 Ready,SchedulingDisabled master 5d3h v1.33.1 apps/nginx=true,beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/arch=amd64,kubernetes.io/hostname=k8s-192-168-0-17,kubernetes.io/os=linux,kubernetes.io/role=master
```

可以看到虽然给17主节点打了标签，但是还是无法调度因为主节点状态是SchedulingDisabled的， 这个状态优先级更高

```shell
# 尝试给worker节点打label
kubectl label node k8s-192-168-0-19 apps/nginx=true
kubectl get node k8s-192-168-0-19 --show-labels 
NAME STATUS ROLES AGE VERSION LABELS
k8s-192-168-0-19 Ready node 5d3h v1.33.1 beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/arch=amd64,kubernetes.io/hostname=k8s-192-168-0-19,kubernetes.io/os=linux,kubernetes.io/role=node
# 再查看pod， 马上从pending到ContainerCreating又转到了running 并且node都在19这个节点上，如果没有节点标签。pod是基本平均分布的
kubectl get pod
NAME READY STATUS RESTARTS AGE
nginx-756c69b65f-7vfv5 0/1 ContainerCreating 0 5m38s
nginx-756c69b65f-8gl9m 0/1 ContainerCreating 0 5m37s
kubectl get pod -o wide
NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES
nginx-756c69b65f-7vfv5 1/1 Running 0 7m22s 172.20.177.63 k8s-192-168-0-19 <none> <none>
nginx-756c69b65f-8gl9m 1/1 Running 0 7m21s 172.20.177.62 k8s-192-168-0-19 <none> <none>
```

策略模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

在策略模式中，我们可以定义一些独立的类来封装不同的算法，每一个类封装一种具体的算法，在这里，每一个封装算法的类我们都可以称之为一种策略(Strategy)，为了保证这些策略在使用时具有一致性，一般会提供一个抽象的策略类来做规则的定义，而每种算法则对应于一个具体策略类。

策略模式的主要目的是将算法的定义与使用分开，也就是将算法的行为和环境分开，将算法的定义放在专门的策略类中，每一个策略类封装了一种实现算法，使用算法的环境类针对抽象策略类进行编程，符合“依赖倒转原则”。在出现新的算法时，只需要增加一个新的实现了抽象策略类的具体策略类即可。

定义

策略模式(Strategy Pattern)：定义一系列算法类，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。策略模式是一种对象行为型模式。

结构

策略模式结构并不复杂，但我们需要理解其中环境类Context的作用，其结构如图24-1所示：

角色

● Context**（环境类）：**环境类是使用算法的角色，它在解决某个问题（即实现某个方法）时可以采用多种策略。在环境类中维持一个对抽象策略类的引用实例，用于定义所采用的策略。

● Strategy**（抽象策略类）：**它为所支持的算法声明了抽象方法，是所有策略类的父类，它可以是抽象类或具体类，也可以是接口。环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。

● ConcreteStrategy**（具体策略类）：**它实现了在抽象策略类中声明的算法，在运行时，具体策略类将覆盖在环境类中定义的抽象策略类对象，使用一种具体的算法实现某个业务处理。

思考

一个环境类Context能否对应多个不同的策略等级结构？如何设计？

典型代码

策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列具体策略类里面，作为抽象策略类的子类。在策略模式中，对环境类和抽象策略类的理解非常重要，环境类是需要使用算法的类。在一个系统中可以存在多个环境类，它们可能需要重用一些相同的算法。

在使用策略模式时，我们需要将算法从Context类中提取出来，首先应该创建一个抽象策略类，其典型代码如下所示：

abstract class AbstractStrategy {
 public abstract void algorithm(); //声明抽象算法
}

然后再将封装每一种具体算法的类作为该抽象策略类的子类，如下代码所示：

class ConcreteStrategyA extends AbstractStrategy {
 //算法的具体实现
 public void algorithm() {
 //算法A
 }
}

其他具体策略类与之类似，对于Context类而言，在它与抽象策略类之间建立一个关联关系，其典型代码如下所示：

class Context {
private AbstractStrategy strategy; //维持一个对抽象策略类的引用
 
 public void setStrategy(AbstractStrategy strategy) {
 this.strategy= strategy;
 }
 
 //调用策略类中的算法
 public void algorithm() {
 strategy.algorithm();
 }
}

在Context类中定义一个AbstractStrategy类型的对象strategy，通过注入的方式在客户端传入一个具体策略对象，客户端代码片段如下所示：

汇编语言入门九：总结与后续（闲扯）

Mon, 01 Jan 0001 00:00:00 +0000

回顾

前面扯了一些个汇编语言的内容，想必读者也应该有了大致的了解。笔者比打算写全面的汇编相关的内容，毕竟目前已经有不少相关的资料了。本入门系列的目的就在于：入门。

完成了入门的任务，入门系列就暂告一段落了。在此，先来对前面提及的内容做一些回顾。前面说到的各项内容大概涉及：

环境配置
寄存器
内存访问
流程控制
函数调用
反汇编
调试

我想，学习汇编中比较容易犯难的几个环节，大致也都覆盖到了。并且教程中也提供了可运行的实例，供读者在学习之后用于验证。

学汇编到底学什么

我想，很多新手在了解汇编语言的时候，难免会遇到各种蛋疼的问题。大致有这样一些情况：

有参考书，虽然书中的知识体系全面，但是内容多却晦涩难懂
内容老旧，一时找不到合适的试验环境来验证，仅仅停留于书本，缺乏强烈直观的感受
各种规范各种环境乱七八糟不统一，讨论汇编时太依赖于特定环境，进一步加大了动手验证的难度

这无疑是给学习者泼来一盆冷水，本来只有3分的热情被灭掉了余下0.3分。

其实学习汇编语言，和学习C语言就有所不同了。你不用想着以后用汇编进行编程，学习汇编语言的首要目标是理解CPU运行程序的时候到底在干什么，你编写的C程序或者其他什么代码在CPU的眼里到底是个什么玩意儿，你能够通过汇编去分析程序的行为，解释一些高级语言下无法解释的现象，等等，才是学习的目标。

也就是说，学习汇编语言，应该抱着理解的目标去学习，理解透彻便足矣，无需做到能够流利地用汇编进行编程。

即便如此，笔者前面所述的各方面入门内容也仅仅是入门。不同人有不同的学习历程、只是背景，笔者很难保证自己觉得足够的入门教程，能够让每个读者都刚好受用。鉴于此，笔者将列出在了解了入门内容后需要关心的内容。

后续

前面也有提到，学习汇编所需要侧重的是理解，而非熟练地编代码。汇编语言更像是一套理论知识，用于分析和解释程序在足够底层时的行为和现象。

与其说学习汇编，不如说是揭开高级语言的面纱，深入到更底层的地方去了解计算机原理，靠近计算机程序的本质。深入理解底层原理，有助于建立对计算机更系统的更深入的认识，面对一些看似诡异的问题时能心中有数，有方法有思路有理据去分析和解决。

要做到这一点，是需要循序渐进慢慢学习的。读者可在后续关注这样一些内容：

继续学习汇编语言

笔者前面所述的入门内容只能保证覆盖了核心内容，并未覆盖到汇编语言相关的方方面面。读者至少要让自己学习汇编知识覆盖面达到足以形成图灵完备的最小集合。

可以从分析高级语言（比如C）去学习汇编语言，如前面所述的反汇编。关注这样一些内容：

指令
寄存器
内存访问
条件跳转
堆栈
程序状态

这些概念不仅在x86体系下，在ARM或是MIPS体系下也适用。仅仅是在不同环境下有不同的思路，有不同的表现形式，但是，核心的概念都是一致的。

计算机组成原理

到这里，便是让你对所有计算机系统的认识有一个大统一。上面说到不同CPU平台下都有相当的共性。组成原理便是对所有计算机系统的大统一，不同平台只是在根据自己的目标特点和偏好在对计算机原理进行应用而已。

组成原理会告诉你，计算机在电路这个层面的本质是什么。

有了上述的汇编、组成原理的认识，同时也还应该去了解计算机操作系统。这里所谓的操作系统是指站在专业的角度，讨论操作系统本质上是在做什么事情，解决什么问题。

这些基础知识将会作为今后进一步学习计算机的坚实基础，基于对计算机、对操作系统的理解，计算机中的一切都将不再神秘，其本质都不过如此，基于自己所学去分析、去理解即可。

学习方法

笔者在学习的过程中，也尝试过总结适合自己的方法，在此也谈一谈自己学习的方式。

虽然微积分揭示了自然现象和数学之间很多本质的东西，但是让一个小学生直接学习的话，难免会困难重重。这里的问题并不在于知识体系不够全面、不够严谨，而在于学习者对微积分没有基本的感性认识，根本不知道是个啥玩意儿（计算期末考试分数的新方法？），即使记住了这些公式和证明，但自身难以去自行演绎，这其实是无效的学习。

所以，借助此例，结合自身经历，笔者认为学习的时候应该先关注下面一些方面：

寻求感性认识

学习一个陌生的东西，我都会尝试先寻求一个感性的认识，感性认识达到什么程度呢？就是做到自己能够用一些简洁的白话，把自己接下来要学习的东西到底是什么玩意儿，给解释清楚，最好能够做到让不明白的人也能听明白。

比如什么是计算机？你能想到的就是你面对的那一台电脑，里面有丰富的的软件，可以做很多有趣的事情。

了解边界

笔者所谓的边界，即接下来要学习的这个东西，能做什么，不能做什么。学习之前明白这一点也非常重要，基于此，便能有一个清晰的目标，对学习后会面对的问题也有一定的底。

比如计算机是无法直接驱动一个火箭上天的，但是能够对航天器的行为进行控制。

让学习可验证

学习过程中自己会思考，会想出很多问题，但是这些问题并非都能从书中找到答案。而在学习过程中要刻意的去养成对知识、对自己的新想法进行验证的习惯。这里面大致是这样的过程：

脑子里冒出来一个想法，可能是疑惑，可能是矛盾
猜想一种最可能的情况来解释
通过实践去验证自己的猜想
总结、回顾（验证后的结果不能解释自己的猜想，会去重新猜）

这里的动手验证不是说真的得去拿个锤子砸钉子，而是说这里的分析、思考、试验、演绎等过程需要落到实处，而不是看到了某个模糊的说法，就这样糊弄过去了。

010部署ingress-nginx-controller

Mon, 01 Jan 0001 00:00:00 +0000

打开yaml文件

必看：

在大规模生产集群上，ingree-nginx 独占一台节点，他就只跑 ingree-nginx 不要再跑其他pod了
kind: ConfigMap 段落的data.worker-processes = 实际服务器ingress-nginx-controller 所在的pod的那个节点的服务器的cpu核数（最好比实际核心数-1）
kind: ConfigMap 段落的data.worker-cpu-affinity 目前配置是空，留空就行
kind: DaemonSet 如果是自建集群使用DaemonSet类型的控制器。他会把容器端口映射到宿主机上这样就不用再使用NodePort映射了如果是是云上比如阿里云的ack 集群，使用Deployment类型的控制器，因为ack的pod使用的是云主机的弹性网卡他可以和你的云主机在同一个网络（网段）所以在这一段的内容中默认用了kind: DaemonSet 如果要用kind: Deployment 那么需要检查 “Deployment need” 和 “DaemonSet need"跟随的一些配置项
基于kind: DaemonSet|Deployment的resources（资源配置）如果limits分配的资源和requests分配的资源是一致的，那么这个pod在k8s集群中的优先级是最高的。当我们集群资源不够时， k8s会驱逐一些优先级低的pod。保证高优先级
如果日志报错提示 “mount: mounting rw on /proc/sys failed: Permission denied”，那么就打开 privileged: true、procMount: Default、runAsUser: 0 这三条注释的内容，如果不报错就不用管他
给对应节点打标签

 nodeSelector:
 boge/ingress-controller-ready: "true"

打标签的方法 kubectl label node ${节点的hostname} boge/ingress-controller-ready=true
查看标签的方法 kubectl get node –show-labels
删除标签的方法 kubectl label node ${节点的hostname} boge/ingress-controller-ready-

模版方法模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

在现实生活中，很多事情都包含几个实现步骤，例如请客吃饭，无论吃什么，一般都包含点单、吃东西、买单等几个步骤，通常情况下这几个步骤的次序是：点单 –> 吃东西 –> 买单。在这三个步骤中，点单和买单大同小异，最大的区别在于第二步——吃什么？吃面条和吃满汉全席可大不相同，如图：

请客吃饭示意图

在软件开发中，有时也会遇到类似的情况，某个方法的实现需要多个步骤（类似“请客”），其中有些步骤是固定的（类似“点单”和“买单”），而有些步骤并不固定，存在可变性（类似“吃东西”）。为了提高代码的复用性和系统的灵活性，可以使用一种称之为模板方法模式的设计模式来对这类情况进行设计，在模板方法模式中，将实现功能的每一个步骤所对应的方法称为基本方法（例如“点单”、“吃东西”和“买单”），而调用这些基本方法同时定义基本方法的执行次序的方法称为模板方法（例如“请客”）。在模板方法模式中，可以将相同的代码放在父类中，例如将模板方法“请客”以及基本方法“点单”和“买单”的实现放在父类中，而对于基本方法“吃东西”，在父类中只做一个声明，将其具体实现放在不同的子类中，在一个子类中提供“吃面条”的实现，而另一个子类提供“吃满汉全席”的实现。通过使用模板方法模式，一方面提高了代码的复用性，另一方面还可以利用面向对象的多态性，在运行时选择一种具体子类，实现完整的“请客”方法，提高系统的灵活性和可扩展性。

定义

模板方法模式：定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Template Method Pattern: Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.

模板方法模式是一种基于继承的代码复用技术，它是一种类行为型模式。

模板方法模式是结构最简单的行为型设计模式，在其结构中只存在父类与子类之间的继承关系。

通过使用模板方法模式，可以将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，从而使得相同的算法框架可以有不同的执行结果。模板方法模式提供了一个模板方法来定义算法框架，而某些具体步骤的实现可以在其子类中完成。

结构

模板方法模式结构比较简单，其核心是抽象类和其中的模板方法的设计

模板方法模式包含如下两个角色：

**(1) AbstractClass（抽象类）：**在抽象类中定义了一系列基本操作(PrimitiveOperations)，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Template Method)，用于定义一个算法的框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。

**(2) ConcreteClass（具体子类）：**它是抽象类的子类，用于实现在父类中声明的抽象基本操作以完成子类特定算法的步骤，也可以覆盖在父类中已经实现的具体基本操作。

典型代码

在实现模板方法模式时，开发抽象类的软件设计师和开发具体子类的软件设计师之间可以进行协作。一个设计师负责给出一个算法的轮廓和框架，另一些设计师则负责给出这个算法的各个逻辑步骤。实现这些具体逻辑步骤的方法即为基本方法，而将这些基本方法汇总起来的方法即为模板方法，模板方法模式的名字也因此而来。下面将详细介绍模板方法和基本方法：

1. 模板方法

一个模板方法是定义在抽象类中的、把基本操作方法组合在一起形成一个总算法或一个总行为的方法。这个模板方法定义在抽象类中，并由子类不加以修改地完全继承下来。模板方法是一个具体方法，它给出了一个顶层逻辑框架，而逻辑的组成步骤在抽象类中可以是具体方法，也可以是抽象方法。由于模板方法是具体方法，因此模板方法模式中的抽象层只能是抽象类，而不是接口。

011基于010实现一次灰度发布

Mon, 01 Jan 0001 00:00:00 +0000

kubectl create deployment old-nginx --image=nginx:1.21.6 --replicas=1
deployment.apps/old-nginx created

kubectl expose deployment old-nginx --port=80 --target-port=80
service/old-nginx exposed

# 修改nginx.yaml
# 在kind: Ingress的matadata.annotations 中添加如下内容
nginx.ingress.kubernetes.io/service-weight: |
 new-nginx: 50, old-nginx: 50

在 spec.rules 中 host: www.boge.com 的部分 http.paths 中添加如下内容 
 - backend:
 service:
 name: old-nginx # 老版本服务
 port:
 number: 80
 path: /
 pathType: Prefix

# 最终重新应用 nginx.yaml

kubectl apply -f nginx.yaml 
service/new-nginx unchanged
ingress.networking.k8s.io/new-nginx configured
deployment.apps/new-nginx unchanged

再通过浏览器访问 https://www.boge.com/ 就会发现几乎是一半打到new-nginx上一般打到old-nginx上

访问者模式

Mon, 01 Jan 0001 00:00:00 +0000

概述

访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。例如处方单中的各种药品信息就是被访问的元素，而划价人员和药房工作人员就是访问者。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

在使用访问者模式时，被访问元素通常不是单独存在的，它们存储在一个集合中，这个集合被称为“对象结构”，访问者通过遍历对象结构实现对其中存储的元素的逐个操作。

定义

访问者模式(Visitor Pattern):提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。

结构

角色

●Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。

●ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。

●Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。【稍后将介绍为什么要这样设计。】

●ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。

● ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。访问者模式包括两个层次结构，一个是访问者层次结构，提供了抽象访问者和具体访问者，一个是元素层次结构，提供了抽象元素和具体元素。相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。在访问者模式中，增加新的访问者无须修改原有系统，系统具有较好的可扩展性。

在访问者模式中，抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法。这些访问方法的命名一般有两种方式：一种是直接在方法名中标明待访问元素对象的具体类型，如visitElementA(ElementA elementA)，还有一种是统一取名为visit()，通过参数类型的不同来定义一系列重载的visit()方法。当然，如果所有的访问者对某一类型的元素的访问操作都相同，则可以将操作代码移到抽象访问者类中，其典型代码如下所示：

abstract class Visitor
{
 public abstract void visit(ConcreteElementA elementA);
 public abstract void visit(ConcreteElementB elementB);
 public void visit(ConcreteElementC elementC)
 {
 //元素ConcreteElementC操作代码
 }
}

在这里使用了重载visit()方法的方式来定义多个方法用于操作不同类型的元素对象。在抽象访问者Visitor类的子类ConcreteVisitor中实现了抽象的访问方法，用于定义对不同类型元素对象的操作，具体访问者类典型代码如下所示：

class ConcreteVisitor extends Visitor
{
 public void visit(ConcreteElementA elementA)
 {
 //元素ConcreteElementA操作代码
 }
 public void visit(ConcreteElementB elementB)
 {
 //元素ConcreteElementB操作代码
 }
}

对于元素类而言，在其中一般都定义了一个accept()方法，用于接受访问者的访问，典型的抽象元素类代码如下所示：

012HPA自动水平伸缩pod.md

Mon, 01 Jan 0001 00:00:00 +0000

先准备一个svc 和 deployment

apiVersion: v1
kind: Service
metadata:
 creationTimestamp: null
 labels:
 app: web
 name: web
spec:
 ports:
 - port: 80
 protocol: TCP
 targetPort: 80
 selector:
 app: web
status:
 loadBalancer: {}

---
 
apiVersion: apps/v1
kind: Deployment
metadata:
 labels:
 app: web
 name: web
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 app: web
 template:
 metadata:
 labels:
 app: web
 spec:
 containers:
 - image: nginx:1.21.6
 name: nginx
 resources:
 limits: # 因为我这里是测试环境，所以这里CPU只分配50毫核（0.05核CPU）和20M的内存
 cpu: "50m"
 memory: 20Mi
 requests: # 保证这个pod初始就能分配这么多资源
 cpu: "50m"
 memory: 20Mi

创建一个hpa

# autoscale 表示自动伸缩
# web 是hpa的名称
# --max=3 表示最大扩容数量为3
# --min=1 表示最小扩容数量为1 
# --cpu-percent=50 表示当CPU使用率超过50%时扩容
kubectl autoscale deployment web --max=3 --min=1 --cpu-percent=30
kubectl get hpa -w

再启动一个终端启动一个临时pod

kubectl run -it --rm busybox --image=registry.cn-shanghai.aliyuncs.com/acs/busybox:v1.29.2 -- sh
/ # while :;do wget -q -O- http://web;done

回到前一个终端

# 查看 kubectl get hpa -w 的输出
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
web Deployment/web cpu: 0%/30% 1 3 1 30s
web Deployment/web cpu: 58%/30% 1 3 1 107s
web Deployment/web cpu: 100%/30% 1 3 2 2m4s
web Deployment/web cpu: 100%/30% 1 3 3 2m22s
web Deployment/web cpu: 95%/30% 1 3 3 2m35s

# 至此可以推出跟踪

# 查看hpa web 的描述
kubectl describe hpa web

Name: web
Namespace: default
Labels: <none>
Annotations: <none>
CreationTimestamp: Thu, 10 Jul 2025 16:58:31 +0800
Reference: Deployment/web
Metrics: ( current / target )
 resource cpu on pods (as a percentage of request): 76% (38m) / 30%
Min replicas: 1
Max replicas: 3
Deployment pods: 3 current / 3 desired
Conditions:
 Type Status Reason Message
 ---- ------ ------ -------
 AbleToScale True ScaleDownStabilized recent recommendations were higher than current one, applying the highest recent recommendation
 ScalingActive True ValidMetricFound the HPA was able to successfully calculate a replica count from cpu resource utilization (percentage of request)
 ScalingLimited True TooManyReplicas the desired replica count is more than the maximum replica count
Events:
 Type Reason Age From Message
 ---- ------ ---- ---- -------
 Normal SuccessfulRescale 101s horizontal-pod-autoscaler New size: 2; reason: cpu resource utilization (percentage of request) above target
 Normal SuccessfulRescale 84s horizontal-pod-autoscaler New size: 3; reason: cpu resource utilization (percentage of request) above target

停掉临时pod中的死循环并监听hpa的变化(这个收缩大概时需要在停止临时pod五分钟后才有效)

kubectl get hpa -w
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
web Deployment/web cpu: 68%/30% 1 3 3 5m47s
web Deployment/web cpu: 83%/30% 1 3 3 5m54s
web Deployment/web cpu: 68%/30% 1 3 3 6m9s
web Deployment/web cpu: 0%/30% 1 3 3 6m24s （6分24s降为0）

kubectl get hpa -w
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
web Deployment/web cpu: 0%/30% 1 3 3 9m45s

kubectl get hpa -w
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
web Deployment/web cpu: 0%/30% 1 3 3 11m
web Deployment/web cpu: 0%/30% 1 3 3 11m
web Deployment/web cpu: 0%/30% 1 3 1 11m （11分收缩到1）

CLion 控制台输出内容乱码问题的解决方法

Thu, 08 May 2025 00:00:00 +0000

问题再现

#include "stdio.h"
#include "stdlib.h"

int main()
{
 printf("嘤嘤嘤");
 return 0;
}

问题原因

现状

编译器没报错
字符出现乱码

推测

字符编码不一
控制台编码与文件编码不一样

解决办法

修改字符编码

解决步骤

进入设置界面

设置编码，这里为了方便，我们统一设置为UTF—8

返回界面，更改输入字符块为GBK

这里记得，会弹出一个对话框

使代码发生变动，重新编译并运行，这里我们把“嘤嘤嘤”换成“嘻嘻嘻”，然后编译，成功后运行

高效的java第三版

Thu, 08 May 2025 00:00:00 +0000

本文转载于 github项目 https://github.com/sjsdfg/effective-java-3rd-chinese 跳转浏览

Mon, 01 Jan 0001 00:00:00 +0000

MySQL5.6.17编译安装

现在MySQL已经是8.x了，这么老的版本应该不会再有人编译安装了。再说单机版这个时代的背景下还是docker启动吧。本文仅用于个人纪念

yum install -y gcc*
安装cmake

# mysql5.5之后需要cmake编译安装，因此，先下载cmake2.8.8
 tar -zxvf cmake-2.8.8.tar.gz -C /usr/local/src
./configure --prefix=/usr/local/cmake
make
make install

安装mysql5.6.17

tar -zxvf mysql-5.6.17.tar.gz -C /usr/local/src
cmake \
#安装路径
-DCMAKE_INSTALL_PREFIX=/usr/local/mysql \ 
#数据文件存放位置 
-DMYSQL_DATADIR=/usr/local/mysql/data \
#my.cnf路径
-DSYSCONFDIR=/etc \
#支持MyIASM引擎 
-DWITH_MYISAM_STORAGE_ENGINE=1 \
#支持InnoDB引擎
-DWITH_INNOBASE_STORAGE_ENGINE=1 \
#支持Memory引擎 
-DWITH_MEMORY_STORAGE_ENGINE=1 \
#快捷键功能(我没用过) 
-DWITH_READLINE=1 \
#连接数据库socket路径 
-DMYSQL_UNIX_ADDR=/tmp/mysqld.sock \
#端口
-DMYSQL_TCP_PORT=3306 \ 
#允许从本地导入数据 
-DENABLED_LOCAL_INFILE=1 \
#安装支持数据库分区
-DWITH_PARTITION_STORAGE_ENGINE=1 \
#安装所有的字符集
-DEXTRA_CHARSETS=all \
#默认字符
-DDEFAULT_CHARSET=utf8 \
-DDEFAULT_COLLATION=utf8_general_ci


make
make install

：配置MySQL

# 使用下面的命令查看是否有mysql用户及用户组 
cat /etc/passwd 查看用户列表
cat /etc/group 查看用户组列表 

#如果没有就创建 
groupadd mysql
useradd -g mysql mysql 


#修改/usr/local/mysql权限 
chown -R mysql:mysql /usr/local/mysql 


#修改/usr/local/mysql权限
#初始化配置
#进入安装路径，执行初始化配置脚本，创建系统自带的数据库和表 
cd /usr/local/mysql 
scripts/mysql_install_db --basedir=/usr/local/mysql --datadir=/usr/local/mysql/data --user=mysql

注：在启动MySQL服务时，会按照一定次序搜索my.cnf，先在/etc目录下找，找不到则会搜索"$basedir/my.cnf"，在本例中就是 /usr/local/mysql/my.cnf，这是新版MySQL的配置文件的默认位置！注意：在CentOS 6.4版操作系统的最小安装完成后，在/etc目录下会存在一个my.cnf，需要将此文件更名为其他的名字，如：/etc/my.cnf.bak，否则，该文件会干扰源码安装的MySQL的正确配置，造成无法启动。启动MySQL

Mon, 01 Jan 0001 00:00:00 +0000

MySQL5.6和5.7的二进制安装

5.6和5.7有略微的不同在 5步和7步请注意

获得二进制文件

# 5.6
wget http://mirrors.sohu.com/mysql/MySQL-5.6/mysql-5.6.28-linux-glibc2.5-x86_64.tar.gz

#
wget http://mirrors.sohu.com/mysql/MySQL-5.7/mysql-5.7.10-linux-glibc2.5-x86_64.tar.gz

加压到 /usr/local/mysql 目录(或者解压到当前目录然后做软链接到/usr/local/mysql)

mkdir /usr/local/mysql
tar -xvf mysql-5.6.28-linux-glibc2.5-x86_64.tar.gz
mv mysql-5.6.28-linux-glibc2.5-x86_64/* /usr/local/mysql/

mkdir /usr/local/mysql
tar -xvf mysql-5.7.10-linux-glibc2.5-x86_64.tar.gz
mv mysql-5.7.10-linux-glibc2.5-x86_64/* /usr/local/mysql/

创建 /usr/local/mysql/data 目录

# 5.6.28版本不需要
mkdir /usr/local/mysql/data

创建mysql用户和修改软件的权限

groupadd mysql
useradd -r -g mysql mysql -s /sbin/nologin (创建mysql用户并设置不可登录)
chown -R mysql.mysql /usr/local/mysql/

初始化数据(切换当前目录到/usr/local/mysql,在5.7中是bin目录下的mysql_install_db)

# 5.6
./scripts/mysql_install_db --user=mysql --basedir=/usr/local/mysql/ --datadir=/usr/local/mysql/data/
....此处省略一万字

# 5.7
bin/mysql_install_db --user=mysql --basedir=/usr/local/mysql/ --datadir=/usr/local/mysql/data/
2016-01-20 02:47:35 [WARNING] mysql_install_db is deprecated. Please consider switching to mysqld --initialize
2016-01-20 02:47:45 [WARNING] The bootstrap log isn't empty:
2016-01-20 02:47:45 [WARNING] 2016-01-19T18:47:36.732678Z 0 [Warning] --bootstrap is deprecated. Please consider using --initialize instead
2016-01-19T18:47:36.750527Z 0 [Warning] Changed limits: max_open_files: 1024 (requested 5000)
2016-01-19T18:47:36.750560Z 0 [Warning] Changed limits: table_open_cache: 431 (requested 2000)

复制配置文件到 /etc/my.cnf

cp -a ./support-files/my-default.cnf /etc/my.cnf (如果问是否替换选择Y)

mysql的服务脚本放到系统服务中

# 5.6
cp -a ./support-files/mysql.server /etc/init.d/mysqld
service mysqld start 
./bin/mysql -uroot -p(空密码)

# 5.7 版本开始系统会默认初始化一个root密码
cp -a ./support-files/mysql.server /etc/init.d/mysqld
service mysqld start 
cat /root/.mysql_secret
# Password set for user 'root@localhost' at 2016-01-20 03:22:59 
Tl:iRfEhRlQ6
bin/mysql -uroot -p(输入Tl:iRfEhRlQ6)
[root@c12 mysql57]# ./bin/mysqladmin -u root -p password
Enter password: 
New password: 
Confirm new password: 
Warning: Since password will be sent to server in plain text, use ssl connection to ensure password safety.
mysql> select version();
+-----------+
| version() |
+-----------+
| 5.7.8-rc |
+-----------+
1 row in set (0.00 sec)

31个！Golang常用工具

Mon, 01 Jan 0001 00:00:00 +0000

一、G0官方工具

（一）go get

该命令可以根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，下载后自动编译，一般引用依赖用go get就可以了。参考：

go get -u "github.com/VictoriaMetrics/fastcache"

参考： https://www.kancloud.cn/cattong/go_command_tutorial/261349

（二）go build

该命令用于编译我们指定的源码文件或代码包以及它们的依赖包。命令的常用标记说明如下：

编译过程输出到文件：go build -x > result 2>&1，因为go build -x 最终是将日志写到标准错误流当中。

如果只在编译特定包时需要指定参数，可以参考包名=参数列表的格式，比如go build -gcflags=‘log=-N -l’ main.go

参考： https://www.kancloud.cn/cattong/go_command_tutorial/261347

（三）go install

该命令用于编译并安装指定的代码包及它们的依赖包。当指定的代码包的依赖包还没有被编译和安装时，该命令会先去处理依赖包。与go build命令一样，传给go install命令的代码包参数应该以导入路径的形式提供。

并且，go build命令的绝大多数标记也都可以用于go install命令。实际上，go install命令只比go build命令多做了一件事，即：安装编译后的结果文件到指定目录。

参考：

https://www.kancloud.cn/cattong/go_command_tutorial/261348

（四）go fmt和gofmt

Golang的开发团队制定了统一的官方代码风格，并且推出了gofmt工具（gofmt或go fmt）来帮助开发者格式化他们的代码到统一的风格。

gofmt是一个cli程序，会优先读取标准输入，如果传入了文件路径的话，会格式化这个文件，如果传入一个目录，会格式化目录中所有.go文件，如果不传参数，会格式化当前目录下的所有.go文件。

gofmt默认不对代码进行简化，使用-s参数可以开启简化代码功能

gofmt是一个独立的cli程序，而go中还有一个go fmt命令，go fmt命令是gofmt的简单封装。go fmt在调用gofmt时添加了-l -w参数，相当于执行了gofmt -l -w

参考：

https://blog.csdn.net/whatday/article/details/97682094

（五）go env

该命令用于打印Go语言的环境信息，常见的通用环境信息如下：

adodb方式连接sqlServer2k

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/go-ole/go-ole v1.2.4 // indirect
 github.com/mattn/go-adodb v0.0.1
 github.com/robfig/cron/v3 v3.0.1
 github.com/wonderivan/logger v1.0.0
 golang.org/x/net v0.0.0-20200904194848-62affa334b73 // indirect
)

main.go

package main

import (
 "database/sql"
 "flag"
 "fmt"
 "log"
 "strconv"

 _ "github.com/mattn/go-adodb"
 "github.com/robfig/cron/v3"
 "github.com/wonderivan/logger"
)

var (
 local bool
 remoteIP string
 remoteDS string
 database string
)

func init() {
 flag.BoolVar(&local, "local", false, "set window connect.")
 flag.StringVar(&remoteIP, "remoteIP", "192.168.0.10", "set up remote mssql of ip.")
 flag.StringVar(&remoteDS, "remoteDS", "MSSQLSERVER", "set up remote mssql of datasource.")
 flag.StringVar(&database, "database", "drivertest", "set up remote mssql of database.")
}

type Mssql struct {
 *sql.DB
 dataSource string
 database string
 windows bool
 sa *SA
}

type SA struct {
 user string
 passwd string
 port int
}

func NewMssql() *Mssql {
 mssql := new(Mssql)
 dataS := "localhost"
 if !local {
 dataS = fmt.Sprintf("%s\\%s", remoteIP, remoteDS)
 }

 mssql = &Mssql{
 // 如果数据库是默认实例（MSSQLSERVER）则直接使用IP，命名实例需要指明。
 // dataSource: "192.168.1.104\\MSSQLSERVER",
 dataSource: dataS,
 database: database,
 // windows: true 为windows身份验证，false 必须设置sa账号和密码
 windows: local,
 sa: &SA{
 user: "elink",
 passwd: "elink888",
 port: 1433,
 },
 }

 return mssql

}

func (m *Mssql) Open() error {
 config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s",
 m.database, m.dataSource)

 if m.windows {
 config = fmt.Sprintf("%s;Integrated Security=SSPI", config)
 } else {
 // sql 2000的端口写法和sql 2005以上的有所不同，在Data Source 后以逗号隔开。
 config = fmt.Sprintf("%s,%d;user id=%s;password=%s",
 config, m.sa.port, m.sa.user, m.sa.passwd)
 }

 var err error
 m.DB, err = sql.Open("adodb", config)
 fmt.Println(config)

 return err
}

func (m *Mssql) Select() {
 rows, err := m.Query("select uid, name from sysusers")
 if err != nil {
 fmt.Printf("select query err: %s\n", err)
 }
 i := 0
 for rows.Next() {
 var id, name string
 rows.Scan(&id, &name)
 fmt.Printf("id = %s, name = %s\n", id, name)
 i++
 }
 fmt.Println(i)
}

func main() {
 // flag.Parse()

 // m := NewMssql()
 // config1 := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s",
 // m.database, m.dataSource)

 // if m.windows {
 // config1 = fmt.Sprintf("%s;Integrated Security=SSPI", config1)
 // } else {
 // // sql 2000的端口写法和sql 2005以上的有所不同，在Data Source 后以逗号隔开。
 // config1 = fmt.Sprintf("%s,%d;user id=%s;password=%s",
 // config1, m.sa.port, m.sa.user, m.sa.passwd)
 // }
 // fmt.Println(config1)
 // err := mssql.Open()

 // checkError(err)

 // mssql.Select()

 // config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s\\MSSQLSERVER,%s;user id=%s;password=%s",
 // "drivertest", "192.168.0.10", "1433", "elink", "elink888")
 config := fmt.Sprintf("Provider=SQLOLEDB;Initial Catalog=%s;Data Source=%s\\MSSQLSERVER,%s;user id=%s;password=%s",
 "znykt", "37.64.227.132", "1433", "elink", "elink888")
 DB, err := sql.Open("adodb", config)
 if err != nil {
 log.Fatal(err)
 }

 crontab := cron.New(cron.WithSeconds()) //精确到秒
 // 定时任务
 deviceStatusOnline_spec := "*/5 * * * * ?" //秒 分 时 日 月 周
 // 定义定时器调用的任务函数
 _, err = crontab.AddFunc(deviceStatusOnline_spec, func() {
 rows, err := DB.Query("select top 200 id from MYCARGOOUTRECORD order by id desc")
 if err != nil {
 fmt.Printf("select query err: %s\n", err)
 }
 i := 0
 for rows.Next() {
 // var id, name string
 // rows.Scan(&id, &name)
 // fmt.Printf("id = %s, name = %s\n", id, name)
 i++
 }
 logger.Info("结果数量：" + strconv.Itoa(i))
 })
 if err != nil {
 log.Fatal(err)
 }
 // 启动定时器
 crontab.Start()
 select {}
}

// func checkError(err error) {
// if err != nil {
// log.Fatal(err)
// }
// }

AES-ECB-PKCS5

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "crypto/aes"
 "crypto/cipher"
 "encoding/base64"
 "encoding/hex"
 "fmt"
 "strings"
)

func Base64URLDecode(data string) ([]byte, error) {
 var missing = (4 - len(data)%4) % 4
 data += strings.Repeat("=", missing)
 res, err := base64.URLEncoding.DecodeString(data)
 fmt.Println(" decodebase64urlsafe is :", string(res), err)
 return base64.URLEncoding.DecodeString(data)
}

func Base64UrlSafeEncode(source []byte) string {
 // Base64 Url Safe is the same as Base64 but does not contain '/' and '+' (replaced by '_' and '-') and trailing '=' are removed.
 bytearr := base64.StdEncoding.EncodeToString(source)
 safeurl := strings.Replace(string(bytearr), "/", "_", -1)
 safeurl = strings.Replace(safeurl, "+", "-", -1)
 safeurl = strings.Replace(safeurl, "=", "", -1)
 return safeurl
}

func AesDecrypt(crypted, key []byte) []byte {
 block, err := aes.NewCipher(key)
 if err != nil {
 fmt.Println("err is:", err)
 }
 blockMode := NewECBDecrypter(block)
 origData := make([]byte, len(crypted))
 blockMode.CryptBlocks(origData, crypted)
 origData = PKCS5UnPadding(origData)
 // fmt.Println("source is :", origData, string(origData))
 return origData
}

func AesEncrypt(src, key string) []byte {
 block, err := aes.NewCipher([]byte(key))
 if err != nil {
 fmt.Println("key error1", err)
 }
 if src == "" {
 fmt.Println("plain content empty")
 }
 ecb := NewECBEncrypter(block)
 content := []byte(src)
 content = PKCS5Padding(content, block.BlockSize())
 crypted := make([]byte, len(content))
 ecb.CryptBlocks(crypted, content)
 // 普通base64编码加密 区别于urlsafe base64
 // fmt.Println("base64 result:", base64.StdEncoding.EncodeToString(crypted))

 // fmt.Println("base64UrlSafe result:", Base64UrlSafeEncode(crypted))
 return crypted
}

func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
 padding := blockSize - len(ciphertext)%blockSize
 padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 return append(ciphertext, padtext...)
}

func PKCS5UnPadding(origData []byte) []byte {
 length := len(origData)
 // 去掉最后一个字节 unpadding 次
 unpadding := int(origData[length-1])
 return origData[:(length - unpadding)]
}

type ecb struct {
 b cipher.Block
 blockSize int
}

func newECB(b cipher.Block) *ecb {
 return &ecb{
 b: b,
 blockSize: b.BlockSize(),
 }
}

type ecbEncrypter ecb

// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
// mode, using the given Block.
func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
 return (*ecbEncrypter)(newECB(b))
}
func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Encrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}

type ecbDecrypter ecb

// NewECBDecrypter returns a BlockMode which decrypts in electronic code book
// mode, using the given Block.
func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
 return (*ecbDecrypter)(newECB(b))
}
func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
 if len(src)%x.blockSize != 0 {
 panic("crypto/cipher: input not full blocks")
 }
 if len(dst) < len(src) {
 panic("crypto/cipher: output smaller than input")
 }
 for len(src) > 0 {
 x.b.Decrypt(dst, src[:x.blockSize])
 src = src[x.blockSize:]
 dst = dst[x.blockSize:]
 }
}

type Person struct {
 Name string `json:"name"`
 Age int `json:"age"`
}

func main() {

 key, _ := base64.StdEncoding.DecodeString("cmVmb3JtZXJyZWZvcm1lcg==")
 strkey := string(key)
 fmt.Println(strkey)
 fmt.Println([]byte(strkey))
 fmt.Println()
 fmt.Println()
 fmt.Println()

 // wait_encode_str := "{\"stationNo\":\"241\"}"
 // encode_str := AesEncrypt(wait_encode_str, "reformerreformer")
 // hex.EncodeToString(encode_str)
 // fmt.Println(hex.EncodeToString(encode_str))

 wait_decode_str := "34D4F1A0506840B2A6D93C20C098312FAEE02E16FC26144A0621512E9F20CBB0AD121A74EFAD7A8935B132981D6C4198E06B8949E593E2A7D6AB4AB640CC498EE58CD0A66B5B0BBAAE1DBF4C9E4A02DE5658319E93B46831595515FA9F8EFD4202631F09DADDCD575B40C7F76739B31393A455B10AE73B2093EBD6B58DB88D24ACFB0F1DD123A9883051C8986BE060A168024690058318B8271F12E9D4795ACED75BDCC4F1F9AF75743BB81066F64D934B02CD41BE0528F2CEFFC3C40AC1645CA53943024C236A75F247DF3131704BECA1AFE7ADB81343E6D5914940F4E608BECF0D290EDD3B0F0B1F9CE0CD1557479B9E888007A48B19557A989E325193BD0F3EF40C9530B6B6F0D60F231A2EA2A58E9EA0D3B212E6C7BD177D0165C3FB052CBB672E9591D57F81115EBAEF9DC8116813F8D67289A440403D3CC9C7B0F716736E04780C06FCE2BC2D01938AE55A14FD6E0965A241608A371136FC9229BB61093367C8E674AAA35C66F4004C6478C11DE085A81A8D289DDF47EFA422BB9311355FB35218112F26981084812B3FBA2CC55D1267804FE913495C1518342E94B1C45A122B0516C01488D7FB6FEB3A06F37F"

 hex_data, _ := hex.DecodeString(wait_decode_str)
 decode_str := AesDecrypt(hex_data, key)
 fmt.Println(string(decode_str))

 // b1, _ := Base64URLDecode("cmVmb3JtZXJyZWZvcm1lcg==")
 // fmt.Println(string(b1))

 // b2 := Base64UrlSafeEncode([]byte("reformerreformer"))
 // fmt.Println(b2)
}


import java.security.Key;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * AES加密类
 *
 */
public class AESUtils {
 /**
 * 密钥算法
 */
 private static final String KEY_ALGORITHM = "AES";

 private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

 /**
 * 初始化密钥
 *
 * @return byte[] 密钥
 * @throws Exception
 */
 public static byte[] initSecretKey() {
 // 返回生成指定算法的秘密密钥的 KeyGenerator 对象
 KeyGenerator kg = null;
 try {
 kg = KeyGenerator.getInstance(KEY_ALGORITHM);
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
 return new byte[0];
 }
 // 初始化此密钥生成器，使其具有确定的密钥大小
 // AES 要求密钥长度为 128
 kg.init(128);
 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();
 return secretKey.getEncoded();
 }

 /**
 * 转换密钥
 *
 * @param key
 * 二进制密钥
 * @return 密钥
 */
 public static Key toKey(byte[] key) {
 // 生成密钥
 return new SecretKeySpec(key, KEY_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return encrypt(data, k, cipherAlgorithm);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为加密模式
 cipher.init(Cipher.ENCRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return decrypt(data, k, cipherAlgorithm);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 public static String showByteArray(byte[] data) {
 if (null == data) {
 return null;
 }
 StringBuilder sb = new StringBuilder("{");
 for (byte b : data) {
 sb.append(b).append(",");
 }
 sb.deleteCharAt(sb.length() - 1);
 sb.append("}");
 return sb.toString();
 }

 /**
 * 将16进制转换为二进制
 *
 * @param hexStr
 * @return
 */
 public static byte[] parseHexStr2Byte(String hexStr) {

 if (hexStr.length() < 1)
 return null;
 byte[] result = new byte[hexStr.length() / 2];
 for (int i = 0; i < hexStr.length() / 2; i++) {
 int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
 int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
 result[i] = (byte) (high * 16 + low);
 }
 return result;
 }

 /**
 * 将二进制转换成16进制
 *
 * @param buf
 * @return
 */
 public static String parseByte2HexStr(byte buf[]) {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < buf.length; i++) {
 String hex = Integer.toHexString(buf[i] & 0xFF);
 if (hex.length() == 1) {
 hex = '0' + hex;
 }
 sb.append(hex.toUpperCase());
 }
 return sb.toString();
 }

 /**
 * @param str
 * @param key
 * @return
 * @throws Exception
 */
 public static String aesEncrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = cipher.doFinal(str.getBytes("utf-8"));
 return new BASE64Encoder().encode(bytes);
 }

 public static String aesDecrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = new BASE64Decoder().decodeBuffer(str);
 bytes = cipher.doFinal(bytes);
 return new String(bytes, "utf-8");
 }

 public static void main(String[] args) throws Exception {
 byte[] key = initSecretKey();
 System.out.println("key：" + Base64.encodeBase64String(key));
 System.out.println("key：" + showByteArray(key));


 // 指定key
// String kekkk = "9iEepr1twrizIEKrs1hs2A==";
 String kekkk = "cmVmb3JtZXJyZWZvcm1lcg==";
 byte[] bs = Base64.decodeBase64(kekkk);
 System.out.println(bs);
 System.out.println("kekkk:" + showByteArray(Base64.decodeBase64(kekkk)));
 Key k = toKey(Base64.decodeBase64(kekkk));

 String data = "{\"requestName\":\"BeforeIn\",\"requestValue\":{\"carCode\":\"浙AD0V07\",\"inTime\":\"2016-09-29 10:06:03\",\"inChannelId\":\"4\",\"GUID\":\"1403970b-4eb2-46bc-8f2b-eeec91ddcd5f\",\"inOrOut\":\"0\"},\"Type\":\"0\"}";
// System.out.println("加密前数据: string:" + data);
// System.out.println("加密前数据: byte[]:" + showByteArray(data.getBytes()));
// System.out.println();

 byte[] encryptData = encrypt(data.getBytes(), k);
 String encryptStr=parseByte2HexStr(encryptData);

 System.out.println("加密后数据: byte[]:" + showByteArray(encryptData));
 System.out.println("加密后数据: Byte2HexStr:" + encryptStr);
 System.out.println();

 byte[] encryptStrByte = parseHexStr2Byte("96B742F275ECC2C77374E888CC3AD5D46CDDDAFA3BBA1AA8184D07BED0D957B250DF794666F5ACA787A8D2F20FB7D195C39E78FBDBDDD2F14B00AFC021BA306B03DB52706969E8497F91084CCA48EB81D902E3C32112F1DB07B21B45314ECFA2742F838C368C770F9C21DE07B99844A691269F83C5582A4EE21FB2C22A2168420EBC4AEEE6FB7D3B182AE5158F1F8E62F3BE3AA26C4F220E382B304F91A52A8CD823B68129409BA6059621F3EC0C94BBE8C5A9C1236C9A137536502BB6354D56");
 System.out.println(encryptStrByte.length);
 byte[] decryptData = decrypt(encryptStrByte, k);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData));
 System.out.println("解密后数据: string:" + new String(decryptData));

 }
}

java依赖

AES加解密

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.encryption;

import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;


/**
 * AES加密类
 *
 */
public class AESUtils {
 /**
 * 密钥算法
 */
 private static final String KEY_ALGORITHM = "AES";

 private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

 /**
 * 初始化密钥
 *
 * @return byte[] 密钥
 * @throws Exception
 */
 public static byte[] initSecretKey() {
 // 返回生成指定算法的秘密密钥的 KeyGenerator 对象
 KeyGenerator kg = null;
 try {
 kg = KeyGenerator.getInstance(KEY_ALGORITHM);
 } catch (NoSuchAlgorithmException e) {
 e.printStackTrace();
 return new byte[0];
 }
 // 初始化此密钥生成器，使其具有确定的密钥大小
 // AES 要求密钥长度为 128
 kg.init(128);
 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();
 return secretKey.getEncoded();
 }

 /**
 * 转换密钥
 *
 * @param key
 * 二进制密钥
 * @return 密钥
 */
 public static Key toKey(byte[] key) {
 // 生成密钥
 return new SecretKeySpec(key, KEY_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
 return encrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return encrypt(data, k, cipherAlgorithm);
 }

 /**
 * 加密
 *
 * @param data
 * 待加密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 加密数据
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为加密模式
 cipher.init(Cipher.ENCRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key) throws Exception {
 return decrypt(data, key, DEFAULT_CIPHER_ALGORITHM);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 二进制密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, byte[] key, String cipherAlgorithm) throws Exception {
 // 还原密钥
 Key k = toKey(key);
 return decrypt(data, k, cipherAlgorithm);
 }

 /**
 * 解密
 *
 * @param data
 * 待解密数据
 * @param key
 * 密钥
 * @param cipherAlgorithm
 * 加密算法/工作模式/填充方式
 * @return byte[] 解密数据
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, Key key, String cipherAlgorithm) throws Exception {
 // 实例化
 Cipher cipher = Cipher.getInstance(cipherAlgorithm);
 // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, key);
 // 执行操作
 return cipher.doFinal(data);
 }

 public static String showByteArray(byte[] data) {
 if (null == data) {
 return null;
 }
 StringBuilder sb = new StringBuilder("{");
 for (byte b : data) {
 sb.append(b).append(",");
 }
 sb.deleteCharAt(sb.length() - 1);
 sb.append("}");
 return sb.toString();
 }

 /**
 * 将16进制转换为二进制
 *
 * @param hexStr
 * @return
 */
 public static byte[] parseHexStr2Byte(String hexStr) {

 if (hexStr.length() < 1)
 return null;
 byte[] result = new byte[hexStr.length() / 2];
 for (int i = 0; i < hexStr.length() / 2; i++) {
 int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
 int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
 result[i] = (byte) (high * 16 + low);
 }
 return result;
 }

 /**
 * 将二进制转换成16进制
 *
 * @param buf
 * @return
 */
 public static String parseByte2HexStr(byte buf[]) {
 StringBuffer sb = new StringBuffer();
 for (int i = 0; i < buf.length; i++) {
 String hex = Integer.toHexString(buf[i] & 0xFF);
 if (hex.length() == 1) {
 hex = '0' + hex;
 }
 sb.append(hex.toUpperCase());
 }
 return sb.toString();
 }

 /**
 * @param str
 * @param key
 * @return
 * @throws Exception
 */
 public static String aesEncrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = cipher.doFinal(str.getBytes("utf-8"));
 return Base64.getEncoder().encodeToString(bytes);
 }

 public static String aesDecrypt(String str, String key) throws Exception {
 if (str == null || key == null)
 return null;
 Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
 byte[] bytes = Base64.getDecoder().decode(str);
 bytes = cipher.doFinal(bytes);
 return new String(bytes, "utf-8");
 }

 public static void main(String[] args) throws Exception {



 // 指定key
 String base64Str1 = "cmVmb3JtZXJyZWZvcm1lcg==";
 byte[] bs = Base64.getDecoder().decode(base64Str1);
 System.out.println("base64Str1解密："+ Arrays.toString(bs));
 System.out.println("base64Str1解密：" + showByteArray(Base64.getDecoder().decode(base64Str1)));
 Key key1 = toKey(Base64.getDecoder().decode(base64Str1));

 String data1 = "{\"aaa\":\"bbb\"}";
 System.out.println("明文：" + data1);

 byte[] encryptData1 = encrypt(data1.getBytes(), key1);
 String encryptStr1=parseByte2HexStr(encryptData1);
 System.out.println("加密后数据1: byte[]:" + showByteArray(encryptData1));
 System.out.println("加密后数据1: Byte2HexStr:" + encryptStr1);
 System.out.println();

 byte[] encryptStrByte1 = parseHexStr2Byte(encryptStr1);
 byte[] decryptData1 = decrypt(encryptStrByte1, key1);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData1));
 System.out.println("解密后数据: string:" + new String(decryptData1));


 System.out.println("--------------------------------------------------------");


 byte[] initKey = initSecretKey();
 System.out.println("key：" + Arrays.toString(Base64.getEncoder().encode(initKey)));
 System.out.println("key：" + showByteArray(initKey));
 Key key2 = toKey(initKey);

 String data2 = "{\"ccc\":\"ddd\"}";
 System.out.println("明文：" + data2);

 byte[] encryptData2 = encrypt(data2.getBytes(), key2);
 String encryptStr2=parseByte2HexStr(encryptData2);
 System.out.println("加密后数据1: byte[]:" + showByteArray(encryptData2));
 System.out.println("加密后数据1: Byte2HexStr:" + encryptStr2);
 System.out.println();

 byte[] encryptStrByte2 = parseHexStr2Byte(encryptStr2);
 byte[] decryptData2 = decrypt(encryptStrByte2, key2);
 System.out.println("解密后数据: byte[]:" + showByteArray(decryptData2));
 System.out.println("解密后数据: string:" + new String(decryptData2));

 }
}

AI基础知识科普

Mon, 01 Jan 0001 00:00:00 +0000

AI核心概念名词解释

基础类术语

AI（Artificial Intelligence）人工智能：广义上指的是让机器具备类似人类的思考、学习、决策等智能行为的技术总称。

AGI（Artificial General Intelligence）通用人工智能：一种尚未实现的 AI 类型，能像人类一样，具备跨领域学习和通用推理能力。

Narrow AI（狭义人工智能）：目前主流 AI 类型，专注在特定任务领域（如语音识别、下围棋）表现优秀，但无法迁移能力。

ML（Machine Learning）机器学习：AI 的一个子领域，强调通过数据训练模型，让系统自动学习模式，而非手工编程规则。

DL（Deep Learning）深度学习：机器学习的一个子集，使用多层神经网络（通常 3 层以上）自动提取特征并完成复杂任务。

模型与算法类

模型（Model）：训练完成后的 AI 实体，用来对新数据进行推理和输出。例如：GPT 就是一个语言模型。

训练（Training）：通过数据喂入模型，反复调整参数，使模型学会输入与输出之间的对应关系的过程。

推理 / 推断（Inference）：模型在训练完成后，对新输入做出判断或生成输出的过程。

参数（Parameters）：模型中可以学习的数值，决定模型输出。例如 GPT-4 有数千亿个参数。

权重（Weights）：神经网络中连接节点的值，是模型学习到的核心内容。

Loss Function（损失函数）：衡量模型输出结果与实际值之间差异的函数。优化目标是“最小化损失”。

Overfitting（过拟合）：模型学得太“死板”，只记住训练集数据，导致泛化能力差。

Fine-tuning（微调）：在已有大模型的基础上，用特定领域数据再次训练，使模型更适应某个细分任务。

生成式 AI 类（大模型领域）

LLM（Large Language Model）大语言模型：使用海量文本训练出的模型，具备文本生成、翻译、总结、问答等能力。代表如：GPT、Claude、Gemini。

Prompt（提示词）：输入给大模型的一段文字，用来引导其生成特定内容。

Prompt Engineering（提示词工程）：通过精心设计提示词，提高生成质量或实现复杂功能的技巧。

Hallucination（幻觉）：AI 模型生成看似合理但实际上是虚假的信息，可能误导用户。

Token（标记）：LLM 将文本分解的最小单位（可能是一个字、词或词根），模型以 Token 形式处理语言。

Top-k / Top-p Sampling：生成式模型中的输出采样策略，用于控制生成内容的多样性与准确性。

RAG（Retrieval-Augmented Generation）检索增强生成：结合搜索引擎 + LLM 的混合架构，模型在生成内容前可访问外部知识库，以提高准确性。

多模态与交互类

多模态（Multimodal）：模型能同时处理多种信息形式：文本、语音、图像、视频。例如：GPT-4o、Gemini 可看图回答问题。

apache日志记录真实ip-

Mon, 01 Jan 0001 00:00:00 +0000

默认情况下log日志格式为： LogFormat “%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-Agent}i"” combined 其中%h 是记录访问者的IP，如果在web的前端有一层代理，那么这个%h其实就是代理机器的IP，这不是我们想要的。在这种情况下， %{X-FORWARDED-FOR}i 字段会记录客户端真实的IP。所以log日志改为： LogFormat “%h %{X-FORWARDED-FOR}i %l %u %t "%r" %>s %b "%{Referer}i" "%{User-Agent}i"” combined

apache限制某个目录下的php文件没有执行权限

Mon, 01 Jan 0001 00:00:00 +0000

为了安全期间，有时我们需要限制网站下的某些目录对于php脚本不能执行。有两种方法可以参考：

使用.htaccess 文件限制

在要限制php执行的目录下，创建.htaccess文件，加入内容

php_flag engine off

使用apache的配置文件httpd.conf

在相关的虚拟主机段，加入

<Directory /www/htdocs/path>
 php_admin_flag engine off 
 <filesmatch "(.*)php">
 Order deny,allow
 Deny from all
 Allow from 127.0.0.1
 </filesmatch> 
</Directory>

apache在虚拟主机中实现用户验证

Mon, 01 Jan 0001 00:00:00 +0000

##两种方法

方法一

虚拟主机配置文件中，需要加入 <Directory /data/web/test> AllowOverride AuthConfig

然后在虚拟主机的主目录，即DocumentRoot 目录下 vi /data/web/test/.htaccess

加入 AuthName “frank share web” AuthType Basic 这种要重启下面的那种不需要重启 AuthUserFile /data/web/test/.htpasswd require valid-user

保存后，然后创建apache的验证用户

htpasswd -c /data/web/test/.htpasswd test #第一次创建用户要用到-c 参数第2次添加用户，就不用-c参数

如果你想修改密码，可以如下

htpasswd -m .htpasswd test2

重启apache，即可。

方法二

到此，你已经配置完成。下面介绍另一种方式： ################################## vi http.conf 在相应的虚拟主机配置文件段，加入 <Directory *> AllowOverride AuthConfig AuthName “自定义的” AuthType Basic AuthUserFile /data/.htpasswd // 这个目录你可以随便写一个，没有限制 require valid-user

保存后，然后创建apache的验证用户

htpasswd 默认创建的密码只有前8位有效

按照如下命令创建密码 htpasswd -c .htpasswd user1 假如，密码为123456789 那么访问时，不管是输入 12345678 还是 123456789 甚至是 123456781234 都能顺利通过验证。这是为什么呢？ htpasswd默认情况，是使用系统库中的crypt()函数来对密码明文进行单向加密的。在网上找到该函数的说明： crypt()将使用Data Encryption Standard(DES)演算法将参数key所指的字符串加以编码，key字符串长度仅取前8个字符，超过此长度的字符没有意义。参数salt为两个字符组成的字符串，由a-z,A-Z,0-9,".",和"/“所组成，用来决定使用4096种不同内建表格的哪一个。函数执行成功后会返回指向编码过的字符串指针，参数key所指的字符串不会有所更动。编码过的字符串长度为13个字符，前两个字符为参数salt代表的字符串。

apt包管理器

Mon, 01 Jan 0001 00:00:00 +0000

dpkg
***************************************************
dpkg -l 查看当前系统中的已经安装软件包的信息 相当于：rpm -qa
dpkg -L 查询系统中已经安装的软件包的文件详细列表 相当于： rpm -ql
dpkg -s 查询已安装的指定软件包的详细信息 相当于： rpm -qi
dpkg -S 查询系统中的某个文件属于哪个软件包 rpm -qf
dpkg -i 安装deb软件包
卸载deb软件包
dpkg -r
dpkg -P 彻底的卸载 包括软件的配置文件等等
查看没有安装的deb包命令
dpkg -c 查询deb包文件中所包含的文件 rpm -qlp
dpkg -I 查询deb包的详细信息-
***************************************************

base64

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "encoding/base64"
 "fmt"
 "strings"
)

//Base64UrlSafeEncode 需要替换掉一些字符
func Base64UrlSafeEncode(source []byte) string {
 // Base64 Url Safe is the same as Base64 but does not contain '/' and '+' (replaced by '_' and '-') and trailing '=' are removed.
 bytearr := base64.StdEncoding.EncodeToString(source)
 safeurl := strings.Replace(string(bytearr), "/", "_", -1)
 safeurl = strings.Replace(safeurl, "+", "-", -1)
 safeurl = strings.Replace(safeurl, "=", "", -1)
 return safeurl
}

func main() {

 //标准base64编码
 wait_encode_data := "reformerreformer"
 wait_decode_data := "cmVmb3JtZXJyZWZvcm1lcg"

 //使用标准库自带的方式加密
 sEnc := base64.StdEncoding.EncodeToString([]byte(wait_encode_data))
 fmt.Println(sEnc)

 sDec, _ := base64.StdEncoding.DecodeString("cmVmb3JtZXJyZWZvcm1lcg==")
 fmt.Println(string(sDec))

 //兼容base64编码
 uEnc := base64.URLEncoding.EncodeToString([]byte(wait_encode_data))
 fmt.Println(uEnc)

 uDec, _ := base64.URLEncoding.DecodeString(wait_decode_data)
 fmt.Println(string(uDec))

}

ByteBuddy动态代理

Mon, 01 Jan 0001 00:00:00 +0000

pom文件添加依赖

 <dependency>
 <groupId>net.bytebuddy</groupId>
 <artifactId>byte-buddy</artifactId>
 <!-- 我用的最新的， 一般1.14.0以上都没问题 -->
 <version>1.15.1</version>
 </dependency>

先创建要被代理的类

public class TargetClass {
 public void performAction() {
 System.out.println("原始方法: performAction");
 }

 public String sayHello(String name) {
 return "Hello, " + name;
 }
}

创建拦截器

import net.bytebuddy.implementation.bind.annotation.*;

import java.lang.reflect.Method;
import java.util.concurrent.Callable;

/**
 * 通用方法拦截器
 */
public class GenericInterceptor {

 @RuntimeType
 public static Object intercept(@Origin Method method,
 @AllArguments Object[] args,
 @This Object obj,
 @SuperCall Callable<?> callable) throws Exception {
 // 获取动态添加的字段值
 String proxyField = (String) obj.getClass().getField("proxyField").get(obj);
 System.out.println("[拦截] proxyField 值: " + proxyField);

 // 修改字段值
 System.out.println("[通用拦截] 修改字段proxyField值: Modified by interceptor" );
 obj.getClass().getField("proxyField").set(obj, "Modified by interceptor");

 System.out.println("[通用拦截] 方法开始: " + method.getName());
 Object result = callable.call(); // 执行原始方法
 System.out.println("[通用拦截] 方法结束: " + method.getName());
 return result;
 }
}

代理工具

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.modifier.Visibility;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 通用 Byte Buddy 动态代理工具类
 */
public class ByteBuddyProxy {

 /**
 * 创建一个代理对象
 *
 * @param targetClass 目标类类型
 * @param interceptor 拦截器类（需使用 Byte Buddy 注解定义逻辑）
 * @param <T> 泛型
 * @return 代理实例
 * @throws NoSuchMethodException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 */
 public static <T> T createProxy(Class<T> targetClass, Class<?> interceptor) throws Exception {

 Class<?> dynamicType = new ByteBuddy()
 .subclass(targetClass)
 // ElementMatchers.any() 拦截所有方法
 .method(ElementMatchers.any())
 // MethodDelegation.to(interceptor) 拦截器类 方法增强
 .intercept(MethodDelegation.to(interceptor))
 // 动态的添加字段。这里可以放到参数里面，然后由调用方传递进来要添加什么参数
 .defineField("proxyField", String.class, Visibility.PUBLIC) // 可选：添加字段
 .defineField("abc", String.class, Visibility.PUBLIC) // 可选：添加字段
 .make()
 .load(targetClass.getClassLoader())
 .getLoaded();
 // 支持构造实例
// .getDeclaredConstructor()
// .newInstance();

 Constructor<?> constructor = dynamicType.getDeclaredConstructor();
 Object instance = constructor.newInstance();

 // 现在就可以 调用方法触发拦截逻辑 了
 // ((TargetClass) instance).performAction();
 // 设置字段值
 System.out.println("[通用拦截] 设置字段proxyField值: Hello Dynamic Field" );
 dynamicType.getField("proxyField").set(instance, "Hello Dynamic Field");

 System.out.println("[通用拦截] 设置字段abc值: def" );
 dynamicType.getField("abc").set(instance, "def");
 return (T) instance;

 }
}

一个测试类用来测试动态代理

public class ByteBuddyGenericExample {
 public static void main(String[] args) throws Exception {
 // 创建代理对象
 TargetClass proxyInstance = ByteBuddyProxy
 .createProxy(TargetClass.class, GenericInterceptor.class);

 // 调用方法
 proxyInstance.performAction();
 String result = proxyInstance.sayHello("World");
 System.out.println("返回值: " + result);

 String abc = (String) proxyInstance.getClass().getField("abc").get(proxyInstance);
 System.out.println("last在打印一遍proxyField: " + abc);
 }
}

cbor

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "encoding/hex"
 "fmt"

 "github.com/fxamacker/cbor/v2"
)

func main() {

 b, _ := cbor.Marshal("hello world")
 fmt.Println(hex.EncodeToString(b))

 cborBytes, _ := hex.DecodeString(hex.EncodeToString(b))

 s := ""
 cbor.Unmarshal(cborBytes, &s)

 fmt.Printf("%s", s)
}

certbot

Mon, 01 Jan 0001 00:00:00 +0000

sudo apt install certbot

让 Certbot 自动编辑您的 nginx 配置以提供证书，只需一步即可打开 HTTPS 访问

sudo certbot –nginx

如果您感觉更保守，并希望手动更改 nginx 配置，请运行此命令

sudo certbot certonly –nginx

Let’s Encrypt 证书的有效期为 90 天，因此您需要设置自动续期以确保证书不会过期。

您可以使用 Certbot 的自动续期功能，或者设置一个定时任务来定期更新证书。您可以通过运行以下命令来测试证书的自动续期

sudo certbot renew –dry-run

这是一个用 certbot 阿里云插件申请阿里云免费证书的方式暂时没验证过

https://zhuanlan.zhihu.com/p/25571676513

CGLIB动态代理

Mon, 01 Jan 0001 00:00:00 +0000

maven项目需要添加依赖

 <!-- https://mvnrepository.com/artifact/cglib/cglib -->
 <dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>3.3.0</version>
 </dependency>

1 0.1 CGLIB包结构

*net.sf.cglib.core *底层字节码处理类。
*net.sf.cglib.transform *该包中的类用于class文件运行时转换或编译时转换。
*net.sf.cglib.proxy *该包中的类用于创建代理和方法拦截。
*net.sf.cglib.reflect *该包中的类用于快速反射，并提供了C#风格的委托。
*net.sf.cglib.util *集合排序工具类。
*net.sf.cglib.beans *JavaBean工具类。

1 使用CGLIB实现动态代理

2 1.1 CGLIB代理相关的类

net.sf.cglib.proxy.Enhancer 主要的增强类。
net.sf.cglib.proxy.MethodInterceptor 主要的方法拦截类，它是Callback接口的子接口，需要用户实现。
net.sf.cglib.proxy.MethodProxy JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用。

cglib是通过动态的生成一个子类去覆盖所要代理类的非final方法，并设置好callback，则原有类的每个方法调用就会转变成调用用户定义的拦截方法（interceptors）。

CGLIB代理相关的常用API如下图所示：

net.sf.cglib.proxy.Callback接口在CGLIB包中是一个重要的接口，所有被net.sf.cglib.proxy.Enhancer类调用的回调（callback）接口都要继承这个接口。

net.sf.cglib.proxy.MethodInterceptor能够满足任何的拦截（interception ）需要。对有些情况下可能过度。为了简化和提高性能，CGLIB包提供了一些专门的回调（callback）类型：

net.sf.cglib.proxy.FixedValue 为提高性能，FixedValue回调对强制某一特别方法返回固定值是有用的。
net.sf.cglib.proxy.NoOp NoOp回调把对方法调用直接委派到这个方法在父类中的实现。
net.sf.cglib.proxy.LazyLoader 当实际的对象需要延迟装载时，可以使用LazyLoader回调。一旦实际对象被装载，它将被每一个调用代理对象的方法使用。
net.sf.cglib.proxy.Dispatcher Dispathcer回调和LazyLoader回调有相同的特点，不同的是，当代理方法被调用时，装载对象的方法也总要被调用。
net.sf.cglib.proxy.ProxyRefDispatcher ProxyRefDispatcher回调和Dispatcher一样，不同的是，它可以把代理对象作为装载对象方法的一个参数传递。

3 1.2 CGLIB动态代理的基本原理

CGLIB动态代理的原理就是用Enhancer生成一个原有类的子类，并且设置好callback到proxy，则原有类的每个方法调用都会转为调用实现了MethodInterceptor接口的proxy的intercept() 函数，如图

在intercept()函数里，除执行代理类的原因方法，在原有方法前后加入其他需要实现的过程，改变原有方法的参数值，即可以实现对原有类的代理了。这似于AOP中的around advice。

4 1.3 使用MethodInterceptor接口实现方法回调

当对代理中所有方法的调用时，都会转向MethodInterceptor类型的拦截（intercept）方法,在拦截方法中再调用底层对象相应的方法。下面我们举个例子，假设你想对目标对象的所有方法调用进行权限的检查，如果没有经过授权，就抛出一个运行时的异常。

channel

Mon, 01 Jan 0001 00:00:00 +0000

顺序执行两个协程

package main

import (
 "fmt"
 "log"
 "math/rand"
 "sync"
 "time"
)

func main() {
 //顺序执行两个协程函数
 ch1 := make(chan string, 5)
 go testBoringWithChannelClose("boring!", ch1)
 ch2 := make(chan string, 5)
 go testBoringWithChannelClose("funning!", ch2)

 for b := range ch1 {
 go log.Printf("You say: %s", b)
 }

 for b := range ch2 {
 go log.Printf("You say: %s", b)
 }

}

func testBoringWithChannelClose(msg string, c chan string) {
 for i := 0; i < 20; i++ {
 c <- fmt.Sprintf("%s %d", msg, i)
 time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
 }
 fmt.Println(msg + "结束")
 close(c)
}

带缓冲的channel 就像一个携程池，去执行协程任务。

package main

import (
 "fmt"
 "log"
 "math/rand"
 "sync"
 "time"
)

func main() {


 //限制1024个协程数执行任务
 goNum1024Times()
}

// 控制1024个协程
func goNum1024Times() {
 var wg sync.WaitGroup
 ch := make(chan struct{}, 1024)
 for i := 0; i < 20000; i++ {
 wg.Add(1)
 ch <- struct{}{}
 go func() {
 defer wg.Done()
 fmt.Printf("%d\n", len(ch)) //打印通道的长度
 <-ch
 }()
 }
 wg.Wait()
}

CRC16

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "CRC15/method" //因为gomod 定义了模块名为 module CRC15 所以引用目录下的method
 "encoding/hex"
 "fmt"
 "strings"
)

func main() {

 byteArr, _ := hex.DecodeString("7F39F60116C067321223344556677889800112230100000000F700000000000000000000000000000000323030B7C2D8BB353030FABBF7D63130")
 checkVal := method.UsMBCRC16(byteArr)
 fmt.Println(strings.ToUpper(fmt.Sprintf("%X", checkVal)))
}

go.mod

module CRC15

go 1.13

method/crc16.go

package method

import (
 "encoding/hex"
 "fmt"
 "strings"
)

var auchCRCLo = [256]uint8{
 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
 0x43, 0x83, 0x41, 0x81, 0x80, 0x40,
}

var auchCRCHi = [256]uint8{
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
}

func UsMBCRC16(pucFrame []byte) int {
 ucCRCHi := 0xFF
 ucCRCLo := 0xFF
 iIndex := 0
 for i := 0; i < len(pucFrame); i++ {
 iIndex = ucCRCLo ^ int(pucFrame[i])
 ucCRCLo = ucCRCHi ^ int(auchCRCHi[iIndex])
 ucCRCHi = int(auchCRCLo[iIndex])
 }
 return ucCRCLo<<8 | ucCRCHi
}

func TopscommCrc16(param string, check string) bool {
 byteArr, _ := hex.DecodeString(param)
 checkVal := UsMBCRC16(byteArr)
 h := fmt.Sprintf("%X", checkVal)
 if h != strings.ToUpper(check) {
 return false
 }

 return true
}

csdn自动跳转清除

Mon, 01 Jan 0001 00:00:00 +0000

find . -name "*.html" -exec sed -i '/window.location.href/d' {} \;

docker-compose

Mon, 01 Jan 0001 00:00:00 +0000

docker-compose.yml中添加自定义网络

1. 如果是3.5以下版本（3.4及以下）
网络配置如下定义
networks:
 自定义网络名1:#此名称在当前docker-compose文件中作为id出现，当前文件使用网络写 "自定义网络名1"即可
 driver: "bridge"
运行后使用 docker network list
会创建一个名为： "目录名_自定义网络名1" 的docker网络

2. 在3.5版本的docker-compose.yml文件中可以定义网络
networks:
 自定义网络2:
 name: 自定义网络2-custom
 driver: "bridge"
此时添加了name属性，在运行 docker network list 命令则创建的docker网络名即为 "自定义网络2-custom"

在docker-compose.yml中使用已有的网络

此以3.4 3.5版本文件为例
此时另一个目录中的docker-compose.yml文件的容器启动也要使用 "目录名_自定义网络名1" 的docker网络
可以如下写法
networks:
 自定义网络3:#"自定义网络3" 作为当前文件中的一个ID标记使用
 external:
 name: 自定义网络2-custom || 目录名_自定义网络名1 
 #(也就是在运行docker network list 命令能打印出来的网络名称)

覆盖镜像中启动的默认命令

command: [“bundle”, “exec”, “thin”, “-p”, “3000”]

DockerNetword

Mon, 01 Jan 0001 00:00:00 +0000

Docker 网络与容器互联

简单整理一下 Docker 中 network 子命令，以及 docker 中相关 network 方面的内容。

在安装完 Docker 后，使用 ifconfig -a 查看可以看到多出一个虚拟的 docker0 接口，这个接口是 Docker 默认的网关地址。

不同 Network driver 介绍

Docker 容器默认有三种连接方式：

bridge
host
none

bridge 模式

Docker 默认会生成一个 docker0 网桥，如果不指定，默认创建的容器都会默认走此网桥，使用 bridge 模式联网。默认 bridge 会产生 docker0 的虚拟接口，在宿主机上可以使用 ifconfig -a 来查看，一般的网关地址是 172.17.0.1，所有的容器都会使用这个地址作为网关，容器的 IP 地址会从 172.17.0.2 到 172.17.0.254 这个范围 IP 段划分。

此模式下，容器可以单向连接外网，外网或宿主要访问容器则需要容器映射端口。

host 模式

host 模式等同于容器直接使用物理机的网络，宿主机的 IP 就是容器的 IP，端口也可以直接调用。

fastjson

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.alibabafastjsondemo;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import java.util.Map;

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

 String str = "{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}";
 //第一种方式
 Map maps = (Map) JSON.parse(str);
 System.out.println("这个是用JSON类来解析JSON字符串!!!");
 for (Object map : maps.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" " + ((Map.Entry)map).getValue());
 }
 //第二种方式
 Map mapTypes = JSON.parseObject(str);
 System.out.println("这个是用JSON类的parseObject来解析JSON字符串!!!");
 for (Object obj : mapTypes.keySet()){
 System.out.println("key为："+obj+"值为："+mapTypes.get(obj));
 }
 //第三种方式
 Map mapType = JSON.parseObject(str,Map.class);
 System.out.println("这个是用JSON类,指定解析类型，来解析JSON字符串!!!");
 for (Object obj : mapType.keySet()){
 System.out.println("key为："+obj+"值为："+mapType.get(obj));
 }
 //第四种方式

 Map json = (Map) JSONObject.parse(str);
 System.out.println("这个是用JSONObject类的parse方法来解析JSON字符串!!!");
 for (Object map : json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 //第五种方式

 JSONObject jsonObject = JSONObject.parseObject(str);
 System.out.println("这个是用JSONObject的parseObject方法来解析JSON字符串!!!");
 for (Object map : json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 //第六种方式

 Map mapObj = JSONObject.parseObject(str,Map.class);
 System.out.println("这个是用JSONObject的parseObject方法并执行返回类型来解析JSON字符串!!!");
 for (Object map: json.entrySet()){
 System.out.println(((Map.Entry)map).getKey()+" "+((Map.Entry)map).getValue());
 }
 String strArr = "{{\"0\":\"zhangsan\",\"1\":\"lisi\",\"2\":\"wangwu\",\"3\":\"maliu\"}," +
 "{\"00\":\"zhangsan\",\"11\":\"lisi\",\"22\":\"wangwu\",\"33\":\"maliu\"}}";
 // JSONArray.parse()
 System.out.println(json);

 }
}

最终输出结果为：

Firebase

Mon, 01 Jan 0001 00:00:00 +0000

要用这东西首先要有跳出凡间的能力

然后如果你刚好有一个仙界的服务器，

安装工具

npm install -g firebase-tools

【验证版本】

firebase –version

firebase login –no-localhost

登录完成后

初始化项目

firebase init

修改操作目录下的public/index.html

执行firebase deploy

gdm3和lightdm切换

Mon, 01 Jan 0001 00:00:00 +0000

# 切换 gdm3
sudo dpkg-reconfigure gdm3

# 切换 lightdm
sudo dpkg-reconfigure lightdm

GetSpringBeanUtil

Mon, 01 Jan 0001 00:00:00 +0000


import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * 可以实现在普通类中获取springBean实例
 */
@Component
public final class GetSpringBeanUtil implements BeanFactoryPostProcessor {
 private static ConfigurableListableBeanFactory beanFactory;

 public GetSpringBeanUtil() {
 }

 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 GetSpringBeanUtil.beanFactory = beanFactory;
 }

 public static <T> T getBean(String name) throws BeansException {
 return (T) beanFactory.getBean(name);
 }

 public static <T> T getBean(Class<T> clz) throws BeansException {
 T result = beanFactory.getBean(clz);
 return result;
 }

 public static boolean containsBean(String name) {
 return beanFactory.containsBean(name);
 }

 public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
 return beanFactory.isSingleton(name);
 }

 public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
 return beanFactory.getType(name);
 }

 public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
 return beanFactory.getAliases(name);
 }

 public static <T> T getAopProxy(T invoker) {
 return (T) AopContext.currentProxy();
 }
}

Git

Mon, 01 Jan 0001 00:00:00 +0000

Git支持多种协议，包括https，但通过ssh支持的原生git协议速度最快。使用https除了速度慢以外，还有个最大的麻烦是每次推送都必须输入口令，但是在某些只开放http端口的公司内部就无法使用ssh协议而只能用https。

分支操作(默认的主分支名为 master)

创建分支并切换: git checkout -b 分支名称
等同于下面两句话
(
1.创建分支: git branch 分支名称
2.切换到某分支: git checkout 分支名称
)
本地创建分支并关联远程分支: git checkout -b 本地分支名 origin/远程分支名
建立本地分支和远程分支的关联，使用: git branch --set-upstream 本地分支名 origin/远程分支名

合并指定分支到当前分支: git merge 目标分支名

查看所有本地分支(当前分支前会有一个*号): git branch

删除某个分支: git branch -d 分支名

强行删除分支: git branch -D 分支名
用带参数的git log也可以看到分支的合并情况: git log --graph --pretty=oneline --abbrev-commit (用git log --graph命令可以看到分支合并图)

带参数的合并,并产生一个新的commit: git merge --no-ff -m "merge with no-ff" dev

存储当前工作空间,解决其他问题,并还原
 1. git stash "贮藏描述" (存储当前工作区)
 2. 其他操作,例如修复bug要创建新的分支,提交合并并且删除bug分支
 3. git stash list (查看工作区)
 (会输出)
 stash@{0}: WIP on master: 2b5faea new info text
 stash@{1}: WIP on dev: b0f1f6a conflict fixed
 stash@{2}: WIP on dev: b0f1f6a conflict fixed
 4. git shash apply stash@{n} (恢复到哪个工作区)
 5. git shash drop(删除缓冲区序号最小的工作区)
 (6. 45两步可以用 git stash pop 会直接还原到序号最小的工作区并将其删除)

拉取: git pull 如果有冲突，要先处理冲突。

标签 Git的标签虽然是版本库的快照，但其实它就是指向某个commit的指针（跟分支很像对不对？但是分支可以移动，标签不能移动），所以，创建和删除标签都是瞬间完成的。打一个新的标签: git tag 标签名给某一个历史提交打标签: git tag 标签名提交Hash

gorm连接mssql

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 github.com/jinzhu/gorm v1.9.14
)

package main

import (
 "flag"
 "fmt"

 _ "github.com/denisenkom/go-mssqldb"
 "github.com/jinzhu/gorm"
)

type Dt_Cardtype struct {
 gorm.Model
 ID string `gorm:"id"`
 CardCname string `gorm:"CardCname"`
}

var (
 debug = flag.Bool("debug", true, "enable debugging")
 password = flag.String("password", "Elink666.", "the database password")
 port *int = flag.Int("port", 1433, "the database port")
 server = flag.String("server", "172.16.183.131", "the database server")
 user = flag.String("user", "sa", "the database user")
)

func main() {
 connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=carpark", *server, *user, *password, *port)
 db, err := gorm.Open("mssql", connString)
 if err != nil {
 panic("连接数据库失败")
 }
 defer db.Close()

 db.SingularTable(true)
 db.LogMode(true)
 db.CommonDB()

 var dc []Dt_Cardtype
 db.Find(&dc)

 fmt.Println(len(dc))
 // // 自动迁移模式
 // db.AutoMigrate(&Product{})

 // // 创建
 // db.Create(&Product{Code: "L1212", Price: 1000})

 // // 读取
 // var product Product
 // db.First(&product, 1) // 查询id为1的product
 // db.First(&product, "code = ?", "L1212") // 查询code为l1212的product

 // // 更新 - 更新product的price为2000
 // db.Model(&product).Update("Price", 2000)

 // // 删除 - 删除product
 // db.Delete(&product)
}

gorose连接mssql

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/denisenkom/go-mssqldb v0.0.0-20200620013148-b91950f658ec
 github.com/gohouse/converter v0.0.3 // indirect
 github.com/gohouse/gorose v1.0.5
 github.com/gohouse/gorose/v2 v2.1.7
 github.com/jinzhu/gorm v1.9.14
)

package main

import (
 "flag"
 "fmt"
 "os"

 _ "github.com/denisenkom/go-mssqldb"
 gorose "github.com/gohouse/gorose/v2"
)

var err error
var engin *gorose.Engin

type DtCardtype struct {
 ID int64 `gorose:"id"`
 CardCname string `gorose:"CardCname"`
 Mark string `gorose:"Mark"`
}

var (
 debug = flag.Bool("debug", true, "enable debugging")
 password = flag.String("password", "123456", "the database password")
 port *int = flag.Int("port", 1433, "the database port")
 server = flag.String("server", "10.10.10.53", "the database server")
 user = flag.String("user", "sa", "the database user")
)

func init() {
 // 全局初始化数据库,并复用
 // 这里的engin需要全局保存,可以用全局变量,也可以用单例
 // 配置&gorose.Config{}是单一数据库配置
 // 如果配置读写分离集群,则使用&gorose.ConfigCluster{}
 // mysql Dsn示例 "root:root@tcp(localhost:3306)/test?charset=utf8&parseTime=true"
 connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=carpark", *server, *user, *password, *port)
 engin, err = gorose.Open(&gorose.Config{Driver: "mssql", Dsn: connString})
 if err != nil {
 fmt.Println(err)
 os.Exit(-1)
 }
}
func DB() gorose.IOrm {
 return engin.NewOrm()
}
func main() {
 var u []DtCardtype
 DB().Table("Park").First()
 fmt.Println(u)
}

goroutine

Mon, 01 Jan 0001 00:00:00 +0000

获取goroutineID

func goID() uint64 {
 b := make([]byte, 64)
 b = b[:runtime.Stack(b, false)]
 b = bytes.TrimPrefix(b, []byte("goroutine "))
 b = b[:bytes.IndexByte(b, ' ')]
 n, _ := strconv.ParseUint(string(b), 10, 64)
 return n
}

go发送get或post请求

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "crypto/md5"
 "crypto/tls"
 "encoding/json"
 "fmt"
 "io"
 "io/ioutil"
 "log"
 "net/http"
 "strconv"
 "time"
)

func main() {
 // GetData()
 PostMethod()
}

//这是get请求
func GetData() {
 tr := &http.Transport{
 TLSClientConfig: &tls.Config{InsecureSkipVerify: true}} //如果需要测试自签名的证书 这里需要设置跳过证书检测 否则编译报错
 client := &http.Client{Transport: tr}
 resp, err := client.Get("https://192.168.7.15:8080/v1/getaction.do")
 //此处需要注意经过测试，不论是否有err在此之前一定要判断resp.Body如果不为空则需要关闭,测试环境go1.16
 if resp.Body != nil {
 defer resp.Body.Close()
 }
 if err != nil {
 fmt.Println("error:", err)
 return
 }

 body, err := ioutil.ReadAll(resp.Body)
 fmt.Println(string(body))
}

//这是post请求
func PostMethod() {
 var rsp io.Reader
 tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}} //如果需要测试自签名的证书 这里需要设置跳过证书检测 否则编译报错
 client := &http.Client{Transport: tr}
 data := "cmd=123"
 resp, err := client.Post("https://192.168.7.15:8080/v1/postaction.do", data, rsp)
 //此处需要注意经过测试，不论是否有err在此之前一定要判断resp.Body如果不为空则需要关闭,测试环境go1.16
 if resp.Body != nil {
 defer resp.Body.Close()
 }
 if err != nil {
 fmt.Println("err:", err)
 } else {
 body, er := ioutil.ReadAll(resp.Body)
 if er != nil {
 fmt.Println("err:", er)
 } else {
 fmt.Println(string(body))
 }
 }

}

func PostMethod() {
 //{"carmeraId":"epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$6","carmeraDesc":"","status":"1","areaId":"001","dataTime":"2020-11-17 14:30:12"}
 //{"carmeraId":"epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$7","carmeraDesc":"2F走廊西","status":"1","areaId":"001","dataTime":"2020-11-17 15:42:01"}
 m3 := map[string]string{
 "cameraId": "epark-370211-dongjiakou~~cctv-dahua~channelCode~dahua!1000003$1$0$7",
 "cameraDesc": "2F走廊西",
 "status": "1",
 "areaId": "001",
 "dataTime": "2020-11-17 15:42:01",
 }
 exportData, err := json.Marshal(m3)

 tr := &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
 client := &http.Client{Transport: tr}
 req, err := http.NewRequest(http.MethodPost, "https://eug-test.elinkit.com.cn/epmet-acs/report/video/info", bytes.NewReader(exportData))
 if err != nil {
 log.Fatal(err.Error)
 }
 times := strconv.FormatInt(time.Now().Unix(), 10)
 data := []byte("c3c4029b9741f26ab4a4cbd98c2310ff" + times)
 has := md5.Sum(data)
 accessToken := fmt.Sprintf("%x", has)
 req.Header.Set("Content-Type", "application/json")
 req.Header.Set("AccessToken", accessToken)
 req.Header.Set("Timestamp", times)

 response, err := client.Do(req)
 //此处需要注意经过测试，不论是否有err在此之前一定要判断 response.Body 如果不为空则需要关闭,测试环境go1.16
 if response.Body != nil {
 defer response.Body.Close()
 }

 if err != nil {
 fmt.Println("err:", err)

 }

 body, er := ioutil.ReadAll(response.Body)
 if er != nil {
 fmt.Println("err:", er)
 }
 fmt.Println(string(body))
}

GO基础

Mon, 01 Jan 0001 00:00:00 +0000

go语言不需要写分号

1. 基本程序结构

package 包名
import ""
func main(){
 //code
}

2. 导包方式

2.1单独导入

import ""

2.2多包导入方式

import(
 ""
 ""
)

3. 变量类型

3.1 普通变量类型

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128

3.2 衍生数据类型

Array types 数组
Structure types 结构体
Union types 联合
Slice types 切片，引用类型
Interface types 接口
Map types 字典，引用类型
Channel Types 通道，引用类型
Slice， Map， Channel 这三种是引用数据类型，使用需要make

go脚本编程接受命令行参数

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "flag"
 "fmt"
)

func main() {
 // 定义几个变量，用于接收命令行的参数值
 var user string
 var password string
 var host string
 var port int
 // &user 就是接收命令行中输入 -u 后面的参数值，其他同理
 flag.StringVar(&user, "u", "root", "账号，默认为root")
 flag.StringVar(&password, "p", "", "密码，默认为空")
 flag.StringVar(&host, "h", "localhost", "主机名，默认为localhost")
 flag.IntVar(&port, "P", 3306, "端口号，默认为3306")
 // 解析命令行参数写入注册的flag里
 flag.Parse()
 // 输出结果
 fmt.Printf("user：%v\npassword：%v\nhost：%v\nport：%v\n",
 user, password, host, port)

}

hmac算法

Mon, 01 Jan 0001 00:00:00 +0000

‌ HMAC （Hash-based Message Authentication Code）是一种基于哈希函数的消息认证码算法‌，用于验证数据的完整性和认证消息的发送者。HMAC结合了哈希函数和密钥，通过将密钥与消息进行哈希运算来生成消息认证码‌

HMAC的工作原理
HMAC使用一个密钥和一个哈希函数（如MD5、SHA-1、SHA-256等）生成一个固定长度的哈希值。具体步骤如下：

‌输入‌：消息和密钥。
‌处理‌：HMAC对输入的消息和密钥进行哈希处理，生成一个固定长度的哈希值。
‌输出‌：该哈希值即为HMAC签名‌

HMAC的安全性
HMAC的安全性依赖于密钥的保密性和所使用的哈希函数的抗碰撞能力。只有持有密钥的一方能够生成或验证该消息的签名，从而确保消息在传输过程中没有被篡改‌

HMAC的应用场景
HMAC广泛应用于各种需要确保数据完整性和认证的应用场景中，例如：

‌ IPSec ‌：在IPSec中，HMAC用于验证IP数据包的完整性和真实性。
‌ SSL/TLS ‌：在SSL/TLS协议中，HMAC用于验证通信双方的身份和数据完整性。

package main

import (
 "crypto/hmac"
 "crypto/sha256"
 "encoding/base64"
 "fmt"
)

func GenHmacSha256(message string, secret string) string {
 h := hmac.New(sha256.New, []byte(secret))
 h.Write([]byte(message))
 return base64.StdEncoding.EncodeToString(h.Sum(nil))
}

func main() {

 key := "VHc1CBWM0YS204rydm+wWxkQrqJSVyXAAgFRktVpOF4="
 str := "/report/data/device?timestamp=123456789&appKey=9aON8USr&nonce=123456"
 ret := GenHmacSha256(str, key)

 fmt.Printf("ret: %s\n", ret)
}

//RdYq6cvBpeF84HO8iQErRF6Aq9XdE2fDx5w4qjDWfrg=
//RdYq6cvBpeF84HO8iQErRF6Aq9XdE2fDx5w4qjDWfrg=
//6D+MQzWc3eU4eqZkXaUQ4xmeviQPljjzs4CQmF18ldk=
//6D+MQzWc3eU4eqZkXaUQ4xmeviQPljjzs4CQmF18ldk=

httpd2.4不能查看状态

Mon, 01 Jan 0001 00:00:00 +0000

httpd无法apachectl status 直接查看状态，虽然没有大的影响。

但是让人十分不悦。解决方法如下。

1，先加查模块是否存在

[root@jingwangweilai ~]# apachectl -M |grep status
status_module (shared)

2，存在就忽略这一步，不存在去/etc/httpd/httpd.conf把这个模块注释掉去掉

LoadModule status_module modules/mod_status.so

3，添加如下字段

<Location /server-status>
SetHandler server-status
Require host localhost
</Location>

Integer比较

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.intandinteger;


// java 9 以后 此初始化已经标记为废弃，推荐使用 Integer.valueOf("100");
public class IntegerTest {
 public static void main(String[] args) {
 int a = 100;

 Integer b = 100;
 if ( a == b ) {
 //原因是由于此区间的只都是由IntegerCache.cache而来，具体查看Integer.valueOf(n)方法
 //其中IntegerCache.cache static final Integer cache[];
 System.out.println("-128 - 127 之间的int类型是在常量池中, ");
 }


 // 但是 Integer.valueOf("100");
 Integer c = Integer.valueOf("300");
 Integer d = Integer.valueOf("300");
 if ( c != d ) {
 System.out.println("Integer.valueOf(\"100\") 初始化的127以上的数字是放到推空间的");
 }


 Integer e = Integer.valueOf("100");
 Integer f = Integer.valueOf("100");
 if ( e == f ) {
 System.out.println("Integer.valueOf(\"100\") 初始化的127以内的还是从常量池中获取");
 }

 Integer g = Integer.valueOf("400");
 int h = 400;
 if ( g == h ) {
 System.out.println("Integer会向下转型");
 }

 }
}

Java的参数是值传递

Mon, 01 Jan 0001 00:00:00 +0000

class User

package cn.anzhongwei.lean.demo.java传参;

public class User {
 private String name;
 private String Gender;

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public String getGender() {
 return Gender;
 }

 public void setGender(String gender) {
 Gender = gender;
 }
}

package cn.anzhongwei.lean.demo.java传参;

/**
 * 要理解java的传参
 * 结果：
 主类中实例化user1-hash:cn.anzhongwei.demo.java传参.User@4d7e1886
 主类中实例化参数:Name=Hollis
 方法中接受到参数user-hash:cn.anzhongwei.demo.java传参.User@4d7e1886 // 与main函数同一个对象
 方法中重新实例化参数user-hash:cn.anzhongwei.demo.java传参.User@3cd1a2f1 // 产生新对象，但是只在局部有效
 方法中重新实例化参数:Name=hollischuang
 经过方法后的user1-hashcn.anzhongwei.demo.java传参.User@4d7e1886 //user1并没有因为在函数中局部参数实例化而发生变化
 经过方法后的参数xiaoming //实例属性会被函数中的更改而发生变化
 */
public class PassOn {
 public void pass(User user) {
 System.out.println("方法中接受到参数user-hash:"+user);
 user.setName("xiaoming");


 user = new User();
 user.setName("hollischuang");
 System.out.println("方法中重新实例化参数user-hash:"+user);
 System.out.println("方法中重新实例化参数:Name="+user.getName());
 }
 public static void main(String[] args) {
 PassOn pt = new PassOn();

 User user1 = new User();
 System.out.println("主类中实例化user1-hash:"+user1);
 user1.setName("Hollis");
 user1.setGender("Male");
 System.out.println("主类中实例化参数:Name="+user1.getName());
 pt.pass(user1);
 System.out.println("经过方法后的user1-hash" + user1);
 System.out.println("经过方法后的参数" + user1.getName());
 }

}

jquery插件开发

Mon, 01 Jan 0001 00:00:00 +0000

<!DOCTYPE html>
<html lang="en" >
<head>
 <meta charset="utf-8" />
 <title>HTML5 时钟</title>
 <link href="css/main.css" rel="stylesheet" type="text/css" />
 <script src="http://code.jquery.com/jquery-latest.min.js"></script>
 <style>
 .clocks {
 height: 500px;
 margin: 25px auto;
 position: relative;
 width: 500px;
 }
 </style>
</head>
<body>
 <ul>
 <li>
 <a href="http://www.webo.com/liuwayong">我的微博</a>
 </li>
 <li>
 <a href="http://http://www.cnblogs.com/Wayou/">我的博客</a>
 </li>
 <li>
 <a href="http://wayouliu.duapp.com/">我的小站</a>
 </li>
</ul>
<div>
 这是div标签
</div>
</body>
<script>
/*
1.直接扩展jquery 添加方法 sayHello();
*/
// $.extend({
// sayHello: function(name) {
// alert('Hello,' + (name ? name : 'Dude'));
// }
// });
// $.sayHello(); //调用
// $.sayHello('Wayou'); //带参调用


/*
2.在全局空间定义myPlugin
*/
// $.fn.myPlugin = function(options) {
// var defaults = {//定义默认参数
// 'color': 'red',
// 'fontSize': '12px'
// };
// var settings = $.extend({}, defaults, options);//合并用户的options 和默认的defaults到插件空间
// return this.css({//返回方法,利于链式操作
// 'color': settings.color,
// 'fontSize': settings.fontSize
// });
// }
// $(function(){
// $('a').myPlugin({
// 'color': '#2C9929',
// 'fontSize': '36px'
// });
// $('div').myPlugin();
// })


/*
3.在全局空间中定义匿名函数,中定义一个插件
在匿名函数前面加一个";"是一个好的习惯
($, window, document, undefined)匿名函数的参数是为了防止其他人全局屏蔽这几个参数
*/
;(function($, window, document, undefined){
 //定义Beautifier的构造函数
 var Beautifier = function(ele, opt) {
 this.$element = ele,
 this.defaults = {
 'color': 'red',
 'fontSize': '12px',
 'textDecoration':'none'
 },
 this.options = $.extend({}, this.defaults, opt)
 }
 //定义Beautifier的方法
 Beautifier.prototype = {
 beautify: function() {
 return this.$element.css({
 'color': this.options.color,
 'fontSize': this.options.fontSize,
 'textDecoration': this.options.textDecoration
 });
 }
 }
 //在插件中使用Beautifier对象
 $.fn.myPlugin = function(options) {
 //创建Beautifier的实体
 var beautifier = new Beautifier(this, options);
 //调用其方法
 //return beautifier;//用于3.1调用
 return beautifier.beautify();//用于3.2调用
 }
})(jQuery, window, document);
//3.1调用
// $(function() {
// $('a').myPlugin({
// 'color': '#2C9929',
// 'fontSize': '12px'
// }).beautify();
// })
//3.2调用
$(function(){
 $('a').myPlugin({
 'color': '#2C9929',
 'fontSize': '20px',
 'textDecoration': 'underline'
 });
});
</script>
</html>

js获取各种节点的方法

Mon, 01 Jan 0001 00:00:00 +0000

如何获取要更新的元素，是首先要解决的问题。令人欣慰的是，使用JavaScript获取节点的方法有很多种，这里简单做一下总结（以下方法在IE7和Firefox2.0.0.11测试通过）：
1. 通过顶层document节点获取：
 （1） document.getElementById(elementId)：该方法通过节点的ID，可以准确获得需要的元素，是比较简单快捷的方法。如果页面上含有多个相同id的节点，那么只返回第一个节点。
 如今，已经出现了如prototype、Mootools等多个JavaScript库，它们提供了更简便的方法：$(id)，参数仍然是节点的id。这个方法可以看作是document.getElementById()的另外一种写法，不过$()的功能更为强大，具体用法可以参考它们各自的API文档。
 （2）document.getElementsByName(elementName)：该方法是通过节点的name获取节点，从名字可以看出，这个方法返回的不是一个节点元素，而是具有同样名称的节点数组。然后，我们可以通过要获取节点的某个属性来循环判断是否为需要的节点。
 例如：在HTML中checkbox和radio都是通过相同的name属性值，来标识一个组内的元素。如果我们现在要获取被选中的元素，首先获取改组元素，然后循环判断是节点的checked属性值是否为true即可。
 （3）document.getElementsByTagName(tagName)：该方法是通过节点的Tag获取节点，同样该方法也是返回一个数组，例如：document.getElementsByTagName('A')将会返回页面上所有超链接节点。在获取节点之前，一般都是知道节点的类型的，所以使用该方法比较简单。但是缺点也是显而易见，那就是返回的数组可能十分庞大，这样就会浪费很多时间。那么，这个方法是不是就没有用处了呢？当然不是，这个方法和上面的两个不同，它不是document节点的专有方法，还可以应用其他的节点，下面将会提到。
2、通过父节点获取：
 （1）parentObj.firstChild：如果节点为已知节点（parentObj）的第一个子节点就可以使用这个方法。这个属性是可以递归使用的，也就是支持parentObj.firstChild.firstChild.firstChild...的形式，如此就可以获得更深层次的节点。
 （2）parentObj.lastChild：很显然，这个属性是获取已知节点（parentObj）的最后一个子节点。与firstChild一样，它也可以递归使用。
 在使用中，如果我们把二者结合起来，那么将会达到更加令人兴奋的效果，即：parentObj.firstChild.lastChild.lastChild...
 （3）parentObj.childNodes：获取已知节点的子节点数组，然后可以通过循环或者索引找到需要的节点。
 注意：经测试发现，在IE7上获取的是直接子节点的数组，而在Firefox2.0.0.11上获取的是所有子节点即包括子节点的子节点。
 （4）parentObj.children：获取已知节点的直接子节点数组。
 注意：经测试，在IE7上，和childNodes效果一样，而Firefox2.0.0.11不支持。这也是为什么我要使用和其他方法不同样式的原因。因此不建议使用。
 （5）parentObj.getElementsByTagName(tagName)：使用方法不再赘述，它返回已知节点的所有子节点中类型为指定值的子节点数组。例如：parentObj.getElementsByTagName('A')返回已知的子节点中的所有超链接。
3、通过临近节点获取：
 （1）neighbourNode.previousSibling：获取已知节点（neighbourNode）的前一个节点，这个属性和前面的firstChild、lastChild一样都似乎可以递归使用的。
 （2）neighbourNode.nextSibling：获取已知节点（neighbourNode）的下一个节点，同样支持递归。
4、通过子节点获取：
 （1）childNode.parentNode：获取已知节点的父节点。

上面提到的方法，只是一些基本的方法，如果使用了Prototype等JavaScript库，可能还获得其他不同的方法，例如通过节点的class获取等等。不过，如果能够灵活运用上面的各种方法，相信应该可以应付大部分的程序

K8S案例解析

Mon, 01 Jan 0001 00:00:00 +0000

helm的官方网站： https://helm.sh/zh/

helm是一个包管理器，用于Kubernetes，它可以将Helm Chart安装到Kubernetes集群中。Helm Chart是一个可重复使用的软件包，包含所有必需的资源定义，如Deployment、Service、Ingress、Secret、ConfigMap等。

helm相对k8s来说就像 apt 对Ubuntu yum对CentOS一样。

安装直接看官方文档

这里把命令补全的方式： https://helm.sh/zh/docs/helm/helm_completion/

针对bash 环境

https://helm.sh/zh/docs/helm/helm_completion_bash/ 贴出来

为当前会话提供命令补全

source <(helm completion bash)

为每个新的会话加载命令补全（其他系统看文档）

Linux： helm completion bash | sudo tee /etc/bash_completion.d/helm

此处提供一个阿里云开发者中心的文档链接 https://developer.aliyun.com/article/1473220

命令演示

# 添加存储库 我这里添加了多个存储库
 
[root@master01 linux-amd64]# helm repo add stable http://mirror.azure.cn/kubernetes/charts
"stable" has been added to your repositories
 
[root@master01 linux-amd64]# helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
"aliyun" has been added to your repositories
 
# 更新所有仓库
 
[root@master01 linux-amd64]# helm repo update
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "aliyun" chart repository
...Successfully got an update from the "stable" chart repository
Update Complete. ⎈Happy Helming!⎈
 
# 列出所有已配置的Helm仓库
 
[root@master01 linux-amd64]# helm repo list
NAME URL
stable http://mirror.azure.cn/kubernetes/charts
aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
 
 
# 搜索Helm仓库中可部署的Chart列表，Redis 为例
# 显示出了 两个仓库的 Chart 包
 
[root@master01 linux-amd64]# helm search repo redis
NAME CHART VERSION APP VERSION DESCRIPTION
aliyun/redis 1.1.15 4.0.8 Open source, advanced key-value store. It is of...
aliyun/redis-ha 2.0.1 Highly available Redis cluster with multiple se...
stable/prometheus-redis-exporter 3.5.1 1.3.4 DEPRECATED Prometheus exporter for Redis metrics
stable/redis 10.5.7 5.0.7 DEPRECATED Open source, advanced key-value stor...
stable/redis-ha 4.4.6 5.0.6 DEPRECATED - Highly available Kubernetes implem...
aliyun/sensu 0.2.0 Sensu monitoring framework backed by the Redis ...
stable/sensu 0.2.5 0.28 DEPRECATED Sensu monitoring framework backed by...
 
# 删除仓库
helm repo remove aliyun

K8S应用笔记

Mon, 01 Jan 0001 00:00:00 +0000

K8S资源

Namespace（命名空间）：

k8s通过命名空间实现资源隔离，简称为ns

我们在获取任何资源时，如果不明确指定命名空间那么会缺省的使用default命名空间
Pod：

K8s的最小运行单元（不太恰当的比喻，一个pod就详单与用docker启动了一个容器）
Controller(控制器)：

一般来说生产环境都是通过各种Controller来管理pod的生命周期。在控制器中每一个副本都是一个pod 通过控制副本数来控制pod的创建和销毁

常用的Controller有Deployment、DaemonSet、StatefulSet、Job、CronJob

最常用的是 Deployment（无状态应用）
replicas：副本数

Deployment通过replicas属性来指定副本数简称rs
service：不论单独创建的pod 还是通过deployment创建的pod 都是一个在k8s集群中的资源，他们的访问只能通过集群内ip访问，不能通过外网访问所以需要通过service来暴露pod访问

service常用的四种网络
1. ClusterIP：集群内部访问，分配了一个稳定的虚拟ip。
2. NodePort：集群外部访问，会在每个node节点上分配固定的端口（端口范围30000-32767），流量可以从外部转发到service，
3. LoadBalancer：集群外部访问，主要在云环境中使用。他为service创建一个外部的负载均衡器，可以通过云环境的负载均衡器将流量打到service上
4. ExternalName：通过返回一个CNAME记录，可以将服务映射到集群外部的服务。
endpoints（v1 Endpoints is deprecated in v1.33+; use discovery.k8s.io/v1 EndpointSlice）： 1.33以后被弃用
EndpointSlice：用于描述Service的实际访问点。它包含了提供服务的Pod的IP地址和端口信息。

这些信息是Kubernetes实现服务发现和流量分发的关键依据

增（创建）

新增命名空间


kubectl create ns ${nsName}

#新建一个deployment
# 应用名 镜像地址 副本数

创建（运行）一个pod

kubectl run ${podName} --image=${镜像名称}:${镜像tag}

心中一个deployment 应用

kubectl create deployment ${deploymentName} --image=${镜像名称}:${镜像tag} --replicas=${副本数}

创建一个deployment的配置文件

Linux基础

Mon, 01 Jan 0001 00:00:00 +0000

Linux 启动


******************************************************************
1.bios找到磁盘上的mbr主引导扇区
2.进入grub界面选择相应的启动内核
3.读取kernel内核文件-/boot/vmlinuz-*
4.读取init的镜像文件-/boot/initrd-*
5.init去读取/etc/inittab
 设置运行级别 0关机 3字符界面 5图形界面 6重启
6.读取启动级(id:3:initdefault)
7.读取/etc/rc.d/rc.sysinit,
 读取系统主机名 识别加载硬件驱动
 读取selinux防火墙 设置系统字体 
 进入一个简单的小欢迎页面 设置系统时钟 
 设置文件和目录权限 加载映射分区
8.读取/etc/rc.d/rc脚本，通过该脚本吸收3级别，然后启动/etc/rc.d/rc3.d下所有以S开头的服务,不启动该目录下以K开头的服务
9.进入登录界面
*****************************************************************

/***********************************************************************************
一.BIOS 加电自检
 当你按电源开关开机时,电脑会首先去启动BIOS(基本输入输出系统),BIOS一般是集成在主板上的.
 BIOS 的工作
 1.检测连接硬件,比如显卡,内存,磁盘等等,检测的目的是以后把这些设备信息提供给操作系统
 2.寻找启动磁盘,每一种BIOS都会有开机启动菜单,可以在菜单里设置以哪个设备启动系统
 比如:光驱,硬盘,网络等等,这个菜单可以设置多个选项,依照设置次序在设备上寻找启动信息
 3.找到了启动硬盘,接着BIOS就会在磁盘上寻找第一个启动扇区,也就是主引导记录MBR(Master Boot Record)
 但是MBR中,存储操作系统的空间只有446字节;MBR总共是512字节（=stage1）（其中引导程序占446字节+分区表占64字节，每16个字节记录一个分区，标识符占2个字节，以55.aa结尾）
 如果没有在MBR中找到操作系统的内核,那么BIOS就无法继续启动工作.
 而我们的内核往往会大于446个字节,存放在磁盘的其他位置上,既然446装不下内核,又为了能顺利的找到放在其他位置上的内核,人们想出了一个办法就在446字节里写了一个小程序,当BIOS试着启动操作系统时就会执行这个小程序,然后再由小程序来载入位于其他位置的内核.这个小程序就是启动载入器(boot loader)

二.BOOT Loader
 linux的boot loader(上文提到的小程序) 常见的有两种:lilo grub
 因为lilo存在着一个1024柱面的限制,并且更改了磁盘上的启动信息文件后需要重新启动系统才能同步446字节的内容,因为lilo的缺陷,已经被grub所取代.现在的绝大多数类linux系统都采用grub做boot loader;
 grub则没有了lilo各种限制,而且方便到能修改系统文件的启动内容就可以立刻与446内容同步.
 那么我们就看看grub的内容 它存在于 /boot/grub中
 GRUB有几个重要的文件，STAGE1、STAGE1.5、STAGE2
 STAGE1：它只有512字节，通常放在MBR中，它的作用很简单，就是在系统启动时用于装载STAGE2并将控制权交给它。
 STAGE2：GRUB的核心，所有的功能都是由它实现。
 STAGE1.5：介于STAGE1和STAGE2之间，是它们的桥梁，因为STAGE2较大，通常都是放在一个文件系统当中的，但是STAGE1并不能识别文件系统格式，所以才需要STAGE1.5来引导位于某个文件系统当中的STAGE2。根据文件系统格式的不同，STAGE1.5也需要相应的文件，如：e2fs_stage1_5，fat_stage1_5，分别用于识别ext和fat的文件系统格式。它存放于1-63的柱面之间.
 引导顺序如下：STAGE1->;STAGE1.5->;STAGE2，
 主要的配置文件时 grub.conf
 里面选项含义:
 title:一个操作系统引动的标头,可以使多个
 root :指明所需文件存在于哪个磁盘哪个分区上 (hd0,0)表示第一个硬盘,第一个分区
 kernel:内核文件的名字,并且会有一些加载内核时的参数
 initrd:包含一些附加的驱动程序
 _____________________
 #cat /boot/grub/grub.conf grub配置文件
 default=0 默认启动项，选择启动条目第一个为0号
 timeout=5 默认超时时间
 splashimage=(hd0,0)/grub/splash.xpm.gz 登陆时默认图片
 hiddenmenu 隐藏菜单

 title CentOS (2.6.32-220.el6.x86_64) 启动菜单名字
 root (hd0,0) hd0代表第一块硬盘，0代表第一个分区
 kernel /vmlinuz-2.6.32-220.el6.x86_64 内核文件名
 initrd /initramfs-2.6.32-220.el6.x86_64.img 

三.内核启动 
 内核启动后会向bios查询电脑的所有硬件信息,然后自己接手下来管理这些设备,以便提供给linux使用
 内核会试着驱动这些设备,这些设备的驱动一部分包含在内核中,叫做静态驱动,一部分以模块的方式(动态)存放文件系统中,由于此时还未挂载任何文件系统,因此还不能使用文件系统中的模块,这里只能驱动在内核中存在的硬件驱动程序的对应设备.想驱动内核中未包含的硬件驱动就需要加载文件系统.
 
四.启动INIT服务
 顺利的挂载了根文件系统后,就会启动init服务，init内核启动的第一个用户级进程
 内核会按 /sbin/init /etc/init /bin/init 顺序寻找init程序,
 如果找不到则内核报错
 启动init的目的就是为了初始化系统环境,启动了init就证明了内核已经顺利启动,接下来就由init服务来建立linux使用环境
 init做了什么?它会读取 /etc/inittab 文件,根据这个文件的信息来进行初始化工作.
 会执行三个脚本 /etc/rc.d/rc.sysinit /etc/rc.d/rc[0-6]/* /etc/rc.d/rc.local(万能配置文件，系统启动完毕后，最后运行此文件内的命令)
 rc.sysinit 主要的功能用来建立系统的基本环境，比如：
 启动udev selinux子系统
 udev负责产生 /dev中的文件,selinux负责增强系统的安全性
 设定核心参数 sysctl -p 加载 /etc/sysctl.conf
 设定系统时间 将硬件时间设定为系统时间
 加载键盘和交换分区 swapon -a -e
 设置主机名,挂载文件系统,并将根重新挂载为可读写的.
 加载动态驱动模块
 USB设备与RAID & LVM
 
 rc 脚本设置启动级别 linux中有许多不同的启动级别,不同的启动级别会制定不同的服务
 根据指定rc的参数会对应执行 /etc/rc.d/rc[0-6].d/ 中的连接脚本文件 以S开头的则启动，K开头的不随机自启动
 rc.local 前两个脚本都是系统至关重要的脚本,如果我们想在启动过程中放置一些其他程序
 应该使用rc.local脚本中
 三个RC脚本执行完毕后,就会建立虚拟主控制台 执行 /bin/login 就提供了用户登陆界面了
 如果是图形 L5级别的话,会启动X window登录界面
 所有的启动就都已经完毕
 
 初始化/sbin/init
 #vime/etc/inittab 初始化配置文件

 # Default runlevel. The runlevels used by RHS are:
 # 0 - halt (Do NOT set initdefault to this) 关机
 # 1 - Single user mode 单用户模式
 # 2 - Multiuser, without NFS (The same as 3, if you do not have networking) 多用户模式，无网络模式,也就是不能远程登录
 # 3 - Full multiuser mode 全部都用户模式
 # 4 - unused 保留参数
 # 5 - X11 图形界面模式
 # 6 - reboot (Do NOT set initdefault to this) 重起模式
 #
 id:3:initdefault: 定义默认启动级别
#ls /etc/rc.d
 init.d rc0.d rc2.d rc4.d rc6.d rc.sysinit(启动初始化)
 rc rc1.d rc3.d rc5.d rc.local (rc0~6为运行级别脚本，启动或关闭的控制文件,S启动，K关闭，启动或关闭顺序S后面的数字越小、优先级越高)
 
五.登陆，加载用户环境变量
 输入用户名和密码系统验证,然后会执行
 /etc/profile 
 /etc/bashrc
 $HOME/.bash_profile
 $HOME/.bashrc 
查看当前启动级别
 # runlevel
 N 5
 N是上次的级别,5是当前级别 也就是说64机器开机就是5级别
************************************************************************************************/

运行级别

 0表示关机，
 1表示单用户，
 2表示没有网络的命令行级别，
 3命令行级别（大多服务器都用这个级别），
 4为保留级别，
 5为图形化级别，
 6为重启。

Linux知识体系

Mon, 01 Jan 0001 00:00:00 +0000

Map

Mon, 01 Jan 0001 00:00:00 +0000

初始化

// 先声明map
var m1 map[string]string
// 再使用make函数创建一个非nil的map，nil map不能赋值
m1 = make(map[string]string)
// 最后给已声明的map赋值
m1["a"] = "aa"
m1["b"] = "bb"

// 直接创建
m2 := make(map[string]string)
// 然后赋值
m2["a"] = "aa"
m2["b"] = "bb"

// 初始化 + 赋值一体化
m3 := map[string]string{
 "a": "aa",
 "b": "bb",
}

判断key是否存在

if v, ok := m1["a"]; ok {
 fmt.Println(v)
} else {
 fmt.Println("Key Not Found")
}

遍历map

for k, v := range m1 {
 fmt.Println(k, v)
}

删除一个元素

scene := make(map[string]int)

// 准备map数据
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960

delete(scene, "brazil")

for k, v := range scene {
 fmt.Println(k, v)
}
//route 66
//china 960

安全的Map

1. map+锁

type SafeMap struct {
 Data map[string]interface{}
 Lock sync.RWMutex
}
 
func (this *SafeMap) Get(k string) interface{} {
 this.Lock.RLock()
 defer this.Lock.RUnlock()
 if v, exit := this.Data[k]; exit {
 return v
 }
 return nil
}
 
func (this *SafeMap) Set(k string, v interface{}) {
 this.Lock.Lock()
 defer this.Lock.Unlock()
 if this.Data == nil {
 this.Data = make(map[string]interface{})
 }
 this.Data[k] = v
}

2. sync.map

var test sync.Map
 
//设置元素
func set (k,v interface{}){
 test.Store(k,v)
}
 
//获得元素
func get (k interface{}) interface{}{
 tem ,exit := test.Load(k)
 if exit {
 return tem
 }
 return nil
}
 
//传入一个 函数 ，sync.map 会内部迭代 ，运行这个函数
func ranggfunc (funcs func(key, value interface{}) bool) {
 test.Range(funcs)
}
 
//删除元素
func del(key interface{}){
 test.Delete(key)
}

md5编码

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "crypto/md5"
 "fmt"
 "io"
)

func main() {
 str := "abcdefg"

 //方法一
 data := []byte(str)
 has := md5.Sum(data)
 md5str1 := fmt.Sprintf("%x", has) //将[]byte转成16进制

 fmt.Println(md5str1)

 //方法二

 w := md5.New()
 io.WriteString(w, str) //将str写入到w中
 md5str2 := fmt.Sprintf("%x", w.Sum(nil)) //w.Sum(nil)将w的hash转成[]byte格式

 fmt.Println(md5str2)
}

modbustcp-client

Mon, 01 Jan 0001 00:00:00 +0000

go.mod

require (
 github.com/goburrow/modbus v0.1.0
 github.com/goburrow/serial v0.1.0 // indirect
)

package main

import (
 "log"
 "os"
 "time"

 "github.com/goburrow/modbus"
)

func main() {

 handler := modbus.NewTCPClientHandler("localhost:502")
 handler.Timeout = 10 * time.Second
 handler.SlaveId = 0 //SlaveId即modbustcp协议从0开始得第6字节称，在厂家协议中称为RTU地址无效字段，标准协议中如果是0则为广播地址
 handler.Logger = log.New(os.Stdout, "test: ", log.LstdFlags)
 // Connect manually so that multiple requests are handled in one connection session
 err := handler.Connect()
 if err != nil {
 log.Fatalf("连接错误：%+v", err)
 }
 defer handler.Close()

 // modbus.Tc
 // modbus.NewClient(handler)
 client := modbus.NewClient(handler)
 log.Printf("客户端：%+v", client)
 client.ReadHoldingRegisters(40001, 10)

 res, e1 := client.ReadHoldingRegisters(40001, 2)
 if e1 != nil {
 log.Fatalf("E1错误：%+v", e1)
 }
 log.Printf("资源内容1：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容2：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容3：%+v", res)
 res, _ = client.ReadHoldingRegisters(40000, 3)
 log.Printf("资源内容4：%+v", res)

 results1, err := client.ReadDiscreteInputs(15, 2)
 results2, err = client.WriteMultipleRegisters(1, 2, []byte{0, 3, 0, 4})

}

mybatisSql语句拼装

Mon, 01 Jan 0001 00:00:00 +0000

MySQL通用

Mon, 01 Jan 0001 00:00:00 +0000

MySQL基础

字段名称，数据类型，类型修饰（限制）
 字符
 CHAR(n)
 VARCHAR(n)
 BINARY(n)
 VARBINARY(n)
 TEXT(n)
 BLOB(n)
 数值
 精确数值
 整型
 TINYINT
 SMALLINT
 MEDIUMINT
 INT
 BIGINT
 
 修饰符：UNSIGNED，无符号
 NOT NULL
 十进制
 DECIMAL
 近似数值
 浮点型
 FLOAT
 DOUBLE
 日期时间
 DATE
 TIME
 DATETIME
 STAMP
 布尔
 内置：ENUM， SET

字段约束：限制
primary key 主键约束
foreign key 外键约束
not null 非空约束
null 空约束
check 检查约束
unique 唯一约束
default 默认值约束
auto_increment 自增长约束

drop、delete区别：
drop：删除库、删除表、删除字段
delete：

alter、update区别：
alter：修改表
update：修改记录

存储引擎(表的类型)
存储引擎分类
1、ISAM：查询速度快、支持全文索引、
 不支持事务、不支持外键、不支持check约束
2、MyISAM：ISAM升级版
3、HEAP：速度快、数据驻留在内存
 数据管理不稳定、计算机断电后所有数据全部丢失
4、InnoDB：速度较慢、支持事务、支持check约束、支持外键
 不支持全文索引

常用的存储引擎：InnoDB、MyISAM
网站必须使用全文索引：MyISAM(大型网站)
不用非得使用全文索引：InnoDB(中小型网站)

数据库优化：修改数据库、表提高数据库运行效率
1、选择最合适的字段类型
 char、varchar区别
 字段的数据类型能用数字，就不用字符串
2、尽可能不使用子查询
 1)用内连接代替子查询
 2)子查询充当字段、delete语句出现子查询。只能用子查询
3、like查询尽可能用右侧%
 1) like 'a%'
4、事务、保持数据的完整
 1)避免数据库中出现大量的垃圾数据
5、尽可能的使用InnoDB引擎
 1)事务：保持数据的完整性
 2)外键：在业务层保证外键
6、给字段适当的添加索引
 1)提高表的查询速度
7、每个表最好都有主键、而且主键还是数字类型
 1)主键本身就是一个主键索引
8、避免数据库中出现NULL值
 1)数据库对NULL值做了特殊处理
9、尽可能让相同类型的字段做比较
 1)避免出现数据类型的转换
10、数据库设计是否合理
11、拆分表
12、主从数据库
13、负载均衡
14、服务器的硬件对数据库的影响

基础配置my.ini配置文件(/etc/my.cnf)

1、设置mysql端口号
 port=3306
2、设置mysql编码
 default-character-set=utf8
3、设置mysql的存储引擎
 default-storage-engine=INNODB
4、设置mysql最大连接数
 max_connections=100
5、设置数据库默认的存储引擎
default-storage-engine=MyISAM

控制台基础命令

# 登录 （在shell中执行）
mysql -h 主机地址 -u 用户名 -p密码

# 显示当前mysql版本和当前日期 
select version(),current_date; 

# 导出数据 （在shell中执行）
mysqldump -u 用户名 -p 数据库名 > FILE.sql
mysqldump -u 用户名 -p 数据库名 表名> 导出的文件名

导出一个数据库结构 
　　mysqldump -u wcnc -p -d -add-drop-table smgp_apps_wcnc >d:wcnc_db.sql 
　　-d 没有数据 -add-drop-table 在每个create语句之前增加一个drop table 
导出多个数据库
[root@localhost ~]# mysqldump -uroot -p -P3306 --databases course test > course.sql

导出所有数据库
[root@localhost ~]# mysqldump -uroot -p -P3306 --all-databases > all.sql

仅导出course数据库的数据，不包括表结构
[root@localhost ~]# mysqldump -uroot -p -P3306 --no-create-info course > course.sql

仅导出course数据库中的students和students_myisam两个表
[root@localhost ~]# mysqldump -uroot -p -P3306 --no-create-info course students students_myisam > students.sql

仅导出course数据库的表结构
[root@localhost ~]# mysqldump -uroot -p -P3306 --no-data course > course.sql

导出course数据库中除了teacher和score两个表的其他表结构和数据
[root@localhost ~]# mysqldump -uroot -p -P3306 --ignore-table=course.teacher --ignore-table=course.score course > course.sql

导出course数据库的表和存储过程和触发器
[root@localhost ~]# mysqldump -uroot -p -P3306 --routines --triggers course > course.sql

导出course数据库中符合条件的数据
[root@localhost ~]# mysqldump -uroot -p -P3306 --where="sid in (1,2)" course students students_myisam > course.sql


在主库备份
[root@codis-178 ~]# mysqldump -uroot -p -P3306 --master-data=2 --single-transctions course > course.sql
（在备份开始之初，在所有表上加一个只读锁（flush table with read lock），当成功获取该锁并开始备份之后，此锁就会立即释放，后续dump过程不会影响其他的读写操作）

在从库备份
[root@codis-178 ~]# mysqldump -uroot -p -P3306 --dump-slave --single-transctions test > test.sql

# 导入数据 （在shell中执行） 
mysqldump -uUSER -p DATABASE < FILE.sql
mysql -u username -p -D dbname < filename.sql 
mysql>source wcnc_db.sql 

# 显示所有库 
show databases;

查看当前使用的数据库 
mysql> select database(); 

# 使用库 
use 库名;

# 查看当前库中所有表 
show tables;

# 查看表结构
desc 表名;
describe tablename;

# 显示当前mysql数据库所有的编码信息
show variables like 'character%';

# 查看表的存储引擎
use information_schema;
select table_schema,table_name,engine from tables;
select table_schema,table_name,engine from tables
 where table_name='表名';
show create table 表名;

# mysql 新设置用户或更改密码后需用`flush privileges;`刷新MySQL的系统权限相关表，否则会出现拒绝访问，还有一种方法，就是重新启动mysql服务器，来使新设置生效。


# 命令行交互模式的一些控制命令 尤其是用windows的命令行连接数据库时很有用。不过说实话现在谁还用命令行连数据库呢
# mysql客户端窗口的编码
character_set_client utf8
# 连接数据库的编码
character_set_connection utf8
# 数据库的编码
character_set_database utf8
# 数据库的文件是哪种类型
character_set_filesystem binary
# 结果集的编码
character_set_results utf8
# mysql服务编码
character_set_server utf8
# mysql系统编码
character_set_system utf8
# mysql编码文件存储位置
character_sets_dir C:\Program Files\MySQL\MySQL Server 5.0\sharets
# 设置客户端编码
set names gbk;

数据库操作

create database name; 创建数据库 



drop database name 直接删除数据库，不提醒 
mysqladmin drop databasename 删除数据库前，有提示。

表操作和字段操作

create table 表名
(
 字段名 数据类型 约束,
 字段名 数据类型 约束,
 字段名 数据类型 约束
)engine=存储引擎名;

修改表结构
1、修改表名
alter table 原名 rename to 新名;
2、添加字段
alter table 表名 add column 字段名 数据类型 约束;
alter table 表名 add 字段名 数据类型 约束;//使用这个即可
3、删除字段
alter table 表名 drop column 字段名;
alter table 表名 drop 字段名;//用这个即可
4、修改字段
alter table 表名 change 原字段名 新字段名 数据类型 约束;
alter table 表名 change userName userName varchar(20) not null;

切换clumon 顺序到最前 
ALTER TABLE INFO MODIFY STAT TINYINT(4) FIRST;

切换到某clumon 后面 
ALTER TABLE 表名 MODIFY clumonname AFTER clumonname;

复制表
1、整表复制(表结构、数据)
create table 新表 select * from 原表;
create table bbsInfo2 select * from bbsInfo;
create table bbsInfo2 select bbsId,clickTimes,bbsTime from bbsInfo;
2、复制表结构(表结构)
create table 新表 like 原表;
create table bbsInfo2 like bbsInfo;

索引操作

索引index
作用：提升数据库查询语句的速度
适合添加索引的字段：经常充当where条件的字段

索引的分类
1、主键索引：字段必须是主键、一张表最多只能有一个主键索引
2、普通索引：对字段没限制
3、唯一索引：字段里不能出现重复值
4、全文索引：对字段也没限制(建议：添加到中文字段)


各种索引适合添加到什么样字段
主键索引：主键
唯一索引：该字段没有重复值
全文索引：中文字段
普通索引：任意字段


创建索引的语法格式
1、主键索引
建表的同时指定主键
2、普通索引
create index 索引名 on 表名(字段名);
3、唯一索引
建表的同时指定唯一约束
create unique index 索引名 on 表名(字段名);
4、全文索引
create fulltext index 索引名 on 表名(字段名);

删除索引
drop index 索引名 on 表名;

索引的例子
1、普通索引
create index bbs_index on bbsInfo(title);
drop index bbs_index on bbsInfo;
2、唯一索引
create unique index bbs_index on bbsInfo(title);
drop index bbs_index on bbsInfo;
3、全文索引
create fulltext index bbs_index on bbsInfo(title);
drop index bbs_index on bbsInfo;

全文索引的例子
create table helloInfo
(
 helloId int auto_increment primary key,
 title varchar(100) not null,
 content text not null,
 helloTime timestamp default current_timestamp
)engine=MyISAM;

create fulltext index hello_index on helloInfo(title);
create fulltext index hello_c_index on helloInfo(content);
drop index hello_c_index on helloInfo;

索引注意：
1、经常充当where条件的字段必须要添加索引
2、全文索引对表的类型的限制
3、什么样的字段适合添加什么类型的索引
4、提升表的查询语句的速度
5、索引不是由用户来调用，而是执行查询时，自动提升查询速度
6、一个字段最多只能有一个索引
 一张表可以有多个索引，但是索引不能同名

索引总结：
1、作用
2、分类
3、索引对字段的限制
4、什么样的字段适合添加什么样的索引
5、创建
6、删除索引

视图操作

创建视图语法格式
create view 视图名
as
select查询语句;
例子
create view myview
as
select claId,claName,schName from classInfo,schoolInfo;

create view bbsInfoView
as
select * from bbsInfo;


查看现存的所有视图
1、利用查看表的语句
show tables;
2、通过information_schema库--->views表 查看
select table_schema,table_name from views;
select table_schema,table_name from information_schema.views;

删除视图
1、删除库(视图所在的库)
drop database 库名;
2、删除视图
drop view 视图名;


修改视图
alter view 视图名
as
select语句;
例子
alter view myview
as
select claId,claName,schName from classInfo a,schoolInfo b
 where a.schId=b.schId;


使用视图：把视图当表用
select * from 视图名;
例子
select * from myview;
select * from myview where claId=3;
select * from myview limit 0,2;
select * from myview order by claId;


使用视图的场合
1、一个多表查询语句在网站开发中使用的次数超3次
2、一个多表查询语句，添加分页功能

视图注意：
1、视图中只能存放select查询语句
2、把视图当表用
3、视图可以执行insert、update、delete操作
 建议不要对视图执行insert、update、delete操作

视图总结：
1、视图作用
2、创建视图
3、查看视图
4、修改视图
5、使用视图
6、使用视图的场合

数据操作

增


添加记录
insert into 表名(字段,字段,字段...)values(值,值,值...);
insert into 表名 values(值,值,值...);//所有字段都要添加

复制数据到新表
1、假设两个表的表结构完全一样
insert into 新表 select * from 原表;
insert into bbsInfo2 select * from bbsInfo;
2、假设两个表的表结构不一样
insert into 新表(字段,字段...) select 字段,字段... from 原表;
insert into bbsInfo2 select bbsId,clickTimes,bbsTime from bbsInfo;

删

delete from 表名 where 条件;

# delete： 慢 可恢复 支持事务 不恢复id
# truncate： 快 不可恢复 不支持事务 恢复id
# 清空表
delete from 表名;//支持事务,进入日志文件

# 截段表
truncate table 表名;//不支持事务

改

update 表名 set 字段=值,字段=值... where 条件;
update 表名 set 字段=值,字段=值...;

查

运算符
逻辑运算符：and or not
比较运算符：< <= > >= = != <>

普通查询
select * from 表名;
select 字段,字段... from 表名;
//查询语句查询出来的结果：结果集、临时表


去掉重复值的查询
select distinct 字段,字段 from 表名;

条件查询
select * from 表名 where 条件;
select 字段... from 表名 where 条件;

排序
select * from 表名 order by 字段; #升序
select * from 表名 order by 字段 desc; #降序
select * from 表名 order by 字段,字段;
select * from 表名 order by 字段 desc,字段 desc;
select * from 表名 where 条件 order by 字段;

聚合函数(聚合查询)：统计查询
聚集函数 意义 
　　SUM ( ) 求和 
　　AVG ( ) 平均值 
　　COUNT ( ) 表达式中记录的数目 
　　COUNT (* ) 计算记录的数目 
　　MAX 最大值 
　　MIN 最小值 
　　VAR 方差 
　　STDEV 标准误差 
　　FIRST 第一个值 
　　LAST 最后一个值 
个数统计
select count(*) from 表名;
select count(字段) from 表名;
总和统计
select sum(字段) from 表名;
平均数统计
select avg(字段) from 表名;
最大值统计
select max(字段) from 表名;
最小值统计
select min(字段) from 表名;
一个语句包含多个聚合函数
select sum(字段),max(字段) from 表名;
注意：除了count以外,所有的聚合函数中的字段必须为数字类型

给字段起别名
select 字段 as 别名 from 表名;
select 字段,字段 as 别名,字段 from 表名;
select 聚合函数(字段) as 别名 from 表名;

给表起别名
select * from 表 as 别名;
select * from 表 别名;

分组
1、查看某一字段有多少个不同的值
select 字段1 from 表名 group by 字段1;
select 聚合函数(字段1) from 表名 group by 字段2;

分页
select * from 表名 limit 起始值,条数;
select * from 表名 where 条件 order by 字段 limit 起始值,条数;


模糊查询(站内搜索)
%：任意长度的任意字符串
_：任意一个字符
使用 \_ 代表 _ (如果要查询的字符是下划线的话) 除了可以转移_ 还可以转义 \0 \' \" \b(退格) \n(换行) \r(回车) \t(tab) \\ \%
select * from 表名 where 字段 like '%_内容';
select * from 表名 where 字段 like '%_内容' and|or 条件;
select * from 表名 where 字段 like '%_内容' order by 字段;
select * from 表名 where 字段 like '%_内容' limit 起始值,条数;

select * from 表名 where userName like '张%';
select * from 表名 where userName like '张_';
select * from 表名 where userName like '%三%';


多表查询
1、内连接：将多张表的字段合为一张表
查询两张表
select * from 表1 inner join 表2 on 关联的字段相等;
查询多张表
select * from 表1 inner join 表2 on 关联的字段相等
 inner join 表3 on 关联的字段相等
 inner join 表4 on 关联的字段相等
内连接另一种使用方式
select * from 表1,表2,表3... where 关联的字段相等;//使用这个比较方便

2、外连接：将多张表的字段合为一张表
左外连接：左表为主、右表为副//以left|right outer join为分界线分左表右表
select * from 表1 left outer join 表2 on 关联的字段相等;
右外连接：右表为主、左表为副
select * from 表1 right outer join 表2 on 关联的字段相等;

3、子查询(嵌套查询)：在一个sql语句中包含另一个查询语句
在查询语句的条件中出现了另一个查询语句
select * from 表1
 where 字段 in (select 字段 from 表2 where 条件);
在删除语句的条件中出现了另一个查询语句
delete from 表1
 where 字段 in (select 字段 from 表2 where 条件);
在修改语句的条件中出现了另一个查询语句
update 表1 set 字段=值,字段=值...
 where 字段 in (select 字段 from 表2 where 条件);
在查询语句的*位置出现了另一个查询语句
select 字段,字段,(select 字段 from 表2 where 条件) as 别名 from 表1;

4、联合查询union：将多张表的记录合为一张表//短期内用不到大型网站使用
将多张表的记录合为一张表，去掉了重复记录
select * from 表1 union select * from 表2;
将多张表的记录合为一张表，不去掉重复记录
select * from 表1 union all select * from 表2;

例：在'WA'地区的雇员表中按头衔分组后，找出具有同等头衔的雇员数目大于1人 group by Title having Count(Title)>1
　　的所有头衔。 
　　Select Title ,Count(Title) as Total 
　　FROM Employees 
　　Where Region = 'WA' 
　　GROUP BY Title 
　　HAVING Count(Title)>1

//做例子要用

学院表
create table schoolInfo
(
 schId int auto_increment primary key,
 schName varchar(100) not null
);
insert into schoolInfo(schName)values('理工学院');
insert into schoolInfo(schName)values('自动化学院');
insert into schoolInfo(schName)values('网络学院');
#班级表
create table classInfo
(
 claId int auto_increment primary key,
 schId int,
 claName varchar(100) not null,
 foreign key (schId) references schoolInfo(schId)
);
insert into classInfo(schId,claName)values(1,'php1401');
insert into classInfo(schId,claName)values(3,'php1402');
insert into classInfo(schId,claName)values(2,'php1403');
insert into classInfo(schId,claName)values(3,'php1404');
#学生表
create table student
(
 stuId int auto_increment primary key,
 claId int,
 stuName varchar(20) not null,
 foreign key (claId) references classInfo(claId)
);
insert into student(claId,stuName)values(1,'张三');
insert into student(claId,stuName)values(2,'李四');
insert into student(claId,stuName)values(3,'王五');
insert into student(claId,stuName)values(4,'赵六');
insert into student(claId,stuName)values(3,'田七');
insert into student(claId,stuName)values(3,'张大三');
insert into student(claId,stuName)values(2,'李小五');

触发器Trigger：数据库中的事件

触发器Trigger：数据库里的事件
作用：当用户对表进行insert、update、delete同时，是否要执行其他的操作

触发器的调用：
当用户对表进行insert、update、delete操作时，由系统自动调用

触发器的类型：insert、update、delete

触发器执行的时间：before、after

创建触发器
delimiter // #修改mysql定界符
drop trigger if exists 触发器名// #如果该触发器己经存，删除
create trigger 触发器名
before|after insert|update|delete
on 表名
for each row
begin
 sql语句; #注意：begin和end之间，不能出现无意义的查询语句
 sql语句;
 sql语句;
end //
delimiter ;//将mysql定界符改回系统默认

删除触发器
1、删除触发器所在的库
drop database 库名;
2、删除触发器所在的表
drop table 表名;
3、删除触发器
drop trigger 触发器名;

触发器注意：
1、触发器是由系统自动调用
2、触发器中不能出现无意义的查询语句
3、触发器没有参数

触发器总结
1、触发器作用
2、触发器的执行时间
3、触发器的类型
4、一张表最多能添加三个触发器
5、创建
6、删除
7、查看现存的所有触发器

查看现存的所有触发器
information_schema库--->triggers表
trigger_schema：库名
trigger_name：触发器名
EVENT_MANIPULATION：触发器类型
event_object_table：表名
select trigger_schema,trigger_name,EVENT_MANIPULATION,event_object_table from triggers;
select trigger_schema,trigger_name,EVENT_MANIPULATION,event_object_table from information_schema.triggers;

触发器例子
create table userInfo
(
 userName varchar(20) primary key,
 password varchar(20) not null,
 sex char(3) check(sex='男' or sex='女')
);
create table newsInfo
(
 newsId int auto_increment primary key,
 title varchar(100) not null,
 newsTime timestamp default current_timestamp
);
#统计信息表
create table msgInfo
(
 userCount int default 0,
 newsCount int default 0
);
insert into msgInfo values(0,0);

#给userInfo表添加一个insert触发器
delimiter //
drop trigger if exists addUserTrigger//
create trigger addUserTrigger
after insert
on userInfo
for each row
begin
 #将msgInfo表的userCount字段值加一
 update msgInfo set userCount=userCount+1;
end //
delimiter ;

#给userInfo添加一个delete触发器
delimiter //
drop trigger if exists delUserTrigger//
create trigger delUserTrigger
after delete
on userInfo
for each row
begin
 update msgInfo set userCount=userCount-1;
end //
delimiter ;


insert into userInfo values('张三','123456','男');
insert into userInfo values('李四','123456','女');
delete from userInfo where userName='张三';

触发器注意：
1、触发器依赖于表
2、触发器类型：insert、update、delete
3、在触发器中不能出现无意义的查询语句
4、一个触发器只能监听一个表的一个操作
5、触发器由系统自动调用
6、触发器不能传参


触发器总结：
1、触发器作用、原理
2、触发器类型
3、触发器的执行时间
4、创建触发器
5、删除触发器
6、查看现存的所有触发器
7、触发器使用场合

存储过程Procedure：数据库中的自定义函数

创建存储过程
delimiter //
drop procedure if exists 存储过程名//
create procedure 存储过程名()
begin
 sql语句;
 sql语句;
 sql语句;
end //
delimiter ;

删除存储过程
1、删除库
drop database 存储过程所在的库名;
2、删除存储过程
drop procedure 存储过程名;

查看现存的所有存储过程
mysql库--->proc表
select db,name from proc;
select db,name from mysql.proc;

调用存储过程
call 存储过程名();
call 存储过程名(值,值,值...);
call 存储过程名(值,值,@变量名,@变量名,@变量名);
select @变量名,@变量名...;

使用存储过程的场合: 操纵数据库时要执行多个sql语句

存储过程注意：
1、一次编写多次调用
2、参数：输入参数、输出参数
3、调用存储过程

存储过程总结：
1、作用
2、创建
3、删除
4、调用
5、参数

类拟于数据库中的输出语句
select '你好' as msg;
select 30 as age;
select current_timestamp as time;

例子：
delimiter //
drop procedure if exists hello//
create procedure hello()
begin
 select current_timestamp as time;
end //
delimiter ;

call hello();

触发器(Trigger)与存储过程(Procedure)的区别

不同点 1、触发器由系统自动调用，存储过程必须由用户通过call来调用 2、触发器没有参数、存储过程可以有参数(输入、输出) 3、触发器依赖表、存储过程依赖于库相同点 1、一次编写多次调用 2、都可以实现T-SQL编程

netplan

Mon, 01 Jan 0001 00:00:00 +0000

在 Ubuntu20.04 版本中使用 netplan 管理网络
在安装好的 Ubuntu20.04 中没有 networking 和 NetworkManage 服务
netplan 配置文件：/etc/netplan/*.yaml ，文件名每个不一样
netplan 说明文件: /usr/share/doc/netplan/example/ 目录下，在该目录下有各种样例文件，可以提供帮助

Netty实战

Mon, 01 Jan 0001 00:00:00 +0000

代码地址

案例一 TCP服务端

要求1: 在客户端连接后打印客户端端的ip和端口号

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class DemoNetty101 {
 public static void main(String[] args) {
 DemoNetty101 demoNetty101 = new DemoNetty101();
 demoNetty101.startTCP();
 }

 private void startTCP() {
 // 一个监听工作组，在很多写法中叫做master组
 EventLoopGroup bossGroup = new NioEventLoopGroup();
 // 一个工作监听组，在很多写法中交child组
 EventLoopGroup workerGroup = new NioEventLoopGroup();
 try {
 ServerBootstrap server = new ServerBootstrap();
 server.group(bossGroup, workerGroup)
 // 设置非阻塞模式
 .channel(NioServerSocketChannel.class) 
 // 添加自定义处理器
 .childHandler(new TCPServerInitializer());
 ChannelFuture f = server.bind(8088).sync();
 System.out.println("Http Server started， Listening on " + 8088);
 f.channel().closeFuture().sync();
 } catch (Exception e) {
 e.printStackTrace();
 } finally {
 bossGroup.shutdownGracefully();
 workerGroup.shutdownGracefully();
 }

 }
}

import io.netty.channel.ChannelInitializer;
import io.netty.channel.socket.SocketChannel;

public class TCPServerInitializer extends ChannelInitializer<SocketChannel> {
 @Override
 protected void initChannel(SocketChannel socketChannel) throws Exception {
 System.out.println("初始化连接成功");
 System.out.println(socketChannel.remoteAddress().getHostString()+":"+socketChannel.remoteAddress().getPort());
 }
}

案例二 TCP服务端

要求1: 在客户端连接后打印客户端端的ip和端口号要求2：能打印出客户端发送的内容

opc-client

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "fmt"

 "github.com/konimarti/opc"
)

func main() {
 client, _ := opc.NewConnection(
 "Matrikon.OPC.Simulation.1", // ProgId
 []string{"localhost"}, // OPC servers nodes
 []string{"Random.Real8", "Random.String"}, // slice of OPC tags
 )
 defer client.Close()

 // read single tag: value, quality, timestamp
 fmt.Println(client.ReadItem("Random.Real8"))

 // read all added tags
 fmt.Println(client.Read())
}

Optional

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.optional;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Optional;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
 private String name;
 private Integer age;
 private Address address;

 public Person(String name, Integer age) {
 this.name = name;
 this.age = age;
 }

 public Optional<String> optionalGetName() {
 return Optional.ofNullable(this.name);
 }
}

package cn.anzhongwei.lean.demo.optional;

import lombok.Data;

@Data
public class Address {
 private String city;
 private String addInfo;
}

package cn.anzhongwei.lean.demo.optional;

import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class OptionalTest {

 /**
 * Optional(T value),empty(),of(T value),ofNullable(T value)
 * Optional(T value) 是private的属于内部方法
 */
 @Test
 public void test1() {
 //of(T value) 是实际上调用了Optional(T value) 而其内部的requireNonNull方法源码中判断value==null时会抛出空指针异常
 //在开发中如果不想隐藏空指针异常时 使用of函数， 不过这种情况几乎不用
 //Optional<Person> p1 = Optional.of(null);

 //所以如果要创建一个value为null的Optional对象则应该使用 empty()
 Optional<Person> pnull = Optional.empty();
 //而ofNullable(T value) 则是一个三元表达式 return value == null ? empty() : of(value);
 Optional<Person> p0 = Optional.ofNullable(null);
 Optional<Person> p1 = Optional.ofNullable(new Person("zhangs", 20));
 }

 /**
 * orElse(T other)，orElseGet(Supplier other)和orElseThrow(Supplier exceptionSupplier)
 * 这三个函数放一组进行记忆，都是在构造函数传入的value值为null时，进行调用的。
 * orElse 和 orElseGet 没区别 可以认为时完全一样的代码
 *
 * orElseThrow 则会当value为空时抛出一个自定义异常
 */
 @Test
 public void test2() {
 Person p = null;
 //当p值不为null时，orElse函数依然会执行createUser()方法
 p = Optional.ofNullable(p).orElse(new Person("zhangsan", 20));
 System.out.println("调用orElse 当p为null时:"+p);
 //而当p不为空，则相当于使用get()方法
 p = Optional.ofNullable(p).orElse(new Person("王五", 60));
 System.out.println("调用orElse 此时p不为null时:"+p);
 //
 p = null;
 //重新赋值p=null
 System.out.println("重新赋值p=:"+p);
 p = Optional.ofNullable(p).orElseGet(() -> new Person("lisi", 30));
 System.out.println("orElseGet 当p为null时:"+p);
 p = Optional.ofNullable(p).orElseGet(() -> new Person("zhaoliu", 34));
 System.out.println("orElseGet 此时p不为null时:"+p);


 }
 @Test
 public void testOrElseThrow() {
 Person p = new Person("lisi", 30);
 p = Optional.ofNullable(p).orElseThrow(()-> new RuntimeException("用户不存在"));
 System.out.println("orElseThrow 此时p不为null时:"+p);
 p = null;
 p = Optional.ofNullable(p).orElseThrow(()-> new RuntimeException("用户不存在"));
 }

 /**
 * map(Function mapper)和flatMap(Function> mapper)
 * 这两个函数做的是转换值的操作
 */
 @Test
 public void test3() {
 Person p = new Person("lisi", 30);
 String name = Optional.ofNullable(p).map( person -> person.getName()).get();
 System.out.println("name="+name);

 String optionalName = Optional.ofNullable(p).flatMap(person -> person.optionalGetName()).get();
 System.out.println("optionalName="+optionalName);
 }

 /**
 * isPresent()和ifPresent(Consumer consumer)
 * isPresent即判断value值是否为空，而ifPresent就是在value值不为空时，做一些操作。
 */
 @Test
 public void test4() {
 Person p = null;
 Optional.ofNullable(p).ifPresent(person -> {

 });
 }

 /**
 * filter(Predicate predicate)
 */
 @Test
 public void test5() {
 Person p = null;
 //如果 p.name 长度小于6则返回， 否则返回EMPTY
 Optional<Person> p1 = Optional.ofNullable(p).filter(u -> u.getName().length()<6);
 }

 /**
 * 实战写法1
 */
 public String getCity(Person person) throws Exception{
 if(person!=null){
 if(person.getAddress()!=null){
 Address address = person.getAddress();
 if(address.getCity()!=null){
 return address.getCity();
 }
 }
 }
 throw new RuntimeException("取值错误");
 }
 public String getCity2(Person person) throws Exception{
 return Optional.ofNullable(person)
 .map(u-> u.getAddress())
 .map(a->a.getCity())
 .orElseThrow(()->new Exception("取值错误"));
 }

 /**
 * 实战写法2
 */
 public void dosomething(Person person) {
 if (Objects.nonNull(person)) {
 //......
 }
 Optional.ofNullable(person).ifPresent(person1 -> {
 //......
 });
 }

 /**
 * 实战写法3
 */
 public Person getUser1(Person user){
 if(user!=null){
 String name = user.getName();
 if(!"zhangsan".equals(name)){
 user = new Person();
 user.setName("zhangsan");
 }
 }else{
 user = new Person();
 user.setName("zhangsan");
 }
 return user;
 }
 public Person getUser2(Person user) {
 return Optional.ofNullable(user)
 .filter(u->"zhangsan".equals(u.getName()))
 .orElseGet(()-> {
 Person user1 = new Person();
 user1.setName("zhangsan");
 return user1;
 });
 }



 public Person getUser3(Person user){
 if(user!=null){
 String name = user.getName();
 if(!"zhangsan".equals(name)){
 user.setName("zhangsan");
 }
 }else{
 user = new Person();
 user.setName("zhangsan");
 }
 return user;
 }
 public Person getUser4(Person user) {
 //这个逻辑一般来说不会这么写， 大多数情况下都是不为空且不为zhangsan时， 将name赋值成zhangsan，而不是重新实例化
 return Optional.ofNullable(user)
 .filter(u->"zhangsan".equals(u.getName()))
 .orElseGet(()-> {
 if (Objects.nonNull(user)) {
 user.setName("zhangsan");
 return user;
 } else {
 Person user1 = new Person();
 user1.setName("zhangsan");
 return user1;
 }


 });
 }
 @Test
 public void test6() {
 //getUser1 和 getUser2 只要name不等于 zhangsan， 就重新初始化
 Person p = new Person("wangwu", 26);
 Person p1 = getUser1(p);
 System.out.println("p1:"+p1);

 p = new Person("lisi", 23);
 Person p2 = getUser2(p);
 System.out.println("p2:"+p2);

 //getUser3 和 getUser4 name不等于 zhangsan， 只改变name=张三， 其他内容不变
 p = new Person("zhaosi", 26);
 Person p3 = getUser3(p);
 System.out.println("p3:"+p3);

 p = new Person("liuqi", 26);
 Person p4 = getUser4(p);
 System.out.println("p4:"+p4);
 }


 @Test
 public void test7() {
 List<Person> personList = new ArrayList<>();
 Person p1 = new Person("zhangsan", 22);personList.add(p1);
 Person p2 = new Person("zhaosi", 29);personList.add(p2);
 Person p3 = new Person("wangwu", 22);personList.add(p3);
 Person p4 = new Person("lisen", 35);personList.add(p4);
 Person p5 = new Person("liuming", 248);personList.add(p5);

 Optional<Person> personOptional = personList.stream().filter(p -> p.getAge() > 22).findFirst();
 Person pp1 = personOptional.orElseGet(() -> personList.get(0));
 System.out.println(pp1);
 Person pp2 = personOptional.orElse(null);
 System.out.println(pp2);

 List<Person> personList2 = Optional.ofNullable(personList).orElseGet(ArrayList::new);
 System.out.println(personList2);

 Map<String, List<Person>> pMap = new HashMap<>();
// List<Person> personList3 = Optional.ofNullable(pMap.get("随便写"))
// //这种写法主要为了后面stream()的流式处理方式不会有空指针
// //这样会空指针
// .get()
// .stream().collect(Collectors.toList());
// System.out.println(personList3);

 List<Person> personList4 = Optional.ofNullable(pMap.get("随便写"))
 //这种写法主要为了后面stream()的流式处理方式不会有空指针
 .orElseGet(ArrayList::new)
 .stream().collect(Collectors.toList());
 System.out.println(personList4);
 }


}

PDF转图片

Mon, 01 Jan 0001 00:00:00 +0000

package cn.anzhongwei.lean.demo.pdftoimg;

import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.ImageType;
import org.apache.pdfbox.rendering.PDFRenderer;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class PdfUtil {
 public static void main(String[] args) {
 String source = "C:\\Home\\22.pdf";
 String desFileName = "invoice";
 String desFilePath = "C:\\Home\\ddd";
 String imageType = "png";
 Long t1 = System.currentTimeMillis();
 List<String> pair = PdfUtil.pdfToImg(source, desFilePath, desFileName, imageType);
 Long t2 = System.currentTimeMillis();
 System.out.println(t2-t1);
 pair.forEach(System.out::println);


 }

 public static List<String> pdfToImg(String source, String desFilePath, String desFileName, String imageType) {
 //通过给定的源路径名字符串创建一个File实例
 File file = new File(source);
 if (!file.exists()) {
 throw new RuntimeException("文件不存在，无法转化");
 }
 //目录不存在则创建目录
 File destination = new File(desFilePath);
 if (!destination.exists()) {
 boolean flag = destination.mkdirs();
 System.out.println("创建文件夹结果：" + flag);
 }
 PDDocument doc = null;
 try {
 //加载PDF文件
 doc = PDDocument.load(file);
 PDFRenderer renderer = new PDFRenderer(doc);
 //获取PDF文档的页数
 int pageCount = doc.getNumberOfPages();
 System.out.println("文档一共" + pageCount + "页");
 List<String> fileList = new ArrayList<>();
 for (int i = 0; i < pageCount; i++) {
 //只有一页的时候文件名为传入的文件名，大于一页的文件名为：文件名_自增加数字(从1开始)
 String realFileName = pageCount > 1 ? desFileName + "_" + (i + 1) : desFileName;
 //每一页通过分辨率和颜色值进行转化
 BufferedImage bufferedImage = renderer.renderImageWithDPI(i, 96*2, ImageType.RGB);
 String filePath = desFilePath + File.separator + realFileName + "." + imageType;
 //写入文件
 ImageIO.write(bufferedImage, imageType, new File(filePath));
 //文件名存入list
 fileList.add(filePath);
 }
 return fileList;
 } catch (IOException e) {
 e.printStackTrace();
 throw new RuntimeException("PDF转化图片异常，无法转化");
 } finally {
 try {
 if (doc != null) {
 doc.close();
 }
 } catch (IOException e) {
 System.out.println("关闭文档失败");
 e.printStackTrace();
 }
 }

 }
}

Post上传文件

Mon, 01 Jan 0001 00:00:00 +0000

package main

import (
 "bytes"
 "encoding/json"
 "fmt"
 "io"
 "io/ioutil"
 "log"
 "mime/multipart"
 "net/http"
 "os"
 "path/filepath"
)

func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (UploadFileRes, error) {
 file, err := os.Open(path)
 if err != nil {
 return UploadFileRes{}, err
 }
 defer file.Close()

 body := &bytes.Buffer{}
 writer := multipart.NewWriter(body)
 part, err := writer.CreateFormFile(paramName, filepath.Base(path))
 if err != nil {
 return UploadFileRes{}, err
 }
 _, err = io.Copy(part, file)

 for key, val := range params {
 _ = writer.WriteField(key, val)
 }
 err = writer.Close()
 if err != nil {
 return UploadFileRes{}, err
 }

 request, err := http.NewRequest("POST", uri, body)
 if err != nil {
 log.Fatal(err)
 return UploadFileRes{}, err
 }
 request.Header.Add("Content-Type", writer.FormDataContentType())
 client := &http.Client{}
 resp, err := client.Do(request)
 if err != nil {
 log.Fatal(err)
 return UploadFileRes{}, err
 } else {
 defer resp.Body.Close()
 body, err := ioutil.ReadAll(resp.Body)
 // body := &bytes.Buffer{}
 // _, err := body.ReadFrom(resp.Body)
 if err != nil {
 log.Fatal(err)
 }

 // fmt.Println(resp.StatusCode)
 // fmt.Println(resp.Header)
 // fmt.Println(body.Bytes())

 var uploadFileRes UploadFileRes
 json.Unmarshal(body, &uploadFileRes)
 return uploadFileRes, nil
 }
 return UploadFileRes{}, fmt.Errorf("lib throwe")
}

func main() {

 extraParams := map[string]string{}
 res, err := newfileUploadRequest("http://192.168.1.56:1502/uploadeFile", extraParams, "file", "/home/koala/project/tmp/images/1.png")
 if err != nil {
 log.Fatal(err)
 }
 fmt.Println(res)

 sep := string(os.PathSeparator)
 fmt.Println(sep)
}

type UploadFileRes struct {
 ErrCode string `json:"errCode"`
 ErrMsg string `json:"errMsg"`
 Data string `json:"data"`
}

reset.css

Mon, 01 Jan 0001 00:00:00 +0000

@charset "utf-8";

/*css reset*/
body,nav,dl,dt,dd,p,h1,h2,h3,h4,ul,ol,li,input,button,textarea,footer{margin:0;padding:0}
body{font:16px/1.5 'Microsoft Yahei','Simsun'; color:#333;background:#fff;-webkit-text-size-adjust: none; min-width:320px;}
h1,h2,h3,h4,h5,h6{font-size:100%}
form{display:inline}
ul,ol{list-style:none}
a{text-decoration:none;color:#1a1a1a}
a:hover, a:active, a:focus{color:#1a1a1a;text-decoration: none;}
a:active{color:#1a1a1a;}
img{vertical-align:middle;border:0;-ms-interpolation-mode:bicubic;}
button,input,select,textarea{font-size:100%; vertical-align:middle;outline:none;}
textarea{resize:none}
button,input[type="button"],input[type="reset"],input[type="submit"] {cursor:pointer;-webkit-appearance:button;-moz-appearance:button}
input:focus:-moz-placeholder,input:focus::-webkit-input-placeholder {color:transparent}
button::-moz-focus-inner,input::-moz-focus-inner { padding:0; border:0}
table { border-collapse:collapse; border-spacing:0}
.fl{float:left;}.fr{float:right;}.hide{display:none;}.show{display: block;}
.ellipsis { white-space:nowrap; text-overflow:ellipsis; overflow:hidden}
.break { word-break:break-all; word-wrap:break-word}
header, footer, article, section, nav, menu, hgroup {display: block;clear:all;}
.clear {zoom:1;}
.clear:after {content:'';display:block;clear:both;height:0;}

.main{width: 100%;font-size: 62.5%;}

Goldydocs on 菜鸟程序员

01单片机原理图和开发板设计图

线性表

1 线性表的特点

2 线性表功能定义

3 代码实现

3.1

001创建一个名称为nginx的pod

01工厂三兄弟之简单工厂模式(Simple Factory Pattern)

概述

定义

结构

角色

典型代码

01快速入门

docker compose 部署

源码部署

添加设备

单设备添加

导入设备

01设计模式概述

设计模式从何而来

01适配器模式

概述

定义

结构

角色

典型代码

案例解析： 算法库

Golang单元测试-wire依赖注入

Golang依赖注入框架wire全攻略

Installing

Quick Start

Golang单元测试-简单示例

Golang单元测试01

搞定Go单元测试（一）——基础原理

单元测试的难点

1.掌握单元测试粒度

2. 破除外部依赖（mock,stub 技术）

Costs and Benefits

1.依赖很少的简单的代码(左下)

2. 依赖较多但是很简单的代码（右下）

3. 依赖很少的复杂代码 (左上)

4.依赖很多又很复杂（右上）

迈出单元测试第一步

1. 识别依赖，抽象成接口

2. 明确需要测什么

InfinityFree白嫖攻略

多个网卡时指定注册ip段.md

方法一： 继承Thread

服务端配置

Mapping to JMS

汇编语言入门一：环境准备

环境

环境检查

开始第一个程序

如何在pom文件中管理多个环境

完全私有化部署

1. 搭建web管理平台服务

职责链模式

概述

定义

结构图

角色

典型代码

02点亮LED

LED

1. 原理图

2. 描述

3. 点亮LED

第一个LED

同时点亮1 3 5 led

轮流点亮每一个LED

轮流点亮每一个LED，每次只点亮一个 从左向右

002进入名为nginx的pod

02边缘测

新增边缘实例

02工厂三兄弟之工厂方法模式

概述

定义

案例解析：算法库

方法一：继承Thread

轮流点亮每一个LED，每次只点亮一个从左向右