SpringBoot整合Druid实现数据库连接池和监控

布满荆棘的人生 2021-09-02 03:51 500阅读 0赞

# 1、Druid的简介 #

Druid是Java语言中使用的比较多的数据库连接池。Druid还提供了强大的监控和扩展功能。下面将介绍SpringBoot整合Druid实现数据库连接池和监控功能。

> **官方文档：**[《Druid官方文档》][Druid]

# 2、创建SpringBoot项目与数据表 #

**【实例】**SpringBoot整合Druid实现数据库连接池和监控，使用MyBaits操作数据库，获取用户信息，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70][]

## 2.1 创建项目 ##

**（1）创建SpringBoot项目，项目结构如下图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1][]

**（2）使用Maven添加依赖文件**

在pom.xml配置信息文件中，添加Druid连接池、MyBatis、MySQL数据库、Thymeleaf模板引擎等相关依赖：

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.23</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
    
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.20</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

## 2.2 创建数据表 ##

使用MySQL数据库，创建 tb\_user 用户信息表，并添加数据。

-- 判断数据表是否存在，存在则删除
    DROP TABLE IF EXISTS tb_user;
     
    -- 创建“用户信息”数据表
    CREATE TABLE IF NOT EXISTS tb_user
    ( 
    	user_id INT AUTO_INCREMENT PRIMARY KEY COMMENT '用户编号',
    	user_name VARCHAR(50) NOT NULL COMMENT '用户姓名',
    	age INT DEFAULT(0) NOT NULL COMMENT '年龄',
    	blog_url VARCHAR(50) NOT NULL COMMENT '博客地址',
    	blog_remark VARCHAR(50) COMMENT '博客信息'
    ) COMMENT = '用户信息表';
     
    -- 添加数据
    INSERT INTO tb_user(user_name,age,blog_url,blog_remark) VALUES('pan_junbiao的博客',32,'https://blog.csdn.net/pan_junbiao','您好，欢迎访问 pan_junbiao的博客');

# 3、Druid实现数据库连接池 #

## 3.1 Druid的配置 ##

在 application.yml 配置文件中配置Druid数据库连接池和监控、MyBatis配置。

#Spring配置
    spring:
      #使用Thymeleaf模板引擎
      thymeleaf:
        mode: HTML5
        encoding: UTF-8
        cache: false  #使用Thymeleaf模板引擎，关闭缓存
        servlet:
          content-type: text/html
      #JDBC配置
      datasource:
        url: jdbc:mysql://localhost:3306/db_admin?useSSL=false&amp
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
        type: com.alibaba.druid.pool.DruidDataSource
        #Druid连接池配置
        druid:
          initial-size: 5 #初始化时建立物理连接的个数
          max-active: 30 #最大连接池数量
          min-idle: 5 # 最小连接池数量
          druid.max-wait: 60000 #获取连接时最大等待时间，单位毫秒
          time-between-eviction-runs-millis: 60000 #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
          min-evictable-idle-time-millis: 300000 #连接保持空闲而不被驱逐的最小时间
          validation-query: select 'x' #用来检测连接是否有效的sql 必须是一个查询语句：mysql中为 select 'x' oracle中为 select 1 from dual
          test-while-idle: true #建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
          test-on-borrow: false #申请连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
          test-on-return: false #归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
          pool-prepared-statements: true #是否缓存preparedStatement,mysql5.5+建议开启
          max-pool-prepared-statement-per-connection-size: 50 #要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
          filters: stat,wall #配置监控统计拦截的filters，去掉后监控界面sql无法统计
          connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500 #通过connectProperties属性来打开mergeSql功能；慢SQL记录
          use-global-data-source-stat: true #合并多个DruidDataSource的监控数据
          #StatViewServlet配置
          stat-view-servlet.enabled: true #是否启用StatViewServlet（监控页面）默认值为false
          stat-view-servlet.login-username: admin #设置访问druid监控页的账号,默认没有
          stat-view-servlet.login-password: admin #设置访问druid监控页的密码,默认没有
    
    #MyBatis配置
    mybatis:
      type-aliases-package: com.pjb.entity #别名定义
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #指定 MyBatis 所用日志的具体实现，未指定时将自动查找
        map-underscore-to-camel-case: true #开启自动驼峰命名规则（camel case）映射
        lazy-loading-enabled: true #开启延时加载开关
        aggressive-lazy-loading: false #将积极加载改为消极加载（即按需加载）,默认值就是false
        #lazy-load-trigger-methods: "" #阻挡不相干的操作触发，实现懒加载
        cache-enabled: true #打开全局缓存开关（二级环境），默认值就是true

> **注意：**druid的配置节点是在datasource节点之下的，节点的层级关系不要写错了。

## 3.2 创建实体类（Entity层） ##

在com.pjb.entity包中，创建UserInfo类（用户信息实体类）。

package com.pjb.entity;
    
    import java.io.Serializable;
    
    /**
     * 用户信息实体类
     * @author pan_junbiao
     **/
    public class UserInfo
    {
        private int userId; //用户编号
        private String userName; //用户姓名
        private int age; //年龄
        private String blogUrl; //博客地址
        private String blogRemark; //博客信息
    
        //省略getter与setter方法...
    }

## 3.3 数据库映射层（Mapper层） ##

在com.pjb.mapper包中，创建UserMapper接口（用户信息Mapper动态代理接口）。

package com.pjb.mapper;
    
    import com.pjb.entity.UserInfo;
    import org.apache.ibatis.annotations.*;
    import org.springframework.stereotype.Repository;
    
    /**
     * 用户信息Mapper动态代理接口
     * @author pan_junbiao
     **/
    @Mapper
    @Repository
    public interface UserMapper
    {
        /**
         * 根据用户ID，获取用户信息
         */
        @Select("SELECT * FROM tb_user WHERE user_id = #{userId}")
        public UserInfo getUserById(int userId);
    
        /**
         * 新增用户，并获取自增主键
         */
        @Insert("INSERT INTO tb_user(user_name,age,blog_url,blog_remark) VALUES(#{userName},#{age},#{blogUrl},#{blogRemark});")
        @Options(useGeneratedKeys = true, keyColumn = "user_id", keyProperty = "userId")
        public int insertUser(UserInfo userInfo);
    
        /**
         * 修改用户
         */
        @Update("UPDATE tb_user SET user_name = #{userName} ,age = #{age} ,blog_url = #{blogUrl} ,blog_remark = #{blogRemark} WHERE user_id = #{userId}")
        public int updateUser(UserInfo userInfo);
    
        /**
         * 删除用户
         */
        @Delete("DELETE FROM tb_user WHERE user_id = #{userId}")
        public int deleteUser(int userId);
    }

## 3.4 业务逻辑层（Service层） ##

在com.pjb.service包下，创建UserService接口（用户信息业务逻辑接口）。

package com.pjb.service;
    
    import com.pjb.entity.UserInfo;
    
    /**
     * 用户信息业务逻辑接口
     * @author pan_junbiao
     **/
    public interface UserService
    {
        /**
         * 根据用户ID，获取用户信息
         */
        public UserInfo getUserById(int userId);
    
        /**
         * 新增用户，并获取自增主键
         */
        public UserInfo insertUser(UserInfo userInfo);
    
        /**
         * 修改用户
         */
        public UserInfo updateUser(UserInfo userInfo);
    
        /**
         * 删除用户
         */
        public int deleteUser(int userId);
    }

在com.pjb.service.impl包下，创建UserServiceImpl类（用户信息业务逻辑类）。

package com.pjb.service.impl;
    
    import com.pjb.entity.UserInfo;
    import com.pjb.mapper.UserMapper;
    import com.pjb.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    /**
     * 用户信息业务逻辑类
     * @author pan_junbiao
     **/
    @Service
    @Transactional
    public class UserServiceImpl implements UserService
    {
        @Autowired
        private UserMapper userMapper;
    
        /**
         * 根据用户ID，获取用户信息
         */
        @Override
        public UserInfo getUserById(int userId)
        {
            return userMapper.getUserById(userId);
        }
    
        /**
         * 新增用户，并获取自增主键
         */
        @Override
        public UserInfo insertUser(UserInfo userInfo)
        {
            userMapper.insertUser(userInfo);
            return userInfo;
        }
    
        /**
         * 修改用户
         */
        @Override
        public UserInfo updateUser(UserInfo userInfo)
        {
            userMapper.updateUser(userInfo);
            return userInfo;
        }
    
        /**
         * 删除用户
         */
        @Override
        public int deleteUser(int userId)
        {
            return userMapper.deleteUser(userId);
        }
    }

在Service类上加上@Transactional事务注解，否则将会在控制台打印以下信息：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 2][]

## 3.5 控制器方法（Controller层） ##

在com.pjb.controller包中，创建UserController类（用户控制器），实现用户数据的查询、新增、修改、删除，并实现数据的返回。

package com.pjb.controller;
    
    import com.pjb.entity.UserInfo;
    import com.pjb.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.ModelAndView;
    
    /**
     * 用户信息控制器
     * @author pan_junbiao
     **/
    @Controller
    @RequestMapping("/user")
    public class UserController
    {
        @Autowired
        private UserService userService;
    
        /**
         * 获取用户信息
         */
        @RequestMapping("getUserById")
        public ModelAndView getUserById(int userId)
        {
            //根据用户ID，获取用户信息
            UserInfo userInfo = userService.getUserById(userId);
    
            if(userInfo==null)
            {
                userInfo = new UserInfo();
            }
    
            //返回结果
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("userInfo",userInfo);
            modelAndView.setViewName("/user-info.html");
            return modelAndView;
        }
    
        /**
         * 新增用户
         */
        @ResponseBody
        @RequestMapping("insertUser")
        public boolean insertUser()
        {
            //创建新用户
            UserInfo userInfo = new UserInfo();
            userInfo.setUserName("pan_junbiao的博客");
            userInfo.setAge(32);
            userInfo.setBlogUrl("https://blog.csdn.net/pan_junbiao");
            userInfo.setBlogRemark("您好，欢迎访问 pan_junbiao的博客");
    
            //执行新增方法
            userService.insertUser(userInfo);
    
            //返回结果
            return userInfo.getUserId() > 0 ? true : false;
        }
    
        /**
         * 修改用户
         */
        @ResponseBody
        @RequestMapping("updateUser")
        public boolean updateUser(int userId)
        {
            UserInfo userInfo = new UserInfo();
            userInfo.setUserId(userId);
            userInfo.setUserName("pan_junbiao的博客_02");
            userInfo.setAge(35);
            userInfo.setBlogUrl("https://blog.csdn.net/pan_junbiao");
            userInfo.setBlogRemark("您好，欢迎访问 pan_junbiao的博客");
    
            //执行修改方法
            userService.updateUser(userInfo);
    
            //返回结果
            return true;
        }
    
        /**
         * 删除用户
         */
        @ResponseBody
        @RequestMapping("deleteUser")
        public boolean deleteUser(int userId)
        {
            //执行新增方法
            int result = userService.deleteUser(userId);
    
            //返回结果
            return result > 0 ? true : false;
        }
    }

## 3.6 显示页面（View层） ##

在 resources/templates 目录下，创建 user-info.html 用户信息显示页面。

<!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>用户信息</title>
        <meta name="author" content="pan_junbiao的博客">
        <style>
            table { border-collapse: collapse; margin-bottom: 10px}
            table,table tr th, table tr td { border:1px solid #000000; padding: 5px 10px;}
        </style>
    </head>
    <body>
    <div align="center">
        <table>
            <caption>用户信息</caption>
            <tr>
                <th>用户ID：</th>
                <td th:text="${userInfo.userId}"></td>
            </tr>
            <tr>
                <th>用户名称：</th>
                <td th:text="${userInfo.userName}"></td>
            </tr>
            <tr>
                <th>年龄：</th>
                <td th:text="${userInfo.age}"></td>
            </tr>
            <tr>
                <th>博客地址：</th>
                <td th:text="${userInfo.blogUrl}"></td>
            </tr>
            <tr>
                <th>备注信息：</th>
                <td th:text="${userInfo.blogRemark}"></td>
            </tr>
        </table>
    </div>
    </body>
    </html>

**执行结果：**

（1）使用Druid数据库连接池从数据表中，获取用户信息，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 3][]

（2）控制台输出的信息，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 4][]

# 4、Druid实现监控功能 #

Druid实现监控功能，主要是在配置中，包括配置是否启动监控页面、设置访问监控页面的登录账号、密码等。如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 5][]

配置完成后，启动项目，在浏览器中直接输入如下地址：

http://127.0.0.1:8080/druid/login.html
    http://127.0.0.1:8080/druid/index.html

**登录页面：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 6][]

**Druid监控首页：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 7][]

> **源代码下载：**[https://github.com/kevinpanjunbiao/DruidDemo][https_github.com_kevinpanjunbiao_DruidDemo]
> 
> **原文地址：**[https://blog.csdn.net/pan\_junbiao/article/details/108733694][https_blog.csdn.net_pan_junbiao_article_details_108733694]

[Druid]: https://github.com/alibaba/druid/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70]: /images/20210724/fbd4235acf634c27b7d3b8f42a65a7fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 1]: /images/20210724/723701e37e9d49639e3c99c74ca178ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 2]: /images/20210724/dcc66ab1d64f4e4d96a19e79c0e91359.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 3]: /images/20210724/134205014fe2485791e983c4102eccc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 4]: /images/20210724/65ff5ba8c244419baf10a96e645e47b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 5]: /images/20210724/3223e9c021e44d84831ee6acd335efef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 6]: /images/20210724/c12d33d65af64586851e73d4f189d939.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Bhbl9qdW5iaWFv_size_16_color_FFFFFF_t_70 7]: /images/20210724/e5c2489aeaef43369760dbeb29cfd8d7.png
[https_github.com_kevinpanjunbiao_DruidDemo]: https://github.com/kevinpanjunbiao/DruidDemo
[https_blog.csdn.net_pan_junbiao_article_details_108733694]: https://blog.csdn.net/pan_junbiao/article/details/108733694