JDBC连接数据库基础（三）

JDBC连接数据库基础（三）

四、JDBC对Sql注入漏洞的处理

• 使用PreparedStatement替换Statement

上一节，我们预先根据用户输入的参数生成完整的sql语句，然后使用Statement对象执行sql语句，实现了增删改查。但我们发现，部分sql是用户来输入的，而且我们也没有做任何的校验处理，这就无法避免用户通过恶意输入来破坏我们的数据库。
比如说下面这种情况，用户输入了' or 1 = '1 ,拼接出了一段查询student表所有数据的sql语句，这会将某些我们不希望被看到的数据呈现给用户。如果这段sql执行的是删除、修改，那后果将是十分恐怖的。

JDBC针对这种情况，给出了另外一种拼接sql的方法，即使用占位符？来替代变量，预先生成一段sql，然后使用PreparedStatement这个对象代替Statement，并把占位符替换成变量。这个过程中，会对引号等做过滤处理，有效的避免了sql注入。

五、使用反射实现自动注入

• 反射

在前面，我们是把查询到结果集根据字段名，一个个地手动匹配注入到对象中。如果采用这种方式，那是很繁琐的，这意味着有多少个实体类，我们就要写多少个针对该实体类的注入方法。
好在Java是强大的，它存在着反射机制，通过反射，我们只要知道类名，就能够去得到这个类里面的方法、字段、字段类型等，甚至可以根据方法名去调用这个方法。
我们来讲讲一点基础的反射知识：
首先是根据一个对象获得它的类：

Class clazz = 对象.getClass();

根据类获得它的方法、字段等：

Field[] fileds  =  clazz.getDeclaredFileds();     //获取所有字段
Field[] fileds = clazz.getFileds();               //获取所有public的字段
Method[] methods  =  clazz.getDeclaredFileds();     //获取所有方法
Method[] methods = clazz.getMethods();               //获取所有public的方法
String name = Filed.getName();					//获得字段名称
Type type = Filed.getType();						//获得字段的数据类型
Method method = clazz.getDeclaredMethod(String 方法名，Type 参数类型)
						........................

还有个最重要的，根据方法对象，和参数列表，调用方法

method.invoke(对象，params[])					//反射调用，调用成功会返回方法返回值

• 工具方法

在注入之前，考虑到数据库和实体类字段书写格式不同，我们先来写两个工具方法，实现驼峰命名和下划线命名互相转换。简单的字符串操作，不需要看懂，当作工具来使用就可以。

/**
     * 转为驼峰命名
     * @param str
     * @return string
     */
    public String underlineTocamel(String str) {
        if (null != str && !"".equals(str)) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0, len = str.length(); i < len; i++) {
                if (str.charAt(i) == '_') {
                    while (str.charAt(i + 1) == '_') {
                        i++;
                    }
                    stringBuilder.append(("" + str.charAt(++i)).toUpperCase());
                } else {
                    stringBuilder.append(str.charAt(i));
                }
            }
            return stringBuilder.toString();
        }
        return str;
    }
    
    //驼峰命名转下划线命名
    public String camelToUnderline(String para){
        StringBuilder sb=new StringBuilder(para);
        int temp=0;//定位
        for(int i=0;i<para.length();i++){
            if(Character.isUpperCase(para.charAt(i))){
                sb.insert(i+temp, "_");
                temp+=1;
            }
        }
        return sb.toString().toUpperCase(); 
	}

在我们开发过程中，遇到像数据库连接参数这种常量时，通常会将它们放在配置文件中，然后通过io流去读取文件来获得参数。
为什么要这样做呢，因为我们的java文件都是编译后成为class文件再部署到服务器上的。如果我们把这些参数写在java文件中，那么在需要修改的时候，就必须在代码环境下修改并编译，然后使用一个新的class文件来替换服务器上面的文件。而写在配置文件中，我们可以直接在服务器上面修改文本。
这里我们先不升级那么快，姑且单独用一个类来存放常量。

package com.zx.util;
/**
 * 存放数据库连接常量
 * @author BMC
 *
 */
public class DataBaseUtil {
	//着你应该看得懂，按照你的数据库修改
	public static final String URL = "jdbc:mysql://localhost:3306/demo";
	public static final String USER = "root";
	public static final String PASSWORD = "root";
	public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
}

考虑到每次都要创建连接和语句对象，我们把它们提取出来（不用跟着我敲，看看就行了，后面会把完整代码发出来）

	//获得连接的方法
	public Connection getConnection() throws SQLException {
		//加载连接驱动
		//Mysql数据库加载这个类   mysql8以后的jar包是加载 com.mysql.cj.jdbc.Driver
		try {
			Class.forName(DataBaseUtil.DRIVERNAME);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//Orcale数据库加载这个类 其他部分都差不多
		//Class.forName("oracle.jdbc.driver.OracleDriver");
		//调用驱动根据url、用户名、密码 创建一个连接
		Connection conn = DriverManager.getConnection(DataBaseUtil.URL, 
				DataBaseUtil.USER, DataBaseUtil.PASSWORD);
		return conn;
	}
	
	//根据sql和参数列表获得语句的方法
	public PreparedStatement getPreparedStatement(String sql,Connection conn,Object... objs) throws SQLException {
		PreparedStatement pstmt = conn.prepareStatement(sql);
		if(null != objs) {
			for(int i = 0;i<objs.length;i++) {
				//从1开始
				pstmt.setObject(i+1, objs[i]);
			}
		}
		return pstmt;
	}
	

• 注入

我们在查询的时候会从数据库获得一个ResultSet，对于每一行我们都要对各个字段进行映射。每一行的字段都是相同的，所以可以把每一行注入的方法抽象出来。通过反射知识，很容易做到。

	//把数据库的一行数据 映射成 对象集合
	/**
	 * @param rs     结果集
	 * @param clazz  实体类类型
	 * @param objs   参数列表
	 * @return
	 */
	public <T> T invoke(ResultSet rs,Class<T> clazz, Object... objs) {
		try {
			//实例化对象
			T object = clazz.getConstructor().newInstance();
			//获取结果集的数据，方便获得每一行
			ResultSetMetaData rsData = rs.getMetaData();
			
			for(int i = 0 ; i< rsData.getColumnCount();i++) {
				//获得当前这一列的列名   以及当前这一列的值
				String columName = rsData.getColumnName(i+1);
				Object columValue = rs.getObject(i+1);
				//接下来我们需要使用反射来调用set方法来进行赋值
				//我们需要：方法名   方法对象   参数类型   参数值
				//转换成驼峰命名
				String fieldName = underlineTocamel(columName);
				//拼接set方法名  注意单词首字母大写
				String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
				//根据字段名 和 传入对象 获得这个字段对象   
				Field field = clazz.getDeclaredField(fieldName);
				//根据字段对象获得字段类型
				Class type = field.getType();
				//根据方法名 和 方法参数类型 获得方法
				Method method = clazz.getDeclaredMethod(methodName,type);
				method.invoke(object,columValue);	
			}
			return object;
		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
				| NoSuchMethodException | SecurityException | SQLException | NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

Object... objs 这种使用...的参数类型，表示可传入任意多个Object类型的参数，可以为空。我们可以通过操作objs这个数组来获得传入的参数列表。特别的，如果只传入一个参数，且这个参数类型为数组，数组会被拆分成参数列表，有兴趣的可以试一下。
<T> T 表示是泛型，java1.5以后增加的类型，可以表示任意类型

这样我们就能完成每一行的映射了

	//自定义查询方法
	/**
	 * @param sql   sql语句
	 * @param clazz 映射实体类的Class
	 * @param objs  参数列表
	 * @return
	 * @throws SQLException
	 */
	public <T> List myQuery(String sql,Class<T> clazz,Object... objs){
		Connection conn = null;
		List list = new ArrayList();
		//工具方法中就捕获异常，避免使用时要处理
		try {
			conn = getConnection();
			PreparedStatement pstmt = getPreparedStatement(sql,conn, objs);
			ResultSet rs = pstmt.executeQuery();
			
			while(rs.next()) {
				T t = invoke(rs, clazz, objs);
				list.add(t);
			}
			//查询完毕关闭资源
			closeAll(conn, pstmt, rs);
		}catch(SQLException sqlException) {
			sqlException.printStackTrace();
		}
		return list;
	}

编写个测试类测试一下

/**
 * 测试类
 * @author BMC
 *
 */
package com.zx.test;

import java.lang.reflect.InvocationTargetException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.zx.dao.MyDAO;
import com.zx.domain.Student;

/**
 * 测试类
 * @author BMC
 *
 */
public class Test {
	
	public static void main(String[] args) {
		MyDAO myDAO = new MyDAO();
		String sql = "select * from student";
		List<Student> list = new ArrayList<Student>();
		//返回的是一个list  如果只有一条结果，就(Student)list.get(0),注意强转类型
		list = myDAO.myQuery(sql, Student.class, null);
		for(Student stu : list) {
			System.out.println(stu.getName());
		}
//		Student stu = new Student();
//		stu.setName("海绵宝宝");
//		stu.setClassId(3);
//		stu.setUsername("haimianbaobao");
//		stu.setPassword("123456");
//		stu.setAge(22);
//		//Orcale主键一般需要根据序列来获取，但是mysql有自增，不需要赋值
//		stu.setId(9);
//		stu.setTest(null);
//
//		new MyDAO().SaveObject(stu);
//			
	}	
}

查询结果如下（报错是因为我驱动导的不对，建议最新版本jar包，但旧版本也可以用）：

最后，再附上其他增删改的方法，注意，删除和修改通常是需要根据主键来删除，视情况而定，所以需要用户手动书写sql来执行。

/**
	 * 根据传入的object  插入一条数据
	 * @param obj
	 * @throws SQLException
	 * @throws SecurityException 
	 * @throws NoSuchMethodException 
	 * @throws InvocationTargetException 
	 * @throws IllegalArgumentException 
	 * @throws IllegalAccessException 
	 */
	public <T> int SaveObject(Object obj) {
		Connection conn = null;
		int result = 0;
		try {
			conn = getConnection();
			List list = new ArrayList<>();
			//获得表名和字段以生成sql
			String tableName = obj.getClass().getSimpleName();
			StringBuffer sql = new StringBuffer();
			sql.append("insert into ").append(tableName).append("(");
			//拼接sql
			Field[] fileds = obj.getClass().getDeclaredFields();
			if(null != fileds && fileds.length != 0) {
				for(int i = 0;i<fileds.length;i++) {
					String columName = camelToUnderline(fileds[i].getName());
					sql.append(columName);
					if(i < fileds.length - 1) sql.append(",");
					String methodName = "get" + fileds[i].getName().substring(0, 1).toUpperCase() + fileds[i].getName().substring(1);
					Method method = obj.getClass().getDeclaredMethod(methodName);
					list.add(method.invoke(obj));
				}
				sql.append(") values(");
				for(int i = 0;i<fileds.length;i++) {
					sql.append("?");
					if(i < fileds.length - 1) sql.append(",");
				}
				sql.append(")");
				PreparedStatement pstmt = getPreparedStatement(sql.toString(),conn, list.toArray());

				result = pstmt.executeUpdate();
				closeAll(conn, pstmt, null);
				
			}
		}catch(SQLException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException sqlException){
			
		}
		
		return result;
	}
	
	
//删除   根据具体sql删除
	public int Delete(String sql,Object...objs) {
		int result = 0;
		Connection conn;
		try {
			conn = getConnection();
			PreparedStatement pstmt = getPreparedStatement(sql,conn,objs);
			result = pstmt.executeUpdate();
			closeAll(conn, pstmt, null);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}
	
	//更新   根据具体sql更新
	public int Update(String sql,Object...objs) {
		int result = 0;
		Connection conn;
		try {
			conn = getConnection();
			PreparedStatement pstmt = getPreparedStatement(sql,conn,objs);
			result = pstmt.executeUpdate();
			closeAll(conn, pstmt, null);
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}