精华内容
下载资源
问答
  • package com.translate.http; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServ...

    第一:客户端测试类:

    package com.translate.http;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class HttpTest extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("访问服务器2!");
            //调用发送post请求的类
            HttpPostClient hpc = new HttpPostClient();
            //HttpSendParam hsp = new HttpSendParam();
            hpc.sendHttpPost("http://localhost:8010/TranslateHttpServlet/httpRes","测试.doc","测试2.pdf","G:\\test");
    //        try {
    //            //hsp.HttpClientGet();
    //            hsp.HttpClientPost();
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    
    //        SendPostToPlatform sptp = new SendPostToPlatform();
    //        sptp.sendPost();
    
    
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    }
    

     

    第二:创建客户端发送post请求的类

    package com.translate.http;
    
    import jdk.internal.util.xml.impl.Input;
    import org.apache.http.Header;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.HttpStatus;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.ContentType;
    
    import org.apache.http.entity.mime.HttpMultipartMode;
    import org.apache.http.entity.mime.MultipartEntity;
    import org.apache.http.entity.mime.MultipartEntityBuilder;
    import org.apache.http.entity.mime.content.FileBody;
    import org.apache.http.entity.mime.content.StringBody;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.params.CoreConnectionPNames;
    import org.apache.http.util.EntityUtils;
    
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.URLDecoder;
    import java.nio.charset.Charset;
    
    //Http 客户端
    public class HttpPostClient {
    
        public void sendHttpPost(String url,String filename1,String filename2,String filepath){
            //创建HttpClient对象
            //HttpClient httpclient = new DefaultHttpClient();
            CloseableHttpClient httpclient = HttpClients.createDefault();
    
            try{
                //设置各种超时时间
                RequestConfig requestConfig = RequestConfig.custom()
                        .setConnectTimeout(5000).setConnectionRequestTimeout(1000)
                        .setSocketTimeout(5000).build();
    
                //创建post请求对象
                    HttpPost httpPost = new HttpPost(url);
                    httpPost.setConfig(requestConfig);
                    //处理文件参数
                    FileBody bin = new FileBody(new File(filepath+File.separator+filename1));
                    FileBody bin2 = new FileBody(new File(filepath + File.separator + filename2));
                    //传递普通参数
                    //StringBody comment = new StringBody("测试");
                    String comment = "测试";
                    //创建上传文件以及参数的表单
                    MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
                    //处理文件名乱码
                    entityBuilder.setCharset(Charset.forName("utf-8"));
                    entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
                //设置字符串编码
                    ContentType strContent= ContentType.create("text/plain", Charset.forName("UTF-8"));
                    entityBuilder.addTextBody("test",comment,strContent);//添加普通参数
                    entityBuilder.addTextBody("test2","测试2",strContent);//添加普通参数
                    entityBuilder.addPart("fileName1",bin);//添加上传的文件
                    entityBuilder.addPart("fileName2",bin2);//添加上传的文件
                    HttpEntity httpEntity = entityBuilder.build();
    //                MultipartEntity reqEntity = new MultipartEntity();
    //                reqEntity.addPart("file1", bin);//file1为请求后台的File upload;属性
    //                reqEntity.addPart("file2", bin2);//file2为请求后台的File upload;属性
    //                reqEntity.addPart("filename1", comment);//filename1为请求后台的普通参数;属性	upload
    
                    httpPost.setEntity(httpEntity);
                    //发起连接,并处理响应结果
                    HttpResponse response = httpclient.execute(httpPost);
    
                   //获取头部信息
                   Header[] headerArray = (Header[]) response.getAllHeaders();
                   for(Header header : headerArray){
                       System.out.println("--Header-----------------------------------------");
                       System.out.println("----Key: " + header.getName());
                       if(header.getName().equals("Content-Disposition")){
                           //对中文进行utf-8转码
                            String encodeStr = header.getValue();
                           System.out.println("----RawValue: " + URLDecoder.decode(encodeStr, "utf-8"));
                       }else{
                           System.out.println("----RawValue: " + URLDecoder.decode(header.getValue(),"utf-8"));
                       }
    
                   }
    
    
                    //获取响应状态码
                    int statusCode = response.getStatusLine().getStatusCode();
                     if(statusCode == HttpStatus.SC_OK){
                         System.out.println("服务器响应正常!");
                         //获取响应体
                         HttpEntity resEntity = response.getEntity();
    
                         //System.out.println(resEntity.getContentType().getElements()[0].getName());
                         //获取返回值的类型
                         String contentType = resEntity.getContentType().getElements()[0].getName();
                         System.out.println(contentType);
                         if(contentType.equals("text/javascript")){
                             String content = EntityUtils.toString(resEntity);
                             System.out.println(content);//httpclient自带的工具类读取返回数据
                         }else if(contentType.equals("application/octet-stream")){
                             //处理文件流
                             InputStream in = resEntity.getContent();
                             //接受文件,存放到本地
                             File file = new File(filepath,"哈哈.doc");
                             FileOutputStream fos = new FileOutputStream(file);
                             int len = -1;
                             byte [] arr = new byte[1024];
                             while((len=in.read(arr))!=-1){
                                 fos.write(arr,0,len);
                             }
                             fos.flush();
                             fos.close();
    
    
    
    
                         }
    
                         //System.out.println(resEntity.getContent());
                         //关闭应该关闭的资源,适当的释放资源
                         EntityUtils.consume(resEntity);
    
    
                     }else{
                         System.out.println("服务器响应不正常!");
                     }
    
    
    
    
    
    
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    //关闭连接
                    httpclient.getConnectionManager().shutdown();
                } catch (Exception ignore) {
    
                }
            }
    
    
    
    
    
    
        }
    }
    

    第三:服务器端接受post请求,并返回一个文件流

    package com.translate.http;
    
    import org.apache.commons.fileupload.FileItem;
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;
    import org.apache.commons.io.FileUtils;
    //import org.omg.CORBA.portable.InputStream;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.*;
    import java.net.URLEncoder;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.UUID;
    
    public class HttpResponseService extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            System.out.println("开始访问服务器");
    
            //放信息
            Map map = new HashMap();
    
            String sysFileSeparator = File.separator;
            //获取操作系统缓存的临时目录
            String sysTemporyPath = System.getProperty("java.io.tmpdir");
            System.out.println("临时文件夹" + sysTemporyPath);
            String temporyPath = sysTemporyPath + sysFileSeparator + getUUID();
            File tempory = new File(temporyPath);
            if(!tempory.exists()){
                tempory.mkdir();
            }
            DiskFileItemFactory factory = new DiskFileItemFactory();
            factory.setSizeThreshold(1024 * 1024);//设置创建缓冲大小
            //当文件大小大于缓冲区就存于临时文件夹
            factory.setRepository(new File(sysTemporyPath));
            ServletFileUpload upload = new ServletFileUpload(factory);
            //设置处理客户端请求的编码
            upload.setHeaderEncoding("utf-8");
            upload.setSizeMax(-1);//设置上传文件限制大小,-1无上限
    
            try{
                List<FileItem> items = upload.parseRequest(req);
    
                //遍历参数
                for(FileItem item:items){
    
                    //参数名
                    String pName = "";
                    //参数值(字符串或者文件流)
                    Object pValue = "";
                    //判断是文件流还是普通参数
                    if(item.isFormField()){
                        //处理普通参数
                        pName = item.getFieldName();
                        System.out.println("变量名"+pName);
                        //获取字符串并以utf-8编码
                        pValue = item.getString("UTF-8");
                        System.out.println("变量值"+pValue);
                        map.put(pName,pValue);
    
    
                    }else{
                        pName = item.getFieldName();
                        System.out.println(pName);
                        //pValue = item.getInputStream();
                        map.put(pName,item.getName());
                        System.out.println("文件名"+item.getName());
                        //获取到上传文件的具体路径名
                        String name = item.getName();
                        if(name != null && !("".equals(name))) {
                            name = name.substring(name.lastIndexOf(File.separator) + 1);
                            File uploadFile = new File(temporyPath,name);
                            FileOutputStream fos = new FileOutputStream(uploadFile);
                            try{
                                //获取输入流
                                InputStream in = (InputStream) item.getInputStream();
    
                                byte [] arr = new byte[1024];
                                int count = -1;
                                while ((count=in.read(arr))!=-1){
                                    fos.write(arr,0,count);
                                }
                            }catch (Exception e){
                                e.printStackTrace();
                            }finally {
                                fos.flush();
                                fos.close();
                            }
    
    
    
                        }
    
                    }
                }
            }catch(Exception e){
                e.printStackTrace();
                System.out.println("服务器解析数据发生错误");
            }
            //响应JSON字符串
            //resp.setContentType("text/javascript;charset=UTF-8");
            resp.setCharacterEncoding("UTF-8");
    //        PrintWriter out = resp.getWriter();
    //        String str ="{\"姓名\":\"HaHa先生\",\"年龄\":\"18岁啦\"}";
    //        out.println(str);
    //        out.flush();
    //        out.close();
            //文件流
            resp.setContentType("application/octet-stream");
            String fileName = "测试.doc";
            //URLEncoder.encode(fileName,"utf8")
            //resp.setHeader("Content-Disposition", "attachment; filename=" + java.net.URLEncoder.encode(fileName, "UTF-8"));
            resp.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fileName,"UTF-8"));
            resp.setHeader("FileName", URLEncoder.encode(fileName, "UTF-8"));
            FileInputStream in = new FileInputStream("G:\\test\\wordtemp.doc");
            int len = -1;
            OutputStream out = resp.getOutputStream();
            byte [] arr = new byte[1024];
            while ((len=in.read(arr))!=-1){
                out.write(arr,0,len);
            }
            out.flush();
            out.close();
            in.close();
    
    
    
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doGet(req,resp);
        }
    
        public String getUUID() {
            return UUID.randomUUID().toString().replaceAll("-", "");
        }
    }
    

     

    展开全文
  • 今天简单介绍一下如何用Java支持HTTP Multipart的request和response。... 在这个程序里,我们的业务场景很简单。在服务端有一个随机数生成器,可以生成...同时,客户端可以向服务端发送一个或多个随机数,这些随机数会...

    今天简单介绍一下如何用Java支持HTTP Multipart的request和response。 整个项目的代码可以在https://github.com/mcai4gl2/multi下载。

    在这个程序里,我们的业务场景很简单。在服务端有一个随机数生成器,可以生成随机的Integer和Guid,客户端通过服务,可以请求一个或多个随机数。同时,客户端可以向服务端发送一个或多个随机数,这些随机数会被加入到一个队列中,被其他的客户端通过请求获得。以下是我们的随机数Bean的定义:

     

    [java] view plaincopy
     
    1. public class RandNumber {  
    2.     private String uuid;  
    3.     private Integer number;  
    4.   
    5.     public String getUuid() {  
    6.         return uuid;  
    7.     }  
    8.   
    9.     public void setUuid(String uuid) {  
    10.         this.uuid = uuid;  
    11.     }  
    12.   
    13.     public Integer getNumber() {  
    14.         return number;  
    15.     }  
    16.   
    17.     public void setNumber(Integer number) {  
    18.         this.number = number;  
    19.     }  
    20.   
    21.     @Override  
    22.     public String toString() {  
    23.         return number + " " + uuid;  
    24.     }  
    25.   
    26.     public static class Builder {  
    27.         private RandNumber number;  
    28.   
    29.         public Builder() {  
    30.             number = new RandNumber();  
    31.         }  
    32.   
    33.         public Builder randomlyGenerate() {  
    34.             Random random = new Random();  
    35.             number.setNumber(random.nextInt(100));  
    36.             number.setUuid(UUID.randomUUID().toString());  
    37.             return this;  
    38.         }  
    39.   
    40.         public Builder withNumber(int num) {  
    41.             number.setNumber(num);  
    42.             return this;  
    43.         }  
    44.   
    45.         public Builder withUuid(String uuid) {  
    46.             number.setUuid(uuid);  
    47.             return this;  
    48.         }  
    49.   
    50.         public RandNumber build() {  
    51.             return number;  
    52.         }  
    53.     }  
    54. }  

    在这个类中,我们除了定义类的基本信息,还添加了一个Builder类。通过这个Builder类,我们可以很方便的生成RandNumber类。Builder类在我们的数据类的Constructor很复杂的时候,非常有用,可以使我们的代码更具可读性。

     

    有了这个简单的数据类,我们继续定义一个简单的业务类RandomNumberGenerator,它继承了IRandomNumberGenerator接口:

     

    [java] view plaincopy
     
    1. public interface IRandomNumberGenerator {  
    2.     RandNumber getRandomNumber();  
    3.     RandNumber[] getRandomNumbers(int num);  
    4.     void submitRandomNumber(RandNumber randNumber);  
    5.     void submitRandomNumbers(RandNumber[] randNumbers);  
    6. }  

    同时,我们还定义了一个RandomNumberSerializer类,它可以对我们的数据类进行JSON Serialization操作,我们的服务端和客户端都将使用它进行通信:

     

    [java] view plaincopy
     
    1. public interface IRandomNumberSerializer {  
    2.     String serializeRandomNumber(RandNumber number);  
    3.     RandNumber deserializeRandomNumber(String input);  
    4.     void serializeRandomNumber(RandNumber number, OutputStream stream);  
    5.     RandNumber deserializeRandomNumber(InputStream stream);  
    6.     String getContentType();  
    7. }  

     

    RandomNumberSerializer内部使用了Gson包来进行序列化操作。在上面的接口中,我们提供了对String和Stream的两种方法,这样,当我们进行HTTP通信的时候,我们可以直接对Network Stream进行操作。

    有了上面的这些类,我们的Servlet服务端代码就很简单了:

     

    [java] view plaincopy
     
    1. @Controller  
    2. public class MultiPartRequestServlet {  
    3.   
    4.     private static Logger log = Logger.getLogger(MultiPartRequestServlet.class);  
    5.   
    6.     @Autowired  
    7.     private IRandomNumberSerializer randomNumberSerializer;  
    8.     @Autowired  
    9.     private IRandomNumberGenerator randomNumberGenerator;  
    10.   
    11.     @RequestMapping(value="/get-multi", method = RequestMethod.GET)  
    12.     public void getMultiple(  
    13.             @RequestHeader("MAX_NUM_NUMS") int maxCount,  
    14.             HttpServletRequest request,  
    15.             HttpServletResponse response,  
    16.             ServletOutputStream outputStream) throws Exception {  
    17.         log.info("multi part get is called");  
    18.         response.setStatus(HttpServletResponse.SC_OK);  
    19.         String boundary = UUID.randomUUID().toString();  
    20.         response.setContentType("multipart/x-mixed-replace;boundary=" + boundary);  
    21.   
    22.         RandNumber[] numbers = randomNumberGenerator.getRandomNumbers(maxCount);  
    23.   
    24.         for (int index = 0; index < maxCount; index++) {  
    25.             outputStream.println("--" + boundary);  
    26.             outputStream.println("Content-Type: " + randomNumberSerializer.getContentType());  
    27.             outputStream.println();  
    28.   
    29.             outputStream.println(randomNumberSerializer.serializeRandomNumber(numbers[index]));  
    30.   
    31.             outputStream.println();  
    32.         }  
    33.         outputStream.println("--" + boundary + "--");  
    34.         outputStream.flush();  
    35.         outputStream.close();  
    36.     }  
    37.   
    38.     @RequestMapping(value="/submit-multi", method = RequestMethod.POST)  
    39.     public void submitMultiple(HttpServletRequest request, HttpServletResponse response) throws Exception {  
    40.         log.info("multi part submit is called");  
    41.         if (!request.getContentType().startsWith("multipart/form-data")) {  
    42.             response.setStatus(HttpServletResponse.SC_BAD_REQUEST);  
    43.         } else {  
    44.             request.setAttribute("org.eclipse.multipartConfig",  
    45.                     new MultipartConfigElement(System.getProperty("java.io.tmpdir")));  
    46.             Collection<Part> parts = request.getParts();  
    47.             for (Part part : parts) {  
    48.                 RandNumber number = randomNumberSerializer.deserializeRandomNumber(part.getInputStream());  
    49.                 randomNumberGenerator.submitRandomNumber(number);  
    50.             }  
    51.             response.setStatus(HttpServletResponse.SC_OK);  
    52.         }  
    53.     }  
    54.   
    55.     @RequestMapping(value="/get-one", method = RequestMethod.GET)  
    56.     public void getOne(HttpServletRequest request, HttpServletResponse response, OutputStream outputStream) throws Exception {  
    57.         log.info("get is called");  
    58.         RandNumber number = randomNumberGenerator.getRandomNumber();  
    59.         response.setStatus(HttpServletResponse.SC_OK);  
    60.         response.setContentType(randomNumberSerializer.getContentType());  
    61.         randomNumberSerializer.serializeRandomNumber(number, outputStream);  
    62.         outputStream.flush();  
    63.         outputStream.close();  
    64.     }  
    65.   
    66.     @RequestMapping(value="/submit-one", method = RequestMethod.POST)  
    67.     public void submitOne(HttpServletRequest request, HttpServletResponse response) throws Exception {  
    68.         log.info("submit is called");  
    69.         RandNumber number = randomNumberSerializer.deserializeRandomNumber(request.getInputStream());  
    70.         randomNumberGenerator.submitRandomNumber(number);  
    71.         response.setStatus(HttpServletResponse.SC_OK);  
    72.     }  
    73. }  

    在上面的代码中,getOne和submitOne很简单,这里我们主要讨论getMultiple和submitMultiple。在getMultiple中,我们直接操作outputStream来实现Multipart协议。而在submitMultiple中,我们则通过Servlet 3.0的getParts方法来直接获得每一个Part。需要注意的是,getParts是在Servlet 3.0中才新添加的方法,在我们部署服务的时候,我们要部署在支持Servlet 3.0的container里(在这里我对Tomcat7和Jetty8进行了测试)。同时,我们在调用getParts之前,我们对request添加了一个attribute,这个attribute只在部署在Jetty时需要。

     


    下面的代码是一个简单的getMultiple的客户端,在这段代码中,我们使用Apache HttpClient来进行HTTP,我们使用了java mail中的MimeMultipart来处理服务端的repsonse。

     

    [java] view plaincopy
     
    1. @Override  
    2.     public RandNumber[] getRandomNumbers(int num) {  
    3.         HttpGet httpGet = new HttpGet(getMultipleUrl);  
    4.         httpGet.setHeader("MAX_NUM_NUMS", Integer.toString(num));  
    5.         try {  
    6.             HttpResponse httpResponse = httpClient.execute(httpGet);  
    7.   
    8.             if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {  
    9.                 ByteArrayDataSource source = new ByteArrayDataSource(httpResponse.getEntity().getContent(),  
    10.                         "multipart/mixed");  
    11.                 MimeMultipart multipart = new MimeMultipart(source);  
    12.   
    13.                 List<RandNumber> numbers = new ArrayList<RandNumber>();  
    14.   
    15.                 for (int index = 0; index < multipart.getCount(); index++) {  
    16.                     numbers.add(randomNumberSerializer.deserializeRandomNumber(multipart.getBodyPart(index).getInputStream()));  
    17.                 }  
    18.                 return numbers.toArray(new RandNumber[numbers.size()]);  
    19.             } else {  
    20.                 HttpEntity httpDataEntity = httpResponse.getEntity();  
    21.                 EntityUtils.consumeQuietly(httpDataEntity);  
    22.                 return null;  
    23.             }  
    24.         } catch (Exception ex) {  
    25.             log.error("Failed to get multiple random numbers", ex);  
    26.             return null;  
    27.         }  
    28.     }  


    除了代码,我还添加了Maven打包配置和发布到local tomcat的脚本。整个Maven项目会被打包成两个文件,一个JAR和一个WAR。JAR打包包含了一个Jetty的服务端程序入口,和一个SampleClient的程序入口。而另一个WAR包可以直接发布到Tomcat上进行调试。这些都是为了我们可以更方便的在本地进行代码调试,在tomcat的启动脚本中,我还打开了JPDA端口,这样我们可以通过IDE对部署在Tomcat上的服务端进行调试。

     

    这些基本的配置,可以大大提高我们编程调试的效率。这也是我写这篇文章的另一个原因。希望这些配置,可以帮到有需要的朋友。

    原文:http://blog.csdn.net/mcai4gl2/article/details/12354945 

     相关文章:http://www.360doc.com/content/11/0809/16/1073512_139171830.shtml

    转载于:https://www.cnblogs.com/langtianya/p/4005520.html

    展开全文
  • 点击打开链接http://blog.chinaunix.net/space.php?uid=16981447&do=blog&id=2839861 注:该实例针对多个客户端同时服务器端发送请求,服务器分别同时执行相应的服务。

     点击打开链接http://blog.chinaunix.net/space.php?uid=16981447&do=blog&id=2839861

    注:该实例针对多个客户端同时向服务器端发送请求,服务器分别同时执行相应的服务。

    展开全文
  • Jmeter之HTTP请求详解

    2021-04-26 16:48:34
    个http请求指从客户端到服务端的请求消息,我们可以通过浏览器的F12键,可以看到以下信息: 请求地址:url 请求方法:HEAD、GET、POST、PUT、OPTIONS、DELETE、PATCH HTTP定义了很于服务器交互的方法: GET ...

    一、 HTTP request详解

        客户端发送的HTTP请求到Web服务器时,请求消息主要包含:

    • 请求行
    • 请求头
    • 请求体(请求报文/请求参数)
      在这里插入图片描述

    1.1 请求行

        请求行用于说明请求类型,以及要访问的资源和使用的HTTP版本。

        请求行包含以下内容:

    • 请求方法: HEAD、GET、POST、PUT、OPTIONS、DELETE、PATCH

    HTTP定义了很多于服务器交互的方法:

    • GET 请求指定的页面信息,并返回实体主体
    • POST 向指定资源提交数据进行处理请求(例如提交表单或者上传文件)。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。
    • PUT 向Web服务器发送数据,并存储在Web服务器内部
    • HEAD 检查一个对象是否存在
      DELETE 从Web服务器上删除一个文件
    • CONNECT 对通道提供支持
    • TRACE 跟踪到服务器的路径
    • OPTIONS 查询Web服务器的性能
    • 请求地址
    • HTTP协议/版本

    1.2 请求头 headers

        请求头headers用于指定服务器要使用的附加信息
    在这里插入图片描述

    • Accept:指定客户端能够接收的内容类型,如:Accept: text/plain, text/html
          类型中的先后次序表示客户端接收的先后顺序

    • Accept-Charset:浏览器可以接受的字符编码集。

    • Accept-Encoding:指定浏览器可以支持的web服务器返回内容压缩编码类型。
          ;Accept-Encoding允许Web服务器将输出内容发回客户端之前进行压缩,以节约带宽。这里设置的就是客户端浏览器所能够支持的压缩格式。
          简单来说,就是Web服务器在给客户端返回页面数据之前,将数据以gzip格式进行压缩,也节省带宽,加快传输。

    说明:

    • gzip 是GNU zip的缩写,是GNU自由软件的文件压缩程序,也用来表示gzip文件格式。
    • deflate 使用LZ77算法于哈夫曼编码(Huffman Coding)的一种无损压缩算法
    • Accept-Language:浏览器可接受的语言

    说明:

    • zh-cn表示简体中文
    • zh 表示中文
    • q 表示权重系数,范围0~1,q值越大请求越倾向于获取;之前的类型所表示的内容,若没有指定q值则默认为1。若q值为0则用于提醒服务器哪些是浏览器不接受的内容类型。
    • Accept-Ranges:可以请求网页实体的一个或者多个子范围字段
    • Authorization:HTTP授权的授权证书
    • Cache-Control:指定请求和响应遵循的缓存机制
    • Connection:表示是否需要持久连接。如果Web服务器接收到Connection的属性值为Keep-Alive,或者请求所使用的协议版本是HTTP 1.1(默认持久连接),此时就会采用持久连接。

    用法:

    • Connection: keep-alive
      当一个Web页面打开时,客户端和Web服务器之间用于传输HTTP数据库的TCP连接不会关闭,如果客户端再次访问Web服务器上的网页,会继续使用这条已经建立的连接。
    • Connection: close
      close表示一个Requset请求完成后,客户端和Web服务器之间用于传输HTTP数据的TCP连接会关闭,当客户端再次发送Request请求时,需要重新建立TCP连接。
    • Cookie:HTTP请求发送时,会把保存在该请求域名下的所有cookie值一起发送给web服务器。
    • Content-Length:请求的内容长度,单位字节(byte),并不包含请求行和请求头的数据长度。
    • Content-Type:请求的与实体对应的MIME信息,只有在POST方法提交时才需要设置此属性。

    当使用POST方式提交数据时,Content-Type属性值支持两种编码类型:
        1. application/x-www-form-urlencode
            默认缺省的编码类型,表单向Web服务器提交数据时所采用的编码类型。
            当向Web服务器发送大量文本、包含非ASCII字符的文本、二进制数据时采用这种编码方式效率很低。
        2. multipart/form-data
            文件上传时所使用的编码类型,它既可以发送文本数据,也支持二进制数据上传。
            在Content-Type属性中还可以指定提交内容的Charset字符编码

    • Date:请求发送的日期和时间
    • Expect:请求的特定的服务器行为
    • Host:指定请求的服务器的域名和端口号
    • Pragma:用来包含实现特定的指令
    • Proxy-Authorization:连接到代理的授权证书
    • Range:只请求实体的一部分,指定范围
    • Referer:先前网页的地址,当前请求网页紧随其后,即来路
    • User-Agent:User-Agent的内容包含发出请求的用户信息

    二、HTTP response详解

    一个http response(http响应)指的是从服务端到客户端的响应消息,它包括了以下信息:

    • 响应行
    • 响应头
    • 响应体(响应报文)
      在这里插入图片描述
      在这里插入图片描述

    2.1 响应行

    • 报文协议及版本
      如:HTTP/1.1 200 OK
    • 状态码及状态描述
    • 1xx: 信息,服务器收到请求,需要请求者继续执行操作
    • 2xx: 成功,操作被成功接收并处理
          200 OK:请求成功。 服务器已成功处理了请求。一般用于GET与POST请求
          204 No Content:无内容。服务器成功处理,但未返回内容。在未更新网页的情况下,可确保浏览器继续显示当前文档。一般用在只是客户端向服务器发送信息,而服务器不用向客户端返回什么信息的情况。不会刷新页面。
          206 Partial Content:部分内容。服务器成功处理了部分GET请求。响应报文中包含Content-Range指定范围的实体内容
    • 3xx: 重定向,需要进一步的操作以完成请求
          301 Moved Permanently:永久移动。资源(网页等)被永久转移到其它URL。服务器返回此响应(对GET或HEAD请求的响应)时,会自动将请求者转到新位置。
           302 Found:临时移动。 资源只是临时被移动,请求者应继续使用原有位置来进行以后的请求。
          303 See Other:临时重定向,应使用GET定向获取请求资源。303功能与302一样,区别只是303明确客户端应该使用GET访问。
          304 Not Modified:未修改。 所请求的资源未修改,服务器返回此状态码时,不会返回任何资源。客户端通常会缓存访问过的资源,通过提供一个头信息指出客户端希望只返回在指定日期之后修改的资源。
          305 Use Proxy:使用代理。所请求的资源必须通过代理访问
          307 Temporary Redirect:临时重定向。服务器目前从不同位置的网页响应请求,但请求者应继续使用原有位置来进行以后的请求。
    • 4xx: 客户端错误,请求包含语法错误或无法完成请求
          400 Bad Request: 客户端请求的语法错误,服务器无法理解
          401 Unauthorized: 请求要求用户的身份认证,这个状态代码必须和WWW-Authenticate报头域一起使用。
          403 Forbidden: 服务器理解请求客户端的请求,但是拒绝执行此请求
          404 Not Found: 服务器无法根据客户端的请求找到资源(网页)
          415 Unsupported media type:服务器无法处理请求附带的媒体格式
    • 5xx: 服务器错误,服务器在处理请求的过程中发生了错误
          500 Internal Server Error: 服务器内部错误,无法完成请求
          502 Bad Gateway: 网关错误。充当网关或代理的服务器,从远端服务器接收到了一个无效的请求
           503 Server Unavailable:由于超载或系统维护,服务器暂时的无法处理客户端的请求。延时的长度可包含在服务器的Retry-After头信息中

         505 HTTP Version not supported: 服务器不支持请求的HTTP协议的版本,无法完成处理

    HTTP状态码大全

    2.2 响应头

    • Accept-Ranges:表明服务器是否支持指定范围请求及哪种类型的分段请求
    • Age:从原始服务器到代理缓存形成的估算时间(以秒计,非负)
    • Allow:对某网络资源的有效的请求行为,不允许则返回405
    • Cache-Control:告诉所有的缓存机制是否可以缓存及哪种类型,常见的取值有常见的取值有private、public、no-cache、max-age,no-store,默认为private。
    • Content-Encoding:web服务器支持的返回内容压缩编码类型
    • Content-Language:响应体的语言
    • Content-Length:响应体的长度
    • Content-Location:请求资源可替代的备用的另一地址
    • Content-Range:在整个返回体中本部分的字节位置
    • Content-Type:返回内容的MIME类型
    • Date:原始服务器消息发出的时间
    • Expires:响应过期的日期和时间
    • Location:用来重定向接收方到非请求URL的位置来完成请求或标识新的资源,需要与状态码302配合使用,完成跳转。
    • Pragma:包括实现特定的指令,它可应用到响应链上的任何接收方
    • Proxy-Authenticate:它指出认证方案和可应用到代理的该URL上的参数
    • Server:web服务器软件名称
    • Set-Cookie:设置Http Cookie
    • Transfer-Encoding:文件传输编码
    • Vary:告诉下游代理是使用缓存响应还是从原始服务器请求
    • Via:告知代理客户端响应是通过哪里发送的
    • WWW-Authenticate:表明客户端请求实体应该使用的授权方案

    2.3 响应体

        响应体是服务器回写给客户端的页面正文,浏览器将正文加载到内存,然后解析渲染 显示页面内容

    展开全文
  • 掌握HTTP请求的精髓

    2020-05-18 10:41:47
    如果面试的时候问到了这道题,用一句话来回答的话,我会说:客户端向服务端发送访问请求,服务端复制了一份自己的内容返回给客户端的过程,但这是把大象塞进冰箱式的回答。 把大象塞进冰箱这一步还可以继续拆解成...
  • http:(4):http请求方法

    2019-09-17 22:05:25
    一个HTTP"客户端"是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP"服务器"同样也是一个应用程序(通常是一个Web服务,如Apache Web服务器或...
  • 是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP"服务器"同样也是一个应用程序(通常是一个Web服务,如Apache Web服务器或IIS...
  • 在前端面试中,经常会被问到“一页面...3.发送HTTP请求 4.服务器处理请求并返回HTTP报文 5.浏览器解析渲染页面 6.连接结束 简要回答: 浏览器据请求的URL交给DNS域名解析,找到对应的IP地址,向服务端发起请求; ...
  • ...HTTP 是基于客户端/...一个HTTP "客户端"是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP "服务器"同样也是一个应用程序(通常是一个Web...
  • HTTP有2个版本,1.0和1.1,目前1.0不用了,因为他只能请求服务器一个资源,但是1.1可以请求多个 ...称之为客户端向服务端发送了一个http请求 以下都是浏览器对服务器的requests 运行<htm...
  • HTTP协议 简介

    2016-04-07 14:45:14
    2.HTTP 请求的内容: 客户端连上服务器后,向服务器请求某个web资源, 称之为客户端向服务端发送个HTTP请求  请求行:客户端的请求方式, 请求的资源名称, 使用HTTP协议版本号  多个消息头:描述客户端请求哪台主机,...
  • nodejs接收get请求参数

    万次阅读 2017-11-30 23:20:23
    1.1-浏览器服务器发送get请求参数的两种方式 1.2-服务端使用url模块解析get请求参数 在http协议中,一完整的url路径如下图通过下图我们可以得知,get请求的参数是直接在url路径中显示。 get的请求参数在path资源...
  • * @param url 发送请求的URL * @return 服务器响应字符串 * @throws Exception */ public static String getRequest(final String url) throws Exception { FutureTask<String> task = new FutureTask( new...
  • Netty HTTP+XML协议栈开发 由于HTTP协议的通用性,很异构系统间的通信交互采用HTTP协议,通过HTTP协议承载...客户端填写订单,通过HTTP客户端向服务端发送订购请求请求消息放在HTTP消息体中,以XML承载,即采用...
  • 一个HTTP"客户端"是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP"服务器"同样也是一个应用程序(通常是一个Web服务,如Apache Web服务器或...
  • Http基础知识整理

    2021-03-25 10:52:19
    HTTP/1.1 长连接(TCP链接不关闭) 管道机制:可同时发送多个请求(有序处理) HTTP2 二进制传输,无序多请求,压缩 TCP三次握手,原因:为什么连接建立需要三次握手,而不是两次握手? 防止失效的连接请求报文段被服务端接收...
  • jQuery文件下载

    2019-10-05 22:14:12
    业务场景是一条数据对应多个文件,需要一次性全部下载,不考虑在服务端把多个文件打包下载,想通过js点击事件向服务端发送多个请求进行下载。在网上找了一篇文章http://www.2cto.com/kf/201501/367538.html,参照它...
  • 2.向服务端发送个HTTP报文 3.服务器收到报文后进行解读,知道了你的诉求,并会解决这个问题,返回一段信息,读取服务端返回的报文信息: 4.关闭连接或者为后续请求重用连接。 浏览器像服务器发出的报文叫“请求”...
  • (2) 客户端向服务端发送请求报文; (3) 服务端向客户端发送响应报文; (4) TCP 四次挥手断开连接。 (5) 返回到 (1)。 通信过程如下图所示: 原理: HTTP/0.9与HTTP/1.0 采用短连接 缺点: 短链接效率非常低下,...
  • HTTP协议详解

    2020-05-11 10:54:03
    是基于客户端与服务端传输的 无状态的 一种通讯传送协议 ... 在HTTP1.1协议中,客户端与web服务器...客户端连上服务器后,服务器请求某个web资源,称之为客户端服务器发送了一个HTTP请求 HTTP请求:请求行 请求头 空格
  • 当浏览器中只点击了一个超级链接,却发送多个数据包。...当客户端和服务端建立TCP连接后,客户端就会服务器发送一个请求信息。http 请求由三部分组成,分别是:请求行、消息报头、请求正文,如:...
  • http

    2019-06-10 16:17:16
    一个HTTP"客户端"是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP"服务器"同样也是一个应用程序(通常是一个Web服务,如Apache Web服务器或...
  • HTTP

    2019-11-13 16:49:46
    一个HTTP "客户端"是一个应用程序(Web浏览器或其他任何客户端),通过连接到服务器达到服务器发送一个或多个HTTP请求的目的。 一个HTTP "服务器"同样也是一个应用程序(通常是一个Web服务,如Apache Web服务器...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 217
精华内容 86
关键字:

向服务端发送多个http请求