简易高重用的jdbcutils工具封装实现类以及简易连接池实现

华为OD机试双机位C卷-流水线(Py/Java/C/C++/Js/Go) 华为OD机试双机位C卷 流水线,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解。华为OD机试 - 流水线。 阅读详情

     由于现在发现做个小项目都是导入n多的依赖包,很烦琐,只想快点开发完一个个的小需求项目,这个时候真心不想用框架,只能自己写个jdbcutils,虽然网上有很多有apache的,阿里的,但是感觉用过后都不怎么顺手,然后自己花了点时间写个新的,不喜勿喷


1.我们要写个resultset集合转成bean的回调接口,这个用过spring jdbc的人都知道这玩意

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package org.simple.mvc.jdbc.bean;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5.   
  6. public interface RowMapper<T> {  
  7.   
  8.     public abstract T mapRow(ResultSet rs) throws SQLException;  
  9.   
  10. }  


2.先来个基本的jdbc操作接口吧,这样好规范点

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package org.simple.mvc.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.sql.Statement;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10.   
  11. import javax.sql.DataSource;  
  12.   
  13. import org.simple.mvc.jdbc.bean.RowMapper;  
  14.   
  15. public interface JdbcOperation {  
  16.   
  17.     /** 
  18.      * update或delete功能 
  19.      *  
  20.      * @param sql 
  21.      * @param params 
  22.      * @return 变更记录数 
  23.      * @throws SQLException 
  24.      */  
  25.     public abstract int execute(String sql, Object[] params) throws SQLException;  
  26.   
  27.     /** 
  28.      * update或delete功能 
  29.      *  
  30.      * @param sql 
  31.      * @return 变更记录数 
  32.      * @throws SQLException 
  33.      */  
  34.     public abstract int execute(String sql) throws SQLException;  
  35.   
  36.     /** 
  37.      * 批处理update或delete功能 
  38.      *  
  39.      * @param sql 
  40.      * @param params 
  41.      * @return 变更记录数 
  42.      * @throws SQLException 
  43.      */  
  44.     public abstract int executeBatch(String sql, List<Object[]> params) throws SQLException;  
  45.   
  46.     /** 
  47.      * 批处理update或delete功能 
  48.      *  
  49.      * @param sql 
  50.      * @param params 
  51.      * @return 变更记录数 
  52.      * @throws SQLException 
  53.      */  
  54.     public abstract int executeBatch(String sql) throws SQLException;  
  55.   
  56.     /** 
  57.      * select功能 
  58.      *  
  59.      * @param sql 
  60.      * @param params 
  61.      * @return 原生ResultSet数据集合 
  62.      * @throws SQLException 
  63.      */  
  64.     public abstract ResultSet queryForResultSet(String sql, Object[] params) throws SQLException;  
  65.   
  66.     /** 
  67.      * select功能 
  68.      *  
  69.      * @param sql 
  70.      * @return 原生ResultSet数据集合 
  71.      * @throws SQLException 
  72.      */  
  73.     public abstract ResultSet queryForResultSet(String sql) throws SQLException;  
  74.   
  75.     /** 
  76.      * select功能 
  77.      *  
  78.      * @param sql 
  79.      * @param params 
  80.      * @return List<?>数据集合 
  81.      * @throws SQLException 
  82.      */  
  83.     public abstract List<?> queryForBean(String sql, Object[] params, RowMapper<?> mapper) throws SQLException;  
  84.   
  85.     /** 
  86.      * select功能 
  87.      *  
  88.      * @param sql 
  89.      * @param params 
  90.      * @return List<?>数据集合 
  91.      * @throws SQLException 
  92.      */  
  93.     public abstract List<?> queryForBean(String sql, RowMapper<?> mapper) throws SQLException;  
  94.   
  95.     /** 
  96.      * select功能 
  97.      *  
  98.      * @param sql 
  99.      * @param params 
  100.      * @return List<Map<String, Object>>数据集合 
  101.      * @throws SQLException 
  102.      */  
  103.     public abstract List<Map<String, Object>> queryForMap(String sql, Object[] params) throws SQLException;  
  104.   
  105.     /** 
  106.      * select功能 
  107.      *  
  108.      * @param sql 
  109.      * @param params 
  110.      * @return List<Map<String, Object>>数据集合 
  111.      * @throws SQLException 
  112.      */  
  113.     public abstract List<Map<String, Object>> queryForMap(String sql) throws SQLException;  
  114.   
  115.     /** 
  116.      * select功能 
  117.      *  
  118.      * @param sql 
  119.      * @return 统计单列记录数 
  120.      * @throws SQLException 
  121.      */  
  122.     public abstract int queryForInt(String sql, Object[] params) throws SQLException;  
  123.   
  124.     /** 
  125.      * select功能 
  126.      *  
  127.      * @param sql 
  128.      * @return 统计单列记录数 
  129.      * @throws SQLException 
  130.      */  
  131.     public abstract int queryForInt(String sql) throws SQLException;  
  132.   
  133.     /** 
  134.      * 释放Connection资源 
  135.      *  
  136.      * @param x 
  137.      */  
  138.     public abstract void free(Connection x);  
  139.   
  140.     /** 
  141.      * 释放Statement资源 
  142.      *  
  143.      * @param x 
  144.      */  
  145.     public abstract void free(Statement x);  
  146.   
  147.     /** 
  148.      * 释放PreparedStatement资源 
  149.      *  
  150.      * @param x 
  151.      */  
  152.     public abstract void free(PreparedStatement x);  
  153.   
  154.     /** 
  155.      * 释放ResultSet资源 
  156.      *  
  157.      * @param x 
  158.      */  
  159.     public abstract void free(ResultSet x);  
  160.   
  161.     /** 
  162.      * 设置数据源 
  163.      *  
  164.      * @param dataSource 
  165.      */  
  166.     public abstract void setDataSource(DataSource dataSource);  
  167.   
  168.     /** 
  169.      * 获取数据库链接 
  170.      *  
  171.      * @return Connection 
  172.      */  
  173.     public abstract Connection getConnection();  
  174.   
  175.     /** 
  176.      * 获取数据库链接 
  177.      *  
  178.      * @param autoCommit 
  179.      * @return Connection 
  180.      */  
  181.     public Connection getConnection(boolean autoCommit);  
  182.   
  183. }  



3.实现我们接口里面的方法

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package org.simple.mvc.jdbc.impl;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.ResultSetMetaData;  
  7. import java.sql.SQLException;  
  8. import java.sql.Statement;  
  9. import java.util.ArrayList;  
  10. import java.util.HashMap;  
  11. import java.util.List;  
  12. import java.util.Map;  
  13.   
  14. import javax.sql.DataSource;  
  15.   
  16. import org.simple.mvc.jdbc.JdbcOperation;  
  17. import org.simple.mvc.jdbc.bean.RowMapper;  
  18.   
  19. /** 
  20.  * 简易JDBC实现类 
  21.  *  
  22.  * @author shadow 
  23.  *  
  24.  */  
  25. public class SimpleJdbc implements JdbcOperation {  
  26.   
  27.     private static final boolean AUTO_COMMIT = true;  
  28.   
  29.     private DataSource dataSource;  
  30.   
  31.     public SimpleJdbc() {  
  32.   
  33.     }  
  34.   
  35.     public SimpleJdbc(DataSource dataSource) {  
  36.         this.dataSource = dataSource;  
  37.     }  
  38.   
  39.     public Connection getConnection() {  
  40.         return getConnection(AUTO_COMMIT);  
  41.     }  
  42.   
  43.     public Connection getConnection(boolean autoCommit) {  
  44.         try {  
  45.             Connection conn = dataSource.getConnection();  
  46.             if (!autoCommit)  
  47.                 conn.setAutoCommit(autoCommit);  
  48.             return conn;  
  49.         } catch (SQLException e) {  
  50.             e.printStackTrace();  
  51.         }  
  52.         return null;  
  53.     }  
  54.   
  55.     @Override  
  56.     public int execute(String sql, Object[] params) throws SQLException {  
  57.         Connection conn = getConnection(false);  
  58.         PreparedStatement stmt = null;  
  59.         int result = -1;  
  60.         try {  
  61.             stmt = createPreparedStatement(conn, sql, params);  
  62.             result = stmt.executeUpdate();  
  63.             conn.commit();  
  64.         } catch (Exception e) {  
  65.             conn.rollback();  
  66.             e.printStackTrace();  
  67.         } finally {  
  68.             free(stmt);  
  69.             free(conn);  
  70.         }  
  71.         return result;  
  72.     }  
  73.   
  74.     @Override  
  75.     public int execute(String sql) throws SQLException {  
  76.         return execute(sql, new Object[] {});  
  77.     }  
  78.   
  79.     @Override  
  80.     public ResultSet queryForResultSet(String sql, Object[] params) throws SQLException {  
  81.         Connection conn = getConnection();  
  82.         PreparedStatement stmt = null;  
  83.         try {  
  84.             stmt = createPreparedStatement(conn, sql, params);  
  85.             return stmt.executeQuery();  
  86.         } catch (Exception e) {  
  87.             e.printStackTrace();  
  88.         } finally {  
  89.             free(stmt);  
  90.             free(conn);  
  91.         }  
  92.         return null;  
  93.     }  
  94.   
  95.     @Override  
  96.     public ResultSet queryForResultSet(String sql) throws SQLException {  
  97.         return queryForResultSet(sql, new Object[] {});  
  98.     }  
  99.   
  100.     @Override  
  101.     public int queryForInt(String sql, Object[] params) throws SQLException {  
  102.         Connection conn = getConnection();  
  103.         PreparedStatement stmt = null;  
  104.         ResultSet rs = null;  
  105.         try {  
  106.             stmt = createPreparedStatement(conn, sql, params);  
  107.             rs = createResultSet(stmt);  
  108.             while (rs.next()) {  
  109.                 return rs.getInt(1);  
  110.             }  
  111.         } catch (Exception e) {  
  112.             e.printStackTrace();  
  113.         } finally {  
  114.             free(rs);  
  115.             free(stmt);  
  116.             free(conn);  
  117.         }  
  118.         return 0;  
  119.     }  
  120.   
  121.     @Override  
  122.     public int queryForInt(String sql) throws SQLException {  
  123.         return queryForInt(sql, new Object[] {});  
  124.     }  
  125.   
  126.     @Override  
  127.     public List<?> queryForBean(String sql, Object[] params, RowMapper<?> mapper) throws SQLException {  
  128.         Connection conn = getConnection();  
  129.         PreparedStatement stmt = null;  
  130.         ResultSet rs = null;  
  131.         List<Object> list = null;  
  132.         try {  
  133.             stmt = createPreparedStatement(conn, sql, params);  
  134.             rs = createResultSet(stmt);  
  135.             list = new ArrayList<Object>();  
  136.             while (rs.next()) {  
  137.                 list.add(mapper.mapRow(rs));  
  138.             }  
  139.         } catch (Exception e) {  
  140.             e.printStackTrace();  
  141.         } finally {  
  142.             free(rs);  
  143.             free(stmt);  
  144.             free(conn);  
  145.         }  
  146.         return list;  
  147.     }  
  148.   
  149.     @Override  
  150.     public List<?> queryForBean(String sql, RowMapper<?> mapper) throws SQLException {  
  151.         return queryForBean(sql, new Object[] {}, mapper);  
  152.     }  
  153.   
  154.     @Override  
  155.     public List<Map<String, Object>> queryForMap(String sql, Object[] params) throws SQLException {  
  156.         Connection conn = getConnection();  
  157.         PreparedStatement stmt = null;  
  158.         ResultSet rs = null;  
  159.         try {  
  160.             stmt = createPreparedStatement(conn, sql, params);  
  161.             rs = createResultSet(stmt);  
  162.   
  163.             List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  164.             Map<String, Object> map = null;  
  165.             ResultSetMetaData rsd = rs.getMetaData();  
  166.             int columnCount = rsd.getColumnCount();  
  167.   
  168.             while (rs.next()) {  
  169.                 map = new HashMap<String, Object>(columnCount);  
  170.                 for (int i = 1; i < columnCount; i++) {  
  171.                     map.put(rsd.getColumnName(i), rs.getObject(i));  
  172.                 }  
  173.                 list.add(map);  
  174.             }  
  175.   
  176.             return list;  
  177.         } catch (Exception e) {  
  178.             e.printStackTrace();  
  179.         } finally {  
  180.             free(rs);  
  181.             free(stmt);  
  182.             free(conn);  
  183.         }  
  184.         return null;  
  185.     }  
  186.   
  187.     @Override  
  188.     public List<Map<String, Object>> queryForMap(String sql) throws SQLException {  
  189.         return queryForMap(sql, new Object[] {});  
  190.     }  
  191.   
  192.     @Override  
  193.     public int executeBatch(String sql, List<Object[]> params) throws SQLException {  
  194.         int result = 0;  
  195.         Connection conn = getConnection(false);  
  196.         PreparedStatement stmt = null;  
  197.         try {  
  198.             stmt = conn.prepareStatement(sql);  
  199.             for (int i = 0; i < params.size(); i++) {  
  200.                 Object[] param = params.get(i);  
  201.                 for (int j = 0; j < param.length; j++)  
  202.                     stmt.setObject(j + 1, param[j]);  
  203.                 stmt.addBatch();  
  204.                 if (i % 1000 == 0) {  
  205.                     stmt.executeBatch();  
  206.                     stmt.clearBatch();  
  207.                 }  
  208.             }  
  209.             stmt.executeBatch();  
  210.             conn.commit();  
  211.             result = params.size();  
  212.         } catch (Exception e) {  
  213.             conn.rollback();  
  214.             e.printStackTrace();  
  215.         } finally {  
  216.             free(stmt);  
  217.             free(conn);  
  218.         }  
  219.         return result;  
  220.     }  
  221.   
  222.     @Override  
  223.     public int executeBatch(String sql) throws SQLException {  
  224.         return executeBatch(sql, new ArrayList<Object[]>());  
  225.     }  
  226.   
  227.     public DataSource getDataSource() {  
  228.         return dataSource;  
  229.     }  
  230.   
  231.     public void setDataSource(DataSource dataSource) {  
  232.         this.dataSource = dataSource;  
  233.     }  
  234.   
  235.     @Override  
  236.     public void free(Connection x) {  
  237.         if (x != null)  
  238.             try {  
  239.                 x.close();  
  240.             } catch (SQLException e) {  
  241.                 e.printStackTrace();  
  242.             }  
  243.     }  
  244.   
  245.     @Override  
  246.     public void free(Statement x) {  
  247.         if (x != null)  
  248.             try {  
  249.                 x.close();  
  250.             } catch (SQLException e) {  
  251.                 e.printStackTrace();  
  252.             }  
  253.     }  
  254.   
  255.     @Override  
  256.     public void free(PreparedStatement x) {  
  257.         if (x != null)  
  258.             try {  
  259.                 x.close();  
  260.             } catch (SQLException e) {  
  261.                 e.printStackTrace();  
  262.             }  
  263.     }  
  264.   
  265.     @Override  
  266.     public void free(ResultSet x) {  
  267.         if (x != null)  
  268.             try {  
  269.                 x.close();  
  270.             } catch (SQLException e) {  
  271.                 e.printStackTrace();  
  272.             }  
  273.     }  
  274.   
  275.     public PreparedStatement createPreparedStatement(Connection conn, String sql, Object[] params) throws SQLException {  
  276.         PreparedStatement stmt = conn.prepareStatement(sql);  
  277.         for (int i = 0; i < params.length; i++)  
  278.             stmt.setObject(i + 1, params[i]);  
  279.         return stmt;  
  280.     }  
  281.   
  282.     public ResultSet createResultSet(PreparedStatement stmt) throws SQLException {  
  283.         return stmt.executeQuery();  
  284.     }  
  285. }  





4.然后实现我们一个连接池吧,不喜欢dbcp,c3p0的话,那些要依赖包的导致项目重量上去了

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package org.simple.mvc.jdbc.source;  
  2.   
  3. import java.io.PrintWriter;  
  4. import java.lang.reflect.InvocationHandler;  
  5. import java.lang.reflect.Method;  
  6. import java.lang.reflect.Proxy;  
  7. import java.sql.Connection;  
  8. import java.sql.DriverManager;  
  9. import java.sql.SQLException;  
  10. import java.util.LinkedList;  
  11.   
  12. import javax.sql.DataSource;  
  13.   
  14. /** 
  15.  * 简易连接池实现类 
  16.  *  
  17.  * @author shadow 
  18.  *  
  19.  */  
  20. public class SimpleDataSource implements DataSource {  
  21.   
  22.     private int poolSize = 5;  
  23.   
  24.     private LinkedList<Connection> pool = new LinkedList<Connection>();  
  25.   
  26.     public SimpleDataSource(String driver, String url, String name, String pwd) {  
  27.         this(driver, url, name, pwd, 5);  
  28.     }  
  29.   
  30.     public SimpleDataSource(String driver, String url) {  
  31.         this(driver, url, "", "", 5);  
  32.     }  
  33.   
  34.     public SimpleDataSource(String driver, String url, String name, String pwd, int poolSize) {  
  35.         try {  
  36.             Class.forName(driver);  
  37.             this.poolSize = poolSize;  
  38.             if (poolSize <= 0) {  
  39.                 throw new RuntimeException("初始化池大小失败: " + poolSize);  
  40.             }  
  41.   
  42.             for (int i = 0; i < poolSize; i++) {  
  43.                 Connection con = DriverManager.getConnection(url, name, pwd);  
  44.                 con = ConnectionProxy.getProxy(con, pool);// 获取被代理的对象  
  45.                 pool.add(con);// 添加被代理的对象  
  46.             }  
  47.         } catch (Exception e) {  
  48.             throw new RuntimeException(e.getMessage(), e);  
  49.         }  
  50.   
  51.     }  
  52.   
  53.     /** 获取池大小 */  
  54.     public int getPoolSize() {  
  55.         return poolSize;  
  56.   
  57.     }  
  58.   
  59.     /** 不支持日志操作 */  
  60.     public PrintWriter getLogWriter() throws SQLException {  
  61.         throw new RuntimeException("Unsupport Operation.");  
  62.     }  
  63.   
  64.     public void setLogWriter(PrintWriter out) throws SQLException {  
  65.         throw new RuntimeException("Unsupport operation.");  
  66.     }  
  67.   
  68.     /** 不支持超时操作 */  
  69.     public void setLoginTimeout(int seconds) throws SQLException {  
  70.         throw new RuntimeException("Unsupport operation.");  
  71.     }  
  72.   
  73.     public int getLoginTimeout() throws SQLException {  
  74.         return 0;  
  75.     }  
  76.   
  77.     @SuppressWarnings("unchecked")  
  78.     public <T> T unwrap(Class<T> iface) throws SQLException {  
  79.         return (T) this;  
  80.     }  
  81.   
  82.     public boolean isWrapperFor(Class<?> iface) throws SQLException {  
  83.         return DataSource.class.equals(iface);  
  84.     }  
  85.   
  86.     /** 从池中取一个连接对象,使用了同步和线程调度 */  
  87.     public Connection getConnection() throws SQLException {  
  88.         synchronized (pool) {  
  89.             if (pool.size() == 0) {  
  90.                 try {  
  91.                     pool.wait();  
  92.                 } catch (InterruptedException e) {  
  93.                     throw new RuntimeException(e.getMessage(), e);  
  94.                 }  
  95.                 return getConnection();  
  96.             } else {  
  97.                 return pool.removeFirst();  
  98.             }  
  99.         }  
  100.     }  
  101.   
  102.     public Connection getConnection(String username, String password) throws SQLException {  
  103.         throw new RuntimeException("不支持接收用户名和密码的操作");  
  104.     }  
  105.   
  106.     /** 实现对Connection的动态代理 */  
  107.     static class ConnectionProxy implements InvocationHandler {  
  108.   
  109.         private Object obj;  
  110.         private LinkedList<Connection> pool;  
  111.   
  112.         private ConnectionProxy(Object obj, LinkedList<Connection> pool) {  
  113.             this.obj = obj;  
  114.             this.pool = pool;  
  115.         }  
  116.   
  117.         public static Connection getProxy(Object o, LinkedList<Connection> pool) {  
  118.             Object proxed = Proxy.newProxyInstance(o.getClass().getClassLoader(), new Class[] { Connection.class },  
  119.                     new ConnectionProxy(o, pool));  
  120.             return (Connection) proxed;  
  121.         }  
  122.   
  123.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  124.             if (method.getName().equals("close")) {  
  125.                 synchronized (pool) {  
  126.                     pool.add((Connection) proxy);  
  127.                     pool.notify();  
  128.                 }  
  129.                 return null;  
  130.             } else {  
  131.                 return method.invoke(obj, args);  
  132.             }  
  133.         }  
  134.   
  135.     }  
  136.   
  137. }  




5.开始测试下我们刚刚写的玩意,simplejdbc主要是有datasource提供给他就可以了,其他的一律无视,测试里面的user对象我就不提供,里面就是两个属性,id和username,然后生成set和get方法即可,当然这个是演示resultset转成bean的,当然也可以直接使用queryForMap直接查询出map集合,我想接口提供的方法已经足够使用了

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static void main(String[] args) throws SQLException {  
  2.         SimpleDataSource dataSource = new SimpleDataSource("org.sqlite.JDBC", "jdbc:sqlite:/E:p1010.db");  
  3.         SimpleJdbc jdbc = new SimpleJdbc(dataSource);  
  4.         List<User> list = (List<User>) jdbc.queryForBean("select * from t_user", new RowMapper<User>() {  
  5.             User user = null;  
  6.   
  7.             @Override  
  8.             public User mapRow(ResultSet rs) throws SQLException {  
  9.                 user = new User();  
  10.                 user.setId(rs.getInt("id"));  
  11.                 user.setUsername(rs.getString("username"));  
  12.                 return user;  
  13.             }  
  14.         });  
  15.         for (User user : list) {  
  16.             System.out.println(user.getId() + "---" + user.getUsername());  
  17.         }  
  18.     }  
淋巴结病理数字玻片读取与处理代码 Whole-slide images are generally stored in a multi-resolution pyramid structure. 首先安装openslide模块 pip install openslide-python import os.path as osp import openslide from pathlib import Path... 阅读详情

相关推荐

海康威视HiTools实战:5分钟搞定工业镜头选型(附避坑指南)

本文详细解析了海康威视HiTools在工业镜头选型中的应用,通过五步操作流程帮助用户快速匹配适合的镜头型号。文章深入探讨了工业视觉系统的核心参数,包括焦距、视野、景深和畸变控制,并提供了光源搭配和系统集成的实战指南,助力提升机器视觉检测精度与效率。

u0v1w2x3的博客 1063

java 高性能dbutil_java学习笔记之DBUtils工具包

DBUtils工具包一.介绍DBUtils是Apache组织开源的数据库工具类。二.使用步骤①.创建QueryRunner对象②.调用update()方法或者query()方法执行sql语句三.构造方法及静态方法QueryRunner类1.构造方法①.无参构造QueryRunner qr =new QueryRunner();使用无参构造的时候,调用update方法和query方法时就需要使用带...

weixin_39639550的博客 234

Windows下用Docker快速搭建SearXNG私有搜索引擎(附Dify集成配置)

本文详细介绍了在Windows环境下使用Docker快速搭建SearXNG私有搜索引擎的完整流程,包括环境准备、容器化部署、安全配置优化以及与Dify平台的深度集成方法。通过分步指导和实用配置示例,帮助开发者构建兼具隐私保护和AI增强能力的本地化搜索解决方案,特别适合需要定制化搜索服务的应用场景。

weixin_30300225的博客 336

笔者带你剖析Apache Commons DbUtils 1.6

《笔者带你剖析Apache Commons DbUtils 1.6》   前言 关于Apache的DbUtils中间件或许了解的人并不多,大部分开发人员在生成环境中更多的是依靠Hibernate、Ibatis、Spring JDBC、JPA等大厂提供的持久层技术解决方案,或者是企业内部自己研发的持久层技术。但无论如何,使用这些技术的初衷和本质都是为了能够减少企业开发成本,提高生产效率...

gao_xianglong的自言自语 294

用Pixhawk 2.4.8和PX4 1.13,从零搭建你的第一支无人机编队(附避坑清单)

本文详细介绍了如何使用Pixhawk 2.4.8飞控和PX4 1.13固件从零搭建低成本无人机编队系统。涵盖硬件选型、固件配置、多机通信和编队飞行逻辑开发的全流程,特别针对学生和爱好者提供实战验证的避坑方案,帮助实现多机协同飞行。

weixin_27219587的博客 403

基于ensp大学网络规划与设计(完整文档+ensp拓扑图)

大家好,我是小华学长,一名计算机领域的博主。经过多年的学习和实践,我积累了丰富的计算机知识和经验,在这里我想与大家分享我的学习心得和技巧,帮助你成为更好的程序员。 作为一名计算机博主,我一直专注于编程、算法、软件开发等领域,在这些方面积累了大量的经验。我相信分享是一种双赢的方式,通过分享,我可以帮助他人提升技术水平,同时也能够得到学习交流的机会。 在我的文章中,你将会看到我对于各种编程语言、开发工具以及常见问题的解析和分析。我会结合自己的实际项目经验,为你提供实用的解决方案和优化技巧。我相信这些经验不仅能够

qq1325513482的博客 5万+

J2EE学习篇之--JDBC详解

今天我们来说一下关于JDBC的相关知识,关于JDBC我想大家都不陌生了,而且我记得早就开始使用它了,记得那是大二的时候做课程设计,但是那时候是为了完成任务,所以遇到问题就google,那时候也没有时间去整理,所以这次就来详细说一下关于JDBC的知识 摘要: JDBC(Java Data Base Connectivity,java数据库连接),由一些接口和类构成的API。 J2SE的一部分,...

810364804 346

解决RuntimeError: Couldn‘t load custom C++ ops. This can happen if your PyTorch

刚下好yolov8的代码,想测一下能否成果,果然没成功,报错如下简单来说就是torchvision和torch不匹配,就很离谱,我照着版本对应关系pip install的啊,怎么会不匹配建议先看看你的版本我是下图红框这个首先确定自己torch没问题,因为我的3090这个卡目前cuda版本是11.1,这个whl是早就下好的,一般1-2G,有问题重新下就麻烦了然后我pip install了很多次torchvision==0.11.3,都没啥用。想试着改改版本,结果要下其他的torch版本,就更不可能了。

DZY的博客 2248

工具类JdbcUtils

/* * * 这是一个工具类,一般工具类不能被继承,所以定义成final * * 不需要构造实例,用私有的构造方法 * 单例模式或者用static静态代码块, * 本例用static,没有实例 * */ package cn.itcast.jdbc;import java.sql.Connection; import java.sql.DriverManager; import

xiueer 4642

Office如何通过VSTO进行WORD插件开发?

VSTO(Visual Studio Tools for Office )是VBA的替代,是一套用于创建自定义Office应用程序的Visual Studio工具包。VSTO可以用Visual Basic 或者Visual C#扩展Office应用程序(例如Word、Excel、PPT)。本文通过VSTO进行Word插件开发总结,并进行记录。

【cacrle】的博客 7322

GPU硬件架构与微架构深度解析09-GPU寄存器文件深度解析

本文探讨GPU架构中大规模寄存器堆的设计与高效分配算法。寄存器文件作为GPU关键组件,支持大规模线程并行和快速数据存取。文章分析了多体寄存器堆的设计考量,包括端口数量、冲突避免和功耗管理,并比较了线性扫描、图着色等寄存器分配算法的特点。还介绍了寄存器压缩、动态分区等高级优化技术,以及NVIDIA Ampere架构的实际案例。这些技术对提升GPU计算性能和能效至关重要。

2301_79143213的博客 122

JDBC---DAO经典模式 实现对数据库的增、删、改、查

JDBC(Java Data Base Connection)的作用是连接数据库 先看下jdbc连接SQLServer数据库的简单例子 代码实现(FirstJDBC): package com.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet;...

247

【网络与爬虫 62】小程序爬虫终极攻略:微信支付宝小程序数据采集完全指南

本文深入解析微信和支付宝小程序的爬虫技术,从基础架构分析到高级逆向工程,涵盖WXML/AXML模板解析、API接口拦截、网络流量分析等核心技术。通过实战案例和代码示例,帮助开发者掌握小程序数据采集的完整技术栈。

熵数实验室 3421

Dao层设计思想、JdbcUtils类、数据库连接池技术

虽然抽出来两个方法使得我们在开发的时候代码的重复度降低,但是现在项目还存在一个问题,就是加载驱动和创建数据库连接都是我们直接写死的,但是这些字符串常量是有可能要修改的。所以我们就可以把这些字符串常量抽取出来存放在一个文件中,然后每次读取的时候从这个文件中读取数据,这样就很好的解决了可以单独修改连接条件。为了解决上面的问题,我们可以把建立连接和释放资源这两个方法封装到一个公共的工具类中JdbcUtils.这个类为所有dao类服务。1.dao类中的增删改查方法里面的代码的重复度非常高。

2401_85142240的博客 659

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

数据库连接池

  连接池是管理连接对象的,是依赖JDBC创建出来的连接Connection,然后管理它。 所以在以下示例中有的需要用到MySQL的驱动和连接池共同使用。 1.封装得到Connection对象 所需MySQL驱动:mysql-connector-java-5.1.7-bin.jar JdbcUtils.java: package cn.itcast.jdbc; import j...

weixin_30408165的博客 112

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

JDBC+JdbcUtils、QueryRunner +JdbcTemplate

JDBC JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统(DBMS)、通用的SQL数据库存取和操作的公共接口(一组API),定义了用来访问数据库的标准Java类库 jdbcUtils jdbcUtils是程序员自己编写的封装jdbc连接的工具,用来获取连接,释放连接;其中获取连接可以使用: 1.通过 DriverManager 来获取:(1)每次向数据库建立连接的时候都要将 Connection 加载到内存中,再验证IP地址,用户名和密码;数据..

xinyihhh的博客 681

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

设计自己的JDBCUtils工具类

设计自己的JDBCUtils工具类

WDreamIn的博客 315

JDBC工具类 : JDBCUtils

JDBC工具类 : JDBCUtils 工具类的作用:把一个通用的功能包装在一个类中,让它可以在不同的地方重用,这样子我们在编程时可以简化书写,避免重复太多代码。 例如,在引入数据库时,可以创建类 JdbcUtil ,功能就是引入数据库,让它可以在只修改数据库名的情况下就能在不同的项目中引用数据库,类中主要包含 3 个方法: 把用户名,密码,URL,驱动类定义成常量 2)连接数据库:getConnection() 关闭所有打开的资源: close(Connection 名1, Statement 名2,

weixin_48092545的博客 453

JDBC深度封装的工具类 (具有高度可重用性)

首先介绍一下Dbutils:     Common Dbutils是操作数据库的组件,对传统操作数据库的类进行二次封装,可以把结果集转化成List。   补充一下,传统操作数据库的类指的是JDBC(java database connection:java数据库连接,java的数据库操作的基础API。)。   DBUtils是java编程中的数据库操作实用工具,小巧简单实用。有兴趣的话可以到

H90P0820的专栏 852

Java封装JDBC通用工具类

Java封装JDBC通用工具类

小张的博客 597

mysql jdbc 封装类_【原创】JDBC基础之(三)封装JDBC通用工具类

JDBC基础之(三)封装JDBC通用工具类一、为何要封装JDBC通用工具类任何一个Java应用程序使用JDBC访问数据库时,都会按步骤来操作数据库:1、加载JDBC驱动程序2、建立Java程序与数据库之间的连接3、创建执行SQL命令的语句对象,并将SQL命令发送到数据库执行4、接收数据库执行SQL命令后返回的结果,并处理执行结果5、关闭Java程序与数据库之间的连接其间,每次执行SQL语句,都会反...

weixin_39640845的博客 285

关于DBUtils工具类的介绍与使用

关于DBUtils工具类的介绍与使用一、前言二、JDBC介绍1.JDBC基本概念2.JDBC操作数据的流程三、DBUtils介绍1.DBUtils基本概念2.DBUtils的特征四、JDBCutils工具类1.JDBCutils的介绍2.JDBCutils1.加载驱动及获取连接的方法2.获取执行SQL对象3.解析结果集4.释放资源五、总结 一、前言 本文是关于JDBCutils工具类使用方法的介绍 二、JDBC介绍 1.JDBC基本概念 JDBC全称为 Java数据库连接(Java Database Con

m0_46779736的博客 401

week7-Day5

1.数据库的连接池:德鲁伊Druid 连接池:创建一些固定的可重用的连接对象,当使用完成连接对象之后不会将对象真正归还到连接池,等待下一次继续去利用,可以重复使用; 传统方式:每一次都需要获取新的连接对象,操作数据库,释放连接;浪费资源; 早期 c3po--->有两种方式: 方式1:src下面提供配置文件 名称 必须是 c3p0-config.xml (配置数据库的信息) 方式2:src下面提供c3p0.properties dbcp ...

Reacher1111的博客 484
上一篇: JDBC轻量级封装的工具包Apache DbUtils使用教程
下一篇: JDBC连接oracle10g数据库-韩顺平SQLHelper类
codepython
博客等级 码龄20年 125粉丝 6原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值