func (m *MsgManager) Receive(ctx context.Context) error {
    // 定义队列
	q, err := m.ch.QueueDeclare(
		"",    // name
		false, // durable
		false, // delete when unused
		true,  // exclusive
		false, // no-wait
		nil,   // arguments
	)
	// 绑定交换机和队列
	err = m.ch.QueueBind(
		q.Name,         // queue name
		"",             // routing key
		m.exchangeName, // exchange
		false,
		nil,
	)
	// 获得一个消费channel，数据会直接传入channel中
	msgCh, err := m.ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	// 启动一个协程，消费消息
	go func() {
		for {
			select {
			case d := <-msgCh:
				m.rwLock.RLock()
                // 扇出模式会导致自己也收到消息，所以缓存了上一个消息，来去重
				if m.backData != nil && bytes.Equal(m.backData, d.Body) {
					m.rwLock.RUnlock()
					continue
				}
				m.rwLock.RUnlock()
				m.ReceiveCh <- d.Body
			case <-ctx.Done():
				log.Println(" [receive]: ctx done!")
				return
			}
		}
	}()
	return nil
}

	go func() {
		for {
			select {
			case <-reconnectCh:
				msgManager = mq.NewMsgManager(util.User, util.Url)
				cancel = nil
				err := msgManager.Init()
				if err != nil {
					log.Println("init msg fail")
					msgManager = nil
					errCh <- err
					continue
				}

				ctx, cancel = context.WithCancel(context.Background())
				err = msgManager.Receive(ctx)
				if err != nil {
					log.Println("init msg receive err")
					errCh <- err
					continue
				}

				log.Println("rabbitMQZ init success")
			Deal:
				for {
					select {
					case cell := <-clipboardM.CellChan:
						cell = filter_.Execute(cell)
						if cell == nil {
							log.Println("Filter cell")
							continue
						}
						data, err := clipboard.Encode(cell)
						if err != nil {
							log.Println("encode fail: ", err)
							continue
						}
						err = msgManager.Send(data)
						if err != nil {
							log.Println("send fail: ", err)
							continue
						}

						log.Printf("send length: %d", len(data))
					case data := <-msgManager.ReceiveCh:
						if len(data) == 0 {
							log.Println("empty payload, reconnect")
							errCh <- fmt.Errorf("empty payload")
							break Deal
						}
						c, err := clipboard.Decode(data)
						if err != nil {
							log.Println("decode fail: ", err)
							continue
						}
						log.Printf(" receive length: %d", len(data))
						err = clipboardM.Write(c)
						if err != nil {
							log.Println("write fail: ", err)
							continue
						}
					}
				}
			case err := <-errCh:
				log.Println("err: ", err)
				if cancel != nil {
					cancel()
				}
				if msgManager != nil {
					msgManager.Close()
				}
				clipboardM.Clean()
				reconnectCh <- struct{}{}
				<-time.After(time.Second * 3)
			}
		}
	}()

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                             Magic                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         Message Type                          |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                        Message Length                         |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+


struct Header {
        unsigned int Magic;
        int MessageType;
        int MessageLength;
}

syntax = "proto3";

option go_package="./;cell";

import "google/protobuf/timestamp.proto";

message Cell{
  google.protobuf.Timestamp Time = 1;
  string Types = 2;
  bytes Data = 3;
}

func (c *Clipboard) Watching(ctx context.Context) {
	ch1 := clipboard.Watch(ctx, clipboard.FmtText)
	ch2 := clipboard.Watch(ctx, clipboard.FmtImage)

	for {
		select {
		case data := <-ch1:
			c.CellChan <- &cell.Cell{
				Time:  timestamppb.Now(),
				Types: TypeText,
				Data:  data,
			}
		case data := <-ch2:
			c.CellChan <- &cell.Cell{
				Time:  timestamppb.Now(),
				Types: TypeImg,
				Data:  data,
			}
		}
	}
}

func (c *Clipboard) Write(cell *cell.Cell) error {
	switch cell.Types {
	case TypeText:
		clipboard.Write(clipboard.FmtText, cell.Data)
		return nil
	case TypeImg:
		clipboard.Write(clipboard.FmtImage, cell.Data)
		return nil
	default:
		return fmt.Errorf("[ClipboardManager]:error type")
	}
}

type Converter interface {
	Encode([]byte) ([]byte, error)
	Decode([]byte) ([]byte, error)
}

type BaseConverter struct {
}

func (c *BaseConverter) Encode(data []byte) ([]byte, error) {
	return data, nil
}

func (c *BaseConverter) Decode(data []byte) ([]byte, error) {
	return data, nil
}

type Encryptor struct {
	Converter Converter
	key       []byte
}

// in -> data -> out
func (e *Encryptor) Encode(in []byte) ([]byte, error) {
	data, err := e.Converter.Encode(in)
	block, err := aes.NewCipher(e.key)
	aesGCM, err := cipher.NewGCM(block)
	nonce := make([]byte, aesGCM.NonceSize())
	if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
		return nil, err
	}
	return aesGCM.Seal(nonce, nonce, data, nil), nil
}

func (e *Encryptor) Decode(in []byte) ([]byte, error) {
	block, err := aes.NewCipher(e.key)
	aesGCM, err := cipher.NewGCM(block)
	nonceSize := aesGCM.NonceSize()
	nonce, cipherData := in[:nonceSize], in[nonceSize:]
	data, err := aesGCM.Open(nil, nonce, cipherData, nil)
	out, err := e.Converter.Decode(data)
	return out, nil
}

func (e *Encryptor) SetKey(key []byte) {
	e.key = key
}

var convert converter.Converter
convert = &converter.BaseConverter{}

func UseCompress() {
	convert = &converter.Compressor{Converter: convert}
}

func UseEncryptor(key []byte) {
	e := &converter.Encryptor{
		Converter: convert,
	}
	e.SetKey(key)
	convert = e
}

clipboard.UseCompress()
clipboard.UseEncryptor(util.MD5([]byte(util.Password)))

type Filter interface {
	Execute(cell *cell.Cell) *cell.Cell
	SetNext(next Filter)
}

type VerificationCode struct {
	next   Filter
	regexp *regexp.Regexp
}

func NewVerificationCode() *VerificationCode {
	r, err := regexp.Compile("^[0-9]{4,6}$")
	if err != nil {
		panic(err)
	}
	return &VerificationCode{
		regexp: r,
	}
}

func (c *VerificationCode) Execute(cell *cell.Cell) *cell.Cell {
	if cell.Types == clipboard.TypeText && c.regexp.Match(cell.Data) {
		log.Println("match code")
		return nil
	}
    // 没有下一个节点了，直接返回
	if c.next == nil {
		return cell
	}
	// next
	return c.next.Execute(cell)
}

func (c *VerificationCode) SetNext(next Filter) {
	c.next = next
}

// 定义2个过滤器
taobaoFilter := &filter.TaobaoLink{}
codeFilter := filter.NewVerificationCode()

// 串联
taobaoFilter.SetNext(codeFilter)
var filter_ filter.Filter = taobaoFilter

// 对cell进行过滤
cell = filter_.Execute(cell)
// 为nil则说明被拦截，放弃这次操作
if cell == nil {
    log.Println("Filter cell")
    continue
}