func MakeEndpoint (svc services.StringService) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (response interface{}, err error) {
  req := request.(*StringService.Request)
  rep , err  := svc.Diff(ctx , req)
  return rep , err
 }
}

package main

import (
 "balencegrpc/services"
 "balencegrpc/router"
 "balencegrpc/proto"
 "balencegrpc/discover"
 "balencegrpc/endpoints"
 "github.com/go-kit/kit/circuitbreaker"
 "google.golang.org/grpc"
 "google.golang.org/grpc/health/grpc_health_v1"
 "log"
 "net"
)

func main() {
 //svc := new()
  svc := services.ServiceI{}
 endpoint := circuitbreaker.Hystrix("testname")(endpoints.MakeEndpoint(svc))
 lis , err := net.Listen("tcp" , ":8081")
 if err != nil {
  log.Println(err)
  return
 }
 router := router.NewRouter(svc , endpoint)
 grpcserver := grpc.NewServer()
 c := discover.Service{}
 grpc_health_v1.RegisterHealthServer(grpcserver , &c)
 StringService.RegisterStringServiceServer(grpcserver , router)
 rs := discover.NewService()
 rs.Register("127.0.0.1" , 8081)
 grpcserver.Serve(lis)
}

func Hystrix(commandName string) endpoint.Middleware {  
   return func(next endpoint.Endpoint) endpoint.Endpoint {  
      return func(ctx context.Context, request interface{}) (response interface{}, err error) {  
         var resp interface{}  
         if err := hystrix.Do(commandName, func() (err error) {  
            resp, err = next(ctx, request)  
            return err  
         }, nil); err != nil {  
            return nil, err  
         }  
         return resp, nil  
      }  
   }  
}

commandName := "my-endpoint"  
hystrix.ConfigureCommand(commandName, hystrix.CommandConfig{  
  Timeout: 1000 * 30,  
  ErrorPercentThreshold: 1,  
  SleepWindow: 10000,  
  MaxConcurrentRequests: 1000,  
  RequestVolumeThreshold: 5,  
})

breakerMw := circuitbreaker.Hystrix(commandName)
//增加熔斷中間件  
reqEndPoint = breakerMw(reqEndPoint)

 
syntax = "proto3"; 
// 請求書詳情的參數(shù)結(jié)構(gòu)  book_id 32位整形
message BookInfoParams {
    int32 book_id = 1;
} 
 
// 書詳情信息的結(jié)構(gòu)   book_name字符串類型
message BookInfo {
    int32 book_id = 1;
    string  book_name = 2;
}
 
// 請求書列表的參數(shù)結(jié)構(gòu)  page、limit   32位整形
message BookListParams {
    int32 page = 1;
    int32 limit = 2;
} 
 
// 書列表的結(jié)構(gòu)    BookInfo結(jié)構(gòu)數(shù)組
message BookList {
    repeated BookInfo book_list = 1;
}
// 定義 獲取書詳情  和 書列表服務(wù)   入?yún)⒊鰠⒎謩e為上面所定義的結(jié)構(gòu)
service BookService {
    rpc GetBookInfo (BookInfoParams) returns (BookInfo) {}
    rpc GetBookList (BookListParams) returns (BookList) {}
}

package main 
import (
	"MyKit"
	"context"
	"fmt"
	"github.com/afex/hystrix-go/hystrix"
	"github.com/go-kit/kit/circuitbreaker"
	"github.com/go-kit/kit/endpoint"
	"github.com/go-kit/kit/log"
	"github.com/go-kit/kit/sd"
	"github.com/go-kit/kit/sd/etcdv3"
	"github.com/go-kit/kit/sd/lb"
	"google.golang.org/grpc"
	"io"
	"time"
)
 
func main() { 
	var (
		//注冊中心地址
		etcdServer = "127.0.0.1:2379"
		//監(jiān)聽的服務(wù)前綴
		prefix = "/services/book/"
		ctx    = context.Background()
	)
	//對hystrix進行配置
	commandName:="my_endpoint"
	hystrix.ConfigureCommand(commandName,hystrix.CommandConfig{
		Timeout:1000*3, //超時
		MaxConcurrentRequests:100, //最大并發(fā)的請求數(shù)
		RequestVolumeThreshold:5,//請求量閾值
		SleepWindow:10000, //熔斷開啟多久嘗試發(fā)起一次請求
		ErrorPercentThreshold:1, //誤差閾值百分比
	})
	breakerMw:=circuitbreaker.Hystrix(commandName) //定義熔斷器中間件
	options := etcdv3.ClientOptions{
		DialTimeout:   time.Second * 3,
		DialKeepAlive: time.Second * 3,
	}
	//連接注冊中心
	client, err := etcdv3.NewClient(ctx, []string{etcdServer}, options)
	if err != nil {
		panic(err)
	}
	logger := log.NewNopLogger()
	//創(chuàng)建實例管理器, 此管理器會Watch監(jiān)聽etc中prefix的目錄變化更新緩存的服務(wù)實例數(shù)據(jù)
	instancer, err := etcdv3.NewInstancer(client, prefix, logger)
	if err != nil {
		panic(err)
	}
	//創(chuàng)建端點管理器， 此管理器根據(jù)Factory和監(jiān)聽的到實例創(chuàng)建endPoint并訂閱instancer的變化動態(tài)更新Factory創(chuàng)建的endPoint
	endpointer := sd.NewEndpointer(instancer, reqFactory, logger) //reqFactory自定義的函數(shù)，主要用于端點層（endpoint）接受并顯示數(shù)據(jù)
	//創(chuàng)建負載均衡器
	balancer := lb.NewRoundRobin(endpointer)
 
	/**
	我們可以通過負載均衡器直接獲取請求的endPoint，發(fā)起請求
	reqEndPoint,_ := balancer.Endpoint()
	*/
 
	/**
	也可以通過retry定義嘗試次數(shù)進行請求
	*/
	reqEndPoint := lb.Retry(3, 100*time.Second, balancer) //請求次數(shù)為3，時間為10S（時間需要多于服務(wù)器限流時間3s）
 
	//增加熔斷中間件
	reqEndPoint=breakerMw(reqEndPoint)
 
	//現(xiàn)在我們可以通過 endPoint 發(fā)起請求了
	req := struct{}{}
	for i:=0;i<20;i++ {  //發(fā)生20次請求
		ctx=context.Background()
		if _, err = reqEndPoint(ctx, req); err != nil {
			//panic(err)
			fmt.Println("當前時間: ", time.Now().Format("2006-01-02 15:04:05.99"),"\t第",i+1,"次")
			fmt.Println(err)
			time.Sleep(1*time.Second)
		}
	}
}
 
//通過傳入的 實例地址  創(chuàng)建對應(yīng)的請求endPoint
func reqFactory(instanceAddr string) (endpoint.Endpoint, io.Closer, error) {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		conn, err := grpc.Dial(instanceAddr, grpc.WithInsecure())
		if err != nil {
			fmt.Println(err)
			panic("connect error")
		}
		defer conn.Close()
		bookClient := book.NewBookServiceClient(conn)
		bi, _ := bookClient.GetBookInfo(context.Background(), &book.BookInfoParams{BookId: 1})
		fmt.Println("獲取書籍詳情")
		fmt.Println("bookId: 1", " => ", "bookName:", bi.BookName)
		fmt.Println("請求服務(wù)成功: ", instanceAddr,"當前時間為:",time.Now().Format("2006-01-02 15:04:05.99"))
		/*bl, _ := bookClient.GetBookList(context.Background(), &book.BookListParams{Page: 1, Limit: 10})
		fmt.Println("獲取書籍列表")
		for _, b := range bl.BookList {
			fmt.Println("bookId:", b.BookId, " => ", "bookName:", b.BookName)
		}*/
		return nil, nil
	}, nil, nil
}