一、使用jdbc操作数据库步骤：
注意：这里操作的是MySQL数据库！
1、创建Java项目，导入jdbc的jar包[ 具体操作步骤 ]
2、创建包（package）：
-
右击项目的src文件夹，选中New—>Package输入包名就ok了，包名一般是公司的域名加项目名，然后是自己要创建的包名（我的是com.yunji.jdbc）
-
这个是我的项目结构：
entity： 实体类包，用于放实体类；
dao: 接口包，用于放接口类；
impl： 接口实现包，用于实现dao的接口
test: 用于测试的包，用于放测试类；
util: 工具类包，用于放工具类；
-
当然，你会发现你新建的包结构和我的不一样，包都是排在一行的，是这样的：
-
不必惊慌，这是idea默认的显示的项目包结构，只需要一个小小的操作就可以和我的一样。开始操作：
点击旁边的设置图标，将选中的勾去掉，就能和我的项目结构显示一样了。
-
看效果图：
显示的风格看个人爱好，不过我个人觉得这样显示的项目结构一目了然，比较方便操作。
3、根据数据库表创建实体类：
- 创建表：
#student数据库表
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
`name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
`sex` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '性别',
`age` int(11) NULL DEFAULT NULL COMMENT '年龄',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
#插入的数据库数据
INSERT INTO `student` VALUES (1, '李武', '男', 15);
INSERT INTO `student` VALUES (2, '李琪琪', '女', 15);
INSERT INTO `student` VALUES (3, '张利', '男', 16);
INSERT INTO `student` VALUES (4, '吴婷', '女', 14);
INSERT INTO `student` VALUES (5, '老铁', '男', 10);
- 创建实体类：
package com.yunji.jdbc.entity;
/**
* @program: jdbc
* @description: 学生表的实体类（student）
* @author:
* @create:
*
* 类名和属性名尽量和数据库表名，字段名一样
**/
public class Student {
/**
* 编号
*/
private int id;
/**
* 姓名
*/
private String name;
/**
* 性别
*/
private String sex;
/**
* 年龄
*/
private int age;
/**
* 使用get/set方法封装
*/
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/**
* 重写toString方法,方便后面打印实体类信息
*
* @return
*/
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
4、在util包下编写jdbc工具类：
package com.yunji.jdbc.util;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
/**
* @program: jdbc
* @description: 数据库连接工具类
* @author:
* @create:
**/
public class JdbcUtils {
/**
* 数据库驱动字符串
*/
private static final String DRIVER = "com.mysql.jdbc.Driver";
/**
* 连接URL字符串
* jdbc:mysql//服务器地址/数据库名
*/
private static final String URL = "jdbc:mysql://127.0.0.1:3306/Java?characterEncoding=utf-8";
/**
* 数据库用户名
*/
private static final String USER = "root";
/**
* 密码(自己数据库的密码)
*/
private static final String PASS = "jtt";
/**
* 数据库连接对象
*/
public static Connection conn = null;
/**
* 结果集对象
*/
public static ResultSet rs = null;
/**
* 预编译的 SQL 语句的对象
*/
public static PreparedStatement ps = null;
/**
* 获取数据库连接的方法
*
* @return 返回数据库连接对象
*/
public static Connection getConnection() {
try {
//加载数据库驱动
Class.forName(DRIVER);
//连接数据库
conn = DriverManager.getConnection(URL, USER, PASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
/**
* 处理占位符的方法(?)
*
* @param objects 要替换?的参数
*/
public static void placeholder(Object... objects) {
//判断是否有参数
if (objects != null && objects.length != 0) {
for (int i = 0; i < objects.length; i++) {
try {
ps.setObject(i + 1, objects[i]);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
/**
* 通用查询方法
*
* @param sql sql语句
* @param objects 查询条件
* @return 返回结果集
*/
public static ResultSet query(String sql, Object... objects) {
try {
//调用静态的获取数据库连接的方法
getConnection();
//执行预编译
ps = conn.prepareStatement(sql);
//调用静态的处理占位符的方法
placeholder(objects);
//执行查询操作
rs = ps.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
//返回结果集
return rs;
}
/**
* 通用增、删、改方法
*
* @param sql sql语句
* @param objects 条件参数，
* @return 返回影响的行数
*/
public static int update(String sql, Object... objects) {
int number = 0;
try {
//调用静态的获取数据库连接的方法
getConnection();
//执行预编译
ps = conn.prepareStatement(sql);
//调用静态的处理占位符的方法
placeholder(objects);
//执行增/删/改操作
number = ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭资源
CloseConnection(null, ps, conn);
}
return number;
}
/**
* 关闭数据库连接的方法
*
* @param res ResultSet对象
* @param pr PreparedStatement对像
* @param con Connection对象
*/
public static void CloseConnection(ResultSet res, PreparedStatement pr, Connection con) {
/**
*关闭的顺序ResultSet —> PreparedStatement —> Connection
*还要要进行异常处理
*/
try {
if (res != null) {
res.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (pr != null) {
pr.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if (con != null) {
con.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
5、在编写操作接口类（dao包下）和操作接口实现类（dao包下的mpl包下）：
- 操作接口类：
package com.yunji.jdbc.dao;
import com.yunji.jdbc.entity.Student;
/**
* @program: jdbc
* @description: Student操作接口
* @author:
* @create:
**/
public interface IStudent {
/**
* 查询所以学生信息的接口
*/
void queryAllStudent();
/**
* 增加Student信息的接口
*
* @param student 学生的信息
* @return 返回影响行数
*/
int insertStudent(Student student);
/**
* 根据id修改学生姓名的接口
*
* @param id 学生id
* @param name 要修改的名字
* @return
*/
int updateStudent(Integer id, String name);
/**
* 根据id删除Student信息的接口
*
* @param id 学生id
* @return 返回影响行数
*/
int deleteStudent(Integer id);
}
- 操作接口实现类类
package com.yunji.jdbc.dao.impl;
import com.yunji.jdbc.dao.IStudent;
import com.yunji.jdbc.entity.Student;
import com.yunji.jdbc.util.JdbcUtils;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
* @program: jdbc
* @description: Student操作接口实现类
* @author:
* @create:
**/
public class IStudentImpl implements IStudent {
int number = 0;
String sql = "";
/**
* 查询所以学生信息的接口实现方法
*
* @return
*/
@Override
public void queryAllStudent() {
//查询的sql语句
sql = "select * from student";
//调用静态的查询方法，得到结果集
ResultSet resultSet = JdbcUtils.query(sql);
//定义一个List集合,用来存储查询出来的student对象
List<Student> studentList = new ArrayList<Student>();
try {
//循环拿出结果集里面的值
while (resultSet.next()) {
/**
* 从结果集里依次拿出值:
*语法：结果集对象.get类型.(ColumnIndex/ColumnLabel);
*
* 1、根据下标(ColumnIndex)拿：根据数据库表字段类型选择匹配的方法，下标从1开始，对应数据库表里面列的顺序.
* resultSet.getInt(1); 拿出学生id
*
* 2、根据数据库表列名(ColumnLabel)拿：根据数据库表字段类型选择匹配的方法.列名对应数据库表里面列的名字
* resultSet.getString("id"); 拿出学生id
*/
/**
* 将拿出的值封装到Student中
*/
//new一个Student对象
Student student = new Student();
student.setId(resultSet.getInt("id"));
student.setName(resultSet.getString("name"));
student.setSex(resultSet.getString("sex"));
student.setAge(resultSet.getInt("age"));
//将对象存入集合
studentList.add(student);
}
//循环打印
for (int i = 0; i < studentList.size(); i++) {
System.out.println(studentList.get(i));
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
//关闭数据库连接
JdbcUtils.CloseConnection(resultSet, JdbcUtils.ps, JdbcUtils.conn);
}
}
/**
* 增加Student信息的接口实现方法
*
* @return
*/
@Override
public int insertStudent(Student student) {
//sql语句
//因为数据库中student的id是自增长的，所以可以设为空
sql = "INSERT INTO student VALUE(null,?,?,?)";
//调用静态的增删改的方法
//student.getName(), student.getSex(), student.getAge()----> 注意：里面的参数要和数据库表字段的顺序一样
//参数的顺序：sql,sql中第一个?是name,第二?是sex,第三个?是age
number = JdbcUtils.update(sql, student.getName(), student.getSex(), student.getAge());
return number;
}
/**
* 根据id修改学生姓名的接口实现类
*
* @param id 学生id
* @param name 要修改的名字
* @return
*/
@Override
public int updateStudent(Integer id, String name) {
//sql语句
sql = "UPDATE student SET `name` =? WHERE id = ?;";
//调用静态的增删改的方法
//参数的顺序：sql,sql中第一个?是name,第二?是id
number = JdbcUtils.update(sql, name, id);
return number;
}
/**
* 根据id删除Student信息的接口
*
* @param id 学生id
* @return 返回影响行数
*/
@Override
public int deleteStudent(Integer id) {
//sql语句
sql = "DELETE FROM student WHERE id =?";
number = JdbcUtils.update(sql, id);
return number;
}
}
6、编写测试类：
package com.yunji.jdbc.test;
import com.yunji.jdbc.dao.IStudent;
import com.yunji.jdbc.dao.impl.IStudentImpl;
import com.yunji.jdbc.entity.Student;
/**
* @program: jdbc
* @description: Jdbc操作测试
* @author:
* @create:
**/
public class JdbcTest {
/**
* main方法（主程序入口）
*/
public static void main(String[] args) {
//new一个Student操作接口实现类
IStudent iStudent = new IStudentImpl();
System.out.println("---------------操作前--------------");
//调用查询方法
iStudent.queryAllStudent();
//调用新增学生信息方法
Student student = new Student();
student.setName("李白");
student.setSex("男");
student.setAge(30);
int number01 = iStudent.insertStudent(student);
if (number01 > 0) {
System.out.println("----新增成功!----");
} else {
System.out.println("----新增失败!-----");
}
int number02 = iStudent.updateStudent(1, "哈哈");
if (number02 > 0) {
System.out.println("----修改成功！----");
} else {
System.out.println("----修改失败!-----");
}
int number03 = iStudent.deleteStudent(2);
if (number03 > 0) {
System.out.println("----删除成功!-----");
} else {
System.out.println("----删除失败!-----");
}
System.out.println("---------------操作后--------------");
//调用查询方法
iStudent.queryAllStudent();
}
}
7、最后看测试结果：
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
