java 数据库连接与增删改查操作实例详解
本文实例讲述了java数据库连接与增删改查操作。分享给大家供大家参考，具体如下：
1、设置数据库的基本配置信息
packagemysql;
//数据库配置资源连接
publicfinalclassDbConfig
{
//数据库资源指定所使用的数据库类型地址端口数据库名称编码格式
publicfinalstaticStringdbUrl="jdbc:mysql://localhost:3306/database_name?useUnicode=true&characterEncodong=utf-8";
//数据库用户名
publicfinalstaticStringdbUser="xxxxxx";
//数据库密码
publicfinalstaticStringdbPwd="xxxxxx";
}
2、数据库连接类用户获取数据库连接
packagemysql;
importjava.sql.SQLException;
importjava.sql.Connection;
importjava.sql.DriverManager;
publicclassConn
{
//保存住默认数据库连接
privatestaticConnectionconn=null;
//数据库连接
privatestaticConnectiongetDbConn(StringdbUurl,StringdbUser,StringdbPwd)
{
ConnectiondbConn;
try{
//载入mysql工具包
Class.forName("com.mysql.jdbc.Driver");
dbConn=DriverManager.getConnection(dbUurl,dbUser,dbPwd);
}catch(ClassNotFoundException|SQLExceptione){
dbConn=null;
e.printStackTrace();
}
returndbConn;
}
//获得第三方数据库链接
publicstaticConnectiongetConn(StringdbUrl,StringdbUser,StringdbPwd)
{
returngetDbConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
}
//获得本地默认数据库连接
publicstaticConnectiongetConn()
{
if(conn==null){
conn=getDbConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
}
returnconn;
}
}
3、数据库测试类检验获得的数据库连接是否有效
importDemo.Demo;
importmysql.*;
importjava.sql.Connection;
importjava.sql.SQLException;
importjava.sql.ResultSet;
importjava.sql.ResultSetMetaData;
importjava.sql.PreparedStatement;
publicclassIndex
{
publicstaticvoidmain(String[]args)
{
index1();
//分隔符
System.out.println("----------------------------------------------");
System.out.println("----------------------------------------------");
System.out.println("----------------------------------------------");
index2();
}
//自定义数据库连接方式
publicstaticvoidindex1()
{
//获取数据库连接
Connectionconn=Conn.getConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
//测试该数据库连接是否有效
index3(conn);
}
//默认方式获取数据库连接
publicstaticvoidindex2()
{
//获取数据库连接
Connectionconn=Conn.getConn();
//测试该数据库连接是否有效
index3(conn);
}
/**
*测试数据库连接是否有效
*@param
*Connectionconn数据库连接
**/
publicstaticvoidindex3(Connectionconn)
{
//定义要执行的sql语句
Stringsql="select*fromtable_namewhereid=?";
try
{
//对sql语句进行预处理
PreparedStatementpre=conn.prepareStatement(sql);
//变量数据填充填充后的sql为select*fromtable_namewhereid="xxxxxxx"
pre.setString(1,"xxxxx");
//执行sql语句发挥执行的结果
ResultSetresult=pre.executeQuery();
//返回的结果是否是空数据
if(!result.next())
{
System.out.println("没有查询到响应的数据");
return;
}
//获取返回结果的元数据，列名
ResultSetMetaDatameta=result.getMetaData();
//打印输出
intmetaLength=meta.getColumnCount();
do{
for(intforInt=1;forInt<=metaLength;forInt++)
{
StringkeyName=meta.getColumnName(forInt);
System.out.println(keyName+"=>"+result.getString(keyName));
}
}while(result.next());
}catch(SQLExceptione){
e.printStackTrace();
}
}
}
获取到Connection连接后看到执行一个sql语句获得返回结果还要这么多的处理操作，以下是自己封装的mysql操作类
数据库接口类，针对数据库操作的类，都得实现这个类。不管以后更换了什么数据库，该数据库的操作类都得实现这个接口所规定的方法，然后我们不需要任何的改动，只需要变更该接口的实现就可以了。
packagestandard.db.operation;
importjava.sql.Connection;
importjava.util.List;
importjava.util.Map;
importspring.beans.db.realization.mysql.DataType;
publicinterfaceDbOper
{
/**
*数据库连接
**/
publicvoidsetConnection(Connectionconn);
publicConnectiongetConnection();
/**
*查询所有数据
*@param
*String要执行的sql语句
*@param
*String[]keyVal映射数组
*@return
*List>result查询结果集
**/
publicList>query(Stringsql,String[]keyVal);
publicList>query(Stringsql);
/**
*查询单行数据
*@param
*String要执行的sql语句
*@param
*String[]keyVal映射数组
*@return
*Mapresult查询结果集
**/
publicMapfind(Stringsql,String[]keyVal);
publicMapfind(Stringsql);
/**
*更新数据
*@param
*String要执行的sql语句
*@param
*String[]keyVal映射数组
*@return
*intresultInt受影响的行数
**/
publicintupdate(Stringsql,String[]keyVal);
publicintupdate(Stringsql);
/**
*新增数据
*@param
*String要执行的sql语句
*@param
*String[]keyVal映射数组
*@return
*intresultInt新增成功行数
**/
publicintinsert(Stringsql,String[]keyVal);
publicintinsert(Stringsql);
/**
*删除数据库
*@param
*String要执行的sql语句
*@param
*String[]keyVal映射数组
*@return
*boolean删除时候成功
**/
publicbooleandelete(Stringsql,String[]keyVal);
publicbooleandelete(Stringsql);
/**
*调用存储过程
*@param
*StringcallFunc存储过程名称
*List>存储过程参数值如：Map<"int","22">
**/
publicList>callResult(StringcallFunc,ListkeyVal);
publicList>callResult(StringcallFunc);
}
针对DbOper接口的实现
packagespring.beans.db.realization.mysql;
importjava.sql.Connection;
importjava.util.List;
importjava.util.ArrayList;
importjava.util.Map;
importjava.util.HashMap;
importjava.sql.CallableStatement;
importjava.sql.SQLException;
importjava.sql.PreparedStatement;
importjava.sql.ResultSet;
importjava.sql.ResultSetMetaData;
importjavax.annotation.PostConstruct;
importjavax.annotation.PreDestroy;
importjavax.sql.DataSource;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.context.annotation.Scope;
importorg.springframework.stereotype.Repository;
importstandard.db.operation.DbOper;
/**
*mysql操作实现类-容器
*author:谭勇
*create_date:2017-04-13
**/
@Repository("db_connection")
@Scope("request")
publicfinalclassMysqlRealizationimplementsDbOper
{
privateConnectionconn;
/**
*对象初始化
**/
@PostConstruct
publicvoidinitDb()
{
}
@Override
publicvoidsetConnection(Connectionconn)
{
this.conn=conn;
}
@Value(value="#{mysql_driver_manager_dataSource}")
publicvoidsetConnection(DataSourcedataSource)
{
try{
setConnection(dataSource.getConnection());
}catch(SQLExceptione)
{
}
}
@Override
publicConnectiongetConnection()
{
returnthis.conn;
}
@Override
publicList>query(Stringsql,String[]keyVal)
{
PreparedStatementpre=null;
ResultSetresult=null;
ResultSetMetaDatameta=null;
try{
pre=conn.prepareStatement(sql);
if(keyVal!=null)
{
//映射到问号
for(inti=1;i<=keyVal.length;i++)
{
pre.setString(i,keyVal[i-1]);
}
}
result=pre.executeQuery();
if(result.next())
{
meta=result.getMetaData();
result.last();
List>list=newArrayList>(result.getRow());
result.first();
intpropertiesLength=meta.getColumnCount();
do{
Mapmap=newHashMap(propertiesLength);
for(inti=1;i<=propertiesLength;i++)
{
StringkeyName=meta.getColumnName(i);
map.put(keyName,result.getString(keyName));
}
list.add(map);
}while(result.next());
returnlist;
}
}catch(SQLExceptione)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
closeResultSet(result);
}
returnnull;
}
@Override
publicList>query(Stringsql)
{
returnquery(sql,null);
}
@Override
publicMapfind(Stringsql,String[]keyVal)
{
PreparedStatementpre=null;
ResultSetresult=null;
ResultSetMetaDatameta=null;
try{
pre=conn.prepareStatement(sql);
if(keyVal!=null)
{
//映射到问号
for(inti=1;i<=keyVal.length;i++)
{
pre.setString(i,keyVal[i-1]);
}
}
result=pre.executeQuery();
if(result.next())
{
meta=result.getMetaData();
intpropertiesLength=meta.getColumnCount();
Mapmap=newHashMap(propertiesLength);
for(inti=1;i<=propertiesLength;i++)
{
StringkeyName=meta.getColumnName(i);
map.put(keyName,result.getString(keyName));
}
returnmap;
}
}catch(SQLExceptione)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
closeResultSet(result);
}
returnnull;
}
@Override
publicMapfind(Stringsql)
{
returnfind(sql,null);
}
@Override
publicintupdate(Stringsql,String[]keyVal)
{
PreparedStatementpre=null;
try{
pre=conn.prepareStatement(sql);
if(keyVal!=null)
{
//映射到问号
for(inti=1;i<=keyVal.length;i++)
{
pre.setString(i,keyVal[i-1]);
}
}
returnpre.executeUpdate();
}catch(SQLExceptione)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
return0;
}
@Override
publicintupdate(Stringsql)
{
returnupdate(sql,null);
}
@Override
publicintinsert(Stringsql,String[]keyVal)
{
PreparedStatementpre=null;
try{
pre=conn.prepareStatement(sql);
if(keyVal!=null)
{
//映射到问号
for(inti=1;i<=keyVal.length;i++)
{
pre.setString(i,keyVal[i-1]);
}
}
returnpre.executeUpdate();
}catch(SQLExceptione)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
return0;
}
@Override
publicintinsert(Stringsql)
{
returninsert(sql,null);
}
@Override
publicbooleandelete(Stringsql,String[]keyVal)
{
PreparedStatementpre=null;
try{
pre=conn.prepareStatement(sql);
if(keyVal!=null)
{
//映射到问号
for(inti=1;i<=keyVal.length;i++)
{
pre.setString(i,keyVal[i-1]);
}
}
returnpre.executeUpdate()>0?true:false;
}catch(SQLExceptione)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
returnfalse;
}
@Override
publicbooleandelete(Stringsql)
{
returndelete(sql,null);
}
/**
*调用存储过程
*@param
*StringcallFunc存储过程名
**/
publicList>callResult(StringcallFunc,ListkeyVal)
{
Stringcall="{call"+callFunc+"}";
ResultSetMetaDatameta=null;
CallableStatementcallableStatement=null;
ResultSetresult=null;
try{
callableStatement=conn.prepareCall(call);
if(keyVal!=null)
{
for(inti=1;i<=keyVal.size();i++)
{
DataTypedata=keyVal.get(i-1);
switch(data.getType())
{
caseValueTypeSource.STRING:
callableStatement.setString(i,String.valueOf(data.getValue()));
break;
caseValueTypeSource.INT:
callableStatement.setInt(i,Integer.valueOf(data.getValue()));
break;
caseValueTypeSource.LONG:
callableStatement.setLong(i,Long.valueOf(data.getValue()));
break;
caseValueTypeSource.DOUBLE:
callableStatement.setDouble(i,Double.valueOf(data.getValue()));
break;
default:
callableStatement.setString(i,String.valueOf(data.getValue()));
}
}
}
callableStatement.execute();
result=callableStatement.getResultSet();
meta=result.getMetaData();
result.last();
List>list=newArrayList>(result.getRow());
result.first();
intpropertiesLength=meta.getColumnCount();
do{
Mapmap=newHashMap(propertiesLength);
for(inti=1;i<=propertiesLength;i++)
{
StringkeyName=meta.getColumnName(i);
map.put(keyName,result.getString(keyName));
}
list.add(map);
}while(result.next());
returnlist;
}catch(SQLExceptione)
{
e.printStackTrace();
returnnull;
}finally{
closeCallableStatement(callableStatement);
closeResultSet(result);
}
}
@Override
publicList>callResult(StringcallFunc)
{
returncallResult(callFunc,null);
}
/**
*关闭资源链接
**/
privatevoidclosePreparedStatement(PreparedStatementpre)
{
if(pre!=null)
{
try
{
pre.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
}
privatevoidcloseResultSet(ResultSetresult)
{
if(result!=null)
{
try
{
result.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
}
privatevoidcloseCallableStatement(CallableStatementcall)
{
if(call!=null)
{
try
{
call.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
}
privatevoidcloseConnection(Connectionconn)
{
if(conn!=null)
{
try
{
conn.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
}
/**
*对象注销
**/
@PreDestroy
publicvoidcloseDb()
{
closeConnection(conn);
}
}
以下用于调用存储过程使用的工具类
packagespring.beans.db.realization.mysql;
publicfinalclassDataType
{
privateStringkeyName;
privateStringvalue;
privateinttype;
publicDataType(){}
publicDataType(StringkeyName,Stringvalue,inttype)
{
setKeyName(keyName);
setValue(value);
setType(type);
}
publicvoidsetKeyName(StringkeyName)
{
this.keyName=keyName;
}
publicvoidsetValue(Stringvalue)
{
this.value=value;
}
publicvoidsetType(inttype)
{
this.type=type;
}
publicStringgetKeyName()
{
returnkeyName;
}
publicStringgetValue()
{
returnvalue;
}
publicintgetType()
{
returntype;
}
}
packagespring.beans.db.realization.mysql;
publicenumValueType
{
INT(ValueTypeSource.INT),
STRING(ValueTypeSource.STRING),
DOUBLE(ValueTypeSource.DOUBLE),
CHAR(ValueTypeSource.CHAR),
DATE(ValueTypeSource.DATE),
BLOB(ValueTypeSource.BLOB),
LONG(ValueTypeSource.LONG);
privateinttype;
privateValueType(inttype)
{
this.type=type;
}
publicintgetType()
{
returntype;
}
}
packagespring.beans.db.realization.mysql;
publicfinalclassValueTypeSource
{
publicfinalstaticintINT=1,
STRING=2,
DOUBLE=3,
CHAR=4,
DATE=5,
LONG=6,
BLOB=7;
}
更多关于java相关内容感兴趣的读者可查看本站专题：《Java使用JDBC操作数据库技巧总结》、《Java+MySQL数据库程序设计总结》、《Java数据结构与算法教程》、《Java文件与目录操作技巧汇总》、《Java操作DOM节点技巧总结》和《Java缓存操作技巧汇总》
希望本文所述对大家java程序设计有所帮助。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。