使用JDBC连接数据库

使用JDBC连接数据库 

 一准备

1、 数据库服务是否开启

2、 连接的数据库是否是远程的

是检查远程连接的服务是否开启,或者用户是否有远程登录的权限

3、 检查客户机与数据库服务器之间是否能ping通

 

4、 准备要连接的数据库的驱动包

注意:请根据自己的数据库版本和jdk选择jar包

 

Oracle ojdbc6.jar

SQLServer :sqljdbc4.jar

MySql:mysql-connector-java-5.1.44-bin.jar

编写BaseDao要用到的jar包

dom4j-2.1.1.jar 用于xml解析

jstl.jar   Result对象需要用到jstl支持

 

二数据库连接文件的配置

 

1、 使用属性文件(.properties)配置

 

#Oracle配置

#driver=oracle.jdbc.driver.OracleDriver

#connStr=jdbc:oracle:thin:@192.168.11.111:1521:orcl

#userName=scott

#userPwd=scott

 

#MySql 配置

userName=root

userPwd=root

connStr=jdbc:mysql://192.168.11.111:3306/PetDB

driver=com.mysql.jdbc.Driver

 

#SQL Server配置

#userName=sa

#userPwd=sasa

#connStr=jdbc:sqlserver://localhost:1433;databaseName=PetDB

#driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

 

2、 使用xml配置

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration SYSTEM "DBConfig.dtd">

<!--

Oracle配置

<configuration>

<driver>oracle.jdbc.driver.OracleDriver</driver>

<connStr>jdbc:oracle:thin:@192.168.11.111:1521:orcl</connStr>

<userName>scott</userName>

<userPwd>scott</userPwd>

</configuration>

 -->

 

<!--

SQLServer 配置

<configuration>

<driver>com.microsoft.sqlserver.jdbc.SQLServerDriver</driver>

<connStr>jdbc:sqlserver://localhost:1433;databaseName=PetDB</connStr>

<userName>sa</userName>

<userPwd>sasa</userPwd>

 

</configuration>

 

 -->

 

 

 

<configuration>

<driver>com.mysql.jdbc.Driver</driver>

<connStr>jdbc:mysql://192.168.11.111/PetDB</connStr>

<userName>root</userName>

<userPwd>root</userPwd>

 

</configuration>

三  BaseDao的编写和测试

1、 BaseDao的编写

package com.hx.basedao;

 

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.Field;

import java.math.BigDecimal;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Properties;

 

import javax.servlet.jsp.jstl.sql.Result;

import javax.servlet.jsp.jstl.sql.ResultSupport;

 

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.OutputFormat;

import org.dom4j.io.SAXReader;

import org.dom4j.io.XMLWriter;

public class BaseDao {

 

private static final String USER_PWD = "userPwd";

private static final String USER_NAME = "userName";

private static final String CONN_STR = "connStr";

private static final String DRIVER = "driver";

private static String driver = "";

private static String connStr = "";

private static String userName = "";

private static String userPwd = "";

 

static {

try {

getDBConfigByXML();

} catch (Exception e) {

e.printStackTrace();

}

}

 

public static void getDBConfigPro() {

// 创建属性文件对象

Properties p = new Properties();

// 获取要读取的属性文件的输入流

 

// 注意属性文件的路径

// 路径只能以/开头,表示根目录

// 不能以./或../开头

// 或者其他目录开头

// 参考网址:https://blog.csdn.net/cyxinda/article/details/78254057

InputStream is = BaseDao.class.getResourceAsStream("/DBConfig.properties");

// 获取BaseDao的路径

// System.out.println(BaseDao.class.getClassLoader().getResource("").getPath());

// 输出此代码，获取到路径，对比配置文件

 

try {

// 把流加载到属性文件,读取对象

p.load(is);

} catch (Exception ex) {

ex.printStackTrace();

} finally {

try {

is.close();

} catch (IOException e) {

e.printStackTrace();

}

}

driver = p.getProperty(DRIVER);

connStr = p.getProperty(CONN_STR);

userName = p.getProperty(USER_NAME);

userPwd = p.getProperty(USER_PWD);

 

}

 

public static void getDBConfigByXML() throws Exception {

SAXReader reader = new SAXReader();

// 通过read方法读取一个文件 转换成Document对象

// System.out.println(BaseDao.class.getClassLoader().getResource("OracleConn.xml").getPath());

/// E:/WorkSpace/Utils/bin/OracleConn.xml

Document doc = reader.read(new File(BaseDao.class.getClassLoader().getResource("DBConfig.xml").getPath()));

 

// 获取根节点

Element root = doc.getRootElement();// configuration

 

// 获取根节点的子节点

List<Element> es = root.elements();

 

for (Element e : es) {

if (e.getName().equals(DRIVER)) {

driver = e.getText().trim();

// System.out.println(driver);

} else if (e.getName().equals(CONN_STR)) {

connStr = e.getText().trim();

} else if (e.getName().equals(USER_NAME)) {

userName = e.getText().trim();

} else if (e.getName().equals(USER_PWD)) {

userPwd = e.getText().trim();

}

}

 

}

 

/**

 * 获取数据库连接的方法

 *

 * @return 数据库连接对象

 */

public static Connection getConn() {

// 创建连接对象

Connection conn = null;

try {

// 1、加载驱动

Class.forName(DRIVER);

// 2、获取连接

conn = DriverManager.getConnection(CONN_STR, USER_NAME, USER_PWD);

} catch (Exception ex) {

ex.printStackTrace();

 

}

return conn;// 返回连接对象

}

 

/**

 * 关闭所有资源

 *

 * @param conn 连接对象

 * @param stmt 命令对象

 * @param rs   结果集

 */

public static void closeAll(Connection conn, Statement stmt, ResultSet rs) {

try {

if (rs != null) {

rs.close();

}

} catch (Exception ex) {

ex.printStackTrace();

 

}

try {

if (stmt != null) {

stmt.close();

}

} catch (Exception ex) {

ex.printStackTrace();

 

}

try {

if (conn != null) {

conn.close();

}

} catch (Exception ex) {

ex.printStackTrace();

 

}

}

 

/**

 * 参数赋值的方法

 *

 * @param pstmt  命令对象

 * @param params 参数数组

 * @throws Exception

 */

public static void setParams(PreparedStatement pstmt, Object[] params) throws Exception {

// 判断sql语句是否有参数

if (params != null && params.length > 0) {

// 循环给sql语句的参数赋值

for (int i = 0; i < params.length; i++) {

pstmt.setObject(i + 1, params[i]);

}

}

}

 

/**

 * 执行增、删、改sql语句的通用方法

 *

 * @param sql    要执行的sql语句

 * @param params sql语句需要的参数，为null时表示sql语句没有参数

 * @return 受影响的行数

 * @throws Exception

 */

public static int update(String sql, Object[] params) {

int row = 0;// 保存执行后受影响的行数

Connection conn = null;// 连接对象

PreparedStatement pstmt = null;// 命令对象,预编译

try {

// 1、获取连接对象(调用ConnectionUtil类中的getConn()方法)

conn = getConn();

// 2、获取命令对象

pstmt = conn.prepareStatement(sql);

// 判断sql语句是否需要设置参数

if (params != null) {

setParams(pstmt, params);

}

// 3、执行sql语句

row = pstmt.executeUpdate();

} catch (Exception ex) {

ex.printStackTrace();

 

} finally {

// 关闭资源

closeAll(conn, pstmt, null);

}

return row;

}

 

/**

 * 查询的通用方法

 *

 * @param sql    要执行的sql语句

 * @param params sql语句需要的参数数组

 * @return result对象

 */

public static Result getResult(String sql, Object[] params) {

 

Connection conn = null;// 连接对象

PreparedStatement pstmt = null;// 命令对象

ResultSet rs = null;// 结果集

Result result = null;

try {

// 获取连接对象

conn = getConn();

// 根据连接对象获取命令对象

pstmt = conn.prepareStatement(sql);

// 判断sql语句是否需要设置参数

if (params != null) {

setParams(pstmt, params);

}

// 执行命令

rs = pstmt.executeQuery();

// 把结果集转换为result对象

result = ResultSupport.toResult(rs);

 

} catch (Exception ex) {

ex.printStackTrace();

} finally {

// 关闭资源

closeAll(conn, pstmt, rs);

}

 

return result;

}

/**

 * -查询的通用方法 - 这个方法容易报错

 *

 * @param sql    要执行的sql语句

 * @param params sql语句需要的参数数组

 * @return result对象

 */

public static List<?> queryByResultSet(String sql, Object[] params, Class<?> clz) {

List list = null;// 保存查询结果

Connection conn = null;// 连接对象

PreparedStatement pstmt = null;// 命令对象

ResultSet rs = null;// 结果集

 

try {

// 获取连接对象

conn = getConn();

// 根据连接对象获取命令对象

pstmt = conn.prepareStatement(sql);

// 判断sql语句是否需要设置参数

if (params != null) {

setParams(pstmt, params);

}

// 执行命令

rs = pstmt.executeQuery();

// 判断是否存在记录

if (rs != null) {// 有数据

// rs.next()

// 存在记录 rs就要向上移一条记录 因为rs.next会滚动一条记录了

// rs.previous();

 

// 在执行while 循环

list = new ArrayList();

while (rs.next()) {

// 结果集的元数据,结果集是由数据库表中一行行数据组成的

// 这里获取的是一行数据

ResultSetMetaData metaData = rs.getMetaData();

int count = metaData.getColumnCount();// 获取总列数；

// System.out.println("总列数"+count);

Object obj = clz.newInstance();// 获取类对象的实例；

for (int i = 0; i < count; i++) {

Object value = rs.getObject(i + 1);// 获取对应列所对应的字段值

// System.out.println("对应列所对应的字段值"+value);

String colname = metaData.getColumnName(i + 1).toLowerCase();// 获取对应列名；

// System.out.println("列名:"+colname);

// oracle 不管你建表时字段是大写还是小写,它一律帮你转换成大写

// 建议所有java类的属性都小写

 

// ①没有对应字段；②属性为私有时获取Field用的方法不是getDeclaredField。否则会报错

Field field = clz.getDeclaredField(colname);// 通过列名获取到字段对象，就是我们所说的属性；

field.setAccessible(true);

 

// 此处调用了Field类的set方法，就是给封装类对象所对应的字段赋值操作，

// 这样数据表对应的封装类的对象类就有值了，相当于查询到了理想的结果。

 

// 判断字段的数据类型

// Oracle 中 number类型 通过ResultSet 的 getObject() 返回的是 BigDecimal 类型

if (value instanceof BigDecimal) {

// System.out.println("bigdecimal");

int num = ((BigDecimal) value).intValue();

field.set(obj, num);

} else {

field.set(obj, value);// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值

}

 

}

 

// 因为考虑到查询的结果不止一条，用集合进行操作

 

// 然后返回该结果集对象

list.add(obj);

}

 

}

 

} catch (Exception ex) {

ex.printStackTrace();

} finally {

// 关闭资源

closeAll(conn, pstmt, rs);

}

 

return list;

}

 

/**

 * 查询的通用方法 将表中的一行数据保存到一个map对象中,key为列(字段)的下标,value为该列(字段)的值 返回保存map的泛型集合

 *

 * @param sql    要做执行的 sql语句

 * @param params SQL语句需要的参数

 * @return

 */

public static List<Map> QueryByResultSet(String sql, Object[] params) {

Connection conn = null;

PreparedStatement pstmt = null;

ResultSet rs = null;

try {

// 1.获取conn

conn = getConn();

// 2.获取Statement

pstmt = conn.prepareStatement(sql);

if (params != null) {

setParams(pstmt, params);

}

// 4.执行查询，得到ResultSet

rs = pstmt.executeQuery(sql);

// 5.处理ResultSet

List<Map> list = new ArrayList<Map>();

ResultSetMetaData metaData = rs.getMetaData();

int columnCount = metaData.getColumnCount();

while (rs.next()) {

Map rowData = new HashMap();

for (int i = 1; i < columnCount; i++) {

rowData.put(metaData.getColumnName(i).toLowerCase(), rs.getObject(i));

 

}

list.add(rowData);

}

 

return list;

} catch (Exception e) {

e.printStackTrace();

 

} finally {

// 6.关闭数据库相应的资源

closeAll(conn, pstmt, rs);

}

 

return null;

}

}

 

测试

在数据库创建表,没有数据库的先创建数据库

在项目中创建表对应的类

接下来进行单元测试

 

1.1 在Oracle服务器 的ORCL中创建表

 

/*

id;神兽的编号

masterId;所属的世界之主编号

name;神兽的昵称

health;健康值

lover;亲密度

type;类型

grade;// 神兽青龙所特有的

*/

 

drop table Dragon;

create table dragon(

id number(5) primary key not null,

masterid number(5) ,

name varchar2(10) ,

health number(3),

lover number(3),

type varchar2(10),

grade varchar(10)

)

--插入数据

insert into(id,masterid,name,health,lover,type,grade) values()

--创建序列

create sequence dragonid_sequ

increment by 1

start with 10000

nomaxvalue

nocycle

cache 10;

 

 

--查询表

select * from dragon

 

--删除表

drop table   dragon

 

1.2 在SQL Server 中创建PetDB数据库 和 Dragon表

 

--创建PetDB数据库

create database StudentDB

on primary--主文件组

(

--数据库文件的逻辑名称,不能重复

name='PetDB',

--数据库物理文件名(绝对路径)

filename='E:PetDB.mdf',

--数据库文件初始大小

size=10MB,

--数据文件增长量

filegrowth=1MB

)

log on

(

--日志文件的逻辑名称,不能重复

name='PetDB_log',

--日志物理文件名(绝对路径)

filename='E:PetDB_log.ldf',

--日志文件初始大小

size=3MB,

--日志文件增长量

filegrowth=1MB

)

go

--创建Dragon表

create table Dragon(

id numeric(5, 0)identity(1,1)  primary key not null,

masterid numeric(5, 0) ,

name varchar(10) ,

health numeric(3, 0),

lover numeric(3, 0),

type varchar(10),

grade varchar(10)

)

 

1.3 在MySql中创建PetDB数据库 和 Dragon表

创建数据库

 CREATE DATABASE `PetDB`

创建表

CREATE TABLE `dragon` (

`id` int(11) NOT NULL AUTO_INCREMENT,  

`masterId` int(11) DEFAULT NULL,

`name` varchar(45) DEFAULT NULL,

`health` int(11) DEFAULT NULL,

`lover` int(11) DEFAULT NULL,

`type` varchar(45) DEFAULT NULL,

 `grade` varchar(45) DEFAULT NULL,

 PRIMARY KEY (`id`))

 ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf

1.4 在java项目中创建Dragon类

 

package com.hx.entity;

 

public class Dragon {

 

/**

 * 神兽的编号

 */

private int id;

/**

 * 所属的世界之主编号

 */

private int masterid;

/**

 * 神兽的昵称

 */

private String name;

/**

 * 健康值

 */

private int health;

 

/**

 * 亲密度

 */

private int lover;

 

/**

 * 类型

 */

private String type;

 

/**

 * 等级

 */

private  String grade;// 神兽青龙所特有的

 

public int getId() {

return id;

}

 

public void setId(int id) {

this.id = id;

}

 

public int getMasterid() {

return masterid;

}

 

public void setMasterId(int masterId) {

this.masterid = masterId;

}

 

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

 

public int getHealth() {

return health;

}

 

public void setHealth(int health) {

this.health = health;

}

 

public int getLover() {

return lover;

}

 

public void setLover(int lover) {

this.lover = lover;

}

 

public String getType() {

return type;

}

 

public void setType(String type) {

this.type = type;

}

 

public String getGrade() {

return grade;

}

 

public void setGrade(String grade) {

this.grade = grade;

}

 

@Override

public String toString() {

return "Dragon [id=" + id + ", masterId=" + masterid + ", name=" + name + ", health=" + health + ", lover="

+ lover + ", type=" + type + ", grade=" + grade + "]";

}

 

 

}

1.5 开始测试

测试比较简单只测了查询

有兴趣的话可以更改配置文件测试不同数据库之间的连接,和对表的其他操作

 

package com.hx.test;

 

import static org.junit.Assert.*;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.junit.Test;

import com.hx.basedao.BaseDao;

import com.hx.entity.Dragon;

 

public class TestJDBC {

public static void main(String[] args) throws IOException {

test();

}

 

@Test

public static void test() {

 

String sql = "select * from dragon";

 

List<Dragon> dList = (List<Dragon>) BaseDao.queryByResultSet(sql, null, Dragon.class);

 

for (Dragon dragon : dList) {

System.out.println(dragon.toString());

}

}

 

@Test

public static void test2() {

String sql = "select * from dragon";

List<Map> list = BaseDao.QueryByResultSet(sql, null);

for (Map m : list) {

System.out.println(m.get("id"));

}

}

}

 

 

 

 

 

 

 

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

 

 

 

 

来自为知笔记(Wiz)