数据库连接JDBC

最新推荐文章于 2024-07-29 14:22:26 发布

Mrs_DongDong

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量770

点赞数

文章标签： java java-ee 数据库

本文链接：https://blog.csdn.net/Mrs_DongDong/article/details/123325202

版权

1、简洁

JDBC（Java DataBase Connectivity，java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序

Java 具有坚固、安全、易于使用、易于理解和可从网络上自动下载等特性，是编写数据库应用程序的杰出语言。所需要的只是 Java应用程序与各种不同数据库之间进行对话的方法。

JDBC可以在各种平台上使用Java，如Windows，Mac OS和各种版本的UNIX。

JDBC的作用：

连接数据库。
创建SQL或MySQL语句。
在数据库中执行SQL或MySQL查询。
查看和修改生成的记录。

2、JDBC体系结构

JDBC API支持用于数据库访问的两层和三层处理模型，但通常，JDBC体系结构由两层组成：

JDBC API：这提供了应用程序到JDBC管理器连接。
JDBC驱动程序API：这支持JDBC管理器到驱动程序连接。

JDBC API使用驱动程序管理器和特定于数据库的驱动程序来提供与异构数据库的透明连接

3、JDBC核心组件

DriverManager：此类管理数据库驱动程序列表。使用通信子协议将来自java应用程序的连接请求与适当的数据库驱动程序匹配。

Driver:此接口处理与数据库服务器的通信，我们很少会直接与Driver对象进行交互。而是使用 DriverManager对象来管理这种类型的对象。

Connection：该界面具有用于联系数据库的所有方法。连接对象表示通信上下文，即，与数据库的所有通信仅通过连接对象

Statement：使用从此接口创建的对象将SQL语句提交到数据库。除了执行存储过程之外，一些派生接口还接受参数。

ResultSet：在使用Statement对象执行SQL查询后，这些对象保存从数据库检索的数据。它作为一个迭代器，允许我们移动其数据。

SQLException：此类处理数据库应用程序中发生的任何错误

4、CRUD语法介绍

SQL 是一种标准化的语言，它允许你在数据库上执行操作，如创建项目，查询内容，更新内容，并删除条目等操作。

Create, Read, Update, and Delete 通常称为CRUD操作。

CREATE DATABASE语句用于创建新的数据库：

create database database_name;

DROP DATABASE语句用于删除现有数据库

DROP DATABASE DATABASE_NAME;

CREATE TABLE语句用于创建新表。语法是

CREATA TABLE EMPLOYEES(
ID INT NOT NULL;
AGE INT NOT NULL;
NAME VARCHER (255);
BIRTHDAY TIMEDATE();
PRIMARY KEYY (ID);
);

DROP TABLE语句用于删除现有表。

DROP TABLE TABLE_NAME;

INSERT的语法类似于以下内容，其中column1，column2等表示要显示在相应列中的新数据

 INSERT INTO table_name VALUES (column1, column2, ...);

SELECT语句用于从数据库中检索数据。SELECT的语法是

SELECT column_name, column_name, ... FROM table_name WHERE conditions;

WHERE子句可以使用比较运算符，例如=，！=，<，>，<=和> =，以及BETWEEN和LIKE运算符。

UPDATE语句用于更新数据。

UPDATE table_name
SET column_name = value, column_name = value, ...
WHERE conditions;

DELETE语句用于从表中删除数据。

DELETE FROM table_name WHERE conditions

5、使用步骤

构建JDBC应用程序涉及以下六个步骤：

导入包：需要包含包含数据库编程所需的JDBC类的包。大多数情况下，使用import java.sql.*就足够
注册JDBC驱动程序：要求您初始化驱动程序，以便您可以打开与数据库的通信通道。
打开连接：需要使用DriverManager.getConnection（）方法创建一个Connection对象，该对象表示与数据库的物理连接。
执行查询：需要使用类型为Statement的对象来构建和提交SQL语句到数据库
从结果集中提取数据：需要使用相应的ResultSet.getXXX（）方法从结果集中检索数据。
释放资源：需要明确地关闭所有数据库资源，而不依赖于JVM的垃圾收集。

6、JDBC连接步骤

建立JDBC连接所涉及的编程相当简单。这是简单的四个步骤

导入JDBC包：将Java语言的import语句添加到Java代码中导入所需的类。
注册JDBC驱动程序：此步骤将使JVM将所需的驱动程序实现加载到内存中，以便它可以满足您的JDBC 请求。
- 注册JDBC驱动程序：此步骤将使JVM将所需的驱动程序实现加载到内存中，以便它可以满足您的JDBC 请求。
创建连接对象：最后，调用DriverManager对象的getConnection（）方法来建立实际的数据库连接。

Class.forName();

注册驱动程序最常见的方法是使用Java的Class.forName()方法，将驱动程序的类文件动态加载到内存中，并将其自动注册

try {
    Class.forName("com.mysql.cj.jdbc.Driver");
}catch(ClassNotFoundException ex) {
    System.out.println("Error: unable to load driver class!");
    System.exit(1);
}

DriverManager.registerDriver()

第二种方法是使用静态DriverManager.registerDriver（）方法。

try {
	Driver myDriver = new com.mysql.cj.jdbc.Driver();
	DriverManager.registerDriver( myDriver );
}catch(ClassNotFoundException ex) {
    System.out.println("Error: unable to load driver class!");
    System.exit(1);
}

数据库URL配置

加载驱动程序后，可以使用DriverManager.getConnection（）方法建立连接。为了方便参考，让我列出三个重载的DriverManager.getConnection()方法 -

getConnection（String url）
getConnection（String url，Properties prop）
getConnection（String url，String user，String password）

创建数据库连接对象

String URL = "jdbc:mysql://localhost:3306/yhp2?serverTimezone=UTC";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

完整的连接地址:

jdbc:mysql://localhost:3306/数据库名?
useSSL=false&useUnicode=true&characterEncoding=UTF-8

jdbc:mysql://localhost:3306/yhp2?serverTimezone=UTC

关闭数据库连接

为确保连接关闭，您可以在代码中提供一个“finally”块。一个finally块总是执行，不管是否发生异常。要关闭上面打开的连接，你应该调用close（）方法如下

coon.close();

6.1JDBC执行SQL语句

一旦获得了连接，我们可以与数据库进行交互。JDBC Statement和PreparedStatement接口定义了使您能够发送SQL命令并从数据库接收数据的方法和属性。

用于对数据库进行通用访问。在运行时使用静态SQL语句时很有用。Statement接口不能接受参数。

当您计划多次使用SQL语句时使用。PreparedStatement接口在运行时接受输入参数。

6.2statement

创建语句对象

在使用Statement对象执行SQL语句之前，需要使用Connection对象的createStatement（）方法创建一个，如下例所示：

Statement stmt = null;
try {
    stmt = conn.createStatement( );
    . . .
}
catch (SQLException e) {
    . . .
}
finally {
	. . .
}

创建Statement对象后，您可以使用它来执行一个SQL语句，其中有三个执行方法

boolean execute（String SQL）：如果可以检索到ResultSet对象，则返回一个布尔值true; 否则返回false。使用此方法执行SQL DDL语句或需要使用真正的动态SQL时。
int executeUpdate（String SQL）：返回受SQL语句执行影响的行数。使用此方法执行预期会影响多个行的SQL语句，例如INSERT，UPDATE或DELETE语句。
ResultSet executeQuery（String SQL）：返回一个ResultSet对象。当您希望获得结果集时，请使用此方法，就像使用SELECT语句一样。

关闭Statement对象

就像我们关闭一个Connection对象以保存数据库资源一样，由于同样的原因，还应该关闭Statement对象。

一个简单的调用close（）方法将执行该作业。如果先关闭Connection对象，它也会关闭Statement对象。但是，应始终显式关闭Statement对象，以确保正确清理。

Statement stmt = null;
try {
    stmt = conn.createStatement( );
    . . .
}
catch (SQLException e) {
	. . .
}
finally {
	stmt.close();
}

6.3SQL注入

就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有应用程序，将（恶意的）SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。比如先前的很多影视网站泄露VIP会员密码大多就是通过 WEB表单递交查询字符暴出的，这类表单特别容易受到SQL注入式攻击。

String username ="admin";
String password=" 'abc' or 1=1 ";
String sql="select * from users where username= '"+username+"' and password=
"+password;

7、PreparedStatement(预状态通道)

该PreparedStatement的接口扩展了Statement接口，它为您提供了一个通用的Statement对象有两个优点附加功能。

此语句使您可以动态地提供参数。

PreparedStatement pstmt = null;
try {
    String SQL = "Update Employees SET age = ? WHERE id = ?";
    pstmt = conn.prepareStatement(SQL);
    . . .
}
catch (SQLException e) {
	. . .
}
finally {
	. . .
}

JDBC中的所有参数都由？符号，这被称为参数标记。在执行SQL语句之前，必须为每个参数提供值。

所述的setXXX()方法将值绑定到所述参数，其中XXX代表要绑定到输入参数的值的Java数据类型。如果忘记提供值，将收到一个SQLException。

每个参数标记由其顺序位置引用。第一个标记表示位置1，下一个位置2等等。该方法与Java数组索引不同，从0开始。

关闭PreparedStatement对象

一个简单的调用close（）方法将执行该作业。如果先关闭Connection对象，它也会关闭 PreparedStatement对象。但是，应始终显式关闭PreparedStatement对象，以确保正确清理。

对比statement和PreparedStatement;

(1)statement属于状态通道，PreparedStatement属于预状态通道
(2)预状态通道会先编译sql语句,再去执行，比statement执行效率高
(3)预状态通道支持占位符?,给占位符赋值的时候，位置从1开始
(4)预状态通道可以防止sql注入，原因:预状态通道在处理值的时候以字符串的方式处理

8、Resultset

SELECT语句是从数据库中选择行并在结果集中查看行的标准方法。该java.sql.ResultSet中的接口表示结果集数据库查询。

ResultSet对象维护指向结果集中当前行的游标。术语“结果集”是指包含在ResultSet对象中的行和列数据。

类型	描述
ResultSet.TYPE_SCROLL_INSENSITIVE	光标可以向前和向后滚动，结果集对创建结果集后发生的数据库的其他更改不敏感。
ResultSet.TYPE_SCROLL_SENSITIVE。	光标可以向前和向后滚动，结果集对创建结果集之后发生的其他数据库所做的更改敏感。
ResultSet.TYPE_FORWARD_ONLY	光标只能在结果集中向前移动。

9、JAVA操作两表关系

四种:双向一对一，一对多，多对一，多对多

多表关系处理数据

(1) 数据库通过外键建立两表关系

(2) 实体类通过属性的方式建立两表关系

实体类要求:类名=表名，列名=属性名

9.1一对多（老师->学生

1创建数据表

CREATE TABLE `student` (
`stuid` int(11) NOT NULL AUTO_INCREMENT,
`stuname` varchar(255) DEFAULT NULL,
`teacherid` int(11) DEFAULT NULL,
PRIMARY KEY (`stuid`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
INSERT INTO `student` VALUES ('1', 'aaa', '3');
INSERT INTO `student` VALUES ('2', 'bb', '1');
INSERT INTO `student` VALUES ('3', 'cc', '3');
INSERT INTO `student` VALUES ('4', 'dd', '1');
INSERT INTO `student` VALUES ('5', 'ee', '1');
INSERT INTO `student` VALUES ('6', 'ff', '2');
DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher` (
`tid` int(11) NOT NULL AUTO_INCREMENT,
`tname` varchar(255) DEFAULT NULL,
PRIMARY KEY (`tid`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `teacher` VALUES ('1', '张三老师');
INSERT INTO `teacher` VALUES ('2', '李四老师');
INSERT INTO `teacher` VALUES ('3', '王五');

2 创建实体类

public class Teacher {
    private int tid;
    private String tname;
    private List<Student> list=new ArrayList<Student>();
    public List<Student> getList() {
        return list;
    }
    public void setList(List<Student> list) {
        this.list = list;
    }
    public int getTid() {
        return tid;
    }
    public void setTid(int tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
}


public class Student {
    private int stuid;
    private String stuname;
    //外键列一般不生成属性
    // private int teacherid;
    public int getStuid() {
    	return stuid;
    }
    public void setStuid(int stuid) {
    	this.stuid = stuid;
    }
    public String getStuname() {
    	return stuname;
    }
    public void setStuname(String stuname) {
    	this.stuname = stuname;
    }
}

3 定义dao接口

public interface TeacherDao {
//定义操作方法
//1.定义一个根据老师id查询老师信息(学生的信息)
public Teacher getById(int tid);
}

4 定义实现类

public class TeacherDaoImpl implements TeacherDao {
    @Override
    public Teacher getById(int tid) {
        //操作数据库
        Connection connection =null;
        PreparedStatement pps =null;
        ResultSet resultSet =null;
        try {
            //1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.获得链接
            String userName="root";
            String passWord="123456";
            String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //3.定义sql,创建预状态通道(进行sql语句的发送)
            String sql="select * from student s,teacher t where
            s.teacherid=t.tid and t.tid=?";
            pps = connection.prepareStatement(sql);
            //给占位符赋值 （下标，内容） 从1开始
            pps.setInt(1,tid);
            //执行sql
            resultSet = pps.executeQuery();
            Teacher teacher = new Teacher();
            List<Student> students=new ArrayList<Student>();
            while (resultSet.next()){
                //1.取出各自的信息
                teacher.setTid(resultSet.getInt("tid"));
                teacher.setTname(resultSet.getString("tname"));
                Student student = new Student();
                student.setStuId(resultSet.getInt("stuid"));
                student.setStuName(resultSet.getString("stuname"));
                //2.建立学生和老师之间的关系
                students.add(student);
            }
            teacher.setStudentList(students);
            return teacher;
        } catch (ClassNotFoundException e) {
        	e.printStackTrace();
        } catch (SQLException throwables) {
        	throwables.printStackTrace();
        } finally {
                try {
                //5.关闭资源
                    if (resultSet != null) {
                    resultSet.close();
                    }
                    if (pps != null) {
                    pps.close();
                    }
                    if (connection != null) {
                    connection.close();
                   	}
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        return null;
        }
}

5 定义测试类

public class Demo1 {
    public static void main(String[] args) {
        TeacherDao dao= new TeacherDaoImpl();
        Teacher teacher = dao.getById(1);
        System.out.println("老师姓名:"+teacher.getTname());
        List<Student> studentList = teacher.getStudentList();
        for (Student student : studentList) {
        	System.out.println("\t studentname="+student.getStuName());
        }
    }
}

9.2多对一（学生----老师

实体类

public class Student {
    private int stuid;
    private String stuname;
    //外键列一般不生成属性
    // private int teacherid;
    private Teacher teacher;
    public int getStuid() {
    	return stuid;
    }
    public void setStuid(int stuid) {
    	this.stuid = stuid;
	}
    public String getStuname() {
    	return stuname;
    }
    public void setStuname(String stuname) {
    	this.stuname = stuname;
    }
    public Teacher getTeacher() {
    	return teacher;
    }
    public void setTeacher(Teacher teacher) {
    	this.teacher = teacher;
    }
}

public class Teacher {
    private int tid;
    private String tname;
    public int getTid() {
    	return tid;
    }
    public void setTid(int tid) {
    	this.tid = tid;
    }
    public String getTname() {
    	return tname;
    }
    public void setTname(String tname) {
    	this.tname = tname;
    }
}

接口

//查询所有的学生(包含老师的信息)
public List<Student> getAll();

实现类

public List<Student> getAll() {
    //操作数据库
    Connection connection =null;
    PreparedStatement pps =null;
    ResultSet resultSet =null;
    try {
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获得链接
        String userName="root";
        String passWord="123456";
        String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
        connection = DriverManager.getConnection(url, userName, passWord);
        //3.定义sql,创建预状态通道(进行sql语句的发送)
        String sql="select * from student s,teacher t where
        s.teacherid=t.tid";
        pps = connection.prepareStatement(sql);
        //执行sql
        resultSet = pps.executeQuery();
        List<Student> students=new ArrayList<>();
        while (resultSet.next()){
            //1.取出各自的信息
            Student student = new Student();
            student.setStuId(resultSet.getInt("stuid"));
            student.setStuName(resultSet.getString("stuname"));
            Teacher teacher = new Teacher();
            teacher.setTid(resultSet.getInt("tid"));
            teacher.setTname(resultSet.getString("tname"));
            //2.建立学生和老师之间的关系
            student.setTeacher(teacher);
            students.add(student);
        }
        return students;
    } catch (ClassNotFoundException e) {
    	e.printStackTrace();
    } catch (SQLException throwables) {
    	throwables.printStackTrace();
    } finally {
        try {
            //5.关闭资源
            if (resultSet != null) {
            	resultSet.close();
            }
            if (pps != null) {
            	pps.close();
            }
            if (connection != null) {
            	connection.close();
            }
        } catch (SQLException throwables) {
        	throwables.printStackTrace();
        }
    }
    return null;
}

测试类

public static void main(String[] args) {
    TeacherDao dao= new TeacherDaoImpl();
    List<Student> students = dao.getAll();
    for (Student student : students) {
    	System.out.println(student.getStuName()+","+student.getTeacher().getTname());
    }
}

9.3一对一

public class Husband {
    private int husid;
    private String husname;
    private Wife wife;
    public int getHusid() {
    	return husid;
    }
    public void setHusid(int husid) {
    	this.husid = husid;
    }
    public String getHusname() {
    	return husname;
    }
    public void setHusname(String husname) {
    	this.husname = husname;
    }
    public Wife getWife() {
    	return wife;
    }
    public void setWife(Wife wife) {
    	this.wife = wife;
    }
}

public class Wife {
    private int wifeid;
    private String wifeName;
    private Husband husband;
    public int getWifeid() {
    	return wifeid;
    }
    public void setWifeid(int wifeid) {
    	this.wifeid = wifeid;
    }
    public String getWifeName() {
    	return wifeName;
    }
    public void setWifeName(String wifeName) {
    	this.wifeName = wifeName;
    }
    public Husband getHusband() {
    	return husband;
    }
    public void setHusband(Husband husband) {
    	this.husband = husband;
    }
}

接口

public interface WifeDao {
    //查询妻子信息(包含丈夫信息)
    public Wife getWife(int wid);
    //查询丈夫信息(包含妻子信息)
    public Husband getHus(int hid);
}

实现类

public class WifeDaoImpl implements WifeDao {
    @Override
    public Wife getWife(int wid) {
            //操作数据库
        Connection connection =null;
        PreparedStatement pps =null;
        ResultSet resultSet =null;
        try {
            //1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.获得链接
            String userName="root";
            String passWord="123456";
            String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //3.定义sql,创建预状态通道(进行sql语句的发送)
            String sql="select * from wife w,husband h where w.hid=h.husid and
            w.wifeid=?";
            pps = connection.prepareStatement(sql);
            pps.setInt(1,wid);
            //执行sql
            resultSet = pps.executeQuery();
            Wife wife = new Wife();
            while (resultSet.next()){
                //1.取出各自的信息
                wife.setWifeId(resultSet.getInt("wifeid"));
                wife.setWifeName(resultSet.getString("wifename"));
                Husband husband = new Husband();
                husband.setHusId(resultSet.getInt("husid"));
                husband.setHusName(resultSet.getString("husname"));
                //2.建立妻子和丈夫之间的关系
                wife.setHusband(husband);
            }
            return wife;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            } catch (SQLException throwables) {
            throwables.printStackTrace();
            } finally {
            try {
                //5.关闭资源
                if (resultSet != null) {
                	resultSet.close();
                }
                if (pps != null) {
                	pps.close();
                }
                if (connection != null) {
                	connection.close();
                }
            } catch (SQLException throwables) {
            	throwables.printStackTrace();
            }
        }
    return null;
    }
@Override
public Husband getHus(int hid) {
    //操作数据库
    Connection connection =null;
    PreparedStatement pps =null;
    ResultSet resultSet =null;
    try {
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获得链接
        String userName="root";
        String passWord="123456";
        String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
        connection = DriverManager.getConnection(url, userName, passWord);
        //3.定义sql,创建预状态通道(进行sql语句的发送)
        String sql="select * from wife w,husband h where w.hid=h.husid and
        h.husid=?";
        pps = connection.prepareStatement(sql);
        pps.setInt(1,hid);
        //执行sql
        resultSet = pps.executeQuery();
        Husband husband = new Husband();
        while (resultSet.next()){
            //1.取出各自的信息
            Wife wife = new Wife();
            wife.setWifeId(resultSet.getInt("wifeid"));
            wife.setWifeName(resultSet.getString("wifename"));
            husband.setHusId(resultSet.getInt("husid"));
            husband.setHusName(resultSet.getString("husname"));
            //2.建立妻子和丈夫之间的关系
            husband.setWife(wife);
        }
        return husband;
    } catch (ClassNotFoundException e) {
    	e.printStackTrace();
    } catch (SQLException throwables) {
    	throwables.printStackTrace();
    } finally {
    try {
        //5.关闭资源
        if (resultSet != null) {
            resultSet.close();
        }
        if (pps != null) {
            pps.close();
        }
        if (connection != null) {
            connection.close();
        }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    return null;
    }
}

测试类

public static void main(String[] args) {
    WifeDaoImpl wifeDao = new WifeDaoImpl();
    Wife wife = wifeDao.getWife(1);
    System.out.println(wife.getWifeName()+","+wife.getHusband().getHusName());
    Husband hus = wifeDao.getHus(1);
    System.out.println(hus.getHusName()+","+hus.getWife().getWifeName());
}

9.4多对多（科目–学生

实体类

public class Subject {
private int subid;
private String subname;
private List stulist;
public int getSubid() {
return subid;
}
public void setSubid(int subid) {
this.subid = subid;
}
public String getSubname() {
return subname;
}
public void setSubname(String subname) {
this.subname = subname;
}
public List getStulist() {
return stulist;
}
public void setStulist(List stulist) {
this.stulist = stulist;
}
}

public class Student {
private int stuid;
private String stuname;
//外键列一般不生成属性
// private int teacherid;
private Teacher teacher;
private List<Subject> subjects;
public List<Subject> getSubjects() {
return subjects;
}
public void setSubjects(List<Subject> subjects) {
this.subjects = subjects;
}
public int getStuid() {
return stuid;
}
public void setStuid(int stuid) {
this.stuid = stuid;
}
public String getStuname() {
return stuname;
}
public void setStuname(String stuname) {
this.stuname = stuname;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}

接口

public interface SubjectDao {
    //查询某个学生信息（查询出所学科目）
    public Student findById(int id);
    //查询某个科目以及对应的学生姓名
    public Subject findBySubId(int subId);
  }

实现类

 public class SubjectDaoImpl implements SubjectDao {
        @Override
        public Student findById(int id) {
			//操作数据库
            Connection connection =null;
            PreparedStatement pps =null;
            ResultSet resultSet =null;
            try {
			//1.加载驱动
                Class.forName("com.mysql.cj.jdbc.Driver");
					//2.获得链接
                String userName="root";
                String passWord="123456";
                String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
                connection = DriverManager.getConnection(url, userName, passWord);
				//3.定义sql,创建预状态通道(进行sql语句的发送)
                String sql="select * from student s,subject su,middle m where
                s.stuid=m.stuid and su.subid=m.subid and s.stuid=?";
                pps = connection.prepareStatement(sql);
                pps.setInt(1,id);
				//执行sql
                resultSet = pps.executeQuery();
                Student student = new Student();
                List<Subject> subjects=new ArrayList<>();
                while (resultSet.next()){
				//1.取出各自的信息
                    student.setStuId(resultSet.getInt("stuid"));
                    student.setStuName(resultSet.getString("stuname"));
                    Subject subject = new Subject();
                    subject.setSubId(resultSet.getInt("subid"));
                    subject.setSubName(resultSet.getString("subname"));
                    subjects.add(subject);
                }
			//2.建立学生和科目之间的关系
                student.setSubjects(subjects);
                return student;
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                try {
			//5.关闭资源
                    if (resultSet != null) {
                        resultSet.close();
                    }
                    if (pps != null) {
                        pps.close();
                    }
                    if (connection != null) {
                        connection.close();
                    }
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            return null;
        }
        @Override
        public Subject findBySubId(int subId) {
		//操作数据库
            Connection connection =null;
            PreparedStatement pps =null;
            ResultSet resultSet =null;
            try {
		//1.加载驱动
                Class.forName("com.mysql.cj.jdbc.Driver");
		//2.获得链接
                String userName="root";
                String passWord="123456";
                String url="jdbc:mysql://localhost:3306/yhp3?serverTimezone=UTC";
                connection = DriverManager.getConnection(url, userName, passWord);
			//3.定义sql,创建预状态通道(进行sql语句的发送)
                String sql="select * from student s,subject su,middle m where
                s.stuid=m.stuid and su.subid=m.subid and su.subid=?";
                pps = connection.prepareStatement(sql);
                pps.setInt(1,subId);
			//执行sql
                resultSet = pps.executeQuery();
                Subject subject = new Subject();
                List<Student> studentList=new ArrayList<>();
                while (resultSet.next()){
			//1.取出各自的信息
                    Student student = new Student();
                    student.setStuId(resultSet.getInt("stuid"));
                    student.setStuName(resultSet.getString("stuname"));
                    studentList.add(student);
                    subject.setSubId(resultSet.getInt("subid"));
                    subject.setSubName(resultSet.getString("subname"));
                }
			//2.建立学生和科目之间的关系
                subject.setStudentList(studentList);
                return subject;
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            } finally {
                try {
		//5.关闭资源
                    if (resultSet != null) {
                        resultSet.close();
                    }
                    if (pps != null) {
                        pps.close();
                    }
                    if (connection != null) {
                        connection.close();
                    }
                    } catch (SQLException throwables) {
                            throwables.printStackTrace();
                     }
                 }
 		return null;
     }
   }

测试类

public static void main(String[] args) {
        SubjectDaoImpl subjectDao = new SubjectDaoImpl();
        /* Student student = subjectDao.findById(1);
        System.out.println(student.getStuName());
        List<Subject> subjects = student.getSubjects();
        for (Subject subject : subjects) {
        System.out.println("\t"+subject.getSubName());
        }*/
        Subject subject = subjectDao.findBySubId(2);
        System.out.println(subject.getSubName());
        List<Student> studentList = subject.getStudentList();
        for (Student student : studentList) {
            System.out.println("\t"+student.getStuName());
         }
    }

10、数据库事物

-> 一组要么同时执行成功，要么同时执行失败的SQL语句。是数据库操作的一个执行单元。

10.1事务概述

事务开始于

连接到数据库上，并执行一条DML语句insert、update或delete
前一个事务结束后，又输入了另一条DML语句

事务结束于

执行commit或rollback语句。
执行一条DDL语句，例如create table语句，在这种情况下，会自动执行commit语句。 -
执行一条DDL语句，例如grant语句，在这种情况下，会自动执行commit。 -
断开与数据库的连接
执行了一条DML语句，该语句却失败了，在这种情况中，会为这个无效的DML语句执行rollback语句

10.2事物的四大特点

actomicity(原子性)
表示一个事务内的所有操作是一个整体，要么全部成功，要么全部失败 -

consistency(一致性)
表示一个事务内有一个操作失败时，所有的更改过的数据都必须回滚到修改前状态 -

isolation(隔离性)
事务查看数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。 -

durability(持久性)
持久性事务完成之后，它对于系统的影响是永久性的。

10.3JDBC中的事物应用

如果JDBC连接处于自动提交模式，默认情况下，则每个SQL语句在完成后都会提交到数据库。

事务使您能够控制是否和何时更改应用于数据库。它将单个SQL语句或一组SQL语句视为一个逻辑单元，如果任何语句失败，则整个事务将失败。

要启用手动事务支持，而不是JDBC驱动程序默认使用的自动提交模式，请使用Connection对象的 setAutoCommit（）方法。如果将boolean false传递给setAutoCommit（），则关闭自动提交。我们可以传递一个布尔值true来重新打开它。

10.4事物的提交和回滚

完成更改后，我们要提交更改，然后在连接对象上调用commit（）方法，如下所示：

conn.commit();

否则，要使用连接名为conn的数据库回滚更新，请使用以下代码

conn.rollback( );

   try{
	//Assume a valid connection object conn
        conn.setAutoCommit(false);
        Statement stmt = conn.createStatement();
        String SQL = "INSERT INTO Employees values (106, 20, 'Rita', 'Tez')";
        stmt.executeUpdate(SQL);
	//Submit a malformed SQL statement that breaks
        String SQL = "INSERTED IN Employees VALUES (107, 22, 'Sita', 'Singh')";
        stmt.executeUpdate(SQL);
	// If there is no error.
        conn.commit();
    }catch(SQLException se){
	// If there is any error.
        conn.rollback();
    }

11.JDBC批处理

11.1Statement批处理

以下是使用语句对象的批处理的典型步骤序列 -

使用createStatement（）方法创建Statement对象。 -
使用setAutoCommit（）将auto-commit设置为false 。 -
使用addBatch（）方法在创建的语句对象上添加您喜欢的SQL语句到批处理中。 -
在创建的语句对象上使用executeBatch（）方法执行所有SQL语句。 -
最后，使用commit（）方法提交所有更改。

    Statement stmt = conn.createStatement();
	conn.setAutoCommit(false);
    //sql1
    String SQL = "INSERT INTO Employees (id, first, last, age) VALUES(200,'Zia',
'Ali', 30)";
        stmt.addBatch(SQL);
    //sql2
    String SQL = "INSERT INTO Employees (id, first, last, age) VALUES(201,'Raj',
'Kumar', 35)";
        stmt.addBatch(SQL);
    //sql3
    String SQL = "UPDATE Employees SET age = 35 WHERE id = 100";
	stmt.addBatch(SQL);
    int[] count = stmt.executeBatch();
	conn.commit();

11.2PreparedStatement批处理

使用占位符创建SQL语句。
使用prepareStatement（）方法创建PrepareStatement对象。
使用setAutoCommit（）将auto-commit设置为false 。
使用addBatch（）方法在创建的语句对象上添加您喜欢的SQL语句到批处理中。
在创建的语句对象上使用executeBatch（）方法执行所有SQL语句。
最后，使用commit（）方法提交所有更改。

    String SQL = "INSERT INTO Employees (id, first, last, age) VALUES(?, ?, ?, ?)";
    PreparedStatement pstmt = conn.prepareStatement(SQL);
    conn.setAutoCommit(false);
    // Set the variables
    pstmt.setInt( 1, 400 );
    pstmt.setString( 2, "Pappu" );
    pstmt.setString( 3, "Singh" );
    pstmt.setInt( 4, 33 );
    // Add it to the batch
    pstmt.addBatch();
    // Set the variables
    pstmt.setInt( 1, 401 );
    pstmt.setString( 2, "Pawan" );
    pstmt.setString( 3, "Singh" );
    pstmt.setInt( 4, 31 );
    // Add it to the batch
    pstmt.addBatch();
        //add more batches
    //Create an int[] to hold returned values
        int[] count = stmt.executeBatch();
    //Explicitly commit statements to apply changes
    conn.commit();

Mrs_DongDong

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据库连接JDBC

1、简洁JDBC（Java DataBase Connectivity，java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序Java 具有坚固、安全、易于使用、易于理解和可从网络上自动下载等特性，是编写数据库应用程序的杰出语言。所需要的只是 Java应用程序与各种不同数据库之间进行对话的方法。JDBC可以在各种平台上使用
复制链接

扫一扫