软件开发的生命周期

传统的软件开发生命周期是指软件产品从构思开始，经过定义、开发、使用和维护直到最后废弃的全过程。按照传统的软件生命周期方法，可以把软件生命周期划分为软件定义、软件开发、软件运行与维护三个阶段。

状态机介绍

我们在web 项目中讨论的状态机通常是指状态机这种设计模式。该设计模式属于行为型设计模式，

它允许对象在内部状态改变时改变其行为，看起来好像修改了自身的类。这种模式通过将状态相关的行为封装到不同的状态对象中，解决了复杂条件判断（如大量if-else或switch-case）导致的代码臃肿问题。

一只喜欢瞎写的程序猿

链式调用位于LangChain三层核心架构中的中间层——工作流API抽象层。链就是负责将这些组件按照某一种逻辑，顺序组合成一个流水线的方式。比如我们要构建一个简单的问答链，就需要把大模型组件和标准输出组件用链串联起来。

龙场悟道

王阳明于明武宗正德元年（1506年），因反对宦官刘瑾，被廷杖四十，谪贬至贵州龙场（贵阳西北七十里，修文县治）当驿丞。龙场万山丛薄，苗、僚杂居。在龙场这既安静又困难的环境里，王阳明结合历年来的遭遇，日夜反省。一天半夜里，他忽然有了顿悟，认为心是感应万事万物的根本，由此提出心即理的命题。认识到“圣人之道，吾性自足，向之求理于事物者误也。”这就是著名的“龙场悟道”，我们这一篇博客讨论的就是阳明心学。小伙伴看到阳明心学可能就联想到唯心主义，阳明心学确实是唯心主义，但不全是。我们现在想过的很多问题，古人早替我们想过了，而且想的更深邃。阳明心学能传承这么多年，自然有它的可取之处，这里我们取的就是阳明心学中的知行合一。

科目一

考试内容：

1. 道路交通安全法律
2. 交通信号
3. 高速公路，山区道路，桥梁，隧道，夜间等条件下的安全驾驶知识
4. 临危处置知识
5. 机动车构造，维护知识
6. 安全行车，文明驾驶知识
7. 自救急救，危险物品

东海龙宫这个项目开了

普罗米修斯介绍

Prometheus（普罗米修斯）是一套开源的监控系统，其基本原理是通过 HTTP 协议周期性抓取被监控组件的状态，不需要任何 SDK 或者其他的集成过程，其架构如图：

KubeSphere 介绍

KubeSphere是k8s控制台，ubeSphere 目前提供了工作负载管理、微服务治理、DevOps 工程、Source to Image、多租户管理、多维度监控、日志查询与收集、告警通知、服务与网络、应用管理、基础设施管理、镜像管理、应用配置密钥管理等功能模块。

redis 的客户端有jedis、lettuce、redission；我个人比较推荐的是redission，因为它的分布式锁和缓存实在是太优秀了。 Redisson采用了基于NIO的Netty框架，封装了大家常用的集合类以及原子类、锁等工具。
本章节主要介绍redission 中重要的两个点：数据结构和锁

redis持久化方式有两种，一种是RDB，一种是aof。
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘。
AOF持久化以日志的形式记录服务器所处理的每一个写操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细的操作记录。

redis数据库结构介绍

在redis源码中数据库的结构由server.h/redisDb表示，
redisDb结构的dict字典保存了数据库中的所有键值对，我们将这个字典称为键空间（key space），redisDb源码：

前文我们看过redisObject的源码：

1
2
3
4
5
6
7
8
9

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

下面我们来了解redisObject相关机制

SDS

redis中没有直接使用C语言的字符串，而是自定义了一种名为简单动态字符串的抽象类型——SDS。我们下载redis源码，可以在src目录下找到一个sds.h的文件，打开这个文件查看它的部分代码：

本地开发集群新方案 Virtualbox+Vagrant

vagrant 相对于 vmware 而言更轻量级，操作更简便移植性更强，如果我们需要学习k8s或者搭建一些集群的话建议使用 Virtualbox+Vagrant。
Vagrant 是创建虚拟机的工具，Virtualbox 是vagrant 管理工具，而且这两个软件是开源的，不需要我去付费或者破解。

环境准备

vagrant 下载地址：https://www.vagrantup.com
virtualbox 下载地址：https://www.virtualbox.org/wiki/Downloads

下载安装完成后，我们还需要下载vagrant镜像
镜像下载地址：https://app.vagrantup.com/boxes/search

Kubernetes中概念的简要概述

• Cluster : 集群是指由Kubernetes使用一系列的物理机、虚拟机和其他基础资源来运行你的应用程序。

• Node : 运行着Kubernetes的物理机或虚拟机，并且pod可以在其上面被调度。

• Pod : k8s的最小调度单元，一个pod 可以包含多个容器，k8s无法直接操作容器，只能操作pod

• Label : 一个label是一个被附加到资源上的键/值对，譬如附加到一个Pod上，为它传递一个用户自定的并且可识别的属性.Label还可以被应用来组织和选择子网中的资源

• selector:是一个通过匹配labels来定义资源之间关系得表达式，例如为一个负载均衡的service指定所目标Pod.

• Deployment: 控制pod生命周期的pod控制器

• Service : 一个service定义了访问pod的方式，比如固定的IP地址和与其相对应的DNS名之间的关系。

• Volume: 目录或者文件夹

• Namespace : 命名空间，起到资源分组he隔离的作用

  more >>

jenkins 邮件通知及sonarqube 插件

邮件通知

在实际项目中往往需要在流水线执行过程中发送通知邮件到相应的开发运维人员的邮箱中，jenkins 可以通过插件 Email Extension Plugin 进行相关配置。
进入jenkins系统设置中找到email 相关配置：

配置内容包括邮箱服务器（参考 spring 发送邮件功能），邮箱后缀等，jenkins 旁边的问号图标都有相关配置项说明，需要注意的是jenkins 内置了一些变量，可查看 Content Token Reference 项。完成基本的邮件配置完成后，还需要再流水线中配置发送邮件相关信息

认识docker

docker是Docker.inc 公司开源的一个基于LXC技术之上构建Container容器引擎技术，Docker基于容器技术的轻量级虚拟化解决方案，实现一次交付到处运行。
docker实现程序集装箱的概念，把我们需要交付的内容集装聚合成一个文件（镜像文件）直接交付。

docker 基本原理

docker 架构图：

从架构图中我们可以看出，docker有三大核心，包括容器，仓库，镜像

什么是Ansible

ansible是一个基于python的自动化运维工具，实现了批量系统配置、批量程序部署、批量运行命令等功能。ansible包括部署和使用简单、默认使用ssh协议、轻量级等特点。

pipeline 的hello world

pipeline是部署流水线，它支持脚本和声明式语法，能够比较高自由度的构建jenkins任务.个人推荐使用这种方式去构建jenkins。

Jenkins 1.x只能通过界面手动配置来配置描述过程，想要配置一些复杂度高的任务，只能选择自由风格的项目，通过选项等操作进行配置，让jenkins可以下载代码、编译构建、然后部署到远程服务器上，这样显然是不方便管理和移植的。

pipeline的功能由pipeline插件提供，我们可以创建一个jenkinsfile来申明一个任务。接下来我们创建一个最简单的pipeline。登录jenkins,点击创建item:

Jenkins 介绍

Jenkins是一款开源 CI&CD 软件，用于自动化各种任务，包括构建、测试和部署软件，CI&CD:

• 持续集成：持续集成可以帮助开发人员更加频繁地将代码更改合并到目标分支
• 持续交付：持续交付的目标是拥有一个可随时部署到生产环境的代码库
• 持续部署：可以自动将应用发布到生产环境

之前我做过一款 chrome代理插件——poseidon-chrome-proxy，这个插件的功能是通过一些配置将浏览器中的请求代理到你配置的服务器上去。这款插件的局限性是只能使用在谷歌浏览器中，而且无法代理https请求，这是因为谷歌浏览器限制了pac脚本对https请求的代理；不仅如此，该插件还存在dns污染的问题，虽然可以通过清除浏览器缓存来解决，但是也是比较糟心。最近项目中恰好遇到了需要对https进行代理的需求，经过我的研究，最终找到了一个比较满意的解决方案，它就是fiddler。

fiddler 介绍

fiddler 是一款专门用于抓取http请求的抓包工具，当启动该工具时，pc端的请求会先被代理到该工具再转发到服务器，因此我们就可以在请求转发前对请求的协议，请求头，路径，请求内容等信息进行修改。而且通过该工具你还能记录某个请求的数据并进行回放或打断点，相比较代理插件，不仅适用范围更广，调试bug也更方便。

插件推荐

• .ignore: ignore文件提示与语法高亮插件
• arthas idea: arthas 插件
• camelcase: 大小写与驼峰转换插件
• checkstyle-idea: 代码检测插件
• cmdsupport: 脚本执行插件
• git Commit template: commit 模板插件
• gson format: json 转对象插件
• ideavim：vim插件
• key promoter x : 快捷键提示插件
• lombok: lombok插件
• maven helper: maven 帮助插件
• save action: 代码保存触发一些操作
• sonarlint: sonar 插件
• translation: 翻译插件

linux 基本命令

1. 目录操作

• mkdir 创建文件夹
• mkdir -p 递归创建目录
• 创建多个目录 mkdir [-p] a b c
• touch a b c 创建文件
• rm -r 递归 -f 强制删除
• cp -r 递归 复制 cp -r a/ b/
• mv 移动（重命名）
• ls （ll=ls -l） more >>

之前写过一篇zk 浅解的博客，介绍了zk 的安装及其指令与原理。这一篇主要介绍zk 在项目中的使用。

sentinel 增加规则的方式 包括三种，数据源加载，代码加载，控制台加载；每一类流控规则我都会从这三个方面去说明如何使用。

我们之前配置的流控规则都是存储在应用的内存中的，这种方式明显无法满足我们实际开发的需求，一旦项目被重启，流控规则就被初始化了，需要我们再次去重新配置，因此规则的持久化就显得很有必要了。

本节会介绍几类主流持久化方式并对自定义持久化做介绍

sentinel介绍

sentinel 是阿里开源的流量控制，熔断降级，系统负载保护的一个Java组件；

Sentinel 分为两个部分:
核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

前文介绍了 kafka 的相关特性和原理，这一节我们将学习怎么在springboot中使用kafka；

首先导入依赖

1
2
3
4

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
</dependency>

接手项目的一次采坑

springboot 有读取外部配置文件的方法，如下优先级：

• 第一种是在jar包的同一目录下建一个config文件夹，然后把配置文件放到这个文件夹下。
• 第二种是直接把配置文件放到jar包的同级目录。
• 第三种在classpath下建一个config文件夹，然后把配置文件放进去。
• 第四种是在classpath下直接放配置文件。 more >>

kafka 的事务是从0.11 版本开始支持的，kafka 的事务是基于 Exactly Once 语义的，它能保证生产或消费消息在跨分区和会话的情况下要么全部成功要么全部失败

最近不太想写技术博客，就来聊一些形而上的东西吧。我准备分三个章节聊一些关于人生的一些感悟。第一篇是基于我18年写的稿子整理来的，主要探讨所谓的“世界观”。

M理论

在围棋游戏中，只有围与不围这样很少的几条规则，加上黑白两色棋子，却可以弈出千变万化的对局。与此相似，现代认为，自然界由很少的几条规则支配，而存在着无限多种这些支配规律容许的状态和结构。任何物理现象或者定律都只是这些规则的进一步推到与演化。那么对于其他事物而言，有没有可能也存在这种M理论呢？

背景

衡量容灾系统的主要指标有

形式逻辑

最近失业没工作闲下来写点东西

代码混乱的常见问题

很多时候我们项目迭代到后期，项目会变得很混乱，往往只有少数人能知道某段代码是干嘛的和该如何去改，或者是干脆谁都不知道，只能靠通过注释去猜测这段代码可能的作用。原因有可能是因为团队内部的人事变动，导致原先写这段代码的人不再管理这段代码了，并且代码写的实在是屎没人捋的清。往往我们称这类代码为“祖传代码”，就像祖宗传下来的代码一样，没人懂没人敢动。祖传代码一多，这个项目就变成了屎一样，开发人员再这基础上迭代就如同屎海翻腾，恶心别人也恶心自己。这是一个很可怕的恶心循环，我们如何去避免这种事情发生呢？先让我们分析下这类代码的通病

kafka 原理深度解读

前文介绍了kafka的一些基本原理，接下来我们深入了解下关于kafka的一些机制和优化

kafka 原理

消息队列一般包含两种模式，一种是点对点的模式，一种是发布订阅的模式。前文提到过 kafka 是一款基于发布订阅的消息队列。
那么kafka是怎么去发布消息，怎么去保存消息，订阅消息的呢？首先我们从kafka的发布订阅模型开始分析。

kafka 介绍

kafka 是一款基于发布订阅的消息系统，Kafka的最大的特点就是高吞吐量以及可水平扩展，
Kafka擅长处理数据量庞大的业务，例如使用Kafka做日志分析、数据计算等。

相对前面几个章节来说，这个章节知识点不是着重点。大家对这一章节知识的掌握程度为了解。好了，废话不多说，开始正文

ListenerContainer 的使用

在消费端，我们的消费监听器是运行在 监听器容器之中的（ ListenerContainer ），springboot 给我们提供了两个监听器容器 SimpleMessageListenerContainer 和 DirectMessageListenerContainer 在配置文件中凡是以 spring.rabbitmq.listener.simple 开头的就是对第一个容器的配置，以 spring.rabbitmq.listener.direct 开头的是对第二个容器的配置。其实这两个容器类让我很费劲；首先官方文档并没有说哪个是默认的容器，似乎两个都能用；其次，它说这个容器默认是单例模式的，但它又提供了工厂方法，而且我们看 @RabbitListener 注解源码：

这一章节我们会学习rabbitMQ在项目生产中一些重要的特性，如持久化，消息确认机制，消息过期等特性。只要能利用好这些特性，我们就能开发出可用性强的，功能强大的MQ系统。

从这一节开始我们进入rabbitMQ的实战环节，项目环境是spring-boot 加maven。首先让我们创建一个spring-boot项目，然后引入web依赖和 rabbitMQ的依赖

前文我们学习了 MQ的相关知识，现在我们来学习一下实现了AMQP协议的 rabbitMQ 中间件。rabbitMQ 是使用 erlang 语言编写的中间件（erlang之父 19年4月去世的，很伟大一个程序员）。

mq 就是消息队列（Message Queue）。想必大家对队列的数据结构已经很熟悉了，消息队列可以简单理解为：把要传输的数据放在队列中，mq 就是存放和发送消息的这么一个队列中间件。在消息队列中，把数据放到消息队列的角色叫做 生产者，从消息队列中消费获取数据的叫做 消费者。

那么消息队列有哪些使用场景呢? 六字真言：异步削峰解耦。

对 rabbitMQ 我们已经有了初步的了解，现在我们来安装 rabbitMQ 来进行一些操作。因为大部分人的操作系统都是windows 而且作者本人使用的也windows系统。所以这里只介绍在windows上安装rabbitMQ。mac用户自行解决（仇富脸）。

操作码介绍

我们都知在Java中我们的类会被编译成字节码然后放到虚拟机中去执行，字节码里面的内容其实我们也是可以去“阅读”的，方法就是通过 jdk自带的工具翻译成操作码。在操作码中我们能看到一些我们平时看不到的关于java的秘密。

Java虚拟机的指令由一个字节长度的的数字以及跟随其后的零至多个代表此操作所需的参数构成。即：Java指令 = 操作码 + 操作数。Java虚拟机本身是采用面向操作数栈而不是寄存器的架构，所以大多数的指令都不包含操作数，只有一个操作码。通过阅读操作码我们能直观的看到一些方法的执行过程。

1.调优参数

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k

-Xmx3550m：设置JVM最大可用内存为3550M。

-Xms3550m：设置JVM促使内存为3550m。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。

-Xmn2g：设置年轻代大小为2G。整个JVM内存大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。

-Xss128k：设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

java -Xmx3550m -Xms3550m -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxPermSize=16m -XX:MaxTenuringThreshold=0

-XX:NewRatio=4:设置年轻代（包括Eden和两个Survivor区）与年老代的比值（除去持久代）。设置为4，则年轻代与年老代所占比值为1：4，年轻代占整个堆栈的1/5
-XX:SurvivorRatio=4：设置年轻代中Eden区与Survivor区的大小比值。设置为4，则两个Survivor区与一个Eden区的比值为2:4，一个Survivor区占整个年轻代的1/6

-XX:MaxPermSize=16m:设置持久代大小为16m。

-XX:MaxTenuringThreshold=0：设置垃圾最大年龄。如果设置为0的话，则年轻代对象不经过Survivor区，直接进入年老代。对于年老代比较多的应用，可以提高效率。如果将此值设置为一个较大值，则年轻代对象会在Survivor区进行多次复制，这样可以增加对象再年轻代的存活时间，增加在年轻代即被回收的概论。

JVM提供了大量命令行参数，打印信息，供调试使用。主要有以下一些：
-XX:+PrintGC
输出形式：[GC 118250K->113543K(130112K), 0.0094143 secs]
[Full GC 121376K->10414K(130112K), 0.0650971 secs]

-XX:+PrintGCDetails

-XX:+PrintGCTimeStamps -XX:+PrintGC：PrintGCTimeStamps可与上面两个混合使用

-XX:+PrintGCApplicationConcurrentTime:打印每次垃圾回收前，程序未中断的执行时间。可与上面混合使用

-XX:+PrintGCApplicationStoppedTime：打印垃圾回收期间程序暂停的时间。可与上面混合使用

-XX:PrintHeapAtGC:打印GC前后的详细堆栈信息

事件的起因

最近在做一个项目，这个项目很有特点——它是一个分布式项目但是它却未使用分布式事务。我分析其事务机制和缺陷时，突然灵感一来，于是有了这篇文章。

spring事务传播行为

在讨论分布式事务之前，我们先把spring事务传播机制过一遍，文章参考自事务传播行为详解 这位大佬写的很用心，文末评论区还讲到了一个关于spring事务的一个很重要的特性。spring事务传播行为有七种：

责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

责任链模式也叫职责链模式。

在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。

当我们的代码中”方法的请求者” 和 “方法的实现者” 之间存在较为紧密的耦合的时候，这段代码的后续维护会变得很困难。如果我们想对方法进行回滚 撤销等操作的话就会很困难；使用命名模式可解决这一问题。

在现实生活中，这样的例子也很多，例如，电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者），还有计算机键盘上的“功能键”等。

策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。策略模式有以下优点：

• 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。
• 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
• 策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
• 策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
• 策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有：
代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

其主要缺点是：
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；

组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系。组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；

装饰器（Decorator）模式指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。采用装饰模式扩展对象的功能比采用继承方式更加灵活；可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。但是装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。

建造者模式(Builder)是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。我们获得一个对象的时候不是直接new这个对象出来，而是对其建造者进行属性设置，然后建造者在根据设置建造出各个对象出来。建造者模式又可以称为生成器模式。

门面（Facade）模式的定义：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。

门面模式又被称作外观模式，这个模式特点很鲜明，在生活中我们就能找到不少例子。比如110，我们生活中遇到困难或者危险等一系列问题，我们都是直接打110找警察同志，然后由公安局统一处理，对应不同的情况再细化到公安的各个部门去处理。

单例模式 （Singleton Pattern）使用的比较多，比如我们的 controller 和 service 都是单例的，但是其和标准的单例模式是有区别的。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

作者: muggle

1 mysql 架构

mysql分为server层和存储引擎

1.1 server层

• 连接器：管理连接权限验证
• 查询缓存：命中缓存直接换回查询结果
• 分析器：分析语法
• 优化器：生成执行计划，选择索引
• 执行器：操作索引返回结果

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

模式结构

适配器模式包含如下角色：

• Target：目标抽象类
• Adapter：适配器类
• Adaptee：适配者类
• Client：客户类

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

设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等，此时至少有如下两种设计方案：

1. 为每一种形状都提供一套各种颜色的版本。
2. 根据实际需要对形状和颜色进行组合

对于有两个变化维度（即两个变化的原因）的系统，采用第二种方案来进行设计系统中类的个数更少，且系统扩展更为方便。第二种方案即是桥接模式的应用。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。对于有两个变化维度（即两个变化的原因）的系统，采用桥接模式开发更为方便简洁。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。

简单工厂模式

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

模式结构

简单工厂模式包含如下角色：

• Factory：工厂角色，工厂角色负责实现创建所有实例的内部逻辑
• Product：抽象产品角色，抽象产品角色是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
• ConcreteProduct：具体产品角色，具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

从官网 https://apache.org/dist/zookeeper/zookeeper-3.5.5/ 上下载zk(注意windows也是下载 tar.gz后解压)，./conf下有个zoo_sample.cfg 复制到同目录下改名为zoo.cfg，在目录下新建data和log文件夹，修改zoo.cfg中的 dataDir 和 dataLogDir为 data和log的路径。现在启动zk，在bin目录下有个zkServer.cmd，运行启动。启动ZK客户端对ZK进行简单的读写操作，在bin目录下打开cmd，运行：

重要

架构图

启动时检查

Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题，默认 check="true"。

基本配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

### 初始化git 仓库
git init

### 设置git 全局变量
git config --global user.name"ssss"

### 将文件纳入 git 管理
git add README.md

### 提交
git commit -m "first commit"

### git 添加远程仓库
git remote add origin https://github.com/xxx

###  将本地的master分支推送到origin主机，同时指定origin为默认主机，后面就可以不加任何参数使用git push了
git push -u origin master

今天介绍两个大家每天都在用但是却很少去了解它的知识点：spi和jar运行机制，废话不多说，开始正题

spi

是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。spi机制是这样的：读取META-INF/services/目录下的元信息，然后ServiceLoader根据信息加载对应的类，你可以在自己的代码中使用这个被加载的类。要使用Java SPI，需要遵循如下约定：

gradle介绍

Gradle是一个构建工具，定位和maven一样，用于管理项目依赖和构建项目。和maven比起来的优势是：语法更灵活，更方便管理项目（个人很讨厌XML）。

gradle具有以下特点：

• 按约定声明构建和建设；
• 强大的支持多工程的构建；
• 强大的依赖管理（基于Apache Ivy），提供最大的便利去构建工程；
• 全力支持已有的 Maven 或者Ivy仓库基础建设；
• 支持传递性依赖管理；
• 基于groovy脚本构建，groovy简单易学；
• 具有广泛的领域模型支持构建；
• 易迁移；
• 自由和开放源码；

注解相关知识

元注解

1. @Retention：生命周期，RetentionPolicy.SOURCE 注解只在源码阶段保留，RetentionPolicy.CLASS 注解只被保留到编译进行的时候，它并不会被加载到 JVM中，RetentionPolicy.RUNTIME 注解可以保留到程序运行的时候
2. @Documented：作用是能够将注解中的元素包含到 Javadoc 中去。
3. @Target：指定了注解运用的地方。ElementType.ANNOTATION_TYPE 可以给一个注解进行注解，ElementType.CONSTRUCTOR 可以给构造方法，ElementType.FIELD 可以给属性，ElementType.LOCAL_VARIABLE 可以给局部变量，ElementType.METHOD 可以给方法，ElementType.PACKAGE 可以给一个包，ElementType.PARAMETER 可以给一个方法内的参数，ElementType.TYPE 可以给一个类型进行注解，比如类、接口、枚举
4. @Inherited：一个超类被 @Inherited 注解过的注解进行注解的话，那么如果它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。
5. @Repeatable ：可重复注解

废话不多说直接开始

1）新建maven项目，pom结构如下：

前言

前段时间写了一篇关于nacos的文章，本人还是很期待nacos成长起来的。nacos在其官方文档里面说nacos未来会支持grpc，正好我对grpc也抱有极大兴趣，于是基于springboot和gradle做了一个小demo对它们进行了整合，初步研究了一下，期待nacos成熟起来，组成一套Spring Cloud+gradle+nacos+grpc+sentinel的完全体。这篇博客的目的是知识储备，并不是讨论解决开发中某些问题。

正文

弄了一天，得到一个结论，gradle+grpc+git subtree 不是目前的我能驾驭的，弃文；等对gradle足够熟练再回来弄。

什么是代理

   代理是一种软件设计模式，这种设计模式不直接访问被代理对象，而访问被代理对象的方法，详尽的解释可参考《java设计模式之禅》，里面的解释还是很通俗的。给个《java设计模式之禅》下载地址：https://pan.baidu.com/s/1GdFmZSx67HjKl_OhkwjqNg

   在JDK中提供了实现动态代理模式的机制，cglib也是一个用于实现动态代理的框架，在这里我介绍jdk自带的动态代理机制是如何使用的。先上代码再慢慢解释：

java 引用介绍

在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。对象引用被划分成简单的两种状态：可用和不可用。从JDK 1.2版本以后，对象的引用被划分为4种级别，从而使程序能更加灵活地控制对象的生命周期，引用的强度由高到低为：强、软、弱、虚引用。

对象生命周期：在JVM运行空间中，对象的整个生命周期大致可以分为7个阶段：创建阶段（Creation）、应用阶段（Using）、不可视阶段（Invisible）、不可到达阶段（Unreachable）、可收集阶段（Collected）、终结阶段（Finalized）与释放阶段（Free）。上面的这7个阶段，构成了 JVM中对象的完整的生命周期。

分为20个模块

core container

core beans context expression language

redis基础知识

客户端与服务端的通讯协议是建立在TCP协议之上构建的；

redis序列化协议 resp

• 状态回复（status reply）的第一个字节是 "+"
• 错误回复（error reply）的第一个字节是 "-"
• 整数回复（integer reply）的第一个字节是 ":"
• 批量回复（bulk reply）的第一个字节是 "$"
• 多条批量回复（multi bulk reply）的第一个字节是 "*"

说明

git subtree可将多个git项目合并在一起，可解决protobuf更新的问题；

打包maven私有仓库也可行，但是maven私有仓库不适合频繁更新，而protobuf更新会很频繁。

测试

1
2
3
4
5
6
7
8
9
10
11
12
13

git clone一个新项目

git remote add <name> <url> 添加一个远程仓库

git subtree add --prefix=<dir> <name> master --squash

git push 会把子仓库的文件提交，合情合理

# 更新子仓库的方法

git subtree push --prefix=<dir> <name> master

每次开机都启动一堆软件，很麻烦，该肿么办？

写个批处理文件 步骤（这里以启动微信为例 ）：

1. 新建一个文本文档
2. 输入以下命令：

start “xx” “xxx”

xx 代表程序名称，可以随便起；xxx代表你想启动的程序的位置 获取程序位置的方法：

此文记录了平时觉得写得很好的博客

事物传播机制的一个实验

guava使用教程

这篇博客会记录我的一些刷题心得

参考：leetcode答案

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

编辑中

nacos简介

在nacos-0.3的时候我就开始关注，期间还写过一篇作为springcloud配置中心的使用记录的博客。在前不久，nacos终于出了正式版，赶个时髦出篇博客吹一波，[nacos官方文档](https://nacos.io/zh-cn/index.html)

CAP 定理

原文链接 http://www.ruanyifeng.com/blog/2018/07/cap.html

分布式系统的最大难点，就是各个节点的状态如何同步。CAP 定理是这方面的基本定理，也是理解分布式系统的起点。

• Consistency 中文叫做”一致性”。意思是，写操作之后的读操作，必须返回该值。

• Availability Availability 中文叫做”可用性”，意思是只要收到用户的请求，服务器就必须给出回应。

• Partition tolerance 中文叫做”分区容错”。大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区（partition）。分区容错的意思是，区间通信可能失败。

  这三个指标不可能同时做到，一般来说，分区容错无法避免，因此可以认为 CAP 的 P 总是成立。CAP 定理告诉我们，剩下的 C 和 A 无法同时做到。对于Eureka而言，其是满足AP的。

dubbo 架构介绍

注册中心 服务提供者 消费者 管理者 容器

registry provider consumer monitor container

作者：muggle

nio介绍

传统的IO又称BIO，即阻塞式IO，NIO就是非阻塞IO了，而NIO在jdk1.7后又进行了升级成为nio.2也就是aio；
Java IO的各种流是阻塞的。这意味着，当一个线程调用read()或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

作者：muggle

服务治理

服务治理是微服务架构中最为核心和基础的模块。它主要用来实现各个微服务实例的自动化注册与发现。随着服务的越来越多，越来越杂，服务之间的调用会越来越复杂，越来越难以管理。而当某个服务发生了变化，或者由于压力性能问题，多部署了几台服务，怎么让服务的消费者知晓变化，就显得很重要了。不然就会存在调用的服务其实已经下线了，但调用者不知道等异常情况。这个时候有个服务组件去统一治理就相当重要了。Eureka便是服务治理的组件。

作者：muggle

注：参考大佬博客牧码小子

springcloud的核心功能：

负载均衡，服务注册与发现，监控，分布式配置管理，api网关 分布式追踪

作者：muggle

设计模式的分类

创建型模式

共五种：

• 工厂方法模式
• 抽象工厂模式
• 单例模式
• 建造者模式
• 原型模式

结构型模式

共七种：

• 适配器模式
• 装饰器模式
• 代理模式
• 外观模式
• 桥接模式
• 组合模式
• 享元模式

muggle

1.类的生命周期

   类从被加载到虚拟机内存中内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（loading）、验证（verification）、准备（preparation）、解析（resolution）、初始化（initialization）、使用（using）卸载（unloading）七个阶段。其中验证、准备、解析三个阶段统称为连接（linking）。

1 标记-清除算法

标记-清除算法是最基础的算法，算法分为标记和清除两个阶段，首先标记出要清除的对象，在标记完后统一回收所有被标记的对象，标记方式为j《jvm系列之垃圾收集器》里面所提到的。这种算法标记和清除两个过程效率都不高；并且在标记清除后，内存空间变得很零散，产生大量内存碎片。当需要分配一个比较大的对象时有可能会导致找不到足够大的内存。 more >>

垃圾收集器介绍

   java内存在运行时被分为多个区域，其中程序计数器、虚拟机栈、本地方法栈三个区域随线程生成和销毁；每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的，在这几个区域内就不需要过多考虑回收问题，因为方法结束或者线程结束时，内存自然就跟着回收了。而堆区就不一样了，我们只有在程序运行的时候才能知道哪些对象会被创建，这部分内存是动态分配的，垃圾收集器主要关注的也就是这部分内存。

作者：muggle

对象的创建

   在语言层面上，创建一个对象通常是通过new关键字来创建，在虚拟机中遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过；如果没有的话就会先加载这个类；类加载检查完后，虚拟机将会为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，在堆中为对象划分一块内存出来。

   虚拟机给对象分配内存的方式有两种——“指针碰撞”的方式和“空闲列表”的方式。如果java堆内存是绝对规整的，所有用过的内存放在一边，未使用的内存放在另一边，中间放一个指针作为指示器，那分配内存就只是把指针向未使用区域挪一段与对象大小相等的距离；这种分配方式叫指针碰撞式，如图1所示。

作者：muggle

运行时数据区域

   想要了解jvm，那对其内存分配管理的学习是必不可少的；java虚拟机在执行java程序的时候会把它所管理的内存划分成若干数据区域。这些区域有着不同的功能、用途、创建/销毁时间。java虚拟机所分配管理的内存区域如图1所示

程序计数器

   程序计数器是一块比较小的内存空间，它可以看做是当前线程所执行的字节码的执行位置的指针。在虚拟机中字节码，解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的指令；虚拟机完成分支、循环、跳转、异常处理、线程恢复等功能都需要依靠它。
   我们知道jvm多线程是通过线程的轮流切换并分配处理器执行时间的的方式来实现的，在任何时刻，一个处理器都只会执行一条线程中的指令。为了使线程被切换后能恢复到正确的执行位置，每条线程的程序计数器都应该是独立的，各条线程之间的计数器互不干涉，独立存储————程序计数器的内存区域为线程私有的内存。

   如果线程正在执行的是java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果执行的是Native方法，这个计数器的值则为空。此内存区域是唯一一个在jvm规范中没有规定任何OutOfMemoryerror情况的区域

作者：muggle

锁优化

减小锁持有时间

减小锁的持有时间可有效的减少锁的竞争。如果线程持有锁的时间越长，那么锁的竞争程度就会越激烈。因此，应尽可能减少线程对某个锁的占有时间，进而减少线程间互斥的可能。

减少锁持有时间的方法有：

• 进行条件判断，只对必要的情况进行加锁，而不是整个方法加锁；
• 减少加锁代码的行数，只对必要的步骤加锁。

作者：muggle

扩展

cas(比较替换)：无锁策略的一种实现方式，过程为获取到变量旧值（每个线程都有一份变量值的副本），和变量目前的新值做比较，如果一样证明变量没被其他线程修改过，这个线程就可以更新这个变量，否则不能更新；通俗的说就是通过不加锁的方式来修改共享资源并同时保证安全性。

使用cas的话对于属性变量不能再用传统的int ,long等；要使用原子类代替原先的数据类型操作，比如AtomicBoolean，AtomicInteger，AtomicInteger等。

java线程锁的分类与实现

以下分类是从多个同角度来划分，而不是以某一标准来划分，请注意

• 阻塞锁：当一个线程获得锁，其他线程就会被阻塞挂起，直到抢占到锁才继续执行，这样会导致CPU切换上下文，切换上下文对CPU而言是很耗费时间的
• 非阻塞锁：当一个线程获得锁，其他线程直接跳过锁资源相关的代码继续执行，就是非阻塞锁
• 自旋锁：当一个线程获得锁，其他线程则在不停进行空循环，直到抢到锁，这样做的好处是避免了上下文切换
• 可重入锁：也叫做递归锁，当一个线程外层函数获得锁之后 ，内层递归函数仍然可以该锁的相关代码，不受影响。
• 互斥锁：互斥锁保证了某一时刻只能有一个线程占有该资源。
• 读写锁：将代码功能分为读和写，读不互斥，写互斥；
• 公平锁/非公平锁：公平锁就是在等待队列里排最前面的的先获得锁，非公平锁就是谁抢到谁用；
• 重量级锁/轻量级锁/偏向锁：使用操作系统“Mutex Lock”功能来实现锁机制的叫重量级锁，因为这种锁成本高；轻量级锁是对重量级锁的优化，提高性能；偏向锁是对轻量级锁的优化，在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径。

作者：muggle

java并发相关概念

同步和异步

同步和异步通常来形容一次方法的调用。同步方法一旦开始，调用者必须等到方法结束才能执行后续动作；异步方法则是在调用该方法后不必等到该方法执行完就能执行后面的代码，该方法会在另一个线程异步执行，异步方法总是伴随着回调，通过回调来获得异步方法的执行结果；

并发和并行

很多人都将并发与并行混淆在一起，它们虽然都可以表示两个或者多个任务一起执行，但执行过程上是有区别的。并发是多个任务交替执行，多任务之间还是串行的；而并行是多个任务同时执行，和并发有本质区别。
对计算机而言，如果系统内只有一个cpu，而使用多进程或者多线程执行任务，那么这种情况下多线程或者多进程就是并行执行，并行只可能出现在多核系统中。当然，对java程序而言，我们不必去关心程序是并行还是并发。

作者：muggle

准备工作

安装hexo并创建一个博客项目

在安装hexo之前请确保安装了git 和node.js

打开cmd，输入

1

npm install -g hexo-cli

作者：muggle

作者：muggle

前言

由于第一版排版实在太过糟糕，而且很多细节没交代清楚，所以决定写第二版；这一版争取将排版设计得清晰明了一点，以方便读者阅读。

以前很少拍照，结果错失了很多珍贵的回忆，翻自己的相册都翻不出什么照片，最近买了个相机，准备摄影一波积累一些素材。

作者：muggle

序

如果你研究过springboot，你就会发现它不仅仅是方便了我们搭建项目整合框架，它其中有许多很高明的编程思想值得去学习研究和模仿；

作者：muggle

为什么要markdown

  markdown语法学习成本低，而且非常方便排版，如果你经常写文章，那么你就很有必要掌握markdown了，而且在vscode中编写markdown也非常方便，只需掌握几个快捷键，安装几个插件就能极大的提高你的写作效率。

作者：muggle

oauth2 相关概念

文章参考理解OAuth 2.0

作者：muggle

从一个基础的springsecurity开始，进行代码跟踪分析其原理

springsecurity是一个典型的责任链模式；我们先新建一个springboot项目，进行最基本的springsecurity配置，然后debug;我这里使用的开发工具是idea.建议大家也使用idea来进行日常开发。好了话不多说，开始：

作者：muggle

netty框架代码很猛（读源码有益身心健康），学习起来也比较难；在阅读这篇文章我假设你有了一定nio基础，tcp网络协议基础，否则不建议阅读。

关于netty的学习视频我推荐B站张龙的教学视频，讲的很不错。学netty之前先学会用，然后在去看他的原理这样学起来会轻松不少。

作者：muggle

Logback是由log4j创始人设计的另一个开源日志组件,分为三个模块：

1. logback-core：其它两个模块的基础模块

2. logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging

3. logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能
   在springboot中我们通过xml配置来操作logback

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/*
    * 第一个问题：虽然被包装过的list是线程安全的，但返回的list获得的Iterator仍然是线程不安全的，所以仍然要用Synchronized代码块包裹起来。

至于第二个问题，其实上面的文章链接也有提到, 大意是：与其所有（多线程）要用到该list都加上Synchronized修饰，还不如直接使用安全的collection更聪明。

也就是说，如果不使用Iterator迭代器的话，使用了安全的collection以后，其实我们不需要再用Synchronized代码块修饰了，这样使用上更方便。

反过来说，使用Iterator迭代器的话，似乎也没必要用Collections.synchronizedList的方法来包装了——反正都是必须要使用Synchronized代码块包起来的。

所以总的来说，Collections.synchronizedXX这种做法，适合不需要使用Iterator、对性能要求也不高的情况。
    *
    * */



/*
*
*  这就是所谓的线程安全的类，在多线程中一样会有问题，那这是为什么呢。后来在一篇博文当中看到了说Vector的contains方法和remove方法之前不具备原子性，这点给了提示。
*  我现在认为出错的原因是在get和remove之间并没有在以上环境中做到同步，比方说，一个线程的get（2）操作发生时，正好遇到了remove操作的正在进行，这时get（2）这个操作就会阻塞，
*  等待remove操作释放锁之后去操作。如果这时候remove操作的正好是remov（2）这个操作，等到去get的时候，这个元素已经没有了，get自然就只能是空欢喜一场。
    这里原因找到了，就该说解决办法了，在说解决办法之前，可能还会困惑，说好的线程安全呢，
    我的理解是，线程安全并不代表使用安全，在实际使用时还是需要考虑当前环境中是否会出现问题的。那么问题来了，java提供线程安全的某些类的意义在哪里呢，反正还是会出问题。
    这就显得比较鸡肋了，但是也不能说没有意义，毕竟写程序还是要独立思考的。
    解决办法就比较简单了，在两个线程的run方法里加上synchronized (testVector)，这样就会使得读取、删除线程中只会有一个对testVector进行操作，也就不会有上述情况出现。
    从这个错误来看的话，编程一定要谨慎，使用到的技术一定要深入了解，不能说不出问题，但是在出了问题之后能找出原因并解决，
    如果没有这个把握就不要轻易去使用，尤其在正式项目中，可能会让你欲哭无泪啊！

* */

队列

• deque 双端对列
• queue 阻塞队列 ArrayBlockingQueue ：一个由数组支持的有界队列。LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
• PriorityQueue 和 ConcurrentLinkedQueue 非阻塞队列

在数学里，幂等有两种主要的定义：在某二元运算下，幂等元素是指被自己重复运算(或对于函数是为复合)的结果等于它自己的元素。如，乘法运算下，0和1符合的自乘运算符和幂等，即s*s=s某一元运算为幂等的时，其作用在任一元素两次后会和其作用一次的结果相同。例如，高斯符号便是幂等的，即f(f(x))=f(x)在计算机中，表示对同一个过程应用相同的参数多次和应用一次产生的效果是一样，这样的过程即被称为满足幂等性在分布式和前后端分离的的项目中，对于restful风格的接口，我们需要保证其接口的幂等性，说白了就是就是一个接口被反复调用不会影响最终结果；为什么呢，因为前后端分离的项目可能会发生这样的场景：前端发出一个请求，但这个请求被阻塞了，然后其重试机制再次发起请求，而恰好此时被阻塞的那个请求又好了，那么这个时候，会对后端发起连续两次请求；对于 get，put,delete 都没问题，连续的两次或者三次都不会影响请求处理结果，但post就有问题了；它会往数据库插入两条数据。