如何用eclipse将数据库oracle数据相连接，实现查询数据库中的信息以及更改添加表中内容

话不多说，直接上代码。

package com.yc.jdbc;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class DBHelper {
static{
try {
Class.forName(DBProperties.getDBDbProperties().getProperty("driver"));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}

/**
* 获取数据库连接的方法
* @return
*/
private Connection getConnection(){
Connection con=null;
try {
con=DriverManager.getConnection(DBProperties.getDBDbProperties().getProperty("url"),DBProperties.getDBDbProperties());
} catch (SQLException e) {
e.printStackTrace();
}
return con;
}

/**
* 给预编译语句中的占位符?赋值
* @param pstmt 要赋值的预编译块
* @param params 给占位符的值
* @throws SQLException 
*/
private void setParams(PreparedStatement pstmt,List<Object> params){
if( params!=null && params.size()>0 ){
for(int i=0,len=params.size();i<len;i++){
try {
pstmt.setOb
4000
ject(i+1,params.get(i));
} catch (SQLException e) {
System.out.println( "第 "+(i+1)+" 个注值失败..."+ e.getMessage() );
e.printStackTrace();
}
}
}
}

/**
* 给预编译语句中的占位符?赋值
* @param pstmt 要赋值的预编译块
* @param params 给占位符的值
* @throws SQLException 
*/
private void setParams(PreparedStatement pstmt,Object ... params){
if( params!=null && params.length>0 ){
for(int i=0,len=params.length;i<len;i++){
try {
pstmt.setObject(i+1,params[i]);
} catch (SQLException e) {
System.out.println( "第 "+(i+1)+" 个注值失败..."+ e.getMessage() );
e.printStackTrace();
}
}
}
}

/**
* 关闭资源的方法
* @param rs 要关闭的结果集
* @param pstmt 要关闭的预编译块
* @param con 要关闭的连接
*/
private void close(ResultSet rs,PreparedStatement pstmt,Connection con){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

if(pstmt!=null){
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

if(con!=null){
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
* 关闭资源的方法
* @param pstmt 要关闭的预编译块
* @param con 要关闭的连接
*/
private void close(PreparedStatement pstmt,Connection con){
if(pstmt!=null){
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

if(con!=null){
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
* 更新数据的方法
* @param sql 要执行的sql语句
* @param params 要执行的sql语句中对应占位符?的值，在添加是必须按照sql语句中?的顺序给定
* @return 语句执行后，影响的数据的行数
*/
public int update(String sql,List<Object> params){
int result=0;

Connection con=null;
PreparedStatement pstmt=null;

try {
con=this.getConnection(); //获取数据库的连接

pstmt=con.prepareStatement(sql);//预编译执行语句

//给预编译sql语句中的占位符赋值
setParams(pstmt, params);

//执行更新并获取结果
result=pstmt.executeUpdate();

} catch (SQLException e) {
e.printStackTrace();
} finally{
close(pstmt,con);
}
return result;
}

/**
* 带事务更新数据的方法
* @param sqld 要执行的sql语句的集合
* @param paramss 要执行的sql语句中对应占位符?的值，在添加是必须按照sql语句中?的顺序给定
* @return 语句执行后，影响的数据的行数
*/
public int update(List<String> sqls,List<List<Object>> paramss){
int result=0;
Connection con=null;
PreparedStatement pstmt=null;
try {
con=this.getConnection(); //获取数据库的连接
con.setAutoCommit(false);//将自动提交事务改成false
if(sqls!=null && sqls.size()>0){
int index=0;
for(String sql:sqls){ //循环执行每一条sql语句
pstmt=con.prepareStatement(sql);//预编译执行语句
//给预编译sql语句中的占位符赋值
setParams(pstmt,paramss.get(index++));
//执行更新并获取结果
result=pstmt.executeUpdate();
}
}
con.commit(); //如果所有语句都执行完成，且没有出现异常，则提交
} catch (SQLException e) {
try {
con.rollback();//一旦出错，所有数据回滚。即当前所有的执行全部回退撤销。
} catch (SQLException e1) {
e1.printStackTrace();
} 
e.printStackTrace();
} finally{
try {
con.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
close(pstmt,con);
}
return result;
}

/**
* 更新数据的方法
* @param sql 要执行的sql语句
* @param params 要执行的sql语句中对应占位符?的值，在添加是必须按照sql语句中?的顺序给定
* @return 语句执行后，影响的数据的行数
*/
public int update(String sql,Object ... params){
int result=0;

Connection con=null;
PreparedStatement pstmt=null;

try {
con=this.getConnection(); //获取数据库的连接

pstmt=con.prepareStatement(sql);//预编译执行语句

//给预编译sql语句中的占位符赋值
setParams(pstmt, params);

//执行更新并获取结果
result=pstmt.executeUpdate();

} catch (SQLException e) {
e.printStackTrace();
} finally{
close(pstmt,con);
}
return result;
}

/**
* 根据结果集对象获取这个结果集中每个列的列名，并以数组的方式返回
* @param rs 要获取每个列列名的结果集对象
* @return 存放了这个结果集中所有列的列名的一个字符串数组
* @throws SQLException 
*/
public String[] getColumnName(ResultSet rs) throws SQLException{
ResultSetMetaData rsmd=rs.getMetaData();
int len=rsmd.getColumnCount(); //获取给定结果集中列的数量
String[] colNames=new String[len];

//循环取出每个列的列名存放到colNames数组中
for(int i=0;i<len;i++){
colNames[i]=rsmd.getColumnName(i+1).toLowerCase(); //将每个列的列名全部转为小写字母
}
return colNames;
}

/**
* 查询
* @param sql 要执行的查询语句
* @param params 查询语句中对应?的值
* @return 所有数据存放在一个list中，每一行数据存放在一个map中
*/
public List<Map<String,Object>> finds(String sql,List<Object> params){
List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
Connection con=null;
PreparedStatement pstmt=null;
ResultSet rs=null;

try {
con=getConnection(); //获取连接
pstmt=con.prepareStatement(sql); //预编译查询语句
setParams(pstmt, params); //给预编译语句中的占位符赋值
rs=pstmt.executeQuery(); //执行查询语句并获取结果集
Map<String,Object> map=null;
String[] colNames=getColumnName(rs); //获取结果集中每个列的列名
while(rs.next()){  //处理结果
//每循环一次就是一行数据，我们需要将这一行数据的每一个列中的值存放到一个map中，以列名为键，以这一列的值为值、
map=new HashMap<String,Object>();

//循环取出每一个列，通过列名
for(String colName:colNames){
map.put(colName, rs.getObject(colName));
}

//当所有列已经循环取完后，说明这一条数据已经取完了，那么我们将这一条数据存放到list中
list.add(map);
map=null;
}
} catch (SQLException e) {
e.printStackTrace();
} finally{
close(rs, pstmt, con);
}
return list;
}

/**
* 针对返回数据只有一行的情况
* @param sql
* @param params
* @return
*/
public Map<String,String> find(String sql,List<Object> params){
Map<String,String> map=null;
Connection con=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
con=getConnection(); //获取连接
pstmt=con.prepareStatement(sql); //预编译查询语句
setParams(pstmt, params); //给预编译语句中的占位符赋值
rs=pstmt.executeQuery(); //执行查询语句并获取结果集
String[] colNames=getColumnName(rs); //获取结果集中每个列的列名
if(rs.next()){  //处理结果
//每循环一次就是一行数据，我们需要将这一行数据的每一个列中的值存放到一个map中，以列名为键，以这一列的值为值、
map=new HashMap<String,String>();

//循环取出每一个列，通过列名
for(String colName:colNames){
map.put(colName, rs.getString(colName));
}
}
} catch (SQLException e) {
e.printStackTrace();
} finally{
close(rs, pstmt, con);
}
return map;
}

/**
* 查询
* @param sql 要执行的查询语句
* @param params 查询语句中对应?的值
* @return 所有数据存放在一个list中，每一行数据存放在一个map中
*/
public List<Map<String,Object>> finds(String sql,Object ... params){
List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
Connection con=null;
PreparedStatement pstmt=null;
ResultSet rs=null;

try {
con=getConnection(); //获取连接
pstmt=con.prepareStatement(sql); //预编译查询语句
setParams(pstmt, params); //给预编译语句中的占位符赋值
rs=pstmt.executeQuery(); //执行查询语句并获取结果集
Map<String,Object> map=null;
String[] colNames=getColumnName(rs); //获取结果集中每个列的列名
while(rs.next()){  //处理结果
//每循环一次就是一行数据，我们需要将这一行数据的每一个列中的值存放到一个map中，以列名为键，以这一列的值为值、
map=new HashMap<String,Object>();

//循环取出每一个列，通过列名
for(String colName:colNames){
map.put(colName, rs.getObject(colName));
}

//当所有列已经循环取完后，说明这一条数据已经取完了，那么我们将这一条数据存放到list中
list.add(map);
map=null;
}
} catch (SQLException e) {
e.printStackTrace();
} finally{
close(rs, pstmt, con);
}
return list;
}

/**
* 针对返回数据只有一行的情况
* @param sql
* @param params
* @return
*/
public Map<String,String> find(String sql,Object ... params){
Map<String,String> map=null;
Connection con=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
con=getConnection(); //获取连接
pstmt=con.prepareStatement(sql); //预编译查询语句
setParams(pstmt, params); //给预编译语句中的占位符赋值
rs=pstmt.executeQuery(); //执行查询语句并获取结果集
String[] colNames=getColumnName(rs); //获取结果集中每个列的列名
if(rs.next()){  //处理结果
//每循环一次就是一行数据，我们需要将这一行数据的每一个列中的值存放到一个map中，以列名为键，以这一列的值为值、
map=new HashMap<String,String>();

//循环取出每一个列，通过列名
for(String colName:colNames){
map.put(colName, rs.getString(colName));
}
}
} catch (SQLException e) {
e.printStackTrace();
} finally{
close(rs, pstmt, con);
}
return map;
}

}

这是一个DBHelper类，实现与oracle的连接。

——————————————————————————————

下面是用单一模式实现将驱动和oracle的scott 用户拿出来的操作

package com.yc.jdbc;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.util.Properties;

/**

 * 读取配置文件的类，这个类在整个程序运行期间只需要一个对象，所以我们采用单例模式

 * 单例模式：

 * 1.不能让用户去实例化对象->将构造私有化

 *  2.用户不能实例化对象，如何获取这个类的实例化对象呢？

 *   提供一个公有的方法 且 必须是静态的，因为用户无法获取到对象的引用，只能通过类名直接获取

 *  3.必须提供一个静态的对象的引用的属性，用来指向实例化后的这个对象

 *   静态方法中只能访问类的静态成员，所以这个属性必须是静态的

 * @author Study

 */

public class DBProperties extends Properties{
private static final long serialVersionUID = 3821319480192779444L;
private static DBProperties instance=new DBProperties();

private DBProperties(){ //此时，在构造方法中，我们应该去读取配置文件
InputStream is=null;
try {
//is=new FileInputStream(new File("bin/db.properties"));
is=this.getClass().getClassLoader().getResourceAsStream("db.properties");
this.load( is );
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

public static DBProperties getDBDbProperties(){
return instance;
}

}

——————————————————————————

下面是将驱动以及oracle用户和密码的file操作

driver=oracle.jdbc.driver.OracleDriver

url=jdbc:oracle:thin:@127.0.0.1:1521:yc

user=scott

password=a

用eclipse建立一个文件然后放到jdbc的包下

到这里就实现了数据库的连接 

——————————

下面来做一个简单Test类 实现一下

package com.yc.test;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

import org.junit.Test;

import com.yc.jdbc.DBHelper;

import com.yc.jdbc.DBProperties;

public class MyTest {
@Test
public void test(){
Properties properties=System.getProperties();
//首先获取所有的键
Set<String> keys=properties.stringPropertyNames();
for(String key:keys){
System.out.println(key+"="+properties.getProperty(key));
}
}

@Test
public void test2(){
DBProperties.getDBDbProperties();
}

@Test
public void test3(){
DBHelper db=new DBHelper();
List<Map<String,Object>> list=db.finds("select * from dept");
for(Map<String,Object> map:list){
System.out.println(map);
}
}

@Test
public void test4(){
DBHelper db=new DBHelper();
//模拟销售的流程->售出2部手机
//1.将销售记录添加到sales表中
int result=db.update("insert into sales values(seq_sales_sid.nextval,2,2)");
if( result>0 ){
result=db.update("update goods set stores=stores-2 where gid=2");
}
//2.要改库存

System.out.println(result);
}

@Test
public void test5(){
DBHelper db=new DBHelper();
String sql1="insert into sales values(seq_sales_sid.nextval,1,2)";
String sql2="update goods set stores=stores-2 where gid=1";

List<String> sqls=new ArrayList<String>();
sqls.add(sql1);
sqls.add(sql2);

List<List<Object>> params=new ArrayList<List<Object>>();
params.add(null);
params.add(null);

int result=db.update(sqls, params);

System.out.println(result);
}

}

记得建立Test中的表哦。 ~~~~~