使用java怎么连接数据库并实现增删改查操作
使用java怎么连接数据库并实现增删改查操作？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。
创新互联公司为企业级客户提高一站式互联网+设计服务，主要包括成都网站设计、网站制作、外贸营销网站建设、成都App定制开发、微信小程序开发、宣传片制作、LOGO设计等，帮助客户快速提升营销能力和企业形象，创新互联各部门都有经验丰富的经验，可以确保每一个作品的质量和创作周期，同时每年都有很多新员工加入，为我们带来大量新的创意。
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> result 查询结果集
* */
public List> query(String sql,String[] keyVal);
public List> query(String sql);
/**
* 查询单行数据
* @param
* String 要执行的sql语句
* @param
* String[] keyVal 映射数组
* @return
* Map result 查询结果集
* */
public Map find(String sql,String[] keyVal);
public Map 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<"int","22">
* */
public List> callResult(String callFunc,List keyVal);
public List> 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> 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> list = new ArrayList>(result.getRow());
result.first();
int propertiesLength = meta.getColumnCount();
do{
Map map = new HashMap(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> query(String sql)
{
return query(sql,null);
}
@Override
public Map 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 map = new HashMap(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 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> callResult(String callFunc,List 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> list = new ArrayList>(result.getRow());
result.first();
int propertiesLength = meta.getColumnCount();
do{
Map map = new HashMap(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> 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的优点是什么
1. 简单，只需理解基本的概念，就可以编写适合于各种情况的应用程序；2. 面向对象；3. 分布性，Java是面向网络的语言；4. 鲁棒性，java提供自动垃圾收集来进行内存管理，防止程序员在管理内存时容易产生的错误。；5. 安全性，用于网络、分布环境下的Java必须防止病毒的入侵。6. 体系结构中立，只要安装了Java运行时系统，就可在任意处理器上运行。7. 可移植性，Java可以方便地移植到网络上的不同机器。8.解释执行，Java解释器直接对Java字节码进行解释执行。
看完上述内容，你们掌握使用java怎么连接数据库并实现增删改查操作的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注创新互联行业资讯频道，感谢各位的阅读！
本文标题：使用java怎么连接数据库并实现增删改查操作
网页URL：http://scyanting.com/article/gjpipj.html
