随笔-295  评论-26  文章-1  trackbacks-0
Jdbc Template详解
  1. /**
  2. * Copyright: Copyright (c) 2005-2005
  3. * Company: JavaResearch(http://www.javaresearch.org)
  4. */
  5. package org.javaresearch.jerch;



  9. import java.lang.reflect.Method;
  10. import java.sql.Connection;
  11. import java.sql.PreparedStatement;
  12. import java.sql.ResultSet;
  13. import java.sql.ResultSetMetaData;
  14. import java.sql.SQLException;
  15. import java.util.ArrayList;
  16. import java.util.List;

  18. import javax.sql.DataSource;

  20. /**
  21. * JDBC的模板定义，包含所有支持的方法。
  22. * 这个类是这个类库的核心，所有的实际功能差不多都是这个定义并完成的。
  23. * 最后更新日期:2005年5月7日
  24. * @author cherami
  25. */
  26. public class JDBCTemplate {
  27.   /**
  28.    * 数据源。
  29.    */
  30.   privateDataSource datasource;
  31.   /**
  32.    * 构造一个空的JDBCTemplate。
  33.    */
  34.   protectedJDBCTemplate() {

  36.   }
  37.   /**
  38.    * 以指定的数据源构造一个JDBCTemplate。
  39.    * @param datasource 数据源
  40.    */
  41.   protectedJDBCTemplate(DataSource datasource) {
  42.     this.datasource = datasource;
  43.   }
  44.  
  45.  
  46.   /**
  47.    * 设置当前JDBCTemplate的数据源。
  48.    * @param datasource 数据源
  49.    */
  50.   protectedvoid setDataSource(DataSource datasource) {
  51.     this.datasource = datasource;
  52.   }
  53.   /**
  54.    * 得到当前JDBCTemplate的数据源。
  55.    * @return 当前JDBCTemplate的数据源
  56.    */
  57.   protectedDataSource getDataSource() {
  58.     return datasource;
  59.   }
  60.   /**
  61.    * 使用psc创建PreparedStatement并使用pss设置相关的参数最后调用action执行。
  62.    * @param psc PreparedStatement的创建器
  63.    * @param pss PreparedStatement的参数设置器
  64.    * @param action PreparedStatement执行的回掉实现
  65.    * @return 执行后的结果
  66.    */
  67.   publicObject execute(PreparedStatementCreator psc,
  68.       PreparedStatementSetter pss, PreparedStatementCallback action) {
  69.     Connection con = Utils.getConnection(datasource);
  70.     PreparedStatement ps = null;
  71.     try {
  72.       ps = psc.createPreparedStatement(con);
  73.       pss.setValues(ps);
  74.       Object result = action.doInPreparedStatement(ps);
  75.       return result;
  76.     }
  77.     catch (SQLException ex) {
  78.       Utils.error("JDBCTemplate.EXECUTE_ERROR", ex);
  79.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",ex);
  80.     } finally {
  81.       Utils.closeStatement(ps);
  82.       Utils.closeConnection(con);
  83.     }
  84.   }
  85.   /**
  86.    * 执行指定的sql并返回更新的记录数。
  87.    * @param sql SQL语句
  88.    * @return 更新的记录数
  89.    */
  90.   publicint update(String sql) {
  91.     return update(sql, nullPSS);
  92.   }
  93.   /**
  94.    * 执行指定的sql并返回更新的记录数。
  95.    * @param sql SQL语句
  96.    * @param args 参数中的值
  97.    * @return 更新的记录数
  98.    */
  99.   publicint update(String sql, Object[] args) {
  100.     return update(sql, new ArgPreparedStatementSetter(args));
  101.   }
  102.   /**
  103.    * 执行指定的sql并返回更新的记录数。
  104.    * @param sql SQL语句
  105.    * @param args 参数中的值
  106.    * @param types 参数类型
  107.    * @return 更新的记录数
  108.    */
  109.   publicint update(String sql, Object[] args, int[] types) {
  110.     return update(sql, new ArgTypePreparedStatementSetter(args, types));
  111.   }
  112.   /**
  113.    * 执行指定的sql并返回更新的记录数。
  114.    * @param sql SQL语句
  115.    * @param pss PreparedStatement的参数设置器
  116.    * @return 更新的记录数
  117.    */
  118.   publicint update(String sql, PreparedStatementSetter pss) {
  119.     Integer result = (Integer) execute(new SimplePreparedStatementCreator(sql),
  120.         pss, newPreparedStatementCallback() {
  121.           publicObject doInPreparedStatement(PreparedStatement stmt)
  122.               throwsSQLException {
  123.             returnnewInteger(stmt.executeUpdate());
  124.           }
  125.         });
  126.     return result.intValue();
  127.   }
  128.   /**
  129.    * 批量执行更新并返回每次的更新记录数
  130.    * @param sql SQL语句
  131.    * @param args 每次执行时的参数值
  132.    * @return 每次执行更新的记录数数组
  133.    */
  134.   publicint[] batchUpdate(String sql, Object[][] args) {
  135.     return batchUpdate(sql, new ArgBatchPreparedStatementSetter(args));
  136.   }

  138.   /**
  139.    * 批量执行更新并返回每次的更新记录数
  140.    * @param sql SQL语句
  141.    * @param args 每次执行时的参数值
  142.    * @param types 参数类型
  143.    * @return 每次执行更新的记录数数组
  144.    */
  145.   publicint[] batchUpdate(String sql, Object[][] args, int[] types) {
  146.     return batchUpdate(sql,
  147.         new ArgTypeBatchPreparedStatementSetter(args, types));
  148.   }

  150.   /**
  151.    * 批量执行更新并返回每次的更新记录数
  152.    * @param sql SQL语句
  153.    * @param bpss PreparedStatement的批量参数设置器
  154.    * @return 每次执行更新的记录数数组
  155.    */
  156.   publicint[] batchUpdate(String sql, BatchPreparedStatementSetter bpss) {
  157.     return batchUpdate(sql, new BatchPreparedStatementSetterConverter(bpss));
  158.   }

  160.   /**
  161.    * 批量执行更新并返回每次的更新记录数
  162.    * @param sql SQL语句
  163.    * @param pss PreparedStatement的参数设置器
  164.    * @return 每次执行更新的记录数数组
  165.    */
  166.   publicint[] batchUpdate(String sql, PreparedStatementSetter pss) {
  167.     return (int[]) execute(new SimplePreparedStatementCreator(sql), pss,
  168.         newPreparedStatementCallback() {
  169.           publicObject doInPreparedStatement(PreparedStatement stmt)
  170.               throwsSQLException {
  171.             return stmt.executeBatch();
  172.           }
  173.         });
  174.   }

  176.   /**
  177.    * 查询一个整型结果。
  178.    * @param sql SQL语句
  179.    * @return 查询的第一行的第一个字段的整型值。
  180.    */
  181.   publicint queryForInt(String sql) {
  182.     return queryForInt(sql, nullPSS);
  183.   }
  184.   /**
  185.    * 查询一个整型结果。
  186.    * @param sql SQL语句
  187.    * @param args 参数中的值
  188.    * @return 查询的第一行的第一个字段的整型值。
  189.    */
  190.   publicint queryForInt(String sql, Object[] args) {
  191.     return queryForInt(sql, new ArgPreparedStatementSetter(args));
  192.   }
  193.   /**
  194.    * 查询一个整型结果。
  195.    * @param sql SQL语句
  196.    * @param args 参数中的值
  197.    * @param types 参数类型
  198.    * @return 查询的第一行的第一个字段的整型值。
  199.    */
  200.   publicint queryForInt(String sql, Object[] args, int[] types) {
  201.     return queryForInt(sql, new ArgTypePreparedStatementSetter(args, types));
  202.   }
  203.   /**
  204.    *  查询一个整型结果。
  205.    * @param sql SQL语句
  206.    * @param pss PreparedStatement的参数设置器
  207.    * @return 查询的第一行的第一个字段的整型值。
  208.    */
  209.   publicint queryForInt(String sql, PreparedStatementSetter pss) {
  210.     Number result = (Number) queryObject(sql, pss,
  211.         new ObjectResultRowExtractor());
  212.     if (result==null) {
  213.       return 0;
  214.     }
  215.     return result.intValue();
  216.   }

  218.   /**
  219.    * 查询一个长整型结果。
  220.    * @param sql SQL语句
  221.    * @return 查询的第一行的第一个字段的长整型值。
  222.    */
  223.   publiclong queryForLong(String sql) {
  224.     return queryForLong(sql, nullPSS);
  225.   }

  227.   /**
  228.    * 查询一个长整型结果。
  229.    * @param sql SQL语句
  230.    * @param args 参数中的值
  231.    * @return 查询的第一行的第一个字段的长整型值。
  232.    */
  233.   publiclong queryForLong(String sql, Object[] args) {
  234.     return queryForLong(sql, new ArgPreparedStatementSetter(args));
  235.   }

  237.   /**
  238.    * 查询一个长整型结果。
  239.    * @param sql SQL语句
  240.    * @param args 参数中的值
  241.    * @param types 参数类型
  242.    * @return 查询的第一行的第一个字段的长整型值。
  243.    */
  244.   publiclong queryForLong(String sql, Object[] args, int[] types) {
  245.     return queryForLong(sql, new ArgTypePreparedStatementSetter(args, types));
  246.   }

  248.   /**
  249.    *  查询一个长整型结果。
  250.    * @param sql SQL语句
  251.    * @param pss PreparedStatement的参数设置器
  252.    * @return 查询的第一行的第一个字段的长整型值。
  253.    */
  254.   publiclong queryForLong(String sql, PreparedStatementSetter pss) {
  255.     Number result = (Number) queryObject(sql, pss,
  256.         new ObjectResultRowExtractor());
  257.     if (result==null) {
  258.       return 0;
  259.     }
  260.     return result.longValue();
  261.   }

  263.   /**
  264.    * 查询一个字符串结果。
  265.    * @param sql SQL语句
  266.    * @return 查询的第一行的第一个字段的字符串值。
  267.    */
  268.   publicString queryString(String sql) {
  269.     return queryString(sql, nullPSS);
  270.   }

  272.   /**
  273.    * 查询一个字符串结果。
  274.    * @param sql SQL语句
  275.    * @param args 参数中的值
  276.    * @return 查询的第一行的第一个字段的字符串值。
  277.    */
  278.   publicString queryString(String sql, Object[] args) {
  279.     return queryString(sql, new ArgPreparedStatementSetter(args));
  280.   }

  282.   /**
  283.    * 查询一个字符串结果。
  284.    * @param sql SQL语句
  285.    * @param args 参数中的值
  286.    * @param types 参数类型
  287.    * @return 查询的第一行的第一个字段的字符串值。
  288.    */
  289.   publicString queryString(String sql, Object[] args, int[] types) {
  290.     return queryString(sql, new ArgTypePreparedStatementSetter(args, types));
  291.   }

  293.   /**
  294.    *  查询一个字符串结果。
  295.    * @param sql SQL语句
  296.    * @param pss PreparedStatement的参数设置器
  297.    * @return 查询的第一行的第一个字段的字符串值。
  298.    */
  299.   publicString queryString(String sql, PreparedStatementSetter pss) {
  300.     return (String) queryObject(sql, pss, new StringResultRowExtractor());
  301.   }

  303.   /**
  304.    * 查询一个对象结果。
  305.    * @param sql SQL语句
  306.    * @param rre 单行结果提取器
  307.    * @return 查询的第一行的结果并使用rre转换为结果对象。
  308.    */
  309.   publicObject queryObject(String sql, ResultRowExtractor rre) {
  310.     return queryObject(sql, nullPSS, rre);
  311.   }

  313.   /**
  314.    * 查询一个对象结果。
  315.    * @param sql SQL语句
  316.    * @param args 参数中的值
  317.    * @param rre 单行结果提取器
  318.    * @return 查询的第一行的结果并使用rre转换为结果对象。
  319.    */
  320.   publicObject queryObject(String sql, Object[] args, ResultRowExtractor rre) {
  321.     return queryObject(sql, new ArgPreparedStatementSetter(args), rre);
  322.   }

  324.   /**
  325.    * 查询一个对象结果。
  326.    * @param sql SQL语句
  327.    * @param args 参数中的值
  328.    * @param types 参数类型
  329.    * @param rre 单行结果提取器
  330.    * @return 查询的第一行的结果并使用rre转换为结果对象。
  331.    */
  332.   publicObject queryObject(String sql, Object[] args, int[] types,
  333.       ResultRowExtractor rre) {
  334.     return queryObject(sql, new ArgTypePreparedStatementSetter(args, types),
  335.         rre);
  336.   }

  338.   /**
  339.    * 查询一个对象结果。
  340.    * @param sql SQL语句
  341.    * @param pss PreparedStatement的参数设置器
  342.    * @param rre 单行结果提取器
  343.    * @return 查询的第一行的结果并使用rre转换为结果对象。
  344.    */
  345.   publicObject queryObject(String sql, PreparedStatementSetter pss,
  346.       finalResultRowExtractor rre) {
  347.     Object result = (Object) execute(new SimplePreparedStatementCreator(sql),
  348.         pss, newPreparedStatementCallback() {
  349.           publicObject doInPreparedStatement(PreparedStatement ps)
  350.               throwsSQLException {
  351.             ResultSet rs = null;
  352.             try {
  353.               rs = ps.executeQuery();
  354.               if (rs.next()) {
  355.                 return rre.extractRow(rs);
  356.               } else {
  357.                 returnnull;
  358.               }
  359.             }
  360.             catch (SQLException e) {
  361.               Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  362.               thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  363.             } finally {
  364.               Utils.closeResultSet(rs);
  365.             }
  366.           }
  367.         });
  368.     return result;
  369.   }

  371.   /**
  372.    * 查询一个对象列表结果。
  373.    * @param sql SQL语句
  374.    * @param rre 单行结果提取器
  375.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
  376.    */
  377.   publicList query(String sql, ResultRowExtractor rre) {
  378.     return (List) execute(new SimplePreparedStatementCreator(sql), nullPSS,
  379.         new ResultRowListPreparedStatementCallback(rre));
  380.   }
  381.   /**
  382.    * 查询结果。
  383.    * @param sql SQL语句
  384.    * @param rse 全部结果提取器。
  385.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
  386.    */
  387.   publicObject query(String sql, finalResultSetExtractor rse) {
  388.     return (Object) execute(new SimplePreparedStatementCreator(sql), nullPSS,
  389.         new ResultSetPreparedStatementCallback(rse));
  390.   }

  392.   /**
  393.    * 查询一个对象列表结果。
  394.    * @param sql SQL语句
  395.    * @param args 参数中的值
  396.    * @param types 参数类型
  397.    * @param rre 单行结果提取器
  398.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
  399.    */
  400.   publicList query(String sql, Object[] args, int[] types, ResultRowExtractor rre) {
  401.     return (List) execute(new SimplePreparedStatementCreator(sql),
  402.         new ArgTypePreparedStatementSetter(args,types),
  403.         new ResultRowListPreparedStatementCallback(rre));
  404.   }

  406.   /**
  407.    * 查询结果。
  408.    * @param sql SQL语句
  409.    * @param args 参数中的值
  410.    * @param types 参数类型
  411.    * @param rse 全部结果提取器。
  412.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
  413.    */
  414.   publicObject query(String sql, Object[] args, int[] types, ResultSetExtractor rse) {
  415.     return (Object) execute(new SimplePreparedStatementCreator(sql),
  416.         new ArgTypePreparedStatementSetter(args,types),
  417.         new ResultSetPreparedStatementCallback(rse));
  418.   }

  420.   /**
  421.    * 查询一个对象列表结果。
  422.    * @param sql SQL语句
  423.    * @param args 参数中的值
  424.    * @param rre 单行结果提取器
  425.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
  426.    */
  427.   publicList query(String sql, Object[] args, ResultRowExtractor rre) {
  428.     return (List) execute(new SimplePreparedStatementCreator(sql),
  429.         new ArgPreparedStatementSetter(args),
  430.         new ResultRowListPreparedStatementCallback(rre));
  431.   }

  433.   /**
  434.    * 查询结果。
  435.    * @param sql SQL语句
  436.    * @param args 参数中的值
  437.    * @param rse 全部结果提取器。
  438.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
  439.    */
  440.   publicObject query(String sql, Object[] args, ResultSetExtractor rse) {
  441.     return (Object) execute(new SimplePreparedStatementCreator(sql),
  442.         new ArgPreparedStatementSetter(args),
  443.         new ResultSetPreparedStatementCallback(rse));
  444.   }

  446.   /**
  447.    * 查询一个对象列表结果。
  448.    * @param sql SQL语句
  449.    * @param pss PreparedStatement的参数设置器
  450.    * @param rre 单行结果提取器
  451.    * @return 查询所有结果并使用rre将每行结果转换为结果对象元素。
  452.    */
  453.   publicList query(String sql, PreparedStatementSetter pss,
  454.       ResultRowExtractor rre) {
  455.     return (List) execute(new SimplePreparedStatementCreator(sql), pss,
  456.         new ResultRowListPreparedStatementCallback(rre));
  457.   }

  459.   /**
  460.    * 查询结果。
  461.    * @param sql SQL语句
  462.    * @param pss PreparedStatement的参数设置器
  463.    * @param rse 全部结果提取器。
  464.    * @return 查询结果并根据自定义的结果提取器提取数据并返回。
  465.    */
  466.   publicObject query(String sql, PreparedStatementSetter pss,
  467.       ResultSetExtractor rse) {
  468.     return (Object) execute(new SimplePreparedStatementCreator(sql), pss,
  469.         new ResultSetPreparedStatementCallback(rse));
  470.   }
  471.   /**
  472.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
  473.    * @param sql SQL语句
  474.    * @param bean 结果Bean的类型
  475.    * @return 第一行的结果并转换为Bean实例。
  476.    */
  477.   publicObject queryForBean(String sql, Class bean) {
  478.     try {
  479.       Object obj = bean.newInstance();
  480.       if (obj instanceofMappable) {
  481.         return queryObject(sql, nullPSS, new MappableResultRowExtractor(obj,
  482.             (Mappable) obj));
  483.       } else {
  484.         return queryObject(sql, nullPSS, new MappableResultRowExtractor(obj,
  485.             newNameMatchMappable()));
  486.       }
  487.     }
  488.     catch (Exception e) {
  489.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  490.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  491.     }
  492.   }

  494.   /**
  495.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
  496.    * @param sql SQL语句
  497.    * @param args 参数中的值
  498.    * @param bean 结果Bean的类型
  499.    * @return 第一行的结果并转换为Bean实例。
  500.    */
  501.   publicObject queryForBean(String sql, Object[] args, Class bean) {
  502.     try {
  503.       Object obj = bean.newInstance();
  504.       if (obj instanceofMappable) {
  505.         return queryObject(sql, new ArgPreparedStatementSetter(args),
  506.             new MappableResultRowExtractor(obj, (Mappable) obj));
  507.       } else {
  508.         return queryObject(sql, new ArgPreparedStatementSetter(args),
  509.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
  510.       }
  511.     }
  512.     catch (Exception e) {
  513.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  514.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  515.     }
  516.   }

  518.   /**
  519.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
  520.    * @param sql SQL语句
  521.    * @param args 参数中的值
  522.    * @param types 参数类型
  523.    * @param bean 结果Bean的类型
  524.    * @return 第一行的结果并转换为Bean实例。
  525.    */
  526.   publicObject queryForBean(String sql, Object[] args, int[] types, Class bean) {
  527.     try {
  528.       Object obj = bean.newInstance();
  529.       if (obj instanceofMappable) {
  530.         return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
  531.             new MappableResultRowExtractor(obj, (Mappable) obj));
  532.       } else {
  533.         return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
  534.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
  535.       }
  536.     }
  537.     catch (Exception e) {
  538.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  539.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  540.     }
  541.   }

  543.   /**
  544.    * 查询并返回第一行的结果并根据字段名自动转换为bean的对应属性。
  545.    * @param sql SQL语句
  546.    * @param pss PreparedStatement的参数设置器
  547.    * @param bean 结果Bean的类型
  548.    * @return 第一行的结果并转换为Bean实例。
  549.    */
  550.   publicObject queryForBean(String sql, PreparedStatementSetter pss, Class bean) {
  551.     try {
  552.       Object obj = bean.newInstance();
  553.       if (obj instanceofMappable) {
  554.         return queryObject(sql, pss,
  555.             new MappableResultRowExtractor(obj, (Mappable) obj));
  556.       } else {
  557.         return queryObject(sql, pss,
  558.             new MappableResultRowExtractor(obj, newNameMatchMappable()));
  559.       }
  560.     }
  561.     catch (Exception e) {
  562.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  563.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  564.     }
  565.   }

  567.   /**
  568.    * 查询并返回第一行的结果并使用m将其转换为bean。
  569.    * @param sql SQL语句
  570.    * @param bean 结果Bean的类型
  571.    * @param m 字段－属性映射器
  572.    * @return 第一行的结果并使用m将其转换为Bean实例。
  573.    */
  574.   publicObject queryForBean(String sql, Class bean, Mappable m) {
  575.     try {
  576.       return queryObject(sql, nullPSS, new MappableResultRowExtractor(bean
  577.           .newInstance(), m));
  578.     }
  579.     catch (Exception e) {
  580.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  581.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  582.     }
  583.   }

  585.   /**
  586.    * 查询并返回第一行的结果并使用m将其转换为bean。
  587.    * @param sql SQL语句
  588.    * @param args 参数中的值
  589.    * @param bean 结果Bean的类型
  590.    * @param m 字段－属性映射器
  591.    * @return 第一行的结果并使用m将其转换为Bean实例。
  592.    */
  593.   publicObject queryForBean(String sql, Object[] args, Class bean, Mappable m) {
  594.     try {
  595.       return queryObject(sql, new ArgPreparedStatementSetter(args),
  596.           new MappableResultRowExtractor(bean.newInstance(), m));
  597.     }
  598.     catch (Exception e) {
  599.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  600.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  601.     }
  602.   }

  604.   /**
  605.    * 查询并返回第一行的结果并使用m将其转换为bean。
  606.    * @param sql SQL语句
  607.    * @param args 参数中的值
  608.    * @param types 参数类型
  609.    * @param bean 结果Bean的类型
  610.    * @param m 字段－属性映射器
  611.    * @return 第一行的结果并使用m将其转换为Bean实例。
  612.    */
  613.   publicObject queryForBean(String sql, Object[] args, int[] types, Class bean, Mappable m) {
  614.     try {
  615.       return queryObject(sql, new ArgTypePreparedStatementSetter(args,types),
  616.           new MappableResultRowExtractor(bean.newInstance(), m));
  617.     }
  618.     catch (Exception e) {
  619.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  620.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR", e);
  621.     }
  622.   }

  624.   /**
  625.    * 查询并返回第一行的结果并使用m将其转换为bean。
  626.    * @param sql SQL语句
  627.    * @param pss PreparedStatement的参数设置器
  628.    * @param bean 结果Bean的类型
  629.    * @param m 字段－属性映射器
  630.    * @return 第一行的结果并使用m将其转换为Bean实例。
  631.    */
  632.   publicObject queryForBean(String sql, PreparedStatementSetter pss,
  633.       Class bean, Mappable m) {
  634.     try {
  635.       return queryObject(sql, pss, new MappableResultRowExtractor(bean
  636.           .newInstance(), m));
  637.     }
  638.     catch (Exception e) {
  639.       Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  640.       thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
  641.     }
  642.   }
  643.   /**
  644.    * 无任何参数的PreparedStatement设置器实例。
  645.    */
  646.   privatestaticfinalPreparedStatementSetter nullPSS = newPreparedStatementSetter() {
  647.     publicvoid setValues(PreparedStatement ps) {
  648.     }
  649.   };

  651.   /**
  652.    * 将参数数组转换为PreparedStatement的设置器的简单适配器。
  653.    */
  654.   privatestaticclass ArgPreparedStatementSetter implements
  655.       PreparedStatementSetter {

  657.     privatefinalObject[] args;

  659.     public ArgPreparedStatementSetter(Object[] args) {
  660.       this.args = args;
  661.     }

  663.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
  664.       if (this.args != null) {
  665.         for (int i = 0; i < this.args.length; i++) {
  666.           ps.setObject(i + 1, this.args[i]);
  667.         }
  668.       }
  669.     }
  670.   }

  672.   /**
  673.    * 将参数数组和其类型转换为PreparedStatement的设置器的简单适配器。
  674.    */
  675.   privatestaticclass ArgTypePreparedStatementSetter implements
  676.       PreparedStatementSetter {

  678.     privatefinalObject[] args;

  680.     privatefinalint[] types;

  682.     public ArgTypePreparedStatementSetter(Object[] args, int[] types) {
  683.       if ((args != null && types == null)
  684.           || (args == null && types != null)
  685.           || (args != null && args.length != types.length)) {
  686.         thrownewJerchException("ArgTypePreparedStatementSetter.ARG_NOT_MATCH");
  687.       }
  688.       this.args = args;
  689.       this.types = types;
  690.     }

  692.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
  693.       if (this.args != null) {
  694.         for (int i = 0; i < this.args.length; i++) {
  695.           ps.setObject(i + 1, this.args[i], this.types[i]);
  696.         }
  697.       }
  698.     }
  699.   }

  701.   /**
  702.    * 将sql语句转换为PreparedStatement的创建器的简单适配器。
  703.    */
  704.   privatestaticclass SimplePreparedStatementCreator implements
  705.       PreparedStatementCreator {

  707.     privatefinalString sql;

  709.     public SimplePreparedStatementCreator(String sql) {
  710.       this.sql = sql;
  711.     }

  713.     publicPreparedStatement createPreparedStatement(Connection con)
  714.         throwsSQLException {
  715.       return con.prepareStatement(this.sql);
  716.     }
  717.   }

  719.   /**
  720.    * 将第一个字段作为String类型提取的单行结果提取器。
  721.    */
  722.   privatestaticclass StringResultRowExtractor implementsResultRowExtractor {
  723.     publicObject extractRow(java.sql.ResultSet rs) throwsSQLException {
  724.       return rs.getString(1);
  725.     }
  726.   }

  728.   /**
  729.    * 将第一个字段作为Object类型提取的单行结果提取器。
  730.    */
  731.   privatestaticclass ObjectResultRowExtractor implementsResultRowExtractor {
  732.     publicObject extractRow(java.sql.ResultSet rs) throwsSQLException {
  733.       return rs.getObject(1);
  734.     }
  735.   }

  737.   /**
  738.    * 将BatchPreparedStatement设置其转换为PreparedStatement设置器的适配器。
  739.    */
  740.   privatestaticclass BatchPreparedStatementSetterConverter implements
  741.       PreparedStatementSetter {
  742.     BatchPreparedStatementSetter bpss;

  744.     public BatchPreparedStatementSetterConverter(
  745.         BatchPreparedStatementSetter bpss) {
  746.       this.bpss = bpss;
  747.     }

  749.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
  750.       for (int i = 0; i < bpss.getBatchSize(); i++) {
  751.         bpss.setValues(ps, i);
  752.         ps.addBatch();
  753.       }
  754.     }
  755.   }

  757.   /**
  758.    * 将批量参数数组转换为PreparedStatement设置器的适配器。
  759.    */
  760.   privatestaticclass ArgBatchPreparedStatementSetter implements
  761.       PreparedStatementSetter {

  763.     privatefinalObject[][] args;

  765.     public ArgBatchPreparedStatementSetter(Object[][] args) {
  766.       this.args = args;
  767.     }

  769.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
  770.       if (this.args != null) {
  771.         for (int i = 0; i < this.args.length; i++) {
  772.           Object[] arg = args[i];
  773.           for (int j = 0; j < arg.length; j++) {
  774.             ps.setObject(j + 1, arg[j]);
  775.           }
  776.           ps.addBatch();
  777.         }
  778.       }
  779.     }
  780.   }

  782.   /**
  783.    * 将批量参数数组和对应类型转换为PreparedStatement设置器的适配器。
  784.    */
  785.   privatestaticclass ArgTypeBatchPreparedStatementSetter implements
  786.       PreparedStatementSetter {

  788.     privatefinalObject[][] args;

  790.     privatefinalint[] types;

  792.     public ArgTypeBatchPreparedStatementSetter(Object[][] args, int[] types) {
  793.       if ((args != null && types == null)
  794.           || (args == null && types != null)
  795.           || (args != null && args.length != types.length)) {
  796.         thrownewJerchException("ArgTypePreparedStatementSetter.ARG_NOT_MATCH");
  797.       }
  798.       this.args = args;
  799.       this.types = types;
  800.     }

  802.     publicvoid setValues(PreparedStatement ps) throwsSQLException {
  803.       if (this.args != null) {
  804.         for (int i = 0; i < this.args.length; i++) {
  805.           Object[] arg = args[i];
  806.           for (int j = 0; j < arg.length; j++) {
  807.             ps.setObject(j + 1, arg[j], types[j]);
  808.           }
  809.           ps.addBatch();
  810.         }
  811.       }
  812.     }
  813.   }

  815.   /**
  816.    * 使用ResultRowExtractor提取单行结果并将全部结果添加到List的PreparedStatement回调实现。
  817.    */
  818.   privatestaticclass ResultRowListPreparedStatementCallback implements
  819.       PreparedStatementCallback {
  820.     ResultRowExtractor rre;

  822.     public ResultRowListPreparedStatementCallback(ResultRowExtractor rre) {
  823.       this.rre = rre;
  824.     }

  826.     publicObject doInPreparedStatement(PreparedStatement ps)
  827.         throwsSQLException {
  828.       ResultSet rs = null;
  829.       List result = newArrayList();
  830.       try {
  831.         rs = ps.executeQuery();
  832.         while (rs.next()) {
  833.           result.add(rre.extractRow(rs));
  834.         }
  835.       }
  836.       catch (SQLException e) {
  837.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  838.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
  839.       } finally {
  840.         Utils.closeResultSet(rs);
  841.       }
  842.       return result;
  843.     }
  844.   }

  846.   /**
  847.    * 使用ResultSetExtractor提取全部结果的PreparedStatement回调实现。
  848.    */
  849.   privatestaticclass ResultSetPreparedStatementCallback implements
  850.       PreparedStatementCallback {
  851.     ResultSetExtractor rse;

  853.     public ResultSetPreparedStatementCallback(ResultSetExtractor rse) {
  854.       this.rse = rse;
  855.     }

  857.     publicObject doInPreparedStatement(PreparedStatement ps)
  858.         throwsSQLException {
  859.       ResultSet rs = null;
  860.       try {
  861.         rs = ps.executeQuery();
  862.         return rse.extractSet(rs);
  863.       }
  864.       catch (SQLException e) {
  865.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  866.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
  867.       } finally {
  868.         Utils.closeResultSet(rs);
  869.       }
  870.     }
  871.   }

  873.   /**
  874.    * 使用Mappable将单行结果转换为对象实例的ResultRow提取器实现。
  875.    */
  876.   privatestaticclass MappableResultRowExtractor implementsResultRowExtractor {
  877.     privateMappable map;

  879.     privateObject obj;

  881.     public MappableResultRowExtractor(Object obj, Mappable map) {
  882.       this.obj = obj;
  883.       this.map = map;
  884.     }

  886.     publicObject extractRow(ResultSet rs) throwsSQLException {
  887.       Class c = obj.getClass();
  888.       ResultSetMetaData metaData = rs.getMetaData();
  889.       int count = metaData.getColumnCount();
  890.       try {
  891.         for (int i = 0; i < count; i++) {
  892.           String fieldName = metaData.getColumnName(i + 1);
  893.           int type = metaData.getColumnType(i + 1);
  894.           Class[] types = { map.getMethodParameterType(fieldName, type) };
  895.           Method m = c.getMethod(map.getMapMethod(fieldName), types);
  896.           Object[] args = { ValueConverterFactory.convert(rs
  897.               .getObject(fieldName), types[0]) };
  898.           m.invoke(obj, args);
  899.         }
  900.       }
  901.       catch (Exception e) {
  902.         Utils.error("JDBCTemplate.EXECUTE_ERROR", e);
  903.         thrownewJerchException("JDBCTemplate.EXECUTE_ERROR",e);
  904.       }
  905.       return obj;
  906.     }
  907.   }
  908. }


大盘预测 国富论
posted on 2007-09-10 11:24 华梦行 阅读(2379) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。
网站导航:
 
Powered by: 博客园 模板提供：沪江博客 Copyright ©2024 华梦行