go语言支持aop。AOP是指面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术；AOP是面向对象中的一种方式，主要应用场景：日志记录，性能统计，安全控制，事务处理，异常处理等等。
本教程操作环境：windows7系统、GO 1.18版本、Dell G3电脑。
什么是aop？
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
面向切面编程是面向对象中的一种方式而已。在代码执行过程中，动态嵌入其他代码，叫做面向切面编程。常见的使用场景：
立即学习“go语言免费学习笔记（深入）”；
日志
事物
数据库操作
面向切面编程，就是将交叉业务逻辑封装成切面，利用AOP的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指，通用的，与主业务逻辑无关的代码，如安全检查，事物，日志等。若不使用AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，会使业务逻辑变得混杂不清。
主要应用场景：日志记录，性能统计，安全控制，事务处理，异常处理等等。
核心概念
JoinPoint:连接点。是程序执行中的一个精确执行点，例如类中的一个方法。
PointCut：切入点。指定哪些组件的哪些方法使用切面组件。
Advice：通知，用于指定具体作用的位置，是方法之前或之后等等，分为前置通知，后置通知，异常通知，返回通知，环绕通知。
Aspect: 切面。封装通用业务逻辑的组件，即我们想要插入的代码内容。
其内在设计模式为代理模式。
go语言支不支持aop？
go语言支持aop。
Go实现AOP的示例：
// User
type User struct {
Name string
Pass string
}
// Auth 验证
func (u *User) Auth() {
// 实际业务逻辑
fmt.Printf("register user:%s, use pass:%s\n", u.Name, u.Pass)
}
// UserAdvice
type UserAdvice interface {
// Before 前置通知
Before(user *User) error
// After 后置通知
After(user *User)
}
// ValidatePasswordAdvice 用户名验证
type ValidateNameAdvice struct {
}
// ValidatePasswordAdvice 密码验证
type ValidatePasswordAdvice struct {
MinLength int
MaxLength int
}
func (ValidateNameAdvice) Before(user *User) error {
fmt.Println("ValidateNameAdvice before")
if user.Name == "admin" {
return errors.New("admin can't be used")
}
return nil
}
func (ValidateNameAdvice) After(user *User) {
fmt.Println("ValidateNameAdvice after")
fmt.Printf("username:%s validate sucess\n", user.Name)
}
// Before 前置校验
func (advice ValidatePasswordAdvice) Before(user *User) error {
fmt.Println("ValidatePasswordAdvice before")
if user.Pass == "123456" {
return errors.New("pass isn't strong")
}
if len(user.Pass) > advice.MaxLength {
return fmt.Errorf("len of pass must less than:%d", advice.MaxLength)
}
if len(user.Pass) < advice.MinLength {
return fmt.Errorf("len of pass must greater than:%d", advice.MinLength)
}
return nil
}
func (ValidatePasswordAdvice) After(user *User) {
fmt.Println("ValidatePasswordAdvice after")
fmt.Printf("password:%s validate sucess\n", user.Pass)
}
// UserAdviceGroup,通知管理组
type UserAdviceGroup struct {
items []UserAdvice
}
// Add 注入可选通知
func (g *UserAdviceGroup) Add(advice UserAdvice) {
g.items = append(g.items, advice)
}
func (g *UserAdviceGroup) Before(user *User) error {
for _, item := range g.items {
if err := item.Before(user); err != nil {
return err
}
}
return nil
}
// After
func (g *UserAdviceGroup) After(user *User) {
for _, item := range g.items {
item.After(user)
}
}
// UserProxy 代理，也是切面
type UserProxy struct {
user *User
}
// NewUser return UserProxy
func NewUser(name, pass string) UserProxy {
return UserProxy{user:&User{Name:name, Pass:pass}}
}
// Auth 校验，切入点
func (p UserProxy) Auth() {
group := UserAdviceGroup{}
group.Add(&ValidatePasswordAdvice{MaxLength:10, MinLength:6})
group.Add(&ValidateNameAdvice{})
// 前置通知
if err := group.Before(p.user); err != nil {
panic(err)
}
// 实际逻辑
p.user.Auth()
// 后置通知
group.After(p.user)
}使用AOP模式进行解耦，分离主业务与副业务。其实也就那样。
