使用开源的连接池DBCP

最新推荐文章于 2025-07-09 13:41:17 发布

原创最新推荐文章于 2025-07-09 13:41:17 发布 · 96 阅读

CC 4.0 BY-SA版权

文章标签：

1.需要用的JAR包commons-collections-3.2.jar，commons-pool-1.3.jar，commons-dbcp-1.2.1.jar
2.需要一个配置文件properties（内容为下面XML）
3.创建数据源BasicDataSourceFactory.createDataSource(properties);


/*
DataSource用来取代DriverManager来获取Connection；
通过DataSource获得Connection速度很快；
通过DataSource获得的Connection都是已经被包裹过的（不是驱动原来的连接），他的close方法已经被修改，不是直接关闭连接，而是释放到连接池中。
一般DataSource内部会用一个连接池来缓存Connection，这样可以大幅度提高数据库的访问速度；
连接池可以理解成一个能够存放Connection的Collection；
我们的程序只和DataSource打交道，不会直接访问连接池；
*/


#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc
username=root
password=

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000


#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=gbk

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED


package com.meiyoudao.jdbc;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;


public final class JdbcUtils {
	private static String url = "jdbc:mysql://localhost:3306/jdbc";
	private static String user = "root";
	private static String password = "";
	private static DataSource myDataSource = null;

	private JdbcUtils() {
	}

	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");

			Properties prop = new Properties();
			// prop.setProperty("driverClassName", "com.mysql.jdbc.Driver");
			// prop.setProperty("user", "user");

			InputStream is = JdbcUtils.class.getClassLoader()
					.getResourceAsStream("dbcpconfig.properties");
			prop.load(is);
			myDataSource = BasicDataSourceFactory.createDataSource(prop);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}

	public static DataSource getDataSource() {
		return myDataSource;
	}

	public static Connection getConnection() throws SQLException {
		// return DriverManager.getConnection(url, user, password);
		return myDataSource.getConnection();
	}

	public static void free(ResultSet rs, Statement st, Connection conn) {
		try {
			if (rs != null)
				rs.close();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				if (st != null)
					st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			} finally {
				if (conn != null)
					try {
						conn.close();
						// myDataSource.free(conn);
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}
	}
}


/**
查询带有参数，和行映射方法:
	public Object queryForObject(String sql, Object[] args, RowMapper rowMapper),使用自定义的UserRowMapper完成映射。
一个RowMapper的常用实现BeanPropertyRowMapper,该实现可将结果集转换成一个Java Bean(字段名与Java Bean属性名不符合规范，可用别名处理)。
public List query(String sql, Object[] args, RowMapper rowMapper)返回多个结果。
public int queryForInt(String sql)(如:select count(*) from user),其他结果比如String可用queryForObject方法向下转型。
public Map queryForMap(String sql, Object[] args)返回若类型的Map（key：字段名或别名，value：列值）。
public List queryForList(String sql, Object[] args)返回多Map。

*/


package com.meiyoudao.jdbc.spring;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.List;
import java.util.Map;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.meiyoudao.jdbc.JdbcUtils;
import com.meiyoudao.jdbc.domain.User;

/**
 * 
 *  Spring 的 JdbcTemplate 使用方法
 */
public class JdbcTemplateTest {

	static JdbcTemplate jdbc = new JdbcTemplate(JdbcUtils.getDataSource());

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		User user = findUser("zhangsan");
		// System.out.println("user:" + user);

		// System.out.println("users:" + findUsers(3));

		// System.out.println("user count:" + getUserCount());

		// System.out.println("user name:" + getUserName(1));

		System.out.println("data:" + getData(1));
	}

	static int addUser(final User user) {
		jdbc.execute(new ConnectionCallback() {

			public Object doInConnection(Connection con) throws SQLException,
					DataAccessException {
				String sql = "insert into user(name,birthday, money) values (?,?,?) ";
				PreparedStatement ps = con.prepareStatement(sql,
						Statement.RETURN_GENERATED_KEYS);
				ps.setString(1, user.getName());
				ps.setDate(2, new java.sql.Date(user.getBirthday().getTime()));
				ps.setFloat(3, user.getMoney());
				ps.executeUpdate();

				ResultSet rs = ps.getGeneratedKeys();
				if (rs.next())
					user.setId(rs.getInt(1));
				return null;
			}
		});
		return 0;
	}

	static Map getData(int id) {
		String sql = "select id as userId, name, money, birthday  from user where id="
				+ id;
		return jdbc.queryForMap(sql);
	}

	static String getUserName(int id) {
		String sql = "select name from user where id=" + id;
		Object name = jdbc.queryForObject(sql, String.class);
		return (String) name;
	}

	static int getUserCount() {
		String sql = "select count(*) from user";
		return jdbc.queryForInt(sql);
	}

	static List findUsers(int id) {
		String sql = "select id, name, money, birthday  from user where id<?";
		Object[] args = new Object[] { id };
		int[] argTypes = new int[] { Types.INTEGER };
		List users = jdbc.query(sql, args, argTypes, new BeanPropertyRowMapper(
				User.class));
		return users;
	}

	static User findUser(String name) {
		String sql = "select id, name, money, birthday  from user where name=?";
		Object[] args = new Object[] { name };
		Object user = jdbc.queryForObject(sql, args, new BeanPropertyRowMapper(
				User.class));
		return (User) user;
	}

	static User findUser1(String name) {
		String sql = "select id, name, money, birthday  from user where name=?";
		Object[] args = new Object[] { name };
		Object user = jdbc.queryForObject(sql, args, new RowMapper() {

			public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
				User user = new User();
				user.setId(rs.getInt("id"));
				user.setName(rs.getString("name"));
				user.setMoney(rs.getFloat("money"));
				user.setBirthday(rs.getDate("birthday"));
				return user;
			}
		});
		return (User) user;
	}
}


package com.meiyoudao.jdbc.spring;

import java.util.HashMap;
import java.util.Map;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

import com.meiyoudao.jdbc.JdbcUtils;
import com.meiyoudao.jdbc.domain.User;

/**
 * 
 * NamedParameterJdbcTemplate内部包含了一个JdbcTemplate， 
 * 所以JdbcTemplate能做的事情NamedParameterJdbcTemplate都能干；
 * NamedParameterJdbcTemplate相对于JdbcTemplate主要增加了参数
 * 可以命名的功能。
 * public Object queryForObject(String sql, Map paramMap,
 *  RowMapper rowMapper)
 * public Object queryForObject(String sql, 
 * SqlParameterSource paramSource, RowMapper rowMapper)
 * 	SqlParameterSource的两个主要实现MapSqlParameterSource
 * 	和BeanPropertySqlParameterSource
 * public int update(String sql, SqlParameterSource
 *  paramSource, KeyHolder generatedKeyHolder)保存数据获得主键。
 * 
 */
public class NamedJdbcTemplate {
	static NamedParameterJdbcTemplate named = new NamedParameterJdbcTemplate(
			JdbcUtils.getDataSource());

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		User user = new User();
		user.setMoney(10);
		user.setId(2);
		System.out.println(findUser1(user));
	}

	static void addUser(User user) {
		String sql = "insert into user(name,birthday, money) values (:name,:birthday,:money) ";
		SqlParameterSource ps = new BeanPropertySqlParameterSource(user);
		KeyHolder keyHolder = new GeneratedKeyHolder();
		named.update(sql, ps, keyHolder);
		int id = keyHolder.getKey().intValue();
		user.setId(id);

		Map map = keyHolder.getKeys();
	}

	static User findUser(User user) {
		String sql = "select id, name, money, birthday  from user "
				+ "where money > :m and id < :id";
		Map params = new HashMap();
		// params.put("n", user.getName());
		params.put("m", user.getMoney());
		params.put("id", user.getId());
		Object u = named.queryForObject(sql, params, new BeanPropertyRowMapper(
				User.class));
		return (User) u;
	}

	static User findUser1(User user) {
		String sql = "select id, name, money, birthday  from user "
				+ "where money > :money and id < :id";
		SqlParameterSource ps = new BeanPropertySqlParameterSource(user);
		Object u = named.queryForObject(sql, ps, new BeanPropertyRowMapper(
				User.class));
		return (User) u;
	}

}