精华内容
下载资源
问答
  • JDBC工具类封装

    2020-04-15 16:51:57
    由于JDBC的注册驱动以及释放资源经常用到,... * JDBC工具类,简化JDBC编程。 */ public class DBUtil { /** * 工具类中的构造方法都是私有的 * 因为工具类中的方法是静态的,不需要new对象,直接采用类名调用。...

    由于JDBC的注册驱动以及释放资源经常用到,所以封装成工具类

    package com.qzh.jdbc.utils;
    
    import java.sql.*;
    
    /**
     * JDBC工具类,简化JDBC编程。
     */
    public class DBUtil {
        /**
         * 工具类中的构造方法都是私有的
         * 因为工具类中的方法是静态的,不需要new对象,直接采用类名调用。
         */
        private DBUtil(){};
    
        static {
            try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
        public static Connection getConnection() throws SQLException {
            return DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
        }
    
        public static void close(Connection conn, Statement ps, ResultSet rs){
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    展开全文
  • 工具类封装 在前面的JDBC案例中我们不难发现,每次操纵数据库都需要进行数据库的注册、连接等大量重复的操作,是的代码变得十分的臃肿,所以此时我们应该考虑如何把重复代码提取出来,随时需要随时拿来用。 这...

    工具类封装

    在前面的JDBC案例中我们不难发现,每次操纵数据库都需要进行数据库的注册、连接等大量重复的操作,是的代码变得十分的臃肿,所以此时我们应该考虑如何把重复代码提取出来,随时需要随时拿来用。
    这就是工具类的封装。

    案例实现:实现emp表的查询、添加、删除、修改

    封装DbUtils

    由于多个地方都需要使用数据库连接和释放,所以把功能封装到工具类中DbUtils
    四个功能:

    1. 注册驱动
    2. 获取连接
    3. 释放资源
    4. 执行命令

    db.properties信息文件

    driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/emp
    user=root
    password=root

    自定义DbUtils工具类

    public class DBUtils {
    
        private static String driver;
        private static String url;
        private static String user;
        private static String password;
    
        static {
            // 使用信息文件进行赋值
            // 使用类加载器加载信息文件
            InputStream is = DBUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties pro = new Properties();
            try {
                // 读取文件信息并赋值
                pro.load(is);
                driver = pro.getProperty("driver");
                url = pro.getProperty("url");
                user = pro.getProperty("user");
                password = pro.getProperty("password");
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                // 注册驱动
                Class.forName(driver);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 获取数据库连接
        public static Connection getConnection() {
            Connection conn = null;
            try {
                // 获取数据库连接
                conn = DriverManager.getConnection(url, user, password);
                return conn;
            } catch (SQLException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        // 更新数据库
        public static int update(String sql, Object... params) {// 接收SQL语句和数据完成数据库的操作
            Connection conn = getConnection();
            PreparedStatement ps = null;
            try {
                ps = conn.prepareStatement(sql);
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
                int len = ps.executeUpdate();
                return len;
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                closeAll(conn, ps, null);
            }
            return 0;
        }
    
        // 查询所有
        public static List<Employee> getAll() {
            List<Employee> list = new ArrayList<Employee>();
            String sql = "SELECT * FROM emp;";
            Connection conn = getConnection();
            PreparedStatement ps = null;
            ResultSet rs = null;
            try {
                ps = conn.prepareStatement(sql);
                rs = ps.executeQuery();
                while (rs.next()) {
                    int empno = rs.getInt(1);
                    String ename = rs.getString(2);
                    String job = rs.getString(3);
                    int mgr = rs.getInt(4);
                    Date hiredate = rs.getDate(5);
                    double sal = rs.getDouble(6);
                    double comm = rs.getDouble(7);
                    int deptno = rs.getInt(8);
                    Employee emp = new Employee(empno, ename, job, mgr, hiredate, sal, comm, deptno);
                    list.add(emp);
                }
                return list;
            } catch (SQLException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        // 根据ID查询
        public static Employee getById(int empno) {
            String sql = "SELECT * FROM emp WHERE empno=?";
            Connection conn = getConnection();
            PreparedStatement ps = null;
            ResultSet rs = null;
            Employee emp = null;
            try {
                ps = conn.prepareStatement(sql);
                ps.setInt(1, empno);
                rs = ps.executeQuery();
                if (rs.next()) {
                    String ename = rs.getString(2);
                    String job = rs.getString(3);
                    int mgr = rs.getInt(4);
                    Date hiredate = rs.getDate(5);
                    double sal = rs.getDouble(6);
                    double comm = rs.getDouble(7);
                    int deptno = rs.getInt(8);
                    emp = new Employee(empno, ename, job, mgr, hiredate, sal, comm, deptno);
                }
                return emp;
            } catch (SQLException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        // 关闭数据库连接
        public static void closeAll(Connection conn, PreparedStatement ps, ResultSet rs) {
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (ps != null) {
                    ps.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    
    展开全文
  • JDBC 工具类封装jdbcUtils

    千次阅读 2018-07-26 21:31:02
    java代码中操作数据库。 操作通常分6步: 1.加载数据库驱动 ...这里对这些数据库操作做一些简单的封装 package jdbc_utils; import java.sql.Connection; import java.sql.DriverManager; im...

    java代码中操作数据库。

    操作通常分6步:

    1.加载数据库驱动

    2.建立数据库连接对象

    3.创建执行SQL的语句对象

    4.执行SQL语句

    5.处理结果

    6.释放数据库资源

    这里对这些数据库操作做一些简单的封装

    package jdbc_utils;

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;

    import com.mysql.jdbc.ResultSetMetaData;

    public class JdbcUtil {
        private static Connection connection = null;
        private static PreparedStatement ps = null;
        private static ResultSet rs = null;
        public static Connection getConnection() {
            try {
                Class.forName("com.mysql.jdbc.Driver");
                connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            return connection;
        }
        
        public static void executeUpdate(String sql,Object[] params) {
            try {
                ps = connection.prepareStatement(sql);
                if(params !=null && params.length != 0) {
                    for(int i = 0;i<params.length;i++) {
                        ps.setObject(i+1, params[i]);
                    }
                }
                ps.executeUpdate();
                
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
        public static void releaseDB() {
            try {
                if(rs != null) {
                    rs.close();
                }
                if(ps != null) {
                    ps.close();
                }
                if(connection != null) {
                    connection.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
                e2.printStackTrace();
            }
        }
        
        public static List<Map<String, Object>> executeQuery(String sql,Object[] params){
            ResultSet rs = null;
            List<Map<String, Object>> list = new ArrayList<>();
            
            try {
                ps = connection.prepareStatement(sql);
                if(params !=null && params.length != 0) {
                    for(int i = 0;i<params.length;i++) {
                        ps.setObject(i+1, params[i]);
                    }
                }
                rs = ps.executeQuery();
                ResultSetMetaData rsmd = (ResultSetMetaData) rs.getMetaData();
                int columnCount = rsmd.getColumnCount();
                while(rs.next()) {
                    Map<String, Object> map = new HashMap<>();
                    for(int i =0;i<columnCount;i++) {
                        String columnName = rsmd.getColumnLabel(i+1);
                        Object columnValue = rs.getObject(i+1);
                        //System.out.println(columnName + "===>" + columnValue);
                        map.put(columnName, columnValue);
                    }
                    list.add(map);
                }
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            return list;
        }
    }

     

    展开全文
  • JDBC工具类封装

    2019-09-10 23:24:00
    一:JDBC工具类封装 作用:简化现有JDBC操作代码 将一些重复性代码封装在一个工具类中,以后使用的时候调用就行了 封装原则: 1、基础功能 2、利于维护 3、性能 效率 基本版本: ...

    一:JDBC工具类的封装
    作用:简化现有JDBC操作代码 将一些重复性代码封装在一个工具类中,以后使用的时候调用就行了
    封装原则:
    1、基础功能
    2、利于维护
    3、性能 效率
    在这里插入图片描述基本版本:
    //获取连接对象

    	public static Connection getConnection() throw Exception{
    		//1、加载驱动  将接口的实现类交给DriverManager处理
    		Class.forName("oracle.jdbc.OracleDriver");
    		//获取数据库连接对象
    		Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr");
    		return conn;
    	}
    	
    	//关闭资源
    	public static void close(Connection conn,PreparedStatement pstm){
    		if(pstm!=null) try{pstm.close();}catch(Exception){}
    		if(conn!=null) try{conn.close();}catch(Exception){}
    	}
    	//关闭资源
    	public static void close(Connection conn,PreparedStatement pstm,ResultSet rs){
    		if(pstm!=null) try{pstm.close();}catch(Exception){}
    		if(conn!=null) try{conn.close();}catch(Exception){}
    		if(rs!=null) try{rs.close();}catch(Exception){}
    	}
    

    在这里插入图片描述

    在这里插入图片描述效率提升版本

    在这里插入图片描述

    展开全文
  • JDBC工具类DBUtils封装jar包

    千次阅读 2019-08-14 20:41:08
    JDBC工具类DBUtils封装jar包 通过对JDBC操作数据库的学习,我们会发现,由于JDBC操作数据库的步骤基本没有大的变化,针对所有的数据访问操作,都会存在大量重复代码,因此,对操作数据库的步骤封装就显得十分有必要...
  • 一、为什么要封装Jdbc工具类 使用Jdbc连接数据库时,总会有一些代码是必不可少的,如加载驱动、获取连接、释放资源等。为了提高重用性,可以将他们封装在一个工具类中。 二、Jdbc工具类的功能 1:properties配置文件...
  • 封装一个JDBC工具类

    2019-08-14 20:43:57
    封装JDBC工具类代码 import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.ResourceBundle; ...
  • 我们写一个jdbc工具类。下次在进行驱动和释放资源时可以直接调用工具类中的 方法。 package com.atguigu.DBUtil; import java.sql.*; /** * jdbc工具类 **/ public class DBUtil { //因为注册只需要进行一次,...
  • JDBC工具类封装方法(公共的、静态的)进行与数据库的连接及执行sql命令,在需要使用的类中直接调用。 package com.offcn.util; import java.io.IOException; import java.io.InputStream; import java.lang....
  • JDBC 封装工具类

    2017-06-26 22:56:55
    1.配置文件 jdbc.properties driverClass=com.mysql.jdbc.Driver url=jdbc:mysql:///mydb?useServerPrepStmts=true&cachePrepStmts=true&rewriteBatchedStatements=true ...2.封装工具类 jdbcUtil
  • 完全封装JDBC工具类

    2020-01-11 11:46:30
    文章目录一、封装的操作二、封装好的包dbcp.propertiesJdbcUtil3.javaJdbcTemplate....(2)加载时加载驱动√ (3)ThreadLocal控制事务√ (4)连接池,提高资源利用率√ (5)rowmapper封装结果集 减少代码冗余...
  • jdbc封装工具类

    2013-06-25 10:17:36
    jdbc封装工具类,此类事封装成list,Object>>格式,可直接把转换为jsonArray格式传输数据。
  • JDBC工具类

    2013-01-04 23:13:50
    自己封装jdbc工具类,有详细的注释,更容易理解。
  • JDBC封装工具类

    2019-01-01 23:43:48
    JDBC封装工具类,将所有共同的代码提取过来,形成工具类
  • 自己封装jdbc工具类

    2013-07-16 10:33:59
    给学生讲课课上写的jdbc封装类,对基本的增删改查和事务做了封装。例子中用的是oracle 11g数据库,如果换其他数据库直接改连库字符串就行,其他的不用动,适合初学者学习。查询的时候会省掉很多工作量,不需要一个一...
  • 目录 一、直接封装JDBCUtils 工具类 二、使用 properties 配置文件封装...在 JDBC 开发中,发现有很多代码都是重复操作,如“获得数据库连接”、“关闭资源”等,因此,可以封装自己的工具类 JDBCUtils,提供获取...
  • JDBC封装工具类

    2017-10-25 20:44:47
    方法封装
  • 利用反射封装JDBC工具类 JDBC数据库通用DAO 转载于:https://my.oschina.net/yunsy/blog/271935...
  • JDBC工具类的三种封装方法

    千次阅读 2018-04-13 16:29:53
    JDBC封装工具类的三种方法1、JDBCUtilsV1package cn.itsust.Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql....
  • JDBC相关工具类封装

    千次阅读 2019-06-15 19:46:18
    一、JDBC连接工具类(MySQL为例) 1、在项目根目录创建一个properties的配置文件db.properties,里面定义了四行数据,分别对应着JDBC连接所需要的几个参数(注:Properties底层为一个Hashtable,配置文件中“=”之前...
  • JDBC JDBCUtil工具类(idea 封装)

    千次阅读 2019-04-11 15:58:57
    jdbc引言 JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API, 可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。...jdbc工具类封装 package...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,141
精华内容 26,856
关键字:

jdbc工具类的封装