通过JDBC的操作连接,Java数据库连接,是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口(位于jdk的java.sql中)。我们通常说的JDBC是面向关系型数据库的,提供了诸如查询、更新、删除、增加数据库中数据的方法。在使用时候需要导入具体的jar包,不同数据库需要导入的jar包不同。
第一步 数据库的创建与表的创建
这里我所使用的是Java2304该数据库,创建了表work,表字段和数据如下图:
第二步 创建项目
在src目录下,创建db.properties文件,配置信息如下:
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/java2304?useSSL=false
user=root
password=root
创建文件lib,下面导入项目需要的三个文件包,当然创建项目时用到maven时,可以通过maven自动导入项目所需要的包,会更加方便快捷,这里我所用的是手动导入所需要的依赖。
第三步 创建实体类,并与数据库建立连接
这里我在src\com\zwj\entity目录下创建了与数据库表相关的对象:
package com.zwj.entity;
public class Work {
private Integer id;
private String name;
private Integer age;
private String info;
public Work() {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Work{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", info='" + info + '\'' +
'}';
}
}
在utils包中创建JdbcUntil的工具类,封装对数据库的连接操作以及关闭操作,随用随拿:
package com.zwj.utils;
import java.io.FileInputStream;
import java.sql.*;
import java.util.Properties;
/**
* 1.获取Connection对象
* 2.关闭资源
*/
public class JdbcUtil {
private static String url = null;
private static String user =null;
private static String password = null;
static {
try {
//只要JdbcUtil类加载了,就会执行静态代码块中的代码
//读取配置文件中的信息:properties文件
//Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。
// 属性列表中的每个键及其对应的值都是一个字符串。
Properties properties = new Properties();
properties.load(new FileInputStream("src/db.properties"));
//数据都在properties 对象中
String diver = properties.getProperty("driver");
url = properties.getProperty("url");
user = properties.getProperty("user");
password = properties.getProperty("password");
Class.forName(diver);
} catch (Exception e) {
e.printStackTrace();
}
}
public static Connection getConnection () {
Connection connection = null;
try {
connection = DriverManager.getConnection(url, user, password);
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
//关闭资源
//增删改 需要关闭两个 查 关闭三个
public static void close (Connection connection) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close (Statement statement, Connection connection) {
try {
statement.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close (ResultSet resultSet, Statement statement, Connection connection) {
try {
resultSet.close();
statement.close();
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
接下来就可以在代码中具体实现数据库的增删改查操作了,我们这里先在a_mysql包下创建一个WorkDao文件,在MVC模式里,这里的代码用于封装数据库的增删改查所实现的具体方法,这样就不用将SQL的增删改查代码卸载main主函数中了,我这里是写在DAO层里来具体实现。
package com.zwj.a_mysql;
import com.zwj.entity.Work;
import com.zwj.utils.BaseDao;
import java.util.List;
public class WorkDao extends BaseDao {
public void insert() {
String sql = "insert into work (name, age, info) values(?, ?, ?)";
Object[] objs = {"老万", 19, "嘻嘻老师的汉"};
super.update(sql, objs);
}
public void delete () {
String sql = "delete from work where id = ?";
Object[] obj = {3};
super.update(sql, obj);
}
public void select () {
String sql = "select * from work";
List<Work> query = super.query(sql, null, Work.class);
System.out.println(query);
}
}
在BaseDao这个类里就是具体的实现了:
package com.zwj.utils;
import org.apache.commons.beanutils.BeanUtils;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* 只有两个方法:
* 1.增删改
* 2.查
*/
public class BaseDao {
/**
* 增删改
* @param sql 需要传入sql语句
* @param parameters 对sql的?进行赋值
* @return 受影响的行数
*/
// String sql = "insert into work (name, age, info) values(?, ?,?)";
// Object[] objs = {"煮鸡蛋", 34, "cxdshjn"};
//baseDao.update(sql, objs);
public int update (String sql, Object[] parameters) {
//1.获取数据路的连接的对象 从另外一个工具类中去获取的
Connection connection = JdbcUtil.getConnection();
//2.获取预处理的搬运工对象去预处理sql语句
PreparedStatement preparedStatement = null;
try {
preparedStatement = connection.prepareStatement(sql);
//3.现在对sql语句参数进行赋值, 你知道有几个参数吗因为参数不确定
//获取参数的个数 靠参数元数据
int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
//System.out.println(parameterCount);
//4.循环进行赋值
// String sql = "insert into work (name, age, info) values(?, ?,?)";
// Object[] objs = {"供电", 12, "23u"}; 3
if (parameters != null && parameters.length == parameterCount) {
//才让你赋值
for (int i = 1; i <= parameterCount; i++) {
//i = 1` setObject(1, "供电")
//i=2 setObject(2, 12)
//i=3 setObject(3, "23u")
preparedStatement.setObject(i, parameters[i - 1]);
}
}
//5.执行sql语句
int i = preparedStatement.executeUpdate();
return i;
} catch (SQLException e) {
e.printStackTrace();
} finally {
JdbcUtil.close(preparedStatement, connection);
}
return 0;
}
//查询的方法 咱们需要关注什么?查询的数据是要赋值给一个实体类对象
/**
*
* @param sql
* @param parameters
* @param cls 查询出来的数据赋值给一个对象
* @param <T>
* @return
*/
// public void select () {
// String sql = "select * from work";
// List<Work> query = super.query(sql, null, Work.class);
// System.out.println(query);
// }
//super.query("select name,age from emp where id = ?", null, Emp.class)
public <T> List<T> query (String sql, Object[] parameters, Class<T> cls) {
//1.连接数据库的对象 获取
Connection connection = JdbcUtil.getConnection();
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//2.获取预处理的搬运工对象
preparedStatement = connection.prepareStatement(sql);
//3.获取参数的个数
int parameterCount = preparedStatement.getParameterMetaData().getParameterCount();
//4.对?进行赋值
if(parameters != null && parameters.length == parameterCount) {
for (int i = 1; i <= parameterCount; i++) {
preparedStatement.setObject(i, parameters[i - 1]);
}
}
//5.执行sql语句
resultSet = preparedStatement.executeQuery();
//6.创建一个空的集合
List<T> list = new ArrayList<>();
//7.获取结果集元数据,通过元数据获取字段的个数和字段的名字
ResultSetMetaData metaData = resultSet.getMetaData();
//8.通过元数据的对象获取字段的个数
/**
* id name age info 《=
* 1 狗蛋 12 大数据 《=
* 2 嘻嘻 18 撒娇年休假
* 3 大黄 89 水性凝胶剂
*/
int columnCount = metaData.getColumnCount();
/**
* resultSet.next()
* 第一条数据 :
* 内层for循环
* i=1 1<4 id getObject("id") 1 i++
* i=2 2<4 name getObject("name") 狗蛋 i++
* i=3 3<4 age...
* resultSet.next()
* 第二条数据:
* 内层for循环
* * i=1 1<4 id getObject("id") 2 i++
* * i=2 2<4 name getObject("name") 嘻嘻 i++
* * i=3 3<4 age..
*/
//9.遍历数据
while (resultSet.next()) {
//往下遍历每一行的数据的
//10.通过Class对象获取所对应的类对象
//Work.class->Work work = new Work()
//Person.calss->person person = new Person();
T t = cls.getConstructor(null).newInstance(null);
for (int i = 1; i <= columnCount; i++) {//获取字段的
//11.获取列(字段)的名字
String columnName = metaData.getColumnName(i);
//System.out.println(columnName);
//12.通过字段获取值
Object value = resultSet.getObject(columnName);
System.out.println(value);
//13.获取数据库重点数据之后,将数据赋值一个对象,得有类啊
//BeanUtils.setProperty(对象, 属性, 值)
BeanUtils.setProperty(t, columnName, value);
}
//14.每次while循环一次 存到集合中
list.add(t);
}
return list.size() != 0 ? list : null;
} catch (Exception e) {
e.printStackTrace();
} finally {
//15.关闭资源
JdbcUtil.close(resultSet, preparedStatement, connection);
}
return null;
}
}
最后在Demo1的主函数里实现:
package com.zwj.a_mysql;
public class Demo1 {
public static void main(String[] args) throws Exception{
WorkDao workDao = new WorkDao();
//workDao.insert();
//workDao.delete();
workDao.select();
}
}