JDBC的学习

 1.数据库驱动：

这里的驱动的概念和平时听到的那种驱动的概念是一样的，比如平时购买的声卡，网卡直接 插到计算机上面是不能用的，必须要安装相应的驱动程序之后才能够使用声卡和网卡，同样道理， 我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道。

应用程序-----》Mysql驱动--------》Mysql数据库

2.JDBC的介绍：

SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范由Java语言编写（类和接口）， 称之为JDBC。这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接口，JDBC通过加载相应的驱动，来操作数据库。

JDBC的全称： Java Data Base Connectivity【Java数据库的连接】

JDBC的两个包：  Java.sql      JavaX.sql;

开发JDBC的应用除了以上的两个包外，还需要导入相应的JDBC数据库的实现（即数据库驱动）

驱动的下载：

推荐下载地址：   https://mvnrepository.com/artifact/mysql/mysql-connector-java 

3.实验环境的搭建：

新建一个Java项目，并导入数据库驱动；

创建一个数据库 JDBCstudy，并创建user表，插入数据。

#创建数据库
CREATE DATABASE /*!32312 IF NOT EXISTS*/`jdbcstudy` /*!40100 DEFAULT CHARACTER SET utf8 */;

#使用该数据库：
USE `jdbcstudy`;

#创建account表
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(40) DEFAULT NULL,
  `money` FLOAT DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;


INSERT  INTO `account`(`id`,`name`,`money`) VALUES (1,'A',500),(2,'B',1000),(3,'C',1000);

#创建user表
DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (
  `id` INT(11) NOT NULL,
  `name` VARCHAR(40) DEFAULT NULL,
  `password` VARCHAR(40) DEFAULT NULL,
  `email` VARCHAR(60) DEFAULT NULL,
  `birthday` DATE DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
#插入数据
INSERT  INTO `users`(`id`,`name`,`password`,`email`,`birthday`) VALUES (1,'zhansan','123456','zs@sina.com','1980-12-04'),(2,'lisi','123456','lisi@sina.com','1981-12-04'),(3,'wangwu','123456','wangwu@sina.com','1979-12-04'),(4,'qinjiang','123456','wangwu@sina.com','1979-12-04');

4.使用JDBC

编写Java程序从user表中读取数据，并打印在控制台上：

JDBC代码的规定步骤：

• 加载驱动（装载相应的JDBC驱动并进行初始化）
• 获取与数据库的连接（建立JDBC和数据库之间的Connection连接）
• 获取向数据库发送SQL语句的statement（创建statement 或 preparedstatement接口，来执行SQL语句）
• 用statement向数据库发送SQL，并返回结果集resultset（处理和显示结果）
• 关闭连接释放资源（释放资源）

   1.加载驱动（装载相应的JDBC驱动并进行初始化）

• 导入专门的jar包（不同的数据库需要的jar包不同)：

访问Mysql数据库需要第三方的类，这些类都被压缩在.jar文件mysql-connector-java-8.0.15-bin.jar中，推荐地址： https://mvnrepository.com/artifact/mysql/mysql-connector-java ，通常下载到该jar包后会放在lib目录中。

idea导包步骤：  File ----》ProjectStructure---》Dependenpies---》“ + ” Jars / Directories---》选择相应的Jar包。

注： 如果没有完成上述的导包操作，后面会报出：Class Not Found Exception。

• 初始化驱动：

通过初始化驱动类 (com.mysql.jdbc.Driver)来初始化驱动，该类就在jar包mysql-connector-java-8.0.15-bin.jar中，如果使用Oracle数据库那么初始化驱动类将不同。

注： Class.forName("com.mysql.jdbc.Driver")需要捕捉Class Not Found Exception。

try {
        Class.forName("com.mysql.jdbc.Driver");        
        } catch (ClassNotFoundException e) {                 
            e.printStackTrace();
        }

Class.forName("class")会将这个类加载到JVM中，在加载的时候就会执行静态的初始化块，完成相应的初始化相关工作。

   2.获取与数据库的连接（JDBC和数据库之间的connection连接）

这里需要提供：

• 数据库所在的IP：127.0.0.1（此处为本机，如果要连接其他电脑上的数据库，就要改变IP）
• 数据库端口号：3306（mysql 专用端口号）
• 数据库的名称：自己命名的
• 编码方式：utf-8
• 账户：root
• 密码：1234567890

    url = "jdbc:mysql://127.0.0.1:3306/dataname?characterEncoding=UTF-8","root","1234567890";

Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/databasename?characterEncoding=UTF-8", "root", "1234567890");

connection是与特定数据库连接会话的接口，使用的时候需要导包，而且必须在程序结束的时候将其关闭。getConnection()方法还需要抛出sqlException。

因为在进行数据库的增删改查时，都需要与数据库建立连接，所以可以将与数据库的连接包装成一个方法，用的时候调用即可。

     /**
     * 取得数据库的连接
     * @return 一个数据库的连接
     */
public static Connection getConnection(){
        Connection conn = null;
         try {
                 //初始化驱动类com.mysql.jdbc.Driver
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/exam?characterEncoding=UTF-8","root", "admin");
                //该类就在 mysql-connector-java-5.0.8-bin.jar中,如果忘记了第一个步骤的导包，就会抛出ClassNotFoundException
            } catch (ClassNotFoundException e) {                 
                e.printStackTrace();
            }catch (SQLException e) {                            
                e.printStackTrace();
            }
         return conn;
    }

  3.创建statement或者preparedstatement接口，来执行SQL语句：

• 使用statement接口：

statement接口创建完成后，可以执行SQL语句，对数据库的增删改查，其中查略显麻烦。在statement中使用字符串拼接的方式，该方式存在句法复杂容易出错的缺点，所以statement在实际使用中用的非常少。

字符串拼接方式的SQL语句是非常繁琐的，中间有很多的单引号，双引号极易出错。

Statement s = conn.createStatement();
//准备SQL语句
//注意：' 字符串要用单引号 '
String sql = "insert into t_course values (null,"+"'数学')";
//在Statement中使用字符串拼接的方式，存在诸多的问题
s.execute(sql);
System.out.println("执行插入语句成功！");

• 使用preparedstatement接口：

与statement一样，preparedStatement也是执行SQL的，不过需要根据SQL语句创建preparedstatement。除此之外，还能够通过设置参数来指定相应的值，而不是statement那样进行字符串的拼接。

给数据库中添加课程： （以下代码中最后关闭资源的两个方法 DbUtil.close(pstmt);  DbUtil.close(conn);  和上面的建立连接的方法是一样的，是在工具类中定义了的关闭方法，下文会给出其代码）

//添加课程：
public  void addCourse(String courseName){
       String sql = "insert into t_course(course_name)values(?)";
    //该语句为每个in参数保留一个问号（“？”）作为占位符
       Connection conn = null；         //和数据库取得连接
       PreparedStatement pstmt = null；  //创建Statement
       try{
               conn = DbUtil.getConnection();
               pstmt = (PreparedStatement) conn.preparedStatement(sql);
               pstmt.setString(1，courseName); //给占位符赋值
               pstmt.executeUpdate();       //执行
       }catch（SQLException e）{
             e.printStackTrace();
       }
         finally{
             DbUtil.close(pstmt);
             DbUtil.close(conn);   //关闭释放资源
      }       
      }

对数据库进行删除：

//删除课程：
public void delCourse(int courseId){
  String sql = "delete from t_course where course_id = ?";
  Connection  conn = null;
  PreparedStatement pstm = null;
  try{
         conn = DbUtil.getConnection();
         pstmt = (PreparedStatement)conn.preparedStatement(sql);
         pstmt.setInt(1,courseId);
         pstmt.executeUpdate();
  }catch(SQLException e){
          e.printStackTrace();
}finally{
       DbUtil.close(pstmt);
       DbUtil.close(conn);
}
}

对数据库中的课程进行修改：

/**
     * 修改课程
     * @param courseId
     * @param courseName
 */
public void modifyCourse(int courseID,String courseName){
      String sql="update t_course set course_name = ?where course_id=?";
      Connection conn = null;
      Preparedstatement pstm = null;
      try{
            conn = DbUtil.getConnection();
            pstm = (Preparedstatement) conn.preparedStatement(sql);
            pstm.setInt(1,courseId);
            pstm.setString(2,courseName);
         //利用preparedStatement的set方法给占位符赋值
          
            pstm.executeUpdate(); //执行sql
      }catch（Exception e）{
             e.printStackTrace();
      }finally(){
             DbUtil.close(pstm);
             DbUtil.close(conn);  //关闭资源
}
}
 

对于以上的增删改，代码结构都是一样的就是SQL语句存在差异，其中有几个地方需要注意一下：

1. PreparedStatement的SQL语句不是字符串拼接的方式，而是采用占位符的方式，“？”在这里就起到占位符的作用。占位符不仅避免了statement繁琐的SQL语句，也提升了性能。每次的SQL语句都是一样的，这样数据库就不会再次的进行编译，显著的提高了性能。

String sql = "update t_course set coueseName=? where courseId=?";

然后在用PreparedStatement的pstmt对象set方法给占位符进行一一的赋值。注意：此处的索引是从一开始的。

pstmt = (Preparedstatement) conn.preparedStatement(sql);
pstm.setInt(1,courseId);   //利用preparedStatement的set方法给参数进行赋值
pstm.setString("2",courseName);
pstm.executeUpdate();

增删改最后都要采用executeUpdate()方法进行SQL语句的提交。

       2.在添加过程中，如果添加的量比较大，可以批量添加，preparedStatement接口提供了相应批量操作的方法：

//采用preparedstatement进行批量添加
for(int i=1;i<100;i++){
   pstm.setInt(1,8000+i);
   pstm.setString(2,"赵_"+i);
      
   pstm.addBatch();  //批量更新
   if(i%10==0){
     pstm.executeUpdate();
}
}

对数据库的查询操作：

       /**
     * 查询课程
     * @return
     */
public List<Course> findCourseList(){
  String sql = "select * from t_course order by course_id";
  Connection conn = null;
  Preparedstatement pstm = null;
  ResultSet rs = null;
  //创建一个集合对象用来存放查询到的数据
  List<Course> courseList = new ArrayList<>();
  try{
   conn = DbUtil.getConnection();
   pstm =(Preparedstatement) conn.perparedStatement(sql);
   rs = (ResultSet) pstm.executeQuery();  //执行查询SQL
   while(rs.next()){
   int id=rs.getInt(course_id);
   String name=rs.getString(courseName);
  //每个记录对应一个对象
   Course course =new Course();
   course.setId(id);
   course.setName(name);
  //将对象放在集合中
   courseList.add(course);
}catch(SQLException  e){
   e.print
}
}
  


} 
    
        List<Course> courseList = new ArrayList<>();
        try {
            conn = DbUtil.getConnection();
            pstmt = (PreparedStatement) conn.prepareStatement(sql);
            rs = (ResultSet) pstmt.executeQuery();
            while (rs.next()){
                int courseId = rs.getInt("course_id");
                String courseName = rs.getString("course_name");
                //每个记录对应一个对象
                Course course = new Course();
                course.setCourseId(courseId);
                course.setCourseName(courseName);
                //将对象放到集合中
                courseList.add(course);
            }
        } catch (SQLException e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            DbUtil.close(pstmt);
            DbUtil.close(conn);        //必须关闭
        }
        return courseList;
    }

 sql的注入：

Ø 我们发现，按照上面的方法进行操作，无论密码是否正确，都提示我们登陆成功，这显然是不 合理的。问题出在哪里呢？
Ø 字符串拼接后的SQL语句是：
select * from users where username = 'kuangshen' or 1 = 1 and password = '"+password+"';
Ø 运行到or的时候已经是条件成立，所以无论后面是否正确，无需验证密码即可登陆成功。 Ø 上面的问题都是通过在SQL语句中添加特殊的字符，构成关键字，改变了程序运行轨迹，从而 对数据进行操作。
SQL注入问题：是指通过客户输入到后台的那些能到数据库得到数据的位置上，恶性的输入一些 对数据有害的操作。

//SQl注入
//
public class Demo2 {

    public static void main(String[] args) throws SQLException {
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入要查询的人名。。。");
        String name=scanner.nextLine();

        Connection connection=null;
        Statement statement=null;
        ResultSet resultSet=null;

        //1.获取数据库连接
        //2.创建statement对象
        //3.编写Sql语句
        //4.执行sql语句
        //5.释放资源
        connection=JDBCUtils.getConnection();

        statement = connection.createStatement();

        String sql ="select * from users where name ="+name;
        System.out.println(sql);

        resultSet = statement.executeQuery(sql);

        //打印查询出来的结果集
        while(resultSet.next()){
            System.out.println(resultSet.getString("name"));
            System.out.println(resultSet.getString("password"));
        }
        //5.
        JDBCUtils.closeAll(resultSet,statement,connection);
    }
}

执行结果：

请输入你要查询的用户名：'qinjiang' or 1=1
select * from users where name = 'qinjiang' or 1=1
zhansan
123456
lisi
123456
wangwu
123456
qinjiang
123456
laowang
123456

5.几个类的那些事：

DriverManager类：

Jdbc程序中的DriverManager用于加载驱动，并创建与数据库的链接，这个API的常用方法： I. DriverManager.registerDriver(new Driver())； II. DriverManager.getConnection(url, user, password)；
注意：在实际开发中并不推荐采用registerDriver方法注册驱动。原因有二： I. 查看Driver的源码可以看到，如果采用此种方式，会导致驱动程序注册两次，在内存中会有两个Driver对象。 II. 程序依赖mysql的api，脱离mysql的jar包，程序将无法编译，将来程序切换底层数据库将会非常麻烦。
推荐方式：Class.forName("com.mysql.jdbc.Driver"); 采用此种方式不会导致驱动对象在内存中重复出现，并且采用此种方式，程序仅仅只需要一个字符串， 不需要依赖具体的驱动，使程序的灵活性更高。

数据库的URL：

URL用于标识数据库的位置，通过URL地址告诉JDBC程序连接哪个数据库，URL的写法为：
依次为 : 协议 + 子协议 + 主机:端口 + 数据库 + 参数
常用数据库URL地址的写法：
Ø Oracle写法：jdbc:oracle:thin:@localhost:1521:sid Ø SqlServer写法：jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=sid Ø MySql写法：jdbc:mysql://localhost:3306/sid
如果连接的是本地的Mysql数据库，并且连接使用的端口是3306 那么的url地址可以简写为： jdbc:mysql:///数据库

Connection类讲解：

Jdbc程序中的Connection，它用于代表数据库的链接，Collection是数据库编程中最重要的一个 对象，客户端与数据库所有交互都是通过connection对象完成的，这个对象的常用方法：
Ø createStatement()：创建向数据库发送sql的statement对象。 Ø prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。 Ø prepareCall(sql)：创建执行存储过程的callableStatement对象。 Ø setAutoCommit(boolean autoCommit)：设置事务是否自动提交。 Ø commit() ：在链接上提交事务。 Ø rollback() ：在此链接上回滚事务。

Statement类讲解：

Jdbc程序中的Statement对象用于向数据库发送SQL语句， Statement对象常用方法：
Ø executeQuery(String sql) ：用于向数据发送查询语句。 Ø executeUpdate(String sql)：用于向数据库发送insert、update或delete语句 Ø execute(String sql)：用于向数据库发送任意sql语句 Ø addBatch(String sql) ：把多条sql语句放到一个批处理中。 Ø executeBatch()：向数据库发送一批sql语句执行。

ResultSet类讲解：

l Jdbc程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似 于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一 行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行 的数据。
l ResultSet既然用于封装执行结果的，所以该对象提供的都是用于获取数据的get方法： l 获取任意类型的数据 : Ø getObject(int index) Ø getObject(string columnName) l 获取指定类型的数据 : Ø getString(int index) Ø getString(String columnName)

ResultSet还提供了对结果集进行滚动的方法：
Ø next()：移动到下一行
Ø Previous()：移动到前一行
Ø absolute(int row)：移动到指定行
Ø beforeFirst()：移动resultSet的最前面。
Ø afterLast() ：移动到resultSet的最后面。

释放资源：

Jdbc程序运行完后，切记要释放程序在运行过程中，创建的那些与数据库进行交互的对象， 这些对象通常是ResultSet, Statement和Connection对象，特别是Connection对象，它是非常稀 有的资源，用完后必须马上释放，如果Connection不能及时、正确的关闭，极易导致系统宕机。
u Connection的使用原则是尽量晚创建，尽量早的释放。 u 为确保资源释放代码能运行，资源释放代码也一定要放在finally语句中。

preparedStatement对象的介绍：

PreperedStatement是Statement的子类 Ø 它的实例对象可以通过调用Connection.preparedStatement()方法获得，相对于Statement对象 而言：PreperedStatement可以避免SQL注入的问题。
Ø Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement可对 SQL进行预编译，从而提高数据库的执行效率。并且PreperedStatement对于sql中的参数， 允许使用占位符的形式进行替换，简化sql语句的编写。

6.Idea下进行JDBC的测试一些注意事项：（Mysql版本8.0.15）：

6.1数据库的表环境：

#创建数据库
CREATE DATABASE /*!32312 IF NOT EXISTS*/`jdbcstudy` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `jdbcstudy`;

/*Table structure for table `account` */

DROP TABLE IF EXISTS `account`;

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(40) DEFAULT NULL,
  `money` float DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

/*Data for the table `account` */

insert  into `account`(`id`,`name`,`money`) values (1,'A',500),(2,'B',1000),(3,'C',1000);

/*Table structure for table `users` */

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (
  `id` int(11) NOT NULL,
  `name` varchar(40) DEFAULT NULL,
  `password` varchar(40) DEFAULT NULL,
  `email` varchar(60) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

/*Data for the table `users` */

insert  into `users`(`id`,`name`,`password`,`email`,`birthday`) values (1,'zhansan','123456','zs@sina.com','1980-12-04'),(2,'lisi','123456','lisi@sina.com','1981-12-04'),(3,'wangwu','123456','wangwu@sina.com','1979-12-04'),(4,'qinjiang','123456','wangwu@sina.com','1979-12-04');

6.2注意下载与数据库所匹配的jar包：mysql-connector-java-8.0.15.jar 下载好后一般放在lib目录下边，然后右键lib目录，点击add as library；

6.3在src目录下编写一个db.properties文件；

driver = com.mysql.jdbc.Driver
username = root
password = 123456
url = jdbc:mysql://localhost:3306/jdbcstudy?useSSL=true

6.4Idea下的Java单元测试：注解 (@Test)，在注解上 " alt+enter "，会自动的导入JUnit4

6.5在第一的运行中报错：

Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

后将驱动器改为如下：

com.mysql.cj.jdbc.Driver

6.6再次运行报错如下：

java.sql.SQLException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or represents more than one time zone. You must configure either the server or JDBC driver (via the serverTimezone configuration property) to use a more specifc time zone value if you want to utilize time zone support.

后再db.properties文件的url后面添加：

?serverTimezone=UTC