这次的代码和之前学习到一般的代码主要就是将一些很常见的操作（建立连接、清除连接）不管做什么操作都需要用到它们，所以将它们单独放到另一个工具类里面去。

用到的术语：

1.事务：https://www.cnblogs.com/cstdio1/p/11626657.html

2.缓冲池（数据源）：https://www.cnblogs.com/chy18883701161/p/11374731.html

主逻辑代码：

  1. import java.sql.Connection;
  2. import java.sql.DriverManager;
  3. import java.sql.PreparedStatement;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  7.  
  8. import JDBCUtils.JDBCUtils;
  9. import JDBCUtils.JDCPDataSource;
  10.  
  11. public class MysqlDemo1 {
  12.  
  13.     public static void main(String[] args) {
  14.         selectAll();
  15.         //System.out.println(selectByUsernamePassword2("zs","123"));
  16.         //sql注入
  17.         //System.out.println(selectByUsernamePassword("zs","12347'or'1'='1"));
  18.         //PageSearch(1,2);
  19.         //insert("sdf","249.1");
  20.         //delete("sdf");
  21.         //update("zs","123","000");
  22.         transAccount("zs","ls",1000);
  23.     }
  24.     public static void selectAll(){
  25.     // TODO Auto-generated method stub
  26.     Connection con=null;
  27.     Statement stmt=null;
  28.     ResultSet rs=null;
  29.     try {
  30.         con = JDCPDataSource.getConnection();
  31.         stmt = con.createStatement();
  32.         String SqlRequest = "select * from student";
  33.         rs= stmt.executeQuery(SqlRequest);
  34.         while(rs.next()){
  35.         System.out.println(rs.getString(1)+" "+rs.getString(2)+" "+rs.getString(3)+" "+rs.getString(4));
  36.         //System.out.println(rs.getString("id")+" "+rs.getString("stu_name")+" "+rs.getString("stu_sex")+" "+rs.getString("stu_score"));
  37.         }
  38.  
  39.     } catch (Exception e) {
  40.         // TODO Auto-generated catch block
  41.         e.printStackTrace();
  42.     }finally{
  43.         JDCPDataSource.closeResource(rs, stmt, con);
  44.         //JDBCUtils.closeResource(rs, stmt, con);
  45.     }        
  46.  
  47. }
  48.  
  49.     public static boolean selectByUsernamePassword(String username,String password){//验证用户名和密码（字符串拼接的方式存在sql注入的问题）
  50.  
  51.         Connection con=null;
  52.         Statement stmt=null;
  53.         ResultSet rs=null;
  54.  
  55.         try {
  56.             con = JDBCUtils.getConnection();
  57.             stmt = con.createStatement();
  58.             String requestSql="select * from user where u_name='"+username+"'and u_password='"+password+"'";
  59.            System.out.print(requestSql);
  60.             rs = stmt.executeQuery(requestSql);
  61.              if(rs.next()){
  62.                  return true;
  63.              }else{
  64.                  return false;
  65.              }
  66.  
  67.         } catch (Exception e) {
  68.             // TODO Auto-generated catch block
  69.             e.printStackTrace();
  70.         }finally{
  71.  
  72.             JDBCUtils.closeResource(rs, stmt, con);
  73.         }
  74.  
  75.         return false;
  76.  
  77.     }
  78.  
  79.     public static boolean selectByUsernamePassword2(String username,String password){//验证用户名和密码(版本2可以防止sql注入)
  80.  
  81.         Connection con=null;
  82.         PreparedStatement pstmt=null;
  83.         ResultSet rs=null;
  84.  
  85.         try {
  86.             con = JDBCUtils.getConnection();
  87.             String RequestSql="select *from user where u_name=? and u_password=? ";
  88.              pstmt = con.prepareStatement(RequestSql);
  89.  
  90.             pstmt.setString(1, username);
  91.             pstmt.setString(2,password);
  92.             rs = pstmt.executeQuery();
  93.              if(rs.next()){
  94.                  return true;
  95.              }else{
  96.                  return false;
  97.              }
  98.  
  99.         } catch (Exception e) {
  100.             // TODO Auto-generated catch block
  101.             e.printStackTrace();
  102.         }finally{
  103.  
  104.             JDBCUtils.closeResource(rs, pstmt, con);
  105.         }
  106.  
  107.         return false;
  108.  
  109.     }
  110.     /*
  111.      *PageNum：查询第几页
  112.      *LineNum：总共显示多少行
  113.      */
  114.     public static void PageSearch(int PageNum,int LineNum){
  115.                //分页查询
  116.         Connection con=null;
  117.         PreparedStatement pstmt=null;
  118.         ResultSet rs=null;
  119.  
  120.         try {
  121.  
  122.             con = JDBCUtils.getConnection();
  123.                String RequestSql="select *from user limit ?,?";
  124.             pstmt = con.prepareStatement(RequestSql);
  125.  
  126.             pstmt.setInt(1,(PageNum-1)*LineNum);
  127.             pstmt.setInt(2,LineNum);
  128.             rs = pstmt.executeQuery();
  129.             while(rs.next()){
  130.                 System.out.println(rs.getString(1)+" "+rs.getString(2));
  131.             }
  132.  
  133.         } catch (Exception e) {
  134.             // TODO Auto-generated catch block
  135.             e.printStackTrace();
  136.         }finally{
  137.             JDBCUtils.closeResource(rs, pstmt, con);
  138.  
  139.         }
  140.  
  141.     }
  142.  
  143.     public static void insert(String UserName,String Password){
  144.                //新注册的信息进行插入操作
  145.  
  146.         Connection con=null;
  147.         PreparedStatement pstmt=null;
  148.         ResultSet rs=null;
  149.         int mark=0;
  150.         try {
  151.             con = JDBCUtils.getConnection();
  152.             String RequestSql="insert into user(u_name,u_password) values(?,?)";
  153.             pstmt = con.prepareStatement(RequestSql);
  154.  
  155.             pstmt.setString(1, UserName);
  156.             pstmt.setString(2,Password);
  157.             mark = pstmt.executeUpdate();
  158.             if(mark>0){
  159.                 System.out.println("插入成功");
  160.             }else{
  161.                 System.out.println("插入失败");
  162.             }
  163.  
  164.         } catch (Exception e) {
  165.             // TODO Auto-generated catch block
  166.             e.printStackTrace();
  167.         }finally{
  168.  
  169.             JDBCUtils.closeResource(rs, pstmt, con);
  170.         }
  171.  
  172.     }
  173.  
  174.     public static void delete(String UserName){
  175.  
  176.         Connection con=null;
  177.         PreparedStatement pstmt=null;
  178.         ResultSet rs=null;
  179.         int mark=0;
  180.         try {
  181.             con = JDBCUtils.getConnection();
  182.             String RequestSql="delete from user where u_name = ?";
  183.             pstmt = con.prepareStatement(RequestSql);
  184.  
  185.             pstmt.setString(1, UserName);
  186.             mark = pstmt.executeUpdate();
  187.             if(mark>0){
  188.                 System.out.println("删除成功");
  189.             }else{
  190.                 System.out.println("删除失败");
  191.             }
  192.  
  193.         } catch (Exception e) {
  194.             // TODO Auto-generated catch block
  195.             e.printStackTrace();
  196.         }finally{
  197.  
  198.             JDBCUtils.closeResource(rs, pstmt, con);
  199.         }
  200.     }
  201.  
  202.     public static void update(String UserName,String OldPassword,String NewPassword){
  203.         //修改用户密码
  204.  
  205.         Connection con=null;
  206.         PreparedStatement pstmt=null;
  207.         ResultSet rs=null;
  208.         int mark=0;
  209.         try {
  210.             con = JDBCUtils.getConnection();
  211.             String RequestSql="update user set u_password = ? where u_name = ? and u_password = ? ";
  212.             pstmt = con.prepareStatement(RequestSql);
  213.  
  214.             pstmt.setString(1, NewPassword);
  215.             pstmt.setString(2, UserName);
  216.             pstmt.setString(3, OldPassword);
  217.             mark = pstmt.executeUpdate();
  218.             if(mark>0){
  219.                 System.out.println("修改成功");
  220.             }else{
  221.                 System.out.println("修改失败");
  222.             }
  223.  
  224.         } catch (Exception e) {
  225.             // TODO Auto-generated catch block
  226.             e.printStackTrace();
  227.         }finally{
  228.  
  229.             JDBCUtils.closeResource(rs, pstmt, con);
  230.         }
  231.     }
  232.  
  233.     public static void transAccount(String UserName1,String UserName2,int money){
  234.     //转账操作(利用事务)
  235.         Connection con=null;
  236.         PreparedStatement pstmt1=null;
  237.         PreparedStatement pstmt2=null;
  238.         ResultSet rs=null;
  239.         try {
  240.             con = JDBCUtils.getConnection();
  241.             con.setAutoCommit(false);//开启事务
  242.                 String sql="update user set u_balance = u_balance - ? where u_name = ? ";
  243.             pstmt1 = con.prepareStatement(sql);
  244.  
  245.             pstmt1.setInt(1, money);
  246.             pstmt1.setString(2, UserName1);
  247.             pstmt1.executeUpdate();
  248.  
  249. //            String s=null;模拟异常情况(断电、数据库崩溃)
  250. //            s.charAt(2);
  251.  
  252.             sql = "update user set u_balance = u_balance + ? where u_name = ? ";
  253.             pstmt2 = con.prepareStatement(sql);
  254.             pstmt2.setInt(1, money);
  255.             pstmt2.setString(2, UserName2);
  256.             pstmt2.executeUpdate();            
  257.  
  258.             con.commit();//事务完成
  259.  
  260.         } catch (Exception e) {
  261.             // TODO Auto-generated catch block
  262.             e.printStackTrace();
  263.         }finally{
  264.  
  265.             JDBCUtils.closeResource(rs, pstmt1, con);
  266.             JDBCUtils.closeResource(null, pstmt2, null);
  267.         }
  268.  
  269.     }
  270. }

分页查询的公式：

JDBC工具类：

  1. package JDBCUtils;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  9. import java.util.ArrayList;
  10.  
  11. public class JDBCUtils {
  12.     private static final String url="jdbc:mysql://localhost:3306/dy?useUnicode=true&characterEncoding=utf-8&useSSL=false";
  13.     private static final String user="root";
  14.     private static final String password="root";
  15.     private static ArrayList <Connection> Clist = new ArrayList<Connection>();//保存连接
  16.  
  17.     static{
  18.         for(int i=0;i<10;i++){
  19.         Connection con = createConnection();//创建连接
  20.         Clist.add(con);//添加到容器中
  21.         }
  22.     }
  23.  
  24.     public static Connection getConnection(){
  25.         if(Clist.isEmpty()==false){
  26.             Connection con = Clist.get(0);//得到容器中的连接
  27.             Clist.remove(con);
  28.             return con;
  29.         }else{
  30.             return createConnection();//创建连接
  31.         }
  32.     }
  33.     public static Connection createConnection(){
  34.         try {
  35.             Class.forName("com.mysql.jdbc.Driver");
  36.             return DriverManager.getConnection(url,user,password);//建立和mysql数据库的连接
  37.         } catch (Exception e) {
  38.             // TODO Auto-generated catch block
  39.             e.printStackTrace();
  40.         }//选择注册驱动
  41.  
  42.         return null;
  43.     }
  44.  
  45.     public static void closeResource(ResultSet rs,Statement stmt,Connection con){
  46.         try {
  47.             if(rs!=null)
  48.             rs.close();
  49.         } catch (SQLException e) {
  50.             // TODO Auto-generated catch block
  51.             e.printStackTrace();
  52.         }
  53.  
  54.         try {
  55.             if(stmt!=null)
  56.             stmt.close();
  57.         } catch (SQLException e) {
  58.             // TODO Auto-generated catch block
  59.             e.printStackTrace();
  60.         }
  61.  
  62. //        try {
  63. //            if(con!=null)
  64. //            con.close();
  65. //        } catch (SQLException e) {
  66. //            // TODO Auto-generated catch block
  67. //            e.printStackTrace();
  68. //        }
  69.         Clist.add(con);
  70.     }
  71.  
  72.     public static void closeResource(ResultSet rs,PreparedStatement pstmt,Connection con){
  73.         try {
  74.             if(rs!=null)
  75.             rs.close();
  76.         } catch (SQLException e) {
  77.             // TODO Auto-generated catch block
  78.             e.printStackTrace();
  79.         }
  80.  
  81.         try {
  82.             if(pstmt!=null)
  83.             pstmt.close();
  84.         } catch (SQLException e) {
  85.             // TODO Auto-generated catch block
  86.             e.printStackTrace();
  87.         }
  88.  
  89. //        try {
  90. //            if(con!=null)
  91. //            con.close();
  92. //        } catch (SQLException e) {
  93. //            // TODO Auto-generated catch block
  94. //            e.printStackTrace();
  95. //        }
  96.         Clist.add(con);//这里的连接不需要关闭，因为在不断建立连接和取消连接的过程会消耗很多时间，所以引入了缓冲池（数据源）的概念
  97.     }
  98. }

我们上面的工具类的数据源是我们自己利用容器去模拟它去实现的，实际上已经有一些现成的我们可以直接使用的，例如：dbcp、c3p0。

DBCP数据源（工具类版本2）：

  1. package JDBCUtils;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  8.  
  9. import org.apache.commons.dbcp2.BasicDataSource;
  10.  
  11. public class JDCPDataSource {
  12.     private static final String url="jdbc:mysql://localhost:3306/dy?useUnicode=true&characterEncoding=utf-8&useSSL=false";
  13.     private static final String user="root";
  14.     private static final String password="root";
  15.     private static BasicDataSource ds;
  16.  
  17.     static{
  18.         ds = new BasicDataSource();
  19.         ds.setDriverClassName("com.mysql.jdbc.Driver");
  20.         ds.setUrl(url);
  21.         ds.setUsername(user);
  22.         ds.setPassword(password);
  23.  
  24.         ds.setInitialSize(5);//设置初始连接
  25.         ds.setMaxTotal(20);//设置最大连接数
  26.         ds.setMinIdle(3);//设置最小空闲连接（一旦小于最小空闲连接它会自动创建连接以达到最小空闲连接）
  27.     }
  28.     public static Connection getConnection(){
  29.  
  30.         try {
  31.             return ds.getConnection();
  32.         } catch (SQLException e) {
  33.             // TODO Auto-generated catch block
  34.             e.printStackTrace();
  35.         }
  36.  
  37.         return null;
  38.     }
  39.     public static void closeResource(ResultSet rs,Statement stmt,Connection con){
  40.         try {
  41.             if(rs!=null)
  42.             rs.close();
  43.         } catch (SQLException e) {
  44.             // TODO Auto-generated catch block
  45.             e.printStackTrace();
  46.         }
  47.  
  48.         try {
  49.             if(stmt!=null)
  50.             stmt.close();
  51.         } catch (SQLException e) {
  52.             // TODO Auto-generated catch block
  53.             e.printStackTrace();
  54.         }
  55.  
  56.         try {
  57.             if(con!=null)
  58.             con.close();
  59.         } catch (SQLException e) {
  60.             // TODO Auto-generated catch block
  61.             e.printStackTrace();
  62.         }
  63.  
  64.     }
  65.  
  66.     public static void closeResource(ResultSet rs,PreparedStatement pstmt,Connection con){
  67.         try {
  68.             if(rs!=null)
  69.             rs.close();
  70.         } catch (SQLException e) {
  71.             // TODO Auto-generated catch block
  72.             e.printStackTrace();
  73.         }
  74.  
  75.         try {
  76.             if(pstmt!=null)
  77.             pstmt.close();
  78.         } catch (SQLException e) {
  79.             // TODO Auto-generated catch block
  80.             e.printStackTrace();
  81.         }
  82.  
  83.         try {
  84.             if(con!=null)
  85.             con.close();
  86.         } catch (SQLException e) {
  87.             // TODO Auto-generated catch block
  88.             e.printStackTrace();
  89.         }
  90.  
  91.     }
  92. }　　

注意：使用dbcp时需要下载：第一个是核心包、后面两个都是核心包所依赖的东西，不下程序会显示找不到Class

c3p0使用方法类似，不做过多演示　

　　

jdbc学习over的更多相关文章

  1. JDBC学习笔记(2)——Statement和ResultSet

    Statement执行更新操作 Statement:Statement 是 Java 执行数据库操作的一个重要方法,用于在已经建立数据库连接的基础上,向数据库发送要执行的SQL语句.Statement ...

  2. JDBC学习笔记(1)——JDBC概述

    JDBC JDBC API是一个Java API,可以访问任何类型表列数据,特别是存储在关系数据库中的数据.JDBC代表Java数据库连接. JDBC库中所包含的API任务通常与数据库使用: 连接到数 ...

  3. 【转】JDBC学习笔记(2)——Statement和ResultSet

    转自:http://www.cnblogs.com/ysw-go/ Statement执行更新操作 Statement:Statement 是 Java 执行数据库操作的一个重要方法,用于在已经建立数 ...

  4. 【转】JDBC学习笔记(1)——JDBC概述

    转自:http://www.cnblogs.com/ysw-go/ JDBC JDBC API是一个Java API,可以访问任何类型表列数据,特别是存储在关系数据库中的数据.JDBC代表Java数据 ...

  5. jdbc学习总结

    jdbc学习总结:   一.简介: jdbc,直译为java连接数据库.实际为java为很好的操作数据库而提供的一套接口,接口的实现(即驱动)由各个数据库厂商提供.   二.知识要点: 连接5要素,3 ...

  6. JDBC 学习笔记（十一）—— JDBC 的事务支持

    1. 事务 在关系型数据库中,有一个很重要的概念,叫做事务(Transaction).它具有 ACID 四个特性: A(Atomicity):原子性,一个事务是一个不可分割的工作单位,事务中包括的诸操 ...

  7. JDBC 学习笔记（十）—— 使用 JDBC 搭建一个简易的 ORM 框架

    1. 数据映射 当我们获取到 ResultSet 之后,显然这个不是我们想要的数据结构. 数据库中的每一个表,在 Java 代码中,一定会有一个类与之对应,例如: package com.gerrar ...

  8. JDBC 学习笔记（六）—— PreparedStatement

    1. 引入 PreparedStatement PreparedStatement 通过 Connection.createPreparedStatement(String sql) 方法创建,主要用 ...

  9. JDBC学习笔记二

    JDBC学习笔记二 4.execute()方法执行SQL语句 execute几乎可以执行任何SQL语句,当execute执行过SQL语句之后会返回一个布尔类型的值,代表是否返回了ResultSet对象 ...

  10. JDBC学习笔记一

    JDBC学习笔记一 JDBC全称 Java Database Connectivity,即数据库连接,它是一种可以执行SQL语句的Java API. ODBC全称 Open Database Conn ...

随机推荐

  1. 安慰奶牛Cheering up the Cow

    传送门 一次a就很开心 可以当作kruskal模板题(orz --------------------------------------------------------------------- ...

  2. 原生java与js结合

    链接:https://www.jb51.cc/html5/15606.html

  3. [踩坑记录] windows10 应用商店打不开 代码: 0x80131500

    在某博客看到的方法,供参考,可以尝试一下,我的也是这么解决的1.打开“运行”输入 inetcpl.cpl (“WINDOWS”+“R”键,输入 inetcpl.cpl亦可)2.点开高级往下拉,勾上&q ...

  4. 第一阶段集训（这篇先写写tarjan以及圆方树）

    第一阶段的集训结束了w,不得不说oi太长时间不整是会退步的. 怎么说好呢,集训这几天过的很充实,知识收货很多,题调的也不少,自己的目标更明确了吧,不过这几天集训也是可以看出蒟蒻就是蒟蒻,还是太菜了.. ...

  5. 架设传奇时打开DBC数据库出错或读取DBC失败解决方法

    架设传奇时打开DBC数据库出错或读取DBC失败解决方法 DBC右键-属性-高级-管理员身份运行 即可

  6. HTML-移动端-rem px vw vh 的转换

    vw/vh rem px 三者的转换(快速入门移动端页面编写) 1:三种单位的转换 2:如何适配移动端的不同设备 前提知识: 手机端的长宽是实际设计过程中的两倍 比如手机端是 750 * 1200 那 ...

  7. P1598

    无语的是,我以为题目条件的‘在任何一行末尾不要打印不需要的多余空格’意思是每一行都只能到最后一个 '*' 出现就换行,然后用了 '\b',结果怎么都不过,于是看了题解,发现别人都没管这个 = =!!, ...

  8. 安卓开发：在Mac系统中搭建安卓开发环境

    第一步:检查下自己的电脑上有没有安装JDK(Java Development Kit)(2019年7月安装的最新版是JDK 1.8.0_181版本),通过在终端中输入"java -versi ...

  9. java月利率计算（等额本息贷款）

    等额本息 每月还款计算公式: 每月本息金额 = (本金×月利率×(1+月利率)^还款月数)÷ ((1+月利率)^还款月数-1)) 反转求出 月利率 月利率 如果根据上面公式反转是算不出来的. 下面给出 ...

  10. spark sql 访问mysql数据库

    pom.xml <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-ja ...