精华内容
下载资源
问答
  • 2021-12-15 14:37:13

    通常,Web服务器一直使用指定端口(默认为80端口)监听客户端的请求。请求由客户端发起,创建一个到服务器指定端口的TCP连接。一旦收到请求,服务器会向客户端返回一个状态,比如“HTTP/1.1 200 OK”,以及返回的内容,如请求的文件、错误消息、或者其他信息,这就是服务器端的响应。

    常见的请求头

    1、 GET或POST:请求类型,后接请求资源、协议和版本

    2、 Host:主机和端口

    3、 Connection:是否使用持续连接

    4、 User-Agent:客户端浏览器的名称

    5、 Accept:浏览器可接受的MIME类型

    6、 Accept-Encoding:浏览器知道如何解码的数据编码类型

    7、 Accept-Language:浏览器指定的语言

    8、 Accept-Charset:浏览器支持的字符编码

    9、 Cookie:保存的Cookie对象

    响应状态

    响应信息的第一行就是响应状态,内容依次是当前HTTP版本号,三位数字组成的状态代码,以及描述状态的短语,彼此由空格分隔。状态代码的第一个数字代表当前响应的类型,xx表示两位数字。

    a、 1xx消息:请求已被服务器接收,继续处理

    b、 2xx成功:请求已成功被服务器接收、理解、并接受

    c、 3xx重定向:需要后续操作才能完成这一请求

    d、 4xx请求错误:请求含有词法错误或者无法被执行

    e、 5xx服务器错误:服务器在处理某个正确请求时发生错误

    响应头

    响应头用于指示客户端如何处理响应体,告诉浏览器响应的类型、字符编码和字节大小等信息。

    1、 Allow:服务器支持哪些请求方法(如GET、POST等)

    2、 Content-Encoding:文档的编码(Encode)类型。只有在解码之后才可以得到Content-Type头指定的内容类型

    3、 Content-Length:内容长度。只有当浏览器使用持久HTTP连接时才需要这个数据

    4、 Content-Type:表示后面的文档属于什么MIME类型

    5、 Date:当前的时间

    6、 Expires:文档过期时间

    7、 Refresh:表示浏览器应该在多少时间之后刷新文档,以秒计

    8、 Server:服务器名称

    9、 Set-Cookie:设置与页面关联的Cookie

    10、 WWW-Authenticate:客户应该在Authorization头中提供的授权信息类型

    响应体

    响应头之后紧跟着一个空行,然后接响应体。响应体就是Web服务器发送到客户端的实际内容。除网页外,响应体还可以是诸如Word、Excel或PDF等其他类型的文档,具体是哪种文档类型由Content-Type指定的MIME类型决定。


    参考博客:https://www.cnblogs.com/lonelyshy/p/13651159.html

    更多相关内容
  • 主要介绍了详解SpringBoot统一响应体解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java response响应体和文件下载实现原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • SpringBoot控制器统一的响应体加密与请求体解密的注解处理方式,支持MD5/SHA/AES/DES/RSA
  • SpringBoot统一响应体解决方案

    千次阅读 2020-06-09 11:32:34
    通过修改响应返回的JSON数据,让其带上一些固有的字段,例如以下这样的 { "code": 10000, "msg": "success", "data": { "id": 2, "name": "test" } } 其中关键属性的用途如下: code为返回结果的状态码 msg...

    参考文章:https://segmentfault.com/a/1190000019795918

    通过修改响应返回的JSON数据,让其带上一些固有的字段,例如以下这样的

    {
        "code": 10000,
        "msg": "success",
        "data": {
            "id": 2,
            "name": "test"
        }
    }
    

    其中关键属性的用途如下:

    • code为返回结果的状态码
    • msg为返回结果的消息
    • data为返回的业务数据

    这3个属性为固有属性,每次响应结果都会有带有它们。

    一、方案思路

    基于上述的需求,选择使用Spring的Controller增强机制,其中关键的类为以下3个:

    • @ControllerAdvice:类注解,用于指定Controller增强处理器类。
    • ResponseBodyAdvice:接口,实现后beforeBodyWrite()方法后可以对响应的body进行修改,需要结合@ControllerAdvice使用。
    • @ExceptionHandler:方法注解,用于指定异常处理方法,需要结合@ControllerAdvice和
      @ResponseBody使用。
    • @Configuration解决返回体为String时报错的问题

    二、示例代码

    1. 需要引入lombok依赖

    <!--lombok-->
    <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <optional>true</optional>
     </dependency>
    

    2. 统一响应体

    Controller增强后统一响应体对应的对象

    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    import java.io.Serializable;
    
    /**
     * 统一的公共响应体
     * @author NULL
     * @date 2019-07-16
     */
    @Data
    @AllArgsConstructor
    public class ResponseResult implements Serializable {
        /**
         * 返回状态码
         */
        private Integer code;
        /**
         * 返回信息
         */
        private String msg;
        /**
         * 数据
         */
        private Object data;
    
    }
    

    3. 统一响应注解

    统一响应注解是一个标记是否开启统一响应增强的注解

    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 统一响应注解<br/>
     * 添加注解后,统一响应体才能生效
     * @author NULL
     * @date 2019-07-16
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD, ElementType.TYPE})
    public @interface BaseResponse {
    
    }
    

    4. 状态码枚举

    统一响应体中返回的状态码code和状态信息msg对应的枚举类

    /**
     * 返回状态码
     *
     * @author NULL
     * @date 2019-07-16
     */
    public enum ResponseCode {
        /**
         * 成功返回的状态码
         */
        SUCCESS(10200, "success"),
        /**
         * 资源不存在的状态码
         */
        RESOURCES_NOT_EXIST(10201, "资源不存在"),
        /**
         * 所有无法识别的异常默认的返回状态码
         */
        SERVICE_ERROR(50000, "服务器异常");
        /**
         * 状态码
         */
        private int code;
        /**
         * 返回信息
         */
        private String msg;
    
        ResponseCode(int code, String msg) {
            this.code = code;
            this.msg = msg;
        }
    
        public int getCode() {
            return code;
        }
    
        public String getMsg() {
            return msg;
        }
    }
    

    5. 业务异常类

    业务异常类是用于识别业务相关的异常,需要注意这个异常类强制需要以ResponseCode作为构造方法入参,这样可以通过捕获异常获得返回的状态码信息

    import com.rjh.web.response.ResponseCode;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    
    /**
     * 业务异常类,继承运行时异常,确保事务正常回滚
     *
     * @author NULL
     * @since  2019-07-16
     */
    @Data
    @EqualsAndHashCode(callSuper = false)
    public class BaseException extends RuntimeException{
    
        private ResponseCode code;
    
        public BaseException(ResponseCode code) {
            this.code = code;
        }
    
        public BaseException(Throwable cause, ResponseCode code) {
            super(cause);
            this.code = code;
        }
    }
    

    6. 异常处理类

    用于处理Controller运行时未捕获的异常的处理类。

    import com.rjh.web.exception.BaseException;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    /**
     * 异常处理器
     *
     * @author NULL
     * @since  2019-07-16
     */
    @ControllerAdvice(annotations = BaseResponse.class)
    @ResponseBody
    @Slf4j
    public class ExceptionHandlerAdvice {
        /**
         * 处理未捕获的Exception
         * @param e 异常
         * @return 统一响应体
         */
        @ExceptionHandler(Exception.class)
        public ResponseResult handleException(Exception e){
            log.error(e.getMessage(),e);
            return new ResponseResult(ResponseCode.SERVICE_ERROR.getCode(),ResponseCode.SERVICE_ERROR.getMsg(),null);
        }
    
        /**
         * 处理未捕获的RuntimeException
         * @param e 运行时异常
         * @return 统一响应体
         */
        @ExceptionHandler(RuntimeException.class)
        public ResponseResult handleRuntimeException(RuntimeException e){
            log.error(e.getMessage(),e);
            return new ResponseResult(ResponseCode.SERVICE_ERROR.getCode(),ResponseCode.SERVICE_ERROR.getMsg(),null);
        }
    
        /**
         * 处理业务异常BaseException
         * @param e 业务异常
         * @return 统一响应体
         */
        @ExceptionHandler(BaseException.class)
        public ResponseResult handleBaseException(BaseException e){
            log.error(e.getMessage(),e);
            ResponseCode code=e.getCode();
            return new ResponseResult(code.getCode(),code.getMsg(),null);
        }
    }
    

    7. 响应增强类

    Conrtoller增强的统一响应体处理类,需要注意异常处理类已经进行了增强,所以需要判断一下返回的对象是否为统一响应体对象。

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.MethodParameter;
    import org.springframework.http.MediaType;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    /**
     * 统一响应体处理器
     * @author NULL
     * @date 2019-07-16
     */
    @ControllerAdvice(annotations = BaseResponse.class)
    @Slf4j
    public class ResponseResultHandlerAdvice implements ResponseBodyAdvice {
    
        @Override
        public boolean supports(MethodParameter returnType, Class converterType) {
            log.info("returnType:"+returnType);
            log.info("converterType:"+converterType);
            return true;
        }
    
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
            if(MediaType.APPLICATION_JSON.equals(selectedContentType) || MediaType.APPLICATION_JSON_UTF8.equals(selectedContentType)){ // 判断响应的Content-Type为JSON格式的body
                if(body instanceof ResponseResult){ // 如果响应返回的对象为统一响应体,则直接返回body
                    return body;
                }else{
                    // 只有正常返回的结果才会进入这个判断流程,所以返回正常成功的状态码
                    ResponseResult responseResult =new ResponseResult(ResponseCode.SUCCESS.getCode(),ResponseCode.SUCCESS.getMsg(),body);
                    return responseResult;
                }
            }
            // 非JSON格式body直接返回即可
            return body;
        }
    }
    

    8. 使用示例

    首先准备一个User对象

    import lombok.Data;
    import lombok.EqualsAndHashCode;
    
    import java.io.Serializable;
    
    /**
     * 用户类
     * @author NULL
     * @date 2019-07-16
     */
    @Data
    @EqualsAndHashCode
    public class User implements Serializable {
    
        private Integer id;
    
        private String name;
        
    }
    

    然后是准备一个简单的UserController即可

    import com.rjh.web.entity.User;
    import com.rjh.web.exception.BaseException;
    import com.rjh.web.response.BaseResponse;
    import com.rjh.web.response.ResponseCode;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 测试用的Controller
     *
     * @author NULL
     * @date 2019-07-16
     */
    @BaseResponse
    @RestController
    @RequestMapping("users")
    public class UserController {
    
        @GetMapping("/{userId}")
        public User getUserById(@PathVariable Integer userId){
            if(userId.equals(0)){
                throw new BaseException(ResponseCode.RESOURCES_NOT_EXIST);
            }
            if(userId.equals(1)){
                throw new RuntimeException();
            }
            if(userId.equals(2)){
                return "你好";
            }
            User user=new User();
            user.setId(userId);
            user.setName("test");
            return user;
        }
        
    }
    

    运行结果

    1. 在浏览器直接访问http://127.0.0.1:8080/users/0,则返回结果如下(结果经过格式化处理):
    {
        "code": 10201,
        "msg": "资源不存在",
        "data": null
    }
    
    1. 在浏览器直接访问http://127.0.0.1:8080/users/1,则返回结果如下(结果经过格式化处理):
        "code": 50000,
        "msg": "服务器异常",
        "data": null
    }
    
    1. 在浏览器直接访问http://127.0.0.1:8080/users/2,则返回结果如下(结果经过格式化处理):
    你好
    
    1. 在浏览器直接访问http://127.0.0.1:8080/users/3,则返回结果如下(结果经过格式化处理):
    {
        "code": 10200,
        "msg": "success",
        "data": {
            "id": 2,
            "name": "test"
        }
    }
    

    由运行结果可以得知统一响应增强其实已经生效了,而且能够很好的处理异常。

    9. 解决返回String类型时格式不准确的问题

    参考文章:https://www.cnblogs.com/oldboyooxx/p/10824531.html

    到这里统一响应和异常处理已经完成了,但是需要注意的是,在上述运行结果3中,如果返回的是字符串,并没有包装成统一的响应体,原因是我们在ResponseResultHandlerAdvice类中做了处理:“// 非JSON格式body直接返回即可”,若想让字符串也以统一响应格式返回的话,可以这么做

    (1).去除ResponseResultHandlerAdvice类中的判断

    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.MethodParameter;
    import org.springframework.http.MediaType;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    /**
     * 统一响应体处理器
     * @author NULL
     * @date 2019-07-16
     */
    @ControllerAdvice(annotations = BaseResponse.class)
    @Slf4j
    public class ResponseResultHandlerAdvice implements ResponseBodyAdvice {
    
        @Override
        public boolean supports(MethodParameter returnType, Class converterType) {
            log.info("returnType:"+returnType);
            log.info("converterType:"+converterType);
            return true;
        }
    
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
            if(body instanceof ResponseResult){ // 如果响应返回的对象为统一响应体,则直接返回body
            	return body;
            }else{
                // 只有正常返回的结果才会进入这个判断流程,所以返回正常成功的状态码
                ResponseResult responseResult =new ResponseResult(ResponseCode.SUCCESS.getCode(),ResponseCode.SUCCESS.getMsg(),body);
                return responseResult;
            }
        }
    }
    

    这样所有的类型都会使用ResponseResult包装一次,但是,这是候如果返回的是字符串的话,会报出如下错误:java.lang.ClassCastException: com.xxx.dto.common.ResponseResult cannot be cast to java.lang.String

    (2).问题原因及解决方案

    因为在所有的 HttpMessageConverter 实例集合中,StringHttpMessageConverter 要比其它的 Converter 排得靠前一些。我们需要将处理 Object 类型的 HttpMessageConverter 放得靠前一些,这可以在 Configuration 类中完成:
    在WebConfiguration方法中添加configureMessageConverters方法

    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    import java.util.List;
    
    @Configuration
    public class WebConfiguration implements WebMvcConfigurer {
    
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            converters.add(0, new MappingJackson2HttpMessageConverter());
        }
    }
    

    这样在浏览器访问http://127.0.0.1:8080/users/2,则返回结果如下(结果经过格式化处理):

    {
        "code": 10200,
        "msg": "success",
        "data": "你好"
    }
    
    展开全文
  • response对象(响应对象) 想要获取客户端的内容,使用request对象。对客户端做出响应使用response对象 响应 响应行 状态码: void setStatus(int sc) 设置状态码 响应头(key:value的形式,1个key1个value/多个...

    response对象和request对象

    response对象(响应对象)

    想要获取客户端的内容,使用request对象。对客户端做出响应使用response对象
    

    响应

    响应行
    	状态码:
    		void setStatus(int sc)  	设置状态码
    		
    响应头(key:value的形式,1个key1个value/多个value)
    	设置头信息
    		 void setHeader(String name, String value)  1对1(经常使用)
    			setHeader("aa","bb");
    			setHeader("aa","cc");
    			结果aa:cc
    
    		 void setIntHeader(String name, int value) 
    		 void setDateHeader(String name, long date) 值是毫秒值(一般int 秒   long  毫秒)
    
    
    		 void addHeader(String name, String value) 1对多
    			addHeader("aa","bb");
    			addHeader("aa","cc");
    			结果aa:bb,cc
    
    		void addIntHeader(String name, int value) 
    		void addDateHeader(String name, long date)  
    
    
    响应体
    
    	ServletOutputStream getOutputStream()	字节输出流
    	PrintWriter getWriter()					字符输出流
    

    案例:

    重定向(登陆界面)

    		登陆界面重定向
    		状态码302	响应头location
    		需求:登陆界面,用户名和密码的登陆界面,用户名和密码都是admin。用户名和密码都是admin	
    			如果有一个不是,重定向到登陆界面,重新登陆
    
    			//设置302的状态码
    			response.setStatus(302);
    			//设置地址
    			response.setHeader("location", "/day10/response/login.html");
    
    			//response提供了一个方法,可以完成重定向
    			response.sendRedirect("/day10/response/login.html");
    

    页面定时刷新(页面读秒操作)

    		响应头	refresh
    

    禁用浏览器缓存(三个头信息)

    		应用:网银。页面的数据是发送变化的
    		
    		Cache-Control:no-cache
    		Expires:-1		值是日期类型(setDateHeader)
    		Pragma:no-cache				
    
    	向页面输出中文(乱码问题)
    		ServletOutputStream getOutputStream()	字节输出流
    

    字节输出流

    /*
     * 字节输出中文的乱码
     * 	输出  你好啊  是否乱码呢?
     * 		不一定乱码
     * 	解决办法
     * 		设置浏览器打开文件时所采用的编码
     * 			response.setHeader("Content-Type", "text/html;charset=UTF-8");
     * 		获取字符串byte数组时的编码和打开文件时编码一致
     * */
    
    
    		PrintWriter getWriter()					字符输出流
    

    字符输出流

    /*
     * 字符输出中文是否乱码
     * 	肯定乱码
     * 		response缓冲区,编码的默认值是ISO-8859-1不支持中文
     * 设置response缓冲区编码
     * response.setCharacterEncoding("UTF-8");
     * 设置浏览器打开文件时的编码
     * 
     * */
    		
    	
    	实现验证码
    

    总结:response对象输出中文产生乱码

    字节
    	解决方案:
    		设置浏览器打开文件时的编码
    			response.setHeader("Content-Type", "text/html;charset=UTF-8");
    		获取字符串byte数组采用的编码
    			os.write("你好啊".getBytes("UTF-8"));
    字符
    	解决方案
    		设置浏览器打开文件时的编码
    			response.setHeader("Content-Type", "text/html;charset=UTF-8");
    		设置response缓冲区编码
    			response.setCharacterEncoding("UTF-8");
    
    		简写方式 response.setContentType("text/html;charset=UTF-8");
    

    实现文件下载(初级的下载)

    超链接,浏览器可以解析就直接打开
    弹出下载窗口
    	前提条件:先准备一个文件。
    	读取文件,读入到输入流中
    	通过response读出到浏览器端
    	设置头信息
    		Content-Disposition		attachment;filename=文件名称
    		以附件形式下载
    

    验证码

    现在内存中生成一张图片(画步,纸)
    	BufferedImage对象			
    	BufferedImage​(int width, int height, int imageType)构造方法
    获取画笔对象
    	Graphics getGraphics()
    随机生成,但是数据是准备的
    	随机生成4个字符		Random类
    通过画笔对象把数字画到图片上
    	drawString​(String str, int x, int y)
    画干扰线
    	drawLine​(int x1, int y1, int x2, int y2)
    需要把内存中的图片输出到客户端上
    	ImageIO.write​(RenderedImage im, String formatName, OutputStream output)
    
    		BufferedImage
    		"jpg"
    		response.getOutputStream()
    

    request对象(请求对象)

    ServletRequest
    		|
    HttpServletRequest
    

    获取客户机的信息

    	getRemoteAddr(****)	获取ip地址
    	getMethod()		获取请求方式
    	getContextPath()	获取虚拟路径(默认和项目名称相同)
    
    	getQueryString()(了解)
    
    	/day10/demo?username=zhangsan?password=123
    

    获取请求头信息

    String getHeader(String name)
    long getDateHeader(String name)
    int getIntHeader(String name)
    
    请求头
    	referer		记住网页的来源
    	User-Agent	判断浏览器哦
    	if-modified-since	控制缓存
    

    获取请求参数(****)

    String getParameter(String name) (****)
    String[] getParameterValues(String name) (****)
    
    Map getParameterMap() (****)
    
    Enumeration getParameterNames()  (用的比较少)
    

    解决request乱码问题

    post请求

    	 * 	void setCharacterEncoding(String env) 		//设置request缓冲区的编码
    

    get请求

    	 * 		解决方案三(****):简写的方式
    	 * 			username = new String(username.getBytes("ISO8859-1"),"utf-8");
    	 * 		
    	 * 		解决方案一:修改tomcat/conf/server.xml
    	 * 			<Connector port="80"....>....URLEncoding="utf-8"/>
    	 * 
    	 * 		解决方案二:逆向编解码
    	 * 			username = URLEncoder.encode(username,"ISO8859-1:);
    	 * 			username = URLDecoder.decode(username,"utf-8");
    	 * 			
    

    利用请求域传递对象(request域对象)

    域对象 
    	ServletContext :服务器一启动,为每个web应用创建一个ServletContext对象,所有的
    					servlet实例共享对象
    	request:一次请求的范围
    	
    setAttribute("","")
    getAttribute("")
    removeAttribute("")
    
    
    RequestDispatcher getRequestDispatcher(String path)
    RequestDispatcher: 
    	void forward(ServletRequest request, ServletResponse response) 转发的方法
    	void include(ServletRequest request, ServletResponse response) (了解)包含
    

    重定向和转发的区别(转发)

    重定向两次请求,两次响应
    转发是一次请求,一次响应
    
    重定向地址发生了变化
    转发地址栏没有变化
    
    重定向不能使用request域传递数据
    
    转发传递数据
    
    重定向可以定向其他系统
    转发只能在系统内部
    
    展开全文
  • ⑥通过response设置响应体 旧 //text package com . itheima . content ; import java . io . IOException ; import java . io . PrintWriter ; import javax . servlet . ServletException ; ...

    ①手动去设置HTTP响应行中的状态码,这里用到了response的setStatus(int sc);这个方法

    package com.itheima.line;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class StatusServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		
    		//手动去设置HTTP响应行中的状态码
    		response.setStatus(1014);//这里的状态码设置为1014
    		
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    

    建立的工程如下:

    在这里插入图片描述

    最后的结果如下:

    在这里插入图片描述

    ②通过response设置响应头

    addHeader(String name, String value)
    addIntHeader(String name, int value)
    addDateHeader(String name, long date)

    setHeader(String name, String value) 重点
    setIntHeader(String name, int value)
    setDateHeader(String name, long date)

    其中,add表示添加,而set表示设置

    为编辑之前的在这里插入图片描述

    在这里插入图片描述

    package com.itheima.header;
    
    import java.io.IOException;
    import java.util.Date;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class HeaderServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		
    		Date date = new Date();
    		
    		//设置响应头
    		response.addHeader("name", "beyondyy");//若重复,则接着添加
    		response.addHeader("name", "beyondwsq");
    		response.addIntHeader("age", 19);
    		response.addDateHeader("birthday", date.getTime());
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    

    编辑之后的结果:

    在这里插入图片描述

    同样的道理,add表示有相同的往后接着添加,set只保留一个,前面的会被后面的给取代。

    ③重定向(302)

    老版

    重定向:说白了就是,当你访问servlet1时,它没有资源,它给你说servlet2有,然后你就会再访问servlet2。

    重定向 状态码 302
    响应头 Location (代表重定向地址)
    //servlet1
    package com.itheima.header;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class Servlet1 extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		//没有响应资源 告知客户端去重定向到servlet2
    		
    		//1.设置状态码为302
    		response.setStatus(302);
    		//2.设置一个响应头Location
    		response.setHeader("Location", "/WEB14/servlet2");
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    
    //servl2
    package com.itheima.header;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class Servlet2 extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		response.getWriter().write("hello beyondsq...");
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    

    web.xml里面url分别设置为servlet1和servlet2

    由于重定向的方法每次都那么写麻烦,javaEE进行封装成一个叫重定向的方法sendRedirect(url);

    封装之后的servlet1

    新版

    //servlet1
    package com.itheima.header;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class Servlet1 extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		//没有响应资源 告知客户端去重定向到servlet2
    		//封装成一个重定向的方法sendRedirect(url);
    		response.sendRedirect("/WEB14/servlet2");
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    

    ④定时刷新(跟重定向一样,就是多了一个时间延迟而已)

    //refresh
    package com.itheima.header;
    
    import java.io.IOException;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class RefreshServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		//设置定时刷新的头
    		response.setHeader("refresh", "5;url=//www.baidu.com");
    		//5s之后再跳转到url为百度的地址
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    } 
    

    ⑤js完成页面的定时跳转

    案例:5秒后自动跳转到百度
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    <script type="text/javascript">
    		window.onload = function(){
    			var time = 5;
    			var secondEle = document.getElementById("second");
    			var timer = setInterval(function(){
    				secondEle.innerHTML = time;
    				time--;
    				if(time==0){
    					clearInterval(timer);	
    					location.href="http://www.baidu.com";
    				}
    			},1000);//1000ms表示1s变一次
    		}
    </script>
    </head>
    <body>
    		恭喜你,注册成功,<span style="color:red" id="second">5</span>秒后跳转。如不跳转,请点击<a href="http://www.baidu.com">这里</a>
    </body>
    </html>
    

    ⑥通过response设置响应体

    //text
    package com.itheima.content;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class TextServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		//设置response查询的码表
    		response.setCharacterEncoding("UTF-8");
    		
    		//通过一个头Content-Type告知客户端使用何种码表进行解码
    		response.setHeader("Context-Type", "text/html;charset=UTF-8");//文本为HTML类型,编码为UTF-8 
    		
    		
    		PrintWriter writer = response.getWriter();
    		writer.write("原谅我这一生不羁放纵爱自由wsq");
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    

    在这里插入图片描述

    工程创建在这里插入图片描述

    新(进行代码封装之后)

    package com.itheima.content;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class TextServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		
    		//进行方法封装之后	
    		response.setContentType("text/html;charset=UTF-8");
    		
    		PrintWriter writer = response.getWriter();
    		writer.write("原谅我这一生不羁放纵爱自由wsq");
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    

    牢记这行代码即可:

    response.setContentType(“text/html;charset=UTF-8”);

    ⑦response的outputstream来获得服务器上的图片

    响应头设置字节

    ServletOutputStream getOutputStream()
    获得字节流,通过该字节流的write(byte[] bytes)可以向response缓冲区中写入字 节,在由Tomcat服务器将字节内容组成Http响应返回给浏览器。

    //byte
    package com.itheima.content;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    import javax.servlet.ServletException;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class ByteServlet extends HttpServlet {
    
    	public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		
    		//使用response获得字节输出流
    		ServletOutputStream out = response.getOutputStream();
    		
    		//获得服务器上的图片
    		String realPath = this.getServletContext().getRealPath("a.jpg");//相对地址,相对web应用的
    		InputStream in = new FileInputStream(realPath);
    
    		int len = 0;
    		byte[] buffer = new byte[1024];
    		while((len = in.read(buffer))>0){
    			out.write(buffer,0,len);
    		}
    		
    		in.close();
    		out.close();	
    	}
    
    	public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		doGet(request, response);
    	}
    }
    
    

    在这里插入图片描述

    展开全文
  • 超全面javaweb教程28天第10天_8_response响应体,响应字节数据
  • //对token赋值 获取的是响应体的值,如果是token在响应头,用这个方法不行 // pm.environment.set("token", data.message) //如下方json格式,如果取大括号里大括号的值则需要 data.data.loginUser.email...
  • 1、设置响应行 public class ResponseServlet01 extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System....
  • 后端响应体和状态码设计

    千次阅读 2019-12-23 18:51:05
    为什么要设计统一响应体 因为系统中默认给我们提供了许多的状态码,比如404,500等。但是HTTP的状态码数量有限,而随着业务的增长,HTTP状态码无法很好地表示业务中遇到的异常情况。 那么可以通过修改响应返回的JSON...
  • Request Body:请求 HTTP请求报文由3部分组成(请求行+请求头+请求): 下面是一个实际的请求报文: ①是请求方法,HTTP/1.1 定义的请求方法有8种:GET、POST、...
  • Spring Cloud Gateway 获取响应体消息

    千次阅读 2020-08-07 10:09:32
      在通常情况下,微服务的业务功能都需要通过网关来进行转发,记录业务响应日志通过网关来记录是最有利的方式。 二、演示代码 测试版本 组件名 版本号 Spring Boot 2.2.5.RELEASE Spring Cloud Hoxton...
  • Spring Cloud Gateway 修改返回的响应体

    千次阅读 2020-11-24 12:04:38
    问题描述: 在gateway中修改返回的响应体,在全局Filter中添加如下代码: import org.springframework.core.Ordered; import org.springframework.cloud.gateway.filter.GlobalFilter; import org.springframework....
  • 二、查看请求信息 (1)请求方法为GET,...(2)响应体信息 注:Response里展示的信息为服务器返回的原始信息;Preview里展示的是经浏览器格式化的服务器返回的信息,如json转成对象,html文本转成页面等等。 ...
  • Request Body:请求 HTTP请求报文由3部分组成(请求行+请求头+请求): 下面是一个实际的请求报文: 其中,①,②和③属于请求行;④属于请求头;⑤属于报文体 ① 是请求方法,HTTP/1.1 定义的请求方法有8种:...
  • 相应行---响应的状态码 HTTP状态码分类 HTTP状态码由三个十进制数字组成,第一个十进制数字定义了状态码的类型,后两个数字没有分类的作用。HTTP状态码共分为5种类型: HTTP状态码分类 分类 分类描述 1** ...
  • 获取nginx响应头、响应体

    千次阅读 2020-07-08 18:29:22
    在原生nginx中无法获取响应相关信息。我们可以在openresty中借助lua来获取这些信息。 worker_processes 1; error_log logs/error.log; events { worker_connections 1024; } http { log_format log_req_resp '$...
  • 在不修改后端代码的情况下,想要修改浏览器中请求页面获取的响应体,使请求页面响应体呈现出自己预期的结果 具体操作: 步骤一:启动fiddler抓包工具 步骤二:使用fiddler过滤器,过滤与本次服务无关的请求...
  • HTTP请求,响应体报文(行,头,体)

    万次阅读 多人点赞 2018-11-28 00:08:14
    响应体(4):是服务器返回给客户端的文本信息。   HTTP响应报文属性 Cache-Control  :响应输出到客户端后,服务端通过该报文头属告诉客户端如何控制响应内容的缓存。常见的有:(默认 为private) ...
  • 企业实战之spring项目《接口响应体格式统一封装》

    万次阅读 多人点赞 2018-01-05 00:03:00
    前言 在之前的文章中我们有介绍过,如何更好、更简单的写好一个接口(接口返回值篇),今天的这篇文章我们主要介绍,怎么统一处理下接口的返回格式问题。 ...1. 成功/失败响应格式不一致(此种方
  • 需求场景 ... 例如:一个错误信息的响应信息应该包含内容以及返回对应的设计错误码。 在flask中如何制定这个的响应信息呢?...return 响应体, 状态码, 响应头 等价于 return (响应体, 状态码, 响应头) return ...
  • http请求体和响应体图解

    千次阅读 2018-08-20 21:19:21
  • response:响应(二)操作响应体

    千次阅读 2018-03-28 10:03:17
    操作响应体: 页面上要展示的内容 常用方法: Writer getWriter():字符流 ServletOutputStream getOutputStream() :字节流 自己写的东西用字符流,其他一概用字节流. 处理响...
  • @ApiModel(value = "响应返回值", description = "用户接口的响应返回数据") public class ResponseVo { /** * 姓名 */ @JsonProperty @ApiModelProperty(value = "姓名") private String CName; /** * ...
  • 使用Fiddler抓包将响应体保存到指定文件 打开Fiddler,用快捷键Ctrl+r打开Fiddler ScriptEditor,搜索OnBeforeResponse,在此方法下加入代码: //过滤无关请求,只关注特定请求 if (oSession.fullUrl.Contains(...
  • ResponseBodyAdvice是spring4.1的新特性,其作用是在响应体写出之前做一些处理;比如,修改返回值、加密等。 我在项目中的用到@ControllerAdvice,ResponseBodyAdvice的目的,是为每个请求的返回json中修改一个...
  • Response设置响应体字符信息

    千次阅读 2019-01-04 22:40:42
    3、out为jsp的内置对象,刷新jsp页面,自动初始化获得out对象,所以使用out对象是需要刷新页面的,而response.getWriter()响应信息通过out对象输出到网页上,当响应结束时它自动被关闭,与jsp页面无关,无需刷新页面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 354,064
精华内容 141,625
关键字:

响应体