解析 JDBC封装过程 & 掌握封装思维

Connection封装

1. 加载驱动在静态代码块中加载

2. 连接数据的信息写在配置文件中

3. 读取配置文件信息通过DriverManager获取conn对象

• JdbcUtils

package packaging.jdbcutils;

import java.io.File;
import java.io.FileReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

import javax.print.DocFlavor.STRING;

import org.junit.Test;


/**
 *  创建所有需要配置的对象
 *  创建properties对象
 *  加载properties
 *  读取properties
 *  安装驱动
 *  创建conn
 *  资源释放 
 *
 */

public class JdbcUtils {

    // 创建所有需要配置的对象 创建properties对象
    static String CLASSDRIVER = "";
    static String URL = "";
    static String USER = "";
    static String PASSWORD = "";
    
    static {

        Properties properties = new Properties();

        try {
            // 加载properties
            properties.load(new FileReader(new File("src/packaging/db.properties")));

        } catch (Exception e) {
            e.printStackTrace();
        }

        // 读取properties
        CLASSDRIVER = properties.getProperty("classdriver");
        URL = properties.getProperty("url");
        USER = properties.getProperty("user");
        PASSWORD = properties.getProperty("password");

        // 安装驱动
        try {
            Class.forName(CLASSDRIVER);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    // 创建conn 
    public static Connection getConn() {
      
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    } 
    
    //资源释放 
    public static void close(AutoCloseable...autoCloseables) {
        for (AutoCloseable autoCloseable : autoCloseables) {
            if (autoCloseable != null) {
                try {
                    autoCloseable.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    @Test
    public void test() {
        Connection conn = JdbcUtils.getConn();
        System.out.println(conn);
    }
}

• db.properties

classdriver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@localhost:1521:orcl
user=scott
password=tiger

update封装

package packaging.updateUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.junit.Test;

import packaging.jdbcutils.JdbcUtils;

/**
 *  增删改
 *      
 *       思路
 *          创建conn
 *          准备sql
 *          获取ps
 *          判断sql占位符是否为空和长度对否为大于0
 *          通过Object设置占位符
 *          执行sql
 *          判断处理结果
 *          释放资源
 *
 */

public class JdbcUpdateUtils {
    
    public static boolean update(String sql, Object[] parameter) {
        
        // 创建conn
        Connection conn = JdbcUtils.getConn();
        
        // 准备sql
        
        PreparedStatement ps = null;
        try {
            // 获取ps
           ps = conn.prepareStatement(sql);

            // 判断sql占位符是否为空和长度对否为大于0
            if (parameter != null && parameter.length > 0) {
                for (int i = 0; i < parameter.length; i++) {
                    // 通过Object设置占位符
                    ps.setObject(i + 1,  parameter[i]);
                    
                }
            }
            
            // 执行sql
            int update = ps.executeUpdate();
            
            // 判断处理结果
            if (update > 0) {
                return true;
                
            } else {
                return false;
                
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            JdbcUtils.close(ps, conn);
            
        }
        return false;
        
    }
    
    
    /**
     * 测试
     */
    @Test
    public void test() {
        String sql = "delete from t_table where id = ?";
        
        Object[] parameter = {4};
        
        boolean update = update(sql, parameter);
        System.out.println(update ? "删除成功" : "删除失败");
    }
    
}

查询的封装

package packaging.queryUtils;

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.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import packaging.bean.Student;
import packaging.jdbcutils.JdbcUtils;

/**
 *  思路
 *      创建conn
 *      准备sql
 *      获取ps
 *      设置占位符
 *      执行sql（获取rs）
 *      通过rs获取matadata
 *      获取列数
 *      循环获取列名
 *      通过列名获取值
 *      创建map
 *      把列名和值存入
 *      创建list
 *      通过反射获取类属性
 *      遍历属性
 *      把属性变成大写
 *      通过map获取值
 *      把值set进list
 *      输出list
 */

public class QueryUtils {

    
    /**
     * 泛型方法的定义: 
     *    1. 存在泛型  
     *    2. 方法中要使用<泛型标记 >在修饰符和方法名之间 
     */
    
    public <T> void test01(T t) {
        
    }
    
    
    
    public static <T> List<T> query(String sql, Object[] parameter, Class<T> clazz) {

        
        // 创建conn
        Connection conn = JdbcUtils.getConn();

        // 准备sql
        //String sql = "select * from t_stu";

        // 获取ps
        PreparedStatement ps = null;
        ResultSet rs = null;
        List<T> list = null;
        try {
            ps = conn.prepareStatement(sql);

            // 设置占位符
            if (parameter != null && parameter.length > 0 ) {
                for (int i = 0; i < parameter.length; i++) {

                    ps.setObject(i + 1, parameter[i]);
                }
            }
            
            // 执行sql（获取rs）
            rs = ps.executeQuery();

            // 创建方法ResultSetToList
            list = getResultSetToList(rs, clazz);

            System.out.println(list);

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

        return list;
    }

• 方法：ResultSet结果集转换成List集合

private static <T> List<T> getResultSetToList(ResultSet rs, Class<T> clazz) {

    List<T> list = new ArrayList<T>();

    // 通过rs获取matadata
    try {
        ResultSetMetaData md = rs.getMetaData();

        while (rs.next()) {

            // 获取列数
            int count = md.getColumnCount();
            // 创建map
            Map<String, Object> map = new HashMap<String, Object>();

            // 循环获取列名
            for (int i = 1; i <= count; i++) {
                // 通过列名获取值
                String columnName = md.getColumnName(i);
                // 把列名和值存入
                map.put(columnName, rs.getObject(columnName));

            }
            //创建方法把map对象转换成bean
            T t = getMapToBean(map, clazz);
            list.add(t);

        }

    } catch (SQLException e) {
        e.printStackTrace();
    }

    return list;
}

• 方法：map集合转换成bean对象

//把map集合转换成bean对象
private static <T> T getMapToBean(Map<String, Object> map, Class<T> clazz) {

    // 创建具体对象
    T t = null;
    try {
        t = clazz.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }

    // 通过反射获取类属性
    Field[] fields = clazz.getDeclaredFields();

    // 遍历属性
    for (Field field : fields) {
        // 把属性变成大写
        String key = field.getName().toUpperCase();
        // 通过map获取值
        Object value = map.get(key);

        // 跳过安全检测
        field.setAccessible(true);

        // 判断什么数据类型
        // 对value调用tostring，在根据属性的类型进行类型转换
        if (field.getType() == int.class) {
            int v = Integer.parseInt(value.toString());
            // 把值set进具体对象
            try {
                field.set(t, v);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (field.getType() == String.class) {
            // 把值set进具体对象
            try {
                field.set(t, value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }
    return t;
}

ResultSetMetaData 类

可用于获取关于 ResultSet 对象中列的类型和属性信息的对象

	说明
ResultSetMetaDate	可用于获取关于 ResultSet 对象中列的类型和属性信息的对象
getMetaData()	获取ResultSetMetaDate
getColumnType(int column)	获取指定列的 SQL 类型
getColumnClassName(int column)	获取指定列的 JAVA 类型
getColumnName(int column)	获取指定列的名称
getColumnCount()	返回此ResultSet 对象中的列数

package packaging.demo01;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

import org.junit.Test;

import packaging.jdbcutils.JdbcUtils01;




/**
 *          
 *          思路
 *              创建conn
 *              准备sql
 *              获取ps
 *              执行sql
 *              通过rs创建resultSetMetaDate
 *              通过ResultSetMetaDate获取列的数量
 *              通过获取的数量进行for循环
 *              获取指定列的名称
 *              获取指定列的sql类型
 *              获取指定列的java类型
 *              
 */

public class Demo01 {
    
    @Test
    public void demo01() {
        
        // 创建conn
        Connection conn = JdbcUtils01.getConn();
        
        // 准备sql
        String sql = "select * from account";
        
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 获取ps
            ps = conn.prepareStatement(sql);
            
            // 执行sql
            rs = ps.executeQuery();

            // 通过rs创建resultSetMetaDate
            ResultSetMetaData md = rs.getMetaData();
            
            // 通过ResultSetMetaDate获取列的数量
            int count = md.getColumnCount();
            
            // 通过获取的数量进行for循环
            for (int i = 1; i <= count; i++) {
                // 获取指定列的名称
                String name = md.getColumnName(i);
                System.out.println(name);
                
                // 获取指定列的sql类型
                String columnType = md.getColumnTypeName(i);
                System.out.println(columnType);
                
                // 获取指定列的java类型
                String columnClassName = md.getColumnClassName(i);
                System.out.println(columnClassName);
            }

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