精华内容
下载资源
问答
  • 主要介绍了Spring mvc实现Restful返回json格式数据实例详解的相关资料,需要的朋友可以参考下
  • Restful接口返回统一数据格式

    千次阅读 2018-08-02 19:50:51
    一、定义返回数据格式: public class ResponseMessage<T> {  private int code;  private boolean state;  private T data;  private String message;  public ResponseMessage() {  } ...

    一、定义返回的数据格式:

    public class ResponseMessage<T> {

        private int code;
        private boolean state;
        private T data;
        private String message;

        public ResponseMessage() {

        }

        public ResponseMessage(boolean state) {
            this.state = state;
            this.code = getCodeByResult(state);
        }

        public ResponseMessage(boolean state, String message) {
            this.state = state;
            this.code = getCodeByResult(state);
            this.message = message;
        }

        public ResponseMessage(int code, boolean state, String message) {
            this.code = code;
            this.state = state;
            this.message = message;
        }

        public ResponseMessage<T> error(String message) {
            return new ResponseMessage<T>(false, message);
        }

        public ResponseMessage<T> success(String message) {
            return new ResponseMessage<T>(true, message);
        }

        public ResponseMessage<T> success(String message, T data) {
            ResponseMessage<T> responseMessage = new ResponseMessage<T>(true, message);
            responseMessage.setData(data);
            return responseMessage;
        }

        public ResponseMessage<T> success(T data) {
            ResponseMessage<T> responseMessage = new ResponseMessage<T>(true);
            responseMessage.setData(data);
            return responseMessage;
        }

        private int getCodeByResult(boolean state) {
            return state ? ResultCode.SUCCESS_STATUS.getCode() : ResultCode.NO_DATA_STATUS.getCode();
        }

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public boolean isState() {
            return state;
        }

        public void setState(boolean state) {
            this.state = state;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

    }

    二、定义状态码

    public enum ResultCode {

        SUCCESS_STATUS(100, "成功!"),
        NO_DATA_STATUS(200, "无数据!"), 
        INTERFACE_BUSINESS_STATUS(300 , "调用接口业务错误!"), 
        INTERFACE_ERROR_STATUS(400, "调用接口异常!"), 
        TOKEN_ERROR(500,"token错误!"),
        TOKEN_OVERDUE(600,"token过期!");
        
        private int code;
        private String message;

        // 构造方法
        private ResultCode(int code, String message) {
            this.code = code;
            this.message = message;
        }

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        /**
         * 根据code获取message
         * 
         * @param code
         * @return
         */
        public static String getMessage(int code) {
            for (ResultCode c : ResultCode.values()) {
                if (c.getCode() == code) {
                    return c.getMessage();
                }
            }
            return null;
        }

    }

    展开全文
  • 主要介绍了spring mvc实现Restful返回xml格式数据的相关资料,需要的朋友可以参考下
  • 统一数据返回格式 统一异常处理 通用返回值类定义: public class GlobalResponse<T> implements POJO { /** * */ private static final long serialVersionUID = 1L; @ApiModelPro...

    关于 Spring 的全局处理,有两方面要说: 

    1. 统一数据返回格式

    2. 统一异常处理

     

    通用返回值类定义:

    public class GlobalResponse<T> implements POJO {
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	@ApiModelProperty(notes = "数据")
    	private T data;
    	@ApiModelProperty(notes = "不为空。等于200时表示业务成功,其他表示业务失败")
    	private int code = 200;
    	@ApiModelProperty(notes = "错误信息,如果不为空,展示给用户")
    	private String msg;
    
    	public GlobalResponse() {
    
    	}
    
    }

    配置

    没错,我们需要借助几个关键注解来完成一下相关配置:

    @EnableWebMvc
    public class UnifiedResponseHandler {
    
    	@RestControllerAdvice
    	static class CommonResultResponseAdvice implements ResponseBodyAdvice<Object> {
    		@Override
    		public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
    			return true;
    		}
    
    		@Override
    		public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
    				Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request,
    				ServerHttpResponse response) {
    			if (body instanceof GlobalResponse) {
    				// 兼容旧版本的数据,已经用GlobalResponse封装好了的,就不用再进行处理了
    				return body;
    			} else if (body instanceof POJO) {
    				// 目前只针对POJO的返回对象进行封装
    				return new GlobalResponse<Object>(body);
    			} else {
    				return body;
    			}
    		}
    	}
    }

    到这里就结束了,我们就可以纵情的写任何 RESTful API 了,所有的返回值都会有统一的 JSON 结构

    解剖实现过程

    从 @EnableWebMvc 这个注解说起,打开该注解看:

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(DelegatingWebMvcConfiguration.class)
    public @interface EnableWebMvc {
    }

    通过 @Import 注解引入了 DelegatingWebMvcConfiguration.class,那来看这个类吧:

    @Configuration
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    
    	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    
    
    	@Autowired(required = false)
    	public void setConfigurers(List<WebMvcConfigurer> configurers) {
    		if (!CollectionUtils.isEmpty(configurers)) {
    			this.configurers.addWebMvcConfigurers(configurers);
    		}
    	}
    
    
    	@Override
    	protected void configurePathMatch(PathMatchConfigurer configurer) {
    		this.configurers.configurePathMatch(configurer);
    	}
    
    	@Override
    	protected void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
    		this.configurers.configureContentNegotiation(configurer);
    	}
    
    	@Override
    	protected void configureAsyncSupport(AsyncSupportConfigurer configurer) {
    		this.configurers.configureAsyncSupport(configurer);
    	}
    
    	@Override
    	protected void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    		this.configurers.configureDefaultServletHandling(configurer);
    	}
    
    	@Override
    	protected void addFormatters(FormatterRegistry registry) {
    		this.configurers.addFormatters(registry);
    	}
    
    	@Override
    	protected void addInterceptors(InterceptorRegistry registry) {
    		this.configurers.addInterceptors(registry);
    	}
    
    	@Override
    	protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    		this.configurers.addResourceHandlers(registry);
    	}
    
    	@Override
    	protected void addCorsMappings(CorsRegistry registry) {
    		this.configurers.addCorsMappings(registry);
    	}
    
    	@Override
    	protected void addViewControllers(ViewControllerRegistry registry) {
    		this.configurers.addViewControllers(registry);
    	}
    
    	@Override
    	protected void configureViewResolvers(ViewResolverRegistry registry) {
    		this.configurers.configureViewResolvers(registry);
    	}
    
    	@Override
    	protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
    		this.configurers.addArgumentResolvers(argumentResolvers);
    	}
    
    	@Override
    	protected void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
    		this.configurers.addReturnValueHandlers(returnValueHandlers);
    	}
    
    	@Override
    	protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    		this.configurers.configureMessageConverters(converters);
    	}
    
    	@Override
    	protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    		this.configurers.extendMessageConverters(converters);
    	}
    
    	@Override
    	protected void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
    		this.configurers.configureHandlerExceptionResolvers(exceptionResolvers);
    	}
    
    	@Override
    	protected void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
    		this.configurers.extendHandlerExceptionResolvers(exceptionResolvers);
    	}
    
    	@Override
    	@Nullable
    	protected Validator getValidator() {
    		return this.configurers.getValidator();
    	}
    
    	@Override
    	@Nullable
    	protected MessageCodesResolver getMessageCodesResolver() {
    		return this.configurers.getMessageCodesResolver();
    	}
    
    }

    有 @Configuration 注解,你应该很熟悉了,该类的父类 WebMvcConfigurationSupport 中却隐藏着一段关键代码:

    @Bean
    	public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
    		RequestMappingHandlerAdapter adapter = createRequestMappingHandlerAdapter();
    		adapter.setContentNegotiationManager(mvcContentNegotiationManager());
    		adapter.setMessageConverters(getMessageConverters());
    		adapter.setWebBindingInitializer(getConfigurableWebBindingInitializer());
    		adapter.setCustomArgumentResolvers(getArgumentResolvers());
    		adapter.setCustomReturnValueHandlers(getReturnValueHandlers());
    
    		if (jackson2Present) {
    			adapter.setRequestBodyAdvice(Collections.singletonList(new JsonViewRequestBodyAdvice()));
    			adapter.setResponseBodyAdvice(Collections.singletonList(new JsonViewResponseBodyAdvice()));
    		}
    
    		AsyncSupportConfigurer configurer = new AsyncSupportConfigurer();
    		configureAsyncSupport(configurer);
    		if (configurer.getTaskExecutor() != null) {
    			adapter.setTaskExecutor(configurer.getTaskExecutor());
    		}
    		if (configurer.getTimeout() != null) {
    			adapter.setAsyncRequestTimeout(configurer.getTimeout());
    		}
    		adapter.setCallableInterceptors(configurer.getCallableInterceptors());
    		adapter.setDeferredResultInterceptors(configurer.getDeferredResultInterceptors());
    
    		return adapter;
    	}

    RequestMappingHandlerAdapter 是每一次请求处理的关键,来看该类的定义:

    
    public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
            implements BeanFactoryAware, InitializingBean {
        ...
    }

    该类实现了 InitializingBean 接口,其中 InitializingBean 接口的afterPropertiesSet 方法就是关键之一,在 RequestMappingHandlerAdapter 类中同样重写了该方法:

    @Override
    	public void afterPropertiesSet() {
    		// Do this first, it may add ResponseBody advice beans
    		initControllerAdviceCache();
    
    		if (this.argumentResolvers == null) {
    			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
    			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    		}
    		if (this.initBinderArgumentResolvers == null) {
    			List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
    			this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    		}
    		if (this.returnValueHandlers == null) {
    			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
    			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
    		}
    	}

    该方法内容都非常关键,但我们先来看 initControllerAdviceCache 方法,其他内容后续再单独说明:

    
    private void initControllerAdviceCache() {
            ...
        if (logger.isInfoEnabled()) {
            logger.info("Looking for @ControllerAdvice: " + getApplicationContext());
        }
    
        List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        AnnotationAwareOrderComparator.sort(beans);
    
        List<Object> requestResponseBodyAdviceBeans = new ArrayList<Object>();
    
        for (ControllerAdviceBean bean : beans) {
            ...
            if (ResponseBodyAdvice.class.isAssignableFrom(bean.getBeanType())) {
                requestResponseBodyAdviceBeans.add(bean);
            }
        }
    }

    通过 ControllerAdviceBean 静态方法扫描 ControllerAdvice注解,可是我们在UnifiedResponseHandler中实际实现上使用的是 @RestControllerAdvice注解,打开看该注解:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @ControllerAdvice
    @ResponseBody
    public @interface RestControllerAdvice {

    该注解由 @ControllerAdvice 和 @ResponseBody 标记,就好比你熟悉的 @RestController 注解由 @Controller 和 @ResponseBody 标记是一样的

    到这里你已经知道我们用 @RestControllerAdvice 标记的 Bean 是如何被加载到 Spring 上下文的,接下来就要知道是 Spring 是如何使用我们的 bean 以及对返回 body 做处理的

    其实在 HttpMessageConverter是这样转换数据的这篇文章中已经说明了一部分,希望小伙伴先看这篇文章,下面的部分就会秒懂了,我们在这里做进一步的说明

    在 AbstractMessageConverterMethodProcessor 的 writeWithMessageConverters 方法中,有一段核心代码:

    if (messageConverter instanceof GenericHttpMessageConverter) {
        if (((GenericHttpMessageConverter) messageConverter).canWrite(
                declaredType, valueType, selectedMediaType)) {
            outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                    (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                    inputMessage, outputMessage);
                ...
            return;
        }
    }

    可以看到通过 getAdvice() 调用了 beforeBodyWrite 方法,我们已经接近真相了

    
    protected RequestResponseBodyAdviceChain getAdvice() {
        return this.advice;
    }

    RequestResponseBodyAdviceChain,看名字带有 Chain,很明显用到了「责任链设计模式」,只不过它传递责任链以循环的方式完成:

    class RequestResponseBodyAdviceChain implements RequestBodyAdvice, ResponseBodyAdvice<Object> {
    
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType contentType,
                Class<? extends HttpMessageConverter<?>> converterType,
                ServerHttpRequest request, ServerHttpResponse response) {
    
            return processBody(body, returnType, contentType, converterType, request, response);
        }
    
        @SuppressWarnings("unchecked")
        private <T> Object processBody(Object body, MethodParameter returnType, MediaType contentType,
                Class<? extends HttpMessageConverter<?>> converterType,
                ServerHttpRequest request, ServerHttpResponse response) {
    
            for (ResponseBodyAdvice<?> advice : getMatchingAdvice(returnType, ResponseBodyAdvice.class)) {
                if (advice.supports(returnType, converterType)) {
                    body = ((ResponseBodyAdvice<T>) advice).beforeBodyWrite((T) body, returnType,
                            contentType, converterType, request, response);
                }
            }
            return body;
        }
    }

    我们重写的 beforeBodyWrite 方法终究会被调用到,真相就是这样了!!!

    其实还没完,你有没有想过,如果我们的 API 方法返回值是 org.springframework.http.ResponseEntity<T> 类型,我们可以指定 HTTP 返回状态码,但是这个返回值会直接放到我们的 beforeBodyWrite 方法的 body 参数中吗?如果这样做很明显是错误的,因为 ResponseEntity 包含很多我们非业务数据在里面,那 Spring 是怎么帮我们处理的呢?

    在我们方法取得返回值并且在调用 beforeBodyWrite 方法之前,还要选择 HandlerMethodReturnValueHandler  来处理不同类型的返回值

    在类 HandlerMethodReturnValueHandlerComposite 中的 handleReturnValue 方法中

    
    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    
        HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
        if (handler == null) {
            throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
        }
        handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
    }

    通过调用 selectHandler 方法来选择合适的 handler,Spring 内置了很多个 Handler,我们来看类图:

     

    HttpEntityMethodProcessor 就是其中之一,它重写了 supportsParameter 方法,支持 HttpEntity 类型,即支持 ResponseEntity 类型:

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return (HttpEntity.class == parameter.getParameterType() ||
                RequestEntity.class == parameter.getParameterType());
    }

    所以当我们返回的类型为 ResponseEntity 时,就要通过 HttpEntityMethodProcessor 的 handleReturnValue 方法来处理我们的结果:

    
    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    
        ...
        if (responseEntity instanceof ResponseEntity) {
            int returnStatus = ((ResponseEntity<?>) responseEntity).getStatusCodeValue();
            outputMessage.getServletResponse().setStatus(returnStatus);
            if (returnStatus == 200) {
                if (SAFE_METHODS.contains(inputMessage.getMethod())
                        && isResourceNotModified(inputMessage, outputMessage)) {
                    // Ensure headers are flushed, no body should be written.
                    outputMessage.flush();
                    // Skip call to converters, as they may update the body.
                    return;
                }
            }
        }
    
        // Try even with null body. ResponseBodyAdvice could get involved.
        writeWithMessageConverters(responseEntity.getBody(), returnType, inputMessage, outputMessage);
    
        // Ensure headers are flushed even if no body was written.
        outputMessage.flush();
    }

    该方法提取出 responseEntity.getBody(),并传递个 MessageConverter,然后再继续调用 beforeBodyWrite 方法,这才是真相!!!  

     

    展开全文
  • 统一数据返回格式 统一异常处理为了将两个问题说明清楚,将分两个章节分别说明,本章主要说第一点 有童鞋说,我们项目都做了这种处理,就是在每个 API 都单独工具类将返回值进行封装,但这种不够优雅;我想写...

    关于 Spring 的全局处理,我有两方面要说:

    1. 统一数据返回格式
    2. 统一异常处理
      为了将两个问题说明清楚,将分两个章节分别说明,本章主要说第一点

    有童鞋说,我们项目都做了这种处理,就是在每个 API 都单独工具类将返回值进行封装,但这种不够优雅;我想写最少的代码完成这件事,也许有童鞋说,加几个注解就解决问题了,说的没错,但这篇文章主要是为了说明为什么加了几个注解就解决问题了,目的是希望大家知其所以然

    为了更好的说明问题,本文先说明如何实现,然后再详细剖析实现原理(这很关键)

    为什么要做统一数据返回格式

    前后端分离是当今服务形式的主流,如何设计一个好的 RESTful API ,以及如何让前端小伙伴可以处理标准的 response JSON 数据结构都至关重要,为了让前端有更好的逻辑展示与页面交互处理,每一次 RESTful 请求都应该包含以下几个信息:

    名称
    描述
    status
    状态码,标识请求成功与否,如 [1:成功;-1:失败]
    errorCode
    错误码,给出明确错误码,更好的应对业务异常;请求成功该值可为空
    errorMsg
    错误消息,与错误码相对应,更具体的描述异常信息
    resultBody
    返回结果,通常是 Bean 对象对应的 JSON 数据, 通常为了应对不同返回值类型,将其声明为泛型类型

    实现

    通用返回值类定义

    根据上面的描述,用 Java Bean 来体现这个结构就是这样:

    @Data
    public final class CommonResult<T> {
    
        private int status = 1;
    
        private String errorCode = "";
    
        private String errorMsg = "";
    
        private T resultBody;
    
        public CommonResult() {
        }
    
        public CommonResult(T resultBody) {
            this.resultBody = resultBody;
        }
    }

    配置

    没错,我们需要借助几个关键注解来完成一下相关配置:

    @EnableWebMvc
    @Configuration
    public class UnifiedReturnConfig {
    
        @RestControllerAdvice("com.example.unifiedreturn.api")
        static class CommonResultResponseAdvice implements ResponseBodyAdvice<Object>{
            @Override
            public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
                return true;
            }
    
            @Override
            public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
                if (body instanceof CommonResult){
                    return body;
                }
    
                return new CommonResult<Object>(body);
            }
        }
    }

    到这里就结束了,我们就可以纵情的写任何 RESTful API 了,所有的返回值都会有统一的 JSON 结构

    测试

    新建 UserController,添加相应的 RESTful API,测试用例写的比较简单,只为了说明返回值的处理

    @RestController
    @RequestMapping("/users")
    public class UserController {
    
    
        @GetMapping("")
        public List<UserVo> getUserList(){
            List<UserVo> userVoList = Lists.newArrayListWithCapacity(2);
            userVoList.add(UserVo.builder().id(1L).name("日拱一兵").age(18).build());
            userVoList.add(UserVo.builder().id(2L).name("tan").age(19).build());
            return userVoList;
        }
    }

    打开浏览器输入地址测试: http://localhost:8080/users/ ,我们可以看到返回了 List JSON 数据

    继续添加 RESTful API,根据用户 ID 查询用户信息

    @GetMapping("/{id}")
    public UserVo getUserByName(@PathVariable Long id){
        return UserVo.builder().id(1L).name("日拱一兵").age(18).build();
    }

    打开浏览器输入地址测试: http://localhost:8080/users/1 ,我们可以看到返回了单个 User JSON 数据

    添加一个返回值类型为 ResponseEntity 的 API

    @GetMapping("/testResponseEntity")
    public ResponseEntity getUserByAge(){
        return new ResponseEntity(UserVo.builder().id(1L).name("日拱一兵").age(18).build(), HttpStatus.OK);
    }

    打开浏览器输入地址测试: http://localhost:8080/users/testResponseEntity ,我们可以看到同样返回了单个 User JSON 数据

    解剖实现过程

    我会将关键部分一一说明清楚,断案还需小伙伴自己去案发现场(打开自己的 IDE 查看)

    故事要从 @EnableWebMvc 这个注解说起,打开该注解看:

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(DelegatingWebMvcConfiguration.class)
    public @interface EnableWebMvc {
    }

    通过 @Import 注解引入了 DelegatingWebMvcConfiguration.class,那来看这个类吧:

    @Configuration
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
        ...
    }

    @Configuration 注解,你应该很熟悉了,该类的父类 WebMvcConfigurationSupport 中却隐藏着一段关键代码:

    @Bean
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
        RequestMappingHandlerAdapter adapter = createRequestMappingHandlerAdapter();
        ...
        return adapter;
    }

    RequestMappingHandlerAdapter 是每一次请求处理的关键,来看该类的定义:

    public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
            implements BeanFactoryAware, InitializingBean {
        ...
    }

    该类实现了 InitializingBean 接口,我在 Spring Bean 生命周期之“我从哪里来”? 这篇文章中明确说明了 Spring Bean 初始化的几个关键,其中 InitializingBean 接口的afterPropertiesSet 方法就是关键之一,在 RequestMappingHandlerAdapter 类中同样重写了该方法:

    @Override
    public void afterPropertiesSet() {
        // Do this first, it may add ResponseBody advice beans
        initControllerAdviceCache();
    
        if (this.argumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
            this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        if (this.initBinderArgumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
            this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        if (this.returnValueHandlers == null) {
            List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
            this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
        }
    }

    该方法内容都非常关键,但我们先来看 initControllerAdviceCache 方法,其他内容后续再单独说明:

    private void initControllerAdviceCache() {
            ...
        if (logger.isInfoEnabled()) {
            logger.info("Looking for @ControllerAdvice: " + getApplicationContext());
        }
    
        List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        AnnotationAwareOrderComparator.sort(beans);
    
        List<Object> requestResponseBodyAdviceBeans = new ArrayList<Object>();
    
        for (ControllerAdviceBean bean : beans) {
            ...
            if (ResponseBodyAdvice.class.isAssignableFrom(bean.getBeanType())) {
                requestResponseBodyAdviceBeans.add(bean);
            }
        }
    }

    通过 ControllerAdviceBean 静态方法扫描 ControllerAdvice 注解,可是我们在实现上使用的是 @RestControllerAdvice 注解,打开看该注解:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @ControllerAdvice
    @ResponseBody
    public @interface RestControllerAdvice {

    该注解由 @ControllerAdvice@ResponseBody 标记,就好比你熟悉的 @RestController 注解由 @Controller@ResponseBody 标记是一样的

    到这里你已经知道我们用 @RestControllerAdvice 标记的 Bean 是如何被加载到 Spring 上下文的,接下来就要知道是 Spring 是如何使用我们的 bean 以及对返回 body 做处理的

    其实在 HttpMessageConverter是如何转换数据的? 这篇文章中已经说明了一部分,希望小伙伴先看这篇文章,下面的部分就会秒懂了,我们在这里做进一步的说明

    在 AbstractMessageConverterMethodProcessor 的 writeWithMessageConverters 方法中,有一段核心代码:

    if (messageConverter instanceof GenericHttpMessageConverter) {
        if (((GenericHttpMessageConverter) messageConverter).canWrite(
                declaredType, valueType, selectedMediaType)) {
            outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                    (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                    inputMessage, outputMessage);
                ...
            return;
        }
    }

    可以看到通过 getAdvice() 调用了 beforeBodyWrite 方法,我们已经接近真相了

    protected RequestResponseBodyAdviceChain getAdvice() {
        return this.advice;
    }

    RequestResponseBodyAdviceChain,看名字带有 Chain,很明显用到了「责任链设计模式」,这些内容在 不得不知的责任链设计模式 文章中明确说明过,只不过它传递责任链以循环的方式完成:

    class RequestResponseBodyAdviceChain implements RequestBodyAdvice, ResponseBodyAdvice<Object> {
    
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType contentType,
                Class<? extends HttpMessageConverter<?>> converterType,
                ServerHttpRequest request, ServerHttpResponse response) {
    
            return processBody(body, returnType, contentType, converterType, request, response);
        }
    
        @SuppressWarnings("unchecked")
        private <T> Object processBody(Object body, MethodParameter returnType, MediaType contentType,
                Class<? extends HttpMessageConverter<?>> converterType,
                ServerHttpRequest request, ServerHttpResponse response) {
    
            for (ResponseBodyAdvice<?> advice : getMatchingAdvice(returnType, ResponseBodyAdvice.class)) {
                if (advice.supports(returnType, converterType)) {
                    body = ((ResponseBodyAdvice<T>) advice).beforeBodyWrite((T) body, returnType,
                            contentType, converterType, request, response);
                }
            }
            return body;
        }
    }

    我们重写的 beforeBodyWrite 方法终究会被调用到,真相就是这样了!!!

    其实还没完,你有没有想过,如果我们的 API 方法返回值是 org.springframework.http.ResponseEntity 类型,我们可以指定 HTTP 返回状态码,但是这个返回值会直接放到我们的 beforeBodyWrite 方法的 body 参数中吗?如果这样做很明显是错误的,因为 ResponseEntity 包含很多我们非业务数据在里面,那 Spring 是怎么帮我们处理的呢?

    在我们方法取得返回值并且在调用 beforeBodyWrite 方法之前,还要选择 HandlerMethodReturnValueHandler 用于处理不同的 Handler 来处理返回值

    在类 HandlerMethodReturnValueHandlerComposite 中的 handleReturnValue 方法中

    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    
        HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
        if (handler == null) {
            throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
        }
        handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
    }

    通过调用 selectHandler 方法来选择合适的 handler,Spring 内置了很多个 Handler,我们来看类图:

    HttpEntityMethodProcessor 就是其中之一,它重写了 supportsParameter 方法,支持 HttpEntity 类型,即支持 ResponseEntity 类型:

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return (HttpEntity.class == parameter.getParameterType() ||
                RequestEntity.class == parameter.getParameterType());
    }

    所以当我们返回的类型为 ResponseEntity 时,就要通过 HttpEntityMethodProcessor 的 handleReturnValue 方法来处理我们的结果:

    @Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    
        ...
        if (responseEntity instanceof ResponseEntity) {
            int returnStatus = ((ResponseEntity<?>) responseEntity).getStatusCodeValue();
            outputMessage.getServletResponse().setStatus(returnStatus);
            if (returnStatus == 200) {
                if (SAFE_METHODS.contains(inputMessage.getMethod())
                        && isResourceNotModified(inputMessage, outputMessage)) {
                    // Ensure headers are flushed, no body should be written.
                    outputMessage.flush();
                    // Skip call to converters, as they may update the body.
                    return;
                }
            }
        }
    
        // Try even with null body. ResponseBodyAdvice could get involved.
        writeWithMessageConverters(responseEntity.getBody(), returnType, inputMessage, outputMessage);
    
        // Ensure headers are flushed even if no body was written.
        outputMessage.flush();
    }

    该方法提取出 responseEntity.getBody(),并传递个 MessageConverter,然后再继续调用 beforeBodyWrite 方法,这才是真相!!!

    这是 RESTful API 正常返回内容的情况,下一篇文章,让我们来侦查一下统一异常情况的处理以及实现原理

    灵魂追问

    1. 返回值是非 ResponseEntity 类型时,用的是什么 handler?它支持的返回值类型是什么?看过你也许就知道为什么要用 @ResponseBody 注解了
    2. 你有追踪过 DispatchServlet 的整个请求过程吗?

    提高效率工具

    推荐阅读

    --------

    欢迎持续关注公众号:「日拱一兵」

    - 前沿 Java 技术干货分享

    - 高效工具汇总 | 回复「工具」

    - 面试问题分析与解答

    - 技术资料领取 | 回复「资料」

    以读侦探小说思维轻松趣味学习 Java 技术栈相关知识,本着将复杂问题简单化,抽象问题具体化和图形化原则逐步分解技术问题,技术持续更新,请持续关注......

    展开全文
  • spring mvc实现Restful返回json格式数据 在本示例中,我们将向您展示如何将对象转换成json格式并通过spring mvc框架返回给用户。 使用技术及环境: Spring 3.2.2.RELEASE Jackson 1.9.10 JDK 1.6 Eclipse 3.6 ...

    spring mvc实现Restful返回json格式数据

    在本示例中,我们将向您展示如何将对象转换成json格式并通过spring mvc框架返回给用户。

    使用技术及环境:

    1. Spring 3.2.2.RELEASE
    2. Jackson 1.9.10
    3. JDK 1.6
    4. Eclipse 3.6
    5. Maven 3

    PS:在spring 3 中,要输出json数据,只需要添加Jackson 库到你的classpath。

    1、项目依赖

    spring和jackson的依赖:

     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0"
    2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    4. http://maven.apache.org/maven-v4_0_0.xsd">
    5. <modelVersion>4.0.0</modelVersion>
    6. <groupId>com.mkyong.common</groupId>
    7. <artifactId>SpringMVC</artifactId>
    8. <packaging>war</packaging>
    9. <version>1.0-SNAPSHOT</version>
    10. <name>SpringMVC Json Webapp</name>
    11. <url>http://maven.apache.org</url>
    12. <properties>
    13. <spring.version>3.2.2.RELEASE</spring.version>
    14. <jackson.version>1.9.10</jackson.version>
    15. <jdk.version>1.6</jdk.version>
    16. </properties>
    17. <dependencies>
    18. <!-- Spring 3 dependencies -->
    19. <dependency>
    20. <groupId>org.springframework</groupId>
    21. <artifactId>spring-core</artifactId>
    22. <version>${spring.version}</version>
    23. </dependency>
    24. <dependency>
    25. <groupId>org.springframework</groupId>
    26. <artifactId>spring-web</artifactId>
    27. <version>${spring.version}</version>
    28. </dependency>
    29. <dependency>
    30. <groupId>org.springframework</groupId>
    31. <artifactId>spring-webmvc</artifactId>
    32. <version>${spring.version}</version>
    33. </dependency>
    34. <!-- Jackson JSON Mapper -->
    35. <dependency>
    36. <groupId>org.codehaus.jackson</groupId>
    37. <artifactId>jackson-mapper-asl</artifactId>
    38. <version>${jackson.version}</version>
    39. </dependency>
    40. </dependencies>
    41. <build>
    42. <finalName>SpringMVC</finalName>
    43. <plugins>
    44. <plugin>
    45. <groupId>org.apache.maven.plugins</groupId>
    46. <artifactId>maven-eclipse-plugin</artifactId>
    47. <version>2.9</version>
    48. <configuration>
    49. <downloadSources>true</downloadSources>
    50. <downloadJavadocs>false</downloadJavadocs>
    51. <wtpversion>2.0</wtpversion>
    52. </configuration>
    53. </plugin>
    54. <plugin>
    55. <groupId>org.apache.maven.plugins</groupId>
    56. <artifactId>maven-compiler-plugin</artifactId>
    57. <version>2.3.2</version>
    58. <configuration>
    59. <source>${jdk.version}</source>
    60. <target>${jdk.version}</target>
    61. </configuration>
    62. </plugin>
    63. </plugins>
    64. </build>
    65. </project>

    2、Model

    一个简单的JavaBean,稍后将被转换成json格式输出。

     
    1. public class Shop {
    2. String name;
    3. String staffName[];
    4. //getter and setter methods
    5. }

    3、Controller

    添加@ResponseBody到返回值,我们看到:

    1. Jackson 包已经在项目的 classpath
    2. mvc:annotation-driven注解已经启用
    3. 返回方法已经添加了@ResponseBody

    spring会自动处理json的转换。

     
    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.PathVariable;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RequestMethod;
    5. import org.springframework.web.bind.annotation.ResponseBody;
    6. import com.mkyong.common.model.Shop;
    7. @Controller
    8. @RequestMapping("/kfc/brands")
    9. public class JSONController {
    10. @RequestMapping(value="{name}", method = RequestMethod.GET)
    11. public @ResponseBody Shop getShopInJSON(@PathVariable String name) {
    12. Shop shop = new Shop();
    13. shop.setName(name);
    14. shop.setStaffName(new String[]{"mkyong1", "mkyong2"});
    15. return shop;
    16. }
    17. }

    4、mvc:annotation-driven

    在你的spring配置文件中启用mvc:annotation-driven注解。

     
    1. <beans xmlns="http://www.springframework.org/schema/beans"
    2. xmlns:context="http://www.springframework.org/schema/context"
    3. xmlns:mvc="http://www.springframework.org/schema/mvc"
    4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5. xsi:schemaLocation="
    6. http://www.springframework.org/schema/beans
    7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    8. http://www.springframework.org/schema/context
    9. http://www.springframework.org/schema/context/spring-context-3.0.xsd
    10. http://www.springframework.org/schema/mvc
    11. http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    12. <context:component-scan base-package="com.mkyong.common.controller" />
    13. <mvc:annotation-driven />
    14. </beans>

    5、示例结果

    访问URL:http://localhost:8080/SpringMVC/rest/kfc/brands/kfc-kampar

    spring-mvc-json-demo

    展开全文
  • Spring MVC 实现RESTful 返回JSON格式数据

    万次阅读 2016-07-17 16:23:55
    在Java后端的日常开发中,系统间调用通过使用json格式数据,本文将向你展示如何将对象转换成json格式并通过Spring MVC框架返回给调用者。开发工具配置 Spring 4.2.7.RELEASE Jackson 2.6.7 JDK 1.7 IntelliJ IDEA 15...
  • restful接口统一返回格式

    千次阅读 2019-05-29 11:49:38
    import java.util.HashMap; import java.util.Map; import org.apache.commons.lang3.StringUtils; ...* @Description : 公共服务接口返会数据--统一格式 */ public class CommonResult { ...
  • Restful 通用返回格式类设计

    千次阅读 2018-04-21 15:50:56
    Restful 通用返回格式类设计 restful 接口返回遵循统一格式, 设计参考类 Optional 遵循函数式编程规范 普通格式 { "data": "waht", "msg": null, "state": 1, ...
  • django-restful中的response返回数据格式

    千次阅读 2019-12-23 16:26:43
    在django-restful中自定义方法的时候,需要给定返回的response 通常会使用from rest_framework.response import Response 引入使用 但是有时候我们需要自定义为业务所需的规范格式,就需要对response进行自定义格式 ...
  • Flask RESTful 返回数据 乱码

    千次阅读 2018-06-15 14:04:34
    代码 class HelloWorld(Resource): def put(self): args = parser.parse_args() name = args["name"] ...在windows下返回是这样的,乱码 上传到Linux下,在windows中远程操作依然乱码 解决: 用Linux测试
  • 如题,PHP如何自动识别第三方Restful API的内容,自动渲染成 json、xml、html、serialize、csv、php等数据? 其实这也不难,因为Rest API也是基于http协议的,只要我们按照协议走,就能做到自动化识别 API 的内容,...
  • spring mvc实现Restful返回xml格式数据

    千次阅读 2017-01-06 17:58:25
    最近,想在自己的小项目中搭建一个Restful风格的服务接口api,项目用的spring mvc 3,听说spring mvc本身就能十分方便的支持restful的实现,于是查询了下资料,果然非常强大。 在一次偶然的#墙#外#(你懂的)状态下...
  • 今天通过本文给大家讲下Yii2 RESTful格式化响应,授权认证和速率限制三个部分,对yii2 restful api相关知识感兴趣的朋友一起看看吧
  • 文章目录背景一、统一格式设计1.1 返回格式1.2 状态码1.3 错误信息1.4 返回对象1.5 成功标示二、实现方案2.1 错误码枚举2.2 统一结果集封装三、测试及总结3.1 简单的测试3.2 其他3.3 技术交流 背景 在分布式、微服务...
  • RESTful格式规范

    千次阅读 2018-05-10 18:58:38
    RESTful是接口开发格式里面很重要的一个山头,基本开发接口都需要遵守这个规范,它共有十条规范格式: 1、域名,一般将api放在组域名下 http://www.example.com/api/ 2、版本,一般把接口的版本号放在url中 ...
  • delphi7使用IXMLHTTPRequest实现RESTful的访问及返回json数据的解析,推送消息段HMACSHA1加密编码
  • NULL 博文链接:https://ainn2006.iteye.com/blog/1678868
  • 调用接口的时候restful接口的时候返回数据格式一直是乱码??????????如何解决:在接口上面添加注释:@RequestMapping(value = "/userlogin",produces = "application/json; charset=utf-8")特别...
  • Flask_RESTful返回参数

    2020-01-15 23:48:06
    Flask_RESTful返回标准化参数 对于一个类视图,可以指定好一些字段作标准化用于返回。 以后使用ORM模型或者自定义模型的时候,它会自动的获取模型中的相应的字段, 生成json格式数据,然后再返回给客户端。 这需要...
  • 强烈建议 restful api 返回如下格式,只有返回这样的格式才方便解析结果
  • 目录DateTime类型数据格式问题C#对象属性名称转换成JSON自动转成“驼峰命名法”解决办法创建新的 JsonResult 对象使用新的 JsonResult 对象 方法一创建一个BaseController 来重写他的Json()方法使用新的 JsonResult ...
  • 统一数据返回格式 统一异常处理 为了将两个问题说明清楚,将分两个章节分别说明,本章主要说第一点 有童鞋说,我们项目都做了这种处理,就是在每个 API 都单独工具类将返回值进行封装,但这种不够优雅;我...
  • Restful API返回对象封装

    千次阅读 2018-04-20 15:45:26
    * 数据 */ private Object data; public Result() { } public Result(Integer code, String msg) { this.code = code; this.msg = msg; } public static Result success() { Result result...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 69,011
精华内容 27,604
关键字:

restful返回数据格式