spring boot学习笔记

[TOC]

spring boot

• 特点：
  • 1、化繁为简，简化配置
  • 2、备受关注，是下一代框架
  • 3、微服务的入门级微框架

RequestMapping若要能使用多个路径访问同一个方法，可以在value={"/hello1", "/hello2"}

Spring-Data-Jpa:JPA定义了一系列对象持久化的标准，目前实现这一规范的产品有hibernate、TopLink等

NOTE:
1、前置知识：利用maven构建项目，Spring注解、RESTful API
2.不需要去学SpringMVC
3.Java、Maven等版本保持一致

Springboot的创建

在idea中用Spring Initializr进行创建

项目配置

方法一：
在application.properties中添加

<!--port代表端口号，context-path代表url前面的前缀-->
server.port=8081
server.context-path=/girl

方法二：
创建一个application.yml文件添加

server:
  context-path: /girl
  port: 8082

如何将配置文件中的属性注入进变量中去

方法一：使用Value注解

配置文件：application.yml

server:
  port: 8080
cupSize: B

NOTE:这里cupSize属性要和server并列，不然会报错

java文件：HelloController.java

  @Value("${cupSize}")
    private String cupSize;

    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String say(){
        return cupSize;
    }

@value：将配置文件中的属性值注入到属性中

方法二：使用类对象

配置文件： applivation.yml

girl:
  cupSize: B
  age: 18

对象类:GirlProperties

@Component
@ConfigurationProperties(prefix = "girl")
public class GirlProperties {
    private  String cupSize;
    private  Integer age;

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

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

    public String getCupSize() {
        return cupSize;
    }

    public Integer getAge() {
        return age;
    }
  }

NOTE:@ConfigurationProperties(prefix = "girl")：获取前缀是girl的配置
@Component：表示与配置文件中的信息进行匹配，把普通pojo实例化到spring容器中

controller:

@RestController
public class HelloController {
@Autowired
 private GirlProperties girlProperties;

    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String say(){
        return girlProperties.getCupSize();
    }
}

多环境配置

环境一：application-dev.yml

server:
  port: 8080
girl:
  cupSize: B
  age: 18

环境二：application-prod.yml

server:
  port: 8080
girl:
  cupSize: F
  age: 18

在 applicatin.yml中配置

Spring:
    profiles:
        active:dev

可以根据active的不同使用不同的环境

Controller的使用

@Controller:处理http请求
@RestController: Spring4之后新加的注解，原来返回json需要@ResponseBody配合@Controller
@RequestMapping:配置url映射

如何处理url中的参数

@PathVariable 获取url中的数据 （请求中为restful类型请求：/hello/${id}）
@RequestParam 获取请求参数的值 （正常请求：/hello?id=23）
@GetMapping 组合注解 (@GetMapping(value="/say")相当于@RequestMapping(value = "/say",method = RequestMethod.GET))

数据库操作

Spring-Data-Jpa
JPA(Java Persistence API)：定义了一系列对象持久化的标准，目前实现这一规范的产品有Hibernate、TopLink等

创建表

pom.xml文件引入依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.24</version>
        </dependency>

Note:mysql的版本控制，如果太高会报错

application.yml文件配置数据源和jpa

  datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/dbgirl
        username: root
        password:
  jpa:
      hibernate:
           ddl-auto: create
      show-sql: true

Note:datasource:连接数据库
ddl-auto:
creat表示不管数据库是不是有这张表都会重新创建
update：第一次运行会创建表，以后创建如果表中有数据会保留数据
create-drop:应用在停下来的时候会将表删除
none:什么都不做
validate:表中字段与实体类中对应，如果有不一样的会报错
show-sql:显示sql语句

Girl实体类:

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

    private String cupSize;

    private  Integer age;
    //下面是get set方法以及空构造
}

Note:@Entity:jpa特性，表示实体类与数据库对应的表
@Id：主键
@GeneratedValue：自动生成

API接口开发

请求类型 请求路径 功能
GET /girls 获取女生列表
POST /girls 创建一个女生
GET /girls/id 通过id查询一个女生
PUT /girls/id 通过id更新一个女生
DELETE /girls/id 通过id删除一个女生

创建一个接口继承Jpa

public interface GirlRepository extends JpaRepository<Girl,Integer>{

    //通过年龄来查询
    public List<Girl> findByAge(Integer age);
}

创建出controller

@RestController
public class GirlController{

    @Autowired
    private GirlRepository girlRepository;

    /*
    查询所有的女生列表
     */
    @GetMapping(value = "/girls")
    public List<Girl> girlList(){

        List<Girl> girlList = girlRepository.findAll();

        return  girlList;
    }
    /*
    添加一个女生
     */
    @PostMapping(value = "/girls")
    public Girl girlAdd(@RequestParam("cupSize") String cupSize,@RequestParam("age") Integer age){
        Girl girl = new Girl();
        girl.setAge(age);
        girl.setCupSize(cupSize);
        return girlRepository.save(girl);
    }

    /**
     * 查询一个女生
     * @param id
     * @return
     */
    @GetMapping(value = "/girls/{id}")
    public Girl girlFindOne(@PathVariable("id") Integer id){
        return girlRepository.findOne(id);
    }

    /**
     * 更新女生信息
     * @param id
     * @param cupSize
     * @param age
     * @return
     */
    @PutMapping("/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);
    }

    /**
     * 删除女生信息
     * @param id
     */
    @DeleteMapping(value = "/girls/{id}")
    public void girlDelete(@PathVariable("id") Integer id){
        girlRepository.delete(id);
    }

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

}

Note:注入时注意idea的spring注解管理是否为warning

save在有id时候为更新，无主键id时候为添加

事务管理

  @Transactional
    public void  insertTwo(){
        Girl girlA = new Girl();
        girlA.setCupSize("B");
        girlA.setAge(18);
        girlRepository.save(girlA);

        Girl girlB = new Girl();
        girlB.setCupSize("Cccc");
        girlB.setAge(19);
        girlRepository.save(girlB);
    }

在方法上面添加一个transational注解表示启动事务管理

spring boot进阶之web进阶

表单验证

Controller方法中使用对象接收前台数据，在对象对应的类中需要验证的属性上添加比如：@Min 注解

@Min(value = 18, message = "未成年人止步")
private Integer age;

这里value表示年龄最小值应为18，小于18的验证不通过，message为验证不通过时提示的信息

Controller方法中形参前面添加@Valid注解，使用BindingResult接收提示信息

@PostMapping("/boys")
public Boy addBoy(@Valid Boy boy, BindingResult bindingResult) {
    // 如果有错误信息，即验证不通过时
    if (bindingResult.hasErrors()) {
        // 后台输出错误提示信息
        System.out.println(bindingResult.getFieldError().getDefaultMessage());
        // 返回null到前台
        return null;
    }
    return boyRepository.save(boy);
}

使用AOP处理请求

概念

AOP（面向切面编程）是一种编程范式，与语言无关，是一种程序设计思想

OOP（面向对象编程） POP（面向过程编程）

面向过程强调流程和规划，面向对象将需求功能垂直地划分为不同的，并且相对独立的，会将其封装成不同的类，让它们有自己的行为。

AOP的关键思想是将通用逻辑从业务逻辑中分离出来

运用

在maven的pom.xml中添加aop依赖

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

第一种方法：

使用sop在控制台输出记录的日志信息

@Aspect
@Component
public class BoyAspect {
    // 公用空方法，使用注解配置切入点，提高重用性
    @Pointcut("execution(public * com.lfy.BoyController.*(..))")
    public void log() {}


    // 前置增强，也可以直接在里面写execution
    @Before("log()")
    public void doBefore() {
        // 使用sop在控制台输出记录的日志信息
        System.out.println("doBefore");
    }

    // 最终增强
    @After("log()")
    public void doAfter() {
        System.out.println("doAfter");
    }
}

第二种方法：

使用LoggerFactory的getLogger方法获取Logger对象，调用其info方法在控制台输出记录的日志信息

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;

@Aspect
@Component
public class BoyAspect {
    private final static Logger logger = LoggerFactory.getLogger(BoyAspect.class);

    @Pointcut("execution(public * com.lfy.BoyController.*(..))")
    public void log() {}

    @Before("log()")
    public void doBefore(JoinPoint joinPoint) {、
        // 获取HttpServletRequest对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 输出相应信息
        // url
        logger.info("url={}", request.getRequestURI());
        // 请求方式
        logger.info("method={}", request.getMethod());
        // 请求的ip地址
        logger.info("ip={}", request.getRemoteAddr());
        // 请求调用的方法（调用JoinPoint的方法）
        logger.info("class.method={}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        // 请求调用的方法的参数（调用JoinPoint的方法）
        logger.info("args={}", joinPoint.getArgs());
    }

    // 后置增强
    @AfterReturning(pointcut="log()", returning = "object")
    public void doAfterReturning(Object object) {
        // 输出响应信息
        logger.info("response={}", object);
    }

    @After("log()")
    public void doAfter() {
        logger.info("doAfter");
    }
} 

统一异常处理

传给前台的数据格式的统一

自定义Result类，因为返回的data数据的类型未知，故使用泛型

public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    // ...
}

Result工具类

public class ResultUtil {
    // 成功并返回data数据
    public static Result success(Object object) {
        Result result = new Result();
        result.setCode(0);
        result.setMessage("成功");
        result.setData(object);
        return result;
    }
    // 成功不返回data数据
    public static Result success() {
        return success(null);
    }

    // 失败
    public static Result error(Integer code, String message) {
        Result result = new Result();
        result.setCode(code);
        result.setMessage(message);
        return result;
    }
}

统一异常处理示例

枚举类的使用，没有set方法，因为枚举类型通过构造方法赋值

public enum ResultEnums {
    UNKNOWN_ERROR(-1, "未知错误"),
    SUCCESS(0, "成功"),
    PRIMARY_SCHOOL(101, "小学"),
    MIDDLE_SCHOOL(102, "中学");

    private Integer code;
    private String message;

    ResultEnums(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }
    public String getMessage() {
        return message;
    }
}

自定义异常，这里继承RuntimeException而不继承Exception是因为spring框架针对RuntimeException才会回滚

public class BoyException extends RuntimeException {
    private Integer code;

    public Integer getCode() {
        return code;
    }

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

    // 直接通过枚举类获取信息
    public BoyException(ResultEnums resultEnums) {
        super(resultEnums.getMessage());
        this.code = resultEnums.getCode();
    }
}

异常处理类

通过@ControllerAdvice注解可以将对于控制器的全局配置放在同一个位置。

注解了@ControllerAdvice的类的方法可以使用@ExceptionHandler等等注解到方法上。

@ControllerAdvice注解将作用在所有注解了@RequestMapping的控制器的方法上。

@ExceptionHandler：用于全局处理控制器里的异常。

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 {
    private static final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);

    @ExceptionHandler(value=Exception.class)
    @ResponseBody
    public Result handle(Exception e) {
        if (e instanceof BoyException) {
            BoyException boyException = (BoyException) e;
            return ResultUtil.error(boyException.getCode(), boyException.getMessage());
        }
        logger.info("系统异常={}", e);
        return ResultUtil.error(-1, "未知错误");
    }
}

service使用自定义异常和枚举类

public void getAge(Integer id) throws Exception {
        Boy boy = boyRepository.findOne(id);
        Integer age = boy.getAge();
        if (age <= 10) {
            throw new BoyException(ResultEnums.PRIMARY_SCHOOL);
        } else if (age <= 16 ) {
            throw new BoyException(ResultEnums.MIDDLE_SCHOOL);
        }
    }

controller，throws Exception使得处理异常返回的结果返回给前台

@GetMapping(value="/boys/getAge/{id}")
public void getAge(@PathVariable("id") Integer id) throws Exception {
    boyService.getAge(id);
}

单元测试

测试service

@RunWith(SpringRunner.class)
@SpringBootTest
public class BoyServiceTest {
    @Autowired
    private BoyService boyService;
    
    @Test
    public void findAllBoy() throws Exception {
        List<Boy> allBoy = boyService.findAllBoy();
        // 此处使用断言进行测试，前者是预期结果，后者是测试结果
        Assert.assertEquals(new Integer(7), allBoy.get(0).getAge());
    }
}

测试结果与预期结果不一致，控制台提示：1 test failed

java.lang.AssertionError:

Expected :8

Actual :7

一致，提示：1 test passed

测试API

添加@AutoConfigureMockMvc注解，使用MockMvc对象进行测试

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class BoyControllerTest {
    @Autowired
    private MockMvc mvc;

    @Test
    public void findAllBoy() throws Exception {
        // 测试访问路径
        mvc.perform(MockMvcRequestBuilders.get("/boys"))
                // 测试响应码是否是200（成功）
                .andExpect(MockMvcResultMatchers.status().isOk())
                // 测试响应的内容
                .andExpect(MockMvcResultMatchers.content().string("123"));
    }
}