解码JSON时出错

Question

I have been experimenting with GO for the first time, over the last few days.

I have a HTML form that passes it's values to a server. This server in turn extracts the form keys/ values and places them inside a JSON. This JSON is then sent to another server.

The issue is: I get the following error when the second server attempts to decode the JSON:

Error decoding JSON: json: cannot unmarshal string into Go value of type main.NewContainerJSON

1: The original HTML form

<form method="post" action="http://127.0.0.1:8080/new-user" autocomplete ="on">
<table>
    <tr>
        <td colspan="2"><h1>Container Configuration</h1></td>
    </tr>
    <tr>
        <td><h2>Container Name</h2></td>
        <td><input type="text" name="containerName" placeholder = "My Container Name" required /></td>
    </tr>
    <tr>
        <td><h2>Base Server</h2></td>
        <td>
            <select name="BaseServer">
                <option value="Ubuntu 14.04">Ubuntu 14.04</option>
        </td>
    </tr>
    <tr>
        <td><h2>Content Management System</h2></td>
        <td>
            <select name="CMS">
                <option value="Wordpress">Wordpress</option>
        </td>
    </tr>
    <tr>
        <td><h2>Website Name</h2></td>
        <td><input type="text" name="websiteName" placeholder = "mysite.com" required /></td>
    </tr>
    <tr>
        <td><h2>New Root Database Password</h2> </td>
        <td><input type = "password" name = "dbRootPWD" placeholder = "password" required /></td>
    </tr>
    <tr>
        <td><h2>Database Admin Username</h2></td>
        <td><input type = "text" name = "dbAdminUname" placeholder = "Admin" required /></td>
    </tr>
    <tr>
        <td><h2>Database Admin Password</h2></td>
        <td><input type = "password" name = "dbAdminPwd" placeholder = "password" required /></td>
    </tr>
    <tr>
        <td></td>
        <td><input type = "submit" value = "submit"></td>
    </tr>
</table>    

2: The first servers code

package main

import (
"fmt"
"encoding/json"
"net"
"net/http"
 )

type newContainerJSON struct {
    ContainerName string
    BaseServer string
    CMS string
    WebsiteName string
    DBrootPWD string
    DBadminUname string
    DBadminPWD string
}

func newUser(w http.ResponseWriter, r *http.Request) {
    r.ParseForm()

    cName := r.FormValue("containerName")
    sName := r.FormValue("BaseServer")
    cmsName := r.FormValue("CMS")
    wsName := r.FormValue("websiteName")
    dbrootPwd := r.FormValue("dbRootPWD")
    dbadmName := r.FormValue("dbAdminUname")
    dbamdpwdName := r.FormValue("dbAdminPwd") 

    c := newContainerJSON {
        ContainerName: cName,
        BaseServer: sName,
        CMS: cmsName,
        WebsiteName: wsName,
        DBrootPWD: dbrootPwd,
        DBadminUname: dbadmName,
        DBadminPWD: dbamdpwdName,
    }

    d, _ := json.Marshal(c)
    s := string(d)
    fmt.Println(s)

    conn, err := net.Dial("tcp", "127.0.0.1:8081")
    checkError(err)

    encoder := json.NewEncoder(conn)

    encoder.Encode(d) 
}

func main() {
    http.HandleFunc("/new-user", newUser)
    err := http.ListenAndServe(":8080", nil) // setting listening port
    checkError(err)
}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
     }
}

3: The second servers code:

package main

import (
    "fmt"
    "net"
    "encoding/json"
)

type NewContainerJSON struct {
    ContainerName string    `json:",string"`
    BaseServer string       `json:",string"`
    CMS string              `json:",string"`
    WebsiteName string      `json:",string"`
    DBrootPWD string        `json:",string"`
    DBadminUname string     `json:",string"`
    DBadminPWD string       `json:",string"`
}

func main() {

    service := "127.0.0.1:8081"
    tcpAddr, err := net.ResolveTCPAddr("tcp", service)
    checkError(err)

    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)

    conn, err := listener.Accept()
    checkError(err)

    decoder := json.NewDecoder(conn)

    var b NewContainerJSON
    err = decoder.Decode(&b)
    checkError(err)

    fmt.Println(b)

    conn.Close() // we're finished

}

func checkError(err error) {
    if err != nil {
        fmt.Println("An error occurred: ", err.Error())

    }
}

The error occurs with following code in the second servers code

var b NewContainerJSON
err = decoder.Decode(&b)
checkError(err)

fmt.Println(b)

I suspect I am not decoding the JSON properly or I am missing something very obvious.

Answer 1

The first server is double encoding the value. The result is a string.

d, _ := json.Marshal(c) // d is []byte containing the JSON
...
encoder.Encode(d)  // encoder writes base64 encoding of []byte as JSON string

Change the code to:

conn, err := net.Dial("tcp", "127.0.0.1:8081")
if err != nil {
     // handle error
}
encoder := json.NewEncoder(conn)
if err := encoder.Encode(c); err != nil {
   // handle error
}