golang如何优雅的编写事务代码

时间 2020-05-26

标签 golang 如何优雅编写事务代码栏目 Go 繁體版

原文原文链接

前言

新手程序员大概有以下特色程序员

if嵌套常常超过3层、常常出现重复代码、单个函数代码特别长。
只会crud，对语言特性和语言的边界不了解。
不懂面向对象原则和设计模式，觉得copy代码就算学会了，常见的是代码职责不明确或者写出万能类
不知道数据结构和算法的重要性，觉得靠硬件能解决运行慢的问题
架构不懂，搭建框架不会，搭建环境不会，使用的软件底层原理一问三不知

其实吧，不少人干了不少年，看似是老手，平时工做看似很忙，其实作的都是最简单的活。
这就像去锻炼，有的人天天练的很积极，准时打卡，频繁发朋友圈，貌似是正能量，结果是几年下来体型仍是那样，该减的肥肉没少，要增的肌肉没加，为何会这样？由于历来都是挑最简单最轻松的练算法

貌似吐槽多了，下面演示一下如何将一坨烂事务代码重构得优雅设计模式

需求

执行一个事务，须要调用one、two、three、four、five几个方法，任意一个方法失败，都回滚事务
下面是这些方法的简单模拟，咱们用尽量少的代码模拟一个操做数据结构

//开启事务
func beginTransaction() {
 fmt.Println("beginTransaction")
}

//回滚事务
func rollback() {
 fmt.Println("rollback")
}

//提交事务
func commit() {
 fmt.Println("commit")
}

//执行one操做
func one() (err error) {
 fmt.Println("one ok")
 return nil
}

//执行two操做
func two() (err error) {
 fmt.Println("two ok")
 return nil
}

//执行three操做
func three() (err error) {
 fmt.Println("two ok")
 return nil
}

//执行four操做
func four() (err error) {
 fmt.Println("four ok")
 return nil
}

//执行five操做
func five() (err error) {
 err = errors.New("five panic")
 panic("five")
 return err
}

烂代码示例

下面演示开启一个事务，依次执行one、two、three、four、five 5个操做，前四个成功，第五个失败架构

这是新手程序员常见使用事务的代码风格，其实也不光是事务，全部的代码均可能长下边这样框架

func demo() (err error) {
 beginTransaction()
 defer func() {
  if e := recover(); e != nil {
   err = fmt.Errorf("%v", e)
   fmt.Printf("%v panic\n", e)
   rollback()
  }
 }()
 if err = one(); err == nil {
  if err = two(); err == nil {
   if err = three(); err == nil {
    if err = four(); err == nil {
     if err = five(); err == nil {
      commit()
      return nil
     } else {
      rollback()
      return err
     }
    } else {
     rollback()
     return err
    }
   } else {
    rollback()
    return err
   }
  } else {
   rollback()
   return err
  }
 } else {
  rollback()
  return err
 }
}

重构套路

1、提早return去除if嵌套

经过提早返回error，来去掉一些else代码，减小嵌套，以下
数据结构和算法

代码函数

func demo() (err error) {
 beginTransaction()
 defer func() {
  if e := recover(); e != nil {
   err = fmt.Errorf("%v", e)
   fmt.Printf("%v panic\n", e)
   rollback()
  }
 }()
 if err = one(); err != nil {
  rollback()
  return err
 }
 if err = two(); err != nil {
  rollback()
  return err
 }
 if err = three(); err != nil {
  rollback()
  return err
 }

 if err = four(); err != nil {
  rollback()
  return err
 }
 if err = five(); err != nil {
  rollback()
  return err
 }
 commit()
 return nil
}

先解决嵌套设计

2、goto+label提取重复代码

代码3d

func demo() (err error) {
 beginTransaction()
 defer func() {
  if e := recover(); e != nil {
   err = fmt.Errorf("%v", e)
   fmt.Printf("%v panic\n", e)
   rollback()
  }
 }()
 if err = one(); err != nil {
  goto ROLLBACK
 }
 if err = two(); err != nil {
  goto ROLLBACK
 }
 if err = three(); err != nil {
  goto ROLLBACK
 }
 if err = four(); err != nil {
  goto ROLLBACK
 }
 if err = five(); err != nil {
  goto ROLLBACK
 }
 commit()
 return nil
ROLLBACK:
 rollback()
 return err
}

3、封装try-catch统一捕获panic

上面的代码其实还有一点问题

defer里有rollback的代码
goto虽然好，可是不建议使用

咱们能够对panic和defer进行封装，模拟一下try-catch，实现以下

能够看到，rollback只调用了一次，完美的进行了事务代码重构

try-catch.go代码

package exception

type Block struct {
 Try func()
 Catch func(interface{})
 Finally func()
}

func (t Block) Do() {
 if t.Finally != nil {
  defer t.Finally()
 }
 if t.Catch != nil {
  defer func() {
   if r := recover(); r != nil {
    t.Catch(r)
   }
  }()
 }
 t.Try()
}

使用代码

exception.Block{
		Try: func() {
			beginTransaction()
			if err = one(); err != nil {
				panic(err)
			}
			if err = two(); err != nil {
				panic(err)
			}
			if err = three(); err != nil {
				panic(err)
			}
			if err = four(); err != nil {
				panic(err)
			}
			if err = five(); err != nil {
				panic(err)
			}
			err = nil
			commit()
		},
		Catch: func(e interface{}) {
			rollback()
			fmt.Printf("%v panic\n", e)
			err = fmt.Errorf("%v", e)
		},
	}.Do()
	return err
}

这样，咱们就能够用很是少的代码实现事务，而且简单清晰好维护，以上为chenqionghe原创，light weight baby