JDBC学习日志使用JDBC进行增删改查（CRUD）以轿车销售系统为例
作者：互联网
在上一章，以及配置好了jdbc所需要的环境，这一章，将简单的介绍jdbc的具体使用。
参考文章：https://www.jianshu.com/p/4557883d8f71
https://www.cnblogs.com/kenx/p/13553931.html
https://docs.oracle.com/javase/tutorial/jdbc/basics/sqldatasources.html 官方文档
JDBC
百度百科：Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。
jdbc即是 java数据库连接API，jdbc提供了一套用于java的通用数据访问，使用jdbc几乎可以访问任何数据源，从关系数据库到电子表格和平面文件，jdbc还提供通用的基础，在此基础可以构建工具和替换接口。
从mysql的角度简单来说，jdbc就是一套用于从mysql获取数据的一套API！
如何使用这一套API，我们从上一章的测试代码进行分析。
1 import java.sql.*;
2
3 public class TestJDBC {
4 public static void main(String[] args) {
5 String url = "jdbc:mysql://localhost:3306/catblog"; //
6 String user = "root";
7 String password ="";
8 Connection connection = null; //连接
9 Statement statement = null; //执行器
10 ResultSet resultSet = null; //结果集
11 try {
12
13 Class.forName("com.mysql.cj.jdbc.Driver"); //通过反射注册驱动
14 connection = DriverManager.getConnection(url,user,password); //通过驱动获取 连接对象 Connection
15 statement = connection.createStatement(); //从 连接 中获取 sql执行器对象 Statement
16 resultSet = statement.executeQuery("select * from user"); //执行器执行sql语句并返回一个结果集对象 ResultSet
17 while(resultSet.next()) //遍历结果集 next()方法，返回值为布尔值，存在下一行，返回true，不存在下一行 返回fales 准确来说，游标位于一行之上返回true，最后一行之下返回false
18 {
19 System.out.println((resultSet.getObject(1)).toString()); // resultSet.getObject(1),以Object对象的形式在resultSet中获取第一列的值，并转化为字符串
20 }
21 }catch (ClassNotFoundException E) //发生错误抛出异常，驱动注册失败异常
22 {
23 E.printStackTrace();
24 System.out.println("无法找到驱动");
25 }catch (SQLException e){ //sql异常
26 e.printStackTrace();
27 }
28 finally { //关闭
29 try {
30 resultSet.close();
31 statement.close();
32 connection.close();
33 } catch (SQLException e) {
34 e.printStackTrace();
35 }
36
37 }
上面的代码涉及到的对象有
Connection Statement ResultSet ，这三个对象是主要的用来与数据库进行通信和操作的对象。接下来会分别简单的介绍这三个对象
Connection
Connection对象/接口，带表的是与数据库的连接，要执行sql语句和获得mysql数据库中的数据，必须要获得一个连接。
获得连接的代码是
Class.forName("com.mysql.cj.jdbc.Driver");
connection = DriverManager.getConnection(url,user,password);
Class.forName() 作用是初始化给定的类，这里的类是Mysql中的Driver类，Driver注册了所需要的mysql驱动
connection = DriverManager.getConnection(url,user,password); 这句话的意思是从驱动管理中获取一个连接，因为上面的代码注册了的驱动，所以可以获得一个连接，
getConnection()是用来获取连接方法，该方法有三个String类型的参数。
url：代表数据库的url地址 jdbc:mysql://localhost:3306/catblog
catblog之前是固定的写法，只有当你的mysql端口设置的是3306的时候，如果不是则需要改成mysql对应的端口号
catblog是一个数据库的名字，假如你要连接一个叫Cardata的数据库，那么url的写法是 jdbc:mysql://localhost:3306/Cardata
下面是一些connection的常用方法
| 返回类型 | 方法 | 功能描述 |
| Statement | createStatment() | 创建一个Statment对象 |
| Statement | createStatment(int resultSetType,int resultSetConcurrency) | 创建一个statment对象,该对象将生成具有给定类型并发性,和可保存的ResultSet对象 |
| PrepareStatement | prepareStatement() | 创建预处理对象prepardStatement |
| CallableStatement | prepareCall(String sql) | 创建一个CallableStatment对象来调用数据库存储过程 |
| boolean | isReadOnly() | 查看当前Collection对象是否为只读 |
| boolean | setReadOnly() | 设置当前对象的默认读写模式 |
具体的使用会在以后的文章具体介绍
Statment
Statement接口/对象主要用于执行静态的sql语句
用法
1 statement = connection.createStatement();
2
3 resultSet = statement.executeQuery("select * from user");
第一行：statement = connection.createStatement(); 用于在连接中获取一个Statement对象，
第二行：resultSet = statement.executeQuery("select * from user"); 用于执行sql语句，其中executeQuery是专门用于执行查询的语句，返回的是一个ResultSet对象。传进去的参数是一个String型的sql语句。
也可以这样写：
String SQL = "select * from user"； resultSet = statement.executeQuery(SQL);
下面是一些常用方法
| 返回类型 | 方法名 | 功能描述 |
| ResultSet | executeQuery(String sql) | 用于向数据发送查询语句。返回查询结果所组成的结果集 |
| int | executeUpdate(String sql) | 用于向数据库发送insert、update或delete语句 返回的值代表可执行增，删，改，返回执行受到影响的行数 |
| boolean | execute(String sql) | 用于向数据库发送任意sql语句，如果是结果集（查询语句） 返回为true，如果是计数值，则返回false |
虽然Stamtement提供的常用方法可以执行任何增删改查语句，但存在sql注入的安全问题，并且在编写sql语句时要拼接sql字符串。所以存在着另一个更好用的sql语句执行器.preparedStatement
PreparedStatement
该接口表示预编译的 SQL 语句的对象,SQL 语句被预编译并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。
PreperedStatement是Statement的子类，它的实例对象可以通过调用Connection.preparedStatement()方法获得
相对于Statement对象而言：PreperedStatement可以避免SQL注入的问题。
Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement可对SQL进行预编译，从而提高数据库的执行效率。并且PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写。
使用方法
String SQL = "insert into car(id,model,color,factory,birday,price) values(?,?,?,?,?,?);";
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1, id);
preparedStatement.setString(2, car.getMode());
preparedStatement.setString(3, car.getColor());
preparedStatement.setString(4, car.getFactor());
preparedStatement.setString(5, car.getbirday());
preparedStatement.setString(6, Price);
以上代码，无法直接使用。
preparedStatement.setString(1, id); 数字1代表的是第几个占位符，id是个String类型，代表要把占位替换的值。
该句的意思是：把 "insert into car(id,model,color,factory,birday,price) values(?,?,?,?,?,?);"字符串中的第一个 "?" 替换成 id字符串的值
同理 preparedStatement.setString(3, car.getColor()); 是把第三个"?" 替换成 car对象中的颜色属性的值 Color。
在使用前同样需要获取一个 preparedStatement对象 preparedStatement = connection.prepareStatement(SQL);
关于preparedStatement的常用方法会在以后的文章介绍
ResultSet
通过调用 Statement 对象的 excuteQuery() 方法创建该对象
JDBC程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。
使用方法
resultSet = statement.executeQuery("select * from user");
while(resultSet.next())
{
System.out.println((resultSet.getObject(1)).toString());
}
通过调用 Statement 对象的 excuteQuery() 方法创建该对象，同样使用preparedStatement.executeQuery()也可以创建ResultSet
查询的结果是以二维表的形式存在resultSet中的。如下图所示。
通过resultSet.next()控制游标移动，获取结果。每一次移动都是向下移动一行。
常用的方法
| 返回类型 | 方法名 | 功能描述 |
| Object | getObject(int index) | 返回结果集中一个指定为index列的数据 |
| Object | getObject(string columnName) | 以Object类型 返回名字为columnName 的列 |
| String | getString(int index) | 返回结果集中一个指定为index列的数据，该数据为String |
| String | getString(String columnName) | 以String类型 返回名字为columnName 的列 |
| boolean | next() | 移动到下一行 |
| void | previous() | 移动到前一行 |
| void | absolute(int row) | 移动到指定行 |
| void | beforeFirst() | 移动resultSet的最前面 |
| void | afterLast() | 移动到resultSet的最后面 |
除了表中的getString之外，还有很多get方法，get方法返回的是java基本数据类型，比如int float double等。
现在以轿车管理系统的一个表作为实例，演示上面三个对象在项目中的具体应用。
比如说，利用上面三个对象实现这个轿车销售系统
第一步：设计数据表。
从上面的描述可以知道至少有4张表，分别为轿车信息表，员工表，客户表，轿车销售表。
进行简单的E-R图设计，本例子着重演示jdbc使用，在考虑设计表事，不考虑数据库设计范式等要求。
E-R图设计好之后，便是根据E-R图设计数据表，数据表中的外键和主键需要在E-R中进行标注，数据表的设计需要考虑依赖关系等，这这里都被我忽略了。
根据E-R图创建四张表，字段属性根据实际业务而定。
设计表的时候一定要记得写注释，否则容易忘记字段说代表的含义。
在数据库中建立表后，就需要编写相对应的javaBean，把数据表映射为对象，以此方便我们对数据进行展示和操作。
以下代码是对应javabean的编写
Car表对应的javaBean。
Car类中的属性对应着表中的字段，这样就可以通过修改javabean的属性值，从而达到修改数据表。JavaBean的作用是把存在硬盘中的数据表映射在内存中，方便我们修改和减少对磁盘的操作，以此提高程序的运行效率
public class Car {
private int id;
private String mode;
private String color;
private String factor;
private String birday;
private double price; //私有属性，必须通过方法获得
public void setPrice(double price) { //set代表设置，get代表或取，提供了我们修改javaBean的接口，这也是JavaBean的编写规范
this.price = price;
}
public void setId(int id) {
this.id = id;
}
public void setBirday(String birday) {
this.birday = birday;
}
public void setColor(String color) {
this.color = color;
}
public void setFactor(String factor) {
this.factor = factor;
}
public void setMode(String mode) {
this.mode = mode;
}
public double getPrice() {
return price;
}
public int getId() {
return id;
}
public String getBirday() {
return birday;
}
public String getColor() {
return color;
}
public String getFactor() {
return factor;
}
public String getMode() {
return mode;
}
@Override
public String toString() { //重写toString方法，方便我们查看
return "Car{" +
"id=" + id +
", mode='" + mode + '\'' +
", color='" + color + '\'' +
", factor='" + factor + '\'' +
", birday='" + birday + '\'' +
", price=" + price +
'}';
}
}
Carsell 对应Mysql数据库中的carsell表
public class Carsell {
private String selldata;
private String classcar;
private String color;
private int number;
private String buyer;
private int id;
public void setColor(String color) {
this.color = color;
}
public void setId(int id) {
this.id = id;
}
public void setNumber(int number) {
this.number = number;
}
public void setBuyer(String buyer) {
this.buyer = buyer;
}
public void setClasscar(String classcar) {
this.classcar = classcar;
}
public void setSelldata(String selldata) {
this.selldata = selldata;
}
public String getColor() {
return color;
}
public int getId() {
return id;
}
public int getNumber() {
return number;
}
public String getBuyer() {
return buyer;
}
public String getClasscar() {
return classcar;
}
public String getSelldata() {
return selldata;
}
@Override
public String toString() {
return "Carsell{" +
"selldata='" + selldata + '\'' +
", classcar='" + classcar + '\'' +
", color='" + color + '\'' +
", number=" + number +
", buyer='" + buyer + '\'' +
", id=" + id +
'}';
}
}
Client
public class Client {
private String name;
private String phone;
private String adress;
private String business;
public void setName(String name) {
this.name = name;
}
public void setAdress(String adress) {
this.adress = adress;
}
public void setPhone(String phone) {
this.phone = phone;
}
public void setBusiness(String business) {
this.business = business;
}
public String getName() {
return name;
}
public String getAdress() {
return adress;
}
public String getPhone() {
return phone;
}
public String getBusiness() {
return business;
}
@Override
public String toString() {
return "Client{" +
"name='" + name + '\'' +
", phone='" + phone + '\'' +
", adress='" + adress + '\'' +
", business='" + business + '\'' +
'}';
}
}
Staff
public class Staff {
private int id;
private String name;
private String sex;
private int age;
private String hometown;
private String education;
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setEducation(String education) {
this.education = education;
}
public void setHometown(String hometown) {
this.hometown = hometown;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getEducation() {
return education;
}
public String getHometown() {
return hometown;
}
public String getSex() {
return sex;
}
@Override
public String toString() {
return "Staff{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", hometown='" + hometown + '\'' +
", education='" + education + '\'' +
'}';
}
}
编写完javaBean后，我们需要编写需要实现的功能。
继续对这个要求分析。需求中，要求我们实现基本信息的录入、修改、删除、并按照一定条件进行查询和统计。在这，我实现基本的增删改查的功能。
增删改查的实现需要借助
Connection
PreparedStatement
ResultSet
在上文的第一个演示中，在数据库中获取数据的步骤是 建立连接->执行语句->获取结果集
但现在步骤变成了
查询
建立连接 - > 按要求选择查询语句->执行语句查询-> 把结果集映射为javabean -> 关闭连接 ->展示JavaBean
删除
建立连接 - > 传入要删除的对象标识->执行语句 -> 对象被删除 ->关闭连接
增加
建立连接 ->输入要增加对象的属性值->映射为JavaBean->传入要增加的对象的JavaBean->执行语句 ->数据库增加 ->关闭连接
修改
建立连接 ->输入要修改的对象的属性值->映射为JavaBean-> 传入要修改的JavaBean对象->执行语句->数据库被修改->关闭连接
可以看到，JavaBean起了桥梁的作用，所以JavaBean的编写是十分重要。在从上面分析，我们可以抽象出一个java对象，这个对象专门用来对数据库进行增删改查
这个对象的属性是
Connection
PreparedStatement
ResultSet
方法是对数据库的具体操作。
因为有4张表，每张表都要进行增删改查，所以有16种方法，当然，完全可以通过反射、代理等机制只编写简短的代码进行方法的实现，但在采用最具有暴力美感的且原始的实现。
对数据库进行操作的java对象的编写
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
public class SqlStatement {
private Connection connection = null; //对应的属性，连接，执行，结果集，这使用的是PreparedStatement，简化了一些代码
private PreparedStatement preparedStatement = null;
private ResultSet resultSet = null;
public boolean insertCar(Car car) {
if (car==null)
{
return false;
}
boolean fl = false;
String SQL = "insert into car(model,color,factory,birday,price) values(?,?,?,?,?);";
String Price = String.valueOf(car.getPrice());
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1, car.getMode());
preparedStatement.setString(2, car.getColor());
preparedStatement.setString(3, car.getFactor());
preparedStatement.setString(4, car.getFactor());
preparedStatement.setString(5, Price);
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
public boolean insertCarsell(Carsell carsell) {
if (carsell==null)
{
return false;
}
boolean fl = false;
String SQL = "insert into carsell(selldata,classcar,color,number,buyer) values(?,?,?,?,?,?);";
String number = String.valueOf(carsell.getNumber());
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,carsell.getSelldata());
preparedStatement.setString(2,carsell.getClasscar() );
preparedStatement.setString(3,carsell.getColor());
preparedStatement.setString(4,number );
preparedStatement.setString(5,carsell.getBuyer());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
public boolean insertClient(Client client) {
if (client==null)
{
return false;
}
boolean fl = false;
String SQL = "insert into client(name,phone,adress,busines) values(?,?,?,?);";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,client.getName());
preparedStatement.setString(2,client.getPhone());
preparedStatement.setString(3,client.getAdress());
preparedStatement.setString(4,client.getBusiness());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
public boolean insertStaff(Staff staff) {
if (staff==null)
{
return false;
}
boolean fl = false;
String SQL = "insert into staff(name,sex,age,hometown,education) values(?,?,?,?,?);";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,staff.getName());
preparedStatement.setString(2,staff.getSex());
preparedStatement.setString(3,String.valueOf(staff.getAge()));
preparedStatement.setString(4,staff.getHometown());
preparedStatement.setString(5,staff.getEducation());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
public ArrayList<Car> getCar() {
ArrayList<Car> temps = new ArrayList<>();
String SQL = "select * from car";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Car car = new Car();
car.setId(resultSet.getInt(1));
car.setMode(resultSet.getString(2));
car.setColor(resultSet.getString(3));
car.setFactor(resultSet.getString(4));
car.setBirday(String.valueOf(resultSet.getDate(5)));
car.setPrice(resultSet.getDouble(6));
temps.add(car);
}
} catch (SQLException e) {
e.printStackTrace();
}
return temps;
}
public ArrayList<Carsell>getCarsell(){
ArrayList<Carsell> temps = new ArrayList<>();
String SQL = "select * from carsell";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Carsell temp = new Carsell();
temp.setSelldata(String.valueOf(resultSet.getDate(1)));
temp.setClasscar(resultSet.getString(2));
temp.setColor(resultSet.getString(3));
temp.setNumber(resultSet.getInt(4));
temp.setBuyer(resultSet.getString(5));
temp.setId(resultSet.getInt(6));
temps.add(temp);
}
} catch (SQLException e) {
e.printStackTrace();
}
return temps;
}
public ArrayList<Client>getClient(){
ArrayList<Client> temps = new ArrayList<>();
String SQL = "select * from client";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Client temp = new Client();
temp.setName(resultSet.getString(1));
temp.setPhone(resultSet.getString(2));
temp.setAdress(resultSet.getString(3));
temp.setBusiness(resultSet.getString(4));
temps.add(temp);
}
} catch (SQLException e) {
e.printStackTrace();
}
return temps;
}
public ArrayList<Staff>getStaff(){
ArrayList<Staff> temps = new ArrayList<>();
String SQL = "select * from staff";
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Staff temp = new Staff();
temp.setId(resultSet.getInt(1));
temp.setName(resultSet.getString(2));
temp.setSex(resultSet.getString(3));
temp.setAge(resultSet.getInt(4));
temp.setHometown(resultSet.getString(5));
temp.setEducation(resultSet.getString(6));
temps.add(temp);
}
} catch (SQLException e) {
e.printStackTrace();
}
return temps;
}
boolean delectCar(int id){
boolean fl = false;
String SQL = "delete from car where id="+id;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
fl = 0 < preparedStatement.executeUpdate();
}catch (SQLException e){
e.printStackTrace();
}
return fl;
}
boolean delectCarsell(int id){
boolean fl = false;
String SQL = "delete from carsell where id="+id;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
fl = 0 < preparedStatement.executeUpdate();
}catch (SQLException e){
e.printStackTrace();
}
return fl;
}
boolean delectClient(String name){
boolean fl = false;
String SQL = "delete from client where name="+name;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
fl = 0 < preparedStatement.executeUpdate();
}catch (SQLException e){
e.printStackTrace();
}
return fl;
}
boolean delectStaff(int id){
boolean fl = false;
String SQL = "delete from staff where id="+id;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
fl = 0 < preparedStatement.executeUpdate();
}catch (SQLException e){
e.printStackTrace();
}
return fl;
}
boolean updateCar(int id,Car car){
if (car==null)
{
return false;
}
boolean fl = false;
String SQL = "update car set model=?,color=?,factory=?,birday=?,price=? where id="+id;
String Price = String.valueOf(car.getPrice());
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1, car.getMode());
preparedStatement.setString(2, car.getColor());
preparedStatement.setString(3, car.getFactor());
preparedStatement.setString(4, car.getFactor());
preparedStatement.setString(5, Price);
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
boolean updateCarsell(int id,Carsell carsell){
if (carsell==null)
{
return false;
}
boolean fl = false;
String SQL = "update carsell set selldata=?,classcar=?,color=?,number=?,buyer=? where id="+id;
String number = String.valueOf(carsell.getNumber());
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,carsell.getSelldata());
preparedStatement.setString(2,carsell.getClasscar() );
preparedStatement.setString(3,carsell.getColor());
preparedStatement.setString(4,number );
preparedStatement.setString(5,carsell.getBuyer());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
};
boolean updateClient(String name,Client client){
if (client==null)
{
return false;
}
boolean fl = false;
String SQL = "update client set name=?,phone=?,adress=?,business=? where name="+name;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,client.getName());
preparedStatement.setString(2,client.getPhone());
preparedStatement.setString(3,client.getAdress());
preparedStatement.setString(4,client.getBusiness());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
boolean updateStaff(int id,Staff staff){
if (staff==null)
{
return false;
}
boolean fl =false;
String SQL = "update stall set name=?,sex=?,age=?,hometown=?,education=? where id="+id;
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1,staff.getName());
preparedStatement.setString(2,staff.getSex());
preparedStatement.setString(3,String.valueOf(staff.getAge()));
preparedStatement.setString(4,staff.getHometown());
preparedStatement.setString(5,staff.getEducation());
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
}
代码很长，以Car表为分析对象
private Connection connection = null;
private PreparedStatement preparedStatement = null;
private ResultSet resultSet = null;
public boolean insertCar(Car car) {
if (car==null)
{
return false;
}
boolean fl = false;
String SQL = "insert into car(model,color,factory,birday,price) values(?,?,?,?,?);";
String Price = String.valueOf(car.getPrice());
try {
connection = utildata.getConnection();
preparedStatement = connection.prepareStatement(SQL);
preparedStatement.setString(1, car.getMode());
preparedStatement.setString(2, car.getColor());
preparedStatement.setString(3, car.getFactor());
preparedStatement.setString(4, car.getBirday());
preparedStatement.setString(5, Price);
fl = 0 < preparedStatement.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
utildata.close(connection, preparedStatement, null);
}
return fl;
}
这是个car的插入函数，函数的流程是 1.判断传入参数是不是空----->2.编写插入所用的SQL语句------>3.把类中不是字符串的属性变成字符串--------->4.获取连接------------->5.设置占位符的属性------------>6.执行SQL------->7.关闭------->8.返回
第四步：获取连接使用的是做自己编写的数据库连接工具类。目的是提高性能，磁盘操作很占用
标签：JDBC,return,String,为例,setString,CRUD,connection,preparedStatement,public 来源： https://www.cnblogs.com/aoCat/p/15957959.html