数据库连接池-12

程序员zhi路

于 2023-04-18 15:20:03 发布

阅读量141

点赞数

分类专栏： JAVAWEB入门文章标签：数据库 log4j java

本文链接：https://blog.csdn.net/qq_53280238/article/details/130222785

版权

JAVAWEB入门专栏收录该内容

14 篇文章 0 订阅

订阅专栏

连接池

什么是连接池
常用的连接池
动态代理封装事务操作

什么是连接池

什么是连接池？

数据库连接是一种资源，数据库连接池本身是一个容器，这个容器可以存放一定数量的连接。当有操作数据库的请求的时候，从这个容器中拿出空闲的连接去操作数据库，操作完成后将连接返回给数据库连接池，其他的数据库操作请求又可以使用这个空闲连接了。随着用户数量越来越多，开始存放的连接可能不够用了，这个时候可以创建一些新的连接进去，让数据库操作请求更快的处理，数据库连接池中的连接数量不能超过数据库的最大承载数。如果连接池中的连接数已经达到最大承载数，但是还有很多数据库操作请求，可以选择让操作等待。直到请求慢慢被处理完成。处理完成后连接池中出现大量空闲连接，连接池会根据情况关闭一些空闲连接。
好处

相对于jdbc而言

1.节省资源，不会频繁的去创建和关闭连接
2. 用户访问的时候效率更高，不需要等待连接的创建和关闭
3.当短时间内大量请求要操作数据库的时候，数据库不会崩溃，而是连接池让请求进行等待
```
 3. 
```
实现数据库连接池

参考一下 https://www.iteye.com/blog/greemranqq-1969273
1. 实现javax.sql.DataSource接口
2. 根据实际情况去重写getConnection方法，通过这个方法去获取连接
3. 获取到的连接的close方法就不再是关闭连接，而是归还连接
常用的数据库连接池

一般情况下数据库连接池还是会使用别人已经实现的连接池

dbcp

c3p0

Hikari 号称史上最快是springboot中默认的连接池

druid 德鲁伊阿里巴巴开发的性能也很强悍可以监控sql执行

druid的使用

添加依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///
username=
password=root
#-------------------------------------------------------------------------------

#配置扩展插件 监控统计用filters:stat 日志用filters:log4j 防御sql注入用filters:wall
filters:stat
#最大连接池数量 初始化建立物理连接的个数 获取连接时最长的等待时间 最小连接池数量 maxIdle
#已经弃用
maxActive:20
initialSize:5
maxWait:60000
minIdle:10
#maxIdle:15
#有两个含义 1.Destroy 线程会检测连接的时间 2.testWhileIdle的判断依据
timeBetweenEvictionRunsMillis:60000
#Destory线程中如果检测到当前连接的最后活跃时间和当前时间的差值大于
minEvictableIdleTimeMillis，则关闭当前连接
minEvictableIdleTimeMillis:300000
#用来检测连接是否的sql，要求是一个查询语句。在mysql中通常设置为SELECT 'X'
validationQuery:SELECT 'x'
#申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery
连接是否有效
testWhileIdle:true
#申请连接时执行validationQuery检测连接是否有效 这个配置会降低性能
testOnBorrow:false
#归还连接时执行validationQuery检测连接是否有效 这个配置会降低性能
testOnReturn:false
#要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true
maxOpenPreparedStatements:20
#对于建立连接超过removeAbandonedTimeout的连接强制关闭
removeAbandoned:true
#指定连接建立多长就被强制关闭
removeAbandonedTimeout:1800
#指定发生removeabandoned时，是否记录当前线程的堆栈信息到日志中
logAbandoned:true

使用

private static DataSource dataSource;

    static {
        //需要先给上面4个变量赋值
        // src下面的文件主要通过类加载器去读取
        InputStream resourceAsStream = SqlUtil.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 获取连接
     * @return
     */
    public static Connection getConnection(){

        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

监控配置

在项目的web.xml文件中添加如下配置

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1"
         metadata-complete="false">
  <display-name>Archetype Created Web Application</display-name>

  <filter>
    <filter-name>webStatFilter</filter-name>
    <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
    <init-param>
      <param-name>exclusion</param-name>
      <param-value>/druid/*,*.js,*.css,*.html,*.jsp</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>webStatFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


  <servlet>
    <servlet-name>statViewServlet</servlet-name>
    <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
    <init-param>
      <param-name>loginUsername</param-name>
      <param-value>druid</param-value>
    </init-param>
    <init-param>
      <param-name>loginPassword</param-name>
      <param-value>druid</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>statViewServlet</servlet-name>
    <url-pattern>/druid/*</url-pattern>
  </servlet-mapping>

</web-app>

按照上面配置好了以后访问 http://localhost:8080/userManager/druid 即可访问到监控界面账号和密码都是druid

代理模式封装事务操作

设计模式：代理模式

静态模式

动态代理

jdk自带代理

cglib代理

jdk自带的代理模式

首先确定事务需要添加到service上，因为service的方法包含了对数据库的一系列操作

每一个请求都是单独的一个线程 我们可以将与这个请求相关的数据库连接保存在 threadlocal中

创建一个注解

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Transactionol {
    
}

注解是添加在service的方法上

@Override
    @Transactionol // 这个方法会开启事务
    public User login(String username, String password) {
        User user = userDao.selectUserByUsername(username);
        if(user == null){
            return null;
        }
        String p = MD5Util.getMD5(password,user.getSalt(),10);
        if(!p.equals(user.getPassword())){
            return null;
        }
        //修改登录时间
        User u = new User();
        u.setUid(user.getUid());
        u.setLoginTime(StringUtil.getCurrentTime());
        userDao.updateLoginTime(u);
        return user;
    }

使用动态代理来处理注解的功能

package com.invocation;

import com.annotation.Transactionol;
import com.utils.SqlUtil;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class TransactionInvocation implements InvocationHandler {

    private Object object;

    public TransactionInvocation(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //找到目标方法
        Method declaredMethod = object.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
        boolean annotationPresent = declaredMethod.isAnnotationPresent(Transactionol.class);
        if(annotationPresent){//需要事务
            SqlUtil.beginTransaction();
        }
        //正常执行方法
        Object invoke = null;

        try {
            invoke = method.invoke(object, args);
            if(annotationPresent){//需要事务
                SqlUtil.commit();
            }
        } catch (RuntimeException e){
            e.printStackTrace();
            //抛出异常回滚事务
            if(annotationPresent){//需要事务
                SqlUtil.rollBack();
            }
        } finally {
            //归还连接
            SqlUtil.close(null,null,SqlUtil.getConnection());
        }


        return invoke;
    }
}

代理对象的创建

package com.proxy;

import com.invocation.TransactionInvocation;

import java.lang.reflect.Proxy;

public class ProxyCreator {


    /**
     * 创建代理对象
     * @param object
     * @param <T>
     * @return
     */
    public static <T> T create(Object object){
        TransactionInvocation transactionInvocation = new TransactionInvocation(object);
        Class<?> aClass = object.getClass();
        return (T) Proxy.newProxyInstance(aClass.getClassLoader(),aClass.getInterfaces(),transactionInvocation);
    }

}

使用

private UserService userService = ProxyCreator.create(new UserServiceImpl());

程序员zhi路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据库连接池-12

什么是连接池？数据库连接是一种资源，数据库连接池本身是一个容器，这个容器可以存放一定数量的连接。当有操作数据库的请求的时候，从这个容器中拿出空闲的连接去操作数据库，操作完成后将连接返回给数据库连接池，其他的数据库操作请求又可以使用这个空闲连接了。随着用户数量越来越多，开始存放的连接可能不够用了，这个时候可以创建一些新的连接进去，让数据库操作请求更快的处理，数据库连接池中的连接数量不能超过数据库的最大承载数。如果连接池中的连接数已经达到最大承载数，但是还有很多数据库操作请求，可以选择让操作等待。
复制链接

扫一扫