飞达,本溪供求信息,可视楼宇对讲系统
今天，接着上一篇（ mysql 数据库 ）的基础上，我就写一下 java 怎样连接数据库，并且操作数据库。
首先，我们先来准备一下数据库连接的驱动：
mysql 的 jar 包下载地址：
oracle 的 jar 包下载地址：https://www.oracle.com/technetwork/cn/middleware/goldengate/downloads/
本文章还用到 c3p0 的数据库连接池
c3p0 的 jar 包下载地址：
接下来，我们就开始正式了解一下什么是 jdbc ，用 java 怎样连接数据库，并且怎样操作数据库。
jdbc（java database connectivity,java数据库连接）是一种用于执行sql语句的java api，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。jdbc提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道。其实也就是数据库厂商的jdbc接口实现，即对connection等接口的实现类的jar文件。
driver接口由数据库厂家提供，作为java开发人员，只需要使用driver接口就可以了。在编程中要连接数据库，必须先装载特定厂商的数据库驱动程序，不同的数据库有不同的装载方法。如：
装载mysql驱动：class.forname("com.mysql.jdbc.driver");
装载oracle驱动：class.forname("oracle.jdbc.driver.oracledriver");
connection与特定数据库的连接（会话），在连接上下文中执行sql语句并返回结果。drivermanager.getconnection(url, user, password)方法建立在jdbc url中定义的数据库connection连接上。
连接mysql数据库：connection conn = drivermanager.getconnection("jdbc:mysql://host:port/database", "user", "password");
连接oracle数据库：connection conn = drivermanager.getconnection("jdbc:oracle:thin:@host:port:database", "user", "password");
连接sqlserver数据库：connection conn = drivermanager.getconnection("jdbc:microsoft:sqlserver://host:port; databasename=database", "user", "password");
常用方法：
使用jdbc的步骤
加载jdbc驱动程序 → 建立数据库连接connection → 创建执行sql的语句statement → 处理执行结果resultset → 释放资源
通过初始化驱动类com.mysql.jdbc.driver，该类就在 mysql-connector-java-5.0.8-bin.jar中。如果你使用的是oracle数据库那么该驱动类将不同。
//加载数据库驱动程序(对应的 driver 实现类中有注册驱动的静态代码块.) string driver ="com.mysql.jdbc.driver"; class.forname(driver);
//通过 drivermanager 的 getconnection() 方法获取数据库连接. connection conn = drivermanager.getconnection(url,user,password);
这里需要提供：url包括以下（jdbc:mysql://ip地址:端口号/需要连接的数据库名字），例如：jdbc:mysql://localhost:3306/db_database05
数据库所处于的ip:127.0.0.1 (这里是本机，如果连接其他电脑上的数据库，请改变该ip)
数据库的端口号： 3306 （mysql专用端口号）
数据库名称： （根据你自己数据库中的名称填写）
数据库连接的用户名：user
数据库的登录密码：password
我要评论/*
* 数据库连接工具类
*/
package com.hzc.util;
import java.sql.connection;
import java.sql.drivermanager;
public class databaseutil {
/**
* 获取数据库连接
* @return connection 对象
*/
public static connection getconnection(){
connection conn = null;
try {
class.forname("com.mysql.jdbc.driver");
string url = "jdbc:mysql://localhost:3306/db_database05";
conn = drivermanager.getconnection(url,user,password); //这里的user和password根据自己的数据库登录和密码填写
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
/**
* 关闭数据库连接
* @param conn connection 对象
*/
public static void closeconnection(connection conn){
//判断 conn 是否为空
if(conn != null){
try {
conn.close(); //关闭数据库连接
} catch (exception e) {
e.printstacktrace();
}
}
}
}
这里在提供 c3p0 数据库连接池的方法
package jdbc;
import java.sql.connection;
import java.sql.resultset;
import java.sql.sqlexception;
import java.sql.statement;
import javax.sql.datasource;
import com.mchange.v2.c3p0.combopooleddatasource;
/*
* 操作jdbc的工具类，其中封装了一些工具方法
*/
public class jdbctools {
private static datasource datasource = null;
//数据库连接池应只初始化一次
static{
datasource = new combopooleddatasource("helloc3p0");
}
//数据库连接：通过读取配置文件从数据库服务器获取一个连接
public static connection getconnection() throws exception{
return datasource.getconnection();
}
//关闭 resultset、statement 和 connection
public static void release(resultset rs,statement statement,connection conn){
if(rs != null){
try {
rs.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
if(statement != null){
try {
statement.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接池的 connection 对象进行 close 时
//并不是真的进行关闭, 而是把该数据库连接会归还到数据库连接池中.
if(conn != null){
try {
conn.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
/*
* 处理数据库的事务
*/
//提交事务
public static void commit(connection conn){
if(conn != null){
try {
conn.commit();
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
//回滚事务
public static void rollback(connection conn){
if(conn != null){
try {
conn.rollback();
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
//开始事务
public static void begintx(connection conn){
if(conn != null){
try {
conn.setautocommit(false);
} catch (sqlexception e) {
e.printstacktrace();
}
}
}
}
c3p0 要在 src 目录下配置：创建一个名为 c3p0-config.xml ，并且记住要导入 c3p0 的 jar 包。
<?xml version="1.0" encoding="utf-8"?>
<c3p0-config>
<named-config name="helloc3p0">
<!-- 指定连接数据源的基本属性 -->
<property name="user">登录名</property>
<property name="password">密码</property>
<property name="driverclass">com.mysql.jdbc.driver</property>
<property name="jdbcurl">jdbc:mysql://localhost:3306/test</property>
<!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
<property name="acquireincrement">5</property>
<!-- 初始化数据库连接池时连接的数量 -->
<property name="initialpoolsize">5</property>
<!-- 数据库连接池中的最小的数据库连接数 -->
<property name="minpoolsize">5</property>
<!-- 数据库连接池中的最大的数据库连接数 -->
<property name="maxpoolsize">10</property>
<!-- c3p0 数据库连接池可以维护的 statement 的个数 -->
<property name="maxstatements">20</property>
<!-- 每个连接同时可以使用的 statement 对象的个数 -->
<property name="maxstatementsperconnection">5</property>
</named-config>
</c3p0-config>
用于执行静态sql语句并返回它所生成结果的对象。
三种statement类：
常用statement方法：
resultset提供检索不同类型字段的方法，常用的有：
resultset还提供了对结果集进行滚动的方法：
使用后依次关闭对象及连接：resultset → statement → connection
这里就直接提供数据库通用的查询方法，自己写成一个公用类，需要用查询方法的时候，就可以继承它，调用里面的方法。
package jdbc;
/*
* jdbc的工具方法
*/
import java.sql.connection;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.sql.resultsetmetadata;
import java.sql.sqlexception;
import java.sql.statement;
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;
import java.util.map;
import org.apache.commons.beanutils.beanutils;
public class dao {
// 执行 sql 语句,使用 preparedstatement
public void update(string sql, object... args) {
connection conn = null;
preparedstatement ps = null;
try {
conn = jdbctools.getconnection();
ps = conn.preparestatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setobject(i + 1, args[i]);
}
ps.executeupdate();
} catch (exception e) {
e.printstacktrace();
} finally {
jdbctools.release(null, ps, conn);
}
}
// 执行sql的方法,使用 statement：insert、update、delete,而不包含select
public void update(string sql) {
connection conn = null;
statement st = null;
try {
conn = jdbctools.getconnection();
st = conn.createstatement();
st.executeupdate(sql);
} catch (exception e) {
e.printstacktrace();
} finally {
jdbctools.release(null, st, conn);
}
}
// 查询一条记录,返回对应的对象
public <t> t get(class<t> clazz, string sql, object... args)throws exception {
list<t> result = getforlist(clazz, sql, args);
if (result.size() > 0) {
return result.get(0);
}
return null;
}
/*
* 传入 sql 语句和 class 对象,返回 sql 语句查询的记录对应的 class 类的对象的集合
*
* @param clazz: 对象的类型
*
* @param sql: sql 语句
*
* @param args: 填充 sql 语句的占位符的可变参数
*
* @return
*/
public <t> list<t> getforlist(class<t> clazz, string sql, object... args)throws exception {
list<t> list = new arraylist<>();
connection conn = null;
preparedstatement ps = null;
resultset rs = null;
try {
// 1、得到结果集
conn = jdbctools.getconnection();
ps = conn.preparestatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setobject(i + 1, args[i]);
}
rs = ps.executequery();
// 2、处理结果集，得到 map 的 list, 其中一个 map 对象就是一条记录. map 的 key 为 rs 中列的别名,
// map 的 value 为列的值
list<map<string, object>> values = handleresultsettomaplist(rs);
// 3、把 map 的 list 转为 clazz 对应的 list, 其中 map 的 key 即为 clazz 对应的对象的
// propertyname,
// 而 map 的 value 即为 clazz 对应的对象的 propertyvalue
list = transftermaplisttobeanlist(clazz, values);
} catch (exception e) {
e.printstacktrace();
} finally {
jdbctools.release(rs, ps, conn);
}
return list;
}
// 把 map 的 list 转为 clazz 对应的 list
public <t> list<t> transftermaplisttobeanlist(class<t> clazz, list<map<string, object>> values)throws exception {
list<t> result = new arraylist<>();
t bean = null;
if (values.size() > 0) {
for (map<string, object> m : values) {
bean = clazz.newinstance();
for (map.entry<string, object> entry : m.entryset()) {
string propertyname = entry.getkey();
object value = entry.getvalue();
beanutils.setproperty(bean, propertyname, value);
}
// 把 object 对象放入到 list 中
result.add(bean);
}
}
return result;
}
/**
* 处理结果集, 得到 map 的一个 list, 其中一个 map 对象对应一条记
*
* @param resultset
* @return
* @throws sqlexception
*/
public list<map<string, object>> handleresultsettomaplist(resultset rs) throws exception {
// 准备一个 list<map<string, object>>:键: 存放列的别名, 值: 存放列的值. 其中一个 map
// 对象对应着一条记录
list<map<string, object>> values = new arraylist<>();
list<string> columnlabels = getcolumnlabels(rs);
map<string, object> map = null;
// 处理 resultset, 使用 while 循环
while (rs.next()) {
map = new hashmap<>();
for (string columnlabel : columnlabels) {
object value = rs.getobject(columnlabel);
map.put(columnlabel, value);
}
// 把一条记录的一个 map 对象放入 list 中
values.add(map);
}
return values;
}
/**
* 获取结果集的 columnlabel 对应的 list
*
* @param rs
* @return
* @throws sqlexception
*/
private list<string> getcolumnlabels(resultset rs) throws exception {
list<string> labels = new arraylist<>();
resultsetmetadata rsmd = rs.getmetadata();
for (int i = 0; i < rsmd.getcolumncount(); i++) {
labels.add(rsmd.getcolumnlabel(i + 1));
}
return labels;
}
// 返回某条记录的某一个字段的值 或 一个统计的值(一共有多少条记录等.)
@suppresswarnings("unchecked")
public <e> e getforvalue(string sql, object... args) {
// 1. 得到结果集: 该结果集应该只有一行, 且只有一列
connection conn = null;
preparedstatement ps = null;
resultset rs = null;
try {
// 1. 得到结果集
conn = jdbctools.getconnection();
ps = conn.preparestatement(sql);
for (int i = 0; i < args.length; i++) {
ps.setobject(i + 1, args[i]);
}
rs = ps.executequery();
if (rs.next()) {
return (e) rs.getobject(1);
}
} catch (exception ex) {
ex.printstacktrace();
} finally {
jdbctools.release(rs, ps, conn);
}
// 2. 取得结果
return null;
}
}
掌握好 jdbc 的连接，java 写很多项目都要与数据库打交道。
自己写的不是专业，希望大家提一下意见。自己也是在学习 java 的小白。写一下博客记录一下自己的学习情况。写一下博客，能了解自己学习的水平。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
浅析我对 String、StringBuilder、StringBuffer 的理解
使用IDEA搭建SSM框架的详细教程(spring + springMVC +MyBatis)
Springboot整合freemarker 404问题解决方案
引入mybatis-plus报 Invalid bound statement错误问题的解决方法
网友评论