java数据库操作工具类

最新推荐文章于 2022-09-17 12:43:48 发布
最新推荐文章于 2022-09-17 12:43:48 发布
阅读量435 收藏
点赞数
分类专栏： java 数据库 jdbc 文章标签： java jdbc 数据库
java 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
数据库
1 篇文章 0 订阅
订阅专栏
jdbc
1 篇文章 0 订阅
订阅专栏

原地址：https://www.oschina.net/code/snippet_1998172_50215

感谢原博主


package com.http.utils;
 
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
 
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang.ArrayUtils;
 
/**
 * [简要描述]:数据库工具类<br/>
 * [详细描述]:<br/>
 *
 * @version [revision],2015年8月12日
 * @author Magic_yuan
 */
public class DBHelp
{
    /**
     * [简要描述]:获取主库的数据源连接<br/>
     * [详细描述]:<br/>
     *
     * @return
     * @exception 
     */
    public static Connection getConn()
    {
        Connection conn = null;
        try
        {
            // Class.forName("com.mysql.jdbc.Driver");
            // String url = PropertiesUtils.getValue("mysqlUrl");
            // String user = PropertiesUtils.getValue("mysqlUser");
            // String password = PropertiesUtils.getValue("mysqlPwd");
            // conn = DriverManager.getConnection(url, user, password);
 
            Context initContext = new InitialContext();
            Context envContext = (Context) initContext.lookup("java:/comp/env");
            DataSource ds = (DataSource) envContext.lookup("neushopDataSourceJNDI");
            conn = ds.getConnection();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return conn;
    }
 
    /**
     * [简要描述]:获取查询库的数据源链接<br/>
     * [详细描述]:<br/>
     *
     * @return
     * @exception 
     */
    public static Connection getQueryConn()
    {
        Connection conn = null;
        try
        {
            Context initContext = new InitialContext();
            Context envContext = (Context) initContext.lookup("java:/comp/env");
            DataSource ds = (DataSource) envContext.lookup("neushopDataSourceQuery");
            conn = ds.getConnection();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return conn;
    }
 
    /**
     * [简要描述]:释放资源<br/>
     * [详细描述]:<br/>
     *
     * @param o
     * @exception 
     */
    public static void closeObject(Object o)
    {
        if (o != null)
        {
            if (o instanceof Connection)
            {
                try
                {
                    ((Connection) o).close();
                }
                catch (SQLException e)
                {
                    e.printStackTrace();
                }
            }
            if (o instanceof Statement)
            {
                try
                {
                    ((Statement) o).close();
                }
                catch (SQLException e)
                {
                    e.printStackTrace();
                }
            }
            if (o instanceof PreparedStatement)
            {
                try
                {
                    ((PreparedStatement) o).close();
                }
                catch (SQLException e)
                {
                    e.printStackTrace();
                }
            }
            if (o instanceof ResultSet)
            {
                try
                {
                    ((ResultSet) o).close();
                }
                catch (SQLException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
 
    /**
     * [简要描述]:查询记录总数<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @return
     * @exception 
     */
    public static int getUniqueResult(String sql)
    {
        int result = 0;
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rs = null;
        try
        {
            conn = DBHelp.getConn();
            pst = conn.prepareStatement(sql);
            rs = pst.executeQuery();
            if (rs.next())
            {
                result = rs.getInt(1);
            }
 
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rs);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return result;
    }
 
    /**
     * [简要描述]:常规sql操作<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @param objects
     * @return
     * @exception 
     */
    public static int doDML(String sql, Object[] objects)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        int flag = 0;
        try
        {
            conn = getConn();
            pst = conn.prepareStatement(sql);
            if (objects != null)
            {
                for (int i = 0; i < objects.length; i++)
                {
                    pst.setObject(i + 1, objects[i]);
                }
            }
            flag = pst.executeUpdate();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return flag;
    }
 
    /**
     * [简要描述]:根据表名和对象自动更新keys值记录<br/>
     * [详细描述]:<br/>
     *
     * @param tableName
     * @param t
     * @param keys
     * @return
     * @throws ReflectiveOperationException
     * @exception 
     */
    public static <T> int autoUpdate(String tableName, T t, String[] keys)
            throws ReflectiveOperationException
    {
        Connection conn = null;
        PreparedStatement pst = null;
 
        Map beanMap = null;
        try
        {
            beanMap = BeanUtils.describe(t);
        }
        catch (IllegalAccessException | InvocationTargetException
                | NoSuchMethodException e1)
        {
            e1.printStackTrace();
            throw e1;
        }
 
        StringBuffer sql = new StringBuffer();
        StringBuffer param = new StringBuffer();
        StringBuffer where = new StringBuffer(" where ");
        sql.append("update ").append(tableName).append(" set ");
 
        Set<Entry<Object, Object>> entrySet = beanMap.entrySet();
 
        for (Entry<Object, Object> entry : entrySet)
        {
            if ("class".equalsIgnoreCase((String) entry.getKey()))
            {
                continue;
            }
 
            if (ArrayUtils.contains(keys, entry.getKey()))
            {
                where.append(entry.getKey()).append(" = '").append(
                        entry.getValue()).append("' and ");
                continue;
            }
 
            if (null == entry.getValue())
            {
                continue;
            }
            else
            {
                param.append(entry.getKey()).append(" = '").append(
                        entry.getValue()).append("',");
                ;
            }
        }
        sql.append(
                param.toString().substring(0, param.toString().lastIndexOf(","))).append(where.substring(0, where.lastIndexOf("and")));
 
        int flag = 0;
        try
        {
            conn = getConn();
            pst = conn.prepareStatement(sql.toString());
            flag = pst.executeUpdate();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return flag;
    }
 
    /**
     * [简要描述]:根据表名和对象自动插入<br/>
     * [详细描述]:<br/>
     *
     * @param tableName
     * @param t
     * @return
     * @throws ReflectiveOperationException
     * @exception 
     */
    public static <T> int autoInsert(String tableName, T t)
            throws ReflectiveOperationException
    {
        Connection conn = null;
        PreparedStatement pst = null;
 
        Map beanMap = null;
        try
        {
            beanMap = BeanUtils.describe(t);
        }
        catch (IllegalAccessException | InvocationTargetException
                | NoSuchMethodException e1)
        {
            e1.printStackTrace();
            throw e1;
        }
 
        StringBuffer sql = new StringBuffer();
        StringBuffer param = new StringBuffer();
        StringBuffer values = new StringBuffer();
        sql.append("insert into ").append(tableName).append(" (");
 
        Set<Entry<Object, Object>> entrySet = beanMap.entrySet();
 
        for (Entry<Object, Object> entry : entrySet)
        {
            if ("class".equalsIgnoreCase((String) entry.getKey()))
            {
                continue;
            }
 
            if (null == entry.getValue())
            {
                continue;
            }
            else
            {
                param.append(entry.getKey()).append(",");
                values.append("'").append(entry.getValue()).append("',");
            }
        }
        sql.append(
                param.toString().substring(0, param.toString().lastIndexOf(","))).append(
                ") values ( ").append(
                values.toString().substring(0,
                        values.toString().lastIndexOf(","))).append(" )");
 
        int flag = 0;
        try
        {
            conn = getConn();
            pst = conn.prepareStatement(sql.toString());
            flag = pst.executeUpdate();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return flag;
    }
 
    /**
     * [简要描述]:根据columns自动封装查询结果为Map集合<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @param args
     * @param columns
     * @return
     * @exception 
     */
    public static List<Map<String, String>> doQuery(String sql, String[] args,
            String[] columns)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rst = null;
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        try
        {
            conn = getQueryConn();
            pst = conn.prepareStatement(sql);
            if (args != null)
            {
                for (int i = 0; i < args.length; i++)
                {
                    pst.setString(i + 1, args[i]);
                }
            }
            rst = pst.executeQuery();
            while (rst.next())
            {
                Map<String, String> map = new HashMap<String, String>();
                for (int i = 0; i < columns.length; i++)
                {
                    map.put(columns[i], rst.getString(columns[i]));
                }
                list.add(map);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rst);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return list;
    }
 
    /**
     * [简要描述]:查询对象集合<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @param t
     * @return
     * @exception 
     */
    public static <T> List<T> doQuery(String sql, Class<T> t)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rst = null;
 
        Object tempStr = null;
        List<T> list = new ArrayList<T>();
        try
        {
            conn = getQueryConn();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            while (rst.next())
            {
                T obj = t.newInstance();
 
                if (obj instanceof String)
                {
                    obj = (T) rst.getString(1);
                }
                else
                {
                    Field[] fields = obj.getClass().getDeclaredFields();
                    for (Field field : fields)
                    {
                        try
                        {
                            tempStr = rst.getObject(field.getName());
                        }
                        catch (SQLException e)
                        {
                            tempStr = "";
                        }
 
                        field.setAccessible(true);
 
                        BeanUtils.setProperty(obj, field.getName(), tempStr);
                    }
 
                }
 
                list.add(obj);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rst);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return list;
    }
 
    /**
     * [简要描述]:查询记录总数<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @return
     * @exception 
     */
    public static int queryCount(String sql)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rst = null;
        int result = 0;
        try
        {
            conn = getQueryConn();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            if (rst.next())
            {
                result = rst.getInt(1);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rst);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return result;
    }
 
    /**
     * [简要描述]:查询单个字符串<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @return
     * @exception 
     */
    public static String queryString(String sql)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rst = null;
        String result = "";
        try
        {
            conn = getQueryConn();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            if (rst.next())
            {
                result = rst.getString(1);
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rst);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return result;
    }
 
    /**
     * [简要描述]:查询单个对象<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @param t
     * @return
     * @exception 
     */
    public static <T> T queryOne(String sql, Class<T> t)
    {
        Connection conn = null;
        PreparedStatement pst = null;
        ResultSet rst = null;
        T obj = null;
        String tempStr = null;
        try
        {
            obj = t.newInstance();
        }
        catch (InstantiationException e1)
        {
            e1.printStackTrace();
        }
        catch (IllegalAccessException e1)
        {
            e1.printStackTrace();
        }
        try
        {
            conn = getQueryConn();
            pst = conn.prepareStatement(sql);
            rst = pst.executeQuery();
            if (rst.next())
            {
                Field[] fields = obj.getClass().getDeclaredFields();
                for (Field field : fields)
                {
                    if ("serialVersionUID".equalsIgnoreCase(field.getName()))
                    {
                        continue;
                    }
 
                    try
                    {
                        tempStr = rst.getString(field.getName());
                    }
                    catch (SQLException e)
                    {
                        tempStr = "";
                    }
 
                    BeanUtils.setProperty(obj, field.getName(), tempStr);
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(rst);
            DBHelp.closeObject(pst);
            DBHelp.closeObject(conn);
        }
        return obj;
    }
 
    /**
     * [简要描述]:批量操作<br/>
     * [详细描述]:<br/>
     *
     * @param sql
     * @param argsList
     * @exception 
     */
    public static void addBatch(String sql, List<String[]> argsList)
    {
        Connection conn = null;
        PreparedStatement prest = null;
        try
        {
            conn = getConn();
            conn.setAutoCommit(false);
            prest = conn.prepareStatement(sql);
 
            for (String[] strings : argsList)
            {
                for (int i = 0; i < strings.length; i++)
                {
                    prest.setString(i + 1, strings[i]);
                }
                prest.addBatch();
            }
 
            prest.executeBatch();
            conn.commit();
        }
        catch (SQLException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            DBHelp.closeObject(prest);
            DBHelp.closeObject(conn);
        }
    }
}
kristenlee1218
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数据库工具类
wjg_selected的博客
03-15 591
java数据库工具类 本工具类主要运用到了集合的知识 DbHelper.java public class DbHelper { private Connection connection; private PreparedStatement preparedStatement; private ResultSet resultSet; public DbHelper() { getConnection(); } //打开连接 public void getConnect
Java连接数据库的工具类
11-10
本资源是java开发的常用工具类，包括01.DTD约束文档，02.Schema约束文档，c3p0，commons-dbutils-1.6，commons-io-2.4，commons-pool-1.5.6，mysql-connector-java-5.1.37
JAVA数据库操作工具类
08-23
JAVA数据库操作工具类，用JAVA实现了对SQL Server数据库的增删改基本操作，对工具类的每个方法使用JUnit来测试
连接数据库-mysql/oracle工具类
hao947的专栏
05-28 539
package com.common.database; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; /** * 功能描述：连接数据库-mysql/oracle * * @author :雪藏的心 * @Date :Jul 18, 2014 * @T
Java数据库操作工具类
08-12
自己封装的数据库工具类，实现自动插入和更新，自动查询封装对象。数据源使用jndi，支持读写分离。
数据库操作工具类
08-26
可以用于快速完成数据库的增删改查操作. 注意,需要自行配置properties 文件以及添加对应数据库的驱动.
Java单例模式下的MongoDB数据库操作工具类
08-28
Java单例模式下的MongoDB数据库操作工具类 在Java编程中，单例模式是一种常见的设计模式，用于限制类的实例化次数，确保某个类只有一个实例。在数据存储和处理中，MongoDB是一个流行的NoSQL数据库，用于存储和处理...
java连接Oracle数据库的工具类
09-03
这个给定的`OracleDbManager`工具类就是为简化这一过程而设计的，它封装了连接、操作和断开Oracle数据库的基本步骤。下面我们将详细讲解这个工具类中的关键知识点。 1. **JDBC驱动注册**： 在静态初始化块中，通过...
【JDBC】java实现数据库操作的工具类
one or only的博客
05-14 4587
JDBC用于实现数据库操作的工具类 DBTools工具类和DAO工具类 DAO是：Database Access Object 数据库访问对象 在DAO中包括insert,delete,update。get()是用于获取结果集中只有一条记录的方法。getForList()是用于获取结果集中有多条记录的方法。而getForValue()用于获取结果集中只有一列的方法（比如想要获取数据库表中的...
数据库工具类DatabaseUtil.java
01-14
package com.hexiang.utils; import java.sql.*; import java.util.*; /** * * Title: 数据库工具类 * * * Description: 将大部分的数据库操作放入这个类中, 包括数据库连接的建立, 自动释放等. * * * @author beansoft 日期: 2004年04月 * @version 2.0 */ public class DatabaseUtil { /** 数据库连接 */ private java.sql.Connection connection; /** * All database resources created by this class, should be free after all * operations, holds: ResultSet, Statement, PreparedStatement, etc. */ private ArrayList resourcesList = new ArrayList(5); public DatabaseUtil() { } /** 关闭数据库连接并释放所有数据库资源 */ public void close() { closeAllResources(); close(getConnection()); } /** * Close given connection. * * @param connection * Connection */ public static void close(Connection connection) { try { connection.close(); } catch (Exception ex) { System.err.println("Exception when close a connection: " + ex.getMessage()); } } /** * Close all resources created by this class. */ public void closeAllResources() { for (int i = 0; i < this.getResourcesList().size(); i++) { closeJDBCResource(getResourcesList().get(i)); } } /** * Close a jdbc resource, such as ResultSet, Statement, Connection.... All * these objects must have a method signature is void close(). * * @param resource - * jdbc resouce to close */ public void closeJDBCResource(Object resource) { try { Class clazz = resource.getClass(); java.lang.reflect.Method method = clazz.getMethod("close", null); method.invoke(resource, null); } catch (Exception e) { // e.printStackTrace(); } } /** * 执行 SELECT 等 SQL 语句并返回结果集. * * @param sql * 需要发送到数据库 SQL 语句 * @return a ResultSet object that contains the data produced * by the given query; never null */ public ResultSet executeQuery(String sql) { try { Statement statement = getStatement(); ResultSet rs = statement.executeQuery(sql); this.getResourcesList().add(rs); this.getResourcesList().add(statement);// BUG fix at 2006-04-29 by BeanSoft, added this to res list // MySql 数据库要求必需关闭 statement 对象, 否则释放不掉资源 // - 此观点错误, 因为关闭此对象后有时数据无法读出 //statement.close(); return rs; } catch (Exception ex) { System.out.println("Error in executeQuery(\"" + sql + "\"):" + ex); // ex.printStackTrace(); return null; } } /** * Executes the given SQL statement, which may be an INSERT, * UPDATE, or DELETE statement or an SQL * statement that returns nothing, such as an SQL DDL statement. 执行给定的 SQL * 语句, 这些语句可能是 INSERT, UPDATE 或者 DELETE 语句, 或者是一个不返回任何东西的 SQL 语句, 例如一个 SQL * DDL 语句. * * @param sql * an SQL INSERT,UPDATE or * DELETE statement or an SQL statement that * returns nothing * @return either the row count for INSERT, * UPDATE or DELETE statements, or * 0 for SQL statements that return nothing */ public int executeUpdate(String sql) { try { Statement statement = getStatement(); return statement.executeUpdate(sql); // MySql 数据库要求必需关闭 statement 对象, 否则释放不掉资源 // - 此观点错误, 因为关闭此对象后有时数据无法读出 //statement.close(); } catch (Exception ex) { System.out.println("Error in executeUpdate(): " + sql + " " + ex); //System.out.println("executeUpdate:" + sql); ex.printStackTrace(); } return -1; } /** * 返回记录总数, 使用方法: getAllCount("SELECT count(ID) from tableName") 2004-06-09 * 可滚动的 Statement 不能执行 SELECT MAX(ID) 之类的查询语句(SQLServer 2000) * * @param sql * 需要执行的 SQL * @return 记录总数 */ public int getAllCount(String sql) { try { Statement statement = getConnection().createStatement(); this.getResourcesList().add(statement); ResultSet rs = statement.executeQuery(sql); rs.next(); int cnt = rs.getInt(1); rs.close(); try { statement.close(); this.getResourcesList().remove(statement); } catch (Exception ex) { ex.printStackTrace(); } return cnt; } catch (Exception ex) { System.out.println("Exception in DatabaseUtil.getAllCount(" + sql + "):" + ex); ex.printStackTrace(); return 0; } } /** * 返回当前数据库连接. */ public java.sql.Connection getConnection() { return connection; } /** * 连接新的数据库对象到这个工具类, 首先尝试关闭老连接. */ public void setConnection(java.sql.Connection connection) { if (this.connection != null) { try { getConnection().close(); } catch (Exception ex) { } } this.connection = connection; } /** * Create a common statement from the database connection and return it. * * @return Statement */ public Statement getStatement() { // 首先尝试获取可滚动的 Statement, 然后才是普通 Statement Statement updatableStmt = getUpdatableStatement(); if (updatableStmt != null) return updatableStmt; try { Statement statement = getConnection().createStatement(); this.getResourcesList().add(statement); return statement; } catch (Exception ex) { System.out.println("Error in getStatement(): " + ex); } return null; } /** * Create a updatable and scrollable statement from the database connection * and return it. * * @return Statement */ public Statement getUpdatableStatement() { try { Statement statement = getConnection() .createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); this.getResourcesList().add(statement); return statement; } catch (Exception ex) { System.out.println("Error in getUpdatableStatement(): " + ex); } return null; } /** * Create a prepared statement and return it. * * @param sql * String SQL to prepare * @throws SQLException * any database exception * @return PreparedStatement the prepared statement */ public PreparedStatement getPreparedStatement(String sql) throws SQLException { try { PreparedStatement preparedStatement = getConnection() .prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE); this.getResourcesList().add(preparedStatement); return preparedStatement; } catch (Exception ex) { ex.printStackTrace(); } return null; } /** * Return the resources list of this class. * * @return ArrayList the resources list */ public ArrayList getResourcesList() { return resourcesList; } /** * Fetch a string from the result set, and avoid return a null string. * * @param rs * the ResultSet * @param columnName * the column name * @return the fetched string */ public static String getString(ResultSet rs, String columnName) { try { String result = rs.getString(columnName); if (result == null) { result = ""; } return result; } catch (Exception ex) { } return ""; } /** * Get all the column labels * * @param resultSet * ResultSet * @return String[] */ public static String[] getColumns(ResultSet resultSet) { if (resultSet == null) { return null; } try { ResultSetMetaData metaData = resultSet.getMetaData(); int numberOfColumns = metaData.getColumnCount(); if (numberOfColumns <= 0) { return null; } String[] columns = new String[numberOfColumns]; //System.err.println("numberOfColumns=" + numberOfColumns); // Get the column names for (int column = 0; column < numberOfColumns; column++) { // System.out.print(metaData.getColumnLabel(column + 1) + "\t"); columns[column] = metaData.getColumnName(column + 1); } return columns; } catch (Exception ex) { ex.printStackTrace(); } return null; } /** * Get the row count of the result set. * * @param resultset * ResultSet * @throws SQLException * if a database access error occurs or the result set type is * TYPE_FORWARD_ONLY * @return int the row count * @since 1.2 */ public static int getRowCount(ResultSet resultset) throws SQLException { int row = 0; try { int currentRow = resultset.getRow(); // Remember old row position resultset.last(); row = resultset.getRow(); if (currentRow > 0) { resultset.absolute(row); } } catch (Exception ex) { ex.printStackTrace(); } return row; } /** * Get the column count of the result set. * * @param resultSet * ResultSet * @return int the column count */ public static int getColumnCount(ResultSet resultSet) { if (resultSet == null) { return 0; } try { ResultSetMetaData metaData = resultSet.getMetaData(); int numberOfColumns = metaData.getColumnCount(); return numberOfColumns; } catch (Exception ex) { ex.printStackTrace(); } return 0; } /** * Read one row's data from result set automatically and put the result it a * hashtable. Stored as "columnName" = "value", where value is converted to * String. * * @param resultSet * ResultSet * @return Hashtable */ public static final Hashtable readResultToHashtable(ResultSet resultSet) { if (resultSet == null) { return null; } Hashtable resultHash = new Hashtable(); try { String[] columns = getColumns(resultSet); if (columns != null) { // Read data column by column for (int i = 0; i < columns.length; i++) { resultHash.put(columns[i], getString(resultSet, columns[i])); } } } catch (Exception ex) { ex.printStackTrace(); } return resultHash; } /** * Read data from result set automatically and put the result it a * hashtable. Stored as "columnName" = "value", where value is converted to * String. * * Note: assume the default database string encoding is ISO8859-1. * * @param resultSet * ResultSet * @return Hashtable */ @SuppressWarnings("unchecked") public static final Hashtable readResultToHashtableISO(ResultSet resultSet) { if (resultSet == null) { return null; } Hashtable resultHash = new Hashtable(); try { String[] columns = getColumns(resultSet); if (columns != null) { // Read data column by column for (int i = 0; i < columns.length; i++) { String isoString = getString(resultSet, columns[i]); try { resultHash.put(columns[i], new String(isoString .getBytes("ISO8859-1"), "GBK")); } catch (Exception ex) { resultHash.put(columns[i], isoString); } } } } catch (Exception ex) { ex.printStackTrace(); } return resultHash; } /** Test this class. */ public static void main(String[] args) throws Exception { DatabaseUtil util = new DatabaseUtil(); // TODO: 从连接池工厂获取连接 // util.setConnection(ConnectionFactory.getConnection()); ResultSet rs = util.executeQuery("SELECT * FROM e_hyx_trans_info"); while (rs.next()) { Hashtable hash = readResultToHashtableISO(rs); Enumeration keys = hash.keys(); while (keys.hasMoreElements()) { Object key = keys.nextElement(); System.out.println(key + "=" + hash.get(key)); } } rs.close(); util.close(); } }
JAVA操作mysql工具类
03-25
http://blog.csdn.net/qqylc0011/article/details/44626729 是我的博客一个附件，包含自己封装的一个JAVA操作数据库类（mysql）。
JDBC数据库操作工具类
11-23
简单封装JDBC操作数据库，实现了增删改查和分页的操作，直接调用工具类方法即可，其中用到了Apache的beanUtils工具类。
java连接数据库（工具类的封装）
10-02
一个标准的连接数据库类的封装…………Mysql
Java工具集-数据库工具类
逍遥云恋
12-31 441
代码示例 package com.simple.util.config.database; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.ResultSet; import java.util.ArrayList; imp...
java数据库常用工具类_java 数据库常用工具类
weixin_33417488的博客
02-26 250
java 数据库常用工具类在开发中遇到了如果该表调用次数少有的时候整个项目就会调用一次如果这样我们在去创一个Mapper类当Mapper类越来越多该项目看起来是不是太过于臃肿了。所以封装了该类的来进行常用sql语句的调用和分页等功能。希望各位能多多指教该方法主要是用来对参数进行调用拼接@Servicepublic class NrrsSuperDao {@AutowiredINrrsSuper i...
java数据库操作--改写成工具类
l-jobs的专栏
12-01 332
改写成工具类 我们发现连接和释放数据库的代码在进行数据库操作时用的很多，所以我们将连接数据库的方法写成一个工具类，方便调用我们希望能在配置文件中设置数据库连接参数，如果我们的数据库更改了，或者用户名和密码更改了，我们不用修改代码，修改配置文件就好了JdbcUtils.java package com.qiaolei; import java.io.IOException; import
Java.Mysql数据库自定义工具类
最新发布
Garson的博客
09-17 527
Java.Mysql数据库自定义工具类
"Java数据库操作管理工具文档总结
Java数据库通用操作类是一个用于进行数据库操作的通用类。它提供了许多方法来执行各种数据库操作，包括查询、插入、更新和删除等。该类是通过Java提供的一些数据库相关的API来实现的。 该类的实现方式是通过建立与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值