抹泪的知更鸟
抹泪的知更鸟

JDBC 数据库连接池详解和示例

JDBC数据库连接池

    • 学习目标
    • 数据库连接池
      • 数据库连接池原理
        • 第一步
        • 第二步
        • 第三步
        • 第四步
        • 第五步
    • DBCP
      • DBCP参数
      • 方法1
      • 方法2
    • C3P0
      • 方法1
      • 方法2
    • DbUtils
      • QueryRunner核心类
      • ResultSetHandler结果集处理类
      • 案例
      • 查询
      • 其他方法
  • 作业
    • 模拟数据库连接池
    • DBCP 连接池
    • C3P0连接池

学习目标

  1. 了解数据库连接池的原理
  2. 了解C3P0数据库连接池
  3. 了解DBCP数据库连接池
  4. 掌握Druid数据库连接池

数据库连接池

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用现有的N个（自定义）数据库连接，不用每次都再重新建立一个新的连接，以提高对数据库操作的性能。

常用开源的数据库连接池

  • C3P0：是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate [2] 一起发布，包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象。
  • Proxool：是一个Java SQDriver驱动程序，提供了对选择的其它类型的驱动程序的连接池封装。可以非常简单的移植到现存的代码中，完全可配置，快速、成熟、健壮。可以透明地为现存的JDBC驱动程序增加连接池功能。
  • Jakarta DBCP：DBCP是一个依赖Jakartacommons-pool对象池机制的数据库连接池。DBCP可以直接的在应用程序中使用。
    -DBPool：是一个高效、易配置的数据库连接池。它除了支持连接池应有的功能之外，还包括了一个对象池，使用户能够开发一个满足自己需求的数据库连接池。
  • SmartPool：是一个连接池组件，它模仿应用服务器对象池的特性。SmartPool能够解决一些临界问题如连接泄漏（connection leaks）、连接阻塞、打开的JDBC对象（如Statements、PreparedStatements）等。
  • Druid连接池是阿里巴巴开源的数据库连接池项目。Druid连接池为监控而生，内置强大的监控功能，监控特性不影响性能。功能强大，能防SQL注入，内置Loging能诊断Hack应用行为。

数据库连接池原理

简单来说，数据库连接池就是在一开始先创建N多个数据库连接connection对象，存储在一个集合内，每次使用一个就从集合内取出一个，用完之后又添加到集合内，一直反复使用。

第一步

创建带有是否使用标记的Connection对象。自定义一个带有是否使用标记的Connection对象。

package com.pool;
import java.sql.Connection;
public class PooledConnection {
    // 数据库连接
    private Connection conn;
    // 用于标识当前数据库连接的状态 true:执行 false:空闲
    private boolean busy;
    public PooledConnection(Connection conn) {
        this.conn = conn;
    }
    public Connection getConn() {
        return conn;
    }
    public void setConn(Connection conn) {
        this.conn = conn;
    }
    public boolean isBusy() {
        return busy;
    }
    public void setBusy(boolean busy) {
        this.busy = busy;
    }
}

第二步

创建数据库线程池对象

数据库线程池对象包含默认连接数、最大连接数、每次新增个数、超时时间和连接对象集合。

package com.star;

import java.io.FileInputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.*;

/**
     * 连接池
     */
public class Poo{
    // 初始化连接数
    private static int initSize = 2;
    // 池中最大连接数
    private static int maxSize = 10;
    // 每次创建的连接数
    private static int stepSize = 2;
    // 超时时间
    private static int timeout = 2000;
    // 用来保存创建的数据库连接
    private static List<PoolCollection> poo= Collections.synchronizedList(new ArrayList<>());
    //单例对象
    private static Pooinstance;

    /**
     * 单利模式：无论什么时候只会有一个Pool对象
     */
    private Pool() {
        resizePool(initSize);
    }

    /**
     * 单利模式：无论什么时候只会有一个Pool对象
     */
    private Pool() {
        resizePool(initSize);
    }

    /**
     * 获取单例对象
     *
     * @return
     */
    public static synchronized PoogetInstance() {
        if (instance == null) {
            instance = new Pool();
        }
        return instance;
    }

    /**
     * 初始化连接池，循环使用池子里的连接对象，如果不够再创建num个，不超过最大数maxSize
     *
     * @param size 初始时按照initSize给池中添加连接，其他时候按照stepSize给池中加
     */
    private void resizePool(int size) {
        int current = pool.size();
        if (current + size > maxSize) {
            size = maxSize - current;

        }
        for (int i = 0; i < size; i++) {
            pool.add(new PoolCollection(createConnection()));
        }

    }
}

第三步

获取连接

/**
 * 创建连接
 *
 * @return
 */
public Connection createConnection() {
    try {
        //加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //加载配置文件
        Properties p = new Properties();
        p.load(new FileInputStream("jdbc.properties"));
        return DriverManager.getConnection(p.getProperty("url"), p.getProperty("user"), p.getProperty("password"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * 获取连接
 *
 * @return
 */
public Connection getConnection() {
    Connection connection = getAddConnection();
    while (connection == null) {
        System.out.println(Thread.currentThread().getName() + "开始等待获取连接");
        try {
            Thread.sleep(timeout);
            connection = getAddConnection();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println(Thread.currentThread().getName() + "拿到连接");
    return connection;
}

/**
 * 可以实现递增获取的机制
 *
 * @return
 */
private Connection getAddConnection() {
    Connection connection = getUsableConnection();
    if (connection == null) {
        resizePool(stepSize);
        connection = getUsableConnection();
    }
    return connection;
}

/**
 * 获取可用的连接
 *
 * @return
 */
private Connection getUsableConnection() {
    Connection connection = null;
    if (pool.size() > 0) {
        for (PoolCollection poolCollection : pool) {
            if (poolCollection.isUsed() == false) {
                poolCollection.setUsed(true);
                connection = poolCollection.getConnection();
                //connection有课能在上次使用过程中产生异常被中断
                try {
                    // connection.isValid如果连接未关闭且有效，则返回true
                    if (connection.isValid(2000) == false) {
                        connection = createConnection();
                    }
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
                break;
            }
        }
    }
    return connection;
}

第四步

归还

/**
 * 关闭
 * @param connection
 */
public void close(Connection connection){
    for (PoolCollection poolCollection : pool) {
        if(connection == poolCollection.getConnection()){
            poolCollection.setUsed(false);
        }
    }
}

第五步

测试

package com.star;

import java.sql.Connection;

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "获取连接");
                    Poopool1 = Pool.getInstance();
                    Connection connection = pool1.getConnection();
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    pool1.close(connection);
                    System.out.println(Thread.currentThread().getName() + "释放连接");
                }
            }.start();
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

DBCP

下载DBCP地址：

下载pool地址

下载Logging地址

DBCP参数

参数 默认值 说明
username 传递给JDBC驱动的用于建立连接的用户名
password 传递给JDBC驱动的用于建立连接的密码
url 传递给JDBC驱动的用于建立连接的URL
driverClassName 使用的JDBC驱动的完整有效的Java 类名
initialSize 0 初始化连接:连接池启动时创建的初始化连接数量,1.2版本后支持
maxActive 8 最大活动连接:连接池在同一时间能够分配的最大活动连接的数量, 如果设置为非正数则表示不限制
maxIdle 8 最大空闲连接:连接池中容许保持空闲状态的最大连接数量,超过的空闲连接将被释放, 如果设置为负数表示不限制
minIdle 0 最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接, 如果设置为0则不创建
maxWait 无限 最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间(以毫秒计数)超过时间则抛出异常,如果设置为-1表示无限等待
testOnReturn false 是否在归还到池中前进行检验
testWhileIdle false 连接是否被空闲连接回收器(如果有)进行检验.如果检测失败, 则连接将被从池中去除.设置为true后如果要生效,validationQuery参数必须设置为非空字符串
minEvictableIdleTimeMillis 1000 * 60 * 30 连接在池中保持空闲而不被空闲连接回收器线程 (如果有)回收的最小时间值，单位毫秒
numTestsPerEvictionRun 3 在每次空闲连接回收器线程(如果有)运行时检查的连接数量
timeBetweenEvictionRunsMillis -1 在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位. 如果设置为非正数,则不运行空闲连接回收器线程
validationQuery null SQL查询,用来验证从连接池取出的连接,在将连接返回给调用者之前.如果指定, 则查询必须是一个SQSELECT并且必须返回至少一行记录
testOnBorrow true 是否在从池中取出连接前进行检验,如果检验失败, 则从池中去除连接并尝试取出另一个.

方法1

package com.dbcp;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSource;

public class DBCPUtils {
	private String driver = "com.mysql.cj.jdbc.Driver";
	private String ur= "jdbc:mysql://localhost/mydbcp?serverTimezone=GMT";
	private String username = "root";
	private String password = "";
	private static BasicDataSource basicDataSource = new BasicDataSource();

	public DBCPUtils() {
		basicDataSource.setUrl(url);
		basicDataSource.setDriverClassName(driver);
		basicDataSource.setUsername(username);
		basicDataSource.setPassword(password);

		basicDataSource.setInitialSize(10);// 初始化时创建10个链接
		basicDataSource.setMaxIdle(8);// 设置最大连接数
		basicDataSource.setMaxIdle(5);// 这只最大的空闲连接数
		basicDataSource.setMinIdle(1);// 设置最小空闲连接数字
	}

	/**
	 * 返回一个数据源DataSource应该是在javax.sql.DataSource包下
	 * 
	 * @return
	 */
	public static DataSource getDataSource() {
		return basicDataSource;
	}
}

测试

package com.dbcp;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class DBCPTest {
	public static void main(String[] args) {
		DBCPUtils uti= new DBCPUtils();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

方法2

配置文件dbcp.properties

#驱动名
driverClassName=com.mysql.cj.jdbc.Driver
#数据库
database=mydbcp
#url
url=jdbc:mysql://localhost/${database}?serverTimezone=Asia/Shanghai&characterEncoding=UTF-8
#用户名
username=root
#密码
password=
#初试连接数
initialSize=30
#最大活跃数
maxTotal=30
#最大idle数
maxIdle=10
#最小idle数
minIdle=5
#最长等待时间(毫秒)
maxWaitMillis=1000
#程序中的连接不使用后是否被连接池回收(该版本要使用removeAbandonedOnMaintenance和removeAbandonedOnBorrow)
#removeAbandoned=true
removeAbandonedOnMaintenance=true
removeAbandonedOnBorrow=true
#连接在所指定的秒数内未使用才会被删除(秒)(为配合测试程序才配置为1秒)
removeAbandonedTimeout=1

使用

package com.dbcp;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;

public class DBCPUtils2 {
	private static BasicDataSource basicDataSource = new BasicDataSource();

	public DBCPUtils2() {
		Properties prop = new Properties();
		try {
			prop.load(new FileInputStream("src/dbcp.properties"));
			basicDataSource = new BasicDataSourceFactory().createDataSource(prop);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 返回一个数据源DataSource应该是在javax.sql.DataSource包下
	 * 
	 * @return
	 */
	public static DataSource getDataSource() {
		return basicDataSource;
	}
}

测试

package com.dbcp;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class DBCPTest2 {
	public static void main(String[] args) {
		DBCPUtils2 uti= new DBCPUtils2();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

C3P0

下载C3P0地址：

方法1

package com.c3p0;

import java.beans.PropertyVetoException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Utils {

	private static ComboPooledDataSource cpds = null;

	/**
	 * 初始化
	 */
	public C3P0Utils() {
		cpds = new ComboPooledDataSource();
		try {
			cpds.setDriverClass("com.mysql.cj.jdbc.Driver");
			cpds.setJdbcUrl("jdbc:mysql://localhost/mydbcp?serverTimezone=GMT");
			cpds.setUser("root");
			cpds.setPassword("");

			cpds.setMinPoolSize(5);
			cpds.setMaxPoolSize(20);
			cpds.setAcquireIncrement(5);
			cpds.setInitialPoolSize(5);
			cpds.setMaxStatements(50);
			cpds.setMaxIdleTime(60);
		} catch (PropertyVetoException e) {
			e.printStackTrace();
		}

	}
	/**
	 * 获取 Connection 连接
	 * 
	 * @return
	 */
	public static ComboPooledDataSource getDataSource() {
		return cpds;
	}
}

测试

package com.c3p0;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class C3P0Test {
	public static void main(String[] args) {
		C3P0Utils uti= new C3P0Utils();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

方法2

配置文件夹，通过 c3p0-config.xml文件进行配置，文件名不能改


<c3p0-config>
	
	<default-config>
		<property name="user">rootproperty>
		<property name="password">rootproperty>
		<property name="jdbcUrl">jdbc:mysql://localhost/mydbcp? serverTimezone=Asia/Shanghai&characterEncoding=UTF-8&useSSL=false
		property>
		<property name="driverClass">com.mysql.cj.jdbc.Driverproperty>
		<property name="checkoutTimeout">30000property>
		<property name="idleConnectionTestPeriod">30property>
		<property name="initialPoolSize">5property>
		<property name="maxIdleTime">60property>
		<property name="maxPoolSize">20property>
		<property name="minPoolSize">5property>
		<property name="maxStatements">50property>
		<property name="acquireIncrement">5property>
	default-config>

	
	<named-config name="test">
		<property name="user">Xiaopengweiproperty>
		<property name="password">123456property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/Xiaopengwei
		property>
		<property name="driverClass">com.mysql.jdbc.Driverproperty>
		
		<property name="acquireIncrement">5property>
		
		<property name="initialPoolSize">20property>
		
		<property name="maxPoolSize">25property>
		
		<property name="minPoolSize">5property>
	named-config>
c3p0-config>

使用

package com.c3p0;

import java.beans.PropertyVetoException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3P0Utils2 {
	private static ComboPooledDataSource cpds = null;
	/**
	 * 初始化
	 */
	public C3P0Utils2() {
		cpds = new ComboPooledDataSource();
	}
	/**
	 * 获取 Connection 连接
	 * @return
	 */
	public static ComboPooledDataSource getDataSource() {
		return cpds;
	}
}

测试

package com.c3p0;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.sql.DataSource;

public class C3P0Test2 {
	public static void main(String[] args) {
		C3P0Utils2 uti= new C3P0Utils2();
		DataSource ds = util.getDataSource();
		Connection conn;
		try {
			conn = ds.getConnection();
			String sq= "insert into user values(null,?,?,?,?)";
			PreparedStatement st = conn.prepareStatement(sql);
			st.setString(1, "王麻子");
			st.setInt(2, 1);
			st.setDate(3, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("2019-06-08").getTime()));
			st.setInt(4, 1);

			int i = st.executeUpdate();
			if (i == 1) {
				System.out.println("success");
			} else {
				System.out.println("fail");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
}

DbUtils

DbUtils是在数据库连接池基础上建立起来的快速操作数据库的工具类。

后面会用到spring JdbcTemplate、Mybatis、hibernate等框架

下载地址：

DBUtils三个核心功能介绍

-QueryRunner中提供对sql语句操作的API

  • ResultSetHandler接口，用于定义select操作后，怎样封装结果集
  • DBUtils类，它就是一个工具类，定义了关闭资源与事务处理的方法

QueryRunner核心类

QueryRunner(DataSource ds)，传入连接池，并且底层自动维护连接connection

-update（String sql，Obj...params），执行更新数据

  • query（String sql，ResultSetHandler rsh,Object...panrams)，执行查询

ResultSetHandler结果集处理类

-ArrayHandler：适合取1条记录，把结果集中的第一行数据转成对象数组。

  • ArrayListHandler：适合取多条记录，把结果集中的每一行数据都转成一个对象数组，再存放到List中。
  • BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中（把每条记录封装成对象，适合取一条记录）
    -BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
  • MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
  • MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
  • KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里(Map)，再把这些map再存到一个map里，其key为指定的列。
    -ColumnListHandler：将结果集中某一列的数据存放到List中。
  • ScalarHandler:将结果集第一行的某一列放到某个对象Object中。

    • 案例

    实体类

    package com.dbutils.entity;

import java.sql.Date;

public class User {

	private Long id;
	private String name;
	private Boolean sex;
	private Date birthday;
	private Integer status;
	
	public User() {
		super();
	}

	public User(Long id, String name, Boolean sex, Date birthday, Integer status) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
		this.status = status;
	}

	public User(String name, Boolean sex, Date birthday) {
		super();
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Boolean getSex() {
		return sex;
	}

	public void setSex(Boolean sex) {
		this.sex = sex;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public Integer getStatus() {
		return status;
	}

	public void setStatus(Integer status) {
		this.status = status;
	}

}

    查询

    package com.dbutils;

import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.jupiter.api.Test;

import com.dbutils.entity.User;
import com.mchange.v2.c3p0.ComboPooledDataSource;

public class MyDbUtils {
	// --1.ArrayHandler：将查询的结果的第一行放到一个数组中
	@Test
	public void query1() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		Object[] array = runner.query("select * from user", new ArrayHandler());
		System.out.println(array[0] + "," + array[1]);
	}

	// --2.ArrayListHandler：将查询的结果的每一行放到一个数组中，然后再将数组放到集合中；
	@Test
	public void query2() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		List<Object[]> list = runner.query("select * from user", new ArrayListHandler());
		for (Object[] objects : list) {
			System.out.println(objects[0] + "," + objects[1]);
		}
	}

	// --3.BeanHandler：将查询的结果的第一行封装到一份javabean对象中；
	@Test
	public void query3() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		User user = runner.query("select * from user", new BeanHandler<User>(User.class));
		System.out.println(user.getId() + "," + user.getName());
	}

	// --4.BeanListHandler：将查询的结果的每一行封装到一个javabean对象中，然后再将这些对象存入list中；
	@Test
	public void query4() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		List<User> list = runner.query("select * from user", new BeanListHandler<User>(User.class));
		for (User user : list) {
			System.out.println(user.getId() + "," + user.getName());
		}
	}

	// --5.MapHandler：将查询的结果的第一行存入到一个map中，键为列名，值为各列值；
	@Test
	public void query5() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		Map<String, Object> map = runner.query("select * from user", new MapHandler());
		for (Entry<String, Object> entry : map.entrySet()) {
			String mapKey = entry.getKey();
			Object mapValue = entry.getValue();
			System.out.println(mapKey + ":" + mapValue);
		}
	}

	// --6.MapListHandler：将查询的结果的每一行存入到一个map中，键为列名，值为各列值；然后再将map存入list中；
	@Test
	public void query6() throws SQLException {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		List<Map<String, Object>> map = runner.query("select * from user", new MapListHandler());
		for (Map<String, Object> map2 : map) {
			for (Entry<String, Object> entry : map2.entrySet()) {
				String mapKey = entry.getKey();
				Object mapValue = entry.getValue();
				System.out.println(mapKey + ":" + mapValue);
			}
			System.out.println("------------------------------------------------");
		}

	}

	// --7.KeyedHandler：将查询的结果集中某一列的数据存放到List中；
	@Test
	public void query7() {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		try {
			// ScalarHandler 的参数可以是列的索引（从1开始）或列名
			Map<Object, Map<String, Object>> map = (Map<Object, Map<String, Object>>) runner.query("select * from user",new KeyedHandler("id"));
			for (Object key : map.keySet()) {
				System.out.println(key + " " + map.get(key));
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// --8.ColumnListHandler：将查询的结果集中某一列的数据存放到List中；
	@Test
	public void query8() {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		try {
			// ScalarHandler 的参数可以是列的索引（从1开始）或列名
			List<Object> list = runner.query("select * from user", new ColumnListHandler<Object>(1));
			for (Object string : list) {
				System.out.println(string);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// --9.ScalarHandler：将查询的结果的第一行的某一列放到一个对象中；精确定位到某个值；
	@Test
	public void query9() {
		QueryRunner runner = new QueryRunner(new ComboPooledDataSource());
		try {
			// ScalarHandler 的参数可以是列的索引（从1开始）或列名
			Object name = runner.query("select * from user", new ScalarHandler<Object>(2));
			System.out.println(name);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

    其他方法

    • close()：
      • DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭连接、声明和结果集（ResultSet）。
        -CloseQuietly:
      • CloseQuietly这一方法不仅能在连接、声明或者结果集（ResultSet）为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
      • 如果你不想捕捉这些异常的话，这对你是非常有用的。
      • 在重载CloseQuietly方法时，特别有用的一个方法是closeQuietly(Connection conn,Statement stmt,ResultSet rs)，这是因为在大多数情况下，连接、声明和结果集（ResultSet）是你要用的三样东西，而且在最后的块你必须关闭它们。
      • 使用这一方法，你最后的块就可以只需要调用这一方法即可。
    • CommitAndCloseQuietly(Connection conn)：
      • 这一方法用来提交连接，然后关闭连接，并且在关闭连接时不向上抛出在关闭时发生的一些SQL异常。
      • LoadDriver(String driveClassName):这一方法装载并注册JDBC驱动程序，如果成功就返回TRUE。
      • 使用这种方法，你不需要去捕捉这个异常ClassNotFoundException。使用loadDrive方法，编码就变得更容易理解，
      • 你也就得到了一个很好的Boolean返回值，这个返回值会告诉你驱动类是不是已经加载成功了。

    作业

    模拟数据库连接池

    DBCP 连接池

    package utility;
/*
 *@author Liu
 *@Description DBPC连接池的工具类
 *@data 2021/12/28
 */

import Entity.User;
import MapperEntity.UserMapperEntity;
import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;

import java.io.FileInputStream;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class DBCPUtility {
    private static BasicDataSource basicDataSource;

    //加载配置文件
    static {
        Properties properties = new Properties();
        try (
                FileInputStream fis = new FileInputStream("dbpc.properties");
        ) {
            properties.load(fis);
            basicDataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static List<User> executeQuery(String sql,Object ... params)  {
        Connection connection = getConnection();
        PreparedStatement statement=null;
        List<User> list = new ArrayList<>();
        if (connection==null) {
            return null;
        }
        try {
            connection.setAutoCommit(false);
            statement=connection.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                statement.setObject(i+1,params[i]);
            }
            ResultSet resultSet = statement.executeQuery();
            list = UserMapperEntity.getUser(resultSet);
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                try {
                    Close(connection,statement);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
     return list;
    }

    /**
     * 修改
     * @param sql
     * @param params
     * @return
     */
    public static int executeUpdate(String sql,Object ... params)  {
        Connection connection = getConnection();
        PreparedStatement statement=null;
        int rows=0;
        List<User> list = new ArrayList<>();
        if (connection==null) {
            return rows;
        }
        try {
            connection.setAutoCommit(false);
            statement=connection.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                statement.setObject(i+1,params[i]);
            }
            rows = statement.executeUpdate();
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                try {
                    Close(connection,statement);
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return rows;
    }
    /**
     * 获取数据库的连接
     *
     * @return 连接
     */
    public static Connection getConnection(){
        try {
           return basicDataSource.getConnection();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭Connection
     *
     * @param connection 连接
     * @throws SQLException
     */
    public static void Close(Connection connection) throws SQLException {
        if (connection != null) {
            connection.close();
        }
    }

    /**
     * 关闭statement
     *
     * @param statement 连接
     * @throws SQLException
     */
    public static void Close(Statement statement) throws SQLException {
        if (statement != null) {
            statement.close();
        }
    }

    /**
     * 关闭connection 和 statement
     * @param connection 连接
     * @param statement statement
     * @throws SQLException
     */
    public static void Close(Connection connection,Statement statement) throws SQLException {
       connection.close();
       statement.close();
    }
}

    C3P0连接池

    package utility;
/*
 *@author Liu
 *@Description
 *@data 2021/12/28
 */

import Entity.User;
import MapperEntity.UserMapperEntity;
import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class C3P0Utility {
    private static final ComboPooledDataSource dataSource;
    static{
        dataSource=new ComboPooledDataSource();
    }

    /**
     * 获取连接
     * @return
     */
    public static Connection getConnection(){
        try {
            return dataSource.getConnection();
        } catch (SQLException throwables)
        {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 查询
     * @param sql
     * @param params
     * @return
     */
    public static List<User> executeQuery(String sql,Object ... params){
        Connection connection = getConnection();
        PreparedStatement statement=null;
        List<User> list = new ArrayList<>();
        if (connection==null) {
            return null;
        }
        try {
            connection.setAutoCommit(false);
            statement=connection.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                statement.setObject(i+1,params[i]);
            }
            ResultSet resultSet = statement.executeQuery();
            list = UserMapperEntity.getUser(resultSet);
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                Close(connection,statement);
            }
        }
        return list;
    }

    /**
     * 修改
     * @param sql
     * @param params
     * @return
     */
    public static int executeUpdate(String sql,Object ... params){
        Connection connection = getConnection();
        PreparedStatement statement=null;
        int rows=0;
        if (connection==null) {
            return rows;
        }
        try {
            connection.setAutoCommit(false);
            statement=connection.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                statement.setObject(i+1,params[i]);
            }
            rows = statement.executeUpdate();
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                Close(connection,statement);
            }
        }
        return rows;
    }

    /**
     * 关闭连接
     * @param connection
     * @return
     */
    public static void Close(Connection connection){
        if (connection!=null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void Close(Statement statement){
        if(Objects.nonNull(statement)){
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void Close(Connection connection,Statement statement){
        Close(connection);
        Close(statement);
    }
}

    你可能感兴趣的:(Java+JDBC,数据库,database,jdbc)

    • Google earth studio 简介 陟彼高冈yu 旅游
      GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
      目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
      1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
      深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
      在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    • python os 环境变量 CV矿工 python开发语言numpy
      环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    • 【PG】常见数据库、表属性设置 江无羡 数据库
      PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
      Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
      前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
      提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
    • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
      目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
      一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    • MongoDB知识概括 GeorgeLin98 持久层mongodb
      MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    • Mongodb Error: queryTxt ETIMEOUT xxxx.wwwdz.mongodb.net 佛一脚 errorreactmongodb数据库
      背景每天都能遇到奇怪的问题，做个记录，以便有缘人能得到帮助！换了一台电脑开发nextjs程序。需要连接mongodb数据，对数据进行增删改查。上一台电脑好好的程序，新电脑死活连不上mongodb数据库。同一套代码，没任何修改，搞得我怀疑人生了，打开浏览器进入mongodb官网毫无问题，也能进入线上系统查看数据，网络应该是没问题。于是我尝试了一下手机热点，这次代码能正常跑起来，连接数据库了！！！是不
    • 入门MySQL——查询语法练习 K_un
      前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
    • 博客网站制作教程 2401_85194651 javamaven
      首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    • ubuntu安装wordpress lissettecarlr
      1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
    • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
      一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
    • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
      文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
    • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
      该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    • MyBatis 详解 阿贾克斯的黎明 javamybatis
      目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    • 3.增删改查--连接查询 问女何所忆
      关系型数据库的一个特点就是，多张表之间存在关系，以致于我们可以连接多张表进行查询操作，所以连接查询会是关系型数据库中最常见的操作。连接查询主要分为三种，交叉连接、内连接和外连接，我们一个个说。1、交叉连接交叉连接其实连接查询的第一个阶段，它简单表现为两张表的笛卡尔积形式，具体例子：如果你没学过数学中的笛卡尔积概念，你可以这样简单的理解这里的交叉连接：两张表的交叉连接就是一个连接合并的过程，T1表中
    • docker from指令的含义_多个FROM-含义 weixin_39722188 dockerfrom指令的含义
      小编典典什么是基本图片？一组文件，加上EXPOSE端口ENTRYPOINT和CMD。您可以添加文件并基于该基础图像构建新图像，Dockerfile并以FROM指令开头：后面提到的图像FROM是新图像的“基础图像”。这是否意味着如果我neo4j/neo4j在FROM指令中声明，则在运行映像时，neo数据库将自动运行并且可在端口7474的容器中使用？仅当您不覆盖CMD和时ENTRYPOINT。但是图像
    • Redis:缓存击穿 我的程序快快跑啊 缓存redisjava
      缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15） 知识分享小能手 大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
      1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
    • ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your †徐先森® Oracle数据库Web相关错误集
      createtablestudents(idintunsignedprimarykeyauto_increment,namevarchar(50)notnull,ageintunsigned,highdecimal(3,2),genderenum('男','女','中性','保密','妖')default'保密',cls_idintunsigned);在对数据库插入如上带有中文带有默认值的字段的时
    • Redis 有哪些危险命令？如何防范？ 花小疯 redis缓存数据库危险命令大数据
      Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
      文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    • 【Golang】 Golang 的 GORM 库中的 Rows 函数 不爱洗脚的小滕 golang开发语言后端
      文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
    • 接口测试如何设计测试用例 李蕴Ronnie
      接口测试用例设计方式针对每个必填参数，都设计一条参数为空的测试用例必填参数不存在传的参数值在数据库中不存在添加数据接口，传入已有的数据重复添加编辑数据接口，各个字段分别编辑，合并编辑参数数据类型限制，针对每个参数设计一条参数值类型不符合的逆向用例参数自身取值范围，针对所有参数，设计一条每个参数值在取值范围内最大值的正向测试用例是否满足前提条件（token、headers），几个前提条件几条用例针对
    • ztree设置禁用节点 3213213333332132 JavaScriptztreejsonsetDisabledNodeAjax
      ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 $(function(){ showTree(); setDisabledNode(); });
    • JVM patch by Taobao bookjovi javaHotSpot
      在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。   7050685：jsdbproc64.sh has a typo in the package name 7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 7060619：C1 should respect inline and
    • 将session存储到数据库中 dcj3sjt126com sqlPHPsession
      CREATE TABLE sessions ( id CHAR(32) NOT NULL, data TEXT, last_accessed TIMESTAMP NOT NULL, PRIMARY KEY (id) );   <?php /** * Created by PhpStorm. * User: michaeldu * Date
    • Vector 171815164 vector
      public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) { for (int i = 0; i < cart.size(); i++) { if (cart.get(i).getId().equals(id)) { cart.remove(i);
    • 各连接池配置参数比较 g21121 连接池
              排版真心费劲，大家凑合看下吧，见谅~     Druid DBCP C3P0 Proxool 数据库用户名称 Username Username User   数据库密码 Password Password Password   驱动名
    • [简单]mybatis insert语句添加动态字段 53873039oycg mybatis
            mysql数据库,id自增,配置如下：       <insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id" parameterType=&
    • struts2拦截器配置 云端月影 struts2拦截器
      struts2拦截器interceptor的三种配置方法 方法1. 普通配置法 <struts>     <package name="struts2" extends="struts-default">         &
    • IE中页面不居中，火狐谷歌等正常 aijuans IE中页面不居中
      问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
    • String,int,Integer,char 几个类型常见转换 antonyup_2006 htmlsql.net
      如何将字串 String 转换成整数 int? int i = Integer.valueOf(my_str).intValue(); int i=Integer.parseInt(str); 如何将字串 String 转换成Integer ? Integer integer=Integer.valueOf(str); 如何将整数 int 转换成字串 String ? 1.
    • PL/SQL的游标类型 百合不是茶 显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
      游标是oracle中的一个结果集,用于存放查询的结果;   PL/SQL中游标的声明; 1,声明游标 2,打开游标(默认是关闭的); 3,提取数据 4,关闭游标     注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标   隐式游标:主要是对DML数据的操作隐
    • JUnit4中@AfterClass @BeforeClass @after @before的区别对比 bijian1013 JUnit4单元测试
      一.基础知识 JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
    • 精通Oracle10编程SQL(12)开发包 bijian1013 oracle数据库plsql
      /* *开发包 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数） */ --包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成 --建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等 --在包规
    • 【EhCache二】ehcache.xml配置详解 bit1129 ehcache.xml
      在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ ehcache.xml ： http://ehcache.org/ehcache.xml ehcache.xsd ： http://ehcache.org/ehcache.xsd ehcache配置文件的根元素是ehcahe   ehcac
    • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL 白糖_ javaeclipsespringtomcatWeb
      今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>  随后启动
    • angular.element boyitech AngularJSAngularJS APIangular.element
      angular.element 描述:     包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）     如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
    • java-给定两个已排序序列，找出共同的元素。 bylijinnan java
      import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class CommonItemInTwoSortedArray { /** * 题目：给定两个已排序序列，找出共同的元素。 * 1.定义两个指针分别指向序列的开始。 * 如果指向的两个元素
    • sftp 异常，有遇到的吗？求解 Chen.H javajcraftauthjschjschexception
      com.jcraft.jsch.JSchException: Auth cancel at com.jcraft.jsch.Session.connect(Session.java:460) at com.jcraft.jsch.Session.connect(Session.java:154) at cn.vivame.util.ftp.SftpServerAccess.connec
    • [生物智能与人工智能]神经元中的电化学结构代表什么? comsci 人工智能
           我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色....      我们可以尝试一下...在某些神经
    • 通过LAC和CID获取经纬度信息 dai_lm laccid
      方法1： 用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 方法2： 发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
    • JAVA的困难分析 datamachine java
      前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。   -----------------------------------------------------------------------------------------
    • 小学5年级英语单词背诵第二课 dcj3sjt126com englishword
      money 钱 paper 纸 speak 讲，说 tell 告诉   remember 记得，想起 knock 敲，击，打 question 问题 number 数字，号码   learn 学会，学习 street 街道 carry 搬运，携带 send 发送，邮寄，发射   must 必须 light 灯，光线，轻的 front
    • linux下面没有tree命令 dcj3sjt126com linux
      centos p安装 yum -y install tree   mac os安装 brew install tree   首先来看tree的用法 tree 中文解释：tree 功能说明：以树状图列出目录的内容。 语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
    • Map迭代方式，Map迭代，Map循环 蕃薯耀 Map循环Map迭代Map迭代方式
      Map迭代方式，Map迭代，Map循环   >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年
    • Spring Cache注解+Redis hanqunfeng spring
      Spring3.1 Cache注解  依赖jar包： <!-- redis --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId>
    • Guava中针对集合的 filter和过滤功能 jackyrong filter
      在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子：    @Test public void whenFilterWithIterables_thenFiltered() { List<String> names = Lists.newArrayList("John"
    • 学习编程那点事 lampcy 编程androidPHPhtml5
      一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    • 架构师之流处理---------bytebuffer的mark,limit和flip nannan408 ByteBuffer
      1.前言。   如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 2.例子. 例子代码: String str = "helloWorld"; ByteBuffer buff = ByteBuffer.wrap(str.getBytes()); Sy
    • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1 Everyday都不同 $转义el表达式
      最近在做Highcharts的过程中，在写js时，出现了以下异常：   严重: Servlet.service() for servlet jsp threw exception org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1,
    • 用Java实现发送邮件到163 tntxia java实现
      /* 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。 此篇仅介绍用
    • 探索实体类存在的真正意义 java小叶檀 POJO
      一. 实体类简述    实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 POJO（Plain Old Java Objects）简单的Java对象   它的一般格式就是 public class A{ private String id; public Str