JDBC连接数据库

最新推荐文章于 2022-08-23 22:24:02 发布

小杰曦

最新推荐文章于 2022-08-23 22:24:02 发布

阅读量1.6k

点赞数 1

分类专栏：总结文章标签： mysql 数据库 jdbc

本文链接：https://blog.csdn.net/qq_41256473/article/details/120118881

版权

总结专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JDBC

1、简介

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

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

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

JDBC库包括通常与数据库使用相关的下面提到的每个任务的API。

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

2、 JDBC体系结构

请添加图片描述

3、 JDBC核心组件

DriverManager：此类管理数据库驱动程序列表。使用通信子协议将来自java应用程序的连接请求与适当的数据库驱动程序匹配。
Driver:此接口处理与数据库服务器的通信，我们很少会直接与Driver对象进行交互。而是使用 DriverManager对象来管理这种类型的对象。
Connection：该界面具有用于联系数据库的所有方法。连接对象表示通信上下文，即，与数据库的所有通信仅通过连接对象。
Statement：使用从此接口创建的对象将SQL语句提交到数据库。除了执行存储过程之外，一些派生接口还接受参数。
ResultSet：在使用Statement对象执行SQL查询后，这些对象保存从数据库检索的数据。它作为一个迭代器，允许我们移动其数据。
SQLException：此类处理数据库应用程序中发生的任何错误

4、 CRUD语法介绍

Create, Read, Update, and Delete 通常称为CRUD操作。与数据库DML、DQL一致

5、使用步骤

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

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

5.1、 JDBC连接步骤

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

导入JDBC包：将Java语言的import语句添加到Java代码中导入所需的类。 -

注册JDBC驱动程序：此步骤将使JVM将所需的驱动程序实现加载到内存中，以便它可以满足您的JDBC 请求。

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

try {
    //MySQL8 com.mysql.cj.jdbc.Driver
    //MySQL com.mysql.jdbc.Driver
    //ORACLE oracle.jdbc.driver.OracleDriver
    //DB2 COM.ibm.db2.jdbc.net.DB2Driver
	Class.forName("com.mysql.cj.jdbc.Driver");
}catch(ClassNotFoundException ex) {
    System.out.println("Error: unable to load driver class!");
    System.exit(1);
}

——第二种方法是使用静态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）
创建连接对象：最后，调用DriverManager对象的getConnection（）方法来建立实际的数据库连接。
```
String URL = "jdbc:mysql://localhost:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=utf-8";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);
```
关闭数据库连接

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

5.2 Statement

创建语句对象在使用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语句。使用增删改语句时使用

ResultSet executeQuery（String SQL）：返回一个ResultSet对象。使用select语句时使用

关闭Statement对象

直接调用close（）方法。

5.3 SQL注入

就是通过把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;

5.4 PreparedStatement(预状态通道)

该PreparedStatement的接口扩展了Statement接口，它为您提供了一个通用的Statement对象有两个优点附加功能。此语句使您可以动态地提供参数。

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

JDBC中的所有参数都由？符号，这被称为参数标记。

在执行SQL语句之前，必须为每个参数提供值。所述的 setXXX() 方法将值绑定到所述参数，其中XXX代表要绑定到输入参数的值的Java数据类型。如果忘记提供值，将收到一个SQLException。

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

关闭PreparedStatement对象

直接调用close（）方法。

对比statement和PreparedStatement区别

(1)statement属于状态通道，PreparedStatement属于预状态通道

(2)预状态通道会先编译sql语句,再去执行，比statement执行效率高

(3)预状态通道支持占位符?,给占位符赋值的时候，位置从1开始

(4)预状态通道可以防止sql注入，原因:预状态通道在处理值的时候以字符串的方式处理

5.5 ResultSet

SELECT语句是从数据库中选择行并在结果集中查看行的标准方法。该java.sql.ResultSet中的接口表示结果集数据库查询。如果没有指定任何ResultSet类型，您将自动获得一个TYPE_FORWARD_ONLY。

6、Java操作两表关系

四种：双向一对一、一对多、多对一、多对多

多表关系处理数据

数据库通过外键建立两表关系
实体类通过属性的方式建立两表关系

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

6.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`)
);
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`)
);
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 getTeacherId(int tid);
}

(4)定义实现类

public class TeacherDaoImpl implements TeacherDao {
    @Override
    public Teacher getTeacherId(int tid) {
        Connection connection = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        Student student = null;
        try {
            //1、加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、连接数据库
            String url = "jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user = "root";
            String password = "root123";
            connection = DriverManager.getConnection(url, user, password);
            //3、创建sql状态预留通道
            String sql = "select * from student1 s,teacher t where s.teacherid=t.tid and t.tid=?";
            pps = connection.prepareStatement(sql);
            //给占位符赋值
            pps.setInt(1, tid);
            resultSet = pps.executeQuery();
            Teacher teacher = new Teacher();
            ArrayList<Student> students = new ArrayList<>();
            while (resultSet.next()) {
                teacher.setTid(resultSet.getInt("tid"));
                teacher.setTname(resultSet.getString("tname"));
                int stuid = resultSet.getInt("stuid");
                String stuname = resultSet.getString("stuname");
                Student student1 = new Student(stuid, stuname);
                students.add(student1);
            }
            teacher.setList(students);
            return teacher;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //释放资源
                if (resultSet != null) {
                    resultSet.close();
                }
                if (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

（4）定义测试类

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

6.2 多对一（学生有多个老师）

（1)实体类

public class Student {
    private int stuid;
    private String stuname;
    private Teacher teacher;

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public Student(int stuid, String stuname) {
        this.stuid = stuid;
        this.stuname = stuname;
    }

    public Student() {
    }

    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 class Teacher {
    private int tid;
    private String tname;

    public ArrayList<Student> getList() {
        return list;
    }

    public void setList(ArrayList<Student> list) {
        this.list = list;
    }

    private ArrayList<Student> list=new ArrayList<>();

    public Teacher() {
    }

    public Teacher(int tid, String tname) {
        this.tid = tid;
        this.tname = 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;
    }
}

（2）接口

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

（3）实现类

 	@Override
    public List<Student> getAll() {
        Connection connection = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        Student student = null;
        try {
            //1、加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、连接数据库
            String url = "jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user = "root";
            String password = "root123";
            connection = DriverManager.getConnection(url, user, password);
            //3、创建sql预状态通道
            String sql = "select * from student1 s,teacher t where s.teacherid=t.tid";
            pps = connection.prepareStatement(sql);
            resultSet = pps.executeQuery(sql);
            List<Student> students = new ArrayList<>();
            while (resultSet.next()) {
                int stuid = resultSet.getInt("stuid");
                String stuname = resultSet.getString("stuname");
                Student student1 = new Student(stuid, stuname);
                Teacher teacher = new Teacher();
                teacher.setTid(resultSet.getInt("tid"));
                teacher.setTname(resultSet.getString("tname"));
                student1.setTeacher(teacher);
                students.add(student1);
            }
            return students;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

（4）测试类:

		TeacherDao dao = new TeacherDaoImpl();
        List<Student> studentList = dao.getAll();
        for (Student student : studentList) {
            System.out.println("学生姓名："+student.getStuname()+"，老师姓名："+student.getTeacher().getTname());
        }

6.3 一对一（妻子丈夫）

数据表:

CREATE TABLE `husband` (
`husid` int(11) NOT NULL AUTO_INCREMENT,
`husname` varchar(255) DEFAULT NULL,
PRIMARY KEY (`husid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `husband` VALUES ('1', '邓超');
DROP TABLE IF EXISTS `wife`;
CREATE TABLE `wife` (
`wifeid` int(11) NOT NULL AUTO_INCREMENT,
`wifename` varchar(255) DEFAULT NULL,
`hid` int(11) DEFAULT NULL,
PRIMARY KEY (`wifeid`),
UNIQUE KEY `uq_wife_hid` (`hid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `wife` VALUES ('1', '孙俪', '1');

（1）实体类

public class Husband {
    private int husid;
    private String husname;
    private Wife wife;

    public Wife getWife() {
        return wife;
    }

    public void setWife(Wife wife) {
        this.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 Husband() {
    }

    public Husband(int husid, String husname) {
        this.husid = husid;
        this.husname = husname;
    }
}

public class Wife {
    private int wifeid;

    private Husband husband;

    public Husband getHusband() {
        return husband;
    }

    public void setHusband(Husband husband) {
        this.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 Wife() {
    }

    public Wife(int wifeid, String wifename) {
        this.wifeid = wifeid;
        this.wifename = wifename;
    }

    private String wifename;

}

（2）接口

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

（3）实现类

public class WifeDaoImpl implements WifeDao {
    @Override
    public Wife getWife(int wifeid) {
        Connection connection=null;
        PreparedStatement pps=null;
        ResultSet resultSet =null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user="root";
            String password="root123";
            connection = DriverManager.getConnection(url,user,password);
            String sql="select * from wife w,husband h where w.hid=h.husid and w.wifeid=?";
            pps = connection.prepareStatement(sql);
            pps.setInt(1,wifeid);
            resultSet = pps.executeQuery();
            Wife wife = new Wife();
            while (resultSet.next()){
                //取出信息
                wife.setWifeid(resultSet.getInt("wifeid"));
                wife.setWifename(resultSet.getString("wifename"));
                Husband husband = new Husband();
                husband.setHusid(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 (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public Husband getHus(int husid) {
        Connection connection=null;
        PreparedStatement pps=null;
        ResultSet resultSet =null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url="jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user="root";
            String password="root123";
            connection = DriverManager.getConnection(url,user,password);
            String sql="select * from wife w,husband h where w.hid=h.husid and h.husid=?";
            pps = connection.prepareStatement(sql);
            pps.setInt(1,husid);
            resultSet = pps.executeQuery();

            Husband husband = new Husband();
            while (resultSet.next()){
                //取出信息
                husband.setHusid(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 (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

（4）测试类

public class Demo {
    public static void main(String[] args) {
        WifeDao 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());
    }
}

6.4 多对多（科目-学生）

数据表

CREATE TABLE `middle` (
`middleid` int(11) NOT NULL AUTO_INCREMENT,
`stuid` int(11) DEFAULT NULL,
`subid` int(11) DEFAULT NULL,
PRIMARY KEY (`middleid`)
) ;
-- ----------------------------
-- Records of middle
-- ----------------------------
INSERT INTO `middle` VALUES ('1', '1', '1');
INSERT INTO `middle` VALUES ('2', '1', '2');
INSERT INTO `middle` VALUES ('3', '1', '3');
INSERT INTO `middle` VALUES ('4', '1', '5');
INSERT INTO `middle` VALUES ('5', '2', '2');
INSERT INTO `middle` VALUES ('6', '3', '2');
INSERT INTO `middle` VALUES ('7', '4', '2');
INSERT INTO `middle` VALUES ('8', '5', '2');
INSERT INTO `middle` VALUES ('9', '6', '2');
-- ----------------------------
-- Table structure for `student`
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`stuid` int(11) NOT NULL AUTO_INCREMENT,
`stuname` varchar(255) DEFAULT NULL,
`teacherid` int(11) DEFAULT NULL,
PRIMARY KEY (`stuid`)
);
-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('1', '张三', '3');
INSERT INTO `student` VALUES ('2', '李四', '1');
INSERT INTO `student` VALUES ('3', '王五', '3');
INSERT INTO `student` VALUES ('4', '赵六', '1');
INSERT INTO `student` VALUES ('5', '花花', '1');
INSERT INTO `student` VALUES ('6', '潇潇', '2');
-- ----------------------------
-- Table structure for `subject`
-- ----------------------------
DROP TABLE IF EXISTS `subject`;
CREATE TABLE `subject` (
`subid` int(11) NOT NULL AUTO_INCREMENT,
`subname` varchar(255) DEFAULT NULL,
PRIMARY KEY (`subid`)
);
-- ----------------------------
-- Records of subject
-- ----------------------------
INSERT INTO `subject` VALUES ('1', 'java');
INSERT INTO `subject` VALUES ('2', 'ui');
INSERT INTO `subject` VALUES ('3', 'h5');
INSERT INTO `subject` VALUES ('4', 'c');
INSERT INTO `subject` VALUES ('5', 'c++');
INSERT INTO `subject` VALUES ('6', 'c#');

(1)实体类

public class Subject {
    private int subid;
    private String subname;
    private Student student;
    private List<Student> studentList;

    public int getSubid() {
        return subid;
    }

    public List<Student> getStudentList() {
        return studentList;
    }

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



    public void setSubid(int subid) {
        this.subid = subid;
    }

    public String getSubname() {
        return subname;
    }

    public void setSubname(String subname) {
        this.subname = subname;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

public class Student {
    private int stuid;
    private String stuname;
    private Subject subject;
    private List<Subject> subjectList;

    public int getTeacherid() {
        return teacherid;
    }

    public void setTeacherid(int teacherid) {
        this.teacherid = teacherid;
    }

    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 Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.subject = subject;
    }

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

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

（2）接口

public interface SubjectDao {
	//查询学生信息（包括科目信息）
    public Student findByStuId(int stuid);
    //查询科目信息（包括学生信息）
    public Subject findBySubId(int subid);
 
}

(3)实现类

public class SubjectDaoImpl implements SubjectDao {
    @Override
    public Student findByStuId(int stuid) {
        Connection connection = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user = "root";
            String password = "root123";
            connection = DriverManager.getConnection(url, user, password);
            String sql = "select * from middle m,student s,subject sub where m.subid=sub.subid and m.stuid=s.stuid and s.stuid=?";
            pps = connection.prepareStatement(sql);
            pps.setInt(1, stuid);
            resultSet = pps.executeQuery();
            Student student = new Student();
            ArrayList<Subject> subjects = new ArrayList<>();
            while (resultSet.next()) {
                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);
            }
            // 建立学生与科目关系
            student.setSubjectList(subjects);
            return student;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public Subject findBySubId(int subid) {

        Connection connection = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user = "root";
            String password = "root123";
            connection = DriverManager.getConnection(url, user, password);
            String sql = "select * from middle m,student s,subject sub where m.subid=sub.subid and m.stuid=s.stuid and sub.subid=?";
            pps = connection.prepareStatement(sql);
            pps.setInt(1, subid);
            resultSet = pps.executeQuery();
            Subject subject = new Subject();
            ArrayList<Student> students = new ArrayList<>();
            while (resultSet.next()) {
                subject.setSubid(resultSet.getInt("subid"));
                subject.setSubname(resultSet.getString("subname"));

                Student student = new Student();
                student.setStuid(resultSet.getInt("stuid"));
                student.setStuname(resultSet.getString("stuname"));
                students.add(student);
            }
            // 建立学生与科目关系
            subject.setStudentList(students);
            return subject;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

（4）测试类

public class Demo1 {
    public static void main(String[] args) {
        SubjectDao dao = new SubjectDaoImpl();
        Student stu = dao.findByStuId(1);
        System.out.println(stu.getStuname());
        List<Subject> subjects=stu.getSubjectList();
        for (Subject subject : subjects) {
            System.out.println("\t 课程名:"+subject.getSubname());
        }
        Subject sub = dao.findBySubId(2);
        System.out.println("报了"+sub.getSubname()+"的同学有：");
        List<Student> students=sub.getStudentList();
        for (Student student : students) {
            System.out.println("\t"+student.getStuname());
        }
    }
}

7、数据库事务

7.1 事务概述

数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元，可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处理。

事务开始于

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

事务结束于

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

10.2 事务的四大特点（ACID）

actomicity(原子性)

表示一个事务内的所有操作是一个整体，要么全部成功，要么全部失败

consistency(一致性)

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

isolation(隔离性)

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

durability(持久性)

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

10.3 JDBC中事务应用

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

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

要启用手动事务支持，而不是JDBC驱动程序默认使用的自动提交模式，请使用Connection对象的 setAutoCommit（） 方法。

如果将boolean false传递给setAutoCommit（），则关闭自动提交。我们可以传递一个布尔值true来重新打开它。

10.4 事务的提交和回滚

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

connection.commit();

否则，要使用连接名为conn的数据库回滚更新

connection.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();
}

8、JDBC批处理

8.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();

8.2 PreparedStatement批处理

使用占位符创建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();

9、反射处理结果集

接口

//查询所有的学生信息
public List<Student> findAll(Class cla);

实现类

public List<Student> findAll(Class cla) {
        Connection connection = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8";
            String user = "root";
            String password = "root123";
            connection = DriverManager.getConnection(url, user, password);
            String sql = "select * from student";
            pps = connection.prepareStatement(sql);
            resultSet = pps.executeQuery();
            Student student = new Student();
            ArrayList students = new ArrayList();
            // 获得数据库中所有的列有哪些
            ResultSetMetaData metaData = resultSet.getMetaData();
            //得到列数
            int count=metaData.getColumnCount();
            // 根据列数获得一个定长的数组
            String[] columns = new String[count];
            // 将每列的名字辅助给数组
            for (int i=0;i<count;i++){
                //列的位置从1开始
                //System.out.println(metaData.getColumnName(i+1));
                columns[i]=metaData.getColumnName(i+1);
            }
            //获取实体类中所有的方法
            Method[] declaredMethods = cla.getDeclaredMethods();
            while (resultSet.next()) {
                try {
                    //获取无参构造函数对象
                    Object o = cla.getDeclaredConstructor().newInstance();
                    for (String column : columns) {
                        //将数据库中获得的列名与set拼接
                        String name="set"+column;
                        for (Method declaredMethod : declaredMethods) {
                            // 将拼接的字符串与实体类中的方法比较
                            if(name.equalsIgnoreCase(declaredMethod.getName())){
                                // 调用invoke方法
                                declaredMethod.invoke(o,resultSet.getObject(column));
                                break;
                            }
                        }
                    }
                    students.add(o);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return students;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (pps != null) {
                    pps.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

10、工具类的定义

public class DBUtil {
    /**
     * //1、定义需要获得的工具类
     */

    private Connection connection = null;
    private PreparedStatement pps = null;
    private ResultSet resultSet = null;
    private static String url;
    private static String user;
    private static String driverClassName;
    private static String password;
    /**
     * 表示受影响的行数
     */
    private int k = 0;
    //2、加载驱动
    static {

        try {
            /**
             * 工具类读取属性方法一
             */
            /*InputStream inputStream = DBUtil.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(inputStream);
            url = properties.getProperty("url");
            user = properties.getProperty("username");
            password = properties.getProperty("password");
            diverClassName = properties.getProperty("driverClassName");*/
            /**
             * 工具类读取属性方法二
             */
            ResourceBundle rb=ResourceBundle.getBundle("db");
            url = rb.getString("url");
            user = rb.getString("username");
            password = rb.getString("password");
            driverClassName = rb.getString("driverClassName");
            Class.forName(driverClassName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * //3、连接数据库
     *
     * @return
     */
    protected Connection getConnection() {
        try {
            //普通连接方式
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    /**
     * //4、创建通道
     *
     * @param sql
     * @return
     */
    protected PreparedStatement getPps(String sql) {
        try {
            getConnection();
            pps = connection.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return pps;
    }

    /**
     * //5、给占位符赋值
     *
     * @param list 保存的是给占位符赋值的值
     */
    protected void setParam(List list) {
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                try {
                    pps.setObject(i + 1, list.get(i));
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * //6、增删改方法调用
     *
     * @param sql
     * @return
     */
    protected int update(String sql, List list) {
        try {
            getPps(sql);
            setParam(list);
            k = pps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return k;
    }

    /**
     * 7、查询方法调用
     *
     * @param sql
     * @param list
     */
    protected ResultSet query(String sql, List list) {
        try {
            getPps(sql);
            setParam(list);
            resultSet = pps.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return resultSet;
    }

    /**
     * 8、释放资源
     */
    protected void close() {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (pps != null) {
                pps.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    Properties ppt = new Properties();
}

10.1 properties文件保存数据库信息

特点： key-value存储方式

url=jdbc:mysql://localhost:3306/mydb?characterEncoding=UTF-8
username=root
password=root123
driverClassName=com.mysql.jdbc.Driver

读取属性两种方式

//1
InputStream inputStream = DBUtil.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(inputStream);
            url = properties.getProperty("url");
            user = properties.getProperty("username");
            password = properties.getProperty("password");
            diverClassName = properties.getProperty("driverClassName");
//2
static{
ResourceBundle rb=ResourceBundle.getBundle("db");
            url = rb.getString("url");
            user = rb.getString("username");
            password = rb.getString("password");
            driverClassName = rb.getString("driverClassName");
            Class.forName(driverClassName);
}

使用ResourceBundle访问本地资源

在设计时，我们往往需要访问一些适合本地修改的配置信息，如果作为静态变量，那么每次修改都需要重新编译一个class，.config保存此类信息并不适合，这时我们需要ResourceBundle。

通过ResourceBundle，我们需要访问位于/WEB-INF/classes目录下的一个后缀名为properties的文本类型文件，从里面读取我们需要的值。

11、连接池

11.1 自定义连接池

数据连接池原理

连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等，也可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

自定义连接池一般不使用

11.2 DBCP连接池

DBCP是一个依赖Jakarta commons-pool对象池机制的数据库连接池.DBCP可以直接的在应用程序中使用，Tomcat的数据源使用的就是DBCP。

步骤：

导入相应jar包

mysql-jdbc.jar
commons-dbcp.jar
commons-pool.jar

硬编码使用DBCP（在代码中添加配置）

public void testHard() throws SQLException{
	// 硬编码 使用DBCP连接池子
	BasicDataSource source = new BasicDataSource();
	//设置连接的信息
    source.setDriverClassName("com.mysql.jdbc.Driver");
    source.setUrl("jdbc:mysql://localhost:3306/day2");
    source.setUsername("root");
    source.setPassword("111");
    Connection connection = source.getConnection();
    String sql = "select * from student";
    Statement createStatement = connection.createStatement();
    ResultSet executeQuery = createStatement.executeQuery(sql);
    while (executeQuery.next()) {
    	System.out.println(executeQuery.getString(2));
    }
	connection.close(); //回收
}

软编码使用DBCP（添加配置文件）

文件名称:db.properties

文件位置: src下

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/day2
username=root
password=root123
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最大空闲连接 -->
maxIdle=20
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=6000

工具类实现

static {
            ResourceBundle rb= ResourceBundle.getBundle("db");
            url = rb.getString("url");
            user = rb.getString("username");
            password = rb.getString("password");
            driverClassName = rb.getString("driverClassName");
        try {
            // DBCP连接池
            dataSource.setDriverClassName(driverClassName);
            dataSource.setUrl(url);
            dataSource.setUsername(user);
            dataSource.setPassword(password);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
protected Connection getConnection() {
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

11.3 C3P0连接池

c3p0与dbcp区别

dbcp没有自动回收空闲连接的功能 c3p0有自动回收空闲连接功能
dbcp需要手动设置配置文件 c3p0不需要手动设置

实现步骤：

导入jar包

c3p0-0.9.1.2.jar

mysql-connector-java-5.0.8.jar

.添加配置文件

文件位置: src

文件命名:c3p0-config.xml/c3p0-config.properties

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
  <default-config>
  	<property name="driverClass">com.mysql.jdbc.Driver</property>
  	<property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb?characterEncoding=UTF-8</property>
  	<property name="user">root</property>
  	<property name="password">root123</property>
  	<!-- 等待连接的超时时间，默认为0，代表无限等待，单位是毫秒 -->
    <property name="checkoutTimeout">30000</property>
    <!-- 检查空闲连接  默认为0 代表不检查 -->
    <property name="idleConnectionTestPeriod">30</property>
    <!-- 初始化连接 -->
    <property name="initialPoolSize">10</property>
    <!-- 最大空闲时间，超过这个时间的连接将被丢弃，默认为0，代表永远不关闭 -->
    <property name="maxIdleTime">50</property>
    <!-- 最大连接数 -->
    <property name="maxPoolSize">100</property>
    <!-- 最小连接数 -->
    <property name="minPoolSize">10</property>
    <!-- preparedStatement的缓存大小 -->
    <property name="maxStatements">200</property>
    <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 --> 
	<property name="AcquireIncrement">5</property>
  </default-config>
</c3p0-config>

工具类实现

static ComboPooledDataSource db=new ComboPooledDataSource("abc");
protected Connection getConnection() {
        try {
            //c3p0连接方式
            connection = db.getConnection();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

11.4 Druid（德鲁伊）连接池

特点：

一. 亚秒级查询 druid提供了快速的聚合能力以及亚秒级的OLAP查询能力，多租户的设计，是面向用户分析应用的理想方式。

二.实时数据注入 druid支持流数据的注入，并提供了数据的事件驱动，保证在实时和离线环境下事件的实效性和统一性

三.可扩展的PB级存储 druid集群可以很方便的扩容到PB的数据量，每秒百万级别的数据注入。即便在加大数据规模的情况下，也能保证时其效性

四.多环境部署 druid既可以运行在商业的硬件上，也可以运行在云上。它可以从多种数据系统中注入数据，包括 hadoop，spark，kafka，storm和samza等

五.丰富的社区 druid拥有丰富的社区，供大家学习

步骤：

导入jar包

druid-1.0.0.jar

工具类实现

private static DruidDataSource ds;
    //2、加载驱动
    static {
        ds=new DruidDataSource();
        Properties properties = new Properties();
        try {
            // 加载配置文件
            ResourceBundle rb=ResourceBundle.getBundle("db");
            driverClassName= rb.getString("driverClassName");
            user = rb.getString("username");
            password = rb.getString("password");
            url = rb.getString("url");
            ds.setDriverClassName(driverClassName);
            ds.setUsername(user);
            ds.setPassword(password);
            ds.setUrl(url);

        } catch (Exception e) {
            e.printStackTrace();
        }
	}
protected Connection getConnection() {
        try {
            connection=ds.getConnection();
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

注:在Druid连接池的配置中，driverClassName可配可不配，如果不配置会根据url自动识别dbType(数据库类型)，然后选择相应的driverClassName。

小杰曦

关注

1
点赞
踩
2

收藏

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

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

扫一扫