数据库—mysql—sql
JDBC：java中用于控制（操作）sql语句的驱动—-都是接口

Java中面向接口编程，给定相关的接口，我们调用接口来说实现相应的功能
比如：jdbc就是给定了java访问数据库的接口—是由各个数据库的厂商提供的驱动来处理的

数据库的驱动：实际上就是一个jar包

这个jar包（数据库驱动）是由各个数据库的厂商自己提供的，用于给java访问自己的数据库
比如：
java要去访问mysql数据库，就使用mysql厂商提供的数据库驱动
java要去访问oracle数据库，就使用oracle厂商提供的数据库驱动

综上所诉：jdbc的作用就是java利用数据库厂商提供的驱动来访问数据库

JDBC的使用

步骤：

  1. 注册驱动
  2. 获取连接
  3. 获取语句执行平台
  4. 获取sql语句
  5. 处理结果
  6. 释放资源

mysql-connector-java-5.1.37-bin.jar

  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.Statement;
  8. import org.junit.Test;
  10. public class Demo {
  12.     @Test
  13.     public void test() throws Exception{
  14.         /*
  15.          * 1、注册驱动--用到的是反射机制
  16.          * 将mysql的数据库驱动导入--大小写敏感，一个字都不能错
  17.          * jdbc的所有api都是在java.sql下的
  18.          * */
  19.         Class.forName("com.mysql.jdbc.Driver");
  21.         //获取连接
  22.         Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb","root","123456");
  23.         System.out.println(conn);//com.mysql.jdbc.JDBC4Connection@4ac68d3e
  25.         //3、获取语言执行平台(执行sql语句的对象)
  26.         Statement stmt= conn.createStatement();
  28.         //4、获取执行sql语句的对象  返回一个结果集
  29.         ResultSet res=  stmt.executeQuery("select*from category");
  31.         //处理查询结果
  32.         while(res.next()){//是否还有下一个数据记录
  33.             //获取每一行的数据
  34.             Integer cid=res.getInt("cid");
  35.             String cname=res.getString("cname");
  36.             System.out.println("cid："+cid+"\t"+"cname："+cname);
  37.         }
  39.         //释放资源--关闭连接
  40.         //关闭结果集
  41.         res.close();
  42.         //关闭sql语句平台
  43.         stmt.close();
  44.         //关闭连接
  45.         conn.close();
  46.     }
  47. }

获取驱动

image.png

getConnection语法格式

  1. getConnection(url,user,password)
  2. 第一参数是连接
  3. 第二参数是数据库用户密码
  4. 第三参数是数据库摩玛
  6. url语法格式
  7. jdbc：mysql://ip地址:数据库端口号//数据库名称

资源释放

  1. 资源释放问题
  2. 数据库的操作原则上是要一次连接一次关闭
  3. 将jdbc中用到的接口先声明好
  5. 因为释放资源是必须的，所以可以放在finally块中

测试

  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.Statement;
  8. import org.junit.Test;
  10. public class Demo3 {
  12.     @Test
  13.     public void test(){
  14.         /*
  15.          * 1、注册驱动--用到的是反射机制
  16.          * 将mysql的数据库驱动导入--大小写敏感，一个字都不能错
  17.          * jdbc的所有api都是在java.sql下的
  18.          * */
  20.         //接口声明
  21.         Connection conn=null;
  22.         Statement st=null;
  23.         ResultSet rs=null;
  25.         try{
  26.             Class.forName("com.mysql.jdbc.Driver");
  27.             conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb","root","123456");
  28.             st=conn.createStatement();
  29.             rs=st.executeQuery("select*from category");
  31.             while(rs.next()){
  32.                 Integer cid=rs.getInt(1);
  33.                 String cname=rs.getString(2);
  34.                 System.out.println("cid："+cid+"\t"+"cname："+cname);
  35.             }
  36.         }catch(Exception e){
  37.             e.printStackTrace();
  38.         }finally{
  39.             //判断是否为空
  40.             try{
  41.                 if(rs!=null)rs.close();
  42.                 if(st!=null)st.close();
  43.                 if(conn!=null)conn.close();
  44.             }catch(Exception e){
  45.                 e.printStackTrace();
  46.             }
  47.         }
  50.     }
  51. }

封装成工具类

  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  9. import org.junit.Test;
  11. public class JDBCUtils {
  12.     /*
  13.      * jdbc的工具类
  14.      * 用户封装jdbc操作中的重复操作
  15.      * 
  16.      * 当前这个工具类一旦封装就可以重复，为了将就效率，一般使用静态
  17.      * */
  19.     private static String driver="com.mysql.jdbc.Driver";
  20.     private static String url="jdbc:mysql://localhost:3306/mydb";
  21.     private static String user="root";
  22.     private static String password="123456";
  26.     static{
  27.         try {
  28.             Class.forName(driver);
  29.         } catch (ClassNotFoundException e) {
  30.             // TODO Auto-generated catch block
  31.             e.printStackTrace();
  32.         }
  33.     }
  35.     //下面封装两个操作
  36.     //1、封装获取连接的方法
  37.     public static Connection getConnection(){
  38.         //直接获取连接
  39.         Connection conn;
  40.         try {
  41.             conn = DriverManager.getConnection(url,user,password);
  42.             return conn;
  43.         } catch (SQLException e) {
  44.             // TODO Auto-generated catch block
  45.             e.printStackTrace();
  46.         }
  47.         return null;
  48.     }
  49.     //封装一个释放资源的方法
  50.     public static void closeResource(Connection conn,Statement st,ResultSet rs){
  51.         try{
  52.             if(st!=null) st.close();
  53.             if(rs!=null) rs.close();
  54.             if(conn!=null) conn.close();
  55.         }catch(Exception e){
  56.             e.printStackTrace();
  57.         }
  58.     }
  61.     @Test
  62.     public void test(){
  63.         Connection conn=getConnection();
  64.         System.out.println("conn==>"+conn);
  65.     }
  67. }

CRUD

  1. C--create--增加
  2. R--Retrieve--读取--查询
  3. U-update--更新--改
  4. D--Delete--删除
  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.Statement;
  7. import org.junit.Test;
  9. public class Demo04 {
  10.     //jdbc模板
  11.     public void test01(){
  12.         Connection conn=null;
  13.         Statement st=null;
  14.         ResultSet rs=null;
  16.         try{
  17.             //逻辑操作
  18.         }catch(Exception e){
  19.             e.printStackTrace();
  20.         }finally{
  21.             //关闭资源
  22.             JDBCUtils.closeResource(conn, st, rs);
  23.         }
  24.     }
  26.     //添加
  27. //    @Test
  28.     public void test02(){
  29.         Connection conn=null;
  30.         Statement st=null;
  31.         ResultSet rs=null;
  33.         try{
  34.             //逻辑操作
  35.             //获取连接
  36.             conn=JDBCUtils.getConnection();
  37.             //获取执行sql对象
  38.             st=conn.createStatement();
  39.             //
  40.             int i=st.executeUpdate("insert into category(cname) values('测试数据1')");
  41.             System.out.println("插入数据结果==》"+i);
  45.         }catch(Exception e){
  46.             e.printStackTrace();
  47.         }finally{
  48.             //关闭资源
  49.             JDBCUtils.closeResource(conn, st, rs);
  50.         }
  51.     }
  52.     //修改
  53. //    @Test
  54.     public void test03(){
  55.         Connection conn=null;
  56.         Statement st=null;
  57.         ResultSet rs=null;
  59.         try{
  60.             //逻辑操作
  61.             //获取连接
  62.             conn=JDBCUtils.getConnection();
  63.             //获取执行sql对象
  64.             st=conn.createStatement();
  65.             //
  66.             int i=st.executeUpdate("update category set cname='测试数据2' where cid=4");
  67.             System.out.println("插入数据结果==》"+i);
  71.         }catch(Exception e){
  72.             e.printStackTrace();
  73.         }finally{
  74.             //关闭资源
  75.             JDBCUtils.closeResource(conn, st, rs);
  76.         }
  77.     }
  78.     //删除
  79. //    @Test
  80.     public void test04(){
  81.         Connection conn=null;
  82.         Statement st=null;
  83.         ResultSet rs=null;
  85.         try{
  86.             //逻辑操作
  87.             //获取连接
  88.             conn=JDBCUtils.getConnection();
  89.             //获取执行sql对象
  90.             st=conn.createStatement();
  91.             //
  92.             int i=st.executeUpdate("delete from category where cid=4");
  93.             System.out.println("插入数据结果==》"+i);
  97.         }catch(Exception e){
  98.             e.printStackTrace();
  99.         }finally{
  100.             //关闭资源
  101.             JDBCUtils.closeResource(conn, st, rs);
  102.         }
  103.     }
  104.     //查询
  105.     @Test
  106.     public void test05(){
  107.         Connection conn=null;
  108.         Statement st=null;
  109.         ResultSet rs=null;
  111.         try{
  112.             //逻辑操作
  113.             //获取连接
  114.             conn=JDBCUtils.getConnection();
  115.             //获取执行sql对象
  116.             st=conn.createStatement();
  117.             //
  118.             rs=st.executeQuery("select * from category where cid=3");
  119.             while(rs.next()){
  120.                 //在mysql数据库中数值类型 会隐式转换为字符串
  121.                 Integer cid=rs.getInt(1);
  122.                 String cname=rs.getString(2);
  123.                 System.out.println("cid："+cid+"\t"+"cname："+cname);
  124.             }
  127.         }catch(Exception e){
  128.             e.printStackTrace();
  129.         }finally{
  130.             //关闭资源
  131.             JDBCUtils.closeResource(conn, st, rs);
  132.         }
  133.     }
  134. }

关于Statement

  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.Statement;
  7. import org.junit.Test;
  9. public class StatementDemo {
  11.     //演示注入攻击
  12.     @Test
  13.     public void test(){
  14.         //模拟登陆
  15.         String username="jack";
  16.         String password="123";
  18.         //
  19.         Connection conn=null;
  20.         Statement st=null;
  21.         ResultSet rs=null;
  23.         try{
  24.             conn=JDBCUtils.getConnection();
  25.             String sql="select*from user where username='"+username+"' and password='"+password+"'";
  26.             System.err.println(sql);
  27.             st=conn.createStatement();
  28.             rs=st.executeQuery(sql);
  29.             if(rs.next()){
  30.                 System.out.println("登陆成功");
  31.             }else{
  32.                 System.out.println("登陆失败");
  33.             }
  35.         }catch(Exception e){
  36.             e.printStackTrace();
  37.         }finally{
  38.             JDBCUtils.closeResource(conn, st, rs);
  39.         }
  42.     }
  44. }

PreparedStatement（防止注入）代替Statement

  1. package cn.ant.Day18;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.Statement;
  8. import org.junit.Test;
  10. public class PreparedStatementDemo {
  12.     /*PreparedStatement
  13.      * 是预处理机制，预处理sql语句
  14.      * 处理的条件使用？来进行站位
  15.      * 能够完美解决sql注入问题
  16.      * 
  17.      * */
  19.     @Test
  20.     public void test(){
  21.         //模拟登陆
  22.                 String username="jack";
  23.                 String password="1234";
  25.                 //
  26.                 Connection conn=null;
  27.                 PreparedStatement ps=null;
  28.                 ResultSet rs=null;
  30.                 try{
  31.                     conn=JDBCUtils.getConnection();
  32.                     String sql="select*from user where username=? and password=?";
  33.                     System.err.println(sql);
  34.                     ps=conn.prepareStatement(sql);
  35.                     ps.setString(1, username);
  36.                     ps.setString(2, password);
  37.                     rs=ps.executeQuery();
  38.                     if(rs.next()){
  39.                         System.out.println("登陆成功");
  40.                     }else{
  41.                         System.out.println("登陆失败");
  42.                     }
  44.                 }catch(Exception e){
  45.                     e.printStackTrace();
  46.                 }finally{
  47.                     JDBCUtils.closeResource(conn, ps, rs);
  48.                 }
  49.     }
  51. }