Java利用反射机制实现简单ORM框架
站长
· 阅读数 50
最近帮一个朋友整他的课设，要求使用jsp和servlet以及mysql实现一个系统，Dao层的部分如果不借助Hibernate或者mybatis框架的话，就需要写很多的原生SQL，而且还需要处理ResultSet，最主要的是，每一个功能都需要写一个Dao文件，里面有很多需求相似的语句，可能会重复很多遍差不多的SELECT、UPDATE、DELETE语句，作为完成任务这样写肯定没问题，但是略枯燥，正好最近又看了看反射，决定用反射加原生SQL实现一个最简单的ORM框架，能够解决基本需求就够了。
1.命名约定
为了简化问题，首先表和实体类命名必须遵守某种规范，否则需要自己写一些配置的注解等去进行映射，这样会增加通用性但是没有必要，够用就行了。这里描述一下实体类和表的命名约定。
1.1.表名
表名采用小写字母加下划线的方式，多个单词之间用下划线隔开，如user_group这样，其中的字段也这么命名。
1.2.实体类名
实体类名使用驼峰式命名法，以Entity结尾，实体类命名与对应的表的名称有关，就是将各单词之间用大写的方式分隔开，如user_group表对应的实体类为userGroupEntity，类成员也按驼峰式命名。
2.声明Dao层抽象父类
这里我声明了一个拥有泛型的抽象父类BaseDao，泛型以后会指明为对应的实体类
public abstract class BaseDao<T> {}
使用泛型的好处是可以通过反射等操作获取实体类名，可以在类中定义一个Class对象保存实体类并在构造方法中获取实体类的值
private Class<T> entityClass;
public BaseDao() {
this.entityClass = null;
Class<?> c = getClass();
Type type = c.getGenericSuperclass();
if (type instanceof ParameterizedType) {
Type[] parameterizedType = ((ParameterizedType) type).getActualTypeArguments();
this.entityClass = (Class<T>) parameterizedType[0];
}
}
3.编写辅助方法
根据之前定义的命名方式，我们需要编写一个变量名从java方式到sql方式转换的方法：
/**
* 获取sql形式的变量名
* @param str Java格式变量名
* @return
*/
public String getSqlFieldName(String str){
for(int i=0;i<str.length();i++){
if(i!=0 && str.charAt(i) > 'A' && str.charAt(i) < 'Z'){
str = str.replace(""+str.charAt(i),"_" + (char)(str.charAt(i) - 'A' + 'a'));
}
}
return str.toLowerCase();
}
获取实体类表名的方法，通过实体类和刚才的转换方法可以轻松完成：
/**
* 获取表名
* @return
*/
private String getTableName(){
String tableNames[] = entityClass.getTypeName().split("\\.");
String tableName = tableNames[tableNames.length-1];
tableName = tableName.substring(0,tableName.length()-6);
tableName = getSqlFieldName(tableName);
return tableName;
}
最后实现一个获取数据库连接的方法：
/**获得数据库的连接，以进行其他操作
*
* @return 数据库连接
*/
protected Connection getConnect(){
Connection connection=null;
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try {
connection = DriverManager.getConnection(URL+DATEBASE,USERNAME,PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
4.编写根据sql执行的方法
这里的方法有三个，一个是直接执行无返回值的execute，一个查询返回一个对象queryOne，一个查询返回对象列表queryList，他们参数都有两个，一个是设置了占位符的字符串类型SQL语句，一个是Object类型的参数数组。 既然使用了占位符，肯定要使用PreparedStatement语句，这三个方法都需要给它设置参数，所以我抽象出一个方法获取设置好了参数的PreparedStatement对象，只需要根据参数的类型调用对应的set方法即可：
protected PreparedStatement getPreparedStatement(Connection connection,String sql,Object [] params) throws SQLException {
// 预准备语句
PreparedStatement ps = connection.prepareStatement(sql);
if(params == null)
return ps;
int index = 1;
// 设置参数
for(int i=0;i<params.length;i++){
Object param = params[i];
if(param == null)
continue;
if(param.getClass() == Integer.class){
ps.setInt(index++, (Integer) param);
}else if(param.getClass() == Double.class){
ps.setDouble(index++, (Double) param);
}else if(param.getClass() == String.class){
ps.setString(index++, (String) param);
}else if(param.getClass() == Long.class){
ps.setLong(index++,(Long)param);
}
}
return ps;
}
之后就可以实现execute方法了，只需要获取连接，获取预处理语句，最后关闭连接即可：
/**
* 执行sql
* @param sql SQL语句
* @param params 参数
* @throws SQLException
*/
protected void execute(String sql,Object[] params) throws Exception {
// 获取连接
Connection connection = getConnect();
// 设置准备语句
PreparedStatement ps = getPreparedStatement(connection,sql,params);
// 执行
ps.execute();
// 关闭
connection.close();
}
接下来是两个略微复杂的查询方法，之所以查询，是因为要处理ResultSet，于是这里我实现了一个根据ResultSet直接自动填充获取实体类的方法：
/**
* 根据result获取实体
* @param resultSet
* @return
*/
public Object getEntity(ResultSet resultSet) throws IllegalAccessException, InstantiationException, SQLException {
// 新建实体类
Object object = entityClass.newInstance();
// 获取成员变量
Field fields[] = entityClass.getDeclaredFields();
// 处理所有成员变量
for(Field field:fields){
// 设置可访问
field.setAccessible(true);
if(field.getType().equals(int.class)){
// 设置int型变量
field.setInt(object,resultSet.getInt(getSqlFieldName(field.getName())));
}else if(field.getType().equals(String.class)){
// 设置String型变量
field.set(object,resultSet.getString(getSqlFieldName(field.getName())));
}else if(field.getType().equals(double.class)){
// 设置String型变量
field.set(object,resultSet.getDouble(getSqlFieldName(field.getName())));
}else if(field.getType().equals(Timestamp.class)){
// 设置timestamp型变量
field.set(object,resultSet.getTimestamp(getSqlFieldName(field.getName())));
}else if(field.getType().equals(long.class)){
field.set(object,resultSet.getLong(getSqlFieldName(field.getName())));
}
}
return object;
}
有了这个方法查询一个对象就会变得简单不少，查询多个对象只需要解析多次获取多个实体类即可，于是可以实现两个query方法：
/**
* 查询一个列表
* @param sql SQL语句
* @param params 参数列表
* @return 返回结果
* @throws SQLException
*/
protected List<T> queryList(String sql,Object...params) throws Exception {
// 获取连接
Connection connection = getConnect();
// 设置准备语句
PreparedStatement ps = getPreparedStatement(connection,sql,params);
// 获取结果集
ResultSet res = ps.executeQuery();
// 新建结果列表
List<T> list = new ArrayList<>();
while(res.next()){
T t = (T) getEntity(res);
list.add(t);
}
// 关闭
connection.close();
// 返回结果
return list;
}
/**
* 查询一条
* @param sql SQL语句
* @param params 参数列表
* @return 执行结果
* @throws SQLException
*/
protected T queryOne(String sql,Object...params) throws Exception {
// 获取连接
Connection connection = getConnect();
// 设置准备语句
PreparedStatement ps = getPreparedStatement(connection,sql,params);
// 获取结果集
ResultSet res = ps.executeQuery();
T t;
if(res.next()){
t = (T) getEntity(res);
}else {
t = null;
}
// 关闭
connection.close();
// 返回结果
return t;
}
有了这些方法，我们便可以在子类中简化SQL的编写填充，此外后面的增删改查也是基于这些方法的。
5.编写实体类的增删查改方法
首先是增的save方法，这里我动态构造了SQL语句与参数列表，然后调用execute方法进行实际的执行，而构造的原理也是基于反射的：
/**
* 常规保存方式
* @param t
*/
public void save(T t) throws Exception{
String tableName = getTableName();
// 构造SQL语句
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.append("INSERT INTO ").append(tableName).append("(");
Field[] fields = entityClass.getDeclaredFields();
Object params[] = new Object[fields.length];
for(int i=0;i<fields.length;i++){
fields[i].setAccessible(true);
params[i] = fields[i].get(t);
}
for(int i=0;i<fields.length;i++){
if(params[i] != null)
sqlBuilder.append(getSqlFieldName(fields[i].getName())).append(",");
}
sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
sqlBuilder.append(")");
sqlBuilder.append(" VALUES(");
for(int i=0;i<fields.length;i++){
if(params[i] != null)
sqlBuilder.append("?,");
}
sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
sqlBuilder.append(")");
execute(sqlBuilder.toString(),params);
}
删除和查询方法就更简单了，甚至不需要使用反射，只需要拿到主键的值即可，构造sql语句后分别调用execute方法和queryOne方法：
/**
* 根据主键获取某个对象
* @param id 主键
* @return
* @throws Exception
*/
public T get(Object id) throws Exception {
String tableName = getTableName();
String sql = "SELECT * FROM " + tableName + " WHERE id=?";
return queryOne(sql,id);
}
/**
* 删除表中某一个数据
* @param id 主键
*/
public void delete(Object id) throws Exception {
String tableName = getTableName();
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.append("DELETE FROM ").append(tableName).append(" WHERE id=?");
Object[] params = {id};
execute(sqlBuilder.toString(),params);
}
对于更改，本来我想直接传入实体类对象作为参数，但因为没有缓存的缘故，要么就把一个记录所有的字段都更新了，要么就查询找出发生变化的字段更新。但这两种的代价都太大，所以我决定传入发生变化成员-值映射字典进行更新，当然更新还需要指明主键，同样需要动态构造SQL语句：
/**
* 更新数据库中某一个对象
* @param id 对象主键
* @param paramMap 需要进行改变的成员-成员值映射
*/
public void update(Object id, Map<String,Object> paramMap) throws Exception {
String tableName = getTableName();
// 构造SQL语句
StringBuilder sqlBuilder = new StringBuilder();
sqlBuilder.append("UPDATE ").append(tableName).append(" SET ");
// 获取Map的键集合
Set<String> set = paramMap.keySet();
for(String key:set){
sqlBuilder.append(key).append("=").append("?,");
}
sqlBuilder.deleteCharAt(sqlBuilder.length()-1);
sqlBuilder.append(" WHERE id=?");
Object params[] = new Object[set.size()+1];
int index = 0;
for(String key:set){
params[index++] = paramMap.get(key);
}
params[index] = id;
execute(sqlBuilder.toString(),params);
}
最后是一个多条记录的查询，利用lastId和length来实现分页：
/**
* 获取下一页的对象列表
* @param lastId
* @param length
*/
public List<T> getNextPage(Object lastId,int length) throws Exception {
String tableName = getTableName();
StringBuilder sqlBuilder = new StringBuilder().append("SELECT * FROM " + tableName + " WHERE id>? LIMIT ");
sqlBuilder.append(length);
Object params[] = {lastId};
return queryList(sqlBuilder.toString(),params);
}
到这里，所有基本方法都已经实现了。
6.使用
BaseDao虽然很复杂，但是好处也很明显，就是子类基本上不需要增加什么方法就能实现大部分的业务，当然如果实在是查询过于复杂，也可以自己编写SQL语句，然后调用execute和query那三个方法来执行，但目前为止，还没有那么复杂的业务逻辑，所以基本上Dao层只需要继承一下BaseDao就可以交给Service层使用了：
public class EmployerDao extends BaseDao<EmployerEntity> {
public static void main(String args[]){
EmployerDao employerDao = new EmployerDao();
EmployerEntity employerEntity = null;
try {
employerEntity = employerDao.get("zhang3");
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(employerEntity.getName());
}
}
可见运行正常。
转载自:https://juejin.cn/post/7083728170343464968