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

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)

    • 为什么wal会 提升数据库性能 浩澜大大 数据库
      由于对于一个数据库内会存在很多张表，那么当数据库更新表数据时（1）直接写入磁盘实际写入的位置，会根据表的不同对应到不同的磁盘位置，在写入数据的时候，就会不停的寻找磁盘地址，找到地址后再去写入，对于机械硬盘来说，无规律的寻址是非常耗时的，对应SSD来说虽然性能提升很多，但是也会消耗时间；（2）先写入日志，在写入磁盘（WAL）WAL的过程，由于总是按照在文件末尾追加，只要找到文件写入位置，写入修改后，
    • 通俗易懂：MySQL中如何设置只读实例并确保数据一致性？ 大龄下岗程序员 mysqljavamysqlspring
      在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
    • C#中的PLINQ和LINQ的效率对比 搬砖的诗人Z C#c#linq开发语言
      PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
    • docker怎么端口映射 Lance_mu docker容器运维
      1、默认固定的端口#Web服务器：WebApache或Nginx通常使用80端口HTTP：80HTTPS：443#数据库服务器MySQL：3306PostgreSQL：5432MongoDB：27017Redis：6379#邮件服务器SMTP：25POP3：110IMAP：143#其他服务SSH：22FTP：21DNS（域名解析）：53代理服务器Squid：3128版本控制系统Git：9418(S
    • 新注册的阿里云账号有哪些优惠？阿里云新用户必看优惠大合集 阿里云最新优惠和活动汇总
      很多用户看到阿里云各种活动中的云服务器、云数据库、企业邮箱等云产品都仅限新用户购买之后，都纷纷直接注册了阿里云新账号之后购买，其实，阿里云新用户不仅可以优惠购买活动中的各种云产品，还有很多优惠，下面是“阿里云最新优惠和活动汇总”整理汇总的阿里云新用户必看优惠大合集。新注册的阿里云账号在购买活动中的云产品之前，还有免费领云产品通用代金券、抽取无门槛代金券、免费试用云服务器和正式购买云服务器等阿里云产
    • MyBatis高级面试题-2024 my_styles mybatisjava开发语言面试题
      MyBatis的核心组件有哪些？首先第一个是，SqlSessionFactory，它就像是一个会话工厂。它的任务是创建SqlSession对象，这个对象是我们与数据库交互的主要途径。SqlSessionFactory的作用很重要，因为它可以帮我们配置数据库连接信息和事务管理等。一旦这个工厂被建立起来，它就会加载一些必要的配置和映射文件，为后续的数据库操作提供一个可靠的基础。第二个是SqlSessi
    • SQLite版本3中的文件锁定和并发(七） 代码工匠云 数据库SQLiteC与c++sqlitec++数据库
      返回：SQLite—系列文章目录上一篇：自己编译SQLite或将SQLite移植到新的操作系统（六）下一篇：SQLite—系列文章目录正文：1.0SQLite版本3中的文件锁定和并发SQLite版本3.0.0引入了新的锁定和日志功能旨在提高SQLite版本2的并发性的机制并减少作家的饥饿问题。新机制还允许交易的原子提交涉及多个数据库文件。本文档介绍新的锁定机制。目标受众是想要理解和/或修改的程序员
    • python转码 Desamond python开发语言
      转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
    • Python | Redis工具类 -拟墨画扇- Pythonredis数据库缓存python
      一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
    • 数据管理知识体系指南（第二版）-第五章——数据建模和设计-学习笔记 键盘上的五花肉 数据治理数据库数据仓库数据治理
      目录5.1引言5.1.1业务驱动因素5.1.2目标和原则5.1.3基本概念5.2活动5.2.1规划数据建模5.2.2建立数据模型5.2.3审核数据模型5.2.4维护数据模型5.3工具5.3.1数据建模工具5.3.2数据血缘工具5.3.3数据分析工具5.3.4元数据资料库5.3.5数据模型模式5.3.6行业数据模型5.4方法5.4.1命名约定的最佳实践5.4.2数据库设计中的最佳实践5.5数据建模和
    • 项目管理工具最佳实践 水岩
      各个公司的最佳实践去哪儿jira自定义使用1.jira编号对应git分支命名，后台增加监控程序，新增一个分支，自动解析分支中的jira编号，自动落地到数据库，完成映射2.各个发布系统间信息同步，消息中心（IC）+数据中心（DC）,广播消息加一站式查询，持续集成，推进代码检查质量，分钟级反馈质量检查反思：1.项目管好：针对一线研发人员，简单易用，而不是满足管理层的“统计度量”（...）简化分类字段，
    • Python Flask 使用数据库 安果移不动 pythonflask开发语言
      pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
    • .NET Core 将实体类转换为 SQL(ORM 映射) 你小子在看什么…… .NET.netcoresqlsugarpostgresql
      一、环境说明PostgreSQL数据库Npgsql数据库连接库SqlSugarORM框架二、映射流程1、创建数据库：检查指定数据库是否存在，如果不存在则创建数据库。2、初始化SqlSugar实例：使用SqlSugarClient初始化数据库连接配置。3、筛选实体类：根据指定的命名空间和排除条件筛选需要创建表的实体类。4、创建表：使用CodeFirst.InitTables方法创建数据库表。////
    • 数据库的魅力：深入探索与应用 小黄编程快乐屋 数据库
      数据库的魅力：深入探索与应用在数字化时代，数据库已经成为信息处理和存储的基石。无论是大型企业还是个人开发者，数据库都是不可或缺的工具。本文将带您深入探索数据库的魅力，了解其基本概念、类型以及应用，并分享一些实用的数据库管理技巧。一、数据库的基本概念数据库，简而言之，就是按照一定规则存储、组织和管理数据的仓库。它可以看作是一个电子化的文件柜，用于存储电子化的文件。这些文件按照特定的数据模型组织起来，
    • Thinkphp - 详细实现网站系统登录功能，附带 Mysql 数据库设置、Web 前端展示界面、信息校验等（详细代码，即设计过程） 王佳斌 +Thinkphpmysql前端数据库
      前言登录功能，是我们几乎开发每个系统都必须的模块。登录功能设计思路，主要包括几个方面。用户输入网址展示登录页面用户输入用户名，密码等点击登录进行信息校验校验通过之后，记录用户登录信息，跳转指定页面用户校验失败，提示失败信息页面目录具体功能实现为了快速搭建可用、美观的页面，我们采用一个比较成熟的前端框架Bootstrap。下面我们到Bootstrap的官网Bootsrap官网下载bootstrap。
    • 设置mysql 数据库和表 的编码方式UTF-8 盖盖衍上 中间件数据库mysqloracle
      要设置MySQL数据库表和字段的编码方式为UTF-8，可以使用下面的SQL语句：1.设置数据库默认编码为UTF-8：ALTERDATABASEyour_database_nameCHARACTERSETutf8mb4COLLATEutf8mb4_unicode_ci;2.创建表时指定编码为UTF-8：CREATETABLEyour_table_name(column1VARCHAR(100)CHA
    • kafka-eagle 配置文件修改使用自带的数据库 bright future cheer kafka数据库分布式
      ######################################multizookeeper&kafkaclusterlistSettingsprefixedwith‘kafka.eagle.’willbedeprecated,use‘efak.’instead######################################efak.zk.cluster.alias=clu
    • mysql 常见数据表操作 天狼1222 mysql系列mysql数据库
      前面介绍了数据库表的基本操作。把常用的做一个汇总。时间久了，记不得完整的语法了，再打开一看，就清楚了。1，表操作1，建表+注释CREATETABLEstudent(idINTPRIMARYKEYAUTO_INCREMENTCOMMENT'学号',nameVARCHAR(200)COMMENT'姓名',ageINTCOMMENT'年龄')COMMENT='学生表'2，修改注释--修改表注释-ALTE
    • GROM学习 码小白l golang
      什么是GROMGo语言ORM（对象关系映射）库，它提供了一种高效、简洁的方式来操作数据库。通过将数据库表映射为Go语言的结构体，GORM让数据库操作变得更加直观和类型安全。GORM支持主流的数据库系统，包括MySQL、PostgreSQL、SQLite和SQLServer等GORM提供了一系列的API来操作MySQL数据库。以下是一些常用的GORMAPI操作，以及它们在操作MySQL时的用法：安装
    • centos7 安装influxdb+telegraf+grafana 监控服务器 吕吕-lvlv grafana服务器运维
      influxdbinfluxdb是一个时间序列数据库,所有数据记录都会打上时间戳,适合存储数字类型的内容telegraftelegraf可以用于收集系统和服务的统计数据并发送到influxdbgrafanagrafana是一个界面非常漂亮,可直接读取influxdb数据展示成各种图表的开源可视化web软件安装并启动influxdb数据库vim/etc/yum.repos.d/influxdb.re
    • Mysql数据库MariaDB数据库MHA高可用程序 yichen_china
      声明：本次实验使用的是MariaDB数据库，所以本文中所出现的MariaDB与MySQL都是指的是MariaDB！！！MHA（MasterHA）是一款开源的MySQL的高可用程序，它为MySQL主从复制架构提供了automatingmasterfailover功能。MHA在监控到master节点故障时，会提升其中拥有最新数据的slave节点成为新的master节点，在此期间，MHA会通过于其它从节
    • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java 计算机程序老哥
      作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    • SQL运维_Unix下MySQL-8.0.18配置文件示例 Mostcow SQLsql运维unix
      SQL运维_Unix下MySQL-8.0.18配置文件示例MySQL是一个关系型数据库管理系统,由瑞典MySQLAB公司开发,属于Oracle旗下产品。MySQL是最流行的关系型数据库管理系统之一,在WEB应用方面,MySQL是最好的RDBMS(RelationalDatabaseManagementSystem,关系数据库管理系统)应用软件之一。MySQL是一种关系型数据库管理系统,关系数据库将
    • c#IQueryable和IEnumberable的区别 彭小彭~ c#基础c#
      IQueryable和IEnumerable是C#中处理集合的两个重要接口，常用于LINQ查询。它们有一些关键区别，适用于不同的场景：1.执行查询的位置IEnumerable:当你对一个IEnumerable序列使用LINQ操作时，这些操作是在本地内存中执行的。如果IEnumerable表示数据库中的数据（例如，使用EntityFramework时），那么整个数据集首先会被加载到内存中，然后再应用
    • 【Hadoop】使用Scala与Spark连接ClickHouse进行数据处理 音乐学家方大刚 ScalaHadoophadoopscalaspark
      风不懂不懂得叶的梦月不听不听闻窗里琴声意难穷水不见不曾见绿消红霜不知不知晓将别人怎道珍重落叶有风才敢做一个会飞的梦孤窗有月才敢登高在夜里从容桃花有水才怕身是客身是客此景不能久TieYann(铁阳)、薄彩生《不知晓》在大数据分析和处理领域，ApacheSpark是一个广泛使用的高性能、通用的计算框架，而ClickHouse作为一个高性能的列式数据库，特别适合在线分析处理（OLAP）。结合Scala语
    • Linux系统定时备份mysql数据库 er_得一 数据库mysqloracle
      1、创建shell脚本mysql_db_backup并赋予执行权限#!/bin/bash#备份目录BACKUP=/data/backup/db#当前时间DATETIME=$(date+%Y-%m-%d_%H%M%S)echo$DATETIME#数据库地址HOST=localhost#数据库用户名DB_USER=root#数据库密码DB_PW=pwd@123#备份的数据库名DATABASE=Apol
    • 解决sqlalchemy执行语句提示Not an executable object 娜年花开666 #Pythonandroid
      问题：fromsqlalchemyimportcreate_engine#数据库的变量HOST='127.0.0.1'PORT=3306DATA_BASE='itbz'USER='root'PWD='123456'#DB_URL=f'数据库的名+驱动名://{USER}:{PWD}@{HOST}:{PORT}/{DATA_BASE}'DB_URL=f'mysql+pymysql://{USER}:
    • MyBatis面试简答题 糯米小麻花啊 mybatis
      以下是一份MyBatis的高难度简答题，共20题：请解释MyBatis中#{}和${}的区别，并举例说明它们在实际应用中的使用场景。MyBatis的Mapper接口是如何与XML映射文件关联的？如何在MyBatis中实现动态SQL？请列举几种常见的动态SQL元素并解释其作用。描述MyBatis中的ResultMap的作用，并说明如何定义和使用它。MyBatis如何处理数据库中的null值？请解释M
    • 数据库（一）：基本语法一 从零开始的奋豆 数据库sql
      数据库第二次作业姓名：~~~，学号：~~~，专业：~~~2.66书写SQL查询来获取以下结果:A.星期五的ChangeClose。SELECTChangeCloseFROMNDXWHERETDayOfWeek='Friday';B.星期五的最小、最大和平均ChangeClose。SELECTMIN(ChangeClose)asMinChangeClose,MAX(ChangeClose)asMax
    • Java中文乱码浅析及解决方案 儿时可乖了 java
      在Java编程中，中文乱码是一种常见的问题，往往会导致程序在处理字符串时出现意料之外的结果。这通常是因为在不同编码之间转换或不正确处理编码时发生的。本文将剖析Java中文乱码的原因，并提出一些实用的解决方案。文章目录前言一、什么是乱码二、常见乱码场景三、解决方案1.统一编码标准2.数据库编码设置3.文件读写指定编码4.网络传输编码处理5.系统默认编码问题总结前言一、什么是乱码所谓“乱码”，就是指字
    • 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