springJDBC学习笔记和实例

前言：相对于Mybatis（ibatis），个人感觉springJDBC更灵活，主要实现类JdbcTemplate；它替我们完成了资源的创建以及释放工作，从而简化了我们对JDBC的使用。它还可以帮助我们避免一些常见的错误，比如忘记关闭数据库连接。JdbcTemplate将完成JDBC核心处理流程，比如SQL语句的创建、执行，而把SQL语句的生成以及查询结果的提取工作留给我们的应用代码。它可以完成SQL查询、更新以及调用存储过程，可以对ResultSet进行遍历并加以提取。它还可以捕获JDBC异常并将其转换成org.springframework.dao包中定义的，通用的，信息更丰富的异常。

概述：

1）core
即核心包，它包含了JDBC的核心功能。此包内有很多重要的类，包括：JdbcTemplate类、SimpleJdbcInsert类，SimpleJdbcCall类，以及NamedParameterJdbcTemplate类。
2）datasource
即数据源包，访问数据源的实用工具类。它有多种数据源的实现，可以在JavaEE容器外部测试JDBC代码。
3）object
即对象包，以面向对象的方式访问数据库。它允许执行查询并返回结果作为业务对象。它可以在数据表的列和业务对象的属性之间映射查询结果。
4）support
即支持包，是core包和object包的支持类。例如提供了异常转换功能的SQLException类。

 

springJDBC完整实例：

工程结构：

 

结构说明：工程结构也不难理解，分为控制层（controller）、服务层（service）、持久层（dao），下面一步一步说明；

1.导入相关的springjdbcjar包，jar包分享到百度云盘，如果无法下载可以在评论留下邮箱我私发；

jar包分享地址：http://pan.baidu.com/s/1kVNQvIn

2.web配置文件：

 1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app version="2.5"  3     xmlns="http://java.sun.com/xml/ns/javaee"  4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  5     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  6     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> 7   <display-name>springJDBCDemo</display-name>     8   <welcome-file-list> 9     <welcome-file>index.jsp</welcome-file>10   </welcome-file-list>11   12   <servlet>13         <servlet-name>dispatcherServlet</servlet-name>14         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>15         <init-param>16             <param-name>contextConfigLocation</param-name>17             <param-value>18                 classpath:conf/spring.xml19             </param-value>20         </init-param>21         <load-on-startup>1</load-on-startup>22     </servlet>23     <servlet-mapping>24         <servlet-name>dispatcherServlet</servlet-name>25         <url-pattern>/do/*</url-pattern>26     </servlet-mapping>27 28     <filter>29         <filter-name>encodingFilter</filter-name>30         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>31         <init-param>32             <param-name>encoding</param-name>33             <param-value>UTF-8</param-value>34         </init-param>35     </filter>36     <filter-mapping>37         <filter-name>encodingFilter</filter-name>38         <url-pattern>/*</url-pattern>39     </filter-mapping>40 </web-app>

说明：<display-name>一般就写工程名了，<servlet>加载配置文件和请求路径配置；

3.spring.xml配置文件

 1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 4     xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" 5     xmlns:util="http://www.springframework.org/schema/util" 6     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     7             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd     8             http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd     9             http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">10 11     <!-- 读取配置文件 -->12     <bean id="propertyConfigurer" class="com.sf.springJDBC.base.http.CustomizedPropertyPlaceholderConfigurer">13         <property name="locations">14             <list>15                 <value>classpath:conf/config.properties</value>16             </list>17         </property>18     </bean>19     20     <!-- 对web包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 -->21     <context:component-scan base-package="com.sf.springJDBC" />22   
　　　　　<!-- 该类设置后台编码为utf-8，如果没有该类可能导致jsp请求返回的数据中文显示为问号 -->23     <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">24         <property name="messageConverters">25             <list>26                 <bean id="UTF8StringHttpMessageConverter" class="com.sf.springJDBC.base.UTF8StringHttpMessageConverter">27                 </bean>28             </list>29         </property>30     </bean>  31     32     <!-- 支持spring3.0新的mvc注解 -->33     <mvc:annotation-driven/>34     35     <!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->36     <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">37         <property name="cacheSeconds" value="0" />38         <property name="messageConverters">39             <list>40                 <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>41             </list>42         </property>43     </bean>44     45     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">46         <property name="maxUploadSize" value="102400000" />47         <property name="resolveLazily" value="true"/>  48         <property name="maxInMemorySize" value="4096"/>  49     </bean>50     51     <!-- 数据库配置-->52     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">53         <property name="driverClassName" value="${dataSource.driver}" />54         <property name="url" value="${dataSource.url}" />55         <property name="username" value="${dataSource.username}" />56         <property name="password" value="${dataSource.password}" />57         <property name="initialSize" value="${dataSource.initialSize}" />58         <property name="maxIdle" value="${dataSource.minIdle}" />59         <property name="maxActive" value="${dataSource.maxActive}" />60         <property name="maxWait" value="${dataSource.maxWait}" />61         <property name="timeBetweenEvictionRunsMillis" value="${dataSource.timeBetweenEvictionRunsMillis}" />62         <property name="minEvictableIdleTimeMillis" value="${dataSource.minEvictableIdleTimeMillis}" />63         <property name="validationQuery" value="select 1 from dual" />64         <property name="poolPreparedStatements" value="true" />65         <property name="defaultAutoCommit" value="true" />66     </bean>67     68     <!-- 给jdbc模板注入数据源-->69     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">70         <property name="dataSource" ref="dataSource"></property>71     </bean>72     73     74 </beans>

上面的注解说的很清楚了；

4.数据源配置文件config.properties：

 1 #oracle 2 dataSource.driver=oracle.jdbc.driver.OracleDriver 3   4 #test 14-2 5 dataSource.url=jdbc:oracle:thin:@ip:port:dbname 6 dataSource.username=username 7 dataSource.password=password 8   9 #Initialize connection10 dataSource.initialSize=511 dataSource.minIdle=1012 dataSource.maxActive=50013 dataSource.maxWait=600014 dataSource.timeBetweenEvictionRunsMillis=300015 dataSource.minEvictableIdleTimeMillis=300000

5.工程主代码：

⑴控制层Controller

 1 package com.sf.springJDBC.controller; 2  3 import java.util.HashMap; 4 import java.util.Map; 5  6 import javax.annotation.Resource; 7 import javax.servlet.http.HttpServletRequest; 8 import javax.servlet.http.HttpServletResponse; 9 10 import org.springframework.stereotype.Controller;11 import org.springframework.web.bind.annotation.RequestMapping;12 import org.springframework.web.bind.annotation.ResponseBody;13 14 import com.sf.springJDBC.base.BaseController;15 import com.sf.springJDBC.service.TestService;16 17 18 @Controller19 @RequestMapping("/test")20 public class TestController extends BaseController{21     @Resource22     private TestService testService;23     24     @ResponseBody25     @RequestMapping(value = "/gettest")26     public String getTest(HttpServletRequest request, HttpServletResponse response) {27         Map<String,Object> map = new HashMap<String, Object>();28         map = testService.getTest();29         String data = resMapToJson(map);30         return data;31     }32 }

⑵服务层：service

1 package com.sf.springJDBC.service;2 3 import java.util.Map;4 5 public interface TestService {6     public Map<String, Object> getTest();7 }

（3）服务实现接口service.impl

package com.sf.springJDBC.service.impl;import java.util.HashMap;import java.util.Map;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import com.sf.springJDBC.dao.BaseDao;import com.sf.springJDBC.dao.sql.TestSql;import com.sf.springJDBC.service.TestService;@Service()public class TestServiceImpl implements TestService {    @Autowired    private BaseDao baseDao;    public Map<String, Object> getTest() {        Map<String,Object> map = new HashMap<String, Object>();        String sql = TestSql.getQuestionsql;        map = baseDao.selectOne(sql, null);        return map;    }}

持久层dao

 1 package com.sf.springJDBC.dao; 2  3 import java.util.List; 4 import java.util.Map; 5  6 public interface BaseDao { 7  8     public Map<String, Object> selectOne(String sql, Object[] params); 9 10     public List<Map<String, Object>> selectList(String sql, Object[] params);11 12     public int selectForInt(String sql, Object[] params);13 14     public long selectForLong(String sql, Object[] params);15     16     public int update(String sql, Object[] params);17     18     public int executeBatch(String[] sql);19     20     public int executeBatch(String sql, List<Object[]> objList);21     22 }

（4）实现接口：dao.impl

  1 package com.sf.springJDBC.dao.impl;  2    3 import java.sql.PreparedStatement;  4 import java.sql.SQLException;  5 import java.sql.Timestamp;  6 import java.util.ArrayList;  7 import java.util.HashMap;  8 import java.util.List;  9 import java.util.Map; 10 import org.springframework.beans.factory.annotation.Autowired; 11 import org.springframework.dao.DataAccessException; 12 import org.springframework.jdbc.core.JdbcTemplate; 13 import org.springframework.jdbc.core.PreparedStatementCallback; 14 import org.springframework.stereotype.Repository; 15  16 import com.sf.springJDBC.dao.BaseDao; 17  18  19 @Repository 20 public class BaseDaoImpl implements BaseDao { 21  22     @Autowired 23     private JdbcTemplate jdbcTemplate; 24  25      26     public Map<String, Object> selectOne(String sql, Object[] params) { 27         Map<String, Object> result = new HashMap<String, Object>(); 28         try { 29             List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, params); 30             if (list.size() > 0) { 31                 result = list.get(0); 32             } 33         } catch (Exception e) { 34             e.printStackTrace(); 35         } 36         return result; 37     } 38  39      40     public List<Map<String, Object>> selectList(String sql, Object[] params) { 41         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>(); 42         try { 43             list = jdbcTemplate.queryForList(sql, params); 44         } catch (Exception e) { 45             e.printStackTrace(); 46         } 47         return list; 48     } 49  50      51     public int selectForInt(String sql, Object[] params) { 52         int count = 0; 53         try { 54             count = jdbcTemplate.queryForInt(sql, params); 55         } catch (Exception e) { 56             e.printStackTrace(); 57         } 58         return count; 59     } 60  61      62     public long selectForLong(String sql, Object[] params) { 63         long count = 0l; 64         try { 65             count = jdbcTemplate.queryForLong(sql, params); 66         } catch (Exception e) { 67             e.printStackTrace(); 68         } 69         return count; 70     } 71  72      73     public int update(String sql, Object[] params) { 74         int count = 0; 75         try { 76             count = jdbcTemplate.update(sql, params); 77         } catch (Exception e) { 78             e.printStackTrace(); 79         } 80         return count; 81     } 82  83      84     public int executeBatch(String[] sql) { 85         int count = 0; 86         try { 87             count = jdbcTemplate.batchUpdate(sql).length; 88         } catch (Exception e) { 89             e.printStackTrace(); 90         } 91         return count; 92     } 93  94      95      96      97     public int executeBatch(String sql, List<Object[]> objList) { 98          99     /*    Object[] objs = new Object[]{1,2,3};100         objs = new Object[]{1,2,3};101         objs = new Object[]{1,2,3};102         objList.add(objs);*/103         104         int count = 0;105         final List<Object[]> paramList = objList;106         try {107             count = jdbcTemplate.execute(sql, new PreparedStatementCallback<int[]>() {108                 109                 public int[] doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {110                     ps.getConnection().setAutoCommit(false);111                     for (int i = 0; i < paramList.size(); i++) {112                         Object[] objs = paramList.get(i);113                         for (int j = 0; j < objs.length; j++) {114                             Object obj = objs[j];115                             int num = j + 1;116                             if (obj instanceof Integer) {117                                 ps.setInt(num, (Integer) obj);118                             } else if (obj instanceof Long) {119                                 ps.setLong(num, (Long) obj);120                             } else if (obj instanceof java.sql.Date) {121                                 ps.setDate(num, (java.sql.Date)obj);122                             } else if (obj instanceof Timestamp) {123                                 ps.setTimestamp(num, (Timestamp) obj);124                             } else if(obj instanceof Double){125                                 ps.setDouble(num,(Double)obj);126                             }127                             else {128                                 129                                 ps.setString(num, String.valueOf(obj));130                             }131                         }132                         ps.addBatch();133                     }134                     int[] o = ps.executeBatch();135                     ps.getConnection().commit();136                     ps.getConnection().setAutoCommit(true);137                     // 如果用<aop:config> 来控制事务，需要把上一行注掉，否则会报错138                     return o;139                 }140             }).length;141         } catch (Exception e) {142             e.printStackTrace();143         }144         return count;145     }146     147 }

（5）sql语句单独写在一个类里面，方便管理：

1 package com.sf.springJDBC.dao.sql;2 3 public class TestSql {4     public static String getQuestionsql = "select * from bs_question_info where question_busi_id='ZJ16111000192'" ;5 }

当sql需要传参数时，参数用?传入，后台服务层传参数方式：baseDao.selectOne(sql, new Object[]{param1,param2});

（6）读取配置文件CustomizedPropertyPlaceholderConfigurer.java

 1 package com.sf.springJDBC.base.http; 2  3 import java.util.HashMap; 4 import java.util.Map; 5 import java.util.Properties; 6  7 import org.springframework.beans.BeansException; 8 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; 9 import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;10 11 /*12  * 读取配置文件13  */14 public class CustomizedPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer {15 16     private static Map<String, Object> ctxPropertiesMap;17 18     @Override19     protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) throws BeansException {20         super.processProperties(beanFactoryToProcess, props);21         ctxPropertiesMap = new HashMap<String, Object>();22         for (Object key : props.keySet()) {23             String keyStr = key.toString();24             String value = props.getProperty(keyStr);25             ctxPropertiesMap.put(keyStr, value);26         }27     }28 29     public static Object getContextProperty(String name) {30         return ctxPropertiesMap.get(name);31     }32 }

（7）控制层继承的基础类：BaseController.java

  1 package com.sf.springJDBC.base;  2   3 import java.io.IOException;  4 import java.io.StringReader;  5 import java.util.HashMap;  6 import java.util.List;  7 import java.util.Map;  8 import java.util.regex.Matcher;  9 import java.util.regex.Pattern; 10  11 import javax.servlet.http.HttpServletRequest; 12 import javax.xml.parsers.DocumentBuilder; 13 import javax.xml.parsers.DocumentBuilderFactory; 14 import javax.xml.parsers.ParserConfigurationException; 15  16 import org.codehaus.jackson.JsonParseException; 17 import org.codehaus.jackson.map.JsonMappingException; 18 import org.codehaus.jackson.map.ObjectMapper; 19 import org.w3c.dom.Document; 20 import org.w3c.dom.Node; 21 import org.w3c.dom.NodeList; 22 import org.xml.sax.InputSource; 23 import org.xml.sax.SAXException; 24  25 import net.sf.json.JSONArray; 26  27 import com.alibaba.fastjson.JSON; 28 import com.oncon.core.common.util.JsonUtils; 29 import com.oncon.core.common.web.controller.SuperController; 30  31 public class BaseController extends SuperController { 32     protected List<Map<String,Object>> list; 33     protected Map<String, Object> result; 34  35     public BaseController() { 36         // 初始化 37         result = new HashMap<String, Object>(); 38         result.put("status", "1"); 39         result.put("desc", "失败"); 40     } 41  42     /** 43      * 返回给前端json 44      *  45      * @param map 46      * @return 47      */ 48     protected String resMapToJson(Map<String, Object> map) { 49         return JsonUtils.getObjectString(map); 50     } 51     protected String resMapToJson2(Map<String, String> map) { 52         return JsonUtils.getObjectString(map); 53     } 54      55     protected String resObjToJson(Object obj) { 56         return JSONArray.fromObject(obj).toString(); 57     } 58  59     /** 60      * 获取登录用户信息 61      *  62      * @param request 63      * @return 64      */ 65 //    protected UserInfoBean getUserInfo(HttpServletRequest request) { 66 //        if (request.getSession().getAttribute("USERINFO") == null) { 67 //            return null; 68 //        } 69 //        return (UserInfoBean) request.getSession().getAttribute("USERINFO"); 70 //    } 71  72     /** 73      * 转化传入的json,示例:{"version":"1"} 74      *  75      * @param requestJson 76      * @return 77      */ 78     // @RequestBody String requestJson 79     @SuppressWarnings("unchecked") 80     protected Map<String, Object> resJsonToMap(String requestJson) { 81         if (requestJson == null || "".equals(requestJson)) { 82             return new HashMap<String, Object>(); 83         } 84         return JsonUtils.toObject(requestJson, HashMap.class); 85     } 86  87     /** 88      * json转为map 89      *  90      * @param map 91      * @param key 92      * @return 93      */ 94     protected String getMapToParamVal(Map<String, Object> map, String key) { 95         String val = getStringValueFromMap(key, map); 96         if (val == null) { 97             return ""; 98         } else { 99             return val.trim();100         }101     }   102     /**103 104      * 调用JsonUtils jar包的方法 返回给前端json105      * 106      * @param map107      * @return108      */109     protected String resListToJson(List<Map<String, Object>> list) {110         return JSON.toJSONString(list);111     }112     /**113      * 获取url传入参数114      * 115      * @param request116      * @param key117      * @return118      */119     protected String getResToParamVal(HttpServletRequest request, String key) {120         String val = request.getParameter(key);121         if (val == null) {122             return "";123         } else {124             return val.trim();125         }126     }127     128     129     130     /**131      * Used to convert from JSON to XML or XML to JSON132      */133     protected ObjectMapper objectMapper = new ObjectMapper();134     135     /**136      * Judge the date type is XML or JSON137      * @return138      */139     protected String analyseDataType(String strData) {140         if (strData == null || strData.trim().length() <= 0) {141             return "";142         }143         144         Pattern pattern = Pattern.compile("^<\\?xml.*");145         Matcher matcher = pattern.matcher(strData);146         boolean b = matcher.matches();147         if (b) {148             return "xml";149         }150         151         pattern = Pattern.compile("^\\{.\\}$");152         matcher = pattern.matcher(strData);153         b = matcher.matches();154         if (b) {155             return "json";156         }157         return "";158     }159     /**160      * Get the request parameters, return map object161      * @param strParam162      * @return163      */164     @SuppressWarnings("unchecked")165     protected Map<String, String> getParam(String strParam) {166         Map<String, String> mapParam = null;167         168         // Judge the date type is XML or JSON169         String dataType = analyseDataType(strParam);170         171         // XML172         if ("xml".equalsIgnoreCase(dataType)) {173             StringReader stringReader = new StringReader(strParam);174             InputSource inputSource = new InputSource(stringReader);175             Document doc = null;176             177             try {178                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();179                 DocumentBuilder builder = factory.newDocumentBuilder();180                 doc = builder.parse(inputSource);181                 NodeList nodeList = doc.getElementsByTagName("ws:pin");182                 if (nodeList == null || nodeList.getLength() <= 0) {183                     return null;184                 }185                 186                 Node node = nodeList.item(0);187                 if (node == null) {188                     return null;189                 }190                 191                 //192                 strParam = node.getFirstChild().getNodeValue();193                 194             } catch (ParserConfigurationException e) {195                 e.printStackTrace();196             } catch (SAXException e) {197                 e.printStackTrace();198             } catch (IOException e) {199                 e.printStackTrace();200             }201         }202         203         // JSON204         try {205             //System.out.println("strParam"+strParam);206             mapParam = objectMapper.readValue(strParam, HashMap.class);207             //System.out.println("mapParam"+mapParam);208         } catch (JsonParseException e) {209             e.printStackTrace();210             //logger.error(e.getMessage());211         } catch (JsonMappingException e) {212             e.printStackTrace();213             //logger.error(e.getMessage());214         } catch (IOException e) {215             e.printStackTrace();216             //logger.error(e.getMessage());217         } finally {218             mapParam = mapParam != null ? mapParam : new HashMap<String, String>();219         }220         221         return mapParam;222     }223 }

（8）设置后台编码为utf-8，spring.xml配置文件需要加载该类，如果前台获取数据中文不是问号胡乱码，可以注释；

  1 package com.sf.springJDBC.base;  2   3 import java.io.IOException;  4 import java.io.InputStreamReader;  5 import java.io.OutputStreamWriter;  6 import java.io.UnsupportedEncodingException;  7 import java.nio.charset.Charset;  8 import java.util.ArrayList;  9 import java.util.List; 10  11 import org.springframework.http.HttpInputMessage; 12 import org.springframework.http.HttpOutputMessage; 13 import org.springframework.http.MediaType; 14 import org.springframework.http.converter.AbstractHttpMessageConverter; 15 import org.springframework.http.converter.HttpMessageNotReadableException; 16 import org.springframework.http.converter.HttpMessageNotWritableException; 17 import org.springframework.util.FileCopyUtils; 18  19 public class UTF8StringHttpMessageConverter extends AbstractHttpMessageConverter<String> { 20  21  22     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8"); 23  24     private final List<Charset> availableCharsets; 25    26     private boolean writeAcceptCharset = true; 27  28     public UTF8StringHttpMessageConverter() { 29         super(new MediaType("text", "plain", DEFAULT_CHARSET), MediaType.ALL); 30         this.availableCharsets = new ArrayList<Charset>(Charset.availableCharsets().values()); 31     } 32  33     /** 34      * Indicates whether the {@code Accept-Charset} should be written to any 35      * outgoing request. 36      * <p> 37      * Default is {@code true}. 38      */ 39     public void setWriteAcceptCharset(boolean writeAcceptCharset) { 40         this.writeAcceptCharset = writeAcceptCharset; 41     } 42  43     @Override 44     public boolean supports(Class<?> clazz) { 45         return String.class.equals(clazz); 46     } 47  48     @Override 49     protected String readInternal(Class clazz, HttpInputMessage inputMessage) throws IOException { 50         Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType()); 51         return FileCopyUtils.copyToString(new InputStreamReader(inputMessage.getBody(), charset)); 52     } 53  54     @Override 55     protected Long getContentLength(String s, MediaType contentType) { 56         Charset charset = getContentTypeCharset(contentType); 57         try { 58             return (long) s.getBytes(charset.name()).length; 59         } catch (UnsupportedEncodingException ex) { 60             // should not occur 61             throw new InternalError(ex.getMessage()); 62         } 63     } 64  65     @Override 66     protected void writeInternal(String s, HttpOutputMessage outputMessage) throws IOException { 67         if (writeAcceptCharset) { 68             outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets()); 69         } 70         Charset charset = getContentTypeCharset(outputMessage.getHeaders().getContentType()); 71         FileCopyUtils.copy(s, new OutputStreamWriter(outputMessage.getBody(), charset)); 72     } 73  74     /** 75      * Return the list of supported {@link Charset}. 76      * 77      * <p> 78      * By default, returns {@link Charset#availableCharsets()}. Can be 79      * overridden in subclasses. 80      * 81      * @return the list of accepted charsets 82      */ 83     protected List<Charset> getAcceptedCharsets() { 84         return this.availableCharsets; 85     } 86  87     private Charset getContentTypeCharset(MediaType contentType) { 88         if (contentType != null && contentType.getCharSet() != null) { 89             return contentType.getCharSet(); 90         } else { 91             return DEFAULT_CHARSET; 92         } 93     } 94  95 /*    @Override 96     protected String readInternal(Class<? extends String> arg0, 97             HttpInputMessage arg1) throws IOException, 98             HttpMessageNotReadableException { 99         // TODO Auto-generated method stub100         return null;101     }102 103     @Override104     protected boolean supports(Class<?> arg0) {105         // TODO Auto-generated method stub106         return false;107     }108 109     @Override110     protected void writeInternal(String arg0, HttpOutputMessage arg1)111             throws IOException, HttpMessageNotWritableException {112         // TODO Auto-generated method stub113         114     }*/115 116 }

5.部署到tomcat启动服务，请求后台数据地址：http://localhost:8080/工程名/do/test/gettest

6.总结：

这种方式获取数据都是存到map里面，很容易解析数据；穿参数也相当灵活，而且对参数类型随意定义；

以上是一个完整的springjdbc实例，如果有什么不妥或不正确的地方，欢迎指正。。。