第一章：Go语言接口机制概述

Go语言的接口机制是一种实现多态行为的重要手段，它将方法的定义与实现分离，使得不同结构体可以通过实现相同的方法集来满足接口的需求。与传统的面向对象语言不同，Go语言的接口采用隐式实现的方式，无需显式声明某个结构体实现了某个接口，只要方法签名匹配即可。

在Go中，接口类型由一组方法签名组成。任何类型只要实现了这些方法，就自动满足该接口。这种设计极大提升了代码的灵活性和可扩展性。例如：

// 定义一个接口
type Speaker interface {
    Speak() string
}

// 实现接口的结构体
type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

上述代码中，Dog结构体通过实现Speak()方法隐式地满足了Speaker接口。这种机制不仅简化了代码结构，还避免了复杂的继承关系。

接口在Go语言中还具有运行时动态绑定的特性，这意味着接口变量可以持有任意实现了其方法的类型的值。这种能力使得接口在构建通用函数、插件系统、序列化/反序列化等场景中非常实用。

Go语言的接口机制结合了静态类型检查与动态行为的能力，是其类型系统中最具特色的部分之一。掌握接口的设计与使用，是深入理解Go语言编程范式的关键一步。

第二章：接口的内部实现原理

2.1 接口变量的内存布局与类型信息

在 Go 语言中，接口变量的内部结构包含两个指针：一个指向其动态类型的类型信息（type），另一个指向实际的数据值（data）。这种设计使得接口能够统一处理不同类型的值。

接口的内存布局

接口变量在内存中通常占用两个机器字（word），分别存储：

字段	内容
`_type`	指向具体类型的类型描述符
`data`	指向实际值的指针或直接存储值的副本

类型信息的作用

接口变量的类型信息不仅记录了值的类型元数据（如大小、对齐方式、方法集等），还在运行时用于类型断言和反射操作。Go 的 reflect 包正是基于这套机制实现动态类型检查和操作。

示例代码解析

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var a interface{} = 42
    fmt.Println(reflect.TypeOf(a)) // 输出 int
}

上述代码中，a 是一个 interface{} 类型变量，它保存了整数 42 及其类型信息 int。调用 reflect.TypeOf(a) 会提取接口中保存的类型信息并输出。

2.2 静态类型检查与动态方法绑定机制

在面向对象编程中，静态类型检查与动态方法绑定是两个核心机制，它们分别在编译期和运行期发挥作用，共同保障程序的类型安全与行为多态。

静态类型检查

静态类型检查在编译阶段完成，确保变量使用与其声明类型一致。例如，在 Java 中：

Animal a = new Cat();
a.speak();  // 编译通过

逻辑分析：
Animal 是变量 a 的静态类型，编译器允许调用 speak() 是因为该方法在 Animal 类中声明。即使实际对象是 Cat，编译器仅依据声明类型进行检查。

动态方法绑定

动态方法绑定（或运行时多态）决定具体执行哪个方法实现：

class Animal {
    void speak() { System.out.println("Animal speaks"); }
}

class Cat extends Animal {
    void speak() { System.out.println("Meow"); }
}

逻辑分析：
尽管变量类型为 Animal，JVM 在运行时根据对象实际类型调用 Cat 的 speak() 方法，体现了动态绑定的核心机制。

类型系统与多态的协同作用

阶段	机制	作用
编译期	静态类型检查	保障类型安全、防止错误调用
运行期	动态方法绑定	实现多态行为、提升灵活性

通过静态类型确保结构正确性，再通过动态绑定赋予程序灵活性，二者协同构成了现代 OOP 语言的核心支柱。

2.3 接口与nil值比较的常见陷阱

在Go语言中，接口（interface）与 nil 值的比较是一个容易产生误解的地方。虽然表面上看，判断一个接口是否为 nil 非常直观，但实际上存在一些隐藏的“陷阱”。

接口的内部结构

Go中的接口变量由两部分组成：动态类型信息和值信息。即使接口的值为 nil，只要其类型信息不为 nil，整个接口就不等于 nil。

一个常见陷阱示例

func getError() error {
    var err *errorString // 假设这是一个实现了error接口的类型
    return err // 返回的error接口不为nil
}

func main() {
    if err := getError(); err != nil {
        fmt.Println("Error is not nil") // 会被执行
    }
}

逻辑分析：

函数 getError() 返回的是一个具体的错误类型指针，即使该指针为 nil，接口 error 的类型信息仍然存在。

因此，接口变量 err 实际上不是 nil，导致条件判断进入“非空”分支。

2.4 接口转换与类型断言的底层逻辑

在 Go 语言中，接口（interface）的转换与类型断言是运行时动态类型处理的核心机制之一。理解其底层逻辑有助于更高效地进行类型安全操作。

接口的本质结构

Go 中的接口变量实际上包含两个指针：

一个指向类型信息（type descriptor）
一个指向实际数据（data pointer）

当执行类型断言时，运行时系统会比对接口变量中存储的动态类型与目标类型是否一致。

类型断言的运行机制

例如：

var i interface{} = "hello"
s := i.(string)

i 是一个接口变量，内部保存了字符串类型信息和实际值的指针。
i.(string) 会触发类型断言，运行时检查接口中保存的类型是否为 string。

如果类型匹配，则返回值；否则触发 panic。使用带 ok 形式的断言可避免崩溃：

s, ok := i.(string)

ok 为布尔值，表示断言是否成功。

转换过程中的性能考量

接口转换和类型断言涉及运行时类型比较和内存访问，因此在性能敏感路径中应尽量减少使用，或使用具体类型替代接口类型。

2.5 接口性能分析与优化建议

在高并发系统中，接口性能直接影响用户体验与系统吞吐能力。常见的性能瓶颈包括数据库访问延迟、网络传输效率、序列化与反序列化开销等。

性能监控指标

要优化接口性能，首先需收集关键指标：

指标名称	说明	目标值示例
响应时间	单次请求处理耗时
吞吐量	每秒处理请求数	> 1000 QPS
错误率	非200响应占比

接口优化策略

以下为常见优化手段：

使用缓存减少数据库访问
异步处理降低阻塞时间
数据压缩减少网络带宽
数据库索引优化查询路径

异步非阻塞调用示例

@Async
public CompletableFuture<String> fetchDataAsync() {
    // 模拟远程调用
    return CompletableFuture.supplyAsync(() -> {
        // 模拟耗时操作
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "data";
    });
}

该方法通过异步执行减少主线程等待时间，提高并发处理能力。使用 CompletableFuture 可以更好地管理异步任务编排和异常处理。

第三章：接口与面向对象设计

3.1 多态实现：接口驱动的灵活设计

在面向对象编程中，多态是一种让不同类对同一消息作出不同响应的能力。通过接口实现多态，可以有效解耦系统模块，提高扩展性和可维护性。

接口与实现分离

接口定义行为规范，具体类实现这些行为。例如：

public interface Shape {
    double area();  // 定义计算面积的方法
}

public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;  // 圆面积公式
    }
}

public class Rectangle implements Shape {
    private double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;  // 矩形面积公式
    }
}

逻辑分析：

Shape 是接口，声明了 area() 方法；
Circle 和 Rectangle 分别实现该接口，提供了各自面积计算逻辑；
这种设计允许在运行时根据对象实际类型调用相应方法，实现多态行为。

多态的优势

提高代码复用性：通过统一接口操作不同对象；
增强系统扩展性：新增形状无需修改已有调用逻辑；
降低模块间依赖：调用方仅依赖接口，而非具体实现类。

3.2 组合优于继承：接口在结构体嵌套中的应用

在 Go 语言中，结构体嵌套与接口的结合使用，很好地体现了“组合优于继承”的设计哲学。

通过嵌套结构体并实现接口方法，可以在不依赖继承关系的前提下，灵活构建复杂行为。例如：

type Animal struct{}

func (a Animal) Speak() string {
    return "Animal sound"
}

type Dog struct {
    Animal // 嵌套实现组合
}

func (d Dog) Speak() string {
    return "Woof!"
}

逻辑分析：

Animal 类型实现了 Speak 方法；
Dog 类型通过嵌套 Animal，继承其行为；
通过重写 Speak 方法，实现了接口行为的定制。

这种方式避免了传统继承体系中可能出现的紧耦合问题，使系统更具可扩展性与可维护性。

3.3 接口隔离原则与Go项目架构实践

接口隔离原则（Interface Segregation Principle, ISP）强调客户端不应被强迫依赖它不使用的接口。在Go语言项目中，这一原则对模块划分和接口设计具有重要指导意义。

以一个服务层接口为例：

type UserService interface {
    GetUser(id string) (*User, error)
    CreateUser(u *User) error
}

type UserNotifier interface {
    NotifyUser(u *User) error
}

上述设计将获取/创建用户与通知用户行为分离，使得实现类仅需关注自身职责，提升了模块解耦性与可测试性。

在项目架构中，通过定义细粒度接口，可以有效降低模块之间的耦合度，提升系统的可扩展性和可维护性。结合依赖注入机制，接口隔离原则为构建高内聚、低耦合的Go应用提供了坚实基础。

第四章：接口在实际项目中的应用模式

4.1 标准库中接口的典型使用场景分析

在现代编程语言的标准库设计中，接口（interface）扮演着抽象行为和实现解耦的关键角色。其典型使用场景主要集中在多态处理、模块化设计以及依赖注入等方面。

数据同步机制

以 Go 标准库为例，io.Reader 和 io.Writer 接口广泛用于抽象数据流操作：

func Copy(dst Writer, src Reader) (written int64, err error)

Reader 接口定义了 Read(p []byte) (n int, err error) 方法；
Writer 接口定义了 Write(p []byte) (n int, err error) 方法；

该设计使得函数能统一处理文件、网络连接、内存缓冲等多种数据源，无需关心底层实现细节。

接口驱动的插件系统

标准库中也常通过接口支持可扩展架构，例如 database/sql 包定义了数据库操作的通用接口，允许接入不同数据库驱动。

组件	作用
`sql.DB`	提供数据库连接池抽象
`driver.Driver`	定义打开数据库连接的接口
`driver.Conn`	表示一次数据库连接

这种接口设计使得上层逻辑与底层实现解耦，为构建可插拔系统提供了基础。

4.2 构建可扩展的插件系统与接口抽象

构建可扩展的插件系统，核心在于接口的抽象设计。良好的接口应具备高内聚、低耦合的特性，使得插件之间相互独立，便于维护和扩展。

接口抽象设计

在设计插件系统时，首先需要定义统一的接口规范，例如：

class PluginInterface:
    def initialize(self):
        """插件初始化方法"""
        pass

    def execute(self, context):
        """插件执行逻辑，context为上下文参数"""
        pass

上述接口中，initialize用于插件加载时的初始化操作，execute则定义了插件实际执行的行为，context参数用于传递运行时上下文信息。

插件注册与加载机制

插件系统通常通过工厂模式或插件管理器统一注册与调度插件：

class PluginManager:
    def __init__(self):
        self.plugins = {}

    def register_plugin(self, name, plugin_instance):
        self.plugins[name] = plugin_instance

    def execute_plugin(self, name, context):
        if name in self.plugins:
            self.plugins[name].execute(context)

通过register_plugin方法将插件实例注册到管理器中，再通过execute_plugin按需调用。这种机制支持动态加载和卸载插件，提升系统的灵活性。

插件生命周期管理

插件的生命周期通常包括加载、初始化、执行、卸载四个阶段。一个良好的插件系统应提供完整的生命周期钩子函数，以便插件开发者可以控制资源的初始化与释放。

插件通信与上下文传递

插件之间可能需要共享数据或进行通信，通常通过统一的上下文对象（Context）传递信息：

字段名	类型	描述
user	User	当前用户信息
config	dict	插件配置参数
shared_data	dict	插件间共享的数据存储

通过上下文对象，插件可以获取运行时环境信息，实现跨插件的数据交互。

插件热加载与热更新

现代插件系统通常支持热加载与热更新能力，即在不停止主程序的前提下加载或替换插件模块。实现方式包括动态加载模块（如使用importlib）和沙箱运行环境。

系统架构图

以下为插件系统的典型架构流程：

graph TD
    A[主程序] --> B[插件管理器]
    B --> C[插件注册]
    B --> D[插件加载]
    B --> E[插件执行]
    C --> F[插件A]
    C --> G[插件B]
    D --> H[插件动态加载]
    E --> I[上下文传递]

通过插件管理器统一管理插件的注册、加载与执行，实现插件系统的模块化和可扩展性。

4.3 接口在并发编程中的角色与安全实践

在并发编程中，接口不仅是模块间通信的契约，更是保障数据一致性和线程安全的重要手段。通过接口抽象，可以有效封装底层并发实现细节，提供统一的访问入口。

线程安全接口设计原则

良好的接口设计应遵循以下原则：

不可变性（Immutability）：尽量设计只读对象，避免状态变更引发的竞争问题；
同步封装：将同步逻辑封装在接口实现内部，对外透明；
最小化共享：减少接口间共享状态，推荐使用消息传递或副本传递方式。

示例：并发安全的配置接口

public interface ConfigService {
    String getConfig(String key); // 返回不可变字符串
}

该接口返回的 String 是不可变对象，即使在多线程环境下也能保证读取安全。调用方无需关心内部实现是否线程安全。

接口安全实践总结

实践方式	优点	适用场景
使用同步容器	简单易用	低并发、简单对象
使用并发接口封装	解耦调用与实现	中高并发、复杂系统
不可变对象传递	天然线程安全	配置、状态快照等

4.4 接口与泛型编程的结合与限制

在现代编程中，接口与泛型的结合为构建灵活、可复用的代码提供了强大支持。通过将泛型类型参数应用于接口定义，可以实现对多种数据类型的统一抽象。

例如：

public interface Repository<T> {
    T findById(Long id);
    List<T> findAll();
}

逻辑说明：
以上代码定义了一个泛型接口 Repository<T>，用于抽象数据访问层。其中 T 是类型参数，表示该接口的操作对象为任意类型。findById 返回 T 类型实例，findAll 返回 T 的列表。

接口泛型的局限性

尽管泛型与接口结合提升了抽象能力，但也有其限制。例如，Java 中的泛型在运行时会被擦除（Type Erasure），导致无法在运行时获取泛型参数的实际类型，从而影响反射、序列化等操作的实现逻辑。

第五章：接口机制的核心价值与未来展望

在现代软件架构中，接口机制早已超越了简单的函数调用边界，成为连接系统组件、服务乃至组织之间协作的核心纽带。随着微服务、Serverless 和云原生架构的普及，接口的设计与治理直接影响着系统的可扩展性、可维护性以及交付效率。

接口作为服务契约的基石

在分布式系统中，接口是服务之间通信的契约。一个设计良好的接口不仅定义了输入输出格式，还明确了错误处理方式、版本控制策略以及安全认证机制。以 Netflix 为例，其 API 网关每天处理数十亿次请求，背后正是通过统一的接口规范和自动化治理工具链，实现了服务的高效集成与弹性伸缩。

接口标准化带来的工程效率提升

采用 OpenAPI、gRPC、GraphQL 等标准化接口协议，使得前后端协作、测试自动化和文档生成变得更加高效。例如，某大型电商平台通过引入 gRPC 接口标准，将接口调用延迟降低了 30%，同时接口文档的更新频率提升了 50%，显著提高了跨团队协作效率。

接口治理的未来趋势

随着服务网格（Service Mesh）和 API 网关技术的发展，接口治理正朝着更智能、更自动化的方向演进。Istio + Envoy 的组合已经在多个企业中实现了接口流量的精细化控制、熔断限流、动态路由等功能。未来，AI 驱动的接口测试与异常检测、接口自动化演进等能力将成为主流。

实战案例：基于 OpenAPI 的自动化测试流水线

某金融科技公司在其 CI/CD 流水线中集成了基于 OpenAPI 的自动化测试框架。每当接口定义变更时，系统自动生成测试用例并执行回归测试，确保接口行为符合预期。这种方式不仅减少了人工测试成本，还大幅降低了接口变更带来的线上故障率。

阶段	传统方式	自动化测试方式
接口变更	手动编写文档，人工测试	自动生成文档，自动执行测试
故障发现	线上报警，响应式修复	预发布阶段自动检测异常
测试覆盖率	依赖测试人员经验	基于接口定义自动生成全路径

graph TD
    A[接口定义更新] --> B[触发CI流水线]
    B --> C[生成接口文档]
    C --> D[生成测试用例]
    D --> E[执行自动化测试]
    E --> F[测试通过，进入部署阶段]
    E --> G[测试失败，通知开发团队]

接口机制的价值不仅体现在技术层面，更在于它推动了工程文化的变革。从接口设计到治理、测试、部署的全流程自动化，正在成为高质量软件交付的核心路径。

第六章：接口机制的常见误区与解决方案

6.1 接口滥用导致的性能瓶颈分析

在高并发系统中，接口的不合理调用是引发性能瓶颈的常见原因。频繁请求、缺乏缓存机制或未限制调用频率，都会造成后端资源过载，进而影响整体系统响应速度。

接口滥用的典型表现

同一客户端短时间内发起大量请求
未使用缓存重复获取相同数据
接口响应时间显著增长，伴随数据库压力激增

性能瓶颈分析示例

public List<User> fetchUsers() {
    return restTemplate.getForObject("http://api.example.com/users", List.class);
}

上述代码每次调用都会发起一次 HTTP 请求，若未做缓存处理，在并发场景下将造成严重性能问题。建议引入本地缓存或分布式缓存机制。

优化建议

引入限流机制（如令牌桶算法）
使用 Redis 缓存高频访问数据
对接口调用频率进行监控与告警

通过合理设计接口调用策略，可有效缓解服务端压力，提升系统整体吞吐能力。

6.2 接口设计不当引发的维护难题

在软件开发过程中，接口作为模块间通信的桥梁，其设计合理性直接影响系统的可维护性与扩展性。若接口定义模糊、职责不清，或未遵循统一规范，将导致后期频繁修改，增加维护成本。

接口职责混乱的典型问题

例如，一个用户服务接口同时承担数据查询与权限校验职责：

public interface UserService {
    User getUserInfo(String userId);
    boolean checkPermission(String userId, String permission);
}

逻辑分析：

getUserInfo 用于获取用户基本信息

checkPermission 用于权限判断
两个功能逻辑上不相关，违反了接口单一职责原则，导致该接口难以复用和测试。

接口版本管理缺失引发的兼容问题

若未对接口进行版本控制，新增字段或修改参数将直接影响调用方，造成系统不稳定。

版本	接口名称	参数变化	影响范围
v1	`/api/login`	`username`, `password`	所有客户端
v2	`/api/login`	`username`, `password`, `device_id`	旧客户端无法兼容

接口设计建议

明确接口职责，遵循 SRP（单一职责原则）
使用版本控制，如 /api/v1/login
保持接口参数简洁，避免过度设计

良好的接口设计是系统可持续发展的基础，应在早期阶段投入足够关注。

6.3 接口调试与测试技巧实践

在接口开发过程中，调试与测试是保障系统稳定性的关键环节。合理的调试策略和测试手段不仅能快速定位问题，还能有效提升接口质量。

使用 Postman 进行接口测试

Postman 是一个功能强大的 API 测试工具，支持请求构造、响应验证、自动化测试等功能。通过其测试脚本功能，可以编写 JavaScript 脚本对接口返回结果进行断言验证。

例如，验证返回状态码是否为 200 的测试脚本如下：

// 验证 HTTP 响应状态码是否为 200
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

逻辑说明：

pm.test 定义一个测试用例
pm.response 获取当前请求的响应对象
to.have.status(200) 是断言语法，表示期望响应码为 200

接口自动化测试流程示意

通过构建自动化测试流程，可以将接口测试嵌入 CI/CD 管道中，实现持续验证。以下是典型的接口测试流程图：

graph TD
    A[编写测试用例] --> B[构造请求]
    B --> C[发送请求]
    C --> D[获取响应]
    D --> E{验证响应?}
    E -- 是 --> F[测试通过]
    E -- 否 --> G[记录错误]

6.4 接口文档化与团队协作最佳实践

在团队协作开发中，接口文档化是保障开发效率与质量的关键环节。清晰、规范的接口文档不仅能提升前后端协作效率，还能降低维护成本。

接口文档的核心要素

一个完整的接口文档应包含以下信息：

字段	说明	是否必填
接口地址	请求的URL路径	是
请求方法	GET、POST等	是
请求参数	参数名、类型、说明	是
响应示例	正常与异常返回结构	是

使用Swagger实现接口文档自动化

# 示例：Swagger接口定义片段
/pets:
  get:
    summary: 获取宠物列表
    parameters:
      - name: limit
        in: query
        type: integer
        description: 返回记录数上限
    responses:
      '200':
        description: 宠物列表
        schema:
          type: array
          items:
            $ref: '#/definitions/Pet'

该定义描述了获取宠物列表的接口逻辑，包含请求参数limit和响应结构。通过Swagger UI可自动生成可视化文档，提升协作效率。

协作流程优化建议

接口设计优先：前后端在开发前达成一致
文档版本管理：与代码一同纳入Git版本控制
持续集成验证：通过CI流程自动检测接口变更

团队协作中的接口同步机制

graph TD
  A[需求评审] --> B[接口设计]
  B --> C[文档生成]
  C --> D[前端开发]
  C --> E[后端开发]
  D --> F[联调测试]
  E --> F

该流程确保接口文档作为开发的核心依据贯穿整个协作过程，减少沟通成本并提升交付质量。

第七章：深入掌握接口机制的学习路径与资源推荐

7.1 接口相关书籍与开源项目推荐

在接口设计与开发领域，深入理解理论与实践结合至关重要。以下推荐涵盖经典书籍与活跃开源项目，帮助开发者由浅入深掌握接口开发核心技能。

开源项目参考

项目名称	技术栈	特点说明
FastAPI	Python	高性能，支持异步处理
Spring Boot	Java	企业级接口开发首选

接口调试工具

使用 Postman 或 Insomnia 可大幅提升接口测试效率，支持自动化测试与环境配置管理。

7.2 接口机制源码剖析入门指南

理解接口机制的底层实现，是掌握现代编程语言运行时行为的关键环节。以常见的接口调用为例，其背后涉及类型匹配、方法绑定与运行时解析等多个阶段。

接口调用的执行流程

通过如下代码片段，我们可以观察接口调用的基本执行路径：

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

上述代码定义了一个Animal接口和一个实现了该接口的Dog结构体。在运行时，Go 使用接口变量的动态类型信息查找对应的方法实现。

接口内部结构解析

Go 的接口变量由两部分组成：

组成部分	描述
类型信息	描述实际存储的数据类型
数据指针	指向实际存储的值

通过这种结构，接口可以在运行时完成方法调用的动态绑定。

7.3 社区优秀实践与案例分析

在开源社区中，涌现出大量值得借鉴的优秀实践。其中，Apache Kafka 的分布式日志处理架构是一个典型范例。

架构设计与数据流转

Kafka 通过分区（Partition）和副本（Replica）机制，实现了高吞吐、可扩展的数据处理能力。其核心流程可通过以下 mermaid 图展示：

graph TD
    Producer --> Broker
    Broker --> Partition
    Partition --> Replica
    Replica --> ISR
    Consumer --> Broker

核心优势分析

水平扩展性强：通过分区机制支持横向扩展
容错能力高：副本机制保障数据不丢失
高性能读写：顺序写入磁盘 + 零拷贝技术优化IO

这些特性使其广泛应用于日志聚合、事件溯源等场景。

7.4 接口机制进阶学习路线图

掌握接口机制的进阶内容，需要从基础的接口定义逐步深入到复杂的设计模式与实际工程应用。

接口设计的层次演进

基础接口调用：理解接口的声明与实现关系；
接口隔离原则：学习如何拆分接口以降低耦合；
接口版本控制：掌握 RESTful API 的版本管理策略；
接口契约与测试：使用 OpenAPI/Swagger 明确接口契约并进行自动化测试。

接口组合与装饰模式

使用接口装饰器模式可以动态增强功能，例如：

interface Service {
    void execute();
}

class BasicService implements Service {
    public void execute() {
        System.out.println("Basic Service Running");
    }
}

class DecoratedService implements Service {
    private Service decoratedService;

    public DecoratedService(Service decoratedService) {
        this.decoratedService = decoratedService;
    }

    public void execute() {
        System.out.println("Before Execution");
        decoratedService.execute();
        System.out.println("After Execution");
    }
}