Go语言入门篇-JSON&http调用

一。Decoder

 /(一)Decoder
 func DecoderExample(){
     const jsonStream = `
         { "Name" : "Ed" , "Text" : "Knock knock." }
         { "Name" : "Sam" , "Text" : "Who's there?" }
         { "Name" : "Ed" , "Text" : "Go fmt." }
         { "Name" : "Sam" , "Text" : "Go fmt who?" }
         { "Name" : "Ed" , "Text" : "Go fmt yourself!" }
     `
     type Message struct {
         Name , Text string
     }
     dec := json. NewDecoder ( strings. NewReader ( jsonStream ) )
     for {
         var m Message
         if err := dec. Decode ( & m ) ; err == io. EOF {
             break
         } else if err != nil {
             log . Fatal ( err )
         }
         fmt. Printf ( "%s: %s \n " , m. Name , m. Text )
         /*
         执行结果：
          Ed: Knock knock.
          Sam: Who's there?
          Ed: Go fmt.
          Sam: Go fmt who?
          Ed: Go fmt yourself!
         */
     }
 }

二。对象转换为JSON的方法（函数）为 json.Marshal()

 //(二)Marshal序列化JSON格式（对象-》JSON）
 func marshalExample(){
     type ColorGroup struct {
         ID     int
         Name   string
         Colors [ ] string
     }
     group := ColorGroup {
         ID :      ,
         Name :   "Reds" ,
         Colors : [ ] string { "Crimson" , "Red" , "Ruby" , "Maroon" } ,
     }
     b , err := json. Marshal ( group )
     if err != nil {
         fmt. Println ( "error:" , err )
     }
     os. Stdout . Write ( b )
     /*
     运行结果：
     {"ID":1,"Name":"Reds","Colors":["Crimson","Red","Ruby","Maroon"]}
     */
 }

三。JSON 转换回对象的方法（函数）为 json.Unmarshal()

 //(三)unmarshal:反序列化json格式(JSON->对象)
 func unmarshalExample(){
     var jsonBlob = [ ] byte ( ` [
         { "Name" : "Platypus" , "Order" : "Monotremata" } ,
         { "Name" : "Quoll" ,     "Order" : "Dasyuromorphia" }
        ] ` )
     type Animal struct {
         Name  string
         Order string
     }
     var animals [ ] Animal
     err := json. Unmarshal ( jsonBlob , & animals )
     if err != nil {
         fmt. Println ( "error:" , err )
     }
     fmt. Printf ( "%+v" , animals )
     /*
     运行结果：
     [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
     */
 }

四。项目需求

参照go http传递json数据：https://blog.csdn.net/lanyang123456/article/details/78702873

golang学习室：https://www.kancloud.cn/digest/batu-go/153529

需求：
go调用java语言，传递json格式参数，并接收java返回的响应数据。（go建立http连接，传递请求参数，接收返回结果）

java端，返回json格式数据

1。Controller

 package com.csvalue.controller;
 import cfca.ra.common.vo.request.CertServiceRequestVO;
 import cfca.ra.common.vo.request.TxRequestVO;
 import cfca.ra.common.vo.response.CertServiceResponseVO;
 import cfca.ra.common.vo.response.TxResponseVO;
 import cfca.ra.toolkit.RAClient;
 import cfca.ra.toolkit.exception.RATKException;
 import com.alibaba.fastjson.JSON;
 import com.csvalue.common.ResponseCode;
 import com.csvalue.common.ResponseResult;
 import com.csvalue.model.CertificateParam;
 import com.csvalue.model.CertificateResult;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;

 @Controller
 @RequestMapping("/cfca")
 public class ApplyCertificateController {

     final org.slf4j.Logger log = LoggerFactory.getLogger(getClass());

     @ResponseBody
     @RequestMapping(value = "/applyCertificate", method = {RequestMethod.GET,RequestMethod.POST})
     public ResponseResult<CertificateResult> applyCertificate(@RequestBody CertificateParam certificateParam) {
         log.info("接收到获取证书的参数：",JSON.toJSONString(certificateParam));
         CertificateResult certificateResult=new CertificateResult();
         try {
             RAClient client = ApplyCertificateConfig.getRAClient();
             TxRequestVO txRequestVO = new TxRequestVO();
             txRequestVO.setTxCode("");
             TxResponseVO txResponseVO = (TxResponseVO) client.process(txRequestVO);
             if(!"".equals(txResponseVO.getResultCode())){
                 return ResponseResult.error(ResponseCode.DISCONNECT);
             }
             //设置请求参数
             CertServiceRequestVO certServiceRequestVO=setCertServiceRequestVO(certificateParam);
             //接收返回结果
             CertServiceResponseVO certServiceResponseVO = (CertServiceResponseVO) client.process(certServiceRequestVO);

             log.info("ResultCode:",certServiceResponseVO.getResultCode()); //
             log.info("resultMsg:",certServiceResponseVO.getResultMessage()); //成功
             //成功获取证书
             if (RAClient.SUCCESS.equals(certServiceResponseVO.getResultCode())) {
                 //设置返回结果
                 certificateResult=setCertificateResult(certServiceResponseVO);
                 log.info("返回申请证书结果：",JSON.toJSON(certificateResult));
             }else if("".equals(certServiceResponseVO.getResultCode())){
                 return ResponseResult.error(ResponseCode.NO_MATCH_CERTIFICATE);
             }else if("".equals(certServiceResponseVO.getResultCode())){
                 return ResponseResult.error(ResponseCode.PUBKEY_IS_USED);
             }else{
                 return ResponseResult.error(ResponseCode.FAIL);
             }
         } catch (RATKException e) {
             log.error(e.getMessage(), e);
             return ResponseResult.error(ResponseCode.FAIL);
         }
         return ResponseResult.success(certificateResult);
     }

     /*设置请求参数*/
     public CertServiceRequestVO setCertServiceRequestVO(CertificateParam certificateParam){
         CertServiceRequestVO certServiceRequestVO = new CertServiceRequestVO();
         certServiceRequestVO.setTxCode("");
         certServiceRequestVO.setCaName(certificateParam.getCaName());
         certServiceRequestVO.setCertType(certificateParam.getCertType());
         certServiceRequestVO.setCustomerType(certificateParam.getCustomerType());
         certServiceRequestVO.setUserName(certificateParam.getUserName());
         certServiceRequestVO.setIdentType(certificateParam.getIdentType());
         certServiceRequestVO.setIdentNo(certificateParam.getIdentNo());
         certServiceRequestVO.setKeyLength(certificateParam.getKeyLength());
         certServiceRequestVO.setKeyAlg(certificateParam.getKeyAlg());
         certServiceRequestVO.setBranchCode(certificateParam.getBranchCode());
         certServiceRequestVO.setEmail(certificateParam.getEmail());
         certServiceRequestVO.setP10(certificateParam.getP10());
         return certServiceRequestVO;
     }

     /*设置返回结果*/
     public CertificateResult setCertificateResult(CertServiceResponseVO certServiceResponseVO){
         CertificateResult certificateResult=new CertificateResult();
         certificateResult.setDn(certServiceResponseVO.getDn());
         certificateResult.setSequenceNo(certServiceResponseVO.getSequenceNo());
         certificateResult.setSerialNo(certServiceResponseVO.getSerialNo());
         certificateResult.setSignatureCert(certServiceResponseVO.getSignatureCert());
         certificateResult.setStartTime(certServiceResponseVO.getStartTime());
         certificateResult.setEndTime(certServiceResponseVO.getEndTime());
         certificateResult.setEncryptionCert(certServiceResponseVO.getEncryptionCert());
         certificateResult.setEncryptionCertSub(certServiceResponseVO.getEncryptionCertSub());
         certificateResult.setSignatureCert(certServiceResponseVO.getSignatureCert());
         certificateResult.setEncryptionPrivateKey(certServiceResponseVO.getEncryptionPrivateKey());
         certificateResult.setEncryptionPrivateKeySub(certServiceResponseVO.getEncryptionPrivateKeySub());
         return certificateResult;
     }
 }

2。model

 package com.csvalue.model;

 import java.io.Serializable;

 public class CertificateParam implements Serializable {
     private String caName;
     private String certType;
     private String customerType;
     private String userName;
     private String identType;
     private String identNo;
     private String keyAlg;
     private String keyLength;
     private String branchCode;
     private String email;
     private String p10;

     public String getCaName() {
         return caName;
     }

     public void setCaName(String caName) {
         this.caName = caName;
     }

     public String getCertType() {
         return certType;
     }

     public void setCertType(String certType) {
         this.certType = certType;
     }

     public String getCustomerType() {
         return customerType;
     }

     public void setCustomerType(String customerType) {
         this.customerType = customerType;
     }

     public String getUserName() {
         return userName;
     }

     public void setUserName(String userName) {
         this.userName = userName;
     }

     public String getIdentType() {
         return identType;
     }

     public void setIdentType(String identType) {
         this.identType = identType;
     }

     public String getIdentNo() {
         return identNo;
     }

     public void setIdentNo(String identNo) {
         this.identNo = identNo;
     }

     public String getKeyAlg() {
         return keyAlg;
     }

     public void setKeyAlg(String keyAlg) {
         this.keyAlg = keyAlg;
     }

     public String getKeyLength() {
         return keyLength;
     }

     public void setKeyLength(String keyLength) {
         this.keyLength = keyLength;
     }

     public String getBranchCode() {
         return branchCode;
     }

     public void setBranchCode(String branchCode) {
         this.branchCode = branchCode;
     }

     public String getEmail() {
         return email;
     }

     public void setEmail(String email) {
         this.email = email;
     }

     public String getP10() {
         return p10;
     }

     public void setP10(String p10) {
         this.p10 = p10;
     }
 }

 package com.csvalue.model;

 import java.io.Serializable;

 /*
 * 申请证书返回结果
 * */
 public class CertificateResult implements Serializable {
     private String dn;
     private String serialNo;
     private String signatureCert;
     private String sequenceNo;
     private String encryptionCert;
     private String encryptionPrivateKey;
     private String signatureCertSub;
     private String encryptionCertSub;
     private String encryptionPrivateKeySub;
     private String startTime;
     private String endTime;

     public String getDn() {
         return dn;
     }

     public void setDn(String dn) {
         this.dn = dn;
     }

     public String getSerialNo() {
         return serialNo;
     }

     public void setSerialNo(String serialNo) {
         this.serialNo = serialNo;
     }

     public String getSignatureCert() {
         return signatureCert;
     }

     public void setSignatureCert(String signatureCert) {
         this.signatureCert = signatureCert;
     }

     public String getSequenceNo() {
         return sequenceNo;
     }

     public void setSequenceNo(String sequenceNo) {
         this.sequenceNo = sequenceNo;
     }

     public String getStartTime() {
         return startTime;
     }

     public void setStartTime(String startTime) {
         this.startTime = startTime;
     }

     public String getEndTime() {
         return endTime;
     }

     public void setEndTime(String endTime) {
         this.endTime = endTime;
     }

     public String getEncryptionCert() {
         return encryptionCert;
     }

     public void setEncryptionCert(String encryptionCert) {
         this.encryptionCert = encryptionCert;
     }

     public String getEncryptionPrivateKey() {
         return encryptionPrivateKey;
     }

     public void setEncryptionPrivateKey(String encryptionPrivateKey) {
         this.encryptionPrivateKey = encryptionPrivateKey;
     }

     public String getSignatureCertSub() {
         return signatureCertSub;
     }

     public void setSignatureCertSub(String signatureCertSub) {
         this.signatureCertSub = signatureCertSub;
     }

     public String getEncryptionCertSub() {
         return encryptionCertSub;
     }

     public void setEncryptionCertSub(String encryptionCertSub) {
         this.encryptionCertSub = encryptionCertSub;
     }

     public String getEncryptionPrivateKeySub() {
         return encryptionPrivateKeySub;
     }

     public void setEncryptionPrivateKeySub(String encryptionPrivateKeySub) {
         this.encryptionPrivateKeySub = encryptionPrivateKeySub;
     }
 }

3。返回结果：

 {
     "code": ,
     "msg": "成功",
     "data": {
         "dn": "bb",
         "serialNo": "",
         "signatureCert": "aa",
         "sequenceNo": "",
         "encryptionCert": "",
         "encryptionPrivateKey": "",
         "signatureCertSub": null,
         "encryptionCertSub": null,
         "encryptionPrivateKeySub": null,
         "startTime": "",
         "endTime": ""
     }
 }

******注意：******

使用postman测试java接口，是否能够成功调用

SpringMVC @RequestBody请求参数在postman中的请求

Step1：设置header中两个参数

Step2：设置json参数

go端，调用java端，传递请求参数及接收返回的JSON数据

1。callJava.go

 package lib

 import (
     "net/http"
     "fmt"
     "git.jd.com/baas/identity/cachain/common"
     "encoding/json"
     "strings"
     "io/ioutil"
     "log"
     "git.jd.com/baas/identity/cachain/api"
 )

 type EnrollCfca struct {
     AuditId         int    `json:"auditId"`
     CaName       string `json:"caName"`
     CertType     string `json:"certType"`
     CustomerType string `json:"customerType"`
     UserName     string `json:"userName"`
     IdentType    string `json:"identType"`
     IdentNo      string `json:"identNo"`
     KeyAlg       string `json:"keyAlg"`
     KeyLength    string `json:"keyLength"`
     BranchCode   string `json:"branchCode"`
     Email        string `json:"email"`
     P10          string `json:"p10"`
 }

 type  ResultCfca struct{
     Code       int               `json:"code"`
     Msg        string          `json:"msg"`
     Data        api.CfcaInfo   `json:"data"`
 }

 func enrollCFCA(w http.ResponseWriter, r *http.Request, h UserHandler)  {
     logger.Debugf("Enter enrollCFCA...")
     defer logger.Debugf("Leave enrollCFCA...")

     SetHeader(w)

     var errMsg string

     rareReq := EnrollCfca{}
     if err := ReadRequest(r, &rareReq); err != nil {
         logger.Errorf("read request err:%s", err.Error())
         errMsg = fmt.Sprintf("Failure to read body:%s", err.Error())
         common.SendResponse(w, common.ERR_READ_REQUEST, errMsg)
         return
     }

     logger.Debugf("user enrollCFCA info: %+v", rareReq)

     //1。调用java，从CFCA获取证书
     resultCfca := callJava(rareReq)

     if resultCfca.Code !=  {
         common.SendResponse(w, common.ERR_FAILURE, resultCfca.Msg)
         return
     }

     resultCfca.Data.AuditId=rareReq.AuditId

     //开启一个事务
     tx, err := h.DBConn.Begin()
     if err != nil {
         logger.Errorf("Fail to begin a transaction,err:%s", err.Error())
         common.SendResponse(w, common.ERR_SQL_TRANSACTION, "Fail to begin transacton,err:"+err.Error())
         return
     }

     //1.将数据存储到数据库
     err = h.SaveCfcaDataToDB(resultCfca.Data)

     if err != nil {
         logger.Errorf("Error insert cfcainfo into database err:%s", err.Error())
         common.SendResponse(w, common.ERR_SQL_INSERT, "Fail insert cfcainfo!user:"+rareReq.UserName+",err:"+err.Error())
         tx.Rollback()
         return
     }
     tx.Commit()
     return
 }
 //调用java
 func callJava(javaParam EnrollCfca) ResultCfca{
     url := "http://localhost:8888/cfca/applyCertificate"
     contentType := "application/json;charset=utf-8"
     javaJsonParam, errs := json.Marshal(javaParam) //转换成JSON返回的是byte[]
     if errs != nil {
         fmt.Println(errs.Error())
     }
     fmt.Println(string(javaJsonParam))

     //发送请求
     req, err := http.NewRequest("POST", url, strings.NewReader(string(javaJsonParam)))
     if err != nil {
         panic(err)
     }
     req.Header.Set("Content-Type", contentType)
     client := &http.Client{}
     resp, err := client.Do(req)
     if err != nil {
         panic(err)
     }
     defer resp.Body.Close()
     //响应
     response, err := ioutil.ReadAll(resp.Body)
     fmt.Println("response:", string(response))
     if err != nil {
         log.Println("Read failed:", err)
         return ResultCfca{}
     }
     log.Println("response:", string(response))

     //cfca返回结果
     resultcfca := ResultCfca{}
     json.Unmarshal([]byte(string(response)), &resultcfca) //json解析到结构体里面
     fmt.Println("resultcfca",resultcfca)         //输入结构体
     fmt.Println("code",resultcfca.Code)

     return resultcfca
 }

2。api.go

 package api
 type CfcaInfo struct {
     AuditId            int         `db:"auditId" json:"auditId"`
     Dn                 string      `db:"dn"        json:"dn"`
     SerialNo           string      `db:"serialNo"    json:"serialNo"`
     SignatureCert     string      `db:"signatureCert"    json:"signatureCert"`
     SequenceNo         string      `db:"sequenceNo"        json:"sequenceNo"`
     StartTime       string     `db:"startTime"        json:"startTime"`
     EndTime          string     `db:"endTime"        json:"endTime"`
     EncryptionCert    string     `db:"encryptionCert"    json:"encryptionCert"`
     EncryptionPrivateKey    string    `db:"encryptionPrivateKey"    json:"encryptionPrivateKey"`
     SignatureCertSub        string    `db:"signatureCertSub" json:"signatureCertSub"`
     EncryptionCertSub        string     `db:"encryptionCertSub" json:"encryptionCertSub"`
     EncryptionPrivateKeySub string     `db:"encryptionPrivateKeySub" json:"encryptionCertSub"`
 }

3。ra.go

 package ra
 const (saveEnrollCfca      = `INSERT INTO cfca_info(auditId,dn,serialNo,signatureCert,sequenceNo,encryptionCert,encryptionPrivateKey,signatureCertSub,encryptionCertSub,encryptionPrivateKeySub,startTime,endTime)
                            VALUES(:auditId,:dn,:serialNo,:signatureCert,:sequenceNo,:encryptionCert,:encryptionPrivateKey,:signatureCertSub,:encryptionCertSub,:encryptionPrivateKeySub,:startTime,:endTime)`
     )
 type DBConn struct {
     *sqlx.DB
 }

 func (d *DBConn) SaveCfcaDataToDB(enrollResult api.CfcaInfo) error {
     logger.Debugf("Enter SaveCfcaDataToDB ...")
     defer logger.Debugf("Leave SaveCfcaDataToDB ...")

     err := d.checkDB()
     if err != nil {
         logger.Errorf("check db err:%s", err.Error())
         return err
     }

     res, err := d.NamedExec(saveEnrollCfca, enrollResult)

     if err != nil {
         logger.Errorf("Error adding cfcaInfo %s to the database: %s", enrollResult.AuditId, err)
         return err
     }

     numRowsAffected, err := res.RowsAffected()
     if err != nil {
         logger.Errorf("Error adding cfcaInfo %s affected err: %s", enrollResult.AuditId, err)
         return err
     }

     if numRowsAffected ==  {
         return fmt.Errorf("Failed to add cfcaInfo %s to the database:", enrollResult.AuditId)
     }

     if numRowsAffected !=  {
         return fmt.Errorf("Expected to add one record to the datab ase, but %d records were added", numRowsAffected)
     }
     return nil
 }

五。项目需求

参考博客：

http://www.cnblogs.com/Goden/p/4658287.html

http://www.01happy.com/golang-http-client-get-and-post/

项目需求：
go调用java传递string类型参数

Java端代码：

  /*
     * 撤销证书
     * */
     @ResponseBody
     @RequestMapping(value = "/revokeCertificate", method = RequestMethod.POST)
     public ResponseResult revokeCertificate(String dn) {
         log.info("接收到撤销的dn参数：", dn);
         try {
             RAClient client = CertificateConfig.getRAClient();
             CertServiceRequestVO certServiceRequestVO = new CertServiceRequestVO();
             certServiceRequestVO.setTxCode("");
             // certServiceRequestVO.setLocale(locale);
             certServiceRequestVO.setDn(dn);
             CertServiceResponseVO certServiceResponseVO = (CertServiceResponseVO) client.process(certServiceRequestVO);
             log.info("撤销证书返回状态码和状态值：",certServiceResponseVO.getResultCode(),certServiceResponseVO.getResultMessage());
             if(!RAClient.SUCCESS.equals(certServiceResponseVO.getResultCode())){ //成功状态
                 return ResponseResult.error(Integer.parseInt(certServiceResponseVO.getResultCode()),certServiceResponseVO.getResultMessage());
             }
             System.out.println(certServiceResponseVO.getResultCode());
             System.out.println(certServiceResponseVO.getResultMessage());
         } catch (RATKException e) {
             log.error(e.getMessage(), e);
             return ResponseResult.error(ResponseCode.FAIL);
         }
         return ResponseResult.success(ResponseCode.OK);
     }

PostMan测试

Go端调用java实现传递url和参数

 /*
 吊销证书
 */
 func revokeCfcaCert(userName string, h UserHandler) error {
     logger.Debugf("enter revokeCert")
     defer logger.Debugf("leave revokeCert")

     if userName == "" {
         return errors.New("userName is null")
     }
     //1.根据用户名查询dn值
     cfcaInfo, err := h.DBGetCfcaInfo(userName)

     log.Println("获取cfcaInfo:", cfcaInfo)

     if err != nil {
         return err
     }

     //2.调用java撤销cfca证书
     resultCfca := callJavaRevoke(cfcaInfo.Dn)

     log.Println("吊销证书resultCfca:", resultCfca)

     if resultCfca.Code !=  {
         //return fmt.Errorf(resultCfca.Msg)
         return errors.New(resultCfca.Msg)
     }
     return nil
 }

 func callJavaRevoke(dn string) ResultCfca {
     url := "http://localhost:8888/cfca/revokeCertificate"
     contentType := "application/x-www-form-urlencoded"
     //发送请求
     req, err := http.NewRequest("POST", url, strings.NewReader("dn="+dn))
     if err != nil {
         panic(err)
     }
     req.Header.Set("Content-Type", contentType)
     client := &http.Client{}
     resp, err := client.Do(req)
     if err != nil {
         panic(err)
     }
     defer resp.Body.Close()
     //响应
     response, err := ioutil.ReadAll(resp.Body)
     fmt.Println("response:", string(response))
     if err != nil {
         log.Println("Read failed:", err)
         return ResultCfca{}
     }
     log.Println("response:", string(response))

     //cfca返回结果
     resultcfca := ResultCfca{}
     json.Unmarshal([]byte(string(response)), &resultcfca) //json解析到结构体里面
     fmt.Println("resultcfca", resultcfca)                 //输入结构体
     fmt.Println("code", resultcfca.Code)
     return resultcfca
 }