精华内容
下载资源
问答
  • //模拟form进行表单提交  post.setEntity(entity);    //banding内容  HttpResponse response = client.execute(post);   //连接服务器     if (response.getStatusLine().getStatusCode()==200){ ...
    public  class  HttpClientPostUtil {
          
            public  static  String  loginGet(String url,String username,String password){
          HttpClient client =  new  DefaultHttpClient();  //客户端对象
          HttpPost post  =  new  HttpPost(url);              //请求对象
          
          NameValuePair pai1 =  new  BasicNameValuePair( "username" ,username);
          NameValuePair pai2 =  new  BasicNameValuePair( "password" ,password);
          List< NameValuePair>list =  new  ArrayList< NameValuePair>();
          list.add(pai1);
          list.add(pai2);
            try  {
                HttpEntity entity =  new  UrlEncodedFormEntity(list); //模拟form进行表单提交
                 post.setEntity(entity);                                //banding内容
                 HttpResponse response = client.execute(post);  //连接服务器
                  if (response.getStatusLine().getStatusCode()==200){
                       HttpEntity entit =  response.getEntity();  //获取内容
                        return  EntityUtils.toString(entit,  "utf-8" );
                 }
                
          }  catch  (UnsupportedEncodingException e) {
                  //  TODO  Auto-generated catch block
                e.printStackTrace();
          }  catch  (ClientProtocolException e) {
                  //  TODO  Auto-generated catch block
                e.printStackTrace();
          }  catch  (IOException e) {
                  //  TODO  Auto-generated catch block
                e.printStackTrace();
          }
          
            return  "" ;
          }


          
            public  static  void  downFile(String urlStr,String target){
                HttpClient client =  new  DefaultHttpClient();
                HttpPost get =  new  HttpPost(urlStr);
                FileOutputStream fos=  null ;
                  try  {
                      HttpResponse response=client.execute(get);
                        if (response.getStatusLine().getStatusCode()==200){
                            HttpEntity entity = response.getEntity();
                             fos =  new  FileOutputStream(target);
                             fos.write(EntityUtils. toByteArray(entity));         //写入到磁盘
                             System.  out .println( "sucess!"  );
                              /*
                             InputStream  is = entity.getContent();
                             byte [] b = new byte[1024*800];
                             int tem =0;
                             while(( tem=is.read())!=-1){
                                   fos.write(b, 0, tem);
                             }
                             */   
                      }
                      fos.flush();
                      fos.close();
                }  catch  (ClientProtocolException e) {
                        //  TODO  Auto-generated catch block
                      e.printStackTrace();
                }  catch  (IOException e) {
                        //  TODO  Auto-generated catch block
                      e.printStackTrace();
                }
                
          }

    }



    测试类


    public  class  HttpClientPostTest {

            public  static  void  main(String[] args) {
                  //  TODO  Auto-generated method stub
           String url = "http://localhost:8080/mp3/servlet/HttpClientServlet"  ;
           Scanner s =  new  Scanner(System. in );
           System.  out .println( "请输入用户名"  );
           String name = s.next();
           System.  out .println( "请输入密码"  );
           String password = s.next();
     
           String msg= HttpClientPostUtil. loginGet(url,name,password);
           System.  out .println(msg);
    //       String str1 = "http://localhost:8080/mp3/aixi.jpg";
    //       String target="d:\\aixiPost.jpg";
    //       HttpClientPostUtil.downFile(str1, target);
         
          }

    }
    展开全文
  • golang表单提交服务器的交互

    千次阅读 2015-07-12 22:49:54
    网络编程 ... 前端是Web+移动,后端是Linux(命令行centos)+开源...服务器和客户端(浏览器也是客户端) socket编程 rpc编程 ------------------------------------------------------------------------------se
    网络编程
    
    socket,http,rpc,json处理


    前端是Web+移动,后端是Linux(命令行centos)+开源


    http编程
    服务器和客户端(浏览器也是客户端)
    socket编程
    rpc编程


    ------------------------------------------------------------------------------server.go


    package main


    //服务端开发,特别是Web开发,基本上全是处理HTTP请求的处理。
    //根据具体用途分为两种:Web页面开发和API接口开发。
    //Web页面开发也完全可以看成是API接口开发,只是它的两个主要部分,
    //页面和ajax请求,一个是返回html,另外一个可以返回html,也可以返回其他格式的而已。
    //API接口开发是针对有客户端产品而言的。可能是移动设备,可能是PC应用等。
    import (
    "fmt"
    "io"
    "net/http"
    )


    func handler(w http.ResponseWriter, r *http.Request) {
    http.SetCookie(w, &http.Cookie{Name: "pa", Value: "dps"})
    r.Header.Add("server", "go/1.0")
    io.WriteString(w, "myserver is running!")
    fmt.Printf("r.header=%+v,r.usr.string=%+v,r.url.path=%+v\n", r.Header, r.URL.String(), r.URL.Path)
    r.ParseForm()
    d := r.Form
    fmt.Println(d)


    }


    func main() {
    http.HandleFunc("/agent", handler)


    http.ListenAndServe(":8080", nil)
    }




    ------------------------------------------------------------------------------------get.go
    自己写客户端,get请求
    代替浏览器的地址栏里输入的所有信息




    func main() {
    resp, err := http.Get("http://localhost:8080/agent?name=幻刺&password=123456#stuff")
    if err != nil {
    fmt.Println("resp err=", err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
    fmt.Println("body err=", err)
    }
    fmt.Println(string(body))
    fmt.Println(resp.StatusCode)
    fmt.Println(resp.Proto, resp.ProtoMajor, resp.ProtoMinor)
    }




    ---------------------------------------------------------------------------------post.go
    自己写客户端 post请求
    post适合提交有密码的信息,因为参数都存储在body中,设置对应的bodytype,对应在浏览器地址栏不会显示


    浏览器默认是get请求,向服务器索取数据的一种请求
    post是想服务器提交数据的一种请求,要提交的信息位于信息头后面的实体中(数据体),在地址栏看不到。
    HTTP协议是以ASCII码传输,建立在TCP/IP协议之上的应用层规范,规范http请求格式
    method request-URL version
    headers
    空一行
    entity-body


    POST提交的数据必须放在消息主体entity-body中,但没有规定编码方式,但要服务端解析成功才有意义。服务器一般根据 请求头中 Content-Type字段获得body的编码方式
    POST(URL,bodytype,[]byte)


    (1)application/x-www-form-urlencoded  最常见的POST提交数据的方式,浏览器的原生form表单。后面可以跟charset=utf-8
    (2)multipart/form-data
    (3)application/json
    (4)text/xml    XML-RPC远程调用


    //第三个参数的简单形式 (url.Values{"title":{"sss"},"content":{"article body"}})


    func main() {
    v := url.Values{}
    v.Add("name", "幻刺")
    v.Set("password", "123456")
    u := ioutil.NopCloser(strings.NewReader(v.Encode()))
    r, err := http.Post("http://localhost:8080/agent", "application/x-www-form-urlencoded", u)
    if err != nil {
    fmt.Println("http post err:", err)
    }
    defer r.Body.Close()
    fmt.Println(r.StatusCode)
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
    fmt.Println("http body err:", err)
    }
    fmt.Println(string(body))
    }


    ---------------------------------------------------------------------------------client.go
    请求头的单词一定不能拼错,都是对应服务端语言去解析的


    func main() {
    client := &http.Client{}
    req, err := http.NewRequest("POST", "http://localhost:8080/agent", strings.NewReader("name=敌法,password=32984"))
    if err != nil {
    fmt.Println("newRequest err:", err)
    }
    req.Header.Set("Connection", "keep-alive")
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Set("Cookie", "幻刺")
    req.Header.Set("User-Agent", "幽鬼")


    resp, err := client.Do(req)
    if err != nil {
    fmt.Println("client do err:", err)
    }
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
    fmt.Println("body read err:", err)
    }
    fmt.Println(string(body))
    }






    ------------------------------------------------socket编程


    tcp tcp4 tcp6 udp udp4 udp6 ip ip4 ip6 简洁的抽象了网络层和传输层
    conn,err:=net.Dial("tcp","192.168.0,10:8080)
    conn,err:=net.Dial("udp","192.168.0,10:8080)
    conn,err:=net.Dial("ip4:icmp","192.168.0,10:8080)
    conn,err:=net.Dial("ip4:1","192.168.0,10:8080)


    用tcp写个聊天测试,分客户端和服务端
    ------------------------------------Dial()


    server.go




    func main() {
    addr, err := net.ResolveTCPAddr("tcp", ":8080")
    checkErr(err)
    listen, err := net.ListenTCP("tcp", addr)
    checkErr(err)
    fmt.Println("Start server...")
    for {
    conn, err := listen.Accept()
    checkErr(err)
    go Handle(conn) // 每次建立一个连接就放到单独的线程内做处理
    }
    }


    const BufLength = 128


    var users map[string]net.Conn = make(map[string]net.Conn, 10)


    func Handle(conn net.Conn) {
    conn.Write([]byte("欢迎加入2B聊天组~"))
    for {
    data := make([]byte, 0) //此处做一个输入缓冲以免数据过长读取到不完整的数据
    buf := make([]byte, BufLength)
    for {
    n, err := conn.Read(buf)
    if err != nil && err != io.EOF {
    checkErr(err)
    }
    data = append(data, buf[:n]...)
    if n != BufLength {
    break
    }
    }


    cmd := strings.Split(string(data), "|")
    fmt.Println("命令:", cmd)


    switch cmd[0] {
    case "nick":
    fmt.Println("注册名称:" + cmd[1])
    users[cmd[1]] = conn
    case "say":
    for k, v := range users {
    if k != cmd[1] {
    fmt.Println("给" + k + "发送消息:" + cmd[2])
    v.Write([]byte(cmd[1] + ":[" + cmd[2] + "]"))
    }
    }
    }
    }
    }


    func checkErr(err error) {
    if err != nil {
    fmt.Println(err)
    os.Exit(-1)
    }
    }




    ------------------------------------client.go


    var nick string = ""


    func main() {
    addr, err := net.ResolveTCPAddr("tcp", ":8080")
    checkErr(err)
    conn, err := net.DialTCP("tcp", nil, addr)
    checkErr(err)
    // 读取提示
    data := make([]byte, 1024)
    conn.Read(data)
    fmt.Println(string(data))
    // 输入昵称
    fmt.Print("输入昵称:")
    fmt.Scanf("%v", &nick)
    fmt.Println("Hello " + nick)
    conn.Write([]byte("nick|" + nick))


    go Handle(conn)


    for {
    someTex := ""
    fmt.Scanf("%v", &someTex)
    conn.Write([]byte("say|" + nick + "|" + someTex))
    }
    }


    const BufLength = 128


    func Handle(conn net.Conn) {
    for {
    data := make([]byte, 1024)
    buf := make([]byte, BufLength)
    for {
    n, err := conn.Read(buf)
    if err != nil && err != io.EOF {
    checkErr(err)
    }
    data = append(data, buf[:n]...)
    if n != BufLength {
    break
    }
    }


    fmt.Println(string(data))
    }
    }


    func checkErr(err error) {
    if err != nil {
    fmt.Println(err)
    os.Exit(-1)
    }
    }




    ----------------------------------------------------------------------rpc编程


    RPC--romote procedure call protocol远程调用,类似调用本地函数一样调用服务器的函数,不需要了解底层网络细节的应用程序通信协议。RPC构建与TCP或UDP,或者是HTTP之上。采用客户端/服务器的工作模式,
    当执行一个远程过程调用时,客户端首先发送一个带有参数的调用信息到服务端,等待服务器的响应。在服务端,服务进程保存睡眠状态直到客户端的调用信息到达为止。组合客户端接收来自服务端的应答信息,获得进程结果
    必须格式:
    func (t *T) MethodName(argType T1,replyType *T2)error{}
    第一个参数是RPC客户端要传入的参数;第二个参数是要返回给RPC客户端的结果。
    服务端一般 通过TCP或HTTP在某个网络地址上进行监听来创建该服务
    net/rpc   rpc.Dail() 和 rpc.DialHTTP() 方法来与指定的RPC服务端建立连接。
    调用RPC客户端的  Call()方法进行同步处理  Go()进行异步处理,即rpc客户端不用等待服务端的结果即可执行后面的程序
    若在rpc传输过程中不指定编码解码器,默认使用go标准库的 encoding/gob




    -----------------------------------------rpcserver.go


    package server
    type Args struct {
    A, B int
    }
    type Quotient struct {
    Quo, Rem int
    }
    type Arith int
    func (t *Arith) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
    }
    func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
    return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
    }
    //注册服务对象并开启该 RPC 服务的代码如下:
    arith := new(Arith)
    rpc.Register(arith)
    rpc.HandleHTTP()
    l, e := net.Listen("tcp", ":1234")
    if e != nil {
    log.Fatal("listen error:", e)
    }
    go http.Serve(l, nil)


    此时, RPC 服务端注册了一个Arith类型的对象及其公开方法Arith.Multiply()和
    Arith.Divide()供 RPC 客户端调用。 RPC 在调用服务端提供的方法之前,必须先与 RPC 服务
    端建立连接,如下列代码所示:
    client, err := rpc.DialHTTP("tcp", serverAddress + ":1234")
    if err != nil {
    log.Fatal("dialing:", err)
    }
    在建立连接之后, RPC 客户端可以调用服务端提供的方法。首先,我们来看同步调用程序顺
    序执行的方式:
    args := &server.Args{7,8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
    log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d", args.A, args.B, reply)


    此外,还可以以异步方式进行调用,具体代码如下:
    quotient := new(Quotient)
    divCall := client.Go("Arith.Divide", args, &quotient, nil)
    replyCall := <-divCall.Done


    ---------------------------------
    package main


    import (
    "fmt"
    "log"
    "net"
    "net/http"
    "net/rpc"
    )


    type Echo int


    //被注册的对象至少要有一个方法满足下面这个特征,才会被导出到rpc服务接口
    func (t *Echo) Hi(args string, reply *string) error {
    *reply = "echo" + args
    return nil
    }


    func main() {
    //注册rpc服务,默认名字为对象的类型Echo,rpc.RegisterName指定特殊名字
    rpc.Register(new(Echo))
    //指定rpc的传输协议,这里用http作为rpc调用的载体。也可用rpc.ServeConn接口,定制自己的传输协议
    rpc.HandleHTTP()
    l, e := net.Listen("tcp", ":1234")
    if e != nil {
    log.Fatal("listen error:", err)
    }
    http.Serve(l, nil)
    }


    /*
    客户端的调用方式
    func main(){
    client,_:=rpc.DialHTTP("tcp", "127.0.0.1:1234")
    var args="hello rpc"
    var reply string
    client.Call("Echo.Hi", args, &reply)
    fmt.Printf("arith:%d*%d=%d\n", args.A,args.B,reply)
    }
    */


    ----------------------------------------
    type Watcher int


    func (w *Watcher) GetInfo(arg int, result *int) error {
    *result = 1
    return nil
    }


    func main() {


    http.HandleFunc("/login", Handler)


    watcher := new(Watcher)
    rpc.Register(watcher)
    rpc.HandleHTTP()


    l, err := net.Listen("tcp", ":1234")
    if err != nil {
    fmt.Println("监听失败,端口可能已经被占用")
    }
    fmt.Println("正在监听1234端口")
    http.Serve(l, nil)
    }


    func Handler(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "<html><body>传输的html文档</body></html>")
    }
    ---------------
    func main() {
    client, err := rpc.DialHTTP("tcp", "127.0.0.1:1234")
    if err != nil {
    fmt.Println("链接rpc服务器失败:", err)
    }
    var reply int
    err = client.Call("Watcher.GetInfo", 1, &reply)
    if err != nil {
    fmt.Println("调用远程服务失败", err)
    }
    fmt.Println("远程服务返回结果:", reply)
    }




    web服务器开发,处理客户端请求


    (1)表单
    在Javascript 中,页面上的每一对<form> 标记都解析为一个对象,即form 对象
    每个表单元素应当尽量使用<label>标签来提高用户体验;
    每个表单元素应当分配 name 属性  和 id 属性。
    name 属性:用来将数据提交到服务器;
    id 属性:用来在客户端做相应的操作;
    使用name属性更易获得元素值,更方便向服务器传数据


    html可以接受表单内容,但是接受了也只能是用JAVASCRIPT进行显示出来,无法保存在后台数据库里面。
    可以设置WEB服务器,把所有的.HTML文件都作为ASP或者PHP等脚本进行解释执行,这样别人看起来是个HTML,实际上里面却是ASP或者PHP。
    3中提交表单的方法:
    <form name=”form” method=”post” action=”#">
        <input type=”submit” name=”submit” value=”提交">
    </form>
    <input type=”image” name=”submit” src=”btnSubmit.jpg”>
    <a href=”javascript:form.submit();”>提交</a> 调用一个js函数来提交表单,可以加到任何一个标签的onclick事件中


    在form里设置enctype="multipart/form-data",这样才能在提交表单时,将文件以二进制流的形式传输到服务器
    enctype:设置或获取表单的多用途网际邮件扩展(MIME) 编码。
    这个属性的默认值为:application/x-www-form-urlencoded
    如果要上传文件,则应该设置为:multipart/form-data


    用submit提交按钮不会进行表单验证,
    <form οnsubmit="return(qbg()")>
    <input type="submit" value="提交"/>
    <input type="button" value="提交" οnclick="myFunction()"/>


    利用js创建一个表单
    1.get方式
    get方式提交的话,表单项都保存在http header中,格式是
    http://localhost:8080/hello.do?name1=value1&name2=value2这样的字符串。server端通过request.getParameter是可以取到值的。


    2.post方式(enctype为缺省的application/x-www-form-urlencoded)
    表单数据都保存在http的正文部分,格式类似于下面这样:用request.getParameter是可以取到数据的


    name1=value1&name2=value2


    3.post方式(enctype为multipart/form-data,多用于文件上传)
    表单数据都保存在http的正文部分,各个表单项之间用boundary隔开。格式类似于下面这样:用request.getParameter是取不到数据的,这时需要通过request.getInputStream来取数据


    html表单数据 ->  处理程序 ->数据库
    你访问显示数据的页面 -> 处理程序 ->查询数据库 ->反馈信息给你


    使用js提交数据(数据少集中的话用form表单,大量的数据或者比较分散用javascript来提交)


    纯html提交数据,分散在网页的各个地方,很难集中在一个form标签下
    javascript结合DOM(内置在浏览器中的对象模型)获得我们要上传的数据,将其组装在一个form中,再用post方式提交到服务器处理,
    有超链接形式,按钮形式


    function submit() {  
     var textValue = document.getElementById("id").value; //这里的id是文本输入框的id  
    //使用下面的方法进行页面跳转,页面跳转的时候可以带参数,所以就可以提交数据  
    window.location.href="result.jsp?text="+textValue;   
    //这里的地址可以是任意的地址,包括提交路径等! 


    package main


    import (
    "fmt"
    "io"
    "net/http"
    )


    func Handle(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "welcome to my server!")
    fmt.Println(r.Header)
    fmt.Println(r.UserAgent())
    fmt.Println(r.URL.RequestURI())
    r.ParseForm()
    val := r.FormValue("key")
    fmt.Println("key=", val)
    w.Write([]byte(val))
    }


    func Handle1(w http.ResponseWriter, r *http.Request) {
    r.ParseForm()
    val := r.FormValue("key")
    fmt.Println("key=", val)
    w.Write([]byte(val))
    }
    func Handle2(w http.ResponseWriter, r *http.Request) {
    _, err := r.MultipartReader()
    if err != nil {
    println("handle2 error=", err)
    return
    }
    val := r.FormValue("key")
    fmt.Println("key:=", val)
    w.Write([]byte(val))
    }
    func main() {
    http.HandleFunc("/one", Handle1)
    http.HandleFunc("/two", Handle2)
    fmt.Println("start...")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
    println("error:", err)
    }
    }




    提交表单,服务器接收数据
    ---index.html
    <body>
    <form id="uploadForm" method="post" enctype="multipart/form-data" action="/upload">
    <p>Golang upload</p>
    <input type="FILE" id="file" name="file" />
    <input type="SUBMIT" value="upload">
    </form>
    </body>


    ---main.go
    var uploadTemplate = template.Must(template.ParseFiles("index.html"))


    func indexHandle(w http.ResponseWriter, r *http.Request) {
    if err := uploadTemplate.Execute(w, nil); err != nil {
    log.Fatal("Execute: ", err.Error())
    return
    }
    }


    func uploadHandle(w http.ResponseWriter, r *http.Request) {
    file, _, err := r.FormFile("file")
    if err != nil {
    log.Fatal("FormFile: ", err.Error())
    return
    }
    defer func() {
    if err := file.Close(); err != nil {
    log.Fatal("Close: ", err.Error())
    return
    }
    }()


    bytes, err := ioutil.ReadAll(file)
    if err != nil {
    log.Fatal("ReadAll: ", err.Error())
    return
    }


    w.Write(bytes)
    }


    func main() {
    http.HandleFunc("/", indexHandle)
    http.HandleFunc("/upload", uploadHandle)
    http.ListenAndServe(":8080", nil)
    }


    -------------------
    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <title>服务器响应给客户端的html文件</title>
    <style type="text/css">
    body {margin:0px;background:#A29C9C;border:0px;padding:0px;font-size:15px;}
    .contain {width:1000px;margin:auto;}
    .header {width:1000px;height:70px;margin:0 auto;font-size:20px;text-align:center;background: #D0CDCD;line-height:70px;}
    .content {width:1000px;margin:5px,auto;text-align:center;font-size:18px;padding:5px;}
    </style>
    </head>
    <body>
    <div class="contain">
    <div class="header">
    <h1>服务器传输的网页</h1>
    </div>
    <div class="content">
    <form action="/upload" method="post" name="uploadForm">
    <label for="txt1">姓名:</label>
    <input type="text" id="txt1" name="myname" />
    <br />
    <label for="txt2">密码:</label>
    <input type="text" id="txt2" name="password">
    <br />
    <!--<input type="FILE" id="file" name="file" />-->
    <input type="button" value="提交" />
    </form>
    </div>
    </div>
    </body>
    </html>


    ----------
    func uploadHandle(w http.ResponseWriter, r *http.Request) {
    r.ParseForm()
    val1 := r.PostFormValue("post_data")
    val2 := r.PostFormValue("password")
    str := "姓名:" + val1 + "\n" + "密码:" + val2
    w.Write([]byte(str))
    //http.Redirect(w, r, urlStr, code)
    }


    --------js提交表单,禁用反复提交
    <form name="frm" method="post" action="javascript:alert('提交成功!');">
         <input type="button" value="提交功能" 
                οnclick="document.forms['frm'].submit();">
         <input type="button" value="禁用反复提交" 
                οnclick="this.disabled=true; this.form.submit();">
      </form>


    -------js创建一个表单
    var myForm = document.createElement("form"); 
    myForm.method="get" ; 
    myForm.action = "line_ticket.aspx" ; 
    var myInput = document.createElement("input") ; 
    myInput.setAttribute("name", "id") ; 
    myInput.setAttribute("value", idStr); 
    myForm.appendChild(myInput) ;
    var myInput2 = document.createElement("input") ; 
    myInput2.setAttribute("name", "fid") ; 
    myInput2.setAttribute("value", fid); 
    myForm.appendChild(myInput2) ;
    var myInput3 = document.createElement("input") ; 
    myInput3.setAttribute("name", "unlock") ; 
    myInput3.setAttribute("value", unlock); 
    myForm.appendChild(myInput3) ;
    var myInput4 = document.createElement("input") ; 
    myInput4.setAttribute("name", "Option") ; 
    myInput4.setAttribute("value", "del"); 
    myForm.appendChild(myInput4) ; 
    document.body.appendChild(myForm) ; 
    myForm.submit() ; 
    document.body.removeChild(myForm) ;


    ------js创建一个表单




    ----go对静态文件的处理,加载css、js文件
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
    目录结构
    main.go
    static---css(main.css)+js(main.js)
    view--index.html


    建立一个静态服务,才能访问静态文件,且模板文件不要和静态文件放在一起
    <!-- index.html -->
    <link rel="stylesheet" href="/static/css/main.css" type="text/css">
    <script type="text/javascript" src="/static/js/main.js"></script>




    func indexHandle(w http.ResponseWriter, r *http.Request) {
    t, _ := template.ParseFiles("view/index.html")
    if err := t.Execute(w, nil); err != nil {
    log.Fatal("Execute: ", err.Error())
    return
    }
    }


    func uploadHandle(w http.ResponseWriter, r *http.Request) {
    r.ParseForm()
    val1 := r.PostFormValue("myname")
    val2 := r.PostFormValue("password")
    str := "姓名:" + val1 + "\n" + "密码:" + val2
    w.Write([]byte(str))
    //http.Redirect(w, r, urlStr, code)
    }


    func main() {
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
    http.HandleFunc("/", indexHandle)
    http.HandleFunc("/upload", uploadHandle)
    http.ListenAndServe(":8080", nil)
    }
    --------部分js操作
    展开全文
  • 项目部署过程中发现含有富文本内容的form表单提交经常出现:连接已重置,或永久移动到其他网站异常, 异常信息为:net::ERR_CONNECTION_ABORTED,而且只有在这台Linux服务器上出现问题,本地和其他服务器均能正常...
  • //将服务器传来的数据赋值 $userId = $_POST['userId']; $userName = $_POST['userName']; $userAge = $_POST['userAge']; echo "学号:" .$userId. " "; echo "姓名:" .$userName. "<br
    <?php
        $userId   = $_POST['userId'];
        $userName = $_POST['userName'];
        $userAge  = $_POST['userAge'];
    
        echo "用户编号:" .$userId."<br/>";
        echo "用户姓名:" .$userName."<br/>";
        echo "用户年龄:" .$userAge."<br/>";
    
    //获取链接
     $url = "localhost";
     $user = "root";
     $password = "123456";
     //连接
     $con = mysql_connect($url,$user,$password);
     //设置编码机
     mysql_query("set names 'utf8'");
     mysql_select_db("test");
     $sql = "create table user_info (user_id int,user_name varchar(255),user_age varchar(255));";
     if (!mysql_query($sql,$con))
     {
       die('Error: ' . mysql_error());
     }
      $sql = "insert into user_info (user_id,user_name,user_age)  values('$userId','$userName','$userAge')";
     if (!mysql_query($sql,$con))
     {
       die('Error: ' . mysql_error());
     }
     echo "添加一条记录";
     mysql_close($con);
    ?>
    展开全文
  • HTML中表单用于向服务器提交信息,之前写动态页面的时候就已经用过,代码内容如下: &lt;form action="/input", method="post"&gt; {% csrf_token %} &lt;!--django有跨站请求...

    HTML中表单用于向服务器提交信息,之前写动态页面的时候就已经用过,代码内容如下:

        <form action="/input", method="post"> 
            {% csrf_token %}   <!--django有跨站请求保护机制要求必须添加此行 -->
            用户名:<input type="text" name="username"/><br/>
            密 码:<input type="password" name="password"/><br/>
            <input type="submit" value="提交">
        </form>
    

    action属性值为url,规定当提交表单时向何处发送表单数据
    method属性的值为get或者post,规定用于发送 form-data 的 HTTP 方法
    {% csrf_token %} django有跨站请求保护机制要求必须添加此行,原因未知,先用着再说

    标签用于换行
    标签用于用于输入数据,输入字段可以有多种形式(文本、复选框、按钮等)

    标签

    1、输入文本

    <html>
    <body>
    
    <form action="/example/html/form_action.asp" method="get">
    <input type="text" id="user-name" required 
    placeholder="姓名" name="name">
    <input type="submit" value="Submit" />
    </form>
    
    </body>
    </html>
    

    type 属性规定 input 元素的类型
    required 属性表示必填字段
    placeholder 输入提示信息,显示在文本框内
    name 属性输入的元素名称

    以上代码显示结果为:
    在这里插入图片描述

    2、单选按钮radio

    <form action="/example" method="get">
      <input type="radio" name="sex" value="male" /> 男<br />
      <input type="radio" name="sex" value="female" /> 女<br />
      <input type="submit" value="提交" />
    </form>
    

    运行结果
    在这里插入图片描述

    参考资料:
    http://www.w3school.com.cn/tags/att_input_type.asp
    http://www.w3school.com.cn/tags/tag_form.asp
    http://www.runoob.com/tags/tag-form.html

    展开全文
  • 防止表单提交按钮多次提交的办法

    万次阅读 2013-07-03 16:40:04
    防止表单提交按钮多次提交的办法 如果表单是通过onsubmit进行Ajax提交,注意将表单提交按钮input type属性设为button,尽量不要设置为submit类型。 另外,在提交事件发出后,最好将提交按钮设置为disabled,防止...
  • JSP页面显示乱码,表单提交中出现乱码,数据库连接乱 一、JSP页面显示乱码 下面的显示页面(display.jsp)就出现乱码: JSP的中文处理 out.print("JSP的中文处理"); %> 对不同的WEB服务器和不同...
  • 防止表单提交按钮多次提交的办法  如果表单是通过onsubmit进行Ajax提交,注意将表单提交按钮input type属性设为button,尽量不要设置为submit类型。 另外,在提交事件发出后,最好将提交按钮设置为disabled,防止...
  • Extjs-表单提交 表单验证 表单布局

    千次阅读 2012-08-16 13:54:34
    1.表单提交 1.1ext默认提交形式 因为FormPanel是布局容器,没有提供submit()函数,所以要先获取它内部包含的BasicForm,才能提交 这个示例中,后台接收数据的脚本是list.jsp,与以前方式相同,唯一的区别就是不再跳转,...
  • 表单提交的几种方式

    万次阅读 2017-08-14 15:31:34
    一、Form和提交 ...method : 表单提交方式,默认为get,可选值为get/post enctype : 规定在向服务器发送表单数据之前如何对其进行编码。(适用于 method="post" 的情况), 可取值为application/x-www-form-
  • form表单提交

    万次阅读 2019-04-03 19:57:35
    开发工具与关键技术:MVC JQuery 的 form表单提交 作者:沈金凤 年级:18级(5)班 撰写日期:2019年4月2日 一、Form表单有两个属性分别是:“action”和“method”: Action: 的值是URL 就是当提交表单时向...
  • ...lt;form&gt;标签对中的&lt;input type='submit'&gt;提交按钮进行请求发送和参数提交。其中form标签的post属性决定提交方式是get还是post。...//action后面的就是表单提交后的位置,这...
  • from 表单提交

    万次阅读 2013-12-10 21:47:59
    因为是转载文章 在此标明出处,以前有文章是转的没标明的请谅解,因为有些已经无法找到出处,或者与其它原因。 如有冒犯请联系本人,或删除,或标明出处。 因为好的文章,以前只想收藏,但连接有时候会失效,...
  • Java+MyEclipse+Tomcat (二)配置Servlet及简单实现表单提交

    万次阅读 多人点赞 2015-05-07 04:42:12
    本文主要讲述MyEclipse和Tomcat配置Servlet的过程和简单实现表单提交功能。希望对大家有所帮助。一. Servlet编程 1.Web基础知识 2.什么是Servlet 二. 配置Servlet 1.Servlet声明 2.Servlet映射 三. 简单实现表单提交...
  • 跨域提交表单攻击

    千次阅读 2014-08-29 11:28:33
    原理:对于大多数服务器,html表单可以向任何服务器的任何url地址提交,攻击者可以利用此点向本来不需要处理表单的页面采用post方式提交表单,或者向处理表单的页面采用post方式提交表单,以此来消耗服务器的...
  • php表单提交之后再后退,表单的内容默认是被清空的(使用session_start的时候),  解决方法是在session_start() 之后,字符输出之前写上  复制代码代码如下: header("Cache-control: private");  ...
  • 表单提交中文乱码的问题

    千次阅读 2011-05-10 16:40:00
    做项目的时候一个成员提交表单后成了乱码,看了以后原来是提交方式的问题:项目本身是采用了SSH2的架构,我一直习惯于采用Struts2的标签,而他采用了普通标签,struts2的Form标签默认提交方式是Post,而普通标签提交...
  • Form表单提交数据的乱码问题

    千次阅读 2017-11-18 20:29:24
    面对多种编码方式,一旦处理不好或者稍有不慎,乱码问题就层出不穷,乱码...下面,主要说一下如何解决Form表单提交数据出现的乱码问题 Form表单以Post方式提交数据 浏览器将数据(假设为“中国”)发送给服务器的时候
  • JSP怎么将表单提交到对应的servlet

    万次阅读 2014-02-23 11:32:54
    JSP怎么将表单提交到对应的servlet,以及其中的配置信息。
  • HttpClient 支持多种访问网络的方式,主要介绍get基本请求 post表单提交,以及文件的长传操作!
  • java 模拟html表单(form)提交数据 包含多文件 上传 表单提交 for j2me j2se android
  • Get和POST表单提交方式详解

    千次阅读 2015-07-28 18:43:00
    1、Get是用来从服务器上获得数据,而Post是用来向服务器上传递数据。 2、Get将表单中数据的按照variable=value的形式,添加到action所指向的URL后面,并且两者使用“?”连接,而各个变量之间使用“&”连接;Post是将...
  • 提交表单 用AFNetWorking

    千次阅读 2015-07-06 18:13:19
    直接上代码:这里//向服务器上传数据 -(void)importDate:(UIButton *)button { NSDictionary *dic = [NSDictionary dictionaryWithObjectsAndKeys:_count,@"count",_productId,@"Id", nil]; ...
  • Laravel学习记录--表单提交方法伪造

    千次阅读 2020-02-01 11:40:25
    有时候我们需要定义发送表单所使用的HTTP请求方式,但HTML表单只支持GET和POST两种提交方法,如果要使用其他的请求方式,需要我们自定义 常见HTTP请求 OPTIONS:允许客户端查看服务器的性能。这个方法会请求服务器...
  • java 代码post表单数据到服务器,servlet接收处理
  • 表单提交中get和post方式的区别

    千次阅读 2016-05-24 11:39:04
    表单提交中get和post方式的区别有5点  1.get是从服务器上获取数据,post是向服务器传送数据。  2.get是把参数数据队列加到提交表单的ACTION属性所指的URL中,值和表单内各个字段一一对应,在URL中可以看到。post是...
  • 1.前言 ...虽然这些协议使用广泛,但是使用这些协议需要在服务器侧专门做一个复杂的解析程序,之后再把数据搬入数据库,这便带来了升级或修改的风险。如果可以使用现有的HTTP 表单手段或JSON+RESTFUL
  • 表单提交与接收

    千次阅读 2019-06-10 07:58:16
    表单提交与接收 …………………………………………………………………………………………………………… 开发工具与关键技术:Visual Studio 2015 C# 作者:林敏静 撰写时间:2019年6月7日 …………………………...
  • 1. ajax表单提交服务器 2. 服务器返回一个固定格式json结构 3. js会调函数根据这个json数据做相应的处理 注意: DWZ框架默认的ajax表单提交都是返回json数据,告诉客户端操作是否成功,成功或失败提示信息...
  • jquery表单防重复提交

    千次阅读 2016-07-08 13:00:29
    网站中防止表单重复提交是一个比较普遍的需求,解决办法很多种 有利用session和cookie即生成个一次性token放在表单隐藏域防重复提交 有利用js设置变量锁定 这里以设置表单失效来实现 注册 ....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,645
精华内容 39,858
关键字:

表单提交无法连接服务器