`
dh189
  • 浏览: 135354 次
  • 性别: Icon_minigender_2
  • 来自: 上海
社区版块
存档分类
最新评论

JDBC使用工具类

    博客分类:
  • java
阅读更多
连接池使用DBCP,代码如下:
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

import java.sql.SQLException;
import java.sql.Connection;
import java.util.Properties;

public class ConnectionSource {

    private static BasicDataSource dataSource = null;

    private final static String connUrl1 = "jdbc:mysql://localhost:3306/directory?useUnicode=true&characterEncoding=UTF-8";

    private final static String connUrl2 = "";

    private static String connUrl = "";

    private static boolean connBool = false;

    private final static String userName = "root";

    private final static String password = "root";

    public static void init(String connUrl) {

        if (dataSource != null) {
            try {
                dataSource.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            dataSource = null;
        }
        try {
            Properties p = new Properties();
            p.setProperty("driverClassName", "com.mysql.jdbc.Driver");
            p.setProperty("url", connUrl);
            p.setProperty("username", userName);
            p.setProperty("password", password);
            // 初始化连接
            p.setProperty("initialSize", "20");
            // 最大连接数量
            p.setProperty("maxActive", "200");
            // 最大空闲连接
            p.setProperty("maxIdle", "20");
            // maxWait的时间不要设得太长
            p.setProperty("maxWait", "1000");
            // 是否自动回收超时连接
            p.setProperty("removeAbandoned", "true");
            // 超时时间(以秒数为单位)
            p.setProperty("removeAbandonedTimeout", "120");
            p.setProperty("testOnBorrow", "true");
            // 是否在自动回收超时连接的时候打印连接的超时错误
            p.setProperty("logAbandoned", "true");
            dataSource = (BasicDataSource) BasicDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static synchronized Connection getConn() throws SQLException {
        if (dataSource == null) {
            init(connUrl);
        }
        Connection conn = null;
        if (dataSource != null) {
            conn = dataSource.getConnection();
        }
        return conn;
    }

    public static synchronized Connection getConnection() {
        if (!connBool) {
            connUrl = connUrl1;
        } else {
            connUrl = connUrl2;
        }
        Connection conn = null;
        try {
            conn = getConn();
        } catch (SQLException e) {
        }
        if (conn == null) {
            connBool = true;
            dataSource = null;
            connUrl = connUrl2;
            try {
                conn = getConn();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return conn;
    }
    
    public static void main(String[] args) {
        ConnectionSource.getConnection();
    }
}


工具类JDBCUtils.java

import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 数据库操作工具类
 * 
 * @author ZZJ
 */
public class JDBCUtils {

    /**
     * 执行查询
     * 
     * @param sql
     * @param pams like aa,bb,cc
     * @return
     */
    public static List<Map<String, Object>> getObjects(String sql, String pams) {
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>(0);
        Connection conn = null;
        String[] ps = pams.split(",");
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            conn = ConnectionSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            rs = pstmt.executeQuery();
            while (rs.next()) {
                Map<String, Object> map = new LinkedHashMap<String, Object>(0);
                for (int i = 0; i < ps.length; i++) {
                    if (rs.getObject(ps[i]) instanceof Clob) {
                        map.put(ps[i], rs.getString(ps[i]));
                    } else {
                        map.put(ps[i], rs.getObject(ps[i]));
                    }
                }
                list.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                rs.close();
                pstmt.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return list;
    }

    /**
     * 查询数量
     * 
     * @param sql like select count(id) as c from table
     * @return
     */
    public static int getCount(String sql) {
        List<Map<String, Object>> list = getObjects(sql, "c");
        if (list.size() > 0) {
            Map<String, Object> m = list.get(0);
            return ((Long) m.get("c")).intValue();
        }
        return 0;
    }

    /**
     * 查询数量
     * 
     * @param table
     * @return
     */
    public static int getCountByTable(String table) {
        String sql = "select count(id) as c from " + table;
        List<Map<String, Object>> list = getObjects(sql, "c");
        if (list.size() > 0) {
            Map<String, Object> m = list.get(0);
            return ((Long) m.get("c")).intValue();
        }
        return 0;
    }

    /**
     * 
     * @param table
     * @param id
     * @return
     */
    public synchronized static boolean excuteDelete(String table, Integer id) {
        String sql = "delete from " + table + " where id=" + id;
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = ConnectionSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.execute();
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            try {
                pstmt.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    /**
     * 执行更新语句
     * 
     * @param sql
     * @return
     */
    public synchronized static boolean excuteUpdate(String sql) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = ConnectionSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            try {
                pstmt.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    /**
     * 执行更新语句
     * 
     * @param table 表名
     * @param map 数据对
     * @param id 数据ID
     * @return
     */
    public synchronized static boolean excuteUpdate(String table, Map<String, Object> map, Integer id) {
        Set<Map.Entry<String, Object>> sets = map.entrySet();
        String fields = "";
        Iterator<Map.Entry<String, Object>> iterator = sets.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Object> entry = iterator.next();
            fields += entry.getKey() + "=?,";
        }
        if (fields.endsWith(",")) {
            fields = fields.substring(0, fields.length() - 1);
        }
        String sql = "update " + table + " set " + fields + " where id=" + id;
        PreparedStatement pstmt = null;
        Connection conn = null;
        try {
            conn = ConnectionSource.getConnection();
            pstmt = conn.prepareStatement(sql);
            iterator = sets.iterator();
            int index = 1;
            while (iterator.hasNext()) {
                Map.Entry<String, Object> entry = iterator.next();
                pstmt.setObject(index, entry.getValue());
                index++;
            }
            pstmt.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                pstmt.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    /**
     * 执行插入数据操作,返回该条的数据的ID
     * 
     * @param table
     * @param seq
     * @param map
     * @return
     * @throws SQLException
     */
    public static int excuteInsert(String table, Map<String, Object> map) throws SQLException {
        Set<Map.Entry<String, Object>> sets = map.entrySet();
        String fields = "";
        String values = "";
        Iterator<Map.Entry<String, Object>> iterator = sets.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Object> entry = iterator.next();
            fields += entry.getKey() + ",";
            values += "?,";
        }
        if (fields.endsWith(",")) {
            fields = fields.substring(0, fields.length() - 1);
            values = values.substring(0, values.length() - 1);
        }
        StringBuffer sb = new StringBuffer(0);
        sb.append("insert into " + table + "(");
        sb.append(fields + ")");
        sb.append(" values(");
        sb.append(values);
        sb.append(")");

        int id = 0;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        Connection conn = null;
        try {
            conn = ConnectionSource.getConnection();
            pstmt = conn.prepareStatement(sb.toString(), new String[] { "id" });
            iterator = sets.iterator();
            int index = 1;
            while (iterator.hasNext()) {
                Map.Entry<String, Object> entry = iterator.next();
                pstmt.setObject(index, entry.getValue());
                index++;
            }
            pstmt.execute();
            rs = pstmt.getGeneratedKeys();
            while (rs.next()) {
                id = rs.getInt(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (null != conn) {
                conn.rollback();
            }
        } finally {
            try {
                rs.close();
                pstmt.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return id;
    }
}
分享到:
评论

相关推荐

    jdbc连接mysql工具类

    下面将详细介绍如何使用Eclipse作为开发环境,通过编写一个JDBC工具类来连接MySQL数据库,并实现基本的增删改查功能。 首先,我们需要引入MySQL的JDBC驱动,也就是`mysql-connector.jar`。这个库文件包含了连接...

    JDBC封装的工具类

    JDBC封装的工具类,将所有共同的代码提取过来,形成工具类

    JDBC的工具类

    在实际开发中,为了提高代码的可重用性和减少重复性工作,我们通常会创建一个JDBC工具类,将数据库连接、关闭资源等操作封装起来。以下是一个关于JDBC工具类的详细解释。 1. **JDBC工具类的作用** - 提高代码的可...

    SpringBoot中封装jdbc工具类

    现在的数据层的开发,大多会使用如MyBatis或...由于部分场景下MyBatis或JPA之类无法满足我的需求,所以我打算自己封装一套查数据库的工具类。 文章地址: https://blog.csdn.net/lxyoucan/article/details/124042295

    jdbc封装工具类

    jdbc封装工具类,此类事封装成list,Object&gt;&gt;格式,可直接把转换为jsonArray格式传输数据。

    Oracle jdbc 单例 工具类

    Oracle JDBC工具类是一种常见的设计模式应用,用于简化与Oracle数据库的交互。在Java编程中,JDBC(Java Database Connectivity)是连接Java应用程序和各种数据库的标准接口。Oracle JDBC驱动程序是Oracle公司提供的...

    JDBC连接数据库工具类

    JDBC连接数据库工具类 JDBC 连接数据库 ORACLE SQLSERVER MYSQL ORACLE 已测 OK 欢迎大家反馈 我的微博是: http://weibo.com/namenode

    JDBC链接Oracle数据库增删改查通用工具类

    标题中的“JDBC链接Oracle数据库增删改查通用工具类”指的是一个Java编程中的实用工具类,它封装了与Oracle数据库交互的JDBC操作,包括插入(Insert)、删除(Delete)、更新(Update)和查询(Select)这四种基本...

    java连接SqlServer完整代码,工具类,jdbc

    JDBC工具类的构建 1.资源释放 见https://mp.csdn.net/postedit/86577443 2.驱动防二次注册 ``` Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); //Driver是静态代码块,类加载了就执行,用...

    JDBC工具类

    - 在JDBC工具类中,可以提供开始事务、提交事务和回滚事务的方法,方便开发者在业务逻辑中使用。 5. **异常处理** - 封装的工具类应该处理可能出现的异常,例如`SQLException`,并根据需要转换为更具体的业务异常...

    jdbc工具类

    在本篇文章中,我们将深入探讨JDBC工具类的核心概念、主要功能以及如何使用它来连接和操作MySQL数据库。 1. **JDBC基础** JDBC提供了一组标准接口和类,使得Java开发者能够通过统一的方式与各种关系型数据库进行...

    JDBC工具类(针对mySQL)

    1、JDBCUtil(JDBC工具类) 这里封装了Java与数据库建立连接,执行查询或更新语句,释放链接等基本方法,并使用连接池实现mySql高效率执行查询更新的功能。 2、SQLUtil(SQL语句工具类) 对基本SQL语句进行了...

    功能强大的JDBC工具类

    此JDBC工具类功能强大,不仅支持查询,还可支持批量操作指定的SQL

    jdbc经典工具类

    1. **JDBC工具类**:JDBC工具类通常封装了数据库连接、预编译SQL语句、执行SQL、关闭资源等常见操作,以减少重复代码,提升开发效率。`connJdbcUtil`可能是一个实现了这些功能的Java类。 2. **数据库连接配置**:...

    spring的jdbc工具类

    spring的jdbc工具类,对数据库的操作,对数据库进行增删改查的操作

    jdbc连接oracle工具类

    本篇文章将详细讲解如何创建一个JDBC连接Oracle的工具类,以及在实际应用中需要注意的事项。 首先,我们需要了解JDBC的基本概念。JDBC是Java与数据库交互的一组接口和类,它允许Java程序通过SQL语句来操作数据库。...

    JDBC的工具类(c3p0连接池,DBUtils)

    本资源是JDBC的工具类,使用时要导入c3p0的工具包和mysql的驱动包和对应的配置文件

    JDBC非常实用的工具类

    对于初学者来说,使用JDBC工具类可以大大简化数据库操作,避免重复编写连接、关闭等代码,提升代码的可读性和可维护性。在实际开发中,有很多开源的JDBC工具类库,如Apache的DBUtils和MyBatis的SqlSession,它们已经...

    JDBC简单地工具类.rar

    7. **JDBC工具类设计** 为了简化JDBC操作,通常会封装一个工具类,将上述步骤整合成便捷的方法。这个资源中的"JDBC简单地工具类"可能就实现了这样的功能,提供如`queryBySql()`, `executeUpdateBySql()`等方法,...

Global site tag (gtag.js) - Google Analytics