Java访问数据库学习笔记

最新推荐文章于 2022-01-05 18:52:08 发布

赵恶龙

最新推荐文章于 2022-01-05 18:52:08 发布

阅读量294

点赞数 1

文章标签： java mysql 数据库

本文链接：https://blog.csdn.net/Superzhaoy/article/details/107864337

版权

day5 - JDBC技术（一）

Java访问数据库技术概述

在JDBC出现之前，早期java需要访问数据库时，需要根据不同的数据库管理系统(DBMS)编写不同的数据源，使用一项称之为JDBC-ODBC桥链接模式。

在这里插入图片描述

通过以上访问方式，程序员会在访问数据方面花费大把精力，因此SUN在后来设计的JDBC接口，将访问数据库的具体实现交给不同的数据库厂商各自实现，从而减少java程序的压力。

JDBC入门

JDBC(Java Database Connectivity),java 链接数据库技术，是由java.sql包中提供的一系列接口构成，通过这些接口结合不同的数据库管理系统的驱动包，可以非常轻松的实现java访问数据库。

在这里插入图片描述

入门案例

//1.加载数据库驱动(注册驱动)  JDBC4之后无需编写
Class.forName("com.mysql.jdbc.Driver"); 
//2.获取连接
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", "root", "123456");
//3.获取执行sql语句命令的对象
Statement stat = conn.createStatement();
//4.执行sql
boolean f = stat.execute("insert into tbuser(username,password) values('java-jdbc','112233')");
//5.处理结果
System.out.println("执行结果:"+f);
//6.关闭资源
stat.close();
conn.close();

JDBC相关接口介绍

jdbc中常用的类和接口：

DriverManager
Connection
Statement/PreparedStatement
ResultSet

DriverManager

驱动管家类，java.sql中提供的一个具体类，内部包含了一些用于加载数据库驱动的方法以及获取连接的操作:getConnection

使用DriverManager获取数据库连接的三种方式

// 方法一:
Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", "root", "123456");

//方法二：
//		Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2?user=root&password=123456");

//方法三:
//		Properties info = new Properties();
//		info.put("user", "root");
//		info.put("password","123456");
//		Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb2", info);

Connection

Connection用于表示从Java程序到数据库的连接通道，通过Connection可以向数据库传输sql命令，并且返回执行结果.另外Connection也可以用于对数据库事务管理，具体使用：

//获取执行sql的命令对象
Statement stat = connection.createStatement();

//获取sql语句的预处理对象(防止sql注入)
PreparedStatement ps = connection.parepareStatement();

//获取一个用于发送存储过程调用命令对象
CallableStatement pc = connection.prepareCall();

//设置禁止事务自动提交
connection.setAutoCommit(false);

//回滚事务
connection.rollback();

//事务提交
connection.commit();

Statement&PreparedStatement

是一个用于执行sql命令的对象，主要用于执行静态sql（事先准备好的，固定的）；由于Statement的固有不安全性（很有可能导致sql注入的风险），因此还提供一个直接子接口：PreparedStatement(预处理命令对象)，可以有效的防止sql注入的风险。

Statement中提供的常见方法：

boolean execute(String sql)
int executeUpdate(String sql)
ResultSet executeQuery(String sql)

PreparedStatement提供的方法：

int executeUpdate();
ResultSet executeQuery();

//方式SQL注入，使用PreparedStatement
public static void login2(String username,String password) throws ClassNotFoundException, SQLException {
    String sql = "select * from tbuser where username=? and password=?";
    //1.加载驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.获取连接
    Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb2", "root", "123456");
    //3.获取预处理sql命令的对象(对传入的sql与进行预编译，防止出现sql注入问题)
    PreparedStatement ps = conn.prepareStatement(sql);
    //预处理
    ps.setString(1, username);
    ps.setString(2, password);
    //4.执行
    ResultSet rs = ps.executeQuery();
    //5.处理结果
    if(rs.next()) {
        System.out.println("登录成功!");
    }else {
        System.out.println("请检查账号和密码！");
    }
    //6.关闭资源
    rs.close();
    ps.close();
    conn.close();
}

//Statement可能导致sql注入
public static void login(String username,String password) throws ClassNotFoundException, SQLException {
    String sql = "select * from tbuser where username='" + username + "' and password='" + password + "'";
    System.out.println("执行sql语句：" + sql);
    //1.加载驱动
    Class.forName("com.mysql.jdbc.Driver");
    //2.获取连接
    Connection conn = DriverManager.getConnection("jdbc:mysql:///mydb2", "root", "123456");
    //3.获取处理sql命令的对象
    Statement stat = conn.createStatement();
    //4.执行sql
    ResultSet rs = stat.executeQuery(sql);
    //5.处理结果
    if(rs.next()) {
        System.out.println("登录成功!");
    }else {
        System.out.println("请检查账号和密码！");
    }
    //6.关闭资源
    rs.close();
    stat.close();
    conn.close();
}

测试:

login2("sdrfsdf", "' or '1=1");

Statement和PreparedStatement的区别？

Statement是原始的执行sql命令的对象，不对sql语句做任何处理，可能会因为传入的参数问题导致sql注入，因此存在注入的风险；所以在实际开发中更加推荐使用PreparedStatement,该接口的实现针对sql语句进行了预编译，解决了可能出现的sql注入风险；另外PreparedStatement内部使用预编译机制，从运行效率来看，略高于Statement。

ResultSet

结果集对象，用于表示对于查询语句执行之后的结果，内部的数据可能是一条也可以是多条

CRUD操作

CRUD,增删改查，基于Java对数据库表中的数据进行增删改查操作(insert ,delete,update,select)

CRUD操作

package com.softeem.lesson48.crud;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.softeem.lesson48.utils.DBUtils;

public class UserCRUD {

    private Connection conn;

    /**
	 * 	添加数据
	 * @param username
	 * @param password
	 * @return
	 * @throws ClassNotFoundException
	 * @throws SQLException
	 */
    public boolean insert(String username,String password) throws ClassNotFoundException, SQLException {
        PreparedStatement ps = null;
        try {
            //DBUtil类参考JDBC基本封装
            conn = DBUtils.getConn();
            String sql = "insert into tbuser(username,password) values(?,?)";
            //3.获取sql语句预处理对象
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            ps.setString(2, password);
            //4.执行
            int i = ps.executeUpdate();
            //5.处理结果
            return i > 0;
        }finally {
            DBUtils.close(null, ps, conn);
        }
    }

    /**
	 * 	修改数据
	 * @param id
	 * @param password
	 * @return
	 * @throws ClassNotFoundException
	 * @throws SQLException
	 */
    public boolean update(int id,String password) throws ClassNotFoundException, SQLException {

        String sql = "update tbuser set password=? where id=?";
        PreparedStatement ps = null;
        try {
            conn = DBUtils.getConn();
            //3.获取sql语句预处理对象
            ps = conn.prepareStatement(sql);
            ps.setString(1, password);
            ps.setInt(2, id);
            //4.执行
            int i = ps.executeUpdate();
            return i > 0;
        }finally {
            DBUtils.close(null, ps, conn);
        }
    }

    /**
	 * 	删除数据
	 * @param id
	 * @return
	 * @throws ClassNotFoundException
	 * @throws SQLException
	 */
    public boolean delete(int id) throws ClassNotFoundException, SQLException {
        String sql = "delete from tbuser where id=?";
        PreparedStatement ps = null;
        try {
            conn = DBUtils.getConn();
            //3.获取sql语句预处理对象
            ps = conn.prepareStatement(sql);
            ps.setInt(1, id);
            //4.执行
            int i = ps.executeUpdate();
            return i > 0;
        }finally {
            DBUtils.close(null, ps, conn);
        }
    }

    /**
	 * 	查询一条数据
	 * @param username
	 * @return
	 * @throws SQLException
	 */
    public Map<String,Object> selectOne(String username) throws SQLException{
        //声明map作为返回值
        Map<String,Object> map = new HashMap<String, Object>();
        String sql = "select * from tbuser where username=?";
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtils.getConn();
            //3.获取预处理是sql命令的对象
            ps = conn.prepareStatement(sql);
            ps.setString(1, username);
            //4.执行查询
            rs = ps.executeQuery();
            if(rs.next()) {
                //根据列的标签(默认列名，如有设置别名，则标签为别名)获取列值
                int id = rs.getInt("id");
                String name = rs.getString("username");
                String pwd = rs.getString("password");
                //将获取的数据装入map集合
                map.put("id", id);
                map.put("username", name);
                map.put("password", pwd);
            }
        } finally {
            DBUtils.close(rs, ps, conn);
        }

        return map;
    }

    /**
	 * 	查询所有
	 * @return
	 * @throws SQLException
	 */
    public List<Map<String,Object>> selectAll() throws SQLException{
        List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
        String sql = "select * from tbuser";

        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtils.getConn();
            //3.获取预处理是sql命令的对象
            ps = conn.prepareStatement(sql);
            //4.执行查询
            rs = ps.executeQuery();
            while(rs.next()) {
                Map<String,Object> map = new HashMap<String, Object>();
                //根据列的标签(默认列名，如有设置别名，则标签为别名)获取列值
                int id = rs.getInt("id");
                String name = rs.getString("username");
                String pwd = rs.getString("password");
                //将获取的数据装入map集合
                map.put("id", id);
                map.put("username", name);
                map.put("password", pwd);
                list.add(map);
            }
        } finally {
            DBUtils.close(rs, ps, conn);
        }
        return list;
    }

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        UserCRUD crud = new UserCRUD();
        //		boolean f = crud.insert("softeem123", "123softeem");
        //		boolean f = crud.update(2, "666666");
        //		boolean f = crud.delete(12);

        //		System.out.println("执行结果:"+f);
        //		Map<String,Object> map = crud.selectOne("softeem");
        List<Map<String, Object>> list = crud.selectAll();
        list.forEach(u->System.out.println(u));
    }
}

JDBC基本封装

/**
 * 	数据库工具类V1.0
 * 	将访问数据库的公共代码抽取:
 *  1.加载驱动
 *  2.获取连接
 *  6.关闭资源
 * @author mrchai
 *
 */
public class DBUtils {

    /**驱动类路径*/
    private static final String DRIVER_CLASS="com.mysql.jdbc.Driver";
    /**url地址*/
    private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb2";
    /**数据库服务器登录用户名*/
    private static final String USER = "root";
    /**数据库服务器登录密码*/
    private static final String PASSWORD = "123456";

    static {
        try {
            //1.加载驱动
            Class.forName(DRIVER_CLASS);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
	 * 	2. 获取数据库连接对象
	 * @return
	 */
    public static synchronized Connection getConn() {
        try {
            return DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
	 * 	6.关闭资源
	 * @param rs
	 * @param stat
	 * @param conn
	 */
    public static void close(ResultSet rs,Statement stat,Connection conn) {
        try {
            if(rs != null)rs.close();
            if(stat != null)stat.close();
            if(conn != null)conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

day3 - JDBC（三）

ResultSetMetaData

public class ResultSetMetaDataDemo {

	public static void main(String[] args) throws SQLException {
		
		String sql = "select * from tblog";
		Connection conn = DBUtils.getConn();
		PreparedStatement ps = conn.prepareStatement(sql);
		ResultSet rs = ps.executeQuery();
		//获取结果集的元数据
		ResultSetMetaData rsmd = rs.getMetaData();
		//查询的列数
		int count = rsmd.getColumnCount();
		System.out.println("查询总列数:"+count);
		
		while(rs.next()) {
			//遍历所有的列
			for (int i = 1; i <= count; i++) {
				//获取列名称
				String name = rsmd.getColumnName(i);
				String label = rsmd.getColumnLabel(i);
				int type = rsmd.getColumnType(i);
				Object value = rs.getObject(label);
				
				System.out.print(name+"--"+label+"--"+type+"==="+value);
			}
			System.out.println();
			
		}
	}
}

基于反射实现查询封装

/**
	 * 封装通用查询单条数据的方法
	 * 
	 * JDBC，反射，集合框架，lambda表达式，新增Objects类
	 * 
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
public static <T> T queryOne(Class<T> t, String sql, Object... params) {
    // 获取查询到到数据集合
    List<Map<String, Object>> list = queryMaps(sql, params);
    if (list.size() > 0) {
        // 获取一个Map对象
        Map<String, Object> map = list.get(0);
        // 将map集合转换为Javabean并返回
        return mapToBean(map, t);
    }
    return null;
}

/**
	 * 封装通用查询多条数据的方法
	 * 
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
    List<T> list = new ArrayList<T>();
    // 获取所有查询的到的数据
    List<Map<String, Object>> maps = queryMaps(sql, params);
    // 遍历集合中每一条数据(map)
    maps.forEach(m -> {
        // 将map转换为Javabean
        T obj = mapToBean(m, t);
        // 将Javabean装入list
        list.add(obj);
    });
    return list;
}

/**
	 * 将Map集合转换为一个确定的类型
	 * 
	 * @param <T>
	 * @param map
	 * @param t
	 * @return
	 */
private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
    //		T obj = null;
    try {
        // 根据提供的Class对象创建对应类型的Object
        T obj = t.newInstance();
        map.forEach((k, v) -> {
            try {
                // 根据Field名称获取字段对象
                Field field = t.getDeclaredField(k);
                // 设置字段的可访问性
                field.setAccessible(true);
                // 为字段设置值
                field.set(obj, v);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
        return obj;
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    // 返回对象
    return null;
}

/**
	 * 执行相关查询并将结果返回为List<Map<String,Object>> 集合
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
    // 声明动态数组用于存储每一个查询到的Map对象
    List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
    // 获取连接
    Connection conn = getConn();
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        // 获取预处理sql命令的对象
        ps = conn.prepareStatement(sql);
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                // 对指定位置的占位符填充值（预处理）
                ps.setObject(i + 1, params[i]);
            }
        }
        // 执行查询获取结果集
        rs = ps.executeQuery();
        // 获取结果集的元数据对象ResultSetMetaData
        ResultSetMetaData rsmd = rs.getMetaData();
        // 获取总查询列数
        int columnCount = rsmd.getColumnCount();
        // 遍历结果集
        while (rs.next()) {
            // 声明map集合存储每一条数据（临时缓存）
            Map<String, Object> map = new HashMap<String, Object>();
            // 遍历获取每一列的信息
            for (int i = 1; i <= columnCount; i++) {
                // 获取列名称（作为map集合的键）
                String key = rsmd.getColumnName(i);
                // 获取列标签
                String label = rsmd.getColumnLabel(i);
                // 获取列值（作为map集合的值）
                Object value = rs.getObject(label);
                if (Objects.nonNull(value)) {
                    // 将取到的每一列的列名与列值存储到map
                    map.put(key, value);
                }
            }
            // 将map集合装入list
            list.add(map);
        }

    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        close(rs, ps, conn);
    }
    return list;
}

/**
	 * 根据提供的查询语句以及查询参数，返回符合条件的数目
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
public static int queryCount(String sql, Object... params) {
    Connection conn = getConn();
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        ps = conn.prepareStatement(sql);
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i + 1, params[i]);
            }
        }
        rs = ps.executeQuery();
        if(rs.next()) {
            return rs.getInt(1);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }finally {
        close(rs, ps, conn);
    }
    return 0;
}

DBUtils完全版

package com.softeem.lesson50.utils;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
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 java.util.Objects;
import java.util.Properties;

/**
 * ORM框架（Mybatis,Hibernate,spring Data JPA）
 * 数据库工具类V2.0 将访问数据库的公共代码抽取: 1.加载驱动 2.获取连接 6.关闭资源
 * @author mrchai
 *
 */
public class DBUtils {

	/** 驱动类路径 */
	private static String DRIVER_CLASS;
	/** url地址 */
	private static String URL;
	/** 数据库服务器登录用户名 */
	private static String USER;
	/** 数据库服务器登录密码 */
	private static String PASSWORD;

	static {
		try {
			//读取属性文件获取连接数据库相关的字符串
			InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
			//创建属性对象
			Properties p = new Properties();
			//加载包含属性信息的输入流
			p.load(is);
			
			//根据属性名获取属性值
			DRIVER_CLASS = p.getProperty("driver");
			URL = p.getProperty("url");
			USER = p.getProperty("user");
			PASSWORD = p.getProperty("password");
			
//			 1.加载驱动
			Class.forName(DRIVER_CLASS);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 2. 获取数据库连接对象
	 * 
	 * @return
	 */
	public static synchronized Connection getConn() {
		try {
			return DriverManager.getConnection(URL, USER, PASSWORD);
		} catch (SQLException e) {
			e.printStackTrace();
		}![在这里插入图片描述](https://img-blog.csdnimg.cn/20200807160919204.png)

		return null;
	}

	/**
	 * 6.关闭资源
	 * 
	 * @param rs
	 * @param stat
	 * @param conn
	 */
	public static void close(ResultSet rs, Statement stat, Connection conn) {
		try {
			if (rs != null)
				rs.close();
			if (stat != null)
				stat.close();
			if (conn != null)
				conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 封装通用的更新操作：INSERT UPDATE DELETE
	 * 
	 * @param sql
	 * @param params Object[] params
	 * @return
	 */
	public static boolean exeUpdate(String sql, Object... params) {
		// 获取连接
		Connection conn = getConn();
		PreparedStatement ps = null;
		try {
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[i]);
				}
			}
			return ps.executeUpdate() > 0;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(null, ps, conn);
		}
		return false;
	}

	/**
	 * 封装通用查询单条数据的方法
	 * 
	 * JDBC，反射，集合框架，lambda表达式，新增Objects类
	 * 
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> T queryOne(Class<T> t, String sql, Object... params) {
		// 获取查询到到数据集合
		List<Map<String, Object>> list = queryMaps(sql, params);
		if (list.size() > 0) {
			// 获取一个Map对象
			Map<String, Object> map = list.get(0);
			// 将map集合转换为Javabean并返回
			return mapToBean(map, t);
		}
		return null;
	}

	/**
	 * 封装通用查询多条数据的方法
	 * 
	 * @param <T>
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
		List<T> list = new ArrayList<T>();
		// 获取所有查询的到的数据
		List<Map<String, Object>> maps = queryMaps(sql, params);
		// 遍历集合中每一条数据(map)
		maps.forEach(m -> {
			// 将map转换为Javabean
			T obj = mapToBean(m, t);
			// 将Javabean装入list
			list.add(obj);
		});
		return list;
	}

	/**
	 * 将Map集合转换为一个确定的类型
	 * 
	 * @param <T>
	 * @param map
	 * @param t
	 * @return
	 */
	private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
//		T obj = null;
		try {
			// 根据提供的Class对象创建对应类型的Object
			T obj = t.newInstance();
			// 获取Class中的所有Field
//			Field[] fields = t.getDeclaredFields();
//			//遍历获取每一个属性对象
//			for (Field field : fields) {
//				//获取属性名
//				String fname = field.getName();
//				//获取属性值
//				Object value = map.get(fname);
//				if(Objects.nonNull(value)) {
//					//设置属性对象的可访问性
//					field.setAccessible(true);
//					//将从map中获取的值设置给属性  obj.name=XX
//					field.set(obj, value);
//				}
//			}
			map.forEach((k, v) -> {
				try {
					// 根据Field名称获取字段对象
					Field field = t.getDeclaredField(k);
					// 设置字段的可访问性
					field.setAccessible(true);
					// 为字段设置值
					field.set(obj, v);
				} catch (NoSuchFieldException e) {
					e.printStackTrace();
				} catch (SecurityException e) {
					e.printStackTrace();
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				}
			});
			return obj;
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		// 返回对象
		return null;
	}

	/**
	 * 执行相关查询并将结果返回为List<Map<String,Object>> 集合
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
		// 声明动态数组用于存储每一个查询到的Map对象
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		// 获取连接
		Connection conn = getConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			// 获取预处理sql命令的对象
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					// 对指定位置的占位符填充值（预处理）
					ps.setObject(i + 1, params[i]);
				}
			}
			// 执行查询获取结果集
			rs = ps.executeQuery();
			// 获取结果集的元数据对象ResultSetMetaData
			ResultSetMetaData rsmd = rs.getMetaData();
			// 获取总查询列数
			int columnCount = rsmd.getColumnCount();
			// 遍历结果集
			while (rs.next()) {
				// 声明map集合存储每一条数据（临时缓存）
				Map<String, Object> map = new HashMap<String, Object>();
				// 遍历获取每一列的信息
				for (int i = 1; i <= columnCount; i++) {
					// 获取列名称（作为map集合的键）
					String key = rsmd.getColumnName(i);
					// 获取列标签
					String label = rsmd.getColumnLabel(i);
					// 获取列值（作为map集合的值）
					Object value = rs.getObject(label);
					if (Objects.nonNull(value)) {
						// 将取到的每一列的列名与列值存储到map
						map.put(key, value);
					}
				}
				// 将map集合装入list
				list.add(map);
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(rs, ps, conn);
		}
		return list;
	}

	/**
	 * 根据提供的查询语句以及查询参数，返回符合条件的数目
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public static int queryCount(String sql, Object... params) {
		Connection conn = getConn();
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			if (params != null) {
				for (int i = 0; i < params.length; i++) {
					ps.setObject(i + 1, params[i]);
				}
			}
			rs = ps.executeQuery();
			if(rs.next()) {
				return rs.getInt(1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			close(rs, ps, conn);
		}
		return 0;
	}

}

连接池技术

由于数据库连接是一种资源，这种资源在使用前必须先创建，而这个创建过程是存在时间和空间的开销的，如果每次在执行数据库访问时都创建连接，并且使用完后要关闭连接，这个过程必然是效率低下的;因此，在实际开发中可以考虑在进行数据库操作前，先提前创建并维护一批数据库连接对象，当需要使用时，从这批对象中获取一个连接，用完之后再返还，从而避免了不必要的时间开销，提高程序的运行效率，这种技术在JDBC中称之为连接池技术（Connection Pool）.

在这里插入图片描述

目前比较常用的连接池技术包含:apache-DBCP、C3P0(Spring/Hibernate框架在使用)、Proxool、阿里巴巴的Druid以及HikariCP（SpringBoot2.0默认连接池），这里我们分别使用Druid和HikariCP连接池:

Druid连接池使用

使用前先导入Druid的依赖:druid-1.1.9.jar

实现代码：

public class DruidDemo {

	public static void main(String[] args) throws SQLException {

		// 创建数据源
		DruidDataSource dataSource = new DruidDataSource();
//		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");
		// 设置最大链接数
		dataSource.setMaxActive(5);
		// 最小闲置链接数
		dataSource.setMinIdle(1);
		// 初始连接个数
		dataSource.setInitialSize(2);
		// 设置获取连接的最大等待时间
		dataSource.setMaxWait(10000);
	

		// 获取连接
		Connection conn1 = dataSource.getConnection();
		System.out.println("conn1:" + conn1);
		
		Connection conn2 = dataSource.getConnection();
		System.out.println("conn2:" + conn2);
		
		Connection conn3 = dataSource.getConnection();
		System.out.println("conn3:" + conn3);
		
		Connection conn4 = dataSource.getConnection();
		System.out.println("conn4:" + conn4);	
		new Thread() {
			public void run() {
				try {
					sleep(15000);
					//关闭第四个连接
					conn4.close();
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			};
		}.start();
		
		Connection conn5 = dataSource.getConnection();
		System.out.println("conn5:" + conn5);
		
		Connection conn6 = dataSource.getConnection();
		System.out.println("conn6:" + conn6);

	}
}

HikariCP使用

HikariCP使用需要以下几个依赖:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WlZ0GLXH-1596787504824)(assets\1596621762539.png)]

实现代码：

public class HikariCPDemo {

	public static void main(String[] args) throws SQLException {
		
		HikariDataSource ds = new HikariDataSource();
		ds.setDriverClassName("com.mysql.jdbc.Driver");
		ds.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
		ds.setUsername("root");
		ds.setPassword("123456");
		//设置最大链接数
		ds.setMaximumPoolSize(10);
		//设置最小闲置连接
		ds.setMinimumIdle(1);
		//设置最长等链接获取时间
		ds.setConnectionTimeout(10000);
		
		Connection conn = ds.getConnection();
		System.out.println(conn);
	}
}

通用工具类

/*
 * #                                                    __----~~~~~~~~~~~------___
 * #                                   .  .   ~~//====......          __--~ ~~
 * #                   -.            \_|//     |||\\  ~~~~~~::::... /~
 * #                ___-==_       _-~o~  \/    |||  \\            _/~~-
 * #        __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~
 * #    _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /
 * #  .~       .~       |   \\ -_    /  /-   /   ||      \   /
 * # /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /
 * # |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\
 * #          '         ~-|      /|    |-~\~~       __--~~
 * #                      |-~~-_/ |    |   ~\_   _-~            /\
 * #                           /  \     \__   \/~                \__
 * #                       _--~ _/ | .-~~____--~-/                  ~~==.
 * #                      ((->/~   '.|||' -_|    ~~-/ ,              . _||
 * #                                 -_     ~\      ~~---l__i__i__i--~~_/
 * #                                 _-~-__   ~)  \--______________--~~
 * #                               //.-~~~-~_--~- |-------~~~~~~~~
 * #                                      //.-~~~--\
 */

/*
 * #                                                    __----~~~~~~~~~~~------___
 * #                                   .  .   ~~//====......          __--~ ~~
 * #                   -.            \_|//     |||\\  ~~~~~~::::... /~
 * #                ___-==_       _-~o~  \/    |||  \\            _/~~-
 * #        __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~
 * #    _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /
 * #  .~       .~       |   \\ -_    /  /-   /   ||      \   /
 * # /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /
 * # |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\
 * #          '         ~-|      /|    |-~\~~       __--~~
 * #                      |-~~-_/ |    |   ~\_   _-~            /\
 * #                           /  \     \__   \/~                \__
 * #                       _--~ _/ | .-~~____--~-/                  ~~==.
 * #                      ((->/~   '.|||' -_|    ~~-/ ,              . _||
 * #                                 -_     ~\      ~~---l__i__i__i--~~_/
 * #                                 _-~-__   ~)  \--______________--~~
 * #                               //.-~~~-~_--~- |-------~~~~~~~~
 * #                                      //.-~~~--\
 */

/*
 * #                                                    __----~~~~~~~~~~~------___
 * #                                   .  .   ~~//====......          __--~ ~~
 * #                   -.            \_|//     |||\\  ~~~~~~::::... /~
 * #                ___-==_       _-~o~  \/    |||  \\            _/~~-
 * #        __---~~~.==~||\=_    -_--~/_-~|-   |\\   \\        _/~
 * #    _-~~     .=~    |  \\-_    '-~7  /-   /  ||    \      /
 * #  .~       .~       |   \\ -_    /  /-   /   ||      \   /
 * # /  ____  /         |     \\ ~-_/  /|- _/   .||       \ /
 * # |~~    ~~|--~~~~--_ \     ~==-/   | \~--===~~        .\
 * #          '         ~-|      /|    |-~\~~       __--~~
 * #                      |-~~-_/ |    |   ~\_   _-~            /\
 * #                           /  \     \__   \/~                \__
 * #                       _--~ _/ | .-~~____--~-/                  ~~==.
 * #                      ((->/~   '.|||' -_|    ~~-/ ,              . _||
 * #                                 -_     ~\      ~~---l__i__i__i--~~_/
 * #                                 _-~-__   ~)  \--______________--~~
 * #                               //.-~~~-~_--~- |-------~~~~~~~~
 * #                                      //.-~~~--\
 */

package lesson52.utils;

import com.alibaba.druid.pool.DruidDataSource;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;


/**
 * ORM框架 (Mybatis )
 * 数据库工具类v2.0
 * 将访问的数据库的公共代码抽取
 * 1.加载驱动
 * 2.获取连接
 * 6.关闭资源
 *
 * @author 法海打印
 */
public class DBUtils {
    /**
     * 驱动类路径
     */
    private static String DRIVER_CLASS;
    /**
     * url地址
     */
    private static String URL;
    /**
     * 数据库服务器登录用户名
     */
    private static String USER;
    /**
     * 数据库服务器登录密码
     */
    private static String PASSWORD;

    /**
     * 最大活动连接数
     */
    private static int MAX_ACTIVE;
    /**
     * 最长等待连接获取的时间
     */
    private static long MAX_WAIT;
    /**
     * 初始连接数
     */
    private static int INIT_SIZE;
    /**
     * 声明连接池引用
     */
    private static DruidDataSource ds;


    static {
        try {
            //读取属性文件获取连接数据库的相关字符串
            InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
            //创建属性对象
            Properties p = new Properties();
            //加载包含属性信息的输入流
            p.load(is);

            //根据属性名获取属性值
            DRIVER_CLASS = PASSWORD = p.getProperty("driver");
            URL = p.getProperty("url");
            USER = p.getProperty("user");
            PASSWORD = p.getProperty("password");

            //获取连接池相关配置
            MAX_ACTIVE = Integer.parseInt(p.getProperty("pool.maxActive"));
            INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
            MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));

            //初始化连接池
            init();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 初始化连接池
     */
    public static void init() {
        ds = new DruidDataSource();
        ds.setDriverClassName(DRIVER_CLASS);
        ds.setUrl(URL);
        ds.setUsername(USER);
        ds.setPassword(PASSWORD);
        ds.setMaxActive(MAX_ACTIVE);
        ds.setInitialSize(INIT_SIZE);
        ds.setMaxWait(MAX_WAIT);
    }


    /**
     * 2.获取数据库连接对象
     * synchronized 线程私有
     *
     * @return
     */
    public static synchronized Connection getConn() {
        try {
            //当连接池为null或者被关闭时,重新创建
            if (ds == null || ds.isClosed()) {
                init();
            }
            //从链接中获取一个连接并返回
            return ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 6.关闭资源
     *
     * @param rs
     * @param stat
     * @param conn
     */
    public static void close(ResultSet rs, Statement stat, Connection conn) {
        try {
            if (rs != null) {
                rs.close();
            } ;
            if (stat != null) {
                stat.close();
            } ;
            if (conn != null) {
                conn.close();
            } ;
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    /**
     * 封装通用的更新操作: insert update delete
     *
     * @param sql
     * @param params object[] params
     * @return
     */
    public static boolean exeUpdate(Connection conn,String sql, Object... params) {

        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            return ps.executeUpdate() > 0;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            close(null,ps,null);
        }
        return false;
    }

    public static boolean exeUpdate(String sql, Object... params) {
        Connection conn=getConn();
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            return ps.executeUpdate() > 0;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            close(null,ps,conn);
        }
        return false;
    }




    /**
     * 封装通用查询单条数据的方法
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> T queryOne(Class<T> t, String sql, Object... params) {
        //获取查询到的数据集合
        List<Map<String, Object>> list = queryMaps(sql, params);
        if (list.size() > 0) {
            //获取一个Map对象
            Map<String, Object> map = list.get(0);
            //将map集合转换为 javabean
            return mapToBean(map, t);

        }
        return null;
    }


    /**
     * 封装通用查询多条数据的方法
     *
     * @param <T>
     * @param t
     * @param sql
     * @param params
     * @return
     */
    public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
        List<T> list = new ArrayList<T>();
        //获取所有查询到的数据
        List<Map<String, Object>> maps = queryMaps(sql, params);
        //遍历集合中每一条数据(map)
        maps.forEach(m -> {
            T obj = mapToBean(m, t);
            //将javabean装入list
            list.add(obj);
        });
        return list;
    }


    /**
     * 将map集合转换为一个确定的类型
     *
     * @param <T>
     * @param map
     * @param t
     * @return
     */
    private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
        T obj = null;
        try {
            //根据提供的Class对象创建对应类型的objct
            obj = t.newInstance();
            //获取Class中的所有的Filed
            Field[] fields = t.getDeclaredFields();
            //遍历获取每一个属性对象
            for (Field field : fields) {
                //获取属性名
                String fname = field.getName();
                //获取属性值
                Object value = map.get(fname);
                if (Objects.nonNull(value)) {
                    //设置属性对象的可访问性
                    field.setAccessible(true);
                    //将从map获取的属性值设置给属性   obj.XX=value
                    field.set(obj, value);
                }
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        //返回对象
        return obj;
    }


    /**
     * 执行相关查询并将结果返回为List<Map<String, Object>>集合
     *
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
        //声明动态数组用于存储每一个查询到的Map对象
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        //获取连接
        Connection conn = getConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            //获取预处理sql命令的对象
            ps = conn.prepareStatement(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    //对指定位置的占位符填充(预处理)
                    ps.setObject(i + 1, params[i]);
                }
            }
            //执行查询获取结果集
            rs = ps.executeQuery();
            //获取结果集元数据对象 ResultsetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            //获取总列数
            int columnCount = rsmd.getColumnCount();
            //遍历结果集
            while (rs.next()) {
                //声明map集合存储每一条数据(临时)
                Map<String, Object> map = new HashMap<String, Object>();
                //遍历获取每一列的数据
                for (int i = 1; i <= columnCount; i++) {
                    //获取列名称(作为map集合的键)
                    String key = rsmd.getColumnName(i);
                    //获取列标签 (别名,没有的话就是列名)
                    String label = rsmd.getColumnLabel(i);
                    //获取列值(作为map集合的值)
                    Object value = rs.getObject(label);
                    if (Objects.nonNull(value)) {
                        //将取到的每一列的列名与列值存储到map
                        map.put(key, value);
                    }
                }
                //将map集合装入list
                list.add(map);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return list;
    }


    /**
     * 根据提供的查询语句以及查询参数,返回符合条件的数目
     *
     * @param sql
     * @param params
     * @return
     */
    public static int queryCount(String sql, Object... params) {
        Connection conn = getConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareCall(sql);
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getInt(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, conn);
        }
        return 0;
    }

    public static void main(String[] args) {

    }
}

赵恶龙

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java访问数据库学习笔记

day5 - JDBC技术（一）Java访问数据库技术概述在JDBC出现之前，早期java需要访问数据库时，需要根据不同的数据库管理系统(DBMS)编写不同的数据源，使用一项称之为JDBC-ODBC桥链接模式。通过以上访问方式，程序员会在访问数据方面花费大把精力，因此SUN在后来设计的JDBC接口，将访问数据库的具体实现交给不同的数据库厂商各自实现，从而减少java程序的压力。JDBC入门JDBC(Java Database Connectivity),java 链接数据库技术，是由java.s
复制链接

扫一扫