JDBC连接数据库反射实现O/R映射

2022-11-03 13:06:11

  1. 测试preparedStatement
  1. public void testPreparedStatement(){
  2. Connection connection=null;
  3. PreparedStatement preparedStatement=null;
  4. try{
  5. connection =JDBCTools.getConnection();
  6. String sql="insert into customers(name,email,birth) "+
  7. "values(?,?,?)";
  8. preparedStatement=connection.prepareStatement(sql);
  9. preparedStatement.setString(1, "ATGUIGU");
  10. preparedStatement.setString(2, "simleint@163.com");
  11. preparedStatement.setDate(3, new Date(new java.util.Date().getTime()));
  12. preparedStatement.executeUpdate();
  13. }catch(Exception e){
  14. e.printStackTrace();
  15. }finally{
  16. JDBCTools.release(null, preparedStatement, connection);
  17. }
  18. }
  1. 测试结果集元数据： 利用SQL进行查询，得到结果集。
  1. 利用反射创建实体对象，获取结果集的列的别名。
  1. 在获取结果集的每一列的值，结合3得到一个Map，键的别名，值：列的值。</span>
  1. 再利用反射为2的对应的属性赋值：属性为Map的键，值为Map的值。</span>
 
  1. public void testResultSetMetaData(){
  2. Customer customer=null;
  3. Connection conn=null;
  4. PreparedStatement preparedStatement=null;
  5. ResultSet rs=null;
  6. try{
  7. String sql="select ID id,NAME name,EMAIL email,BIRTH birth from customers";
  8. conn=JDBCTools.getConnection();
  9. preparedStatement=conn.prepareStatement(sql);
  10. 1得到rs
  11. rs=preparedStatement.executeQuery();
  12. Map<String,Object>values=
  13. new HashMap<String,Object>();
  14. //2得到结果集ResultSetMetaData对象。
  15. ResultSetMetaData rsmd=rs.getMetaData();
  16. while(rs.next()){
  17. for(int i=0;i<rsmd.getColumnCount();i++){
  18. String columnLabel=rsmd.getColumnLabel(i+1);
  19. Object columnValue=rs.getObject(columnLabel);
  20. values.put(columnLabel,columnValue);
  21. }
  22. }
  23. System.out.println(values);
  24. Class clazz=Customer.class;
  25. Object object=clazz.newInstance();
  26. for(Map.Entry<String, Object>entry:values.entrySet()){
  27. String fieldName=entry.getKey();
  28. Object fieldValue=entry.getValue();
  29. System.out.println(fieldName+" :"+fieldValue);
  30. ReflectionUtils.setFieldValue(object,fieldName,fieldValue);
  31. }
  32. }catch(Exception e){
  33. e.printStackTrace();
  34. }finally{
  35. JDBCTools.release(rs,preparedStatement,conn);
  36. }
  37. }

抽取出泛型方法：

  1. public void testGet(){
  2. String sql="select ID id,NAME name,EMAIL email,BIRTH birth "+"From customers";
  3. Customer customer=get(Customer.class,sql);
  4. System.out.println(customer);
  5. }
  6. public <T> T get(Class<T> clazz,String sql,Object...args){
  7. T entity=null;
  8. Connection conn=null;
  9. PreparedStatement preparedStatement=null;
  10. ResultSet rs=null;
  11. try{
  12. conn=JDBCTools.getConnection();
  13. preparedStatement=conn.prepareStatement(sql);
  14. for(int i=0;i<args.length;i++)
  15. {
  16. preparedStatement.setObject(i+1, args[i]);
  17. }
  18. //1得到rs
  19. rs=preparedStatement.executeQuery();
  20. //2得到结果集ResultSetMetaData对象。
  21. ResultSetMetaData rsmd=rs.getMetaData();
  22. //3创建一个Map<String,Object>对象，键：SQL查询的别名。值：列的值
  23. Map<String,Object>values=
  24. new HashMap<String,Object>();
  25. //处理结果集。
  26. while(rs.next()){
  27. for(int i=0;i<rsmd.getColumnCount();i++){
  28. String columnLabel=rsmd.getColumnLabel(i+1);
  29. Object columnValue=rs.getObject(columnLabel);
  30. values.put(columnLabel,columnValue);
  31. }
  32. }
  33. //5若Map不为空利用反射创建clazz对应的对象。
  34. if(values.size()>0){
  35. entity=clazz.newInstance();
  36. for(Map.Entry<String, Object>entry:values.entrySet()){
  37. String fieldName=entry.getKey();
  38. Object fieldValue=entry.getValue();
  39. ReflectionUtils.setFieldValue(entity,fieldName,fieldValue);
  40. }
  41. }
  42. }catch(Exception e){
  43. e.printStackTrace();
  44. }finally{
  45. JDBCTools.release(rs,preparedStatement,conn);
  46. }
  47. return entity;
  48. }

其中JDBCTools.java为：

  1. /*
  2. * 操作JDBC的工具类，其中封装了一些工具方法
  3. * 通过读取配置文件从数据库服务器获取一个连接*/
  4. public class JDBCTools {
  5. public static Connection getConnection() throws IOException, ClassNotFoundException, SQLException{
  6. //1.准备连接数据库的4个字符串。
  7. //1)z创建jdbc.properties对象。
  8. Properties properties=new Properties();
  9. //2)加载对应的输入流。
  10. InputStream in=JDBCTools.class.getClassLoader().getResourceAsStream("jdbc.properties");
  11. //3)加载2）对应的输入流
  12. properties.load(in);
  13. //4)具体决定user，password等4个字符串。
  14. String user=properties.getProperty("user");
  15. String password=properties.getProperty("password");
  16. String driver=properties.getProperty("driverClass");
  17. String jdbcUrl=properties.getProperty("jdbcUrl");
  18. //2.加载数据库驱动（对应的Driver实现类中有注册驱动的静态代码块）
  19. Class.forName(driver);
  20. //3.通过DriverManager的getConnection（）方法获取数据库连接。
  21. return DriverManager.getConnection(jdbcUrl,user,password);
  22. }
  23. /*
  24. *关闭Statement，Connection */
  25. public static void  release(ResultSet rs,Statement statement,Connection conn){
  26. if(rs!=null){
  27. try {
  28. rs.close();
  29. } catch (SQLException e) {
  30. // TODO Auto-generated catch block
  31. e.printStackTrace();
  32. }
  33. }
  34. if(statement!=null){
  35. try{
  36. statement.close();
  37. }catch(Exception e2){
  38. e2.printStackTrace();
  39. }
  40. }
  41. if(conn!=null){
  42. try{
  43. conn.close();
  44. }catch(Exception e2){
  45. e2.printStackTrace();
  46. }
  47. }
  48. }
  49. public static void update(String sql) throws SQLException{
  50. Connection conn=null;
  51. Statement statement=null;
  52. try{
  53. conn=JDBCTools.getConnection();
  54. statement=conn.createStatement();
  55. statement.executeUpdate(sql);
  56. }catch(Exception e){
  57. e.printStackTrace();
  58. }finally{
  59. JDBCTools.release(null,statement, conn);
  60. }
  61. }
  62. public static void update(String sql,Object...args) throws IOException, ClassNotFoundException{
  63. Connection conn=null;
  64. PreparedStatement pstmt=null;
  65. try{
  66. conn=JDBCTools.getConnection();
  67. pstmt=conn.prepareStatement(sql);
  68. for(int i=0;i<args.length;i++){
  69. pstmt.setObject(i+1,args[i]);
  70. }
  71. pstmt.executeUpdate();
  72. }catch(SQLException e){
  73. System.out.println("使用预编译语句更新数据操作发生异常");
  74. }
  75. }
  76. /*
  77. * 1ResultSetMetaData是描述ResultSet的元数据的对象，即从中可以获取到结果集中有多少列，列名是多少。。。
  78. * 2得到ResultSetNataData对象：调用ResultSet的getMetaData()方法
  79. * ResultSetMetaData有哪些方法。
  80. * int getColumnCount（）：SQL语句中包含哪些列。
  81. * String getColumnLable（int column）获取指定的列的别名，其中索引从1开始。*/
  82. public <T> T get(Class<T> clazz,String sql,Object...args){
  83. /*
  84. * 1先利用SQL进行查询得到结果集
  85. * 2利用反射创建实体类的对象
  86. * 3获取结果集的列的别名：idcard。。。
  87. * 4获取结果集的每一列的值，结合3得到一个Map。键：列的别名，值：列的值
  88. * 5再利用反射为2的对应的属性赋值。*/
  89. T entity=null;
  90. Connection conn=null;
  91. PreparedStatement preparedStatement=null;
  92. ResultSet rs=null;
  93. try{
  94. conn=JDBCTools.getConnection();
  95. preparedStatement=conn.prepareStatement(sql);
  96. for(int i=0;i<args.length;i++)
  97. {
  98. preparedStatement.setObject(i+1, args[i]);
  99. }
  100. //1得到rs
  101. rs=preparedStatement.executeQuery();
  102. //2得到结果集ResultSetMetaData对象。
  103. ResultSetMetaData rsmd=rs.getMetaData();
  104. //3创建一个Map<String,Object>对象，键：SQL查询的别名。值：列的值
  105. Map<String,Object>values=
  106. new HashMap<String,Object>();
  107. //处理结果集。
  108. while(rs.next()){
  109. for(int i=0;i<rsmd.getColumnCount();i++){
  110. String columnLabel=rsmd.getColumnLabel(i+1);
  111. Object columnValue=rs.getObject(columnLabel);
  112. values.put(columnLabel,columnValue);
  113. }
  114. }
  115. //5若Map不为空利用反射创建clazz对应的对象。
  116. if(values.size()>0){
  117. entity=clazz.newInstance();
  118. for(Map.Entry<String, Object>entry:values.entrySet()){
  119. String fieldName=entry.getKey();
  120. Object fieldValue=entry.getValue();
  121. ReflectionUtils.setFieldValue(entity,fieldName,fieldValue);
  122. }
  123. }
  124. }catch(Exception e){
  125. e.printStackTrace();
  126. }finally{
  127. JDBCTools.release(rs,preparedStatement,conn);
  128. }
  129. return entity;
  130. }
  131. public Customer getCustomer(String sql,Object...args){
  132. Customer customer=null;
  133. Connection conn=null;
  134. PreparedStatement preparedStatement=null;
  135. ResultSet rs=null;
  136. try{
  137. conn=JDBCTools.getConnection();
  138. preparedStatement=conn.prepareStatement(sql);
  139. for(int i=0;i<args.length;i++)
  140. {
  141. preparedStatement.setObject(i+1, args[i]);
  142. }
  143. rs=preparedStatement.executeQuery();
  144. if(rs.next()){
  145. customer=new Customer();
  146. customer.setId(rs.getInt(1));
  147. customer.setName(rs.getString(2));
  148. customer.setEmail(rs.getString(3));
  149. customer.setBirth(rs.getDate(4));
  150. }
  151. }catch(Exception e){
  152. e.printStackTrace();
  153. }finally{
  154. JDBCTools.release(rs,preparedStatement,conn);
  155. }
  156. return customer;
  157. }
  158. }

ReflectionUtils.java为：

  1. package com.atguigu.jdbc;
  2. import java.lang.reflect.Field;
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Modifier;
  6. import java.lang.reflect.ParameterizedType;
  7. import java.lang.reflect.Type;
  8. /**
  9. * 反射的 Utils 函数集合
  10. * 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
  11. * @author Administrator
  12. *
  13. */
  14. public class ReflectionUtils {
  15. /**
  16. * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
  17. * 如: public EmployeeDao extends BaseDao<Employee, String>
  18. * @param clazz
  19. * @param index
  20. * @return
  21. */
  22. @SuppressWarnings("unchecked")
  23. public static Class getSuperClassGenricType(Class clazz, int index){
  24. Type genType = clazz.getGenericSuperclass();
  25. if(!(genType instanceof ParameterizedType)){
  26. return Object.class;
  27. }
  28. Type [] params = ((ParameterizedType)genType).getActualTypeArguments();
  29. if(index >= params.length || index < 0){
  30. return Object.class;
  31. }
  32. if(!(params[index] instanceof Class)){
  33. return Object.class;
  34. }
  35. return (Class) params[index];
  36. }
  37. /**
  38. * 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
  39. * 如: public EmployeeDao extends BaseDao<Employee, String>
  40. * @param <T>
  41. * @param clazz
  42. * @return
  43. */
  44. @SuppressWarnings("unchecked")
  45. public static<T> Class<T> getSuperGenericType(Class clazz){
  46. return getSuperClassGenricType(clazz, 0);
  47. }
  48. /**
  49. * 循环向上转型, 获取对象的 DeclaredMethod
  50. * @param object
  51. * @param methodName
  52. * @param parameterTypes
  53. * @return
  54. */
  55. public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){
  56. for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
  57. try {
  58. //superClass.getMethod(methodName, parameterTypes);
  59. return superClass.getDeclaredMethod(methodName, parameterTypes);
  60. } catch (NoSuchMethodException e) {
  61. //Method 不在当前类定义, 继续向上转型
  62. }
  63. //..
  64. }
  65. return null;
  66. }
  67. /**
  68. * 使 filed 变为可访问
  69. * @param field
  70. */
  71. public static void makeAccessible(Field field){
  72. if(!Modifier.isPublic(field.getModifiers())){
  73. field.setAccessible(true);
  74. }
  75. }
  76. /**
  77. * 循环向上转型, 获取对象的 DeclaredField
  78. * @param object
  79. * @param filedName
  80. * @return
  81. */
  82. public static Field getDeclaredField(Object object, String filedName){
  83. for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
  84. try {
  85. return superClass.getDeclaredField(filedName);
  86. } catch (NoSuchFieldException e) {
  87. //Field 不在当前类定义, 继续向上转型
  88. }
  89. }
  90. return null;
  91. }
  92. /**
  93. * 直接调用对象方法, 而忽略修饰符(private, protected)
  94. * @param object
  95. * @param methodName
  96. * @param parameterTypes
  97. * @param parameters
  98. * @return
  99. * @throws InvocationTargetException
  100. * @throws IllegalArgumentException
  101. */
  102. public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
  103. Object [] parameters) throws InvocationTargetException{
  104. Method method = getDeclaredMethod(object, methodName, parameterTypes);
  105. if(method == null){
  106. throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
  107. }
  108. method.setAccessible(true);
  109. try {
  110. return method.invoke(object, parameters);
  111. } catch(IllegalAccessException e) {
  112. System.out.println("不可能抛出的异常");
  113. }
  114. return null;
  115. }
  116. /**
  117. * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
  118. * @param object
  119. * @param fieldName
  120. * @param value
  121. */
  122. public static void setFieldValue(Object object, String fieldName, Object value){
  123. Field field = getDeclaredField(object, fieldName);
  124. if (field == null)
  125. throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
  126. makeAccessible(field);
  127. try {
  128. field.set(object, value);
  129. } catch (IllegalAccessException e) {
  130. System.out.println("不可能抛出的异常");
  131. }
  132. }
  133. /**
  134. * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
  135. * @param object
  136. * @param fieldName
  137. * @return
  138. */
  139. public static Object getFieldValue(Object object, String fieldName){
  140. Field field = getDeclaredField(object, fieldName);
  141. if (field == null)
  142. throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
  143. makeAccessible(field);
  144. Object result = null;
  145. try {
  146. result = field.get(object);
  147. } catch (IllegalAccessException e) {
  148. System.out.println("不可能抛出的异常");
  149. }
  150. return result;
  151. }
  152. }

Customer类为：

  1. package com.atguigu.jdbc;
  2. import java.sql.Date;
  3. public class Customer {
  4. private int id;
  5. private String name;
  6. private String email;
  7. private Date birth;
  8. public int getId() {
  9. return id;
  10. }
  11. public void setId(int id) {
  12. this.id = id;
  13. }
  14. public String getName() {
  15. return name;
  16. }
  17. public void setName(String name) {
  18. this.name = name;
  19. }
  20. public String getEmail() {
  21. return email;
  22. }
  23. public void setEmail(String email) {
  24. this.email = email;
  25. }
  26. public Date getBirth() {
  27. return birth;
  28. }
  29. public void setBirth(Date birth) {
  30. this.birth = birth;
  31. }
  32. public Customer(){}
  33. public Customer(int id, String name, String email, Date birth) {
  34. super();
  35. this.id = id;
  36. this.name = name;
  37. this.email = email;
  38. this.birth = birth;
  39. }
  40. public String toString() {
  41. return "Customer [id=" + id + ", name=" + name + ", email=" + email
  42. + ", birth=" + birth + "]";
  43. }
  44. }
上一篇：CentOS 6.4安装OpenOffice


下一篇：关于 Xcode8打印JSON的时候，NSLog控制台显示不完整