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

    2018-09-20 12:02:27
    JDBC连接工具类,用于提供JDBC连接时所使用,第一次发表请多关照。
  • 1、JDBCUtil(JDBC工具类) 这里封装了Java与数据库建立连接,执行查询或更新语句,释放链接等基本方法,并使用连接池实现mySql高效率执行查询更新的功能。 2、SQLUtil(SQL语句工具类) 对基本SQL语句进行了...
  • jdbc工具类

    2016-11-15 11:13:20
    基于jdbc的封装,轻量级映射,自带连接池,无第三方依赖。支持多数据源,配置简单,支持注解sql查询,自带分页查询。
  • 自己封装的绝对好用的jdbc工具类库,包含数据库连接及增删改查功能,并且可以自己在dao层中编写相应sql语句。
  • 利用JDBC工具类方式实现对mysql数据库的连接,并实现登录功能
  • JdbcUtils是JDBC工具类,封装了JDBC连接获取,语句结构,资源释放等繁琐步骤,对外提供简洁的数据库查询和更新操作接口。 使用前准备 添加maven仓库地址 < id>byx-maven-repo < name>byx-maven-repo < url>...
  • Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库,使用它能够简化JDBC应用程序的开发,同时也不会影响程序的性能。
  • 自己封装的jdbc工具类

    2013-07-16 10:33:59
    给学生讲课课上写的jdbc封装,对基本的增删改查和事务做了封装。例子中用的是oracle 11g数据库,如果换其他数据库直接改连库字符串就行,其他的不用动,适合初学者学习。查询的时候会省掉很多工作量,不需要一个一...
  • JDBC工具类详解

    千次阅读 2020-08-26 18:25:28
    ​ 在我们使用JDBC 的时候,我们多数的代码都是一样的,这个时候我们就像能不能把相同的代码包装成静态方法给我们使用,这就是我们所谓的JDBC工具类 在认识JDBC工具类之前,我们需要对Properties类有一个复习 ...

    JDBCUtils工具类

    ​ 在我们使用JDBC 的时候,我们多数的代码都是一样的,这个时候我们就像能不能把相同的代码包装成静态方法给我们使用,这就是我们所谓的JDBC工具类

    • 在认识JDBC工具类之前,我们需要对Properties类有一个复习
    方法名说明
    String getProperty(String key)在此属性列表中搜索具有指定键的属性,并返回所对应的值。
    void load(InputStream inStream)从输入字节流中读取属性列表(键和元素对)。
    • 类加载器
    方法名说明
    URL getResource(String name)查找具有给定名称的资源。 资源是一些数据(图像,音频,文本等),可以通过类代码以独立于代码位置的方式访问。

    JDBC工具类

    package com.ningxiao.day17;
    
    import java.io.FileReader;
    import java.io.IOException;
    import java.net.URL;
    import java.sql.*;
    import java.util.Properties;
    
    /*
    author :wt
    @create 2020-08-26 14:04
    */
    public class JDBCUtils {
    
        private static String url ;
        private static String user ;
        private static String password ;
        private static String driver;
    
        static {
            Properties pro = new Properties();
            //这里是通过类加载器获取jdbc.propertise的绝对路径
                //首先获取类的加载器,然后通过类的加载器获取src路径下资源的绝对路径
                //这里的意思是不管模块如何移植,只要在模块当中,就能通过相对路径找到
                //绝对路径
            ClassLoader loader = JDBCUtils.class.getClassLoader();
            //通过类加载器获取scr路径下的资源的绝对路径
            URL res = loader.getResource("JDBC.properties");
            //获取绝对路径
            String path = res.getPath();
    
            try {
                pro.load(new FileReader(path));
            } catch (IOException e) {
                e.printStackTrace();
            }
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
        public static Connection getConnection() throws SQLException {
            return DriverManager.getConnection(url,user,password);
        }
    
        public static void close(Statement stmt, Connection conn){
            if (stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void close(ResultSet rs,Statement stmt, Connection conn){
    
            if (rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (stmt!=null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (conn!=null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    展开全文
  • JDBC封装的工具类

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

    千次阅读 2019-05-25 21:54:39
    学了一下JDBCTools的编写,写个小总结。

    介绍

    简介

    我刚学JDBC的时候,在DAO层中获取数据是这样写的:
    在这里插入图片描述

    但如果使用过DButils包或者Spring JDBCTemplate,就知道,在JavaBean里,代码可以这样写:
    在这里插入图片描述
    所以相比之下,第一种方法看起来就像原始人一样…

    接下来我将介绍一下,如何自己写一个简单的类来模拟这个功能。Ps:这里我用到了数据库连接池。

    准备

    JDBC驱动mysql-connector-java-xxx.jar
    C3P0数据库连接池c3p0-xxx.jar

    实现

    先创建一个名为JDBCTools的类

    连接

    创建数据库连接池

    首先,你需要一个配置文档,取名为c3p0-config,内容写法如下:

    <c3p0-config>
    <named-config name="起个名字">
    
    <!-- 指定连接数据源的基本属性 -->
    
    <property name="user">root</property>
    <property name="password">自己写你的密码去</property>
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/你的Database</property>
    
    <!-- 下面是可写可不写的 -->
    
    <!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
    <property name="acquireIncrement">5</property>
    <!-- 初始化数据库连接池时连接的数量 -->
    <property name="initialPoolSize">20</property>
    <!-- 数据库连接池中的最小的数据库连接数 -->
    <property name="minPoolSize">5</property>
    <!-- 数据库连接池中的最大的数据库连接数 -->
    <property name="maxPoolSize">50</property>
    <!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
    <property name="maxStatements">30</property>
    <!-- 每个连接同时可以使用的 Statement 对象的个数 -->
    <property name="maxStatementsPerConnection">5</property>
    
    </named-config>
    </c3p0-config>
    

    由于你这个类中所有的操作都是基于实例化了这个数据库连接池之后才能做事的,所以:
    1.这个类需要有一个数据源DataSource作为成员变量。
    2.需要先使用静态代码块来先实例化。(关于为什么不使用构造函数呢,因为这个工具类的所有方法都将被写为static方法,本类不会被实例化,所以不需要写构造函数)
    实现如下:

    
    	private static DataSource dataSource = null;
    	
    	static{
    		dataSource = new ComboPooledDataSource("写你刚起的那个名字");
    	}
    	
    

    获取连接

    有了一个DataSource,获取连接这件事情就变得很简单了:在数据库连接池中之前已经创建好了很多个Connection了,现在你只需要找它要一个就对了。

    public static Connection getConnection() throws SQLException{
    		return dataSource.getConnection();
    	}
    

    释放

    Java7里的自动释放

    Java7里面增加了个语法糖:try-with-resources。用法是在try后面加上括号,括号里面new一个对象(但是要求实现java.lang.AutoCloseable接口),编译器在这个对象使用完后自动检测null然后关闭。不过鉴于我们这里的有些new操作是封装了的,所以这样似乎不太方便,所以,可以利用:Connection,Statement,resultSet都实现java.lang.AutoCloseable接口的特性来写一个通用的关闭方法:

    public void close(AutoCloseable auto) 
    		{
    			if(auto!=null)
    			 {
    				try {
    					auto.close();
    					} 
    				catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    
    

    传统的方法

    不过我个人写的是另外一种方法:一下把Connection,Statement,resultSet都关了的方法。

    	public static void releaseDB(ResultSet resultSet, Statement statement,
    			Connection connection) {
    
    		if (resultSet != null) {
    			try {
    				resultSet.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    		if (statement != null) {
    			try {
    				statement.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    		if (connection != null) {
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    

    Connection,Statement,resultSet这三个是在各种操作中最常见的,但是如果你只需要用到两个类,你用null来占位置就行了。

    特别说明:在使用了数据库连接池之后,Connection的close()操作就不再是真正意义上的关闭连接了,而是把这个连接放回数据库连接池中,再次变成空闲状态。

    更新

    在执行增,删,改这类操作的时候,只用执行SQL语句即可,不需要从数据库中的得到什么,所以我们需要的只是
    1.统一地补全PreparedStatement语句
    2.执行

    在补全语句的时候,为了使得代码的耦合性降低,给几个参数就补全几个,所以这里使用可变参数 Object ... args来。
    (这里多说一句,不管SQL语句有没有占位符?最好用PreparedStatement,因为Statement在执行的时候有可能被SQL注入)

    public static void executeSql(String sql, Object ... args)
    	{
    		Connection conn = null;
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		
    		try
    		{
    			ps = conn.prepareStatement(sql);
    			//逐个填写
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			ps.execute();
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(null, ps, conn);
    		}
    	}
    

    查询

    与更新不同的是,查询会返回某个值。

    获取一组对象

    由于获取的对象的类可能是各种各样的,这里需要用到泛型和反射的知识,使得这个方法可以对所有的类都通用。
    此外还需JDBC结果集的元数据(ResultSetMetaData)。

    所以,
    1.同上面那个更新方法一样的执行操作,得到resultSet
    2.利用resultSet得到元数据(让你知道哪行的哪个值对应的属性名字是什么)
    3.创建一个目标类的List,准备接受内容。
    4.把每行的值和名字都依次放到一个HashMap<String,Object>里面去
    5.这样你会得到一个HashMap的数组,数组里每个HashMap代表的是实际每个对象的信息结果
    6.对这个数组,进行循环操作:
    (1)先利用反射实例化一个对象
    (2)通过HashMap中储存的名字和值来给这个对象赋值
    (3)把赋值好了的对象加入到第3步中的List中
    7.返出List即可
    在这里插入图片描述

    对于第6步中的(2),我们得到的“名字”实际上是数据库的表里面的首行的名字,而不一定和JavaBean中的变量名字一样,这样会导致赋值失败。例如数据库中的是user_id,而JavaBean中是userId。
    所以我们可以
    1.把表头的属性名字取的和JavaBean的一样(但是这个方法不推荐,虽然我就是这样做的)
    2.利用AS语法:SELECT user_id AS userId,……

    而利用名字给对象属性赋值也有两种方法
    1.反射赋值,就是我下面代码些的那种。
    2.懒人使用commons-beanutils工具类,点此下载
    还需要commons-logging.jar,点此下载。
    然后,使用方法如下:

    BeanUtils.setProperty(对象的名字, “属性的名字”, 属性的值);

    下面是正式代码:

    	public static <T> List<T> executeQuery(Class clazz, String sql, Object ... args)
    	{
    		Connection conn = null;
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		
    		List<T> list = new ArrayList<T>();
    		
    		try
    		{
    			ps = conn.prepareStatement(sql);
    			//填写语句
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			//执行查询
    			rs = ps.executeQuery();
    			//获得元数据
    			ResultSetMetaData rsmd= rs.getMetaData();
    			
    			//元数据的使用方法
    			while(rs.next())
    			{
    				Map<String,Object> map = new HashMap<String,Object>();
    				
    				for(int i = 1;i<=rsmd.getColumnCount();i++)
    				{
    					map.put(rsmd.getColumnLabel(i), rs.getObject(i));
    				}
    				
    				//利用反射创建一个实例
    				T entity = (T) clazz.newInstance(); 
    				
    				//利用反射赋值
    				for(Map.Entry<String, Object> entry : map.entrySet())
    				{
    					
    					String fieldName = entry.getKey();
    					Object fieldValue = entry.getValue();
    					
    					//反射赋值,如果你用了BeanUtils就替换下面三句
    			        Field f = entity.getClass().getDeclaredField(fieldName);
    			        f.setAccessible(true);
    			        f.set(entity, fieldValue);   
    				}			
    				list.add(entity);
    			}
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(rs, ps, conn);
    		}
    		
    		return list;
    	}
    

    不过这里有个小小的Bug。当你只需要返回一个对象的时候,这个方法返回给你的是个只有一个对象的List,所以嘛,就手动加点代码啦,例如:

    	public Article ViewArticle(int id) {
    	
    		String sql = "SELECT * FROM ARTICLE WHERE ID = ?";
    		
    		List<User> list = JDBCTools.executeQuery(User.class, sql, id);
    		
    		//手动获取第一个对象XD
    		User user = list.get(0);	
    		
    		return user;
    	}
    

    获取某个值

    本质上和上面那个一样,但是返回的就是个值,所以简单多了。

    public static int executeGetSum(String sql, Object ... args)
    	{
    		Connection conn = null;
    		
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		int value = 0;
    		
    		try
    		{
    			ps = conn.prepareStatement(sql);
    			//填写语句
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			
    			rs = ps.executeQuery();
    			
    			while(rs.next())
    			{  
    				//这里实际看你列名怎么取的如果你用了AS XXX那这里记得改
    				value = rs.getInt("COUNT(*)");
    			}
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(null, ps, conn);
    		}
    		
    		return value;
    	}
    

    我的JDBCTools类的完整代码

    dbq我还没写注释文档…

    package com.dao;
    
    import java.lang.reflect.Field;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    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 javax.sql.DataSource;
    
    import org.junit.Test;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    
    /**
     * JDBC 的工具类
     * 
     * 其中包含: 获取数据库连接, 关闭数据库资源等方法.
     */
    public class JDBCTools {
    	
    	private static DataSource dataSource = null;
    
    	//数据库连接池应只被初始化一次. 自动创建了一堆Conn然后来管理
    	//然后这里的conn.close的含义 就变为了释放 而不是关闭!
    	static{
    		dataSource = new ComboPooledDataSource("LehrC3P0");
    	}
    	
    	
    	public static Connection getConnection() throws SQLException{
    	
    		return dataSource.getConnection();
    	
    	}
    
    	public static void releaseDB(ResultSet resultSet, Statement statement,
    			Connection connection) {
    
    		if (resultSet != null) {
    			try {
    				resultSet.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    		if (statement != null) {
    			try {
    				statement.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    		if (connection != null) {
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    
    	//执行一条sql,没有返回值
    	@Test
    	public static void executeSql(String sql, Object ... args)
    	{
    		Connection conn = null;
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		
    		try
    		{
    			ps = conn.prepareStatement(sql);
    			//填写语句
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			ps.execute();
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(null, ps, conn);
    		}
    	}
    	
    	//执行Select语句
    	/**
    	 * @param <T>
    	 * @param sql 
    	 * @param args
    	 * @return
    	 */
    	@SuppressWarnings({ "rawtypes" })
    	public static <T> List<T> executeQuery(Class clazz, String sql, Object ... args)
    	{
    		Connection conn = null;
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		
    		List<T> list = new ArrayList<T>();
    		
    		try
    		{
    			ps = conn.prepareCall(sql);
    			//填写语句
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			//执行查询
    			rs = ps.executeQuery();
    			//获得元数据
    			ResultSetMetaData rsmd= rs.getMetaData();
    			
    			while(rs.next())
    			{
    				Map<String,Object> map = new HashMap<String,Object>();
    				
    				for(int i = 1;i<=rsmd.getColumnCount();i++)
    				{
    					map.put(rsmd.getColumnLabel(i), rs.getObject(i));
    				}
    				
    
    				//利用反射创建一个实例
    				@SuppressWarnings("unchecked")
    				T entity = (T) clazz.newInstance(); 
    				
    				//利用反射赋值
    				for(Map.Entry<String, Object> entry : map.entrySet())
    				{
    					
    					String fieldName = entry.getKey();
    					Object fieldValue = entry.getValue();
    					
    					//直接对属性操作!但是这里时间类和Long那个有点小问题
    			        Field f = entity.getClass().getDeclaredField(fieldName);
    			        f.setAccessible(true);
    			        f.set(entity, fieldValue);
    					
    			        //其实这里也可以导入Beanutils包来快速操作的
    			        
    				}
    				
    			
    				list.add(entity);
    			
    			}
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(rs, ps, conn);
    		}
    		
    		return list;
    	}
    	
    	
    	//不用加AS NUM !!!
    	public static int executeGetSum(String sql, Object ... args)
    	{
    		Connection conn = null;
    		
    		try {
    			conn = getConnection();
    		} catch (Exception e1) {
    			// TODO Auto-generated catch block
    			e1.printStackTrace();
    		}
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		int value = 0;
    		
    		try
    		{
    			ps = conn.prepareStatement(sql);
    			//填写语句
    			for(int i=0;i<args.length;i++)
    			{
    				ps.setObject(i+1, args[i]);
    			}
    			
    			rs = ps.executeQuery();
    			
    			while(rs.next())
    			{  
    				value = rs.getInt("COUNT(*)");
    			}
    		}
    		catch(Exception e)
    		{
    			e.printStackTrace();
    		}
    		finally
    		{
    			releaseDB(null, ps, conn);
    		}
    		
    		return value;
    	}
    	
    }
    
    展开全文
  • MySQL 数据库 (实现JDBC工具类)

    千次阅读 2018-08-26 01:56:12
    JDBC工具类:   package com.itcast.ma; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException;...

    JDBC工具类:

     

    package com.itcast.ma;
    
    
    import java.sql.Connection;
    
    import java.sql.DriverManager;
    
    import java.sql.PreparedStatement;
    
    import java.sql.ResultSet;
    
    import java.sql.SQLException;
    
    
    /**
    
    * 工具类
    
    * 提供获取连接及释放资源的方法
    
    * @author lenovo
    
    *
    
    */
    
    
    public class JDBCUtils {
    
        /**
    
         * 获取连接方法
    
         * @return
    
         */
    
        public static Connection getConnection(){
    
            Connection conn = null;
    
            try {
    
                Class.forName("com.mysql.jdbc.Driver");
    
                
    
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/user","root","123456");
    
                
    
            } catch (Exception e) {
    
                
    
                e.printStackTrace();
    
            }
    
            
    
            
    
            return conn;
    
        }
    
        /**
    
         * 释放资源方法
    
         * @param conn
    
         * @param pstmt
    
         * @param rs
    
         */
    
        public static void release(Connection conn, PreparedStatement pstmt, ResultSet rs){
    
            if(rs != null){
    
                try {
    
                    rs.close();
    
                } catch (SQLException e) {
    
                    
    
                    e.printStackTrace();
    
                }
    
            }
    
            if(pstmt != null){
    
                try {
    
                    pstmt.close();
    
                } catch (SQLException e) {
    
                    
    
                    e.printStackTrace();
    
                }
    
            }
    
            if(conn != null){
    
                try {
    
                    conn.close();
    
                } catch (SQLException e) {
    
                    
    
                    e.printStackTrace();
    
                }
    
            }
    
        }
    
    
    }
    
    

    查询数据:

    package com.ma.test;
    
    import java.sql.Connection;
    
    import java.sql.PreparedStatement;
    
    import java.sql.ResultSet;
    
    import java.sql.SQLException;
    
    import org.junit.Test;
    
    import com.itcast.ma.JDBCUtils;
    
    /**
    
     *测试工具类
    
     * @author lenovo
    
     *
    
     */
    
    public class TestUtils {
    
          /**
    
           * 根据id查询
    
           */
    
          @Test
    
          public void testFindUserById(){
    
                Connection conn = null;
    
                PreparedStatement pstmt  = null;
    
                ResultSet rs = null;
    
          
    
                try {
    
                      //1、获取连接
    
                      conn = JDBCUtils.getConnection();
    
                      //2、编写 sql
    
                      String sql = "select * from t_user where uid = ?";
    
                      //3、获取执行语句对象
    
                      pstmt = conn.prepareStatement(sql);
    
                      //4、设置参数
    
                      pstmt.setInt(1, 2);
    
                      //5、查询
    
                      rs = pstmt.executeQuery();
    
                      //6、处理资源
    
                      while(rs.next()){
    
                            System.out.println(rs.getString(2)+"----"+ rs.getString("password"));
    
                      }
    
                      
    
                } catch (SQLException e) {
    
                      
    
                      e.printStackTrace();
    
                }finally{
    
                      //7、释放资源
    
                      JDBCUtils.release(conn, pstmt, rs);
    
                }
    
                
    
          } 
    
    }

    测试结果:

     

    使用 properties 配置文件:

     

    开发过程中获得连接的四个参数(驱动、url 、用户名、密码)通常都存放在配置文件中,方便后期维护,程序如果需要更换数据库,只需要修改配置文件即可。

    1、文件位置:建议 src 下面。

    2、文件名称:任意,扩展名为 properties。

    3、文件内容:一行一组数据,格式是“key = value”;key 名自定义,如果多个单词用 . 分隔;value 不支持中文。

     

    driver = com.mysql.jdbc.Driver

    url = jdbc;mysql://localhost:3306/user?useUnicode = true & characterEncoding = utf-8

    username = rooot

    password = 123456

     

    加载配置文件:ResourceBundle 对象。

    package com.itcast.ma;
    
    import java.util.ResourceBundle;
    
    /**
    
     * 工具类
    
     * 提供获取连接及释放资源的方法
    
     * @author lenovo
    
     *
    
     */
    
    public class JDBCUtils {
    
          private static String driver;//驱动
    
          private static String url;//路径
    
          private static String user;//用户
    
          private static String password;//密码
    
          /**
    
           * 配置文件只需要加载一次,提供静代码,当前类被加载到内存执行
    
           */
    
          static{
    
                //1、使用 JDK 提供的工具类加载 properties 文件
    
                //ResourceBundle 专门处理 properties 文件,提供 getBundle() 方法,只需要写入文件。
    
                ResourceBundle bundle = ResourceBundle.getBundle("db");
    
                //2、通过 key 获取需要的值
    
                driver = bundle.getString("driver");
    
                url = bundle.getString("url");
    
                user = bundle.getString("username");
    
                password = bundle.getString("password");
    
                
    
          }
    
    }

     

    插入数据:

     

     


     

    /**
    
           * 添加用户信息方法
    
           */
    
          @Test
    
          public void testAdd(){
    
                Connection conn = null;
    
                PreparedStatement pstmt = null;
    
                
    
                try {
    
                      //1、获取连接
    
                      conn = JDBCUtils.getConnection();
    
                      //2、书写 sql 语句
    
                      String sql = "insert into t_user values(null,?,?,?)";
    
                      //3、获取 sql 执行对象
    
                      pstmt = conn.prepareStatement(sql);
    
                      //4、设置参数
    
                      pstmt.setString(1, "MaYue");
    
                      pstmt.setString(2, "321456");
    
                      pstmt.setString(3, "LIN");
    
                      //5、执行插入操作
    
                      int row = pstmt.executeUpdate();
    
                      if(row > 0){
    
                            System.out.println("插入成功 !");
    
                      }
    
                } catch (SQLException e) {
    
                      
    
                      e.printStackTrace();
    
                }
    
                
    
          }
    
    

    删除数据:

    /**
    
           * 根据id 删除用户的方法
    
           */
    
          @Test
    
          public void testDelete(){
    
                Connection conn = null;
    
                PreparedStatement pstmt = null;
    
                
    
                try {
    
                      //1、获取连接
    
                      conn = JDBCUtils.getConnection();
    
                      //2、书写 sql 语句
    
                      String sql = "delete from t_user where uid = ?";
    
                      //3、获取 sql 执行对象
    
                      pstmt = conn.prepareStatement(sql);
    
                      //4、设置参数
    
                      pstmt.setInt(1, 9);
    
                      //5、执行插入操作
    
                      int row = pstmt.executeUpdate();
    
                      if(row > 0){
    
                            System.out.println("删除成功 !");
    
                      }else{
    
                            System.out.println("删除失败 !");
    
                      }
    
                } catch (SQLException e) {
    
                      
    
                      e.printStackTrace();
    
                }finally{
    
                      //6、释放资源
    
                      JDBCUtils.release(conn, pstmt, null);
    
                }
    
                
    
                
    
          }

     


     

    更新数据:

    /**
    
           * 根据id 更新用户的方法
    
           */
    
          @Test
    
          public void testUpdate(){
    
                Connection conn = null;
    
                PreparedStatement pstmt = null;
    
                
    
                try {
    
                      //1、获取连接
    
                      conn = JDBCUtils.getConnection();
    
                      //2、书写 sql 语句
    
                      String sql = "update t_user set password = ? where uid = ?";
    
                      //3、获取 sql 执行对象
    
                      pstmt = conn.prepareStatement(sql);
    
                      //4、设置参数
    
                      pstmt.setString(1, "666666");
    
                      pstmt.setInt(2, 1 );
    
                      //5、执行插入操作
    
                      int row = pstmt.executeUpdate();
    
                      if(row > 0){
    
                            System.out.println("更新成功 !");
    
                      }else{
    
                            System.out.println("更新失败 !");
    
                      }
    
                } catch (SQLException e) {
    
                      
    
                      e.printStackTrace();
    
                }finally{
    
                      //6、释放资源
    
                      JDBCUtils.release(conn, pstmt, null);
    
                }
    
                
    
                
    
          }

     

    展开全文
  • JDBC工具类.txt

    2020-12-28 13:27:02
    注册驱动的抽取 抽取一个方法获取连接对象
  • JAVA之JDBC工具类-Mysql(简单版)

    千次阅读 2018-12-04 23:50:21
    分享一下自己最近写的一个JDBC工具类吧,不对之处还请各位不吝赐教 在项目的目录下创建config文件夹,在里面新建文件保存jdbc的配置信息,这样做便于修改 jdbc.properties内容: driver=com.mysql.jdbc.Driver url=...

    分享一下自己最近写的一个JDBC工具类吧,不对之处还请各位不吝赐教

    在项目的目录下创建config文件夹,在里面新建文件保存jdbc的配置信息,这样做便于修改

    jdbc.properties内容:

    driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/xianfeng?useUnicode=true&characterEncoding=utf8
    user=root
    password=root
    

    xianfeng就是对应数据库的名字
    用户密码要改成自己的哦

    在这里插入图片描述

    在src下新建一个util包,分别对应三个类Config、jdbcTest、jdbcUtil。

    Config用于读取配置文件的方法

    package util;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    
    public class Config {
    private Properties prop = new Properties();
    	
    	public Config(String file)
    	{
    		try
    		{
    			InputStream in = new FileInputStream(file);
    			prop.load(in);
    		} 
    		catch (IOException e) 
    		{
    			e.printStackTrace();
    		}
    	}
    	public String getValue(String key)
    	{
    		return prop.getProperty(key);
    	}
    }
    

    jdbcUtil主要用于数据库方法的封装

    package util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    
    public class JdbcUtils {
    	
    	private static String driverClass ;
    	private static String url ;
    	private static String user ;
    	private static String password ;
    	
    	static{
    		Config config = new Config("config/jdbc.properties");
    		//读取配置信息
    		driverClass = config.getValue("driver");
    		url = config.getValue("url");
    		user = config.getValue("user");
    		password = config.getValue("password");
    		
    		/**
             * 驱动注册
             */
    		try {
    			Class.forName(driverClass);//注册加载驱动
    		} catch (ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
         * 获取 Connetion
         * @return
         * @throws SQLException
         */
    	
    	public static Connection getConnection() throws SQLException{
    		Connection conn = DriverManager.getConnection(url, user, password);
    		return conn;
    	}
    	
    	/**
    	 * 关闭ResultSet资源
    	 * @param rs
    	 */
    	
    	public static void close(ResultSet rs){
    		if(null != rs){
    			try {
    				rs.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	/**
    	 * 关闭Statement资源
    	 * @param stmt
    	 */
    	
    	public static void close(Statement stmt){
    		if(null != stmt){
    			try {
    				stmt.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	
    	/**
    	 * 关闭close资源
    	 * @param conn
    	 */
    	public static void close(Connection conn){
    		if(null != conn){
    			try {
    				conn.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    	/**
    	 * 关闭资源
    	 * @param rs
    	 * @param stmt
    	 * @param conn
    	 */
    	
    	public static void close(ResultSet rs,Statement stmt,Connection conn){
    		close(rs);
    		close(stmt);
    		close(conn);
    	}
    	
    }
    

    jdbcTest主要对工具类的测试

    package util;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    
    public class jdbcTest {
    	
    
    
    	public static void main(String[] args) {
    		Connection conn = null;
    		PreparedStatement stmt = null;
    		ResultSet rs = null;
    		
    		try {
    			//获取连接
    			conn = JdbcUtils.getConnection();
    			//编写sql
    			String sql = "select * from t_bingli";
    			//创建语句执行者
    			stmt = conn.prepareStatement(sql);
    			rs = stmt.executeQuery();
    			
    			while(rs.next()) {
    				//输出结果中的第一列和第二列
                    System.out.println(rs.getString(1)+"+++"+rs.getString(2));
                }
    		} catch (SQLException e) {
    			e.printStackTrace();
    		}finally {
    			JdbcUtils.close(rs, stmt, conn);
            }
    
    	}
    
    }
    

    结果

    对应到数据库的信息:

    现在大概应该掌握了如何使用这个简单的jdbc工具类了吧,赶紧去试试吧

    展开全文
  • Java JDBC工具类

    千次阅读 2018-07-31 16:55:47
    * @title JDBC工具类 * 连接数据库 * 执行SQL * 查询对象 * 查询集合 * @author Xingbz */ public class JdbcUtil { /** 驱动名称 */ private static final String DRIVER_NAME = ...
  • JDBC工具类的封装

    千次阅读 2020-05-03 14:57:25
    JDBC工具类,简化JDBC编程 本篇供个人学习使用,有问题欢迎讨论 一、配置JDBC的代码驱动 首先,在编写JDBC工具类前,我们得先配置JDBC的代码驱动。 不会配置的可以看我的另一篇博客,IDEA的JDBC代码配置驱动 二、...
  • 超好用的JDBC工具类,你get到了嘛?

    千次阅读 多人点赞 2020-11-27 19:23:18
    目录 QueryRunner类 query() update() batch() ResultHandler接口 ...今天和大家分享一下在使用jdbc连接数据库时,为了我们对数据进行操作的方便性,而常用的工具类和接口的具体使用方法,关于Java的jdb...
  • 功能强大的JDBC工具类

    2014-03-21 16:01:14
    JDBC工具类功能强大,不仅支持查询,还可支持批量操作指定的SQL
  • JAVA之JDBC工具类-Mysql(进阶版)

    千次阅读 2019-01-13 23:55:06
    接着上一次JAVA之JDBC工具类简单版,新手的话可以先看看简单版(点击前面的简单版即可跳转的简单版博客)再回来看这个进阶版。还是那句话,不对之处还请各位不吝赐教。 在开始之前,在项目中引入mysql的资源包,...
  • 自己封装的JDBC工具类

    2017-11-16 23:29:41
    自己封装的JDBC工具类,能够实现对数据库的增删改查以及批处理,事物处理等操作
  • JDBC工具类DBUtils封装jar包

    千次阅读 2019-08-14 20:41:08
    JDBC工具类DBUtils封装jar包 通过对JDBC操作数据库的学习,我们会发现,由于JDBC操作数据库的步骤基本没有大的变化,针对所有的数据访问操作,都会存在大量重复代码,因此,对操作数据库的步骤封装就显得十分有必要...
  • Jdbc工具类例子

    千次阅读 2020-06-23 12:00:21
    Jdbc工具类的简单例子 封装方法 创建连接,共用调用 静态代码块,只需调用一次,账号密码等配置文件获取,不需更改代码 关闭资源方法 配置文件: driver=com.mysql.cj.jdbc.Driver url = jdbc:mysql://...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,318
精华内容 70,127
关键字:

jdbc工具类