jdbc玩出hibernate的感觉.docx

jdbc玩出hibernate的感觉.docx

《jdbc玩出hibernate的感觉.docx》由会员分享，可在线阅读，更多相关《jdbc玩出hibernate的感觉.docx（17页珍藏版）》请在冰豆网上搜索。

jdbc玩出hibernate的感觉

用jdbc也能玩出Hibernate的感觉（jdbc.rar为源码）

近期完成一个项目，持久层依旧采用jdbc，因为公司的技术比较落后，项目也不大 

采用框架的话，其他同事的要花费时间来学习，成本比较大，但jdbc大量的重复代码，有的时候真的崩溃 

apache的开源框架db_util也用过，感觉不是很顺手 

想想算了，自己封装一层，简单的以操作对象的形式完成数据库的调用，这样会节省开发时间 

下面说一下基本思路 

1.定义简单的配置文件jdbc.hbm.xml，里面仅仅给出每一个实体类中主键的生成方式，自增的还是手动配置的 

Java代码 

1.

xml version="1.0" encoding="UTF-8"?

>  

2.  

3.    

-- 定义实体类路径 -->  

4.      

5.        

-- 实体中对应表中的主键，及数据类型 -->  

6.          

7.            

-- 主键生成方式 ，其中assigned 为手动配置，identity为数据库自增长 -->  

8.              

9.          

10.      

11.      

12.          

13.              

14.          

15.      

16.      

17.          

18.              

19.          

20.      

21.  

2.在项目启动时，加载所有的实体类并与配置文件jdbc.hbm.xml进行比对，判断jdbc.hbm.xml中定义的类、属性、类型在每一个实体类中是否存在 

Java代码 

1.       private static final Log log = LogFactory.getLog（ValidConfig.class）;  

2.  

3.private static final String ELEMENT_NODE_CLASS = "class";  

4.  

5.private static final String ELEMENT_NODE_ID = "id";  

6.  

7.private static final String ELEMENT_ATTR_NAME = "name";  

8.  

9.private static final String ELEMENT_ATTR_PRIMITIVE = "type";  

10.  

11.private static final String ELEMENT_NODE_GENERATOR = "generator";  

12.  

13.private static final String ELEMENT_ATTR_GENERATOR = "class";  

14.  

15.private ValidConfig（）{  

16.      

17.}  

18.  

19./** 

20. * 加在jdbc.hbm.xml配置文件并解析 

21. *  

22. * @throws AppException 

23. */  

24.public static void loadXml（String path） throws AppException {  

25.    // 加在XML所在路径  

26.    XMLFactory factory = XMLFactory.getInstance（path）;  

27.    // 获取根元素下的子节点  

28.    Element rootElement = factory.getRootElement（）;  

29.    // 获取节点集合  

30.    List eles = rootElement.elements（ELEMENT_NODE_CLASS）;  

31.    try {  

32.        iteratorNodes（eles）;  

33.    } catch （Exception e） {  

34.        throw new AppException（e）;  

35.    }  

36.}     

37.  

38./** 

39. * 遍历所有节点 

40. * @param elements 

41. * @throws Exception 

42. */  

43.public static void iteratorNodes（List elements） throws Exception{  

44.    if（elements.isEmpty（））{  

45.        return ;  

46.    }  

47.    for （Element ele :

 elements） {  

48.        String clazz = ele.attributeValue（ELEMENT_ATTR_NAME）;  

49.        Element eleId = ele.element（ELEMENT_NODE_ID）;  

50.        String pk = eleId.attributeValue（ELEMENT_ATTR_NAME）;  

51.        String type = eleId.attributeValue（ELEMENT_ATTR_PRIMITIVE）;  

52.        try {  

53.            // 验证节点信息  

54.            Object clazzInstance = validInfo（clazz, pk, type）;  

55.              

56.            // 遍历到element的generator节点并获取其指定的主键生成方式  

57.            Element generator = eleId.element（ELEMENT_NODE_GENERATOR）;  

58.            String generator_class = generator.attributeValue（ELEMENT_ATTR_GENERATOR）;  

59.            XMLElementEntity entity = new XMLElementEntity（）;  

60.            entity.setClazzName（clazzInstance）;  

61.            entity.setGenerator（generator_class）;  

62.            entity.setPkName（pk）;  

63.            entity.setPrimitive（type）;  

64.            // 以类名称做为KEY ，保存对象信息  

65.            Constants.entityInfo.put（clazzInstance, entity）;  

66.        } catch （Exception e） {  

67.            throw new AppException（e）;  

68.        }  

69.    }  

70.}  

71.  

72./** 

73. * 验证配置文件信息是否正确 

74. * 定义的类、属性及数据类型是否正确 

75. * @param clazz 

76. * @param primaryKey 

77. * @param type 

78. * @return 

79. * @throws Exception 

80. */  

81.public static Object validInfo（String clazz, String primaryKey, Object type） throws Exception{  

82.    try {  

83.        Object clazzInstance = Class.forName（clazz）.newInstance（）;  

84.        // valid class Fields   

85.        if （!

validField（clazzInstance, primaryKey, type）） {  

86.            throw new AppException（"[jdbc.hbm.xml] can't cast fieldType with "+ primaryKey +" "+ type + " in "+ clazz）;  

87.        }  

88.        // split（"@"） ：

class@十进制哈希值,取类名  

89.        return clazzInstance.toString（）.split（"@"）[0];  

90.    } catch （ClassNotFoundException e） {  

91.        throw new AppException（"[jdbc.hbm.xml] can't find class -- "+ clazz）;  

92.    }   

93.}  

94.  

95./** 

96. * 验证属性 

97. * 比对类中的元素所对应的数据类型是否与jdbc.hbm.xml配置文件中所对应的数据类型一致 

98. * @param clazz 

99. * @param primaryKey 

100. * @param type 

101. * @return 

102. * @throws Exception 

103. */  

104.public static boolean validField（Object clazz, String primaryKey, Object primitivType） throws Exception{  

105.    try {  

106.        // 在当前指定类中查找相应属性 【以下必须传一个已经实例化的对象，才能查询类中的所有 属性】  

107.        Field field = clazz.getClass（）.getDeclaredField（primaryKey）;  

108.        // 获取元素数据类型  

109.        String fieldType = MethodUtil.changeWrapClass（field.getType（））;  

110.        if （primitivType.equals（fieldType）） {  

111.            return true;  

112.        }  

113.    } catch （NoSuchFieldException e） {  

114.        throw new AppException（"[jdbc.hbm.xml] can't find field "+ primaryKey +" in "+ clazz）;  

115.    }  

116.    return false;  

117.}  

3.封装baseDAO，进行统一操作，此处就摘取部分操作对象的代码 

当需要保存一个实体对象的时 

Java代码 

1.public int executeUpdate（String sql, Object entity） throws Exception{  

2.        // 验证基本数据类型  

3.        if （MethodUtil.isWrapClass（entity.getClass（））） {  

4.            return executeUpdate（sql, new Object[] { entity }）;  

5.        }  

6.        int result = 0;  

7.        pstm = null;  

8.        try {  

9.            this.conn = ConnectionManager.getInstance（）.getConnection（）;  

10.            pstm = getPreparedStatementViaEntity（this.conn, sql, entity）;  

11.            result = pstm.executeUpdate（）;  

12.        } catch （Exception e） {  

13.            throw e;  

14.        } finally {  

15.            closeConnection（）;  

16.        }  

17.        return result;  

18.    }  

这里首先会判断参数entity是否是一个基本数据类型还是常用的数据类型，比如String,Date等 

当传递参数的时候可能只有一个参数，比如id，而这个id可能是基本数据类型，也可能是常用数据类型所以要在这做一个判断，如果不是常用数据类型则当实体类 

当entity是一个常用数据类型的时候，调用另一个方法 

Java代码 

1.public int executeUpdate（String sql, Object[] params） throws Exception {  

2.    int result = 0;  

3.    try {  

4.        conn = ConnectionManager.getInstance（）.getConnection（）;  

5.        pstm = getPreparedStatementViaParams（conn, sql, params）;  

6.        result = pstm.executeUpdate（）;  

7.    } catch （Exception e） {  

8.        throw e;  

9.    } finally {  

10.        closeConnection（）;  

11.    }  

12.    return result;  

13.}  

这里就直接对sql语句中带有的?

进行了赋值操作 

Java代码 

1.pstm = getPreparedStatementViaEntity（this.conn, sql, entity）;  

这一步获取PrepareStatement对象，通过名字可以看出此处要操作的对象是实体类，而不是普通的参数数组 

Java代码 

1.public PreparedStatement getPreparedStatementViaEntity（Connection conn, String sql, Object entity） throws Exception {  

2.        if （null !

= conn） {  

3.            this.conn = conn;  

4.        }  

5.        pstm = conn.prepareStatement（sql）;  

6.        List