@RequestParam("cupSize") String cupSize,
@RequestParam("age") Integer age

/**
 * 新增一个女生
 * http://localhost:8081/girl/girls
 * 注意：post请求
 *
 * 参数
 * cupSize  f
 * age  16
 *
 * 插入因为自增注意id冲突
 */
@PostMapping(value = "/girls")
public Girl girlAdd(Girl girl){
    girl.setCupSize(girl.getCupSize());
    girl.setAge(girl.getAge());
    //save返回添加对对象
    return repository.save(girl);
}

@Min(value = 18, message = "未成年少女禁止入内")
private Integer age;

/**
 * 新增一个女生
 * http://localhost:8081/girl/girls
 * 注意：post请求
 *
 * 参数
 * cupSize  f
 * age  16
 *
 * 插入因为自增注意id冲突
 */
@PostMapping(value = "/girls")
//@Valid表示要验证的是这个对象 BindingResult返回验证信息
public Girl girlAdd(@Valid Girl girl, BindingResult bindingResult){
    //判断是否发生错误
    if (bindingResult.hasErrors()){
        //打印错误信息
        System.out.println(bindingResult.getFieldError().getDefaultMessage());
        return null;
    }
    girl.setCupSize(girl.getCupSize());
    girl.setAge(girl.getAge());
    //save返回添加对对象
    return repository.save(girl);
}

package com.bennyrhys.girl.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect //aop标识
@Component //添加到容器
public class HttpAspect {
    //拦截方法：加两个..表示任何参数都会被拦截
    @Before("execution(public * com.bennyrhys.girl.controller.GirlController.girlList(..))")
    //先定方法不然没上方提示
    public void log(){
        System.out.println("llllllll");
    }
}

@Before("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")

package com.bennyrhys.girl.aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect //aop标识
@Component //添加到容器
public class HttpAspect {
    //@Before方法执行之前就执行了
    //拦截方法：加两个..表示任何参数都会被拦截
    @Before("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")
    //先定方法不然没上方提示
    public void log(){
        System.out.println("llllllll");
    }


    @After("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")
    //先定方法不然没上方提示
    public void doAfter(){
        System.out.println("22222222");
    }
}

/**
 * 查询所有女生列表
 * @return
 * http://localhost:8081/girl/girls
 * [
 *     {
 *         "id": 1,
 *         "cupSize": "B",
 *         "age": 18
 *     }
 * ]
 */
@GetMapping(value = "/girls")
public List<Girl> girlList(){
    System.out.println("girlList测试检测顺序");
    return repository.findAll();
}

package com.bennyrhys.girl.aspect;

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.springframework.stereotype.Component;

@Aspect //aop标识
@Component //添加到容器
public class HttpAspect {
    //提取公共方法
    //拦截方法：加两个..表示任何参数都会被拦截
    @Pointcut("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")
    //先定方法不然没上方提示
    public void log(){
        System.out.println("1111");
    }

    //@Before方法执行之前就执行了
    @Before("log()")
    public void doBefore(){
        System.out.println("11111111");
    }


    @After("log()")
    //先定方法不然没上方提示
    public void doAfter(){
        System.out.println("22222222");
    }
}

package com.bennyrhys.girl.aspect;

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 //aop标识
@Component //添加到容器
public class HttpAspect {

    //日志输出slf4j
    private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);


    //提取公共方法
    //拦截方法：加两个..表示任何参数都会被拦截
    @Pointcut("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")
    //先定方法不然没上方提示
    public void log(){
    }

    //@Before方法执行之前就执行了
    @Before("log()")
    public void doBefore(){
        logger.info("111111111");
    }


    @After("log()")
    //先定方法不然没上方提示
    public void doAfter(){
        logger.info("222222222");
    }
}

//日志输出slf4j
private final static Logger logger = LoggerFactory.getLogger(GirlController.class);
        logger.info("girlList测试检测顺序");

package com.bennyrhys.girl.aspect;

import org.aspectj.lang.JoinPoint;
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;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

@Aspect //aop标识
@Component //添加到容器
public class HttpAspect {

    //日志输出slf4j 注意类名切换
    private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);


    //提取公共方法
    //拦截方法：加两个..表示任何参数都会被拦截
    @Pointcut("execution(public * com.bennyrhys.girl.controller.GirlController.*(..))")
    //先定方法不然没上方提示
    public void log(){
    }

    //@Before方法执行之前就执行了
    @Before("log()")
    public void doBefore(JoinPoint joinPoint){
        //此处强转
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        //import javax.servlet.http.HttpServletRequest;
        HttpServletRequest request = attributes.getRequest();
        //url
        logger.info("url={}", request.getRequestURL());
        //method
        logger.info("method={}",request.getMethod());
        //ip
        logger.info("ip={}",request.getRemoteAddr());
        //类方法 参数传入doBefore(JoinPoint joinPoint)
        //类名：getDeclaringTypeName类方法：getName
        logger.info("class_method={}", joinPoint.getSignature().getDeclaringTypeName()+"."+joinPoint.getSignature().getName());
        //参数
        logger.info("args={}", joinPoint.getArgs());
    }


    @After("log()")
    //先定方法不然没上方提示
    public void doAfter(){
        logger.info("222222222");
    }
}

//日志获取响应信息
//入参：returning 注意：toString方法，否则输出是对象
@AfterReturning(returning = "object", pointcut = "log()")
public void doAfterReturning(Object object){
    logger.info("response={}", object.toString());
}

package com.bennyrhys.girl.domain;

/**
 * http请求返回对最外层对象
 */
//get/set
public class Result<T> {//具体内容用范型表示
    //错误码
    private Integer code;
    //提示信息
    private String msg;
    //具体内容
    private T data;
}

/**
 * 新增一个女生
 * http://localhost:8081/girl/girls
 * 注意：post请求
 *
 * 参数
 * cupSize  f
 * age  16
 *
 * 插入因为自增注意id冲突
 */
@PostMapping(value = "/girls")
//@Valid表示要验证的是这个对象 BindingResult返回验证信息
public Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult){
    //判断是否发生错误
    if (bindingResult.hasErrors()){
        //打印错误信息
        Result result = new Result();
        result.setCode(1);
        result.setMsg(bindingResult.getFieldError().getDefaultMessage());
        result.setData(null);
        return result;
    }
    girl.setCupSize(girl.getCupSize());
    girl.setAge(girl.getAge());
    //save返回添加对对象

    Result result =  new Result();
    result.setCode(0);
    result.setMsg("成功");
    result.setData(repository.save(girl));
    return result;
}

package com.bennyrhys.girl.utils;

import com.bennyrhys.girl.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);
        return  result;
    }
}

/**
 * 新增一个女生
 * http://localhost:8081/girl/girls
 * 注意：post请求
 *
 * 参数
 * cupSize  f
 * age  16
 *
 * 插入因为自增注意id冲突
 */
@PostMapping(value = "/girls")
//@Valid表示要验证的是这个对象 BindingResult返回验证信息
public Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult){
    //判断是否发生错误
    if (bindingResult.hasErrors()){
        //打印错误信息
        return ResultUtil.error(1,bindingResult.getFieldError().getDefaultMessage());
    }
    girl.setCupSize(girl.getCupSize());
    girl.setAge(girl.getAge());
    //save返回添加对对象

    return ResultUtil.success(repository.save(girl));
}

/**
 * 获取女生年龄做判断
 * 【   ，10），返回“应该在上小学”
 *
 * 【10，16），返回“可能在上初中”
 */
public void getAge(Integer id)throws Exception{
    Optional<Girl> optional = repository.findById(id);
    if (optional.isPresent()){
        Girl girl = optional.get();
        Integer age = girl.getAge();
        if(age < 10){
            //【    ，10），返回“应该在上小学”
            throw new Exception("应该在上小学");

        }else if (age >= 10 && age <16){
            //【10，16），返回“可能在上初中”
            throw new Exception("可能在上初中");

        }
    }
}

/**
 * 获取女生年龄做判断
 * 【   ，10），返回“应该在上小学”
 *
 * 【10，16），返回“可能在上初中”
 */
@GetMapping(value = "/girls/getAge/{id}")
public void getAge(@PathVariable("id") Integer id)throws Exception{
    //逻辑在service中判断
    service.getAge(id);
}

package com.bennyrhys.girl.handle;

import com.bennyrhys.girl.domain.Result;
import com.bennyrhys.girl.utils.ResultUtil;
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 {
    //声明捕获哪个类
    @ExceptionHandler(value = Exception.class)
    @ResponseBody //因为要返回给浏览器，上面又没写@restcontroller
    public Result handle(Exception e){
        return ResultUtil.error(100,e.getMessage());
    }
}

package com.bennyrhys.girl.exception;

/**
 * 重写Exception-多状态码
 *
 * 注意：
 * 继承RuntimeException
 * 因为spring事务回滚针对RuntimeException，而RuntimeException继承Exception。
 * Exception不回滚
 */
public class GirlException extends RuntimeException{
    private Integer code;
    //get/set/构造

    public GirlException(Integer code,String message) {
        //添加字段message，父类本身就会传一个message进去
        super(message);
        this.code = code;
    }


    public Integer getCode() {
        return code;
    }

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

/**
 * 获取女生年龄做判断
 * 【   ，10），返回“应该在上小学”
 *
 * 【10，16），返回“可能在上初中”
 */
public void getAge(Integer id)throws Exception{
    Optional<Girl> optional = repository.findById(id);
    if (optional.isPresent()){
        Girl girl = optional.get();
        Integer age = girl.getAge();
        if(age < 10){
            //【    ，10），返回“应该在上小学”
            throw new GirlException(100,"应该在上小学");

        }else if (age >= 10 && age <16){
            //【10，16），返回“可能在上初中”
            throw new GirlException(101,"可能在上初中");

        }
    }
}

package com.bennyrhys.girl.handle;

import com.bennyrhys.girl.domain.Result;
import com.bennyrhys.girl.exception.GirlException;
import com.bennyrhys.girl.utils.ResultUtil;
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 {
    //声明捕获哪个类
    @ExceptionHandler(value = Exception.class)
    @ResponseBody //因为要返回给浏览器，上面又没写@restcontroller
    public Result handle(Exception e){
        //捕获时，判断一下异常是否是自己定义的GirlException
        if (e instanceof GirlException){
            GirlException girlException = (GirlException) e;
            return ResultUtil.error(girlException.getCode(),girlException.getMessage());
        }else {
            return ResultUtil.error(-1,"未知错误");
        }
    }
}

//日志
private final static Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);

//将未知异常通过日志排除
            logger.error("[系统异常]={}",e);

package com.bennyrhys.girl.handle;

import com.bennyrhys.girl.domain.Result;
import com.bennyrhys.girl.exception.GirlException;
import com.bennyrhys.girl.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 {
    //日志
    private final static Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);

    //声明捕获哪个类
    @ExceptionHandler(value = Exception.class)
    @ResponseBody //因为要返回给浏览器，上面又没写@restcontroller
    public Result handle(Exception e){
        //捕获时，判断一下异常是否是自己定义的GirlException
        if (e instanceof GirlException){
            GirlException girlException = (GirlException) e;
            return ResultUtil.error(girlException.getCode(),girlException.getMessage());
        }else {
            //将未知异常通过日志排除
            logger.error("[系统异常]={}",e);
            return ResultUtil.error(-1,"未知错误");
        }
    }
}

package com.bennyrhys.girl.enums;

/**
 * 管理异常code和msg-枚举
 * 注意：枚举类型文件
 */
public enum ResultEnum {
    UNKNOW_ERROR(-1,"未知错误"),
    SUCCESS(0,"成功"),
    PRIMARY_SCHOOL(100,"可能小学"),
    MIDDLE_SCHOOL(101,"可能中学"),
    ;
    private Integer code;
    private String msg;
//    构造方法（两个参数），只get方法(因为枚举都是直接用构造方法创建，不用再set了)

    ResultEnum(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

if(age < 10){
    //【    ，10），返回“应该在上小学”
    throw new GirlException(ResultEnum.PRIMARY_SCHOOL);

}else if (age >= 10 && age <16){
    //【10，16），返回“可能在上初中”
    throw new GirlException(ResultEnum.MIDDLE_SCHOOL);

}

public GirlException(ResultEnum resultEnum) {
    //添加字段message，父类本身就会传一个message进去
    super(resultEnum.getMsg());
    this.code = resultEnum.getCode();
}

/**
 * 测试service
 * 通过id查询一个女生信息并返回
 */
public Girl findOne(Integer id){
    Optional<Girl> optional = repository.findById(id);
    if (optional.isPresent()){
        Girl girl = optional.get();
        return girl;
    }
    return null;
}

package com.bennyrhys.girl;

import com.bennyrhys.girl.domain.Girl;
import com.bennyrhys.girl.service.GirlService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.Assert;

@SpringBootTest //启动整个spring工程
public class GirlServiceTest {
    @Autowired
    private GirlService girlService;

    @Test
    public void findOneTest(){
        Girl girl = girlService.findOne(3);
      //断言比较，测试通过 新版本适用Assertions
        Assertions.assertEquals(9,girl.getAge());
    }
}

package com.bennyrhys.girl.service;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 自动创建的测试unit5
 */
class GirlServiceTest {

    @Test
    void findOne() {
    }
}

package com.bennyrhys.girl.controller;

import org.junit.jupiter.api.Test;
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.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
@AutoConfigureMockMvc //检测api
class GirlControllerTest {

    @Autowired
    private GirlController girlController;
    @Autowired
    private MockMvc mvc;

    @Test
    void girlList() throws Exception {
//        不是这样测试，这样测试没有报错，但没检测到api及请求类型
//        girlController.girlList();
        mvc.perform(MockMvcRequestBuilders.get("/girls"))
                .andExpect(MockMvcResultMatchers.status().isOk()) //期望返回状态码200，测试通过
                .andExpect(MockMvcResultMatchers.content().string("abc")); //期望返回string=abc，测试肯定不通过
/**
 * 检测abc返回，控制台输出
 * Expected :abc
 * Actual   :[{"id":3,"cupSize":"G","age":9},{"id":4,"cupSize":"G","age":15},{"id":5,"cupSize":"F","age":22},{"id":6,"cupSize":"F","age":16},{"id":7,"cupSize":"F","age":16},{"id":8,"cupSize":"C","age":22},{"id":9,"cupSize":"C","age":20},{"id":10,"cupSize":"C","age":18},{"id":11,"cupSize":"D","age":19},{"id":12,"cupSize":"D","age":18},{"id":13,"cupSize":"D","age":18},{"id":14,"cupSize":"D","age":18},{"id":15,"cupSize":"D","age":18}]
 */
    }
}

package com.bennyrhys.girl;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

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

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    //通过注解获取配置中的属性
    @Value("${cupSize}")
    private String cupSize;
    @Value("${age}")
    private Integer age;
    @Value("${content}")
    private String content;


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

package com.bennyrhys.girl;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

//对应配置文件的girl
@ConfigurationProperties(prefix = "girl")
//注入配置
@Component
public class GirlConfig {
    private String cupSize;
    private Integer age;

    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;
    }
}

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;



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

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@Controller
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;



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

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
//@ResponseBody
@Controller
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;


    @ResponseBody
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String say(){
        return girlConfig.getCupSize()+girlConfig.getAge();
//        return "index";
    }
}

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/say")
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;


    @RequestMapping(value = {"/hello","/hi"}, method = RequestMethod.GET)
    public String say(){
        return girlConfig.getCupSize()+girlConfig.getAge();
//        return "index";
    }
}

@RequestMapping(value = {"/hello","/hi"}, method = RequestMethod.POST)

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/say")
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;

    @RequestMapping(value = {"/hi"}, method = RequestMethod.GET)
    public String say(@RequestParam("id") Integer myid){
//        return girlConfig.getCupSize()+girlConfig.getAge();
        return "id："+myid;
    }
}

//required = false 是否必传
public String say(@RequestParam(value = "id", required = false, defaultValue = "0") Integer myid){

//    @RequestMapping(value = {"/hi"}, method = RequestMethod.GET)
    @GetMapping(value = "/hi")

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/say")
public class HelloController {
    //通过注解获取配置:类中的属性
    @Autowired
    private GirlConfig girlConfig;

//    @RequestMapping(value = {"/hi"}, method = RequestMethod.GET)
    @GetMapping(value = "/hi")

    public String say(@RequestParam(value = "id", required = false, defaultValue = "0") Integer myid){
//        return girlConfig.getCupSize()+girlConfig.getAge();
        return "id："+myid;
    }
}

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

//表示对应数据库对表
@Entity
public class Girl {
    @Id //指定唯一id
    @GeneratedValue  //自增
    private Integer id;
    private String cupSize;
    private Integer age;

package com.bennyrhys.girl;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

/**
 * dao
 * 注意命名，继承jpa，参数<字段类，唯一id类型>
 * extends JpaRepository<Girl,Integer>
 */
public interface GirlRepository extends JpaRepository<Girl,Integer> {
    //通过年龄来查询，方法名有讲究
    public List<Girl> findByAge(Integer age);
}

package com.bennyrhys.girl;

import com.sun.org.apache.regexp.internal.RE;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
public class GirlController {

    @Autowired
    private GirlRepository repository;

    /**
     * 查询所有女生列表
     * @return
     * http://localhost:8081/girl/girls
     * [
     *     {
     *         "id": 1,
     *         "cupSize": "B",
     *         "age": 18
     *     }
     * ]
     */
    @GetMapping(value = "/girls")
    public List<Girl> girlList(){
        return repository.findAll();
    }
    /**
     * 新增一个女生
     * http://localhost:8081/girl/girls
     * 注意：post请求
     *
     * 参数
     * cupSize  f
     * age  16
     *
     * 插入因为自增注意id冲突
     */
    @PostMapping(value = "/girls")
    public Girl girlAdd(@RequestParam("cupSize") String cupSize,
                          @RequestParam("age") Integer age){
        Girl girl = new Girl();
        girl.setCupSize("F");
        girl.setAge(16);
        //save返回添加对对象
        return repository.save(girl);
    }
    /**
     * 通过id查询一个女生
     * @return
     * http://localhost:8081/girl/girl/2
     * {
     *     "id": 2,
     *     "cupSize": "F",
     *     "age": 16
     * }
     */
    @GetMapping(value = "/girls/{id}")
    public Girl girlFindById(@PathVariable("id") Integer id){
        return repository.findById(id).orElse(null);

    }

    /**
     * 更新某个id女生基因信息
     * http://localhost:8081/girl/girls/2
     * 参数
     * cupSize  G
     * age  22
     *
     * {
     *     "id": 2,
     *     "cupSize": "G",
     *     "age": 22
     * }
     */
    @PutMapping(value = "/girls/{id}")
    public Girl updateGirl(@PathVariable("id") Integer id,
                           @RequestParam("cupSize") String cupSize,
                           @RequestParam("age") Integer age){
        Optional<Girl> optional = repository.findById(id);
        if (optional.isPresent()){
            Girl girl = optional.get();
            girl.setAge(age);
            girl.setCupSize(cupSize);
            return girl;
        }
        return null;
    }
    /**
     *删除某个id女生的信息
     * http://localhost:8081/girl/girls/2
     * 2
     */
    @DeleteMapping(value = "/girls/{id}")
    public Integer deleteGirlById(@PathVariable("id") Integer id){
        Optional<Girl> optional = repository.findById(id);
        if (optional.isPresent()){
            Girl girl = optional.get();
            repository.delete(girl);
            return id;
        }
        return null;
    }
    /**
     * 通过年龄查询女生列表
     * 先自定义dao方法
     * http://localhost:8081/girl/girls/age/16
     * [
     *     {
     *         "id": 3,
     *         "cupSize": "F",
     *         "age": 16
     *     },
     *     {
     *         "id": 4,
     *         "cupSize": "g",
     *         "age": 16
     *     },
     */
    @GetMapping("/girls/age/{age}")
    public List<Girl> girlListByAge(@PathVariable("age") Integer age){
        return repository.findByAge(age);
    }


}

package com.bennyrhys.girl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class GirlService {
    @Autowired
    private GirlRepository repository;

    @Transactional //保证同时发生的注解，spring版
    public void changgeTwo(){
        Girl girl = new Girl();
        girl.setId(3);
        girl.setAge(20);
        girl.setCupSize("G");
        repository.save(girl);

        Girl girl2 = new Girl();
        girl2.setId(4);
        girl2.setAge(20);
        girl2.setCupSize("G");
        repository.save(girl2);
    }
}

/**
 * 触发事务
 * 同时改变基因cupSize
 * http://localhost:8081/girl/girls/two
 * 数据发生改变
 */
@PostMapping(value = "/girls/two")
public void girlsTwo(){
    service.changgeTwo();
}

package com.bennyrhys.luckymoney;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
//    @GetMapping("/hello")
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public  String hello(){
        return "hello world";
    }
}