spring返回值



package com.clic.common.action;

import com.clic.auth.pojo.UserAuthentication;
import com.clic.auth.pojo.UserAuthority;
import com.clic.common.action.pojo.RestResult;
import com.clic.common.action.pojo.ClientInfo;
import com.clic.common.action.pojo.ClientInfo.ClientType;
import com.clic.common.action.service.IRequestHelper;
import com.clic.common.exception.BizException;
import com.clic.common.exception.FrameworkException;

import com.clic.system.service.ISystemHandleService;
import com.clic.system.service.SystemConfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class BaseController {
 private Logger log = LoggerFactory.getLogger(BaseController.class);
    @Autowired
    private IRequestHelper requestHelper;
    @Autowired
 private ISystemHandleService handleService;
   
    private final String SORT_NAME = "sort";
    private final String PAGE_NAME = "p";
    private final String SIZE_NAME = "len";
    private final int DEFAULT_PAGE = 0;
    private final char DESC='-';
    private final int DEFAULT_SIZE = 10;

    protected Pageable getPage() {
        HttpServletRequest reqeust = getReqeust();
        int page = DEFAULT_PAGE;
        if (reqeust.getParameter(PAGE_NAME) != null) {
            page = Integer.parseInt(reqeust.getParameter(PAGE_NAME));
        }

        int size = DEFAULT_SIZE;
        if (reqeust.getParameter(SIZE_NAME) != null) {
            size = Integer.parseInt(reqeust.getParameter(SIZE_NAME));
        }

        Sort sort = null;
        if (reqeust.getParameter(SORT_NAME) != null) {
            List<String> sortValue = Arrays.asList(reqeust.getParameter(SORT_NAME).split("\\|"));
            List<Sort.Order> orders = new ArrayList<>();
            sortValue.forEach(new Consumer<String>() {
                @Override
                public void accept(String s) {
                    Sort.Direction direction = Sort.Direction.ASC;
                    if (DESC == s.charAt(0)){
                        direction=  Sort.Direction.DESC;
                        s=s.substring(1);
                    }
                    orders.add(new Sort.Order(direction, s));
                }
            });
            sort = new Sort(orders);
        }
        return new PageRequest(page, size, sort);
    }

 protected ClientInfo getClientInfo() {
  return requestHelper.getClientInfo(getReqeust());
 }
 
 protected ClientInfo getLoginClientInfo() {
  return requestHelper.getLoginClientInfo(getReqeust());
 }
 
 
 protected HttpServletRequest getReqeust() {
  return ((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest();
 }
 
 protected HttpServletResponse getResponse() {
  return ((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getResponse();
 }
 
 @ExceptionHandler(BizException.class)
 public <T> ResponseEntity<RestResult<T>> runtimeExceptionHandler(BizException ex) {
  ex.printStackTrace();
  return error(ex);
 }

 @ExceptionHandler(FrameworkException.class)
 public <T> ResponseEntity<RestResult<T>> runtimeExceptionHandler(FrameworkException ex) {
  if(SystemConfig.isDebug()) {
   ex.printStackTrace();
  }else {
   //发送EMAIL、短信给开发人员
   handleService.sendAlarmMessage(ex);
  }  
  return error(ex);
 }

 @ExceptionHandler(Exception.class)
 public void runtimeExceptionHandler(Exception ex) {
  StringBuffer errorMsg = new StringBuffer(ex.toString());
  StackTraceElement[] stacks = ex.getStackTrace();
  int len = stacks.length;
  for(int i=0;i<len;i++) {
   errorMsg.append("\r\n").append(stacks[i]);
  }
  //发送EMAIL、短信给开发人员
  handleService.sendAlarmMessage(ex.getMessage(), errorMsg.toString());
  log.error(errorMsg.toString());
 }

 private MultiValueMap<String, String> jsonHeader(){
  MultiValueMap<String, String> header = new LinkedMultiValueMap<>();
  header.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
  return header;
 }
 
 protected UserAuthentication getCurrentUser() {
  Authentication auth = SecurityContextHolder.getContext().getAuthentication();
  if(auth instanceof UserAuthentication) {
   return (UserAuthentication)auth;
  }
  return null;
//   auth = (CustomerAuthentication)
//  return (AuthorityUserInfo)SecurityContextHolder.getContext().getAuthentication().getPrincipal();
 }
 
 protected UserAuthority getCurrentAuthority() {
  return getCurrentUser().getAuth();
 }
 
 public ClientType getUserClientType() {
  return getCurrentUser().getClientType();
 }
 
 protected ResponseEntity<RestResult<String>> success() {
  return new ResponseEntity<RestResult<String>>(RestResult.succuss(""), HttpStatus.OK);
 }
 
 protected <T> ResponseEntity<RestResult<T>> success(T data) {
  return new ResponseEntity<RestResult<T>>(RestResult.succuss(data), HttpStatus.OK);
 }

 private <T> ResponseEntity<RestResult<T>> error(BizException ex) {
  log.warn(ex.getMessage());
  return new ResponseEntity<RestResult<T>>(RestResult.failure(ex), HttpStatus.OK);
 }

 private <T> ResponseEntity<RestResult<T>> error(FrameworkException ex) {
  log.error(ex.getMessage());
  return new ResponseEntity<RestResult<T>>(RestResult.failure(ex), HttpStatus.OK);
 }
}

ResponseEntity<RestResult<Map<String,String>>> return success(map);也可以是对象