week03 单例作业以及组合模式

关注
发布于: 2020 年 06 月 23 日
﻿
单例模式，就是用来保证一个对象只能创建一个实例，当然，它还提供对实例的全局访问方法。单例模式实现方式如下图：
﻿
﻿
单例模式显示只由单个类组成。为确保单例的唯一性，所有单例构造器都要被声明为私有（private），通过声明静态（static）方法实现全局访问获得该单例实例。
﻿
﻿
代码建模责任链模式主要类主要包含如下特性：
成员属性
ChildComponents: 子组件列表 -> 稳定不变的
成员方法
Do: 执行组件&子组件 -> 变化的
﻿
伪代码实现如下：
﻿
﻿
﻿
一个父类(抽象类)：
- 成员属性
    + `ChildComponents`: 子组件列表
- 成员方法
    + `Do`: 抽象方法
​
组件一，winfrom 窗口(继承父类、看成一个大的组件)： 
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件二，picture(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件三，button(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件四，button(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件五，frame(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件六，lable(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件七，textBox(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件八，Lable(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件九，PasswordBox(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件十，CheckBox(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件十一，TextBox(继承父类)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
组件十二，Linkable(继承父类，未来扩展的组件)：
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
﻿
﻿
﻿
﻿
﻿
﻿
一个接口(interface)：
+ 抽象方法`Do`: 执行组件&子组件
​
一个基础结构体`BaseComponent`：
- 成员属性
    + `ChildComponents`: 子组件列表
- 成员方法
    + 实体方法`ChildsDo`: 执行子组件
​
组件一，winfrom： 
- 合成复用基础结构体`BaseComponent` 
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件二，picture：
- 合成复用基础结构体`BaseComponent` 
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
组件三，button：
- 合成复用基础结构体`BaseComponent` 
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子组件的逻辑
​
...略
​
组件十一，Linkable：
- 合成复用基础结构体`BaseComponent` 
- 成员方法
    + `Do`: 执行当前组件的逻辑，执行子
﻿
demo 代码：
﻿
﻿
﻿
package main
​
import (
    "fmt"
    "reflect"
    "runtime"
)
​
//------------------------------------------------------------
//李锦的测试代码
//组合模式打印输出窗口
//------------------------------------------------------------
​
// Context 上下文
type Context struct{}
​
// Component 组件接口
type Component interface {
    // 执行组件&子组件
    Do(ctx *Context) error
}
​
// BaseComponent 基础组件
type BaseComponent struct {
    // 子组件列表
    ChildComponents []Component
}
​
// Do 执行组件&子组件
func (bc *BaseComponent) Do(ctx *Context) (err error) {
    // do nothing
    return
}
​
// ChildsDo 执行子组件
func (bc *BaseComponent) ChildsDo(ctx *Context) (err error) {
    // 执行子组件
    for _, childComponent := range bc.ChildComponents {
        if err = childComponent.Do(ctx); err != nil {
            return err
        }
    }
    return
}
​
// WinFromComponent WinForm页面组件
type WinFromComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *WinFromComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "WinForm...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// PicComponent LOGO图片组件
type PicComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *PicComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "图片组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// Button1Component 登录组件
type Button1Component struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *Button1Component) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "登录按钮组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// ButtonRComponent 注册按钮组件
type ButtonRComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *ButtonRComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "注册按钮组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// FrameComponent Frame1组件
type FrameComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *FrameComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "Frame1组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// LableComponent 用户名组件
type LableComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *LableComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "用户名组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// TextComponent 文本框组件
type TextComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *TextComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "文本框组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// LablePComponent 密码组件
type LablePComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *LablePComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "密码组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// PasswordBoxComponent 密码框组件
type PasswordBoxComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *PasswordBoxComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "密码框组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// CheckBoxComponent 复选框组件
type CheckBoxComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *CheckBoxComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "复选框组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// TextComponent 记住用户名组件
type TextComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *TextComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "记住用户名组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
// LinkLableComponent 忘记密码组件
type LinkLableComponent struct {
    // 合成复用基础组件
    BaseComponent
}
​
// Do 执行组件&子组件
func (bc *LinkLableComponent) Do(ctx *Context) (err error) {
    // 当前组件的业务逻辑写这
    fmt.Println(runFuncName(), "忘记密码组件...")
​
    // 执行子组件
    bc.ChildsDo(ctx)
​
    // 当前组件的业务逻辑写这
​
    return
}
​
func main() {
    // 初始化WinForm页面 这个大组件
    WinFrom := &WinFromComponent{}
​
    // 挂载子组件
    FrameComponent := &FrameComponent{}
    
    // 开始构建组件数据
    WinFrom.Do(&Context{})
}
​
// 获取正在运行的函数名
func runFuncName() string {
    pc := make([]uintptr, 1)
    runtime.Callers(2, pc)
    f := runtime.FuncForPC(pc[0])
    return f.Name()
﻿