版权声明:fromZjy QQ1045152332 https://blog.csdn.net/qq_36762677/article/details/83001451
@PostMapping(value = "/girls")
public Object addGirl(Girl girl) {//此处不用使用多个@RequestParam("name")
Result result = new Result("addGirl_Error", 0, false);
try {
result.setResult(commandService.addGirl(girl));
result.setType("addGirl_ACK");
return result;
} catch (Exception e) {
logger.error("添加女生失败", e);
result.setCode(-3);
return result;
}
}
@Valid表单验证
验证传进controller的对象属性是否有错
1.Girl实体类成员变量需要添加注解
@Min(value = 18 , message = "未满18岁不可访问")
private Integer age;
2.controller参数需要处理
@PostMapping(value = "/girls")
//!!!!需要加@Valid注解
public Object addGirl(@Valid Girl girl,BindingResult br) {
Result result = new Result("addGirl_Error", 0, false);
//需要处理没验证通过的结果,错误信息返回
if (br.hasErrors()){
result.setMessage(br.getFieldError().getDefaultMessage());
return result;
}
try {
result.setResult(commandService.addGirl(girl));
result.setType("addGirl_ACK");
return result;
} catch (Exception e) {
logger.error("添加女生失败", e);
result.setCode(-3);
return result;
}
}
使用AOP处理请求或记录日志
- AOP面向切面 _编程范式(程序设计思想)
- 分离通用逻辑
1.引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2.具体切面代码
/**
* 日志写入管理
* zjy
*/
@Aspect
@Component
public class ControllerAspect {
private final static Logger logger = LoggerFactory.getLogger(ControllerAspect.class);
@Autowired
@Qualifier("logServiceImpl")
private LogService logService;
@Autowired
private UserService userService;
@Pointcut("execution(* com.honghe.managerTool.controller.CommandController.*(..)) "
+ "|| execution(* com.honghe.managerTool.controller.UserController.*(..)) ")
public void aspect() {//拦截所有类下所有方法
}
//配置前置通知,使用在方法aspect()上注册的切入点
@Before("aspect()")
public void before(JoinPoint joinPoint) {
String[] paramNames = ((CodeSignature) joinPoint
.getSignature()).getParameterNames();
Object[] paramValues = joinPoint.getArgs();
String userIp = "127.0.0.1";
String oprationName = joinPoint.getSignature().getName();
switch (oprationName){
case "start":
oprationName=Operation.START.value;
break;
case "stop":
oprationName=Operation.STOP.value;
break;
case "restart":
oprationName=Operation.RESTART.value;
break;
default:
return;
}
if(paramValues.length>0){
if(paramValues[0] instanceof HttpServletRequest){
HttpServletRequest request = (HttpServletRequest)paramValues[0];
userIp = ParamUtil.getIpAddress(request);
}
}
Log log = new Log(oprationName,new Date(),userIp,1);
logService.saveLog(log);
}
//配置后置通知,使用在方法aspect()上注册的切入点
@After("aspect()")
public void after(JoinPoint joinPoint){
logger.info("after out successfully");
}
}
对http请求解析
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
/**
* @author: zhaojianyu
* @create: 2018-10-11 09:11
**/
@Aspect
@Component
public class HttpAspect {
private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
/**
* 拦截所有类下所有方法
*/
@Pointcut("execution(* com.zjy.blog.blog_start.controller.HelloContraller.*(..)) ")
public void aspect() {
}
/**
* 配置前置通知,使用在方法aspect()上注册的切入点
*/
@Before("aspect()")
public void before(JoinPoint joinPoint) {
logger.info("方法开始执行"+new Date());
ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
//url
logger.info("url={}",request.getRequestURL());
logger.info("uri={}",request.getRequestURI());
//请求方法
logger.info("method={}",request.getMethod());
//请求ip地址
logger.info("ip={}",request.getRemoteAddr());
//类名 类方法
logger.info("class_method={}",joinPoint.getSignature().getDeclaringTypeName()+"="+joinPoint.getSignature().getName());
//参数
logger.info("args={}",joinPoint.getArgs());
}
@After("aspect()")
public void after() {
logger.info("方法执行完毕1"+new Date());
}
@AfterReturning(returning = "object",pointcut = "aspect()")
public void afterReturning(Object object) {
logger.info("方法执行完毕2"+new Date() + object);
}
}
统一异常处理
Error和Exception区分:
Error是编译时错误和系统错误,系统错误在除特殊情况下,都不需要你来关心,基本不会出现。而编译时错误,如果你使用了编译器,那么编译器会提示。
Exception则是可以被抛出的基本类型,我们需要主要关心的也是这个类。
Exception又分为RunTimeException和其他Exception。
RunTimeException和其他Exception区分:
其他Exception,受检查异常。可以理解为错误,必须要开发者解决以后才能编译通过,解决的方法有两种,1:throw到上层,2,try-catch处理。
RunTimeException:运行时异常,又称不受检查异常,不受检查!不受检查!!不受检查!!!重要的事情说三遍,因为不受检查,所以在代码中可能会有RunTimeException时Java编译检查时不会告诉你有这个异常,但是在实际运行代码时则会暴露出来,比如经典的1/0,空指针等。如果不处理也会被Java自己处理。
统一异常处理类
import com.honghe.managerTool.config.exception.MySecurityException;
import com.honghe.managerTool.entity.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* 全局处理异常
* @author zhaojianyu
* 2018 10 11
*/
/**
* @ControllerAdvice //处理所有
* @ControllerAdvice(annotations=RestController.class) //处理这个类下的异常
* @ControllerAdvice(basePackages={"com.honghe.managerTool.controller"}) //处理包下的异常
*/
@ControllerAdvice
public class GlobalExceptionHandler {
private Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
/**
* @ExceptionHandler(value={RuntimeException.class,MyRuntimeException.class}) //处理需要处理的异常类
* @ExceptionHandler //处理所有异常
* @ExceptionHandler(MySecurityException.class) //处理专门的异常
*/
@ResponseBody
@ExceptionHandler
public Result exceptionHandler(Exception e) {
if (e instanceof MySecurityException){
MySecurityException me = (MySecurityException)e;
//logger.error("权限异常",e);
return new Result(me.getCode(),false,e.getMessage());
}else if (e instanceof NullPointerException){
logger.error("空指针异常",e);
return new Result(-3,false,"空指针异常");
}else{
return new Result(-3,false,"异常");
}
}
}
自定义异常类
/**
* 权限验证异常
* @author zhaojianyu
*/
public class MySecurityException extends RuntimeException {
private Integer code;
/**
* 无参构造方法
*/
public MySecurityException(){
super();
}
/**
* 有参的构造方法
*/
public MySecurityException(String message,Integer code){
super(message);
this.code = code;
}
/**
* 用指定的详细信息和原因构造一个新的异常
*/
public MySecurityException(String message, Throwable cause){
super(message,cause);
}
/**
* 用指定原因构造一个新的异常
*/
public MySecurityException(Throwable cause) {
super(cause);
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
}
抛出自定义异常
throw new MySecurityException("请求超时,请同步服务器时间",-2);
返回值代码枚举类
/**
*
* 返回值枚举类
* @author: zhaojianyu
* @create: 2018-10-11 17:50
**/
public enum ResultEnum {
/**
* 异常信息
*/
UNKONW_ERROR(-1,"未知错误"),
SUCCESS(0,"请求成功"),
SECURITY_EXCEPTION(-2,"权限异常"),
PARAMS_EXCEPTION(-3,"权限异常")
;
private Integer code;
private String message;
ResultEnum() {
}
ResultEnum(Integer code, String message) {
this.code = code;
this.message = message;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}