[Java知识库]spring boot（2） 连接数据库

spring boot（2） 连接数据库

使用国产数据库连接池Druid

maven添加：

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

<!-- mysql依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!-- 连接池druid，一定要加版本不然下载依赖失败 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>

maven中有一个问题，自动生成项目的时候没有版本号，这里是报错的，说找不到依赖：

<build>
    <plugins>
        <plugin>
            <!-- 这里也要添加版本，与上面parent标签内版本一致就可以了 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.5.3</version>
        </plugin>
    </plugins>
</build>

在resources目录下新建application.yml：

spring:
  datasource:
    # 数据库访问配置, 使用druid数据源(默认数据源是HikariDataSource)
    type: com.alibaba.druid.pool.DruidDataSource
    #链接池配置
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/test_crm?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
      username: root
      password: root123456

      # 连接池配置：大小，最小，最大
      initial-size: 5
      min-idle: 5
      max-active: 20

      # 连接等待超时时间
      max-wait: 30000

      # 配置检测可以关闭的空闲连接，间隔时间
      time-between-eviction-runs-millis: 60000

      # 配置连接在池中的最小生存时间
      min-evictable-idle-time-millis: 300000
      # 检测连接是否有，有效得select语句
      validation-query: select '1' from dual
      # 申请连接的时候检测，如果空闲时间大于time-between-eviction-runs-millis，执行validationQuery检测连接是否有效，建议配置为true，不影响性能，并且保证安全性。
      test-while-idle: true
      # 申请连接时执行validationQuery检测连接是否有效，建议设置为false，不然会会降低性能
      test-on-borrow: false
      # 归还连接时执行validationQuery检测连接是否有效，建议设置为false，不然会会降低性能
      test-on-return: false

      # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
      # 打开PSCache，并且指定每个连接上PSCache的大小
      pool-prepared-statements: true
      max-open-prepared-statements: 20
      max-pool-prepared-statement-per-connection-size: 20

      # 配置监控统计拦截的filters, 去掉后监控界面sql无法统计, 'wall'用于防火墙防御sql注入，stat监控统计,logback日志
      filters: stat,wall
      # Spring监控AOP切入点，如x.y.z.service.*,配置多个英文逗号分隔
      #aop-patterns: com.springboot.servie.*
      # lowSqlMillis用来配置SQL慢的标准，执行时间超过slowSqlMillis的就是慢
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

      # WebStatFilter监控配置
      web-stat-filter:
        enabled: true
        # 添加过滤规则：那些访问拦截统计
        url-pattern: /*
        # 忽略过滤的格式：哪些不拦截，不统计
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'

      # StatViewServlet配置（Druid监控后台的Servlet映射配置，因为SpringBoot项目没有web.xml所在在这里使用配置文件设置）
      stat-view-servlet:
        enabled: true
        # 配置Servlet的访问路径：访问路径为/druid/**时，跳转到StatViewServlet，会自动转到Druid监控后台
        url-pattern: /druid/*
        # 是否能够重置数据
        reset-enable: false
        # 设置监控后台的访问账户及密码，URL为http://127.0.0.1:8080/druid
        login-username: root
        login-password: 123456
        # IP白名单：允许哪些主机访问，默认为“”任何主机
        # allow: 127.0.0.1
        # IP黑名单：禁止IP访问，（共同存在时，deny优先于allow）
        # deny: 192.168.1.218

      # 配置StatFilter
      filter:
        stat:
          log-slow-sql: true

启动项目，访问 http://localhost:8080/druid 用配置里的账号密码登入说明成功

使用MyBatis

不使用xml

maven

<!-- 整合mybatis -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>

流程(不使用xml)：

1. 先编写数据库表的类
2. 编写表操作的接口(使用@Mapper不需要写实现类了，使用@Repository注册到IOC)
3. 编写服务接口
4. 编写服务接口实现类(使用@Service注册注册到IOC，因为这里需要调用Mapper接口实现类实例，使用@Autowired获取实例)
5. 接口去调用服务接口实现类获取数据(这里也使用@Autowired获取服务接口实现类的实例)

目录:

• java
  • com.example.springboot01
    • controller
      • HelloController.java
      • GetPlayController.java(修改)
      • PostPlayController.java
    • ret
      • RetCode.java
      • RetResult.java
      • RetResponse.java
      • GlobalExceptionHandler.java
    • validation
      • PlayUserValidation.java
    • dto(数据库表对应类，新建)
      • Player.java(数据库表对应类，新建)
    • mapper(表操作接口与实现类，新建)
      • PlayerMapper.java(表操作接口与实现类，新建)
    • service(服务接口与实现类，新建)
      • PlayerService.java(服务接口，新建)
      • PlayerServiceImpl.java(服务接口实现类，新建)
    • Springboot01Application.java

Player.java 数据库表对应类：

package com.example.springboot01.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Player {
    private int player_id;
    private int team_id;
    private String player_name;
    private float height;
}

PlayerMapper.java 表操作接口与实现类：

package com.example.springboot01.mapper;
import com.example.springboot01.dto.Player;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
// @Mapper注解之后这个接口在编译时会生成相应的实现类
@Mapper
// @Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理，IOC管理
@Repository
public interface PlayerMapper {
    // 查询
    @Select("SELECT * FROM player WHERE player_id = #{id}")
    List<Player> selectPlayer(int id);
}

PlayerService.java 服务接口：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import java.util.List;
public interface PlayerService {
    List<Player> selectPlayer(int id);
}

PlayerServiceImpl.java 服务接口实现类：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import com.example.springboot01.mapper.PlayerMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
// @Service将类交给spring管理，IOC管理
@Service
public class PlayerServiceImpl implements PlayerService{
    // @Autowired bean自动装配，注入DAO层Mapper，IOC统一管理类，需要实例就从IOC中拿
    // PlayerMapper 使用了 @Repository 注册到IOC中，所以这里可以使用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerMapper playerMapper;
    @Override
    public List<Player> selectPlayer(int id) {
        return playerMapper.selectPlayer(id);
    }
}

GetPlayController.java 修改：

package com.example.springboot01.controller;
import com.example.springboot01.dto.Player;
import com.example.springboot01.ret.RetResponse;
import com.example.springboot01.ret.RetResult;
import com.example.springboot01.service.PlayerServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
// @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
// @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
@RestController
// 通过这里配置使下面的映射都在/play下
@RequestMapping("/play")
public class GetPlayController {
    // @GetMapping注释将 HTTP GET 请求映射到特定的处理程序方法。
    // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.GET)的快捷方式
    // 这个相当于二级路由，访问的是http://127.0.0.1:8080/play/
    @GetMapping("/")
    public String getPlays(){
        return "这是get请求";
    }
    // URL是http://127.0.0.1:8080/play/1，通过@PathVariable获取参数
    @GetMapping("/{id}")
    public String getPlay(@PathVariable("id") int id){
        return "id: "+id;
    }
    // URL是http://127.0.0.1:8080/play?id=1，通过@RequestParam获取参数
    // @RequestParam还可以有两个参数，required是否可以为空，defaultValue默认值
    // 可以有多个@RequestParam
    @GetMapping("")
    public String getPlay2(@RequestParam("id") int id){
        return "id2: "+id;
    }
    // 如果参数过多使用上面那样的方法显然比较麻烦，就可以使用map参数
    // URL是http://127.0.0.1:8080/play/user?id=1&name=hhh
    @GetMapping("/user")
    public String getPlayUser(@RequestParam Map<String, Object> params){
        return "name: "+params.get("name")+" id: "+params.get("id");
    }
    // 可以接受数据参数
    // URL是http://127.0.0.1:8080/play/users?ids=1&ids=2&ids=3
    @GetMapping("/users")
    public String getPlayUser2(@RequestParam int[] ids){
        String str = "";
        for(int id: ids){
            System.out.println(id);
            str = str + "id"+id+": "+id+" ";
        }
        return str;
    }
    // 注入Service
    // 因为PlayerServiceImpl使用了@Service注册到IOC中，所以这里可以用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerServiceImpl playerServiceImpl;
    // get请求还可以接收对象参数
    @GetMapping("/player")
    public RetResult<Object> getPlayers(@RequestParam int id){
        List<Player> players= playerServiceImpl.selectPlayer(id);
        return RetResponse.success(players);
    }
}

URL是 http://127.0.0.1:8080/play/player?id=10001

结果：

{
    "code": 200,
    "msg": "success",
    "data": [
        {
            "player_id": 10001,
            "team_id": 1001,
            "player_name": "韦恩-艾灵顿",
            "height": 1.93
        }
    ]
}

使用xml

流程(使用xml)：

1. 添加yaml配置
2. 先编写数据库表的类
3. 编写表操作的接口(使用@Mapper不需要写实现类了，使用@Repository注册到IOC)
4. 编写表操作的xml文件
5. 编写服务接口
6. 编写服务接口实现类(使用@Service注册注册到IOC，因为这里需要调用Mapper接口实现类实例，使用@Autowired获取实例)
7. 接口去调用服务接口实现类获取数据(这里也使用@Autowired获取服务接口实现类的实例)

步骤一：application.yml 添加如下内容：

# MyBatis配置
mybatis:
  # 配置别名，表类所在的包
  type-aliases-package: com.example.springboot01.dto

  configuration:
    # 打印sql语句和返回结果
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 配置启用驼峰命名自动转换
    # 这里有一个问题，比如我的类字段没有用驼峰命名而是和数据库一样的形式，启动这个以后会发现字段找不到，返回null
    # map-underscore-to-camel-case: true
  # 配置XML扫描地址
  mapper-locations:
    - classpath:mapper/*.xml

# 设置日志显示：在控制台打印SQL，如果上面mybatis设置了log-impl，这就会失效，而且这个不返回sql结果
logging:
  level:
    # 以包名前置，表示指定包下的操作指定日志级别。
    # 这里是mapper所在的包
    com.example.springboot01.mapper: DEBUG

步骤二已经有了还是用Player类

步骤三：修改PlayerMapper.java 添加一个新的查询：

import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
// @Mapper注解之后这个接口在编译时会生成相应的实现类
@Mapper
// @Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理，IOC管理
@Repository
public interface PlayerMapper {
    // 查询
    @Select("SELECT * FROM player WHERE player_id = #{id}")
    List<Player> selectPlayer(int id);
    // 查询多个id
    // 这里一定要加 @Param 不然会报错说找不到参数
    List<Player> selectPlayerList(@Param("ids") int[] ids);
}

步骤四：添加表操作的xml：
在 resources 目录下新建 mapper 目录，然后新建 PlayerMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 绑定mapper -->
<mapper namespace= "com.example.springboot01.mapper.PlayerMapper">
    <select id = "selectPlayerList" resultType = "com.example.springboot01.dto.Player">
        SELECT * FROM player
        WHERE player_id IN
        <foreach item="item" index="index" collection="ids"
                 open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>
</mapper>

步骤五和六：修改服务接口和实现类
PlayerService.java：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import java.util.List;
public interface PlayerService {
    List<Player> selectPlayer(int id);
    List<Player> selectPlayerList(int[] ids);
}

PlayerServiceImpl.java：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import com.example.springboot01.mapper.PlayerMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
// @Service将类交给spring管理，IOC管理
@Service
public class PlayerServiceImpl implements PlayerService{
    // @Autowired bean自动装配，注入DAO层Mapper，IOC统一管理类，需要实例就从IOC中拿
    // PlayerMapper 使用了 @Repository 注册到IOC中，所以这里可以使用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerMapper playerMapper;
    @Override
    public List<Player> selectPlayer(int id) {
        return playerMapper.selectPlayer(id);
    }
    @Override
    public List<Player> selectPlayerList(int[] ids) {
        return playerMapper.selectPlayerList(ids);
    }
}

步骤七：修改请求，GetPlayController.java：

package com.example.springboot01.controller;
import com.example.springboot01.dto.Player;
import com.example.springboot01.ret.RetResponse;
import com.example.springboot01.ret.RetResult;
import com.example.springboot01.service.PlayerServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
// @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
// @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
@RestController
// 通过这里配置使下面的映射都在/play下
@RequestMapping("/play")
public class GetPlayController {
    // @GetMapping注释将 HTTP GET 请求映射到特定的处理程序方法。
    // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.GET)的快捷方式
    // 这个相当于二级路由，访问的是http://127.0.0.1:8080/play/
    @GetMapping("/")
    public String getPlays(){
        return "这是get请求";
    }
    // URL是http://127.0.0.1:8080/play/1，通过@PathVariable获取参数
    @GetMapping("/{id}")
    public String getPlay(@PathVariable("id") int id){
        return "id: "+id;
    }
    // URL是http://127.0.0.1:8080/play?id=1，通过@RequestParam获取参数
    // @RequestParam还可以有两个参数，required是否可以为空，defaultValue默认值
    // 可以有多个@RequestParam
    @GetMapping("")
    public String getPlay2(@RequestParam("id") int id){
        return "id2: "+id;
    }
    // 如果参数过多使用上面那样的方法显然比较麻烦，就可以使用map参数
    // URL是http://127.0.0.1:8080/play/user?id=1&name=hhh
    @GetMapping("/user")
    public String getPlayUser(@RequestParam Map<String, Object> params){
        return "name: "+params.get("name")+" id: "+params.get("id");
    }
    // 可以接受数据参数
    // URL是http://127.0.0.1:8080/play/users?ids=1&ids=2&ids=3
    @GetMapping("/users")
    public String getPlayUser2(@RequestParam int[] ids){
        String str = "";
        for(int id: ids){
            System.out.println(id);
            str = str + "id"+id+": "+id+" ";
        }
        return str;
    }
    // 注入Service
    // 因为PlayerServiceImpl使用了@Service注册到IOC中，所以这里可以用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerServiceImpl playerServiceImpl;
    // get请求还可以接收对象参数
    @GetMapping("/player")
    public RetResult<Object> getPlayers(@RequestParam int id){
        List<Player> players= playerServiceImpl.selectPlayer(id);
        return RetResponse.success(players);
    }
    // URL是http://127.0.0.1:8080/play/playlist?ids=10001&ids=10002
    @GetMapping("/playlist")
    public RetResult<Object> getPlayerList(@RequestParam int[] ids){
        List<Player> players= playerServiceImpl.selectPlayerList(ids);
        return RetResponse.success(players);
    }
}

URL是 http://127.0.0.1:8080/play/playlist?ids=10001&ids=10002

结果：

{
    "code": 200,
    "msg": "success",
    "data": [
        {
            "player_id": 10001,
            "team_id": 1001,
            "player_name": "韦恩-艾灵顿",
            "height": 1.93
        },
        {
            "player_id": 10002,
            "team_id": 1001,
            "player_name": "雷吉-杰克逊",
            "height": 1.91
        }
    ]
}

开启事务

在服务接口中需要事务的方法上添加 @Transactional

写一个新增的例子：
流程：

1. 因为post请求验证，先给表类的字段加上验证
2. mapper接口增加表操作方法
3. xml添加表操作sql
4. 服务接口添加方法，给方法添加 @Transactional，开启事务
5. 服务实现类方法重写
6. post请求修改

第一步：给表的字段添加验证：
Player.java：

package com.example.springboot01.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
import javax.validation.constraints.*;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Player {
    private int player_id;
    @NotNull(message = "球队ID不能为空")
    private int team_id;
    @Length(max = 3, message = "队员名字长度不能超过3")
    @NotBlank(message = "队员名字不能为空")
    private String player_name;
    @Min(value = 1, message = "身高不能小于1")
    @Max(value = 3, message = "身高不能超过3")
    @NotNull(message = "身高不能为空")
    private float height;
}

第二步：mapper编写：
PlayerMapper.java：

package com.example.springboot01.mapper;
import com.example.springboot01.dto.Player;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
// @Mapper注解之后这个接口在编译时会生成相应的实现类
@Mapper
// @Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理，IOC管理
@Repository
public interface PlayerMapper {
    // 查询
    @Select("SELECT * FROM player WHERE player_id = #{id}")
    List<Player> selectPlayer(int id);
    // 查询多个id
    // 这里一定要加 @Param 不然会报错说找不到参数
    List<Player> selectPlayerList(@Param("ids") int[] ids);
    // 新增，用int，插入成功后会显示条数
    int addPlayers(Player player);
}

第三步：添加xml的sql：
PlayerMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 绑定mapper -->
<mapper namespace= "com.example.springboot01.mapper.PlayerMapper">
    <select id = "selectPlayerList" resultType = "com.example.springboot01.dto.Player">
        SELECT * FROM player
        WHERE player_id IN
        <foreach item="item" index="index" collection="ids"
                 open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>
    <insert id="addPlayers" useGeneratedKeys="true" keyProperty="player_id" parameterType="com.example.springboot01.dto.Player">
        INSERT INTO player VALUES(null,#{team_id},#{player_name},#{height})
    </insert>
</mapper>

第四步：编写服务接口，并在需要开启事务的方法上使用@Transactional开启事务：
PlayerService.java：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
public interface PlayerService {
    List<Player> selectPlayer(int id);
    List<Player> selectPlayerList(int[] ids);
    // 事务管理
    @Transactional
    int addPlayers(Player player);
}

第五步：服务接口实现类编写：
PlayerServiceImpl.java：

package com.example.springboot01.service;
import com.example.springboot01.dto.Player;
import com.example.springboot01.mapper.PlayerMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
// @Service将类交给spring管理，IOC管理
@Service
public class PlayerServiceImpl implements PlayerService{
    // @Autowired bean自动装配，注入DAO层Mapper，IOC统一管理类，需要实例就从IOC中拿
    // PlayerMapper 使用了 @Repository 注册到IOC中，所以这里可以使用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerMapper playerMapper;
    @Override
    public List<Player> selectPlayer(int id) {
        return playerMapper.selectPlayer(id);
    }
    @Override
    public List<Player> selectPlayerList(int[] ids) {
        return playerMapper.selectPlayerList(ids);
    }
    @Override
    public int addPlayers(Player player) {
        return playerMapper.addPlayers(player);
    }
}

第六步：post请求：
PostPlayController.java：

package com.example.springboot01.controller;
import com.example.springboot01.dto.Player;
import com.example.springboot01.service.PlayerServiceImpl;
import com.example.springboot01.validation.PlayUserValidation;
import com.example.springboot01.ret.RetResponse;
import com.example.springboot01.ret.RetResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
// @RestController 是 @Controller 和 @ResponseBody 两个注解的结合体
// @Controller声明是一个控制器，@ResponseBody的作用其实是将java对象转为json格式的数据
@RestController
// 通过这里配置使下面的映射都在/play下
@RequestMapping("/postplay")
public class PostPlayController {
    // @PostMapping注释将 HTTP POST 请求映射到特定的处理程序方法。
    // 它是一个组合的注释，用作@RequestMapping(method = RequestMethod.POST)的快捷方式
    // URL是http://127.0.0.1:8080/postplay
    @PostMapping("")
    // @RequestParam就是前端的表单参数，form-data参数
    // 和get一样@RequestParam也可以单个参数，多个参数，数组参数，设置默认值，是否为空，这里不演示
    public String postPlay(@RequestParam Map<String, Object> params){
        return "id: "+params.get("id")+" name: "+params.get("name");
    }
    // URL是http://127.0.0.1:8080/postplay/
    @PostMapping("/")
    // 如果把 json 作为参数传递，我们可以使用 @RequestBody 接收参数，将数据转换 Map
    public String postPlay1(@RequestBody Map<String, Object> params){
        return "id: "+params.get("id")+" name: "+params.get("name");
    }
    // post也可以接收对象为参数
    // put，delete能使用@PathVariable，@RequestParam和@RequestBody

    // URL是http://127.0.0.1:8080/postplay/user
    // 测试参数：{"id":1,"userName":"hhhh","nickName":"xxx","email":"xxxqq.com"}
    @PostMapping("/user")
    // @Validated 使用校验，BindingResult校验结果类可以获取失败信息
    // 有了全局处理就可以去掉BindingResult结果类参数和错误处理
    public RetResult<Object> postPlayUser(@RequestBody @Validated PlayUserValidation user){
        return RetResponse.success(user);
    }
    // 注入Service
    // 因为PlayerServiceImpl使用了@Service注册到IOC中，所以这里可以用@Autowired从IOC中拿类的实例
    @Autowired
    PlayerServiceImpl playerServiceImpl;
    // URL是http://127.0.0.1:8080/postplay/addplayer
    // 参数是{ "team_id":"1001", "player_name":"SSS", "height":1.98 }
    @PostMapping("/addplayer")
    public RetResult<Object> addPlayer(@RequestBody @Validated Player player){
        int playNum = playerServiceImpl.addPlayers(player);
        if(playNum>0){
            return RetResponse.success("添加成功");
        }else{
            return RetResponse.error("添加失败");
        }
    }
}

URL是 http://127.0.0.1:8080/postplay/addplayer
参数是：

{
	"team_id":"1001",
	"player_name":"SSS",
	"height":1.98
}