java 数据库连接与增删改查操作实例详解
更新时间：2019年11月20日 10:06:40 作者：倾听岁月
这篇文章主要介绍了java 数据库连接与增删改查操作,结合实例形式详细分析了java使用jdbc进行数据库连接及增删改查等相关操作实现技巧与注意事项,需要的朋友可以参考下
本文实例讲述了java 数据库连接与增删改查操作。分享给大家供大家参考，具体如下：
1、设置数据库的基本配置信息
package mysql;
//数据库配置资源连接
public final class DbConfig
{
//数据库资源 指定所使用的数据库类型 地址 端口 数据库名称 编码格式
public final static String dbUrl = "jdbc:mysql://localhost:3306/database_name?useUnicode=true&characterEncodong=utf-8";
//数据库用户名
public final static String dbUser= "xxxxxx";
//数据库密码
public final static String dbPwd = "xxxxxx";
}
2、数据库连接类 用户获取数据库连接
package mysql;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DriverManager;
public class Conn
{
//保存住默认数据库连接
private static Connection conn = null;
//数据库连接
private static Connection getDbConn(String dbUurl,String dbUser,String dbPwd)
{
Connection dbConn;
try{
//载入mysql 工具包
Class.forName("com.mysql.jdbc.Driver");
dbConn = DriverManager.getConnection(dbUurl,dbUser,dbPwd);
}catch(ClassNotFoundException | SQLException e){
dbConn = null;
e.printStackTrace();
}
return dbConn;
}
//获得第三方数据库链接
public static Connection getConn(String dbUrl,String dbUser,String dbPwd)
{
return getDbConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
}
//获得本地默认数据库连接
public static Connection getConn()
{
if(conn == null){
conn = getDbConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
}
return conn;
}
}
3、数据库测试类 检验获得的数据库连接是否有效
import Demo.Demo;
import mysql.*;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.PreparedStatement;
public class Index
{
public static void main(String[] args)
{
index1();
//分隔符
System.out.println("----------------------------------------------");
System.out.println("----------------------------------------------");
System.out.println("----------------------------------------------");
index2();
}
//自定义数据库连接方式
public static void index1()
{
//获取数据库连接
Connection conn = Conn.getConn(DbConfig.dbUrl,DbConfig.dbUser,DbConfig.dbPwd);
//测试该数据库连接是否有效
index3(conn);
}
//默认方式获取数据库连接
public static void index2()
{
//获取数据库连接
Connection conn = Conn.getConn();
//测试该数据库连接是否有效
index3(conn);
}
/**
* 测试数据库连接是否有效
* @param
* Connection conn 数据库连接
* */
public static void index3(Connection conn)
{
//定义要执行的sql语句
String sql = "select * from table_name where id = ?";
try
{
//对sql语句进行预处理
PreparedStatement pre = conn.prepareStatement(sql);
//变量数据填充 填充后的sql为 select * from table_name where id = "xxxxxxx"
pre.setString(1,"xxxxx");
//执行sql语句 发挥执行的结果
ResultSet result = pre.executeQuery();
//返回的结果是否是空数据
if(!result.next())
{
System.out.println("没有查询到响应的数据");
return;
}
//获取返回结果的元数据，列名
ResultSetMetaData meta = result.getMetaData();
//打印输出
int metaLength = meta.getColumnCount();
do{
for(int forInt = 1;forInt <= metaLength;forInt++)
{
String keyName = meta.getColumnName(forInt);
System.out.println(keyName + " => " + result.getString(keyName));
}
}while(result.next());
}catch(SQLException e){
e.printStackTrace();
}
}
}
获取到Connection 连接后看到执行一个sql语句获得返回结果还要这么多的处理操作，以下是自己封装的mysql操作类
数据库接口类，针对数据库操作的类，都得实现这个类。不管以后更换了什么数据库，该数据库的操作类都得实现这个接口所规定的方法，然后我们不需要任何的改动，只需要变更该接口的实现就可以了。
package standard.db.operation;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import spring.beans.db.realization.mysql.DataType;
public interface DbOper
{
/**
* 数据库连接
* */
public void setConnection(Connection conn);
public Connection getConnection();
/**
* 查询所有数据
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* List<Map<String,String>> result 查询结果集
* */
public List<Map<String,String>> query(String sql,String[] keyVal);
public List<Map<String,String>> query(String sql);
/**
* 查询单行数据
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* Map<String,String> result 查询结果集
* */
public Map<String,String> find(String sql,String[] keyVal);
public Map<String,String> find(String sql);
/**
* 更新数据
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* int resultInt 受影响的行数
* */
public int update(String sql,String[] keyVal);
public int update(String sql);
/**
* 新增数据
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* int resultInt 新增成功行数
* */
public int insert(String sql,String[] keyVal);
public int insert(String sql);
/**
* 删除数据库
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* boolean 删除时候成功
* */
public boolean delete(String sql,String[] keyVal);
public boolean delete(String sql);
/**
* 调用存储过程
* @param
* String callFunc 存储过程名称
* List<Map<String,String>> 存储过程参数值 如：Map<"int","22">
* */
public List<Map<String,String>> callResult(String callFunc,List<DataType> keyVal);
public List<Map<String,String>> callResult(String callFunc);
}
针对DbOper接口的实现
package spring.beans.db.realization.mysql;
import java.sql.Connection;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.sql.CallableStatement;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
import standard.db.operation.DbOper;
/**
* mysql 操作实现类 - 容器
* author : 谭勇
* create_date : 2017-04-13
* */
@Repository("db_connection")
@Scope("request")
public final class MysqlRealization implements DbOper
{
private Connection conn;
/**
* 对象初始化
* */
@PostConstruct
public void initDb()
{
}
@Override
public void setConnection(Connection conn)
{
this.conn = conn;
}
@Value(value="#{mysql_driver_manager_dataSource}")
public void setConnection(DataSource dataSource)
{
try{
setConnection(dataSource.getConnection());
}catch(SQLException e)
{
}
}
@Override
public Connection getConnection()
{
return this.conn;
}
@Override
public List<Map<String, String>> query(String sql, String[] keyVal)
{
PreparedStatement pre = null;
ResultSet result = null;
ResultSetMetaData meta = null;
try{
pre = conn.prepareStatement(sql);
if(keyVal != null)
{
//映射到问号
for(int i=1;i<=keyVal.length;i++)
{
pre.setString(i, keyVal[i-1]);
}
}
result = pre.executeQuery();
if (result.next())
{
meta = result.getMetaData();
result.last();
List<Map<String,String>> list = new ArrayList<Map<String,String>>(result.getRow());
result.first();
int propertiesLength = meta.getColumnCount();
do{
Map<String,String> map = new HashMap<String,String>(propertiesLength);
for(int i=1;i<=propertiesLength;i++)
{
String keyName = meta.getColumnName(i);
map.put(keyName, result.getString(keyName));
}
list.add(map);
}while(result.next());
return list;
}
}catch(SQLException e)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
closeResultSet(result);
}
return null;
}
@Override
public List<Map<String, String>> query(String sql)
{
return query(sql,null);
}
@Override
public Map<String, String> find(String sql, String[] keyVal)
{
PreparedStatement pre = null;
ResultSet result = null;
ResultSetMetaData meta = null;
try{
pre = conn.prepareStatement(sql);
if(keyVal != null)
{
//映射到问号
for(int i=1;i<=keyVal.length;i++)
{
pre.setString(i, keyVal[i-1]);
}
}
result = pre.executeQuery();
if (result.next())
{
meta = result.getMetaData();
int propertiesLength = meta.getColumnCount();
Map<String,String> map = new HashMap<String,String>(propertiesLength);
for(int i=1;i<=propertiesLength;i++)
{
String keyName = meta.getColumnName(i);
map.put(keyName, result.getString(keyName));
}
return map;
}
}catch(SQLException e)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
closeResultSet(result);
}
return null;
}
@Override
public Map<String, String> find(String sql)
{
return find(sql,null);
}
@Override
public int update(String sql, String[] keyVal)
{
PreparedStatement pre = null;
try{
pre = conn.prepareStatement(sql);
if(keyVal != null)
{
//映射到问号
for(int i=1;i<=keyVal.length;i++)
{
pre.setString(i, keyVal[i-1]);
}
}
return pre.executeUpdate();
}catch(SQLException e)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
return 0;
}
@Override
public int update(String sql)
{
return update(sql,null);
}
@Override
public int insert(String sql, String[] keyVal)
{
PreparedStatement pre = null;
try{
pre = conn.prepareStatement(sql);
if(keyVal != null)
{
//映射到问号
for(int i=1;i<=keyVal.length;i++)
{
pre.setString(i, keyVal[i-1]);
}
}
return pre.executeUpdate();
}catch(SQLException e)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
return 0;
}
@Override
public int insert(String sql)
{
return insert(sql,null);
}
@Override
public boolean delete(String sql, String[] keyVal)
{
PreparedStatement pre = null;
try{
pre = conn.prepareStatement(sql);
if(keyVal != null)
{
//映射到问号
for(int i=1;i<=keyVal.length;i++)
{
pre.setString(i, keyVal[i-1]);
}
}
return pre.executeUpdate() > 0 ? true:false;
}catch(SQLException e)
{
e.printStackTrace();
}finally{
closePreparedStatement(pre);
}
return false;
}
@Override
public boolean delete(String sql)
{
return delete(sql,null);
}
/**
* 调用存储过程
* @param
* String callFunc 存储过程名
* */
public List<Map<String,String>> callResult(String callFunc,List<DataType> keyVal)
{
String call = "{call " + callFunc + "}";
ResultSetMetaData meta = null;
CallableStatement callableStatement= null;
ResultSet result = null;
try{
callableStatement = conn.prepareCall(call);
if(keyVal != null)
{
for(int i=1;i<=keyVal.size();i++)
{
DataType data = keyVal.get(i-1);
switch(data.getType())
{
case ValueTypeSource.STRING:
callableStatement.setString(i, String.valueOf(data.getValue()));
break;
case ValueTypeSource.INT:
callableStatement.setInt(i, Integer.valueOf(data.getValue()));
break;
case ValueTypeSource.LONG:
callableStatement.setLong(i, Long.valueOf(data.getValue()));
break;
case ValueTypeSource.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<Map<String,String>> list = new ArrayList<Map<String,String>>(result.getRow());
result.first();
int propertiesLength = meta.getColumnCount();
do{
Map<String,String> map = new HashMap<String,String>(propertiesLength);
for(int i=1;i<=propertiesLength;i++)
{
String keyName = meta.getColumnName(i);
map.put(keyName, result.getString(keyName));
}
list.add(map);
}while(result.next());
return list;
}catch(SQLException e)
{
e.printStackTrace();
return null;
}finally{
closeCallableStatement(callableStatement);
closeResultSet(result);
}
}
@Override
public List<Map<String,String>> callResult(String callFunc)
{
return callResult(callFunc,null);
}
/**
* 关闭资源链接
* */
private void closePreparedStatement(PreparedStatement pre)
{
if(pre != null)
{
try
{
pre.close();
}catch(SQLException e)
{
e.printStackTrace();
}
}
}
private void closeResultSet(ResultSet result)
{
if(result != null)
{
try
{
result.close();
}catch(SQLException e)
{
e.printStackTrace();
}
}
}
private void closeCallableStatement(CallableStatement call)
{
if(call != null)
{
try
{
call.close();
}catch(SQLException e)
{
e.printStackTrace();
}
}
}
private void closeConnection(Connection conn)
{
if(conn != null)
{
try
{
conn.close();
}catch(SQLException e)
{
e.printStackTrace();
}
}
}
/**
* 对象注销
* */
@PreDestroy
public void closeDb()
{
closeConnection(conn);
}
}
以下用于调用存储过程使用的工具类
package spring.beans.db.realization.mysql;
public final class DataType
{
private String keyName;
private String value;
private int type;
public DataType(){}
public DataType(String keyName,String value,int type)
{
setKeyName(keyName);
setValue(value);
setType(type);
}
public void setKeyName(String keyName)
{
this.keyName = keyName;
}
public void setValue(String value)
{
this.value = value;
}
public void setType(int type)
{
this.type = type;
}
public String getKeyName()
{
return keyName;
}
public String getValue()
{
return value;
}
public int getType()
{
return type;
}
}
package spring.beans.db.realization.mysql;
public enum ValueType
{
INT(ValueTypeSource.INT),
STRING(ValueTypeSource.STRING),
DOUBLE(ValueTypeSource.DOUBLE),
CHAR(ValueTypeSource.CHAR),
DATE(ValueTypeSource.DATE),
BLOB(ValueTypeSource.BLOB),
LONG(ValueTypeSource.LONG);
private int type;
private ValueType(int type)
{
this.type = type;
}
public int getType()
{
return type;
}
}
package spring.beans.db.realization.mysql;
public final class ValueTypeSource
{
public final static int INT=1,
STRING=2,
DOUBLE=3,
CHAR=4,
DATE=5,
LONG=6,
BLOB=7;
}
更多关于java相关内容感兴趣的读者可查看本站专题：《Java使用JDBC操作数据库技巧总结》、《Java+MySQL数据库程序设计总结》、《Java数据结构与算法教程》、《Java文件与目录操作技巧汇总》、《Java操作DOM节点技巧总结》和《Java缓存操作技巧汇总》
希望本文所述对大家java程序设计有所帮助。
您可能感兴趣的文章:
- 在IntelliJ IDEA中使用Java连接MySQL数据库的方法详解
- Java连接数据库，及增删改查的示例
- Java连接mysql数据库的详细教程(推荐)
- Java连接数据库JDBC技术之prepareStatement的详细介绍
- Java之jdbc连接mysql数据库的方法步骤详解
- Java连接数据库oracle中文乱码解决方案
- Java连接mysql数据库代码实例程序
- java连接mysql数据库实现单条插入和批量插入
- Java读取properties文件连接数据库的方法示例
- Java JDBC连接数据库常见操作总结
- Java使用JDBC连接postgresql数据库示例
- java使用jdbc连接数据库简单实例
- java实现的连接数据库及模糊查询功能示例
- Java 实现加密数据库连接的步骤
相关文章
定时器是一种实际开发中非常常用的组件, 类似于一个 “闹钟”, 达到一个设定的时间之后, 就执行某个指定好的代码。本文主要来和大家聊聊定时器的原理与使用，需要的可以参考一下2023-01-01
本文介绍Spring Security实现自定义访问策略，当根据谁访问哪个域对象做出安全决策时,您可能需要一个自定义的访问决策投票者,幸运的是，Spring Security有很多这样的选项来实现访问控制列表（ACL）约束,下面就来学习Spring Security自定义访问策略,需要的朋友可以参考下2022-02-02
这篇文章主要介绍了Mybatis框架中Interceptor接口的使用说明，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-09-09
这篇文章主要介绍了解决@JsonIgnore的使用以及自己踩坑,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-07-07
Java实现单链表反转，递归和非递归两种形式。接下来通过本文给大家分享Java实现单链表翻转实例代码，需要的的朋友参考下2017-03-03
这篇文章主要介绍了Java 并发编程的可见性、有序性和原子性的相关资料，帮助大家更好的理解和学习Java并发编程，感兴趣的朋友可以了解下。2020-11-11
这篇文章主要介绍了SpringBoot如何实现分离资源文件并打包,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-06-06
这篇文章主要为大家介绍了tomcat手动配置servlet，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助2021-11-11
Elasticsearch8.1中的Script使用实例深入解读
这篇文章主要为大家介绍了Elasticsearch8.1中的Script使用实例深入解读,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2023-10-10
Java中使用jaxp进行sax解析_动力节点Java学院整理
使用SAX的优势在于其解析速度较快，相对于DOM而言占用内存较少。这篇文章主要介绍了Java中使用jaxp进行sax解析,需要的朋友可以参考下2017-08-08
最新评论