func Start(cc Chaincode) error {
	viper.SetEnvPrefix("OPENCHAIN")
	viper.AutomaticEnv()
	replacer := strings.NewReplacer(".", "_")
	//替换前缀为openchain的文件中的.为_
	viper.SetEnvKeyReplacer(replacer)

	flag.StringVar(&peerAddress, "peer.address", "", "peer address")

	flag.Parse()

	chaincodeLogger.Debug("Peer address: %s", getPeerAddress())

	// 使用同步检验建立与client的连接 
	clientConn, err := newPeerClientConnection()
	if err != nil {
		chaincodeLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
		return fmt.Errorf("Error trying to connect to local peer: %s", err)
	}

	chaincodeLogger.Debug("os.Args returns: %s", os.Args)

	chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)

	err = chatWithPeer(chaincodeSupportClient, cc)
	//启动chiancodeSuppportClient

	return err
}

func newPeerClientConnection() (*grpc.ClientConn, error) {
//调用google.golang.org中grpc的ClinetConn方法
	var opts []grpc.DialOption
	if viper.GetBool("peer.tls.enabled") {
//viper来源于github.com/spf13/viper，一个应用程序的配置系统
		var sn string
		if viper.GetString("peer.tls.server-host-override") != "" {
			sn = viper.GetString("peer.tls.server-host-override")
		}
		var creds credentials.TransportAuthenticator
		//credenetials包实现了各种支持g RPC库调用的凭证
		if viper.GetString("peer.tls.cert.file") != "" {
			var err error
			creds, err = credentials.NewClientTLSFromFile(viper.GetString("peer.tls.cert.file"), sn)
			if err != nil {
				grpclog.Fatalf("Failed to create TLS credentials %v", err)
			}
		} else {
			creds = credentials.NewClientTLSFromCert(nil, sn)
//NewClientTLSFromCert从客户端输入的证书中构造了TLS
		}
//append中grpc调用的方法在grpc根目录下下clientconn.go文件中定义方//法
		opts = append(opts, grpc.WithTransportCredentials(creds))
	}
///WithTransportCredentials返回配置了一个连接级别的安全凭据（例//如，TLS/ SSL）的拨号操作。
	opts = append(opts, grpc.WithTimeout(1*time.Second))
//WithTimeout返回配置客户端拨号超时连接的拨号操作
	opts = append(opts, grpc.WithBlock())
//WithBlock返回一个拨号选项，它将持续调用一个拨号块直到底层的连接已经建立。没有这一点，在后台发生将会立即返回拨打和服务器连接。
	opts = append(opts, grpc.WithInsecure())
	conn, err := grpc.Dial(getPeerAddress(), opts...)
	if err != nil {
		return nil, err
	}
	return conn, err
}

func chatWithPeer(chaincodeSupportClient pb.ChaincodeSupportClient, cc Chaincode) error {

	// 通过peer验证创建流
	stream, err := chaincodeSupportClient.Register(context.Background())
	if err != nil {
		return fmt.Errorf("Error chatting with leader at address=%s:  %s", getPeerAddress(), err)
	}

	//创建传递给链码的链码存根
	//stub := &ChaincodeStub{}

	// Create the shim handler responsible for all control logic
	handler = newChaincodeHandler(getPeerAddress(), stream, cc)

	defer stream.CloseSend()
	// Send the ChaincodeID during register.
	chaincodeID := &pb.ChaincodeID{Name: viper.GetString("chaincode.id.name")}
	payload, err := proto.Marshal(chaincodeID)
	if err != nil {
		return fmt.Errorf("Error marshalling chaincodeID during chaincode registration: %s", err)
	}
	// 流寄存器
	chaincodeLogger.Debug("Registering.. sending %s", pb.ChaincodeMessage_REGISTER)
	handler.serialSend(&pb.ChaincodeMessage{Type: pb.ChaincodeMessage_REGISTER, Payload: payload})
	waitc := make(chan struct{})
	go func() {
		defer close(waitc)
		msgAvail := make(chan *pb.ChaincodeMessage)
		var nsInfo *nextStateInfo
		var in *pb.ChaincodeMessage
		recv := true
		for {
			in = nil
			err = nil
			nsInfo = nil
			if recv {
				recv = false
				go func() {
					var in2 *pb.ChaincodeMessage
					in2, err = stream.Recv()
					msgAvail <- in2
				}()
			}
			select {
			case in = <-msgAvail:
				if err == io.EOF {
					chaincodeLogger.Debug("Received EOF, ending chaincode stream, %s", err)
					return
				} else if err != nil {
					chaincodeLogger.Error(fmt.Sprintf("Received error from server: %s, ending chaincode stream", err))
					return
				} else if in == nil {
					err = fmt.Errorf("Received nil message, ending chaincode stream")
					chaincodeLogger.Debug("Received nil message, ending chaincode stream")
					return
				}
				chaincodeLogger.Debug("[%s]Received message %s from shim", shortuuid(in.Uuid), in.Type.String())
				recv = true
			case nsInfo = <-handler.nextState:
				in = nsInfo.msg
				if in == nil {
					panic("nil msg")
				}
				chaincodeLogger.Debug("[%s]Move state message %s", shortuuid(in.Uuid), in.Type.String())
			}

			// 调用 FSM.handleMessage()，fsm即状态机
			err = handler.handleMessage(in)
			if err != nil {
				err = fmt.Errorf("Error handling message: %s", err)
				return
			}
			if nsInfo != nil && nsInfo.sendToCC {
				chaincodeLogger.Debug("[%s]send state message %s", shortuuid(in.Uuid), in.Type.String())
				if err = handler.serialSend(in); err != nil {
					err = fmt.Errorf("Error sending %s: %s", in.Type.String(), err)
					return
				}
			}
		}
	}()
	<-waitc
	return err
}

func Execute(ctxt context.Context, chain *ChaincodeSupport, t *pb.Transaction) ([]byte, error) {
	var err error

	// 得到一个处理账本至标记TX的开始/结束
	ledger, ledgerErr := ledger.GetLedger()
	if ledgerErr != nil {
		return nil, fmt.Errorf("Failed to get handle to ledger (%s)", ledgerErr)
	}

	if secHelper := chain.getSecHelper(); nil != secHelper {
		var err error
		t, err = secHelper.TransactionPreExecution(t)
		// 注意，t被现在解密并且是原始输入t的深克隆
		if nil != err {
			return nil, err
		}
	}

	if t.Type == pb.Transaction_CHAINCODE_NEW {
		_, err := chain.DeployChaincode(ctxt, t)
		if err != nil {
			return nil, fmt.Errorf("Failed to deploy chaincode spec(%s)", err)
		}

		//启动并等待准备就绪
		markTxBegin(ledger, t)
		_, _, err = chain.LaunchChaincode(ctxt, t)
		if err != nil {
			markTxFinish(ledger, t, false)
			return nil, fmt.Errorf("%s", err)
		}
		markTxFinish(ledger, t, true)
	} else if t.Type == pb.Transaction_CHAINCODE_EXECUTE || t.Type == pb.Transaction_CHAINCODE_QUERY {
		//将发动（如有必要，并等待就绪）
		cID, cMsg, err := chain.LaunchChaincode(ctxt, t)
		if err != nil {
			return nil, fmt.Errorf("Failed to launch chaincode spec(%s)", err)
		}

		//这里应该生效，因为它上面的生效...
		chaincode := cID.Name

		if err != nil {
			return nil, fmt.Errorf("Failed to stablish stream to container %s", chaincode)
		}

		// 当getTimeout调用被创建的事务块需要注释下一行，并取消注释
		timeout := time.Duration(30000) * time.Millisecond
		//timeout, err := getTimeout(cID)

		if err != nil {
			return nil, fmt.Errorf("Failed to retrieve chaincode spec(%s)", err)
		}

		var ccMsg *pb.ChaincodeMessage
		if t.Type == pb.Transaction_CHAINCODE_EXECUTE {
			ccMsg, err = createTransactionMessage(t.Uuid, cMsg)
			if err != nil {
				return nil, fmt.Errorf("Failed to transaction message(%s)", err)
			}
		} else {
			ccMsg, err = createQueryMessage(t.Uuid, cMsg)
			if err != nil {
				return nil, fmt.Errorf("Failed to query message(%s)", err)
			}
		}

		markTxBegin(ledger, t)
		resp, err := chain.Execute(ctxt, chaincode, ccMsg, timeout, t)
		if err != nil {
			// 交易回滚
			markTxFinish(ledger, t, false)
			return nil, fmt.Errorf("Failed to execute transaction or query(%s)", err)
		} else if resp == nil {
			// 交易回滚
			markTxFinish(ledger, t, false)
			return nil, fmt.Errorf("Failed to receive a response for (%s)", t.Uuid)
		} else {
			if resp.Type == pb.ChaincodeMessage_COMPLETED || resp.Type == pb.ChaincodeMessage_QUERY_COMPLETED {
				// Success
				markTxFinish(ledger, t, true)
				return resp.Payload, nil
			} else if resp.Type == pb.ChaincodeMessage_ERROR || resp.Type == pb.ChaincodeMessage_QUERY_ERROR {
				// Rollback transaction
				markTxFinish(ledger, t, false)
				return nil, fmt.Errorf("Transaction or query returned with failure: %s", string(resp.Payload))
			}
			markTxFinish(ledger, t, false)
			return resp.Payload, fmt.Errorf("receive a response for (%s) but in invalid state(%d)", t.Uuid, resp.Type)
		}

	} else {
		err = fmt.Errorf("Invalid transaction type %s", t.Type.String())
	}
	return nil, err
}