在Golang项目里，当某个资源对象的创建成本高、访问需要权限或者调用频率需要被限制时，直接让调用方使用真实对象会让业务逻辑掺杂大量非功能性代码。代理模式的核心思想是提供一个与真实资源实现相同接口的代理对象，由代理在转发请求前后插入控制逻辑，从而保护或优化对底层资源的访问。
代理模式的基础结构与接口抽象
要在Golang中实现代理模式，第一步是定义统一的行为接口。接口隔离了调用方与具体实现，使得代理和真实对象可以互相替换。假设我们有一个读取配置文件的资源，其访问较慢且需要鉴权，先抽象出ConfigSource接口，包含Get方法。真实对象realConfig从磁盘加载数据，而代理proxyConfig持有realConfig的引用，并在Get中先做权限检查再委托调用。
这种静态代理写法的优势在于类型安全且易于理解。因为Golang的接口是隐式实现的，只要代理结构体实现了接口的全部方法，就能赋值给接口变量。调用方完全感知不到自己拿到的是代理还是真实对象。下面的代码展示了接口与两个结构体的定义，以及代理如何包裹真实对象。
package main
import "fmt"
// ConfigSource 资源访问接口
type ConfigSource interface {
Get(key string) (string, error)
}
// realConfig 真实资源，从慢速存储读取
type realConfig struct {
data map[string]string
}
func (r *realConfig) Get(key string) (string, error) {
if v, ok := r.data[key]; ok {
return v, nil
}
return "", fmt.Errorf("key not found")
}
// proxyConfig 代理对象，控制访问
type proxyConfig struct {
real ConfigSource
token string
allow map[string]bool
}
func (p *proxyConfig) Get(key string) (string, error) {
if !p.allow[p.token] {
return "", fmt.Errorf("access denied")
}
return p.real.Get(key)
}
func main() {
real := &realConfig{data: map[string]string{"timeout": "30s"}}
proxy := &proxyConfig{real: real, token: "abc", allow: map[string]bool{"abc": true}}
v, err := proxy.Get("timeout")
fmt.Println(v, err)
}
从上面例子可以看出，代理结构体通过组合ConfigSource字段持有真实依赖，并在方法内部决定是否放行。如果后期需要增加缓存，只需在代理里加一个map缓存层，调用前查缓存、未命中再走真实对象，业务代码零改动。这也体现了代理模式对资源访问的控制力。
基于函数的轻量代理与延迟初始化
并非所有场景都需要定义繁重的接口。Golang的一等公民函数让我们可以用闭包实现轻量代理。比如真实资源是一个数据库连接，建立连接很耗时，我们可以用一个函数变量包装初始化逻辑，只有第一次访问时才创建真实对象，后续直接复用。这种方式叫虚拟代理，重点在于延迟加载以节约系统启动开销。
下面的示例用sync.Once保证真实资源只初始化一次，代理函数每次被调用时先检查是否已就绪，再执行访问控制。相比结构体代理，函数代理更灵活，适合工具类或中间件封装。不过当控制逻辑变多时，结构体代理的可读性会更好，因为相关字段和判断都能集中管理。
package main
import (
"fmt"
"sync"
)
type dbConn struct {
addr string
}
func (d *dbConn) Query(sql string) string {
return "result from " + d.addr
}
func NewLazyProxy(token string) func(string) (string, error) {
var (
once sync.Once
conn *dbConn
)
return func(sql string) (string, error) {
if token != "valid" {
return "", fmt.Errorf("bad token")
}
once.Do(func() {
conn = &dbConn{addr: "127.0.0.1:3306"}
})
return conn.Query(sql), nil
}
}
func main() {
proxy := NewLazyProxy("valid")
r, _ := proxy("select 1")
fmt.Println(r)
}
延迟初始化代理在微服务启动时特别有用。很多下游资源其实在启动阶段用不到，如果提前全量连接会拖慢启动并占用连接数。把代理放在调用链入口，能自然把资源创建推迟到真正需要的时候，同时 token 校验逻辑统一收口在闭包里，避免散落到各个业务函数。
动态代理思路与访问控制进阶
Golang没有Java那样的内置动态代理机制，但借助reflect包，我们依然能为任意接口生成通用代理。核心是用reflect.Value包装真实对象，在Invoke前后插入日志、限流或鉴权。虽然反射会带来少量性能损耗，但对于后台管理类接口或测试桩来说完全可接受。动态代理最适合做横切逻辑的统一织入，比如对所有资源方法统计耗时。
实际做访问控制时，代理层还可以结合上下文context.Context传递用户身份，在每次方法调用时解析并比对权限表。这样真实资源方法不需要感知是谁在调用，只专注数据操作。下面的代码用反射实现了一个简易通用代理，在调用任何方法前打印日志并模拟鉴权，展示如何将控制逻辑与业务解耦。
package main
import (
"fmt"
"reflect"
)
type Service interface {
Do(id int) string
}
type realService struct{}
func (r *realService) Do(id int) string {
return fmt.Sprintf("handled %d", id)
}
func MakeProxy(real interface{}, ok bool) interface{} {
rv := reflect.ValueOf(real)
rt := rv.Type()
proxy := reflect.New(rt.Elem())
for i := 0; i < rt.NumMethod(); i++ {
m := rt.Method(i)
f := func(args []reflect.Value) []reflect.Value {
if !ok {
panic("access denied")
}
fmt.Println("before call", m.Name)
return m.Func.Call(append([]reflect.Value{rv}, args...))
}
// 简化示意，实际需构造方法值
_ = f
}
return proxy.Interface()
}
func main() {
var s Service = &realService{}
fmt.Println(s.Do(1))
}
上面的反射示例省略了完整的方法值绑定细节，但思路很明确：通过遍历接口方法并用闭包包裹原方法，就能在不修改真实对象的前提下控制每一次访问。在正式项目中，若需要完整的动态代理库，可以参考开源的 AOP 风格封装，但原理都离不开接口抽象加中间转发。总体来说，Golang实现代理模式控制资源访问的手段非常务实，小到闭包函数，大到接口组合与反射，都能帮我们把权限、缓存、延迟加载等关注点干净地隔离在业务之外。