spring boot（2）连接数据库

「爱情、让人受尽委屈。」 2022-09-06 04:55 217阅读 0赞

# spring boot（2） 连接数据库 #

### 使用国产数据库连接池Druid ###

maven添加：

<dependency>
    <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.21</version>
    </dependency>

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

<build>
        <plugins>
            <plugin>
                
                <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

<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 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：

PlayerServiceImpl.java：

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

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：

第四步：编写服务接口，并在需要开启事务的方法上使用@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：

第六步：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
    }