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.xml
19             </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 connection
10 dataSource.initialSize=5
11 dataSource.minIdle=10
12 dataSource.maxActive=500
13 dataSource.maxWait=6000
14 dataSource.timeBetweenEvictionRunsMillis=3000
15 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 @Controller
19 @RequestMapping("/test")
20 public class TestController extends BaseController{
21     @Resource
22     private TestService testService;
23     
24     @ResponseBody
25     @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     @Override
19     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包的方法 返回给前端json
105      * 
106      * @param map
107      * @return
108      */
109     protected String resListToJson(List<Map<String, Object>> list) {
110         return JSON.toJSONString(list);
111     }
112     /**
113      * 获取url传入参数
114      * 
115      * @param request
116      * @param key
117      * @return
118      */
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 JSON
132      */
133     protected ObjectMapper objectMapper = new ObjectMapper();
134     
135     /**
136      * Judge the date type is XML or JSON
137      * @return
138      */
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 object
161      * @param strParam
162      * @return
163      */
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 JSON
169         String dataType = analyseDataType(strParam);
170         
171         // XML
172         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         // JSON
204         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 stub
100         return null;
101     }
102 
103     @Override
104     protected boolean supports(Class<?> arg0) {
105         // TODO Auto-generated method stub
106         return false;
107     }
108 
109     @Override
110     protected void writeInternal(String arg0, HttpOutputMessage arg1)
111             throws IOException, HttpMessageNotWritableException {
112         // TODO Auto-generated method stub
113         
114     }*/
115 
116 }

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

6.总结：

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

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