简介：最近刚学习到Java中连接Mysql数据库，为了日后的方便使用，就花了两天时间写了一个封装类，让我可以快速使用Mysql进行相关例如增删改查等操作。写这篇文章进行一个总结！
目录
方法一：传入参数【1.数据库名:Db 2.数据库登录用户名:user 3.数据库登录密码:password】
方法二：传入参数【1.数据库名:Db 2.数据库登录用户名:user 3.数据库登录密码:password 4.所要执行的Sql语句:Sql】
针对于上述两种不同的构造方法，分别阐述如何进行“增删改查”操作
再进行数据库相关操作过程中，还有一些方法，虽然不常用，但是关键时候可能会有用！
1. 相关版本号
Mysql：
java：
mysql-connector-java-8.0.25.jar：
编辑器：Eclipse 4.6.3
2. 封装类ConnectDB（***）
package mysql;
import java.sql.*;
import java.util.HashMap;
import java.util.Set;
public class ConnectDB {
// 1.数据库名称
private String Db;
// 2.登录用户（例：root）
private String user;
// 3.登录密码
private String password;
// 4.所要执行的sql语句
private String sql;
// 5.数据库连接所使用对象
private Connection conn;
private Statement stmt;
private ResultSet rs;
// 6.HashMap对象，用来存储查询语句的查询结果，为字典形式
private HashMap<String, Object[]> dict = new HashMap<>() ;
// 7.Object[][]对象，用来存储查询语句的查询结果，为二维数组形式,与数据库一致
private Object[][] data_object;
// 8.Object[][]对象，用来存储查询语句的查询结果，为二维数组形式，数据库转置
private Object[][] data_object_Transposition;
// 9.查询结果集行数
private int row;
// 10.查询结果集列数
private int col;
// 11.查询结果集的字段名
private String []column;
// 默认构造函数
public ConnectDB(){}
// 初始化（不传Sql）
public ConnectDB(String Db,String user,String password){
this.Db = Db;
this.user = user;
this.password = password;
}
// 初始化（传入Sql）
public ConnectDB(String Db,String user,String password,String sql){
this.Db = Db;
this.user = user;
this.password = password;
this.sql = sql;
}
// 切换数据库
public void Set_Db(String Db){this.Db = Db;}
// 传入sql
public void Set_sql(String sql){this.sql = sql;}
// 获取当前数据库名称
public String get_Db(){return this.Db;}
// 获取当前数据库登录用户
public String get_user(){return this.user;}
// 获取当前数据库密码
public String get_password(){return this.password;}
// 获取当前所执行的Sql语句
public String get_sql(){return this.sql;}
// 关闭数据库连接（*）
public void close(){
try {
if(this.rs!=null){this.rs.close();}
if(this.stmt!=null){this.stmt.close();}
if(this.conn!=null){this.conn.close();}
}
catch (SQLException e) {
e.printStackTrace();
}
}
// 数据库接口 1
//（返回参数：sql.Connection类型的变量conn）
public Connection Get_Connection(){
Connection con = null;
try{
Class.forName("com.mysql.cj.jdbc.Driver");
}
catch(Exception e){
}
String url = "jdbc:mysql://localhost:3306/" + Db + "?" + "useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC";
try{
con = DriverManager.getConnection(url, user, password);
}
catch(SQLException e){
System.out.println(e);
}
return con;
}
// 数据库接口2
//（返回参数：sql.Connection类型的变量rs）
public ResultSet Get_ResultSet(){
conn = Get_Connection();
if(conn==null){
}
// 执行sql语句
try{
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(sql);
}
catch(SQLException se){
se.printStackTrace();
}
return rs;
}
// 数据库接口3（查询用）
//（返回参数：HashMap类型的变量dict）
public HashMap<String,Object[]> Get_HashMap_Data(){
conn = Get_Connection();
if(conn==null){ }
// 执行sql语句
try{
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(sql);
col= get_column_length();
column = get_column_name();
row = 0;
while(rs.next()){
row++;
}
Object [][]data = new Object[col][row];
int current_row = 0;
rs.beforeFirst();
while(rs.next()){
for(int i=0;i<col;i++){
Object single_data = rs.getObject(column[i]);
data[i][current_row] = single_data;
}
current_row ++;
}
// 关闭数据库连接
close();
// 存储到HashMap中
for(int i=0;i<data.length;i++){
dict.put(column[i], data[i]);
}
}
catch(SQLException se){
se.printStackTrace();
}
return dict;
}
// 数据库接口4（查询用）
//（返回参数：Object[][]类型的变量data_object）
public Object[][] Get_Object_Data(){
conn = Get_Connection();
if(conn==null){ }
// 执行sql语句
try{
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(sql);
col= get_column_length();
column = get_column_name();
row = 0;
while(rs.next()){
row++;
}
data_object = new Object[row][col];
int current_row = 0;
rs.beforeFirst();
while(rs.next()){
for(int i=0;i<col;i++){
Object single_data = rs.getObject(column[i]);
data_object[current_row][i] = single_data;
}
current_row ++;
}
// 关闭数据库连接
close();
}
catch(SQLException se){
se.printStackTrace();
}
return data_object;
}
// 数据库接口5（查询用）
//（返回参数：Object[][]类型的变量data_object）
public Object[][] Get_Object_Data_Transposition(){
conn = Get_Connection();
if(conn==null){ }
// 执行sql语句
try{
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(sql);
col= get_column_length();
column = get_column_name();
row = 0;
while(rs.next()){
row++;
}
data_object_Transposition = new Object[col][row];
int current_row = 0;
rs.beforeFirst();
while(rs.next()){
for(int i=0;i<col;i++){
Object single_data = rs.getObject(column[i]);
data_object_Transposition[i][current_row] = single_data;
}
current_row ++;
}
// 关闭数据库连接
close();
}
catch(SQLException se){
se.printStackTrace();
}
return data_object;
}
// 数据库接口6（增删改）
//（返回参数：String类型执行sql语句的执行记录）
public void Execute_sql(){
try{
conn = Get_Connection();
stmt = conn.createStatement();
int rowAction = stmt.executeUpdate(sql);
if(rowAction>0){
System.out.println("记录" + Show_Type() + "成功，影响了 " + rowAction + "行。");
}
else{
System.out.println("记录" + Show_Type() + "失败！");
}
// 关闭数据库连接
close();
}
catch (SQLException e) {
e.printStackTrace();
}
}
// 获取查询字段的个数
public int get_column_length(){
rs = Get_ResultSet();
int column_length = 0;
try{
rs.beforeFirst();
ResultSetMetaData metaData = rs.getMetaData();
column_length = metaData.getColumnCount();
}
catch (SQLException e) {
e.printStackTrace();
}
return column_length;
}
// 获取查询结果集的行数
public int get_row_length(){
rs = Get_ResultSet();
int rows = 0;
try {
rs.beforeFirst();
while(rs.next()){
rows++;
}
} catch (SQLException e) {
e.printStackTrace();
}
return rows;
}
// 获取查询字段名称
public String[] get_column_name(){
String []column_name = new String[get_column_length()];
try{
rs.beforeFirst();
ResultSetMetaData metaData = rs.getMetaData();
int columnCount = metaData.getColumnCount();
for(int i=1;i<=columnCount;i++){
String columnName = metaData.getColumnName(i);
column_name[i-1] = columnName;
}
}
catch (SQLException e) {
e.printStackTrace();
}
return column_name;
}
// 输出HashMap类型数据库数据（*）
public void Show_HashMap_Data(){
for(int i=0;i<column.length;i++){
System.out.print(column[i]+" ");
}
System.out.print("\n");
for(int i=0;i<row;i++){
for(int j=0;j<column.length;j++){
System.out.print(dict.get(column[j])[i]);
System.out.print(" -----");
}
System.out.print("\n\n");
}
}
// 输出Object类型数据库数据（*）
public void Show_Object_data(){
for(int i=0;i<column.length;i++){
System.out.print(column[i]+" ");
}
System.out.print("\n");
for(int i=0;i<row;i++){
for(int j=0;j<col;j++){
System.out.print(data_object[i][j]);
System.out.print(" -----");
}
System.out.print("\n\n");
}
}
// 输出Object类型数据库数据（*）
public void Show_Object_data_Transposition(){
for(int i=0;i<column.length;i++){
System.out.print(column[i]+" ");
}
System.out.print("\n");
for(int i=0;i<row;i++){
for(int j=0;j<col;j++){
System.out.print(data_object_Transposition[j][i]);
System.out.print(" -----");
}
System.out.print("\n\n");
}
}
// 获取增删改类型
public String Show_Type(){
String type = sql.substring(0,6);
type = type.toLowerCase();
if(type.equals("insert")){
type = "添加";
}
else if(type.equals("update")){
type = "更新";
}
else if(type.equals("delete")){
type = "删除";
}
return type;
}
// 输出函数 // （测试用）
// 输出String类型单个字符
public void output(String s){
System.out.print(s + " ");
}
// 输出int类型单个字符
public void output(int s){
System.out.print(s + " ");
}
// 输出float类型单个字符
public void output(float s){
System.out.print(s + " ");
}
// 输出double类型单个字符
public void output(double s){
System.out.print(s + " ");
}
// 输出String类型字符数组
public void output(String []s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出int类型整型数组
public void output(int []s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出float类型浮点型数组
public void output(float []s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出double类型浮点型数组
public void output(double []s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出Object类型单个字符
public void output(Object s){
System.out.print(s + " ");
}
// 输出Object类型字符数组
public void output(Object []s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出Object类型二维数组
public void output(Object [][]s){
for(int i=0;i<s.length;i++){
output(s[i]);
}
output("\n");
}
// 输出HashMap类型的字典
public void output(HashMap<String,Object[]> data,String []column_name){
for(int i=0;i<column_name.length;i++){
output(column_name[i] + ": ");
output(data.get(column_name[i]));
}
output("\n");
}
}
3. 解释说明与举例
这里对上述封装类ConnectDB进行相关解释
先在Mysql数据库中创建一张表，插入一些数据
create database if not exists mysql;
create table if not exists mysql.test(
id VARCHAR(47),
name VARCHAR(47),
score FLOAT
);
insert into mysql.test(id,name,score) values('1','s1',1);
insert into mysql.test(id,name,score) values('2','s2',2);
insert into mysql.test(id,name,score) values('3','s3',3);
insert into mysql.test(id,name,score) values('4','s4',4);
insert into mysql.test(id,name,score) values('5','s5',5);
insert into mysql.test(id,name,score) values('6','s6',6);
insert into mysql.test(id,name,score) values('7','s7',7);1. 初始化
初始化有两种方法，都是调用构造函数
方法一：传入参数【1.数据库名:Db 2.数据库登录用户名:user 3.数据库登录密码:password】
（这个方法适用于还不知道要进行的数据库操作是什么，也就是Sql语句还没有的情况）
public class test {
public static void main(String args[]){
String Db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(Db,user,password);
}
}方法二：传入参数【1.数据库名:Db 2.数据库登录用户名:user 3.数据库登录密码:password 4.所要执行的Sql语句:Sql】
（这个方法适用于已经明确知道当前要进行的数据库操作是什么，直接将Sql语句传进去）
public class test {
public static void main(String args[]){
String Db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test";
ConnectDB mysql = new ConnectDB(Db,user,password,sql);
}
}2. “增删改查”操作
针对于上述两种不同的构造方法，分别阐述如何进行“增删改查”操作
方法一初始化后的“增删改查”操作：
1. 添加数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// InSert语句
String sql = "insert into test(id,name,score) values('8','s8',8);";
// 使用Set_sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}2. 删除数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// Delete语句
String sql = "delete from test where id='1';";
// 使用Set_sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}3. 修改数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// UPDATE语句
String sql = "update test set name='s8_1' where id='8';";
// 使用Set_sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}4. 查询数据（*）
查询数据得到的数据形式可以有三种
第一种：HashMap<String,Object[ ]> 。
这种形式其实就是字典，字典的键为查询到的结果集的字段名(String)，字典的每个键后面的值为该字段对应那一列的所有的数据值(Object[ ])
import java.util.HashMap;
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// SELECT语句
String sql = "select * from test;";
// 使用Set_Sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Get_HashMap_Data方法获取查询到的数据集
HashMap<String,Object[]> data = mysql.Get_HashMap_Data();
// 使用Show_HashMap_Data输出查询到的数据
mysql.Show_HashMap_Data();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----
第二种：Object[ ][ ]。
这种形式就是每个元素为Object类型的一个二维数组。数组的每一行与数据库中每一行对应，数组的行数与数据库行数一致。
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// SELECT语句
String sql = "select * from test;";
// 使用Set_Sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Get_Object_Data方法获取查询到的数据集
Object [][]data = mysql.Get_Object_Data();
// 使用Show_Object_Data输出查询到的数据
mysql.Show_Object_data();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----第三种仍然是：Object[ ][ ]。
这种形式就是每个元素为Object类型的一个二维数组。与上面第二种不同的是数组的每一行是数据库中每一列的数据。Object第一行是查询结果第一个字段的全部数据，和第一种字典有点像，相当于字典中只保留了值，忽略了键。
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
ConnectDB mysql = new ConnectDB(db,user,password);
// SELECT语句
String sql = "select * from test;";
// 使用Set_Sql方法设置sql语句
mysql.Set_sql(sql);
// 使用Get_Object_Data_Transposition方法获取查询到的数据集
Object [][]data = mysql.Get_Object_Data_Transposition();
// 使用Show_Object_Data_Transposition输出查询到的数据
mysql.Show_Object_data_Transposition();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----方法二初始化后的“增删改查”操作：
方法二其实就是方法一少了添加sql语句的步骤
1. 添加数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "insert into test(id,name,score) values('8','s8',8);";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}2. 删除数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "delete from test where id='8';";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}3. 修改数据
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "update test set name='s8_1' where id='8';";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Execute_sql方法执行sql语句
mysql.Execute_sql();
}
}4. 查询数据（*）
第一种：HashMap<String,Object[ ]> 。
这种形式其实就是字典，字典的键为查询到的结果集的字段名(String)，字典的每个键后面的值为该字段对应那一列的所有的数据值(Object[ ])
import java.util.HashMap;
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Get_HashMap_Data方法获取查询到的数据集
HashMap<String,Object[]> data = mysql.Get_HashMap_Data();
// 使用Show_HashMap_Data输出查询到的数据
mysql.Show_HashMap_Data();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----第二种：Object[ ][ ]。
这种形式就是每个元素为Object类型的一个二维数组。数组的每一行与数据库中每一行对应，数组的行数与数据库行数一致。
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Get_Object_Data方法获取查询到的数据集
Object [][]data = mysql.Get_Object_Data();
// 使用Show_Object_Data输出查询到的数据
mysql.Show_Object_data();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----第三种仍然是：Object[ ][ ]。
这种形式就是每个元素为Object类型的一个二维数组。与上面第二种不同的是数组的每一行是数据库中每一列的数据。Object第一行是查询结果第一个字段的全部数据，和第一种字典有点像，相当于字典中只保留了值，忽略了键。
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Get_Object_Data_Transposition方法获取查询到的数据集
Object [][]data = mysql.Get_Object_Data_Transposition();
// 使用Show_Object_Data_Transposition输出查询到的数据
mysql.Show_Object_data_Transposition();
}
}
输出结果：
id name score
1 -----s1 -----1.0 -----
2 -----s2 -----2.0 -----
3 -----s3 -----3.0 -----
4 -----s4 -----4.0 -----
5 -----s5 -----5.0 -----
6 -----s6 -----6.0 -----
7 -----s7 -----7.0 -----总结，其实方法二就是方法一的省略版本，所以还是推荐使用方法一
3. 其他相关方法的介绍
再进行数据库相关操作过程中，还有一些方法，虽然不常用，但是关键时候可能会有用！
方法一：获取查询结果集字段的个数（结果集列数）
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用get_column_length方法获取查询字段的个数
int col = mysql.get_column_length();
}
}方法二：获取查询结果集的行数
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用get_row_length方法获取查询字段的个数
int row= mysql.get_row_length();
mysql.output(row);
}
}方法三：切换当前数据库
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用Set_Db方法切换当前数据库
mysql.Set_Db("mysql_1");
}
}方法四：获取当前数据库相关参数
public class test {
public static void main(String args[]){
String db = "mysql";
String user = "root";
String password = "123456";
String sql = "select * from test;";
ConnectDB mysql = new ConnectDB(db,user,password,sql);
// 使用get_Db方法获取当前对象的数据库名称
String current_Db = mysql.get_Db();
// 使用get_user方法获取当前对象的登录用户名
String current_user = mysql.get_user();
// 使用get_password方法获取当前对象的登录密码
String current_password = mysql.get_password();
// 使用get_sql方法获取当前对象所执行的sql语句
String current_sql = mysql.get_sql();
}
}
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
