快收藏!最全GO语言实现设计模式【下】

点个关注👆跟腾讯工程师学技术

bfea4d1bece8280e9af580594eb4b693.png

导语| 继上篇【快收藏!最全GO语言实现设计模式】,本文继续列出GO语言实现的经典设计模式示例,每个示例都精心设计,力求符合模式结构,可作为日常编码参考,同时一些常用的设计模式融入了开发实践经验总结,帮助大家在平时工作中灵活运用。

46cfa9d0b62b2c55a62b210154f7974b.jpeg

解释器模式

(一)概念

解释器模式用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下,为了更好地描述某一些特定类型的问题,我们可以创建一种新的语言,这种语言拥有自己的表达式和结构,即文法规则,这些问题的实例将对应为该语言中的句子。此时,可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解,并且掌握编程语言中文法规则的解释过程。

(二)示例

定义一个解析特征值的语句解释器,提供是否包含特征值的终结表达式,并提供或表达式与且表达式,同时,生成南极洲特征判断表达式,及美国人特征判断表达式,最后测试程序根据对象特征值描述,通过表达式判断是否为真。

  • 特征值解释器

package interpreter


import "strings"


// Expression 表达式接口,包含一个解释方法
type Expression interface {
  Interpret(context string) bool
}


// terminalExpression 终结符表达式,判断表达式中是否包含匹配数据
type terminalExpression struct {
  matchData string
}


func NewTerminalExpression(matchData string) *terminalExpression {
  return &terminalExpression{matchData: matchData}
}


// Interpret 判断是否包含匹配字符
func (t *terminalExpression) Interpret(context string) bool {
  if strings.Contains(context, t.matchData) {
    return true
  }
  return false
}


// orExpression 或表达式
type orExpression struct {
  left, right Expression
}


func NewOrExpression(left, right Expression) *orExpression {
  return &orExpression{
    left:  left,
    right: right,
  }
}


func (o *orExpression) Interpret(context string) bool {
  return o.left.Interpret(context) || o.right.Interpret(context)
}


// andExpression 与表达式
type andExpression struct {
  left, right Expression
}


func NewAndExpression(left, right Expression) *andExpression {
  return &andExpression{
    left:  left,
    right: right,
  }
}


func (o *andExpression) Interpret(context string) bool {
  return o.left.Interpret(context) && o.right.Interpret(context)
}
  • 测试程序

package interpreter


import (
  "fmt"
  "testing"
)


func TestInterpreter(t *testing.T) {
  isAntarcticaExpression := generateCheckAntarcticaExpression()
  // 大洲描述1
  continentDescription1 := "此大洲生活着大量企鹅,全年低温,并且伴随着有暴风雪"
  fmt.Printf("%s,是否是南极洲?%t\n", continentDescription1, isAntarcticaExpression.Interpret(continentDescription1))
  // 大洲描述2
  continentDescription2 := "此大洲生活着狮子,全年高温多雨"
  fmt.Printf("%s,是否是南极洲?%t\n", continentDescription2, isAntarcticaExpression.Interpret(continentDescription2))


  isAmericanExpression := generateCheckAmericanExpression()
  peopleDescription1 := "此人生活在北美洲的黑人,说着英语,持有美国绿卡"
  fmt.Printf("%s,是否是美国人?%t\n", peopleDescription1, isAmericanExpression.Interpret(peopleDescription1))


  peopleDescription2 := "此人生活在欧洲,说着英语,是欧洲议会议员"
  fmt.Printf("%s,是否是南极洲?%t\n", peopleDescription2, isAmericanExpression.Interpret(peopleDescription2))


}


// generateCheckAntarcticaExpression 生成校验是否是南极洲表达式
func generateCheckAntarcticaExpression() Expression {
  // 判断南极洲的动物,或关系
  animalExpression := NewOrExpression(NewTerminalExpression("企鹅"),
    NewTerminalExpression("蓝鲸"))
  // 判断南极洲的天气,与关系
  weatherExpression := NewAndExpression(NewTerminalExpression("低温"),
    NewTerminalExpression("暴风雪"))
  // 最终返回动物与天气的与关系
  return NewAndExpression(animalExpression, weatherExpression)
}


// generateCheckAmericanExpression 生成检查美国人表达式
func generateCheckAmericanExpression() Expression {
  // 人种判断,或关系
  raceExpression := NewOrExpression(NewTerminalExpression("白人"),
    NewTerminalExpression("黑人"))
  // 生活方式,与关系
  lifeStyleExpression := NewAndExpression(NewTerminalExpression("英语"),
    NewTerminalExpression("北美洲"))
  // 身份,与关系
  identityExpression := NewAndExpression(lifeStyleExpression, NewTerminalExpression("美国绿卡"))
  return NewAndExpression(raceExpression, identityExpression)
}
  • 运行结果

=== RUN   TestInterpreter
此大洲生活着大量企鹅,全年低温,并且伴随着有暴风雪,是否是南极洲?true
此大洲生活着狮子,全年高温多雨,是否是南极洲?false
此人生活在北美洲的黑人,说着英语,持有美国绿卡,是否是美国人?true
此人生活在欧洲,说着英语,是欧洲议会议员,是否是美国人?false
--- PASS: TestInterpreter (0.00s)
PASS

c2c4ea4d8fceb8ea5ab92f8137501bdd.jpeg

适配器模式

(一)概念

适配器模式是一种结构型设计模式,它能使接口不兼容的对象能够相互合作。

适配器可担任两个对象间的封装器,它会接收对于一个对象的调用, 并将其转换为另一个对象可识别的格式和接口。

(二)示例

通过充电宝给不同充电接口的手机充电是一个非常符合适配器模式特征的生活示例;一般充电宝提供USB电源输出接口,手机充电输入接口则分为两类一是苹果手机的lightning接口,另一类是安卓手机的typeC接口,这两类接口都需要通过适配电源线连接充电宝的USB接口,这里USB接口就相当于充电宝的通用接口,lightning或typeC接口要想充电需要通过充电线适配。

  • 手机充电插头

package adapter


import "fmt"


// HuaweiPlug 华为手机充电插槽接口
type HuaweiPlug interface {
  ConnectTypeC() string
}


// HuaweiPhone 华为系列手机
type HuaweiPhone struct {
  model string
}


// NewHuaweiPhone 华为手机创建方法
func NewHuaweiPhone(model string) *HuaweiPhone {
  return &HuaweiPhone{
    model: model,
  }
}


// ConnectTypeC 华为手机TypeC充电插槽
func (h *HuaweiPhone) ConnectTypeC() string {
  return fmt.Sprintf("%v connect typeC plug", h.model)
}


// ApplePlug 苹果手机充电插槽
type ApplePlug interface {
  ConnectLightning() string
}


// IPhone 苹果系列手机
type IPhone struct {
  model string
}


// NewIPhone 苹果手机创建方法
func NewIPhone(model string) *IPhone {
  return &IPhone{
    model: model,
  }
}


// ConnectLightning 苹果手机Lightning充电插槽
func (i *IPhone) ConnectLightning() string {
  return fmt.Sprintf("%v connect lightning plug", i.model)
}
  • 充电宝适配器

package adapter


import "fmt"




// CommonPlug 通用的USB电源插槽
type CommonPlug interface {
  ConnectUSB() string
}


// HuaweiPhonePlugAdapter 华为TypeC充电插槽适配通用USB充电插槽
type HuaweiPhonePlugAdapter struct {
  huaweiPhone HuaweiPlug
}


// NewHuaweiPhonePlugAdapter 创建华为手机适配USB充电插槽适配器
func NewHuaweiPhonePlugAdapter(huaweiPhone HuaweiPlug) *HuaweiPhonePlugAdapter {
  return &HuaweiPhonePlugAdapter{
    huaweiPhone: huaweiPhone,
  }
}


// ConnectUSB 链接USB
func (h *HuaweiPhonePlugAdapter) ConnectUSB() string {
  return fmt.Sprintf("%v adapt to usb ", h.huaweiPhone.ConnectTypeC())
}


// ApplePhonePlugAdapter 苹果Lightning充电插槽适配通用USB充电插槽
type ApplePhonePlugAdapter struct {
  iPhone ApplePlug
}


// NewApplePhonePlugAdapter 创建苹果手机适配USB充电插槽适配器
func NewApplePhonePlugAdapter(iPhone ApplePlug) *ApplePhonePlugAdapter {
  return &ApplePhonePlugAdapter{
    iPhone: iPhone,
  }
}


// ConnectUSB 链接USB
func (a *ApplePhonePlugAdapter) ConnectUSB() string {
  return fmt.Sprintf("%v adapt to usb ", a.iPhone.ConnectLightning())
}


// PowerBank 充电宝
type PowerBank struct {
  brand string
}


// Charge 支持通用USB接口充电
func (p *PowerBank) Charge(plug CommonPlug) string {
  return fmt.Sprintf("%v power bank connect usb plug, start charge for %v", p.brand, plug.ConnectUSB())
}
  • 测试程序

package adapter


import (
  "fmt"
  "testing"
)


func TestAdapter (t *testing.T) {
  huaweiMate40Pro := NewHuaweiPhone("华为 mate40 pro")
  iphone13MaxPro := NewIPhone("苹果 iphone13 pro max")


  powerBank := &PowerBank{"飞利浦"}
  fmt.Println(powerBank.Charge(NewHuaweiPhonePlugAdapter(huaweiMate40Pro)))
  fmt.Println(powerBank.Charge(NewApplePhonePlugAdapter(iphone13MaxPro)))
}
  • 运行结果

=== RUN   TestAdapter
飞利浦 power bank connect usb plug, start charge for 华为 mate40 pro connect typeC plug adapt to usb 
飞利浦 power bank connect usb plug, start charge for 苹果 iphone13 pro max connect lightning plug adapt to usb 
--- PASS: TestAdapter (0.00s)
PASS

b3fb24379377b7dcebd8b86654d343e4.jpeg

桥接模式

(一)概念

桥接是一种结构型设计模式,可将业务逻辑或一个大类拆分为不同的层次结构, 从而能独立地进行开发。

层次结构中的第一层(通常称为抽象部分)将包含对第二层 (实现部分) 对象的引用。抽象部分将能将一些(有时是绝大部分)对自己的调用委派给实现部分的对象。所有的实现部分都有一个通用接口,因此它们能在抽象部分内部相互替换。

简单的说,一个事物存在多个维度的变化点,每一个维度都抽象出一个接口,事物引用这些接口实现整体行为逻辑,而每一个接口都可以存在多个变化的实现。

更简单的一句话:依赖接口编程。

(二)示例

对于一段经历的描述,经历就可能有多种实现,比如旅游经历,探险经历这相当于第一层次的类结构,同时描述旅游经历或探险经历又包含多个维度,比如如何到达目的地,在目的地开展了什么活动等,到达目的地有很多种方式,比如飞机、火车、汽车等;开展的活动又根据地点不同而不同,海边可以冲浪,山地可以攀岩,荒漠可以徒步穿越等;这两个维度的变化点对于描述经历来说相当于第二层次类实现,通过接口被第一层次引用。

这里对于经历描述存在三个维度的变化,

1.经历本身的两个实现:旅游经历与探险经历。

2.交通方式的两个实现:飞机和汽车。

3.开展活动的三个实现:冲浪、攀岩与徒步穿越。

如果用一个类层次去实现就需要2*2*3=12个不同的实现类,如果用桥接模式仅需要2+2+3=7个不同的类,而且两种方式的加速度也不一样,比如增加一个交通方式火车,非桥接模式需要增加2*3*3-12=6个实现类,桥接模式2+3+3-7=1个实现类;桥接模式大大增加了类之间组合的灵活性。

  • 交通工具

package bridge


// Traffic 交通工具
type Traffic interface {
   Transport() string
}


// airplane 飞机
type airplane struct{}


// Transport 坐飞机
func (a *airplane) Transport() string {
   return "by airplane"
}


// car 汽车
type car struct{}


// Transport 坐汽车
func (t *car) Transport() string {
   return "by car"
}
  • 目的地

package bridge


import "fmt"


// Location 地点
type Location interface {
  Name() string // 地点名称
  PlaySports() string // 参与运动
}


// namedLocation 被命名的地点,统一引用此类型,声明名字字段及获取方法
type namedLocation struct {
  name string
}


// Name 获取地点名称
func (n namedLocation) Name() string {
  return n.name
}


// seaside 海边
type seaside struct {
  namedLocation
}


// NewSeaside 创建指定名字的海边,比如三亚湾
func NewSeaside(name string) *seaside {
  return &seaside{
    namedLocation: namedLocation{
      name: name,
    },
  }
}


// PlaySports 海边可以冲浪
func (s *seaside) PlaySports() string {
  return fmt.Sprintf("surfing")
}


// mountain 山
type mountain struct {
  namedLocation
}


// NewMountain 创建指定名字的山,比如泰山
func NewMountain(name string) *mountain {
  return &mountain{
    namedLocation: namedLocation{
      name: name,
    },
  }
}


// PlaySports 可以爬山
func (m *mountain) PlaySports() string {
  return fmt.Sprintf("climbing")
}


// desert 荒漠
type desert struct {
  namedLocation
}


// NewDesert 创建指定名字的荒漠,比如罗布泊
func NewDesert(name string) *desert {
  return &desert{
    namedLocation: namedLocation{
      name: name,
    },
  }
}


// PlaySports 荒漠可以徒步穿越
func (d *desert) PlaySports() string {
  return fmt.Sprintf("trekking")
}
  • 经历描述

package bridge


import "fmt"


// Experience 经历
type Experience interface {
  Describe() string // 描述经历
}


// travelExperience 旅游经历
type travelExperience struct {
  subject  string
  traffic  Traffic
  location Location
}


// NewTravelExperience 创建旅游经历,包括主题、交通方式、地点
func NewTravelExperience(subject string, traffic Traffic, location Location) *travelExperience {
  return &travelExperience{
    subject:  subject,
    traffic:  traffic,
    location: location,
  }
}


// Describe 描述旅游经历
func (t *travelExperience) Describe() string {
  return fmt.Sprintf("%s is to %s %s and %s", t.subject, t.location.Name(), t.traffic.Transport(), t.location.PlaySports())
}


// adventureExperience 探险经历
type adventureExperience struct {
  survivalTraining string
  travelExperience
}


// NewAdventureExperience 创建探险经历,包括探险需要的培训,其他的与路由参数类似
func NewAdventureExperience(training string, subject string, traffic Traffic, location Location) *adventureExperience {
  return &adventureExperience{
    survivalTraining: training,
    travelExperience: *NewTravelExperience(subject, traffic, location),
  }
}


// Describe 描述探险经历
func (a *adventureExperience) Describe() string {
  return fmt.Sprintf("after %s, %s", a.survivalTraining, a.travelExperience.Describe())
}
  • 测试程序

package bridge


import (
   "fmt"
   "testing"
)


func TestBridge(t *testing.T) {
   // 坐飞机去三亚度蜜月
   honeymoonTravel := NewTravelExperience("honeymoon", new(airplane), NewSeaside("SanyaYalongBay"))
   fmt.Println(honeymoonTravel.Describe())
   // 坐车去泰山毕业旅游
   graduationTrip := NewTravelExperience("graduationTrip", new(car), NewMountain("Tarzan"))
   fmt.Println(graduationTrip.Describe())


   // 野外生存培训后,坐车去罗布泊,徒步穿越
   desertAdventure := NewAdventureExperience("wilderness survival training", "adventure", new(car), NewDesert("Lop Nor"))
   fmt.Println(desertAdventure.Describe())
}
  • 运行结果

=== RUN   TestBridge
honeymoon is to SanyaYalongBay by airplane and surfing
graduationTrip is to Tarzan by car and climbing
after wilderness survival training, adventure is to Lop Nor by car and trekking
--- PASS: TestBridge (0.00s)
PASS

a02de36b719fcc3a2912f82bce79b3cf.jpeg

组合模式

(一)概念

组合是一种结构型设计模式,你可以使用它将对象组合成树状结构,并且能像使用独立对象一样使用它们。

对于绝大多数需要生成树状结构的问题来说,组合都是非常受欢迎的解决方案。组合最主要的功能是在整个树状结构上递归调用方法并对结果进行汇总。

(二)示例

一般来说一个地区统计人口或经济总量,总是通过行政区划一层层上报汇总得出结果,区镇是最低一级行政区划,需要落实统计人口及经济总量的工作,再上一级行政区划需要将所辖区镇的数据汇总统计,以此类推每一级行政区划都需要统计人口与经济总量,就像一个倒过来的树状结构,各级行政区划统一的组件接口是统计人口与经济总量,区镇相当于最底层的叶子节点,中间级别行政区划相当于组合节点;下面代码以苏州市为例;

  • 组件接口

package composite


// Region 行政区,作为组合模式component接口
type Region interface {
   Name() string    // 名称
   Population() int //人口
   GDP() float64    // gdp
}
  • 区镇实现

package composite


// town 区镇,组合模式中相当于叶子节点
type town struct {
  name       string
  population int
  gdp        float64
}


// NewTown 创建区镇,根据名称、人口、GDP
func NewTown(name string, population int, gdp float64) *town {
  return &town{
    name:       name,
    population: population,
    gdp:        gdp,
  }
}


func (c *town) Name() string {
  return c.name
}


func (c *town) Population() int {
  return c.population
}


func (c *town) GDP() float64 {
  return c.gdp
}
  • 县市地市实现

package composite


// cities 市,包括县市或者地市,组合模式中相当于composite
type cities struct {
  name    string
  regions map[string]Region
}


// NewCities 创建一个市
func NewCities(name string) *cities {
  return &cities{
    name:    name,
    regions: make(map[string]Region),
  }
}


func (c *cities) Name() string {
  return c.name
}


func (c *cities) Population() int {
  sum := 0
  for _, r := range c.regions {
    sum += r.Population()
  }
  return sum
}


func (c *cities) GDP() float64 {
  sum := 0.0
  for _, r := range c.regions {
    sum += r.GDP()
  }
  return sum
}


// Add 添加多个行政区
func (c *cities) Add(regions ...Region) {
  for _, r := range regions {
    c.regions[r.Name()] = r
  }
}


// Remove 递归删除行政区
func (c *cities) Remove(name string) {
  for n, r := range c.regions {
    if n == name {
      delete(c.regions, name)
      return
    }
    if city, ok := r.(*cities); ok {
      city.Remove(name)
    }
  }
}


func (c *cities) Regions() map[string]Region {
  return c.regions
}
  • 测试程序

package composite


import (
   "fmt"
   "testing"
)


func TestComposite(t *testing.T) {
   gusu := NewTown("姑苏区", 100, 2000.00)
   fmt.Println(ShowRegionInfo(gusu))
   wuzhong := NewTown("吴中区", 150, 2600.00)
   fmt.Println(ShowRegionInfo(wuzhong))
   huqiu := NewTown("虎丘区", 80, 1800.00)
   fmt.Println(ShowRegionInfo(huqiu))


   kunshan := NewCities("昆山市")
   kunshan.Add(NewTown("玉山镇", 60, 1200.00),
      NewTown("周庄镇", 68, 1900.00),
      NewTown("花桥镇", 78, 2200.00))
   fmt.Println(ShowRegionInfo(kunshan))


   changshu := NewCities("常熟市")
   changshu.Add(NewTown("沙家浜镇", 55, 1100.00),
      NewTown("古里镇", 59, 1300.00),
      NewTown("辛庄镇", 68, 2100.00))
   fmt.Println(ShowRegionInfo(changshu))


   suzhou := NewCities("苏州市")
   suzhou.Add(gusu, wuzhong, huqiu, kunshan, changshu)
   fmt.Println(ShowRegionInfo(suzhou))


}


func ShowRegionInfo(region Region) string {
   return fmt.Sprintf("%s, 人口:%d万, GDP:%.2f亿", region.Name(), region.Population(), region.GDP())
}
  • 运行结果

=== RUN   TestComposite
姑苏区, 人口:100万, GDP:2000.00亿
吴中区, 人口:150万, GDP:2600.00亿
虎丘区, 人口:80万, GDP:1800.00亿
昆山市, 人口:206万, GDP:5300.00亿
常熟市, 人口:182万, GDP:4500.00亿
苏州市, 人口:718万, GDP:16200.00亿
--- PASS: TestComposite (0.00s)
PASS

d56dd9f4658fdeed21ecfa46a77cf14c.jpeg

装饰模式

(一)概念

装饰是一种结构设计模式,允许你通过将对象放入特殊封装对象中来为原对象增加新的行为。

由于目标对象和装饰器遵循同一接口,因此你可用装饰来对对象进行无限次的封装。结果对象将获得所有封装器叠加而来的行为。

(二)示例

地铁进站的过程一般情况下只需要买票,检票进站,但是如果你是带行李,就需要进行安全检查,如果是疫情时期,就需要进行疫情防护检查,比如戴口罩、测量体温等,这里买票进站相当于通用进站流程,安检及防疫检查就相当于加强的修饰行为。

  • 修饰器实现

package decorator


import "fmt"


// Station 车站,修饰器模式统一接口
type Station interface {
  Enter() string // 进站
}


// subwayStation 地铁站
type subwayStation struct {
  name string
}


// NewSubwayStation 创建指定站名地铁站
func NewSubwayStation(name string) *subwayStation {
  return &subwayStation{
    name: name,
  }
}


// Enter 进地铁站
func (s *subwayStation) Enter() string {
  return fmt.Sprintf("买票进入%s地铁站。", s.name)
}


// securityCheckDecorator 进站安检修饰器
type securityCheckDecorator struct {
  station Station
}


func NewSecurityCheckDecorator(station Station) *securityCheckDecorator {
  return &securityCheckDecorator{
    station: station,
  }
}


func (s *securityCheckDecorator) Enter() string {
  return "行李通过安检;" + s.station.Enter()
}


// epidemicProtectionDecorator 进站疫情防护修饰器
type epidemicProtectionDecorator struct {
  station Station
}


func NewEpidemicProtectionDecorator(station Station) *epidemicProtectionDecorator {
  return &epidemicProtectionDecorator{
    station: station,
  }
}


func (e *epidemicProtectionDecorator) Enter() string {
  return "测量体温,佩戴口罩;" + e.station.Enter()
}
  • 测试代码

package decorator


import (
   "fmt"
   "testing"
)


func TestDecorator(t *testing.T) {
   xierqiStation := NewSubwayStation("西二旗")
   fmt.Println(EnhanceEnterStationProcess(xierqiStation, false, false).Enter())
   fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, false).Enter())
   fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, true).Enter())
}


// EnhanceEnterStationProcess 根据是否有行李,是否处于疫情,增加进站流程
func EnhanceEnterStationProcess(station Station, hasLuggage bool, hasEpidemic bool) Station {
   if hasLuggage {
      station = NewSecurityCheckDecorator(station)
   }
   if hasEpidemic {
      station = NewEpidemicProtectionDecorator(station)
   }
   return station
}
  • 运行结果

=== RUN   TestDecorator
买票进入西二旗地铁站。
行李通过安检;买票进入西二旗地铁站。
测量体温,佩戴口罩;行李通过安检;买票进入西二旗地铁站。
--- PASS: TestDecorator (0.00s)
PASS

50066bc61218cf9659dd23d3d1371cea.jpeg

外观模式

(一)概念

外观是一种结构型设计模式,能为复杂系统、程序库或框架提供一个简单 (但有限) 的接口。

尽管外观模式降低了程序的整体复杂度,但它同时也有助于将不需要的依赖移动到同一个位置。

(二)示例

用户在淘宝电商系统买商品时,只需要选好商品在结算页点击提交即可完成下单;在客户端系统仅需要一个创建订单的方法,但是整个订单的生成需要很多步骤,比如查询用户配送地址,查询商品价格,使用优惠券,扣减商品库存,支付相应价钱等。

  • 淘宝电商系统

package facade


import "fmt"


// TaobaoFacade 淘宝网站门面,在淘宝网站下单涉及到多个系统配合调用,包括用户系统,商品系统,优惠券系统,库存系统,支付系统,最终生成订单
type TaobaoFacade struct {
  userService    *UserService
  productService *ProductService
  couponService  *CouponService
  stockService   *StockService
  paymentService *PaymentService
}


// NewTaobaoFacade 创建淘宝网站
func NewTaobaoFacade() *TaobaoFacade {
  return &TaobaoFacade{
    userService: &UserService{},
    productService: &ProductService{
      products: map[string]float64{"笔记本电脑": 6666.66},
    },
    couponService:  &CouponService{},
    stockService:   &StockService{},
    paymentService: &PaymentService{},
  }
}


// CreateOrder 根据用户名,商品名,商品数量生成购买订单
func (t *TaobaoFacade) CreateOrder(userName string, productName string, count int) string {
  // 使用优惠券
  couponInfo := t.couponService.useCoupon()
  // 扣减库存
  stockInfo := t.stockService.decreaseFor(productName, count)
  // 计算商品总价
  sumPrice := t.productService.getProductPrice(productName) * float64(count)
  // 支付价格
  payInfo := t.paymentService.pay(sumPrice)
  return fmt.Sprintf("用户%s,购买了%d件%s商品,%s,%s,%s,送货到%s", userName, count, productName, couponInfo,
    stockInfo, payInfo, t.userService.getUserAddress(userName))
}


// UserService 用户系统
type UserService struct{}


func (u *UserService) getUserAddress(userName string) string {
  return fmt.Sprintf("%s地址是:北京市海淀区中关村大街,1号院2号楼3单元402", userName)
}


// ProductService 商品系统
type ProductService struct {
  products map[string]float64
}


func (p *ProductService) getProductPrice(productName string) float64 {
  return p.products[productName]
}


// CouponService 优惠券系统
type CouponService struct{}


func (c *CouponService) useCoupon() string {
  return "使用满100减20优惠券"
}


// StockService 库存系统
type StockService struct{}


func (s *StockService) decreaseFor(productName string, count int) string {
  return fmt.Sprintf("扣减%d件%s商品库存", count, productName)
}


// PaymentService 支付系统
type PaymentService struct{}


func (p *PaymentService) pay(amount float64) string {
  return fmt.Sprintf("支付金额%.2f", amount)
}
  • 测试程序

package facade


import (
   "fmt"
   "testing"
)


func TestFacade(t *testing.T) {
   // 通过门面模式,隐藏下单过程中,后端多个系统的复杂交互
   taobao := NewTaobaoFacade()
   fmt.Println(taobao.CreateOrder("张三", "笔记本电脑", 1))
}
  • 运行结果

=== RUN   TestFacade
用户张三,购买了1件笔记本电脑商品,使用满100减20优惠券,扣减1件笔记本电脑商品库存,支付金额6666.66,送货到张三地址是:北京市海淀区中关村大街,1号院2号楼3单元402
--- PASS: TestFacade (0.00s)
PASS

30495498c76e7ae96e73ac334dd24bfa.jpeg

享元模式

(一)概念

享元是一种结构型设计模式,它允许你在消耗少量内存的情况下支持大量对象。

模式通过共享多个对象的部分状态来实现上述功能。换句话来说,享元会将不同对象的相同数据进行缓存以节省内存。

(二)示例

北京出租车调度系统,需要每隔一分钟记录一下全市出租车的位置信息,假设为了提高系统响应速度,近一天的数据需要存储在内存中,每个位置信息包括出租车辆信息及位置信息,位置信息在系统中就是一个(x,y)坐标,车辆信息包括车的号牌,颜色,品牌和所属公司,在调度系统存储的出租车行驶轨迹中,位置是实时在变化的,但车辆信息就可以通过享元模式共用一个对象引用,来减少内存消耗。

  • 出租车享元对象

package flyweight


import (
  "fmt"
)


// Taxi 出租车,享元对象,保存不变的内在属性信息
type Taxi struct {
  licensePlate string // 车牌
  color        string // 颜色
  brand        string // 汽车品牌
  company      string // 所属公司
}


// LocateFor 获取定位信息
func (t *Taxi) LocateFor(monitorMap string, x, y int) string {
  return fmt.Sprintf("%s,对于车牌号%s,%s,%s品牌,所属%s公司,定位(%d,%d)", monitorMap,
    t.licensePlate, t.color, t.brand, t.company, x, y)
}


// taxiFactoryInstance 出租车工厂单例
var taxiFactoryInstance = &TaxiFactory{
  taxis: make(map[string]*Taxi),
}


// GetTaxiFactory 获取出租车工厂单例
func GetTaxiFactory() *TaxiFactory {
  return taxiFactoryInstance
}


// TaxiFactory 出租车工厂类
type TaxiFactory struct {
  taxis map[string]*Taxi // key为车牌号
}


// getTaxi 获取出租车
func (f *TaxiFactory) getTaxi(licensePlate, color, brand, company string) *Taxi {
  if _, ok := f.taxis[licensePlate]; !ok {
    f.taxis[licensePlate] = &Taxi{
      licensePlate: licensePlate,
      color:        color,
      brand:        brand,
      company:      company,
    }
  }
  return f.taxis[licensePlate]
}
  • 出租车调度系统

package flyweight


import "bytes"


// TaxiPosition 出租车位置信息 x,y为外在数据信息,taxi为内在数据信息(享元对象)
type TaxiPosition struct {
  x    int
  y    int
  taxi *Taxi
}


func NewTaxiPosition(taxi *Taxi, x, y int) *TaxiPosition {
  return &TaxiPosition{
    taxi: taxi,
    x:    x,
    y:    y,
  }
}


// LocateFor 定位信息
func (p *TaxiPosition) LocateFor(monitorMap string) string {
  return p.taxi.LocateFor(monitorMap, p.x, p.y)
}


// TaxiDispatcher 出租车调度系统
type TaxiDispatcher struct {
  name   string
  traces map[string][]*TaxiPosition // 存储出租车当天轨迹信息,key为车牌号
}


func NewTaxiDispatcher(name string) *TaxiDispatcher {
  return &TaxiDispatcher{
    name:   name,
    traces: make(map[string][]*TaxiPosition),
  }
}


// AddTrace 添加轨迹
func (t *TaxiDispatcher) AddTrace(licensePlate, color, brand, company string, x, y int) {
  taxi := GetTaxiFactory().getTaxi(licensePlate, color, brand, company)
  t.traces[licensePlate] = append(t.traces[licensePlate], NewTaxiPosition(taxi, x, y))
}


// ShowTraces 显示轨迹
func (t *TaxiDispatcher) ShowTraces(licensePlate string) string {
  bytesBuf := bytes.Buffer{}
  for _, trace := range t.traces[licensePlate] {
    bytesBuf.WriteString(trace.LocateFor(t.name))
    bytesBuf.WriteByte('\n')
  }
  return bytesBuf.String()
}
  • 测试程序

package flyweight


import (
   "fmt"
   "testing"
)


func TestFlyweight(t *testing.T) {
   dispatcher := NewTaxiDispatcher("北京市出租车调度系统")
   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 10, 20)
   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 20, 30)
   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 30, 40)
   dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 40, 50)


   dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 20, 40)
   dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 50, 50)


   fmt.Println(dispatcher.ShowTraces("京B.123456"))
   fmt.Println(dispatcher.ShowTraces("京B.567890"))
}
  • 运行结果

=== RUN   TestFlyweight
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(10,20)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(20,30)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(30,40)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(40,50)


北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(20,40)
北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(50,50)
--- PASS: TestFlyweight (0.00s)
PASS

f44d8a66cf6f0eca3cfd5cab379b71aa.jpeg

代理模式

(一)概念

代理是一种结构型设计模式,让你能提供真实服务对象的替代品给客户端使用。代理接收客户端的请求并进行一些处理 (访问控制和缓存等), 然后再将请求传递给服务对象。

代理对象拥有和服务对象相同的接口,这使得当其被传递给客户端时可与真实对象互换。

修饰与代理是非常相似的设计模式,都是基于组合设计原则,也就是说一个对象应该将部分工作委派给另一个对象。但两者之间不同点我认为是,修饰器模式总是要执行服务对象,对于执行之前或执行之后结果进行加强,服务对象基本是客户端创建好再嵌套外层的修饰对象;而代理模式不一定执行服务对象,有可能通过缓存,延迟加载等没有访问服务对象,同时服务对象什么时候创建也是由代理类决定的。

(二)示例

房屋中介代理帮助房东卖房子,这个过程就是一个代理模式的过程,中介会收集尽量多的卖房信息,并通过各种渠道发布,同时中介会随时带客户看房,并初步商讨价格,如果达成初步购买意向,才会约房东讨论房屋价格,最后签约卖房;房屋中介与房东都实现卖房接口,中介会提前坐一些前期工作,如果都没问题,才会约房东执行真正的签约卖房流程。

  • 房屋中介卖房

package proxy


import (
  "bytes"
  "fmt"
)


// HouseSeller 房屋出售者
type HouseSeller interface {
  SellHouse(address string, buyer string) string
}


// houseProxy 房产中介代理
type houseProxy struct {
  houseSeller HouseSeller
}


func NewHouseProxy(houseSeller HouseSeller) *houseProxy {
  return &houseProxy{
    houseSeller: houseSeller,
  }
}


// SellHouse 中介卖房,看房->初步谈价->最终和房东签协议
func (h *houseProxy) SellHouse(address string, buyer string) string {
  buf := bytes.Buffer{}
  buf.WriteString(h.viewHouse(address, buyer) + "\n")
  buf.WriteString(h.preBargain(address, buyer) + "\n")
  buf.WriteString(h.houseSeller.SellHouse(address, buyer))
  return buf.String()
}


// viewHouse 看房介绍基本情况
func (h *houseProxy) viewHouse(address string, buyer string) string {
  return fmt.Sprintf("带买家%s看位于%s的房屋,并介绍基本情况", buyer, address)
}


// preBargain 初步沟通价格
func (h *houseProxy) preBargain(address string, buyer string) string {
  return fmt.Sprintf("讨价还价后,初步达成购买意向")
}


// houseOwner 房东
type houseOwner struct{}


// SellHouse 房东卖房,商讨价格,签署购房协议
func (h *houseOwner) SellHouse(address string, buyer string) string {
  return fmt.Sprintf("最终商讨价格后,与%s签署购买地址为%s的购房协议。", buyer, address)
}
  • 测试程序

package proxy


import (
  "fmt"
  "testing"
)


func TestProxy(t *testing.T) {
  proxy := NewHouseProxy(&houseOwner{})
  fmt.Println(proxy.SellHouse("北京市海淀区中关村大街,2号院1号楼4单元502室", "李四"))
}
  • 运行结果

=== RUN   TestProxy
带买家李四看位于北京市海淀区中关村大街,2号院1号楼4单元502室的房屋,并介绍基本情况
讨价还价后,初步达成购买意向
最终商讨价格后,与李四签署购买地址为北京市海淀区中关村大街,2号院1号楼4单元502室的购房协议。
--- PASS: TestProxy (0.00s)
PASS

90f64c37b19118f36cc63ff4291645e2.jpeg

工厂方法模式

(一)概念

工厂方法模式是一种创建型设计模式,其在父类中提供一个创建对象的方法, 允许子类决定实例化对象的类型。

(二)示例

摊煎饼的小贩需要先摊个煎饼,再卖出去,摊煎饼就可以类比为一个工厂方法,根据顾客的喜好摊出不同口味的煎饼。

  • 接口

package factorymethod


// Pancake 煎饼
type Pancake interface {
  // ShowFlour 煎饼使用的面粉
  ShowFlour() string
  // Value 煎饼价格
  Value() float32
}


// PancakeCook 煎饼厨师
type PancakeCook interface {
  // MakePancake 摊煎饼
  MakePancake() Pancake
}


// PancakeVendor 煎饼小贩
type PancakeVendor struct {
  PancakeCook
}


// NewPancakeVendor ...
func NewPancakeVendor(cook PancakeCook) *PancakeVendor {
  return &PancakeVendor{
    PancakeCook: cook,
  }
}


// SellPancake 卖煎饼,先摊煎饼,再卖
func (vendor *PancakeVendor) SellPancake() (money float32) {
  return vendor.MakePancake().Value()
}
  • 实现

各种面的煎饼实现

package factorymethod


// cornPancake 玉米面煎饼
type cornPancake struct{}


// NewCornPancake ...
func NewCornPancake() *cornPancake {
  return &cornPancake{}
}


func (cake *cornPancake) ShowFlour() string {
  return "玉米面"
}


func (cake *cornPancake) Value() float32 {
  return 5.0
}


// milletPancake 小米面煎饼
type milletPancake struct{}


func NewMilletPancake() *milletPancake {
  return &milletPancake{}
}


func (cake *milletPancake) ShowFlour() string {
  return "小米面"
}


func (cake *milletPancake) Value() float32 {
  return 8.0
}

制作各种口味煎饼的工厂方法实现

package factorymethod


// cornPancakeCook 制作玉米面煎饼厨师
type cornPancakeCook struct{}


func NewCornPancakeCook() *cornPancakeCook {
  return &cornPancakeCook{}
}


func (cook *cornPancakeCook) MakePancake() Pancake {
  return NewCornPancake()
}


// milletPancakeCook 制作小米面煎饼厨师
type milletPancakeCook struct{}


func NewMilletPancakeCook() *milletPancakeCook {
  return &milletPancakeCook{}
}


func (cook *milletPancakeCook) MakePancake() Pancake {
  return NewMilletPancake()
}
  • 运用

package factorymethod


import (
  "fmt"
  "testing"
)


func TestFactoryMethod(t *testing.T) {
  pancakeVendor := NewPancakeVendor(NewCornPancakeCook())
  fmt.Printf("Corn pancake value is %v\n", pancakeVendor.SellPancake())


  pancakeVendor = NewPancakeVendor(NewMilletPancakeCook())
  fmt.Printf("Millet pancake value is %v\n", pancakeVendor.SellPancake())
}

输出:

=== RUN   TestFactoryMethod
Corn pancake value is 5
Millet pancake value is 8
--- PASS: TestFactoryMethod (0.00s)
PASS

c337e765d63ed78d8533ca8349ce57ee.png

抽象工厂模式

(一)概念

抽象工厂是一种创建型设计模式,它能创建一系列相关的对象,而无需指定其具体类。

抽象工厂定义了用于创建不同产品的接口,但将实际的创建工作留给了具体工厂类。每个工厂类型都对应一个特定的产品变体。

在创建产品时,客户端代码调用的是工厂对象的构建方法,而不是直接调用构造函数 ( new操作符)。由于一个工厂对应一种产品变体,因此它创建的所有产品都可相互兼容。

客户端代码仅通过其抽象接口与工厂和产品进行交互。该接口允许同一客户端代码与不同产品进行交互。你只需创建一个具体工厂类并将其传递给客户端代码即可。

(二)示例

厨师准备一餐时,会分别做吃的和喝的,根据早、中、晚三餐饮食习惯,会分别制作不同的饮食,厨师就相当于抽象工厂,制作三餐的不同烹饪方式就好比不同抽象工厂的实现。

  • 接口

package abstractfactory
// Cook 厨师接口,抽象工厂
type Cook interface {
  // MakeFood 制作主食
  MakeFood() Food
  // MakeDrink 制作饮品
  MakeDrink() Drink
}


// Food 主食接口
type Food interface {
  // Eaten 被吃
  Eaten() string
}


// Drink 饮品接口
type Drink interface {
  // Drunk 被喝
  Drunk() string
}
  • 实现

三餐不同厨师接口的实现

package abstractfactory


// breakfastCook 早餐厨师
type breakfastCook struct{}


func NewBreakfastCook() *breakfastCook {
  return &breakfastCook{}
}


func (b *breakfastCook) MakeFood() Food {
  return &cakeFood{"切片面包"}
}


func (b *breakfastCook) MakeDrink() Drink {
  return &gruelDrink{"小米粥"}
}


// lunchCook 午餐厨师
type lunchCook struct{}


func NewLunchCook() *lunchCook {
  return &lunchCook{}
}


func (l *lunchCook) MakeFood() Food {
  return &dishFood{"烤全羊"}
}


func (l *lunchCook) MakeDrink() Drink {
  return &sodaDrink{"冰镇可口可乐"}
}


// dinnerCook 晚餐厨师
type dinnerCook struct{}


func NewDinnerCook() *dinnerCook {
  return &dinnerCook{}
}


func (d *dinnerCook) MakeFood() Food {
  return &noodleFood{"大盘鸡拌面"}
}


func (d *dinnerCook) MakeDrink() Drink {
  return &soupDrink{"西红柿鸡蛋汤"}
}

不同吃的

package abstractfactory


import "fmt"


// cakeFood 蛋糕
type cakeFood struct {
  cakeName string
}


func (c *cakeFood) Eaten() string {
  return fmt.Sprintf("%v被吃", c.cakeName)
}


// dishFood 菜肴
type dishFood struct {
  dishName string
}


func (d *dishFood) Eaten() string {
  return fmt.Sprintf("%v被吃", d.dishName)
}


// noodleFood 面条
type noodleFood struct {
  noodleName string
}


func (n *noodleFood) Eaten() string {
  return fmt.Sprintf("%v被吃", n.noodleName)
}

不同喝的

package abstractfactory


import "fmt"


// gruelDrink 粥
type gruelDrink struct {
  gruelName string
}


func (g *gruelDrink) Drunk() string {
  return fmt.Sprintf("%v被喝", g.gruelName)
}


// sodaDrink 汽水
type sodaDrink struct {
  sodaName string
}


func (s *sodaDrink) Drunk() string {
  return fmt.Sprintf("%v被喝", s.sodaName)
}


// soupDrink 汤
type soupDrink struct {
  soupName string
}


func (s *soupDrink) Drunk() string {
  return fmt.Sprintf("%v被喝", s.soupName)
}

运用

package abstractfactory


import (
  "fmt"
  "testing"
)


func TestAbstractFactory(t *testing.T) {
  fmt.Printf("breakfast: %v\n", HaveMeal(NewBreakfastCook()))
  fmt.Printf("lunch: %v\n", HaveMeal(NewLunchCook()))
  fmt.Printf("dinner: %v\n", HaveMeal(NewDinnerCook()))
}


// HaveMeal 吃饭
func HaveMeal(cook Cook) string {
  return fmt.Sprintf("%s %s", cook.MakeFood().Eaten(), cook.MakeDrink().Drunk())
}

输出

=== RUN   TestAbstractFactory
breakfast: 切片面包被吃 小米粥被喝
lunch: 烤全羊被吃 冰镇可口可乐被喝
dinner: 大盘鸡拌面被吃 西红柿鸡蛋汤被喝
--- PASS: TestAbstractFactory (0.00s)
PASS

863f8cc67005c4166212b677e662b7c5.png

生成器模式

(一)概念

生成器是一种创建型设计模式,使你能够分步骤创建复杂对象。

与其他创建型模式不同,生成器不要求产品拥有通用接口。这使得用相同的创建过程生成不同的产品成为可能。

(二)示例

还是摊煎饼的例子,摊煎饼分为四个步骤,1放面糊、2放鸡蛋、3放调料、4放薄脆,通过四个创建过程,制作好一个煎饼,这个摊煎饼的过程就好比煎饼生成器接口,不同生成器的实现就相当于摊不同品类的煎饼,比如正常的煎饼,健康的煎饼(可能用的是粗粮面、柴鸡蛋、非油炸薄脆、不放酱等),生成器接口方法也可以通过参数控制煎饼的大小,比如放两勺面糊,放2个鸡蛋等。

生成器的使用者为了避免每次都调用相同的构建步骤,也可以通过包装类固定几种构建过程,生成几类常用的产品,就好像摊煎饼有几类常卖固定成品,比如普通的,加两个鸡蛋的,不要香菜的等等,这几类固定构建过程提前定制好,直接通过简单工厂方法就直接创建,如果用户再需要细粒度的定制构建,再通过生成器创建。

  • 接口

package builder


// Quantity 分量
type Quantity int


const (
  Small  Quantity = 1
  Middle Quantity = 5
  Large  Quantity = 10
)


type PancakeBuilder interface {
  // PutPaste 放面糊
  PutPaste(quantity Quantity)
  // PutEgg 放鸡蛋
  PutEgg(num int)
  // PutWafer 放薄脆
  PutWafer()
  // PutFlavour 放调料 Coriander香菜,Shallot葱 Sauce酱
  PutFlavour(hasCoriander, hasShallot, hasSauce bool)
  // Build 摊煎饼
  Build() *Pancake
}


// Pancake  煎饼
type Pancake struct {
  pasteQuantity Quantity // 面糊分量
  eggNum        int      // 鸡蛋数量
  wafer         string   // 薄脆
  hasCoriander  bool     // 是否放香菜
  hasShallot    bool     // 是否放葱
  hasSauce      bool     // 是否放酱
}
  • 实现

正常煎饼创建器

package builder


type normalPancakeBuilder struct {
  pasteQuantity Quantity // 面糊量
  eggNum        int      // 鸡蛋数量
  friedWafer    string   // 油炸薄脆
  hasCoriander  bool     // 是否放香菜
  hasShallot    bool     // 是否放葱
  hasHotSauce   bool     // 是否放辣味酱
}


func NewNormalPancakeBuilder() *normalPancakeBuilder {
  return &normalPancakeBuilder{}
}


func (n *normalPancakeBuilder) PutPaste(quantity Quantity) {
  n.pasteQuantity = quantity
}


func (n *normalPancakeBuilder) PutEgg(num int) {
  n.eggNum = num
}


func (n *normalPancakeBuilder) PutWafer() {
  n.friedWafer = "油炸的薄脆"
}


func (n *normalPancakeBuilder) PutFlavour(hasCoriander, hasShallot, hasSauce bool) {
  n.hasCoriander = hasCoriander
  n.hasShallot = hasShallot
  n.hasHotSauce = hasSauce
}


func (n *normalPancakeBuilder) Build() *Pancake {
  return &Pancake{
    pasteQuantity: n.pasteQuantity,
    eggNum:        n.eggNum,
    wafer:         n.friedWafer,
    hasCoriander:  n.hasCoriander,
    hasShallot:    n.hasShallot,
    hasSauce:      n.hasHotSauce,
  }
}

健康煎饼创建器

package builder


type healthyPancakeBuilder struct {
  milletPasteQuantity Quantity // 小米面糊量
  chaiEggNum          int      // 柴鸡蛋数量
  nonFriedWafer       string   // 非油炸薄脆
  hasCoriander        bool     // 是否放香菜
  hasShallot          bool     // 是否放葱
}


func NewHealthyPancakeBuilder() *healthyPancakeBuilder {
  return &healthyPancakeBuilder{}
}


func (n *healthyPancakeBuilder) PutPaste(quantity Quantity) {
  n.milletPasteQuantity = quantity
}


func (n *healthyPancakeBuilder) PutEgg(num int) {
  n.chaiEggNum = num
}


func (n *healthyPancakeBuilder) PutWafer() {
  n.nonFriedWafer = "非油炸的薄脆"
}


func (n *healthyPancakeBuilder) PutFlavour(hasCoriander, hasShallot, _ bool) {
  n.hasCoriander = hasCoriander
  n.hasShallot = hasShallot
}


func (n *healthyPancakeBuilder) Build() *Pancake {
  return &Pancake{
    pasteQuantity: n.milletPasteQuantity,
    eggNum:        n.chaiEggNum,
    wafer:         n.nonFriedWafer,
    hasCoriander:  n.hasCoriander,
    hasShallot:    n.hasShallot,
    hasSauce:      false,
  }
}

煎饼生成器的封装类-厨师

package builder


// PancakeCook 摊煎饼师傅
type PancakeCook struct {
  builder PancakeBuilder
}


func NewPancakeCook(builder PancakeBuilder) *PancakeCook {
  return &PancakeCook{
    builder: builder,
  }
}


// SetPancakeBuilder 重新设置煎饼构造器
func (p *PancakeCook) SetPancakeBuilder(builder PancakeBuilder) {
  p.builder = builder
}


// MakePancake 摊一个一般煎饼
func (p *PancakeCook) MakePancake() *Pancake {
  p.builder.PutPaste(Middle)
  p.builder.PutEgg(1)
  p.builder.PutWafer()
  p.builder.PutFlavour(true, true, true)
  return p.builder.Build()
}


// MakeBigPancake 摊一个巨无霸煎饼
func (p *PancakeCook) MakeBigPancake() *Pancake {
  p.builder.PutPaste(Large)
  p.builder.PutEgg(3)
  p.builder.PutWafer()
  p.builder.PutFlavour(true, true, true)
  return p.builder.Build()
}


// MakePancakeForFlavour 摊一个自选调料霸煎饼
func (p *PancakeCook) MakePancakeForFlavour(hasCoriander, hasShallot, hasSauce bool) *Pancake {
  p.builder.PutPaste(Large)
  p.builder.PutEgg(3)
  p.builder.PutWafer()
  p.builder.PutFlavour(hasCoriander, hasShallot, hasSauce)
  return p.builder.Build()
}
  • 运用

package builder


import (
  "fmt"
  "testing"
)


func TestBuilder(t *testing.T) {
  pancakeCook := NewPancakeCook(NewNormalPancakeBuilder())
  fmt.Printf("摊一个普通煎饼 %#v\n", pancakeCook.MakePancake())


  pancakeCook.SetPancakeBuilder(NewHealthyPancakeBuilder())
  fmt.Printf("摊一个健康的加量煎饼 %#v\n", pancakeCook.MakeBigPancake())
}

输出

=== RUN   TestBuilder
摊一个普通煎饼 &builder.Pancake{pasteQuantity:5, eggNum:1, wafer:"油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:true}
摊一个健康的加量煎饼 &builder.Pancake{pasteQuantity:10, eggNum:3, wafer:"非油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:false}
--- PASS: TestBuilder (0.00s)
PASS

61e7e5660bc39e11b11e30346db97a25.png

原型模式

(一)概念

原型是一种创建型设计模式,使你能够复制对象,甚至是复杂对象,而又无需使代码依赖它们所属的类。

所有的原型类都必须有一个通用的接口, 使得即使在对象所属的具体类未知的情况下也能复制对象。原型对象可以生成自身的完整副本, 因为相同类的对象可以相互访问对方的私有成员变量。

(二)示例

纸质文件可以通过复印机轻松拷贝出多份,设置Paper接口,包含读取文件内容和克隆文件两个方法。同时声明两个类报纸(Newspaper)和简历(Resume)实现了Paper接口,通过复印机(Copier)复印出两类文件的副本,并读取文件副本内容。

  • 接口实现

package prototype


import (
  "bytes"
  "fmt"
  "io"
)


// Paper 纸张,包含读取内容的方法,拷贝纸张的方法,作为原型模式接口
type Paper interface {
  io.Reader
  Clone() Paper
}


// Newspaper 报纸 实现原型接口
type Newspaper struct {
  headline string
  content  string
}


func NewNewspaper(headline string, content string) *Newspaper {
  return &Newspaper{
    headline: headline,
    content:  content,
  }
}


func (np *Newspaper) Read(p []byte) (n int, err error) {
  buf := bytes.NewBufferString(fmt.Sprintf("headline:%s,content:%s", np.headline, np.content))
  return buf.Read(p)
}


func (np *Newspaper) Clone() Paper {
  return &Newspaper{
    headline: np.headline + "_copied",
    content:  np.content,
  }
}


// Resume 简历 实现原型接口
type Resume struct {
  name       string
  age        int
  experience string
}


func NewResume(name string, age int, experience string) *Resume {
  return &Resume{
    name:       name,
    age:        age,
    experience: experience,
  }
}


func (r *Resume) Read(p []byte) (n int, err error) {
  buf := bytes.NewBufferString(fmt.Sprintf("name:%s,age:%d,experience:%s", r.name, r.age, r.experience))
  return buf.Read(p)
}


func (r *Resume) Clone() Paper {
  return &Resume{
    name:       r.name + "_copied",
    age:        r.age,
    experience: r.experience,
  }
}
  • 运用

package prototype


import (
  "fmt"
  "reflect"
  "testing"
)


func TestPrototype(t *testing.T) {
  copier := NewCopier("云打印机")
  oneNewspaper := NewNewspaper("Go是最好的编程语言", "Go语言十大优势")
  oneResume := NewResume("小明", 29, "5年码农")


  otherNewspaper := copier.copy(oneNewspaper)
  copyNewspaperMsg := make([]byte, 100)
  byteSize, _ := otherNewspaper.Read(copyNewspaperMsg)
  fmt.Println("copyNewspaperMsg:" + string(copyNewspaperMsg[:byteSize]))


  otherResume := copier.copy(oneResume)
  copyResumeMsg := make([]byte, 100)
  byteSize, _ = otherResume.Read(copyResumeMsg)
  fmt.Println("copyResumeMsg:" + string(copyResumeMsg[:byteSize]))
}


// Copier 复印机
type Copier struct {
  name string
}


func NewCopier(n string) *Copier {
  return &Copier{name: n}
}


func (c *Copier) copy(paper Paper) Paper {
  fmt.Printf("copier name:%v is copying:%v ", c.name, reflect.TypeOf(paper).String())
  return paper.Clone()
}

输出

=== RUN   TestPrototype
copier name:云打印机 is copying:*prototype.Newspaper copyNewspaperMsg:headline:Go是最好的编程语言_copied,content:Go语言十大优势
copier name:云打印机 is copying:*prototype.Resume copyResumeMsg:name:小明_copied,age:29,experience:5年码农
--- PASS: TestPrototype (0.00s)
PASS

110eb6014e805d7bd8f83b711213dfe1.png

单例模式

(一)概念

单例是一种创建型设计模式,让你能够保证一个类只有一个实例,并提供一个访问该实例的全局节点。

单例拥有与全局变量相同的优缺点。尽管它们非常有用,但却会破坏代码的模块化特性。

(二)示例

通过地球对象实现单例,earth不能导出,通过TheEarth方法访问全局唯一实例,并通过sync.Once实现多协程下一次加载。

  • 接口实现

package singleton


import "sync"


var once sync.Once


// 不可导出对象
type earth struct {
  desc string
}


func (e *earth) String() string {
  return e.desc
}


// theEarth 地球单实例
var theEarth *earth


// TheEarth 获取地球单实例
func TheEarth() *earth {
  if theEarth == nil {
    once.Do(func() {
      theEarth = &earth{
        desc: "美丽的地球,孕育了生命。",
      }
    })
  }
  return theEarth
}
  • 运用

package singleton


import (
  "fmt"
  "testing"
)


func TestSingleton(t *testing.T) {
  fmt.Println(TheEarth().String())
}

输出

=== RUN   TestSingleton
美丽的地球,孕育了生命。
--- PASS: TestSingleton (0.00s)
PASS

点击下方空白 ▼ 查看明日开发者黄历

0967d586466834d35b137a8aa24debd6.png

summer

time

2022

/

07.23

b235a3f5c08a2661a294edf29fcaa902.png

相关推荐

大模型的Agent Skill功能,在LLM HTTP底层交互流中是怎么承载的?

网络文章文本的 skill,昨天我实现了之后也就开始好奇起 Skills 的底层原理了——相比起各种花里胡哨的 agrnt 应用,我一直以来都很对大模型在纯粹的 HTTP 交互层面是如何交互的更感兴趣。Skill 的全部"魔法"都发生在 system prompt 的措辞和 SKILL.md 文件的编写质量上——本质上是一种 prompt engineering + 文件系统的组合。但是各种天花乱坠的 skills,是如何在底层的 HTTP 中,与大模型——这个只会嘴遁的工具交互的呢?

QcloudCommunity的博客 407

万字入门AI Infra:深入理解大模型中的数学与Infra优化

关注腾讯云开发者,一手技术干货提前解锁👇AI Infra科普、入门或者进阶 ~~ 不到 5 万字,带你融会贯通理解大模型的数学、算法、硬件到系统工程。任何问题欢迎沟通交流。可怕,我竟然有点认同这句话。当然大概率是因为姚顺宇太懂AI了,而我则是因为无知者无畏。不过仔细想想,大模型推理中的数学逻辑确实不复杂,很多原理只需要高中数学知识就能看懂。但是为什么像 vLLM 这种推理系统这么复杂呢?本文将拆解大模型中几个核心操作(RMSNorm、Softmax、Causal Mask、Sampling)背后的数学与

QcloudCommunity的博客 1170

平平无奇的源码,竟藏着Agent的核心秘密?

System Prompt 是剧本,Skill 是剧本的扩展包,Agent Loop 是演员按剧本行动。欢迎留言,我们将邀请作者针对性回复你的评论,我们将选取1则优质的评论,送出腾讯云定制文件袋套装。,让 Agent 能主动"巡逻",而不只是被动等待用户消息。OpenClaw 的 System Prompt 分层结构。的"行为底线",任何 Skill 或用户命令都无法覆盖它。精华 2:Skill 的"按需加载"避免 token 浪费。精华 1:System Prompt 是"分层乐高积木"

QcloudCommunity的博客 426

QQ音乐Harness Engineering实践

一个看似简单的需求,背后可能牵动服务调用链、配置、灰度、埋点、错误码、接口契约和历史兼容性。当 AI 开始快速生成大量代码,真正的瓶颈就不再是"写不出来",而是"看不完、想不清、管不住"。在对话式编码阶段,一种典型的工作模式逐渐流行:开发者把需求丢给 AI,扫一眼输出"看起来对"就直接采纳,不审 diff、不追问逻辑、不验证边界。以音乐商业化业务为例,一个需求可能从 TAPD 单开始,经过需求评审、技术方案、服务影响面分析、IDL 契约变更、业务代码实现、测试验证、CR、灰度上线,最后才进入稳定运行。

QcloudCommunity的博客 716

从Prompt、Context到Harness,工程的三次进化与终局之战

同时,强制要求散落各处的决策记录(Slack、邮件、文档)全部迁移至代码仓库,确保 Agent 的唯一信息来源是可信的、版本受控的仓库。更坑爹的是,研究表明,当上下文过长时,模型会出现"中间遗忘(Lost in the Middle)"现象:它对开头和结尾的内容记忆较好,对中间大段内容的关注度大幅下降。这篇文章,我想带你完整走一遍这三次进化的逻辑:它们分别解决了什么问题,它们之间是什么关系,它们的边界在哪里,以及:当三者融合,AI 工程师的终极形态究竟是什么?大语言模型的本质,就是这位金鱼助理。

QcloudCommunity的博客 719

让Skill自己训练自己:8阶段Loop、3层评测、5维AND门控,从此实现自进化

所以每一轮改动都是有据可查的,不是「感觉这里可以优化」,而是「Case 41 挂了,因为 agent 把离职问题路由到了邮箱分类,但正确答案在通讯录,所以我改 root_index.md 加个易混淆提示」。但让我最后决定把它记录下来的,不是这的个「吸收」过程,而是它真的在替我探索我不想费脑力触达的边界,这看起来更像是一个机器智能应该有的样子。不准跨层,每轮只改一层的东西。但我经过这 19 轮之后觉得,更准确的描述是互补——你在明处看着,AI 在暗处替你试错,你看不见的那一半就是 AI 能贡献的地方。

QcloudCommunity的博客 1128

只加两行代码,为什么要两天?一文深度理解业务系统的复杂性

关注腾讯云开发者,一手技术干货提前解锁👇业务系统复杂性一直是令开发者头痛的问题。复杂的不是增加一个需求需要耗费多少时间,而是在增加一个需求后带来的蝴蝶效应:其它功能会不会受到影响、要如何去找到这些影响,最终如何实现系统正常运行......功能之间隐秘增加的耦合、不可避免的代码腐化在导致业务复杂性增加。大家都在说的软件开发提效到底在提什么?程序员日常工作中应该如何提升开发效率?敏捷开发、瀑布流式开发孰是孰非?欢迎阅读。业务背景与目标我依然非常清晰地记得某个时候,我所在团队 Leader 曾讲过一段话:“我担

QcloudCommunity的博客 713

从零设计生产级 Multi-Agent Harness:架构、评估、记忆、成本与 MCP 工具接入全拆解

在 AI Agent 领域,Multi-Agent Harness 指的是把多个 Agent 的能力、工具、状态、通信、编排、监控统一收束在一个运行时之内的框架。第三,Agent 路由。一个输入框,一个大模型,几个工具,一段写得很漂亮的 System Prompt,再配上一个炫酷的前端,看起来就像一个能干活的“数字员工”。Multi-Agent 完全不一样——它有计划、有中间步骤、有工具调用、有 Agent 协作、有重试、有反思、有最终合成。增加 Budget、权限、重试、压缩、轨迹评估、审计、回归测试。

QcloudCommunity的博客 710

拆完Hermes源码,我发现Agent的“自我进化“根本不需要训练模型

两个月 5.2 万 Star,Hermes Agent 用一个"LLM 审判官"机制实现了 Agent 的自我进化——不改模型权重,只改"怎么用模型"的策略。OpenClaw(社区昵称"龙虾"🦞)是 2025-2026 年最火的开源 Agent 框架,30 万+ Star,插件市场 ClawHub 里有数千个插件,能接入 Telegram、WhatsApp、Slack、飞书、企业微信——几乎是一个"个人 AI 操作系统"。Skill 是英语写的,Memory 是英语写的,审查 Prompt 也是英语写的。

QcloudCommunity的博客 911

AI Infra 其实没有多少新东西

传统 Infra 追求横向扩展,而 AI Infra 呈现 “AI 大型机”特性,是因为传统后台服务的可以容忍毫秒级延迟,但 AI 集群不行,GPU 的算力是 CPU 的数百倍,微秒级的延时等待也会造成很大的算力损耗,需要硬件的高度集成。在可预见的1-3年的未来,这样的专用硬件+网络的集中式架构很难发生比较大的改变。与之相似,模型推理的批处理就是将多个输入样本打包(batch),将原本串行的 N 次轻量的推理计算,合并为 1 次重量的计算,实现单位时间内处理更多的请求,提高了 GPU 利用率。

QcloudCommunity的博客 826

程序员越早想通这些越好

永远没有正确架构,你永远无法偿还完所有的技术债务,如同你永远不会设计出完美的界面,请避开完美主义的陷阱,永远没有完美的代码,能够满足当前需求,又为未来不管是自己还是他人留有扩展空间,就很好了。我们努力的方向就是将现实世界映射到有限的数据结构中,这就需要用户自定义类型,如果你的代码中包含类似 trader portfolio 这样的概念,你就可以使用他们的名称来建模,而不是使用基本数据类型复杂嵌套表述你的目的。从另一个角度看,代码里的注释都是补丁,是碎片化的,局部的注释很难推导模块整体的顺序及耦合关系。

QcloudCommunity的博客 466

RAG已死?不,是Grep回归了!

这样一来可以直接复用已有的计算缓存,只为新增的增量部分付全价,前面累积的大头按约 1/10 的缓存价计费。所以实际的工具组合方式是灵活的:Grep(默认模式)→ Read 是最常见的路径,但 Grep(content 模式)可以独立使用,LLM 也可以直接调 Read(如果已经知道文件路径),或者一次同时发起多个 Grep 并行搜索。它从零开始构建自己的对话历史,不继承主对话的消息,这意味着它搜索过程中产生的大量 grep 结果、代码片段都留在自己的 context 里,主对话只收到一段总结性的文本结论。

QcloudCommunity的博客 576

深入浅出Harness Engineerring之核心模式与理念

在智能体生命周期的关键节点(如会话开始、工具调用后)自动触发预设动作(如代码格式化),由系统确保关键流程被执行,不依赖可能被模型遗忘的指令。简单讲就是利用向量存储这个技术,来实现模糊检索,原理是:即使字面不同,但语义相近的文本,其向量在数学空间中的位置也很接近。根据命令类型、参数和影响,自动评估其风险等级(安全、有风险、危险),并采取自动执行、请求确认或直接拦截等不同策略。关键特性是可隔离、可重建、可扩展。不是一次判断就定终身,允许你改变、允许情况复杂,通过不断观察、思考、调整,越来越懂真实的你。

QcloudCommunity的博客 625

Harness Engineering实践心得:如何高效驾驭AI?

但如果这些经验被拆成一条条 Rule、一个个 Skill、一项项 Script 检查——"XAML 不能有中文"、"编译要用这个路径的 MSBuild"、"SVN 命令必须带认证参数"——AI 就能在秒级时间里"吸收"十年的踩坑经验。然后可以看到下方的图,我的PM会很顺利的调度其他agent分别负责不同的事项,遇到问题的时候也能准确的找到合适的agent。MCP 本质上是在扩展 AI 的"感知范围"——Rule 管"该怎么做",Skill 管"怎么操作",MCP 管"能看到什么、能碰到什么"。

QcloudCommunity的博客 843

从第一性原理思考 Agentic Engineering

需要注意的是,这一结论是有条件的:如果 AI 缺乏领域知识,过早介入反而可能引入 1.2 节所述的"似是而非"损耗——因此上下文供给(实践 1)是 AI 全链条参与的前提,而非结果。通过一个专门的自迭代 Skill 实现——当 AI 在协作过程中识别到自己被纠正(用户否定了 AI 的输出并给出了正确方向),它自动评估这个错误的根因,搜索现有的 Rules 和 Skills 中是否已有针对该类问题的处理规则。事实上,越是复杂的项目,工程师的认知负担越重(公理 3),AI 分担认知负担的潜在边际价值也越大。

QcloudCommunity的博客 757

万字干货!Harness Engineering如何工程化落地?

关注腾讯云开发者,一手技术干货提前解锁👇Harness Engineering 的概念已经火了有一阵了,全网很多文章基本都是在讲理念,讲为什么今天做 AI 开发,不能只靠一段提示词,也不能把模型当一个“更聪明的代码补全”。但与此同时,一个问题也在持续地发酵:这个问题特别重要。因为 Harness 这个词听上去很大,很像一个抽象的方法论,但它如果不能落到工程、目录、文档、脚本、工作流里,那它最后就只是一句漂亮的话。事实上,不同项目落地出来的 Harness,表面上可能完全不一样。有的项目是 CI 很强,有的

QcloudCommunity的博客 1171

全方位对比:Hermes VS OpenClaw

多账号矩阵运营 如果你的业务涉及同时管理多个社交媒体账号、多个平台的内容分发、多渠道的客户互动——OpenClaw是目前市场上的"无可替代的底座"。一个有专业背景的个人,现在可以快速构建一个垂直领域的AI助手:比如"财务分析Hermes"、"法律咨询Hermes"、"技术架构Hermes",直接通过微信提供服务,积累自己的专业IP。跨平台生态融合 如果你的工作流涉及飞书、Slack、Discord等多个平台的深度集成,需要这些平台之间的数据流转和联动——OpenClaw的生态支持是强大的。

QcloudCommunity的博客 1218

一文讲透:Harness Engineering即控制论!

而研发模式的升级我认为将会是一个飞跃的过程,之所以现在我们仍然需要需要参与编码,一个非常大的原因就是缺乏传感器和基建,仍然需要人来串流程,比如需要人来验证UI是否正确、需要人来告诉AI代码不符合代码规范,因此在有些场景我们仍然感觉 AI 完成的很吃力,但这不是 AI 能力不行,而是我们并没有为 AI 提供友好的环境……控制论中的突变理论介绍了矫枉过正和飞跃现象之间的矛盾,如果质变中经历的中间过渡态是不稳定的,那么他就是一个飞跃的过程,如果中间过渡态是稳定的,那么他就是一个渐变的过程。但是这些阶段要解决的。

QcloudCommunity的博客 1204

神级开源插件!一句话让QClaw变3D小镇,Agent工作可视化,赛博云监工

这个架构是翻了几次车才想通的—原有AI的实现机制是用 setTimeout 猜动画时长导致了幽灵 NPC、工位撞车、越改越崩,后面我停下来换了思路,推翻原有的架构,按照“意图+回传”的架构进行重构,之前的问题一次性全部解决。15 天,我和 AI 吵了 185 次架, 4.5 万行代码,开发了一款 QClaw / OpenClaw 的UGC游戏插件,这可能是人类跟 Agents 交互的新范式,插件已完全开源,有需要的欢迎自取~我天天用,用着用着我就在思考,Agent 产品现在的交互体验,基本都一个样。

QcloudCommunity的博客 1197

一文搞懂Hermes:新顶流Agent如何从经验中自我进化

Voyager 是一个能在 Minecraft 中自主探索、学习技能、无限积累能力的 AI Agent,它提出了 "Skill Library"(技能库)的概念——Agent 将成功的行为序列编码为可复用的技能函数,存储在一个持续增长的代码库中。如果 Skill 的名称和描述不够精准,或者用户的任务描述与 Skill 的触发条件有语义差距,Agent 可能会错过相关的 Skill。如果进程在写入过程中崩溃,目标文件要么是旧内容(还没被替换),要么是新内容(替换已完成),绝不会出现写了一半的损坏文件。

QcloudCommunity的博客 2637

自掏腰包一万元,拥抱AI这一年,我的工具、实践和思考

其实也很好理解,过往的每个领域(比如前端、后端、设计、测试等等)都主要是这个领域的从业者在为它添砖加瓦,但是大模型时代的 AI 应用领域却几乎是所有使用 AI 的人类一起在迭代,无分领域,无分文理,无分老少。因为每个时期的 AI 都有着不同的特点,很多时候当我费尽心思去钻研,自以为有点弄明白 AI 应该怎么玩的时候,基座模型和行业范式常常就会迎来颠覆式的变革,很多过往的经验都会倾覆,然后只能从头再来。过去一年多,被热议的 AI 范式大概是沿着四个阶段递进演化,每一个阶段其实都在解决前一个阶段的核心问题。

QcloudCommunity的博客 627

办公Agent的CI/CD时刻到来了

核心观点是:企业给员工配了一堆 AI 工具,试点跑了几百个,但真正拖慢 AI 转型速度的瓶颈不在模型能力,在"最后一公里":AI 输出和实际工作流之间的那道鸿沟。代码写完,打个 tar 包,开 FTP 传到服务器上,SSH 进去解压,改配置文件,重启服务,刷一下页面祈祷别 500。你复制,切窗口,粘贴到腾讯文档里,发现 Markdown 格式全乱了,手动调标题层级,代码块重新标记语言类型,表格散架了重排一遍。模型是越来越聪明了,但"生成"到"落地"之间那段路,还是你自己在走,一步一步,手动搬运。

QcloudCommunity的博客 608

4亿token买来5个教训:让6个AI Agent连写4天代码发生了什么?

Watchdog 检测到崩溃 → 启动诊断 Agent 分析原因 → 诊断 Agent 跑满 20 轮没搞定 → Watchdog 判定“已修复”,重启系统 → 重启的系统因为诊断 Agent 留下的环境变量被继承,连续 3 次拒绝启动 → 触发连续失败保护退出 → Watchdog 第 3 次巡检,发现进程和记录文件都没了,尝试手动重启,自己也停了。启动前我翻了论文、做了架构设计、写了监控+修复异常的脚本。这个发现让我的情绪从沮丧变成了兴奋——不是那种"终于修好了"的释然,是"我找到根因了"的快感。

QcloudCommunity的博客 584

赛博斗蛐蛐:9大模型决战三国志,天命在谁?

我猜是这样的,当Gemini面临决策的时候,一系列关键词比如 守城,劣势,粮草,三国等等,在语义层面的关联性中LLM发现了竖壁清野这个关键词概率非常高,所以以此为策略,然后再根据这个策略完美执行操作。MiMo 的外交是三方中最精明的。Kimi作为国产模型,也同样颠覆了我对他的看法,最后的比赛他甚至一度是优势者,存在很多夺冠的可能性,要知道他的对手可是claude和gemini,而他经常出兵慢,回过头来想想或许正是他的策略,毕竟中后期他的优势都来自于稳健的发展和较少的战斗频率(和claude比).

QcloudCommunity的博客 875

Claude Code是怎么知道你在骂他的?这 12 条发现值得关注

确实存在——5,500+ 行,集成了消息队列、工具装配、MCP 编排、会话状态、权限、分析、文件持久化和优雅关闭,基本上一个文件干了所有事。对抗虚假声明——"不要在输出显示失败时声称所有测试通过,不要压缩或简化失败的检查来制造绿色结果"。完整的 KAIROS 是一个持续驻留的守护进程,能感知你在不在电脑前、主动寻找有用的工作做,更像是住在终端里的全职同事。源码里藏着一个叫 "Buddy" 的电子宠物系统,完整度令人惊讶——这不是一个 TODO,而是一个从数值系统到 ASCII 动画都实现了的完整功能。

QcloudCommunity的博客 702

逆向深扒Claude Code源码,我发现了什么!?

Anthropic 内部用户获得更严格的质量控制 prompt、更好的验证机制(独立 Verification Agent)、以及针对 model 弱点的专门对策(如 Capybara v8 的 29-30% 错误声明率对策)。这不是代码混乱的标志——它是整个 Agent Loop 的心脏,所有的流式处理、工具调度、上下文压缩、子代理管理都在这个文件中协调。这种"胖核心"设计是刻意的:保持核心循环的原子性,避免分散到多个模块导致的协调复杂度。核心价值:Fork 代理的工具输出不会回到主代理的上下文窗口。

QcloudCommunity的博客 893

一文讲透如何构建Harness——六大组件全解析

本文将从"裸模型的四个硬伤"出发,逐一拆解 Harness 的六大组件——文件系统、Bash + 沙箱、记忆(AGENTS.md)、Web Search + MCP、上下文工程、编排 + Hooks——带你看清 AI Agent 真正的竞争壁垒,不在模型层,而在 Harness 层。如果你用过 Agent 做复杂任务,你一定有过这样的体验:一开始 Agent 的表现很好,但随着对话变长,它开始"变笨"——遗忘之前的约定,重复之前犯过的错误,甚至对同一个问题给出前后矛盾的回答。对于简单的问答场景,这无所谓。

QcloudCommunity的博客 761

Harness Engineering 来了,SDD 还有意义吗?

他们的解法是把「品味」编码进规则,然后用一个定期运行的「doc-gardening」Agent 自动扫描漂移、发起修复 PR——「技术债务就像一笔高息贷款,不断地以小额贷款的方式偿还,总比让债务不断累积要好」。代码仓库本地的、已版本化的工件,才是 Agent 所能看到的全部。在 Vibe Coding 模式下(即不做规划、随意向 AI 提需求的开发方式),大量设计决策、跨服务约定、「为什么不选另一个方案」的讨论,全部停留在一次性的 AI 对话里——下一个人,或者下一次 AI 会话,完全无从获取。

QcloudCommunity的博客 419

零废话!一文讲透从0构建AI Agent

每个工具都要写一套"定义→解析→执行"的胶水代码。上下文管理就是在"记住足够多"和"别超标"之间找平衡,常见策略包括滑动窗口、摘要压缩、RAG 检索增强。上下文窗口是 Agent 的"工作记忆",但它有硬性限制。LLM 负责"动脑"决策,代码负责"动手"执行。这是从"聊天机器人"进化到"Agent"的关键一步。每次调 API 都把完整对话历史发过去,LLM 本身是无状态的,"记忆"完全靠客户端的数组模拟。这样 Agent 一开始就知道自己"在哪里"、"手头有什么",不需要先花一轮工具调用去探索环境。

QcloudCommunity的博客 711

距离AI把小编我裁掉还有72小时

这是一个基于 OpenClaw 开源生态打造的本地化 AI Agent 助手,已于上周开启全量公测,无需复杂配置,三步即可上手,自带安全防护,支持微信直连绑定,内置多款优质国产大模型,现阶段也是完全免费使用,基本上前面提到过的痛点都可以靠它解决。对了,这里特别强调一点,上面的截图让产品同事汗流浃背,再三找我确认 QClaw 思考过程中优美的“草”字说法,不会是默认出现的吧?AI 好,AI 得学,但更重要的是,在你的工作和生活里,哪些东西是能结构化地被 AI 所接入的,不要死守着那些脏活累活不放。

QcloudCommunity的博客 674
上一篇: 如何更好地使用Kafka?
下一篇: 从鹅厂实例出发!分析Go Channel底层原理
腾讯云开发者
腾讯云开发者 企业官方账号 企业官方账号
博客等级 码龄10年 6291粉丝 1962原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值