请选择 进入手机版 | 继续访问电脑版

我爱科技论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

查看: 201|回复: 0

[技术分享] 【java工具类】SQLHelper超强工具类封装

[复制链接]

696

主题

743

帖子

7686

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
7686

最佳新人活跃会员热心会员推广达人宣传达人灌水之王突出贡献优秀版主荣誉管理论坛元老

发表于 2017-12-22 18:00:28 | 显示全部楼层 |阅读模式
经过小编的又一番努力,实现了java直接访问数据库的操作,并进行了SQLHelper超强工具类的封装操作,可以实现对数据库的增删改查等操作,此外部分还考虑到了事务、并发查询的影响!
SQLHelper超强工具类封装代码如下:
  1. package com.news.dao;

  2. import java.io.*;
  3. import java.sql.*;
  4. import java.util.*;



  5. /**
  6. * @
  7. **/
  8. public class SqlHelper {

  9.         // 定义需要的变量
  10.         private static Connection ct = null;
  11.         private static Statement sm = null;
  12.         private static ResultSet rs = null;
  13.         private static PreparedStatement ps = null; // 解决了SQL注入漏洞

  14.         // ;连接数据库的参数
  15.         private static String url = "";
  16.         private static String username = "";
  17.         private static String driver = "";
  18.         private static String password = "";

  19.         // 读取配置文件需要的参数
  20.         private static Properties pp = null;
  21.         private static FileInputStream fis = null;

  22.         // 定义JAVAweb项目中读取配置文件需要的InputStream
  23.         private static InputStream is = null;

  24.         // 调用存储过程(不考虑存储过程)
  25.         private static CallableStatement cs = null;

  26.         public static void main(String[] args) {
  27.                 ct = getConn();
  28.                 String sql = "select * from students";
  29.                 try {
  30.                         ps = ct.prepareStatement(sql);
  31.                         rs = ps.executeQuery();

  32.                         while (rs.next()) {
  33.                                 System.out.println(rs.getInt(1) + " " + rs.getString(2) + " "
  34.                                                 + rs.getFloat(3) + " " + rs.getFloat(4) + " "
  35.                                                 + rs.getFloat(5));
  36.                         }
  37.                 } catch (SQLException e) {
  38.                         // TODO Auto-generated catch block
  39.                         e.printStackTrace();
  40.                 }// 预编译SQL对象

  41.         }

  42.         // 把数据库查询封装成一个函数
  43.         public static ArrayList<Object[]> executeQueryFour(String sql, String[] paras) {
  44.                 ArrayList<Object[]> arrlist = new ArrayList<Object[]>();
  45.                 for (int i = 0; i < paras.length; i++) {
  46.                         System.out.println("paras[" + i + "] =" + paras[i]); // okay!!!
  47.                 }
  48.                 System.out.println("本次要执行的SQL语句为:" + sql);
  49.                 try {
  50.                         // 加载驱动, 得到连接
  51.                         ct = getConn();
  52.                         ps = ct.prepareStatement(sql);

  53.                         System.out.println("ps = ct.prepareStatement(sql) ok");

  54.                         // 给SQL语句的问号赋值
  55.                         for (int i = 0; i < paras.length; i++) {
  56.                                 System.out
  57.                                                 .println("------------本次赋值问号的SQL执行语句----------------------------------"
  58.                                                                 + sql
  59.                                                                 + "paras[i]"
  60.                                                                 + paras[i]
  61.                                                                 + "  paras.length" + paras.length);
  62.                                 // paras[0]=100 paras[1]=123456
  63.                                 // System.out.println("ps.setString(i) error");
  64.                                 ps.setString(i + 1, paras[i]); // okay
  65.                                 // System.out.println("本次要执行的参数"+paras[i]+"sql"+sql+"paras.length= "+paras.length);
  66.                         }

  67.                         // ps.setString(1, paras[0]); bug1 .error
  68.                         // ps.setString(2, paras[1]); bug2 .error
  69.                         // java.lang.ArrayIndexOutOfBoundsException: 1

  70.                         System.out.println("给问号赋值过后需要执行的SQL语句" + sql);
  71.                         rs = ps.executeQuery();

  72.                         // 求出查询结果的列数目
  73.                         ResultSetMetaData rsmd = rs.getMetaData();
  74.                         int columnNum = rsmd.getColumnCount();

  75.                         // 循环的从rs中取出数据, 并且放入到arraylist中去
  76.                         while (rs.next()) {
  77.                                 // 新建一个对象数组(对象数组的大小即列的大小)-----数组中存放了返回的所有结果
  78.                                 Object[] object = new Object[columnNum];
  79.                                 for (int i = 0; i < object.length; i++) {
  80.                                         // 把查询到的所有结果放入到object中去【每一列的结果放入到一个对象中的一个元素】
  81.                                         object[i] = rs.getObject(i + 1); // okay
  82.                                 }

  83.                                 // 把object放入到arrlist中去
  84.                                 arrlist.add(object);
  85.                         }

  86.                 } catch (Exception e) {
  87.                         // TODO: handle exception
  88.                         e.printStackTrace();
  89.                         System.out.println("本次查询操作失败!!!");
  90.                 } finally {
  91.                         System.out.println("本次最终执行啥情况查询语句为: " + sql);
  92.                 }
  93.                 return arrlist;
  94.         }

  95.         public static CallableStatement getCs() {
  96.                 return cs;
  97.         }

  98.         public static Connection getCt() {
  99.                 return ct;
  100.         }

  101.         public static ResultSet getRs() {
  102.                 return rs;
  103.         }

  104.         public static PreparedStatement getPs() {
  105.                 return ps;
  106.         }

  107.         // 加载驱动, 只需要加载一次即可
  108.         static {
  109.                 try {
  110.                         // 从dbinfo.propertities中读取配置信息
  111.                         pp = new Properties();
  112.                         // fis = new FileInputStream("dbinfo.properties");

  113.                         // 注意:当我们使用Javaweb的时候, 读取文件要使用类加载器
  114.                         is = SqlHelper.class.getClassLoader().getResourceAsStream(
  115.                                         "dbinfo.properties");
  116.                         pp.load(is);
  117.                         url = pp.getProperty("url");
  118.                         username = pp.getProperty("username");
  119.                         driver = pp.getProperty("driver");
  120.                         password = pp.getProperty("password");
  121.                         System.out.println(url + " " + username + " " + driver + " "
  122.                                         + password);
  123.                         Class.forName(driver);
  124.                 } catch (Exception e) {
  125.                         // TODO Auto-generated catch block
  126.                         e.printStackTrace();
  127.                 } finally {
  128.                         try {
  129.                                 if (fis != null) {
  130.                                         fis.close();
  131.                                 }
  132.                         } catch (Exception e2) {
  133.                                 // TODO: handle exception
  134.                                 e2.printStackTrace();
  135.                         }
  136.                         fis = null;
  137.                 }
  138.         }

  139.         // 得到连接
  140.         public static Connection getConn() {
  141.                 try {
  142.                         ct = DriverManager.getConnection(url, username, password);
  143.                 } catch (SQLException e) {
  144.                         // TODO Auto-generated catch block
  145.                         e.printStackTrace();
  146.                 }
  147.                 return ct;
  148.         }

  149.         // 分页问题
  150.         public static ResultSet executeQueryTwo(String sql, String paras[]) {
  151.                 return null;
  152.         }

  153.         // 调用存储过程, 有返回值
  154.         // sql call procedure()
  155.         public static CallableStatement callProlTwo(String sql, String[] inParas,
  156.                         Integer[] outParas) {
  157.                 try {
  158.                         ct = getConn();
  159.                         cs = ct.prepareCall(sql);
  160.                         if (inParas != null) {
  161.                                 for (int i = 0; i < inParas.length; i++) {
  162.                                         cs.setObject(i + 1, inParas[i]);
  163.                                 }
  164.                         }
  165.                         // 给outParas参数赋值
  166.                         if (outParas != null) {
  167.                                 for (int i = 0; i < outParas.length; i++) {
  168.                                         cs.registerOutParameter(inParas.length + 1 + i, outParas[i]);
  169.                                 }
  170.                         }

  171.                         // 执行存储过程
  172.                         cs.execute();

  173.                 } catch (Exception e) {
  174.                         // TODO: handle exception
  175.                         e.printStackTrace();
  176.                         throw new RuntimeException(e.getMessage());
  177.                 } finally {
  178.                         // 资源无需关闭
  179.                 }
  180.                 return cs;
  181.         }

  182.         // 调用存储过程
  183.         // sql {call 过程(?, ?, ?)}

  184.         /*
  185.          * create or replace procedure pro1(v_in_empno, number, v_in_ename varchar2)
  186.          * is --定义变量 begin --执行语句 insert into emp (empno, ename) values
  187.          * (v_in_empno,v_in_ename); end;
  188.          */
  189.         public static void callProl(String sql, String[] paras) {
  190.                 try {
  191.                         ct = getConn();
  192.                         cs = ct.prepareCall(sql);

  193.                         // 给问号赋值
  194.                         if (paras != null) {
  195.                                 for (int i = 0; i < paras.length; i++) {
  196.                                         cs.setObject(i + 1, paras[i]);
  197.                                 }
  198.                         }
  199.                         cs.execute();
  200.                         System.out.println("存储过程调用成功!!!");
  201.                 } catch (Exception e) {
  202.                         // TODO: handle exception
  203.                         e.printStackTrace();
  204.                         throw new RuntimeException(e.getMessage());
  205.                 } finally {
  206.                         close(rs, cs, ct);
  207.                 }
  208.         }

  209.         // 执行一个统一的select(查询操作, 需要手动关闭资源)
  210.         public static ResultSet executeQuery(String sql, String paras[]) {
  211.                 // System.out.println("当前SQL执行语句 "+sql);
  212.                 try {
  213.                         ct = getConn();
  214.                         ps = ct.prepareStatement(sql);
  215.                         // ps.setString(1, paras[0]);
  216.                         // ps.setString(2, paras[1]);
  217.                         if (paras != null) {
  218.                                 for (int i = 0; i < paras.length; i++) {
  219.                                         // ps.setObject(i+1, paras[i]);
  220.                                         ps.setString(i + 1, paras[i]);
  221.                                         // System.out.println("paras[i]"+paras[i]);
  222.                                 }
  223.                         }
  224.                         rs = ps.executeQuery();
  225.                 } catch (Exception e) {
  226.                         // TODO: handle exception
  227.                         e.printStackTrace();
  228.                         throw new RuntimeException(e.getMessage());
  229.                 }
  230.                 return rs;
  231.         }

  232.         // 事务可以解决SQL语句同时执行成功, 要么同时执行失败, 避免出现单提交
  233.         // 如果有多个update /insert /delete,需要考虑事务
  234.         public static void executeUpdateTwo(String sql[], String[][] paras) {
  235.                 try {
  236.                         // 获取链接
  237.                         ct = getConn();
  238.                         // 此时用户传入的是多个SQL语句
  239.                         ct.setAutoCommit(false);
  240.                         /*
  241.                          * SQL语句执行格式:(一条SQL语句对应多个参数) sql1 aaa1, bbb1 sql2 aaa2, bbb2 sql3
  242.                          * aaa3, bbb3 sql4 aaa4, bbb4
  243.                          */
  244.                         // 先取出sql语句
  245.                         for (int i = 0; i < sql.length; i++) {
  246.                                 ps = ct.prepareStatement(sql[i]);
  247.                                 // paras[i]是对应的第i条SQL语句对应的参数 数组
  248.                                 if (paras[i] != null) {
  249.                                         // 开始取出第i条SQL语句对应的参数
  250.                                         for (int j = 0; j < paras[i].length; j++) {
  251.                                                 // 取出第i条SQL语句, 把i条SQL语句对应的第j个参数赋值给第j+1个参数
  252.                                                 ps.setString(j + 1, paras[i][j]);
  253.                                         }
  254.                                 }
  255.                                 ps.executeUpdate();
  256.                         }
  257.                         // int i = 9/0; //系统出现异常, 数据库中的表也不会出现异常
  258.                         ct.commit();
  259.                         System.out.println("事务提交成功!!!");
  260.                 } catch (Exception e) {
  261.                         // TODO: handle exception
  262.                         e.printStackTrace();
  263.                         // 事务如果提交失败就回滚
  264.                         try {
  265.                                 // 系统出现异常, 回滚
  266.                                 ct.rollback();
  267.                         } catch (SQLException e1) {
  268.                                 // TODO Auto-generated catch block
  269.                                 e1.printStackTrace();
  270.                                 System.out.println("回滚失败!!!");
  271.                         }
  272.                         throw new RuntimeException(e.getMessage());
  273.                 } finally {
  274.                         close(rs, ps, ct);
  275.                 }
  276.         }

  277.         // 数据库的修改 update / delete / insert
  278.         // sql : update emp set ename = ? where id = ?
  279.         // paras[]: {"abc", 23}
  280.         public static void executeUpdate(String sql, String paras[]) {
  281.                 // 把参数给?赋值
  282.                 try {
  283.                         ct = getConn();
  284.                         ps = ct.prepareStatement(sql);
  285.                         if (paras != null) {
  286.                                 // 如果使用for循环增强, 不太好(不知道是第几个问号)
  287.                                 for (int i = 0; i < paras.length; i++) {
  288.                                         ps.setString(i + 1, paras[i]);
  289.                                 }
  290.                         }
  291.                         // 执行SQL语句
  292.                         // int num = ps.executeUpdate(); 去过用update()更新, 那么执行成功的就不仅是一行数据
  293.                         ps.executeUpdate();
  294.                 } catch (SQLException e) {
  295.                         // TODO Auto-generated catch block
  296.                         e.printStackTrace(); // 开发阶段需要打印出异常

  297.                         // 抛出运行异常(可以给调用该函数的一个选择, 调用者可以处理, 也可以放弃处理)
  298.                         throw new RuntimeException(e.getMessage());
  299.                 } finally {
  300.                         close(rs, ps, ct);
  301.                 }
  302.         }

  303.         // 关闭资源的函数
  304.         // 由于prepareStatement是Statement的子接口, 因此在这里我们选择关闭Statement
  305.         public static void close(ResultSet rs, Statement ps, Connection ct) {
  306.                 try {
  307.                         if (rs != null) {
  308.                                 rs.close();
  309.                                 rs = null;
  310.                         }
  311.                         if (ps != null) {
  312.                                 ps.close();
  313.                                 ps = null;
  314.                         }
  315.                         if (ct != null) {
  316.                                 ct.close();
  317.                                 ct = null;
  318.                         }
  319.                         System.out.println("资源关闭成功");
  320.                 } catch (Exception e2) {
  321.                         // TODO: handle exception
  322.                         e2.printStackTrace();
  323.                 }

  324.         }

  325. }
复制代码
以上就是小编本期提供的Java访问数据库实现的基本操作的封装,读者可以直接复制代码调用即可!注意,转载请注明出处,我爱科技论坛!




上一篇:【java工具类】java文件读写操作工具类
下一篇:【java进阶】如何实现类似于Spring的可配置框架
发帖求助前要善用【论坛搜索】功能,那里可能会有你要找的答案; 如果你在论坛求助问题,并且已经从坛友或者管理的回复中解决了问题,请把帖子分类或者标题加上【已解决】。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

微信扫一扫

快速回复 返回顶部 返回列表