SpringBoot进阶之Web进阶

其他 2018-09-23 06:23:11 阅读次数: 0
版权声明：作者已开启版权声明，如转载请注明转载地址。 https://blog.csdn.net/qq_34829447/article/details/82777930

一.表单验证

1.为要校验的对象添加对应的校验注解

  • 使用@Min(value=18,message="未成年少女金之入内")标记对应类中的属性。注解表示age最小值为18，错误提示为：未成年少女禁止入内

  • Girl类实例代码

    package com.study.demo.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.constraints.Min;

@Entity
public class Girl{
    @Id
    @GeneratedValue
    private Integer id;
    private String cupSize;

    //表示age最小值为18，错误提示为：未成年少女禁止入内
    @Min(value=18,message = "未成年少女禁止入内")
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCupSize() {
        return cupSize;
    }

    public void setCupSize(String cupSize) {
        this.cupSize = cupSize;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "id=" + id +
                ", cupSize='" + cupSize + '\'' +
                ", age=" + age +
                '}';
    }
}

2.在对应方法的入参中使用@Vaild注解标记该对应需要被验证，并通过BindingResult类型参数接受验证结果

  • 结果对象的hasErrors()方法用于判断是否发生错误

  • 结果对象的getFieldError().getDefaultMessage()方法获得对应的错误信息

  • 对应方法的实例代码

    //新增女生
@PostMapping(value="/girls")
public Girl girlAdd(@Valid Girl girl, BindingResult bindingResult){//@Valid注解表示要验证的对象为girl,验证结果会返回到参数bindingResult对象中
    //通过对象的hasErrors()方法获得是否发生错误
    if(bindingResult.hasErrors()){
        //并通过getFieldError().getDefaultMessage()方法获得对应的错误信息
        System.out.println(bindingResult.getFieldError().getDefaultMessage());
        return null;
    }
    girl.setCupSize(girl.getCupSize());
    girl.setAge(girl.getAge());
    return girlRepository.save(girl);//方法返回的就是添加的对象
}

  • 当发送post请求时，若cupSize属性超过18则会在控制台输出“未成年少女禁止入内”，并返回null值

二.AOP统一处理请求日志

1.什么是AOP？

  • AOP是一种编程范式，与语言无关，是一种程序设计思想
  • 面向切面（AOP）Aspect Oriented Programming:将通用逻辑从业务逻辑中分离出来
  • 面向对象（OOP）Object Oriented Programming
  • 面向过程（POP）Procedure Oriented Programming

2.网络请求的生命周期

收到HttpRequest请求 —> 记录请求 —> 处理网络请求 —> 生成HttpResponse —> 记录回复

3.操作数据库的生命周期

收到数据库操作请求 —> 记录请求 —> 增删改查 —> 生成处理结果 —> 记录回复

4.记录每一个http请求

  • 添加依赖

    <dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

  • 建立处理文件：aspect/HttpAspect.java

    import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
@Aspect//标记类为Aspect类
@Component//引入到Spring容器中
public class HttpAspect {

    //org.slf4j.Logger是Spring自带的日志记录框架
    private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);

    @Pointcut("execution(public * com.study.demo.controller.HelloController.girlList(..))")//.girlList(..)表示girlList方法不管是任何参数都会被拦截;.*(..)则表示该类的所有方法都会被拦截
    public void log(){

    }

    //定义在http请求到方法之前将内容记录下来
    @Before("log()")
    public void doBefore(){
        logger.info("记录日志");//使用Logger的方法记录日志
    }

    //定义在执行完方法后调用
    @After("log()")
    public void doAfter(){
        logger.info("执行方法之后的调用...");
    }
}

  • 访问接口时的显示内容(可以看出使用logger.info()方法打印的内容带有时间等相关信息)

    2018-09-19 12:58:55.250  INFO 44464 --- [nio-8082-exec-2] com.study.demo.aspect.HttpAspect         : 记录日志
2018-09-19 12:58:55.253  INFO 44464 --- [nio-8082-exec-2] c.study.demo.controller.HelloController  : 执行到GirlList
2018-09-19 12:58:55.280  INFO 44464 --- [nio-8082-exec-2] o.h.h.i.QueryTranslatorFactoryInitiator  : HHH000397: Using ASTQueryTranslatorFactory
Hibernate: select girl0_.id as id1_0_, girl0_.age as age2_0_, girl0_.cup_size as cup_size3_0_ from girl girl0_
2018-09-19 12:58:55.364  INFO 44464 --- [nio-8082-exec-2] com.study.demo.aspect.HttpAspect         : 执行方法之后的调用...

  • 调整@Before注解的方法执行指定内容

    @Before("log()")
public void doBefore(JoinPoint joinPoint){
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = attributes.getRequest();
    //url
    logger.info("url={}",request.getRequestURL());
    //method
    logger.info("method={}",request.getMethod());
    //客户端的ip
    logger.info("ip={}",request.getRemoteAddr());
    //请求的类方法,通过当前类的参数传入的JoinPoint对象获取对应的内容
    //joinPoint.getSignature().getDeclaringTypeName()获取的是类名
    //joinPoint.getSignature().getName()获取类方法名
    logger.info("class_method={}",joinPoint.getSignature().getDeclaringTypeName()+"."+joinPoint.getSignature().getName());
    //参数
    logger.info("args={}",joinPoint.getArgs());
}

  • 通过@AfterReturning注解获得方法返回的内容

    //参数1为方法的入参变量名，参数2为使用的连接点方法名
@AfterReturning(returning="object",pointcut="log()")
//返回的内容可以是很多，但是对于程序而言他们都是对象
public void doAfterReturning(Object object){
    logger.info("response={}",object);
}

  • 访问接口时显示的内容

    2018-09-19 13:20:31.876  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : url=http://localhost:8082/girls
2018-09-19 13:20:31.876  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : method=GET
2018-09-19 13:20:31.876  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : ip=0:0:0:0:0:0:0:1
2018-09-19 13:20:31.878  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : class_method=com.study.demo.controller.HelloController.girlList
2018-09-19 13:20:31.878  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : args={}
2018-09-19 13:20:31.882  INFO 44599 --- [nio-8082-exec-1] c.study.demo.controller.HelloController  : 执行到GirlList
2018-09-19 13:20:31.911  INFO 44599 --- [nio-8082-exec-1] o.h.h.i.QueryTranslatorFactoryInitiator  : HHH000397: Using ASTQueryTranslatorFactory
Hibernate: select girl0_.id as id1_0_, girl0_.age as age2_0_, girl0_.cup_size as cup_size3_0_ from girl girl0_
2018-09-19 13:20:31.991  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : 执行方法之后的调用...
2018-09-19 13:20:31.991  INFO 44599 --- [nio-8082-exec-1] com.study.demo.aspect.HttpAspect         : response=[]

三.统一异常处理

统一异常处理的实例

  • 定义统一异常返回对象/src/main/java/com/study/demo/domain/Result.java

    package com.study.demo.domain;
/**
 * Http请求返回的最外层对象
 */
public class Result<T> {
    /* 错误码 */
    private Integer code;
    /* 提示信息 */
    private String msg;
    /* 具体内容 */
    private T data;
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

  • 定义错误对象生成工具方法/src/main/java/com/study/demo/utils/ResultUtil.java

    package com.study.demo.utils;
import com.study.demo.domain.Result;
public class ResultUtil {
    public static Result success(Object object){
        Result result = new Result();
        result.setCode(0);
        result.setMsg("成功");
        result.setData(object);
        return result;
    }
    public static Result success(){
        return success(null);
    }
    public static Result error(Integer code,String msg){
        Result result = new Result();
        result.setCode(code);
        result.setMsg(msg);
        result.setData(null);
        return result;
    }
}

  • 自定义异常，用于传递对应的错误编号/src/main/java/com/study/demo/exception/GirlException.java

    package com.study.demo.exception;
import com.study.demo.enums.ResultEnum;
public class GirlException extends RuntimeException {
    private Integer code;
    public GirlException(ResultEnum resultEnum){
        super(resultEnum.getMsg());
        this.code = resultEnum.getCode();
    }
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
}

  • 定义异常处理内容，在方法抛出异常时执行的对应处理方法/src/main/java/com/study/demo/handle/ExceptionHandle.java

    package com.study.demo.handle;
import com.study.demo.domain.Result;
import com.study.demo.exception.GirlException;
import com.study.demo.utils.ResultUtil;
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;
@ControllerAdvice
public class ExceptionHandle {
    public static final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
    //声明要捕获哪个异常类
    @ExceptionHandler(value = Exception.class)
    //由于要返回的是一个json，但是类上方又没有@RestController注解，故需要用ResponseBody修饰
    @ResponseBody
    public Result handle(Exception e){
        if(e instanceof GirlException){
            GirlException girlException = (GirlException)e;
            return ResultUtil.error(girlException.getCode(),girlException.getMessage());
        }else{
            logger.error("[系统异常]{}",e);
            return ResultUtil.error(-1,"未知错误");
        }
    }
}

  • 在Controller中添加判断对象年龄并抛出异常测试方法/src/main/java/com/study/demo/controller/HelloController.java

    package com.study.demo.controller;

import com.study.demo.domain.Girl;
import com.study.demo.domain.Result;
import com.study.demo.repository.GirlRepository;
import com.study.demo.service.GirlService;
import com.study.demo.utils.ResultUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.bind.BindResult;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;
import java.util.Optional;

@RestController
public class HelloController {

    public final static Logger logger = LoggerFactory.getLogger(HelloController.class);

    @Autowired
    private GirlRepository girlRepository;
    @Autowired
    public GirlService girlService;

    //查询所有女生列表
    @GetMapping(value="/girls")
    public List<Girl> girlList(){
        logger.info("执行到GirlList");
        return girlRepository.findAll();
    }

    //新增女生
    @PostMapping(value="/girls")
    public Result girlAdd(@Valid Girl girl, BindingResult bindingResult){//@Valid注解表示要验证的对象为girl,验证结果会返回到参数bindingResult对象中
        //通过对象的hasErrors()方法获得是否发生错误
        if(bindingResult.hasErrors()){
            return ResultUtil.error(1,bindingResult.getFieldError().getDefaultMessage());
        }
        girl.setCupSize(girl.getCupSize());
        girl.setAge(girl.getAge());
        return ResultUtil.success(girlRepository.save(girl));//方法返回的就是添加的对象
    }

    //查询一个女生
    @GetMapping(value="/girls/{id}")
    public Optional<Girl> girlFindOne(@PathVariable("id")Integer id){
        Optional<Girl> girl = girlRepository.findById(id);
        return girl;
    }

    //更新
    @PutMapping(value="/girls/{id}")
    public Girl girlUpdate(@PathVariable("id")Integer id,@RequestParam("cupSize")String cupSize,@RequestParam("age")Integer age){
        Girl girl = new Girl();
        girl.setId(id);
        girl.setCupSize(cupSize);
        girl.setAge(age);
        return girlRepository.save(girl);
    }

    //删除
    @DeleteMapping(value="/girls/{id}")
    public void girlDelete(@PathVariable("id")Integer id){
        girlRepository.deleteById(id);
    }

    //通过年龄查询女生列表
    @GetMapping(value="/girls/age/{age}")
    public List<Girl>girlListByAge(@PathVariable("age")Integer age){
        return girlRepository.findByAge(age);
    }

    //添加两条数据
    @PostMapping(value="/girls/two")
    public void girlTwo(){
        girlService.insertTwo();
    }

    //判断对象年龄并抛出异常测试方法
    @GetMapping(value = "girls/getAge/{id}")
    public void getAge(@PathVariable("id")Integer id) throws Exception{
        girlService.getAge(id);
    }
}

  • 在service中添加对应处理方法，针对不同情况的age内容抛出不同错误码的异常/src/main/java/com/study/demo/service/GirlService.java

    package com.study.demo.service;
import com.study.demo.domain.Girl;
import com.study.demo.enums.ResultEnum;
import com.study.demo.exception.GirlException;
import com.study.demo.repository.GirlRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
@Service
public class GirlService {
    @Autowired
    private GirlRepository girlRepository;
    //添加@Transactional事务注解
    @Transactional
    public void insertTwo(){
        Girl girlA = new Girl();
        girlA.setCupSize("A");
        girlA.setAge(18);
        girlRepository.save(girlA);

        Girl girlB = new Girl();
        girlB.setCupSize("Fffffff");
        girlB.setAge(19);
        girlRepository.save(girlB);
    }
    public void getAge(Integer id) throws GirlException{
        Optional<Girl> girl = girlRepository.findById(id);
        Integer age = girl.get().getAge();
        if(age<10){
            //返回你还在上小学吧——使用枚举的形式获得
            throw new GirlException(ResultEnum.PRIMARY_SCHOOL);
        }else if(age>=10&&age<16){
            //返回你可能在上初中
            throw new GirlException(ResultEnum.MIDDLE_SCHOOL);
        }
    }
}

  • 定义枚举类型，将错误编号与错误信息统一管理/src/main/java/com/study/demo/enums/ResultEnum.java

    package com.study.demo.enums;
//使用枚举将错误编号与错误信息统一管理
public enum ResultEnum {
    UNKOWN_ERROR(-1,"未知错误"),
    SUCCESS(0,"成功"),
    PRIMARY_SCHOOL(100,"你可能在上小学~"),
    MIDDLE_SCHOOL(101,"你可能在上初中~")
    ;
    private Integer code;
    private String msg;
    //枚举的使用基本上不用set方法，而使用构造方法
    ResultEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    public Integer getCode() {
        return code;
    }
    public String getMsg() {
        return msg;
    }
}

四.单元测试

1.对service进行测试方式一：创建/src/test/java/com/study/demo/GirlServiceTest.java文件编写findOneTest方法进行测试

  • 在GirlService中编写需要测试的方法

    package com.study.demo.service;
import com.study.demo.domain.Girl;
import com.study.demo.enums.ResultEnum;
import com.study.demo.exception.GirlException;
import com.study.demo.repository.GirlRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
@Service
public class GirlService {
    @Autowired
    private GirlRepository girlRepository;
    //添加@Transactional事务注解
    @Transactional
    public void insertTwo(){
        Girl girlA = new Girl();
        girlA.setCupSize("A");
        girlA.setAge(18);
        girlRepository.save(girlA);

        Girl girlB = new Girl();
        girlB.setCupSize("Fffffff");
        girlB.setAge(19);
        girlRepository.save(girlB);
    }
    public void getAge(Integer id) throws GirlException{
        Optional<Girl> girl = girlRepository.findById(id);
        Integer age = girl.get().getAge();
        if(age<10){
            //返回你还在上小学吧
            throw new GirlException(ResultEnum.PRIMARY_SCHOOL);
        }else if(age>=10&&age<16){
            //返回你可能在上初中
            throw new GirlException(ResultEnum.MIDDLE_SCHOOL);
        }
    }
    /**
     * 通过Id查询一个女生的信息
     */
    public Optional<Girl> findOne(Integer id){
        return girlRepository.findById(id);
    }
}

  • 编写GirlServiceTest方法进行测试(右击Run on findOneTest进行执行)

    package com.study.demo;
import com.study.demo.domain.Girl;
import com.study.demo.service.GirlService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Optional;
//表示当前是在测试环节里面跑的，底层使用JUnit测试工具
@RunWith(SpringRunner.class)
//将启动整个Spring的工程
@SpringBootTest
public class GirlServiceTest {
    @Autowired
    private GirlService girlService;
    @Test
    public void findOneTest(){
        Optional<Girl> girl = girlService.findOne(4);
        //断言的方式判断，要求参数都是Object
        Assert.assertEquals(new Integer(16),girl.get().getAge());
    }
}

2.对service进行测试方法二：利用IDEA生成对应的测试方法

  • 在对应需要测试的方法上右击 -> Go To -> Test ->Create new Test -> 选择要测试的方法 -> OK
  • 系统会自动在test包下创建对应包即测试文件

3.对controller进行测试

  • 使用IDEA执行右击 -> Go To -> Test ->Create new Test -> 选择要测试的方法 -> OK生成对应的测试文件

  • 在测试文件类上不仅要添加@RunWith(SpringRunner.class)和@SpringBootTest注解，还要添加@AutoConfigurationMockMvc注解标注是controller的测试类，并使用MockMvc对象的perform方法进行相关测试内容的设置

    package com.study.demo.controller;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import static org.junit.Assert.*;
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {
    @Autowired
    private MockMvc mvc;
    @Test
    public void girlList() throws Exception{
        mvc.perform(MockMvcRequestBuilders.get("/girls"))//Get方法，请求地址为/girls
                .andExpect(MockMvcResultMatchers.status().isOk())//表示期望返回的状态码为200
                .andExpect(MockMvcResultMatchers.content().string("abc"));//表示期望返回的是abc字符串
    }
}

4.执行mvn clean package进行打包的时候会自动执行对应的单元测试

  • 如果单元测试用例测试不通过则提示报错信息，打包失败
  • 如果单元测试用例测试通过则没有错误信息，打包成功
  • 当我们打包时希望不执行单元测试时，需要使用命令mvn clean package -Dmaven.test.skip=true跳过单元测试

猜你喜欢

转载自blog.csdn.net/qq_34829447/article/details/82777930
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022