JDBC学习日志使用JDBC进行增删改查（CRUD）以轿车销售系统为例

2022/3/5 6:17:13

编程Tag： string return CRUD connection jdbc public 为例 preparedStatement setString

本文主要是介绍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学习日志使用JDBC进行增删改查（CRUD）以轿车销售系统为例的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

JDBC学习日志使用JDBC进行增删改查（CRUD）以轿车销售系统为例

JDBC

Connection

PreparedStatement

ResultSet

相关编程文章