`
vipbooks
  • 浏览: 148265 次
  • 性别: Icon_minigender_1
  • 来自: 长沙
社区版块
存档分类

用于JDBC操作数据库的公共类

阅读更多
   哈哈,再发一个用于JDBC操作数据库的公共类,这也是我在很久以前写的,其中的RWProperties类在我的“Java基础”分类中有一篇《用于读写Properties属性配制文件的通用类》的文章中就有,希望能对大家有些帮助,以后我还会发更多的原创文章上来,也希望大家能提出一些宝贵的建议和想法,让我们大家在这里共同成长!

修改日志(20111010)
   在写完该工具之后的日子里对该工具进行过很多迭代式的修改,这里今年修改的最新的版本,更加通用、更加灵活,同时支持ICO、批量操作和手动提交事务,并去除了对RWProperties.java的依赖。

/* 
 * @(#)CommonSql.java  2011-9-5 
 *  
 * Copyright 2011 Bianjing,All rights reserved. 
 */  

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

/**
 * 用于JDBC操作数据库的共通类
 * 
 * @author Bianjing
 * @version 1.0.0 2011-9-5
 */
public class CommonSql {
    /** 数据源 */
    private DataSource dataSource;

    /** 数据库连接对象 */
    private Connection connection;

    /** 数据库操作对象 */
    private PreparedStatement ps;

    /** 数据库操作对象 */
    private Statement statement;

    /** 返回的数据结果集对象 */
    private ResultSet rs;

    /** 是否自动提交事务,默认为true,如果该值为false则需要手动提交事务 */
    private boolean autoCommit = true;

    /** 数据库连接是否已经打开 */
    private boolean openConnection;

    /** JNDI名称 */
    private String jndiName;

    /** 数据库驱动 */
    private String driver;

    /** 数据库访问地址 */
    private String url;

    /** 用户名 */
    private String user;

    /** 密码 */
    private String pwd;

    public CommonSql() {
        
    }

    public CommonSql(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public CommonSql(String jndiName) {
        this.jndiName = jndiName;
    }

    public CommonSql(String driver, String url, String user, String pwd) {
        this.driver = driver;
        this.url = url;
        this.user = user;
        this.pwd = pwd;
    }

    /**
     * 打开数据库连接并创建数据库连接对象<br/>
     * 支持通过ICO注入数据源、数据库驱动、数据库驱动、JNDI名称、数据库访问地址和用户名、密码
     * 
     * @return boolean true:连接成功,false:连接失败
     */
    public boolean openConnection() {
        /**
         * 通过数据源来获取数据库连接对象
         */
        if (dataSource != null) {
            try {
                connection = dataSource.getConnection();
                // 数据库连接已经打开
                openConnection = true;
            } catch (SQLException e) {
                closeAll();
                // 所有的"System.out.println"都可以替换为"logger.error"
                System.out.println("从数据源获取数据库连接失败!");
                throw new RuntimeException(e);
            }

            return openConnection;
        }
        /**
         * 通过JNDI来获取数据库连接对象
         */
        if (jndiName != null) {
            try {
                Context initContext = new InitialContext();
                dataSource = (DataSource) initContext.lookup(jndiName);
                connection = dataSource.getConnection();
                // 数据库连接已经打开
                openConnection = true;
            } catch (Exception e) {
                closeAll();
                System.out.println("从JNDI获取数据库连接失败!");
                throw new RuntimeException(e);
            }

            return openConnection;
        }
        /**
         * 通过数据库驱动、数据库访问地址、用户名、密码来获取数据库连接对象
         */
        try {
            Class.forName(driver);
            connection = DriverManager.getConnection(url, user, pwd);
            // 数据库连接已经打开
            openConnection = true;
        } catch (Exception e) {
            closeAll();
            System.out.println("数据库连接失败!");
            throw new RuntimeException(e);
        }

        return openConnection;
    }

    /**
     * 执行数据库的更新操作
     * 
     * @param sql
     *            要执行的SQL语句
     * @return boolean true:执行成功,false:执行失败
     */
    public boolean execUpdate(String sql, Object... args) {
        boolean isPassed = false;
        // 判断连接数据库是否成功
        if (openConnection) {
            try {
                ps = connection.prepareStatement(sql);
                // 设置参数
                if (args != null && args.length > 0) {
                    for (int i = 0; i < args.length; i++) {
                        ps.setObject(i + 1, args[i]);
                    }
                }
                ps.executeUpdate();

                isPassed = true;
            } catch (SQLException e) {
                try {
                    if (autoCommit) {
                        connection.rollback();
                    }
                } catch (SQLException e1) {
                    throw new RuntimeException(e1);
                }
                System.out.println("SQL:" + sql);
                throw new RuntimeException(e);
            } finally {
                if (autoCommit) {
                    closeAll();
                }
            }
        } else {
            System.out.println("数据库连接对象没有打开!");
        }

        return isPassed;
    }
    
    /**
     * 执行数据库的更新操作
     * 
     * @param sql
     *            要执行的SQL语句
     * @return boolean true:执行成功,false:执行失败
     */
    public boolean execUpdate(String sql, List<?> args) {
        return execUpdate(sql, args.toArray());
    }

    /**
     * 执行批量更新数据库操作
     * 
     * @param sql
     *            要执行的SQL语句的字符串数组
     * @return boolean true:执行成功,false:执行失败
     */
    public boolean execUpdate(Object[] sql) {
        boolean flag = false;
        // 判断连接数据库是否成功
        if (openConnection) {
            try {
                statement = connection.createStatement();
                for (int i = 0; i < sql.length; i++) {
                    statement.addBatch((String) sql[i]);
                }
                statement.executeBatch();

                flag = true;
            } catch (SQLException e) {
                try {
                    if (autoCommit) {
                        connection.rollback();
                    }
                } catch (SQLException e1) {
                    throw new RuntimeException(e1);
                }
                for (int i = 0; i < sql.length; i++) {
                    System.out.println("SQL " + (i + 1) + ":" + sql[i]);
                }
                throw new RuntimeException(e);
            } finally {
                if (autoCommit) {
                    closeAll();
                }
            }
        } else {
            System.out.println("数据库连接对象没有打开!");
        }

        return flag;
    }

    /**
     * 执行批量更新数据库操作
     * 
     * @param sql
     *            要执行的SQL语句的集合
     * @return boolean true:执行成功,false:执行失败
     */
    public boolean execUpdate(List<?> sql) {
        return execUpdate(sql.toArray());
    }

    /**
     * 执行数据库查询操作
     * 
     * @param sql
     *            要执行的SQL语句
     * @param args
     *            查询参数列表
     * @return ResultSet 返回查询的结果集对象
     */
    public ResultSet execQuery(String sql, Object... args) {
        rs = null;
        // 判断连接数据库是否成功
        if (openConnection) {
            try {
                ps = connection.prepareStatement(sql);
                // 设置参数
                if (args != null && args.length > 0) {
                    for (int i = 0; i < args.length; i++) {
                        ps.setObject(i + 1, args[i]);
                    }
                }
                
                rs = ps.executeQuery();
            } catch (SQLException e) {
                if (autoCommit) {
                    closeAll();
                }
                System.out.println("SQL:" + sql);
                throw new RuntimeException(e);
            }
        } else {
            System.out.println("数据库连接对象没有打开!");
        }

        return rs;
    }

    /**
     * 执行数据库查询操作
     * 
     * @param sql
     *            要执行的SQL语句
     * @param args
     *            查询参数列表
     * @return ResultSet 返回查询的结果集对象
     */
    public ResultSet execQuery(String sql, List<?> args) {
        return execQuery(sql, args.toArray());
    }

    /**
     * 根据标准SQL查询数据库,返回一个int值
     * 
     * @param sql
     *            要执行的SQL语句
     * @param args
     *            查询参数列表
     * @return int值,如果出错则返回-1
     */
    public int findForInt(String sql, Object... args) {
        ResultSet rs = execQuery(sql, args);
        int count = -1;
        try {
            if (rs != null && rs.next()) {
                count = rs.getInt(1);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (autoCommit) {
                closeAll();
            }
        }

        return count;
    }
    
    /**
     * 根据标准SQL查询数据库,返回一个int值
     * 
     * @param sql
     *            要执行的SQL语句
     * @param args
     *            查询参数列表
     * @return int值,如果出错则返回-1
     */
    public int findForInt(String sql, List<?> args) {
        return findForInt(sql, args.toArray());
    }

    /**
     * 关闭所有数据库连接对象
     */
    public void closeAll() {
        if (rs != null || ps != null || statement != null || connection != null) {
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            } finally {
                rs = null;
                if (ps != null || statement != null || connection != null) {
                    try {
                        if (ps != null && !ps.isClosed()) {
                            ps.close();
                        }
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    } finally {
                        ps = null;
                        if (statement != null || connection != null) {
                            try {
                                if (statement != null && !statement.isClosed()) {
                                    statement.close();
                                }
                            } catch (SQLException e) {
                                throw new RuntimeException(e);
                            } finally {
                                statement = null;
                                try {
                                    if (connection != null
                                            && !connection.isClosed()) {
                                        connection.close();
                                    }
                                } catch (SQLException e) {
                                    throw new RuntimeException(e);
                                } finally {
                                    connection = null;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 提交事务并关闭数据库连接
     */
    public void commit() {
        try {
            if (!autoCommit) {
                connection.commit();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            autoCommit = true;
            closeAll();
        }
    }

    /**
     * 回滚事务并关闭数据库连接
     */
    public void rollback() {
        try {
            if (!autoCommit) {
                connection.rollback();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            autoCommit = true;
            closeAll();
        }
    }

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public boolean getAutoCommit() {
        return autoCommit;
    }

    public void setAutoCommit(boolean autoCommit) {
        try {
            connection.setAutoCommit(autoCommit);
        } catch (SQLException e) {
            closeAll();
            throw new RuntimeException(e);
        }
        this.autoCommit = autoCommit;
    }

    public boolean getOpenConnection() {
        return openConnection;
    }

    public String getJndiName() {
        return jndiName;
    }

    public void setJndiName(String jndiName) {
        this.jndiName = jndiName;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public Connection getConnection() {
        return connection;
    }

    /**
     * 测试数据库连接是否成功
     * 
     * @param args
     * @throws SQLException
     */
    public static void main(String[] args) throws SQLException {
        String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=demo";
        String user = "sa";
        String pwd = "sa";

        CommonSql commonSql = new CommonSql(driver, url, user, pwd);
        if (commonSql.openConnection()) {
            System.out.println("数据库连接成功!");
            DatabaseMetaData dbMetaData = commonSql.getConnection()
                    .getMetaData();
            System.out
                    .print("当前连接的数据库是:" + dbMetaData.getDatabaseProductName());
            System.out.println(" " + dbMetaData.getDatabaseProductVersion());
        } else {
            System.out.println("数据库连接失败!");
        }

        commonSql.closeAll();
    }
}

1
0
分享到:
评论
2 楼 vipbooks 2011-10-10  
liangzai718 写道
RWProperties.getProperty("driver", "com/test/config/db.properties");
-- RWProperties类貌似没有getProperty(arg0,arg1)这个方法呀?这个怎么调呀?


哈哈,不好意思啊,这个类已经改了很多地方了,我还没有把改好的上传上来,今天我就更新一下!
RWProperties已经更新过了,易用性更好了!
1 楼 liangzai718 2011-10-09  
RWProperties.getProperty("driver", "com/test/config/db.properties");
-- RWProperties类貌似没有getProperty(arg0,arg1)这个方法呀?这个怎么调呀?

相关推荐

    操作数据库的公共类 jar 包

    为了简化这一过程,开发者通常会使用预定义的类库,其中一个常见的就是"操作数据库的公共类 jar 包"。这个jar包提供了一组通用的数据库操作类,使得程序员可以便捷地进行数据库的连接、查询、更新等操作,无需深入...

    02-JDBC-数据库连接技术

    "JDBC数据库连接技术" JDBC(Java Database Connectivity)是一种Java API,用于连接和操作关系型数据库。它提供了一组统一的接口,允许Java程序与不同的关系型数据库管理系统进行交互。 1. 常见的关系型数据库 ...

    JDBC公共操作方法代码

    这篇名为“JDBC公共操作方法代码”的博客文章可能详细介绍了如何使用JDBC进行常见的数据库操作。下面我们将深入探讨JDBC的关键知识点。 首先,JDBC连接数据库的步骤通常包括以下几个部分: 1. 导入JDBC驱动:在...

    JDBC数据库访问技术

    它由一组Java编写的类和接口组成,允许开发者执行SQL语句并处理数据库操作。JDBC的主要目标是提供一个统一的方式来访问不同类型的数据库,避免了针对不同数据库系统编写特定代码的需求。 1. JDBC的概念: JDBC不仅...

    JDBC连接myaql数据库.rar

    综上所述,JDBC连接mysql数据库.rar提供的两个JDBC驱动包主要用于在Java项目中与MySQL数据库建立连接,不同版本适应不同的MySQL服务和功能需求。在实际开发中,选择适合项目需求的版本并正确使用JDBC连接步骤,可以...

    jdbc jar包

    JDBC Jar包是实现这一连接功能的核心库,它包含了所有必要的类和接口,使得Java开发者能够编写程序来访问和操作数据库。在Java应用程序中,JDBC扮演着桥梁的角色,允许程序执行SQL语句,进行数据查询、插入、更新和...

    用工厂模式开发多数据库连接类

    在软件设计模式中,工厂模式是一种非常常见的创建型模式,它的主要目的是为了抽象产品的创建过程,使得客户端可以无须关心具体的产品实现,只需要通过一个公共的接口或者类来获取产品实例。在这个“用工厂模式开发多...

    hive jdbc 连接所需要的jar包

    3. **hadoop-common*.jar**: Hadoop的公共库,包含了Hadoop系统的基本功能,如文件系统操作、网络通信等,对于Hive JDBC来说,它是连接HDFS(Hadoop Distributed File System)的基础。 4. **hadoop-hdfs*.jar**: ...

    JDBC技术和数据库连接池专题

    JDBC(Java Database Connectivity)是一种用于执行SQL语句的Java API,它可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JDBC提供了与数据库建立连接、发送SQL语句并处理结果的基本方法...

    数据库表映射成实体类

    然而,直接使用JDBC进行数据操作可能会导致大量的重复代码,因此,将数据库表映射为实体类可以提高代码的可读性和可维护性。ORM框架如Hibernate、MyBatis等,它们提供了自动化的JavaBean到数据库表之间的映射功能。 ...

    hive2.1.1 + hadoop2.6.0jdbc驱动

    标题 "hive2.1.1 + hadoop2.6.0 jdbc驱动" 指的是一个包含特定版本的Hive和Hadoop组件的集合,这些组件特别针对通过JDBC进行数据库连接进行了优化。Hive是Apache软件基金会开发的一个数据仓库工具,它允许用户使用...

    JDBC核心技术_汇总篇.pdf

    JDBC作为通用的SQL数据库存取和操作的公共接口,为访问不同的数据库提供了一种统一的途径,屏蔽了一些数据库访问的细节问题。 要使用JDBC,程序员不需要对特定的数据库系统的特点有过多了解,只需要使用JDBC提供的...

    Dao数据库工具类

    - 定义了一个公共类`BaseDao`,用于封装数据库访问逻辑。 4. **私有静态成员变量**: - `private static final String driverName = "oracle.jdbc.driver.OracleDriver";` - `private static final String url =...

    jdbc 驱动包

    1. msbase.jar:这是JDBC驱动的基础组件,包含了与SQL Server数据库交互所需的公共类和接口。这些类和接口是JDBC驱动的核心,用于执行SQL语句、处理结果集、管理数据库连接等。 2. mssqlserver.jar:这个文件是SQL ...

    使用java的反射机制来模拟hibernater的jdbc操作

    3. **获取方法**:通过`Class对象.getMethod()`或`getDeclaredMethod()`获取类的方法,这两个方法分别用于获取公共方法和所有方法,包括私有方法。 4. **执行方法**:有了Method对象后,我们就可以调用`invoke()`...

    Java封装hibernate操作数据库.rar

    在"CommonLibJDK15(4hibernate)"这个子目录中,可能包含了支持Hibernate运行的公共库,如JDBC驱动、Hibernate核心库等。使用JDK15版本,说明此项目已经采用了较新的Java语言特性,如模块系统、增强的switch语句等,...

    spring连接数据库代码

    这是一个公共的数据库操作类,提供了五个静态字符串变量,用于定义数据库操作语句。这些变量分别是:createSqlString、insertData1String、insertData2String、insertData3String 和 selectSqlString。 实体类 ...

    xfire+jdbc的操作

    JDBC是Java与数据库交互的桥梁,它定义了一组接口和类,用于建立数据库连接、执行SQL语句以及处理结果集。为了使用JDBC,我们需要先加载数据库驱动,然后创建Connection对象,接着通过Statement或PreparedStatement...

    Jdbc相关知识点归档

    JDBC(Java Database Connectivity)是Java语言中用于实现数据库操作的核心技术,它提供了一套标准的API,使得Java程序能够以一种统一的方式访问不同的数据库系统。以下将从JDBC概述、数据持久化、Java中的数据存储...

    JDBC所需jar包

    将这些JAR文件添加到项目的类路径中后,开发者就能够使用JDBC API编写代码来连接Oracle数据库,执行SQL查询、更新数据、处理结果集等操作。例如,使用`Class.forName()`加载驱动,然后通过`DriverManager.get...

Global site tag (gtag.js) - Google Analytics