JAVA连接数据库(JDBC)连接操作，CRUD 操作，JAVA中操作数据库的两表关系，JDBC中事务的应用。

JAVA操作两表关系

一对多（老师->学生）

 学生实体类

package com.bean;

//多方，多个学生可以对应一个老师
//实体类要求:类名=表名，列名=属性名
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;
    }

    public int getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(int teacherId) {
        this.teacherId = teacherId;
    }
}

老师实体类

package com.bean;

import java.util.List;

//一方，一个老师可以对应多个学生
//实体类要求:类名=表名，列名=属性名
public class Teacher {
    private int tid;
    private String tname;
    //在一方创建存储多方数据的集合
    private List<Student> studentList;

    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> getStudentList() {
        return studentList;
    }

    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
}

Dao包，定义操作方法的接口

package com.dao;

import com.bean.Teacher;

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

实现Dao包里的接口，定义实体操作方法

package com.dao.impl;

import com.bean.Student;
import com.bean.Teacher;
import com.dao.TeacherDao;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class TeacherDaoImpl implements TeacherDao {
    @Override
    public Teacher getById(int tid) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //1.加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //3.通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
            //JDBC中的所有参数都由？符号，这被称为参数标记。
            String sql = "SELECT * FROM student s,teacher t WHERE s.`teacherid`=t.`tid` AND t.`tid`=?";
            preparedStatement = connection.prepareStatement(sql);
            //4.参数填充，占位符赋值，下标从1开始
            preparedStatement.setInt(1, tid);
            //5.通过预编译sql语句和传入的参数查询语句查到结果集
            resultSet = preparedStatement.executeQuery();
            Teacher t = new Teacher();
            //创建集合存储学生信息
            List<Student> studentList = new ArrayList<>();
            //6.取出结果集
            while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
                //1.取出各自的信息
                //因为是一对多的关系，通过老师的id查询学生，老师的信息是不变的，学生的信息每行都是变化的
                String tname = resultSet.getString("tname");
                int teacherId = resultSet.getInt("tid");
                //将查询的结果赋值到Teacher对象里
                t.setTid(teacherId);
                t.setTname(tname);
               //因为是一对多的关系，通过老师的id查询学生，老师的信息是不变的，学生的信息每行都是变化的
                Student student = new Student();
                student.setStuId(resultSet.getInt("stuid"));
                student.setStuName(resultSet.getString("stuname"));
                //建立学生和老师之间的关系
                studentList.add(student);
            }
            //将学生对象的集合添加到老师对象里
            t.setStudentList(studentList);
            return t;


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        return null;
    }
}

测试类 

package com.test;

import com.bean.Student;
import com.bean.Teacher;
import com.dao.TeacherDao;
import com.dao.impl.TeacherDaoImpl;

import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        TeacherDao teacherDao = new TeacherDaoImpl();
        Teacher teacher = teacherDao.getById(1);
        System.out.println("老师姓名" + teacher.getTname());
        System.out.println("老师id" + teacher.getTid());
        List<Student> studentList = teacher.getStudentList();
        for (Student student : studentList) {
            System.out.println("学生姓名" + student.getStuName());
        }
        /*老师姓名张三老师
        老师id1
        学生姓名bb
        学生姓名dd
        学生姓名ee*/
    }
}

多对一(学生->老师)

多名学生对应一个老师

package com.bean;

//多方，多个学生可以对应一个老师
//实体类要求:类名=表名，列名=属性名
public class Student {
    private int stuId;
    private String stuName;
    private int teacherId;
    //多对一，在多方创建一个存储一方数据的对象
    private Teacher teacher;

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.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 int getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(int teacherId) {
        this.teacherId = teacherId;
    }
}

public List<Student> getAll() {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    //操作数据库
    //1.加载驱动
    try {
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.通过驱动管理器获取jdbc连接对象
        String userName = "root";
        String passWord = "123456";
        String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
        connection = DriverManager.getConnection(url, userName, passWord);
        //3.通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
        //JDBC中的所有参数都由？符号，这被称为参数标记。
        String sql = "SELECT * FROM student s,teacher t WHERE s.`teacherid`=t.`tid` ";
        preparedStatement = connection.prepareStatement(sql);
        //4.通过预编译sql语句和传入的参数查询语句查到结果集
        resultSet = preparedStatement.executeQuery();
        //创建集合存储学生对象也包含老师对象
        List<Student> studentList = new ArrayList<>();
        //5.取出结果集
        while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
            //1.取出各自的信息
            Student student = new Student();
            student.setStuId(resultSet.getInt("stuid"));
            student.setStuName(resultSet.getString("stuname"));

            Teacher teacher = new Teacher();
            String tname = resultSet.getString("tname");
            int teacherId = resultSet.getInt("tid");
            //将查询的结果赋值到Teacher对象里
            teacher.setTid(teacherId);
            teacher.setTname(tname);

            //将老师的信息赋值到学生对象里
            student.setTeacher(teacher);
    
            //将查询到的一行数据学生老师的都添加到集合里
            studentList.add(student);
        }

        return studentList;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    return null;
}

List<Student> all = teacherDao.getAll();
for (Student student : all) {
    System.out.println(student.getStuId() + "," +
            student.getStuName() + "," +
            "老师姓名" + student.getTeacher().getTname());
}
/*1,aaa,老师姓名王五
2,bb,老师姓名张三老师
3,cc,老师姓名王五
4,dd,老师姓名张三老师
5,ee,老师姓名张三老师
6,ff,老师姓名李四老师*/

一对一（妻子丈夫）

package com.bean;

//丈夫实体类
public class Husband {
    private int hid;
    private String husName;
    //双向一对一关系，在各自的类中创建对象
    private Wife wife;

    public int getHid() {
        return hid;
    }

    public void setHid(int hid) {
        this.hid = hid;
    }

    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;
    }
}

-------------------------------------------------------------------------
package com.bean;
//妻子实体类
public class Wife {
    private int wifeId;
    private String wifeName;
    private int hid;
    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 int getHid() {
        return hid;
    }

    public void setHid(int hid) {
        this.hid = hid;
    }

    public Husband getHusband() {
        return husband;
    }

    public void setHusband(Husband husband) {
        this.husband = husband;
    }
}
-------------------------------------------------------------------------
package com.dao;

import com.bean.Husband;
import com.bean.Wife;

public interface WideDao {
    //查询妻子信息(包含丈夫信息)
    public Wife getWife(int wid);

    //查询丈夫信息(包含妻子信息)
    public Husband getHus(int hid);
}
-------------------------------------------------------------------------
package com.dao.impl;

import com.bean.Husband;
import com.bean.Student;
import com.bean.Teacher;
import com.bean.Wife;
import com.dao.WideDao;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class WifeDaoImpl implements WideDao {
    @Override
    public Wife getWife(int wid) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //1.加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //3.通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
            //JDBC中的所有参数都由？符号，这被称为参数标记。
            String sql = "SELECT* FROM wife,husband WHERE wife.`hid`=husband.`husid` AND wifeid=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, wid);
            //4.通过预编译sql语句和传入的参数查询语句查到结果集
            resultSet = preparedStatement.executeQuery();
            Wife wife = new Wife();
            //5.取出结果集
            while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
                wife.setWifeId(resultSet.getInt("wifeid"));
                wife.setWifeName(resultSet.getString("wifename"));
                Husband husband = new Husband();
                husband.setHid(resultSet.getInt("husid"));
                husband.setHusName(resultSet.getString("husname"));
                //建立两表关系
                wife.setHusband(husband);
            }
            return wife;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public Husband getHus(int hid) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //1.加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //3.通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
            //JDBC中的所有参数都由？符号，这被称为参数标记。
            String sql = "SELECT* FROM wife,husband WHERE wife.`hid`=husband.`husid` AND husid=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, hid);
            //4.通过预编译sql语句和传入的参数查询语句查到结果集
            resultSet = preparedStatement.executeQuery();
            Husband husband = new Husband();
            //5.取出结果集
            while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
                husband.setHid(resultSet.getInt("husid"));
                husband.setHusName(resultSet.getString("husname"));
                Wife wife = new Wife();
                wife.setWifeId(resultSet.getInt("wifeid"));
                wife.setWifeName(resultSet.getString("wifename"));
                //建立两表关系
                husband.setWife(wife);
            }
            return husband;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

多对多(科目-学生)

package com.bean;

import java.util.List;

//多方，多个学生可以对应一个老师
//实体类要求:类名=表名，列名=属性名
public class Student {
    private int stuId;
    private String stuName;
    private int teacherId;
    //多对一，在多方创建一个存储一方数据的对象
    private Teacher teacher;

    //多对多关系，一个学生对应多个科目
    private List<Subject> subjectList;

    public List<Subject> getSubjectList() {
        return subjectList;
    }

    public void setSubjectList(List<Subject> subjectList) {
        this.subjectList = subjectList;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.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 int getTeacherId() {
        return teacherId;
    }

    public void setTeacherId(int teacherId) {
        this.teacherId = teacherId;
    }
}
————————————————————————————————————————————————————————————————————————————————————————
package com.bean;

import java.util.List;

public class Subject {
    private int subId;
    private String subName;
    //多对多关系，一个科目对应多个学生
    private List<Student> studentList;

    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<Student> getStudentList() {
        return studentList;
    }

    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
}
————————————————————————————————————————————————————————————————————————————————————————
package com.dao;

import com.bean.Student;
import com.bean.Subject;

public interface SubjectDao {
    //听过学生id找到信息，包含科目信息
    public Student getByStuId(int stuId);
    //听过科目id找到信息，包含学生信息
    public Subject getBySubId(int subId);
}
————————————————————————————————————————————————————————————————————————————————————————
package com.dao.impl;

import com.bean.Student;
import com.bean.Subject;
import com.bean.Teacher;
import com.dao.SubjectDao;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class SubjectDaoImpl implements SubjectDao {
    @Override
    public Student getByStuId(int stuId) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
            //JDBC中的所有参数都由？符号，这被称为参数标记。
            String sql = " SELECT * FROM student s,SUBJECT sub,middle m WHERE s.`stuid`=m.`stuid`AND sub.`subid`=m.`subid` AND s.`stuid`=? ";
            preparedStatement = connection.prepareStatement(sql);
            //传参给占位符
            preparedStatement.setInt(1, stuId);
            //通过预编译sql语句和传入的参数查询语句查到结果集
            resultSet = preparedStatement.executeQuery();
            //创建学生对象，因为要查询的是学生，学生信息是不变的，一个学生对应多个科目
            Student student = new Student();
            //创建集合存储科目对象，一个学生对应多个科目
            List<Subject> subjectList = new ArrayList<>();
            //取出结果集
            while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
                //取出各自的信息
                student.setStuId(resultSet.getInt("stuid"));
                student.setStuName(resultSet.getString("stuname"));
                Subject subject = new Subject();
                subject.setSubId(resultSet.getInt("subid"));
                subject.setSubName(resultSet.getString("subname"));
                //将查询到的一行学科对象添加到集合中
                subjectList.add(subject);
            }
            //将学科对象的集合传到学生对象里
            student.setSubjectList(subjectList);
            return student;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public Subject getBySubId(int subId) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //通过jdbc连接对象创建sql语句预编译执行环境对象,传入预编译的SQL语句
            //JDBC中的所有参数都由？符号，这被称为参数标记。
            String sql = " SELECT * FROM student s,SUBJECT sub,middle m WHERE s.`stuid`=m.`stuid`AND sub.`subid`=m.`subid` AND sub.`subid`=? ";
            preparedStatement = connection.prepareStatement(sql);
            //传参给占位符
            preparedStatement.setInt(1, subId);
            //通过预编译sql语句和传入的参数查询语句查到结果集
            resultSet = preparedStatement.executeQuery();
            //创建学科对象，因为要查询的是学科，学科信息是不变的，一个学科对应多个学生
            Subject subject = new Subject();
            //创建集合存储学生对象，一个学科对应多个学生
            List<Student> studentList = new ArrayList<>();
            //取出结果集
            while (resultSet.next()) {//一个while循环每走一次遍历的是一行数据
                //取出各自的信息
                subject.setSubId(resultSet.getInt("subid"));
                subject.setSubName(resultSet.getString("subname"));

                Student student = new Student();
                student.setStuId(resultSet.getInt("stuid"));
                student.setStuName(resultSet.getString("stuname"));
                //将查询到的一行学生对象添加到集合中
                studentList.add(student);
            }
            //将学生对象的集合传到学科对象里
            subject.setStudentList(studentList);
            return subject;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

事务

事务面试题:

JDBC中事务应用

try{
//开启手动提交事务，可以在一个事务中操作多次数据
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
String SQL1 = "INSERT INTO Employees values (106, 20, 'Rita', 'Tez')";
stmt.executeUpdate(SQL);
//提交一个格式错误的sql语句，会出现异常
String SQL2 = "INSERTED IN Employees VALUES (107, 22, 'Sita', 'Singh')";
stmt.executeUpdate(SQL);
// 如果整个事务没有错误则提交，有错误则回滚
conn.commit();
}catch(SQLException se){
// 有异常则回滚到最初的状态，都没提交
conn.rollback();
}

Savepoints

try{
conn.setAutoCommit(false);
Statement stmt = conn.createStatement();
String SQL1 = "INSERT INTO Employees VALUES (106, 20, 'Rita', 'Tez')";
stmt.executeUpdate(SQL);
//设置保存点，起名为Savepoint1
Savepoint savepoint1 = conn.setSavepoint("Savepoint1");
//提交一个格式错误的sql语句，会出现异常
String SQL2 = "INSERTED IN Employees VALUES (107, 22, 'Sita', 'Tez')";
stmt.executeUpdate(SQL);
conn.commit();
}catch(SQLException se){
//遇到异常时，回滚到Savepoint1，而Savepoint1保存点执行了SQL1
conn.rollback(savepoint1);
//将SQL1的执行提交，有效的保证有些数据让他部分提交
conn.commit();
}

事务案例-转账

package com.test;

import com.bean.Student;
import com.bean.Subject;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class Demo4 {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        //操作数据库
        //加载驱动
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            //通过驱动管理器获取jdbc连接对象
            String userName = "root";
            String passWord = "123456";
            String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";
            connection = DriverManager.getConnection(url, userName, passWord);
            //开启手动提交事务
            connection.setAutoCommit(false);
            //创建sql执行通道
            Statement statement = connection.createStatement();
            //转账
            int i1 = statement.executeUpdate("UPDATE money SET yue=yue-100 WHERE userid=1");
            //收账
            int i2 = statement.executeUpdate("UPDATE money SET yue=yue+100 WHERE userid=2");
            //打印一个异常，有异常直接回滚，回到数据最初状态
            System.out.println(2/0);
            //事务提交
            connection.commit();
            if (i2 > 0) {
                System.out.println("执行成功");
            } else {
                System.out.println("执行失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}