微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

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

分类：JDBC作者：编程之家原文地址AI导航网

在上一章，以及配置好了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.返回

第四步：获取连接使用的是做自己编写的数据库连接工具类。目的是提高性能，磁盘操作很占用

 

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

讲解JDBC
连接数据库的方式：第一种方式：ODBC：开放数据库连接是微软公司开放服务结构中有关数据库的一个组成部分，是数据库访问接口标准。ODBC是基于C语言实现的。提供了语言和数据库进行交互的一致性的接口，便于语言和数据库通信以及语言对数据库的各种操作。第二种方式：JDBC（本章重点）在Java中，
Jmeter 数据库请求
JDBCRequest 使用VariableNamesmysql：数据库连接池对象variousname：设置的变量名称 如何使用该变量a_#、b_#、c_#、d_#：代表行数a_1：第1行、第1列b_2：第2行、第2列
抽取基本JDBC中的基本操作与数据连接池
 1.JDBCDBC(JavaDataBaseConnectivity)：Java数据库连接技术：具体讲就是通过Java连接广泛的数据库，并对表中数据执行增、删、改、查等操作的技术。JDBC是数据库与Java代码的桥梁。JDBC中定义了操作数据库的各种接口和类型：增删改基本操作：（1）获取连接：Connectionconnection=
JDBC操作流程
1.需要jar包的支持：java.sqljavax.sqlmysql-conneter-java...连接驱动（必须要导入）<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.46</version></depend
Activiti可视化流程管理器
1.简介Activiti是一个业务流程管理(BPM)框架,它是覆盖了业务流程管理，工作流，服务协作等领域的一个开源，灵活的，易扩展的可执行流程语言框架。在Java工作流引擎中可谓是主流，我们的项目也是使用的这个框架进行流程相关的开发。与流程息息相关的就是我们的流程定义BPMN文件，包含有一系列
0811JDBC随笔
1.JDBC体系系统一组规范：接口JDBC接口（API）包括两个层次：面向应用的API：JavaAPI，抽象接口，供应用开发人员使用（连接数据库，执行SQL语句，获得结果）面向数据库的API：JavaDriverAPI，供开发商开发数据库驱动程序JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接
JDBC的基本概念
原文链接JDBC一般指Java数据库连接（JavaDatabaseConnectivity）api应用程序接口（API）：可以调用或者使用类/接口/方法等去完成某个目标。API制定的类/方法可以做什么。API由开发人员调用。spi服务提供接口（SPI）：需要继承或实现某些类/接口/方法等去完成某个目标。SPI告诉你
Shardingsphere-ShardingSphere-JDBC-Spring Boot配置-分片规则
spring.shardingsphere.datasource.names=#省略数据源配置，请参考用法#标准分表配置spring.shardingsphere.rules.sharding.tables.<table-name>.actual-data-nodes=#描述数据源名称和实际表，分隔符为点，多个数据节点用逗号分隔，支持内联表达式。Absent表示仅对数据库进行分片
20220814 idea_springboot_启动 Cannot load driver class: com.mysql.cj.jdbc.Driver
1问题Cannotloaddriverclass:com.mysql.cj.jdbc.Driver 2解决方案2.1已解决2.1.1首先，去查看项目中MySQL的版本如果找不到，说明可能还没有jdbc驱动，需要配置或者引入       （1）如果是直接引用的jar包，就去lib文件夹中查看，后缀是版
JDBC
JDBC一、JDBC概述什么是JDBC？JDBC是使用Java语言操作关系型数据库的一套API。这套API是交由不同的数据库厂商实现的。我们利用JDBC编写操作数据库的代码，真正执行的是各个数据库的实现类（驱动）。全称：（JavaDataBaseConnectivity）Java数据库连接。JDBC的好处面向接口编
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native