第golang包循環引用的幾種解決方案總結目錄1.golang包循環引用的幾種解決方案1.1.前言1.2.新建公共接口包(父包),將需要循環調用的函數或方法抽象為接口1.3.新建公共組合包(子包),在組合包中組合調用1.4.全局存儲需要相互依賴的函數,通過關鍵字進行調用1.5.不需要回調結果的可以通過事件總線(eventBus)解耦總結

1.golang包循環引用的幾種解決方案

1.1.前言

golang為了加速編譯,不允許包循環引用。通常來說,只要你的包規劃得好,嚴格規范單向調用鏈(如控制層-業務層-數據層),一般不會出現包循環引用問題。當然現實業務往往不會這么理想,同層級之間的不同包經常需要互相引用,下面我就分享幾種解決包循環引用的方案。

1.2.新建公共接口包(父包),將需要循環調用的函數或方法抽象為接口

package_i

packagepackage_i

typePackageAInterfaceinterface{

PrintA()

typePackageBInterfaceinterface{

PrintB()

package_a

packagepackage_a

import(

"cycle/package_i"

"fmt"

typePackageAstruct{

Bpackage_i.PackageBInterface

func(aPackageA)PrintA(){

fmt.Println("I'ma!")

func(aPackageA)PrintAll(){

a.PrintA()

a.B.PrintB()

package_b

packagepackage_b

import(

"cycle/package_i"

"fmt"

typePackageBstruct{

Apackage_i.PackageAInterface

func(bPackageB)PrintB(){

fmt.Println("I'mb!")

func(bPackageB)PrintAll(){

b.PrintB()

b.A.PrintA()

main

packagemain

import(

"cycle/package_a"

"cycle/package_b"

funcmain(){

a:=new(package_a.PackageA)

b:=new(package_b.PackageB)

a.B=b

b.A=a

a.PrintAll()

b.PrintAll()

1.3.新建公共組合包(子包),在組合包中組合調用

package_c

packagepackage_c

import(

"cycle/package_a"

"cycle/package_b"

typeCombileABstruct{

A*package_a.PackageA

B*package_b.PackageB

func(cCombileAB)PrintAll(){

c.A.PrintA()

c.B.PrintB()

main

packagemain

import(

"cycle/package_a"

"cycle/package_b"

"cycle/package_c"

funcmain(){

a:=new(package_a.PackageA)

b:=new(package_b.PackageB)

c:=new(package_c.CombileAB)

c.A=a

c.B=b

c.PrintAll()

1.4.全局存儲需要相互依賴的函數,通過關鍵字進行調用

callback_mgr

packagecallback_mgr

import(

"fmt"

"reflect"

varcallBackMapmap[string]interface{}

funcinit(){

callBackMap=make(map[string]interface{})

funcRegisterCallBack(keystring,callBackinterface{}){

callBackMap[key]=callBack

funcCallBackFunc(keystring,args...interface{})[]interface{}{

ifcallBack,ok:=callBackMap[key];ok{

in:=make([]reflect.Value,len(args))

fori,arg:=rangeargs{

in[i]=reflect.ValueOf(arg)

outList:=reflect.ValueOf(callBack).Call(in)

result:=make([]interface{},len(outList))

fori,out:=rangeoutList{

result[i]=out.Interface()

returnresult

}else{

panic(fmt.Errorf("callBack(%s)notfound",key))

package_a

packagepackage_a

import(

"cycle/callback_mgr"

"fmt"

funcinit(){

callback_mgr.RegisterCallBack("getA",new(PackageA).GetA)

typePackageAstruct{

func(aPackageA)GetA()string{

return"I'ma!"

func(aPackageA)PrintAll(){

fmt.Println(a.GetA())

fmt.Println(callback_mgr.CallBackFunc("getB")[0].(string))

package_b

packagepackage_b

import(

"cycle/callback_mgr"

"fmt"

funcinit(){

callback_mgr.RegisterCallBack("getB",new(PackageB).GetB)

typePackageBstruct{

func(bPackageB)GetB()string{

return"I'mb!"

func(bPackageB)PrintAll(){

fmt.Println(b.GetB())

fmt.Println(callback_mgr.CallBackFunc("getA")[0].(string))

main

packagemain

import(

"cycle/package_a"

"cycle/package_b"

funcmain(){

a:=new(package_a.PackageA)

b:=new(package_b.PackageB)

a.PrintAll()

b.PrintAll()

1.5.不需要回調結果的可以通過事件總線(eventBus)解耦

eventBus

packageeventBus

import(

"/asaskevich/EventBus"

varglobalEventBusEventBus.Bus

funcinit(){

globalEventBus=EventBus.New()

funcSubscribe(topicstring,fninterface{})error{

returnglobalEventBus.Subscribe(topic,fn)

funcSubscribeAsync(topicstring,fninterface{},transactionalbool)error{

returnglobalEventBus.SubscribeAsync(topic,fn,transactional)

funcPublish(topicstring,args...interface{}){

globalEventBus.Publish(topic,args...)

package_a

packagepackage_a

import(

"cycle/eventBus"

"fmt"

funcinit(){

eventBus.Subscribe("PrintA",new(PackageA).PrintA)

typePackageAstruct{

func(aPackageA)PrintA(){

fmt.Println("I'ma!")

func(aPackageA)PrintAll(){

a.PrintA()

eventBus.Publish("PrintB")

package_b

packagepackage_b

import(

"cycle/eventBus"

"fmt"

func