当前位置：首页 > article >正文

15分钟学 Go 第 56 天：架构设计基本原则

article 2024/11/17 17:12:14

第56天：架构设计基本原则

学习目标

理解和掌握基本的架构设计原则，以提升软件系统的可维护性、可扩展性和可重用性。

内容提纲

架构设计原则概述
常见架构设计原则
- 单一职责原则 (SRP)
- 开放/封闭原则 (OCP)
- 里氏替换原则 (LSP)
- 接口分离原则 (ISP)
- 依赖反转原则 (DIP)
架构设计的最佳实践
示例代码
运行流程图
总结

1. 架构设计原则概述

架构设计原则是开发软件系统时用以指导设计和开发过程的基本准则。这些原则帮助开发者创建更优秀的软件架构，从而确保可维护性、可扩展性、可重用性和良好的性能。

2. 常见架构设计原则

2.1 单一职责原则 (SRP)

定义：一个类应该只有一个原因引起它的变化。换句话说，每个类应该专注于完成一项职责。

示例代码：

package main

import "fmt"

// 用户管理类
type User struct {
    Name string
    Age  int
}

// 发送邮件功能
type EmailService struct{}

func (es *EmailService) SendEmail(email string) {
    fmt.Printf("Sending email to %s\n", email)
}

// 用户服务
type UserService struct {
    emailService *EmailService
}

func (us *UserService) CreateUser(name string, age int, email string) {
    user := User{Name: name, Age: age}
    fmt.Printf("User created: %+v\n", user)
    us.emailService.SendEmail(email)
}

func main() {
    emailService := &EmailService{}
    userService := &UserService{emailService: emailService}
    userService.CreateUser("Alice", 30, "alice@example.com")
}

运行流程图：

+---------------------+
|  创建 UserService   |
|  +----------------+  |
|  | EmailService   |  |
|  +----------------+  |
+---------------------+
           |
  +---------------------+
  |  CreateUser        |
  +---------------------+
           |
  +---------------------+
  |  发送邮件          |
  +---------------------+

2.2 开放/封闭原则 (OCP)

定义：软件实体（类、模块、函数等）应当对扩展开放，对修改封闭。即，应该可以通过添加新功能或新代码来扩展系统，而不需要去修改现有的代码。

示例代码：

package main

import "fmt"

// Shape 接口
type Shape interface {
    Area() float64
}

// 矩形
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 圆
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

// 计算总面积
func TotalArea(shapes []Shape) float64 {
    total := 0.0
    for _, shape := range shapes {
        total += shape.Area()
    }
    return total
}

func main() {
    shapes := []Shape{
        Rectangle{Width: 10, Height: 5},
        Circle{Radius: 7},
    }
    fmt.Printf("Total Area: %.2f\n", TotalArea(shapes))
}

运行流程图：

+---------------------+
|   TotalArea        |
+---------------------+
           |
+----------+----------+
|                     |
|                     |
+                     +
|                     |
+--------+------------+
|  计算每个 Area     |
+---------------------+

2.3 里氏替换原则 (LSP)

定义：子类对象能够替换父类对象，并且在程序运行中不会影响程序的正常运行。

示例代码：

package main

import "fmt"

// Bird 接口
type Bird interface {
    Fly() string
}

// Sparrow 是 Bird 的实现
type Sparrow struct{}

func (s Sparrow) Fly() string {
    return "Sparrow flying"
}

// Ostrich 是 Bird 的实现，但不能飞
type Ostrich struct{}

func (o Ostrich) Fly() string {
    return "Ostrich can't fly"
}

// 使用 Bird 接口
func MakeBirdFly(bird Bird) {
    fmt.Println(bird.Fly())
}

func main() {
    sparrow := Sparrow{}
    ostrich := Ostrich{}

    MakeBirdFly(sparrow) // 输出: Sparrow flying
    MakeBirdFly(ostrich) // 输出: Ostrich can't fly
}

运行流程图：

+---------------------+
|   MakeBirdFly      |
+---------------------+
           |
+----------+----------+
|                     |
|                     |
+                     +
|                     |
+--------+------------+
|  调用 Fly 方法     |
+---------------------+

2.4 接口分离原则 (ISP)

定义：客户端不应该被迫依赖于它不使用的方法。即接口应该尽可能的细小，客户端只需关注自身需要的方法。

示例代码：

package main

import "fmt"

// 形状接口
type Shape interface {
    Area() float64
}

// 3D 形状接口
type ThreeDimensionalShape interface {
    Shape
    Volume() float64
}

// 矩形
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 立方体
type Cube struct {
    Side float64
}

func (c Cube) Area() float64 {
    return 6 * (c.Side * c.Side)
}

func (c Cube) Volume() float64 {
    return c.Side * c.Side * c.Side
}

func main() {
    var shapes []Shape
    shapes = append(shapes, Rectangle{Width: 10, Height: 5})

    for _, shape := range shapes {
        fmt.Printf("Area: %.2f\n", shape.Area())
    }

    cube := Cube{Side: 3}
    fmt.Printf("Cube Area: %.2f, Volume: %.2f\n", cube.Area(), cube.Volume())
}

运行流程图：

+---------------------+
|  计算形状面积      |
+---------------------+
           |
+----------+----------+
|                     |
|                     |
+                     +
|                     |
+--------+------------+
|  计算立方体体积    |
+---------------------+

2.5 依赖反转原则 (DIP)

定义：高层模块不应依赖于低层模块，二者应依赖于抽象（接口）。抽象不应依赖于细节，细节应依赖于抽象。

示例代码：

package main

import "fmt"

// 数据库接口
type Database interface {
    Query() string
}

// MySQL 数据库实现
type MySQL struct{}

func (m MySQL) Query() string {
    return "Query from MySQL"
}

// PostgreSQL 数据库实现
type PostgreSQL struct{}

func (p PostgreSQL) Query() string {
    return "Query from PostgreSQL"
}

// 数据库服务
type DatabaseService struct {
    db Database
}

func (ds *DatabaseService) Execute() {
    fmt.Println(ds.db.Query())
}

func main() {
    mysqlService := &DatabaseService{db: MySQL{}}
    mysqlService.Execute()  // 输出: Query from MySQL

    postgresService := &DatabaseService{db: PostgreSQL{}}
    postgresService.Execute() // 输出: Query from PostgreSQL
}

运行流程图：

+---------------------+
|  DatabaseService    |
+---------------------+
           |
+----------+----------+
|                     |
|                     |
+                     +
|                     |
+-------+-------------+
|  执行 Query 方法    |
+---------------------+