Spring使用JdbcTemplate实现对数据库操作

最新推荐文章于 2021-11-29 08:15:00 发布
最新推荐文章于 2021-11-29 08:15:00 发布
阅读量347 收藏
点赞数
分类专栏： 雪野实训

转载于：http://www.16boke.com/article/detail/15


spring对数据库的操作使用JdbcTemplate来封装JDBC，结合Spring的注入特性可以很方便的实现对数据库的访问操作。

使用JdbcTemplate可以像JDBC一样来编写数据库的操作代码，与hibernate相比对SQL语句的控制上会更灵活，下面以一个例子来讲解JdbcTemplate的使用及相应的API。

​


一、实体Bean

[java] view plain copy
  1. package com.orm.dto;  
  2.   
  3. import java.sql.Timestamp;  
  4.   
  5. public class AreaDto implements java.io.Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private Integer areaid;  
  9.     private String area_name;  
  10.     private String area_detail;  
  11.     private Integer floor_id;  
  12.     private Integer build_id;  
  13.     private String region_name;  
  14.     private String sortno;  
  15.     private Timestamp insert_time;  
  16.     private Timestamp update_time;  
  17.     private Integer operate_id;  
  18.   
  19.     public AreaDto() {  
  20.     }  
  21.   
  22.     public AreaDto(Integer areaid) {  
  23.         this.areaid = areaid;  
  24.     }  
  25.   
  26.     public Integer getAreaid() {  
  27.         return areaid;  
  28.     }  
  29.   
  30.     public void setAreaid(Integer areaid) {  
  31.         this.areaid = areaid;  
  32.     }  
  33.   
  34.     public String getArea_name() {  
  35.         return area_name;  
  36.     }  
  37.   
  38.     public void setArea_name(String area_name) {  
  39.         this.area_name = area_name;  
  40.     }  
  41.   
  42.     public String getArea_detail() {  
  43.         return area_detail;  
  44.     }  
  45.   
  46.     public void setArea_detail(String area_detail) {  
  47.         this.area_detail = area_detail;  
  48.     }  
  49.   
  50.     public Integer getFloor_id() {  
  51.         return floor_id;  
  52.     }  
  53.   
  54.     public void setFloor_id(Integer floor_id) {  
  55.         this.floor_id = floor_id;  
  56.     }  
  57.   
  58.     public Integer getBuild_id() {  
  59.         return build_id;  
  60.     }  
  61.   
  62.     public void setBuild_id(Integer build_id) {  
  63.         this.build_id = build_id;  
  64.     }  
  65.   
  66.     public String getRegion_name() {  
  67.         return region_name;  
  68.     }  
  69.   
  70.     public void setRegion_name(String region_name) {  
  71.         this.region_name = region_name;  
  72.     }  
  73.   
  74.     public String getSortno() {  
  75.         return sortno;  
  76.     }  
  77.   
  78.     public void setSortno(String sortno) {  
  79.         this.sortno = sortno;  
  80.     }  
  81.   
  82.     public Timestamp getInsert_time() {  
  83.         return insert_time;  
  84.     }  
  85.   
  86.     public void setInsert_time(Timestamp insert_time) {  
  87.         this.insert_time = insert_time;  
  88.     }  
  89.   
  90.     public Timestamp getUpdate_time() {  
  91.         return update_time;  
  92.     }  
  93.   
  94.     public void setUpdate_time(Timestamp update_time) {  
  95.         this.update_time = update_time;  
  96.     }  
  97.   
  98.     public Integer getOperate_id() {  
  99.         return operate_id;  
  100.     }  
  101.   
  102.     public void setOperate_id(Integer operate_id) {  
  103.         this.operate_id = operate_id;  
  104.     }  
  105.   
  106. }  

[java] view plain copy
  1. package com.orm.dto;  
  2.   
  3. import java.sql.Timestamp;  
  4.   
  5. public class BuildingDto implements java.io.Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private Integer buildid;  
  9.     private String buildname;  
  10.     private String detail;  
  11.     private String sortno;  
  12.     private Timestamp insertTime;  
  13.     private Timestamp updateTime;  
  14.     private Integer operateId;  
  15.   
  16.     public BuildingDto() {  
  17.     }  
  18.   
  19.     public BuildingDto(Integer buildid) {  
  20.         this.buildid = buildid;  
  21.     }  
  22.   
  23.     public BuildingDto(Integer buildid, String buildname, String detail, String sortno, Timestamp insertTime,  
  24.             Timestamp updateTime, Integer operateId) {  
  25.         this.buildid = buildid;  
  26.         this.buildname = buildname;  
  27.         this.detail = detail;  
  28.         this.sortno = sortno;  
  29.         this.insertTime = insertTime;  
  30.         this.updateTime = updateTime;  
  31.         this.operateId = operateId;  
  32.     }  
  33.   
  34.     public Integer getBuildid() {  
  35.         return this.buildid;  
  36.     }  
  37.   
  38.     public void setBuildid(Integer buildid) {  
  39.         this.buildid = buildid;  
  40.     }  
  41.   
  42.     public String getBuildname() {  
  43.         return this.buildname;  
  44.     }  
  45.   
  46.     public void setBuildname(String buildname) {  
  47.         this.buildname = buildname;  
  48.     }  
  49.   
  50.     public String getDetail() {  
  51.         return this.detail;  
  52.     }  
  53.   
  54.     public void setDetail(String detail) {  
  55.         this.detail = detail;  
  56.     }  
  57.   
  58.     public String getSortno() {  
  59.         return this.sortno;  
  60.     }  
  61.   
  62.     public void setSortno(String sortno) {  
  63.         this.sortno = sortno;  
  64.     }  
  65.   
  66.     public Timestamp getInsertTime() {  
  67.         return this.insertTime;  
  68.     }  
  69.   
  70.     public void setInsertTime(Timestamp insertTime) {  
  71.         this.insertTime = insertTime;  
  72.     }  
  73.   
  74.     public Timestamp getUpdateTime() {  
  75.         return this.updateTime;  
  76.     }  
  77.   
  78.     public void setUpdateTime(Timestamp updateTime) {  
  79.         this.updateTime = updateTime;  
  80.     }  
  81.   
  82.     public Integer getOperateId() {  
  83.         return this.operateId;  
  84.     }  
  85.   
  86.     public void setOperateId(Integer operateId) {  
  87.         this.operateId = operateId;  
  88.     }  
  89.   
  90. }  

[java] view plain copy
  1. package com.orm.dto;  
  2.   
  3. import java.sql.Timestamp;  
  4.   
  5. public class FloorDto implements java.io.Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private Integer floorid;  
  9.     private String floorname;  
  10.     private Integer floor;  
  11.     private String detail;  
  12.     private Integer buildId;  
  13.     private String sortno;  
  14.     private Timestamp insertTime;  
  15.     private Timestamp updateTime;  
  16.     private Integer operateId;  
  17.   
  18.     public FloorDto() {  
  19.     }  
  20.   
  21.     public FloorDto(Integer floorid) {  
  22.         this.floorid = floorid;  
  23.     }  
  24.   
  25.     public Integer getFloorid() {  
  26.         return this.floorid;  
  27.     }  
  28.   
  29.     public void setFloorid(Integer floorid) {  
  30.         this.floorid = floorid;  
  31.     }  
  32.   
  33.     public String getFloorname() {  
  34.         return this.floorname;  
  35.     }  
  36.   
  37.     public void setFloorname(String floorname) {  
  38.         this.floorname = floorname;  
  39.     }  
  40.   
  41.     public String getDetail() {  
  42.         return this.detail;  
  43.     }  
  44.   
  45.     public void setDetail(String detail) {  
  46.         this.detail = detail;  
  47.     }  
  48.   
  49.     public Integer getBuildId() {  
  50.         return this.buildId;  
  51.     }  
  52.   
  53.     public void setBuildId(Integer buildId) {  
  54.         this.buildId = buildId;  
  55.     }  
  56.   
  57.     public String getSortno() {  
  58.         return this.sortno;  
  59.     }  
  60.   
  61.     public void setSortno(String sortno) {  
  62.         this.sortno = sortno;  
  63.     }  
  64.   
  65.     public Timestamp getInsertTime() {  
  66.         return this.insertTime;  
  67.     }  
  68.   
  69.     public void setInsertTime(Timestamp insertTime) {  
  70.         this.insertTime = insertTime;  
  71.     }  
  72.   
  73.     public Timestamp getUpdateTime() {  
  74.         return this.updateTime;  
  75.     }  
  76.   
  77.     public void setUpdateTime(Timestamp updateTime) {  
  78.         this.updateTime = updateTime;  
  79.     }  
  80.   
  81.     public Integer getOperateId() {  
  82.         return this.operateId;  
  83.     }  
  84.   
  85.     public void setOperateId(Integer operateId) {  
  86.         this.operateId = operateId;  
  87.     }  
  88.   
  89.     public Integer getFloor() {  
  90.         return floor;  
  91.     }  
  92.   
  93.     public void setFloor(Integer floor) {  
  94.         this.floor = floor;  
  95.     }  
  96.   
  97. }  

[java] view plain copy
  1. package com.orm.dto;  
  2.   
  3. import java.sql.Timestamp;  
  4.   
  5. public class StoreDto implements java.io.Serializable {  
  6.   
  7.     private static final long serialVersionUID = 1L;  
  8.     private Integer id;  
  9.     private String storename;  
  10.     private String storenameen;  
  11.     private String storeno;  
  12.     private Integer build_Id;  
  13.     private Integer floor_Id;  
  14.     private Integer area_Id;  
  15.     private Integer type_Id;  
  16.     private Integer point_Id;  
  17.     private String storeowner;  
  18.     private String area;  
  19.     private String remark;  
  20.     private String status;  
  21.     private String sortno;  
  22.     private Timestamp inserttime;  
  23.     private Timestamp updatetime;  
  24.     private Integer operateid;  
  25.   
  26.     public StoreDto() {  
  27.     }  
  28.   
  29.     public StoreDto(Integer id) {  
  30.         this.id = id;  
  31.     }  
  32.   
  33.     public Integer getId() {  
  34.         return this.id;  
  35.     }  
  36.   
  37.     public void setId(Integer id) {  
  38.         this.id = id;  
  39.     }  
  40.   
  41.     public String getStorename() {  
  42.         return this.storename;  
  43.     }  
  44.   
  45.     public void setStorename(String storename) {  
  46.         this.storename = storename;  
  47.     }  
  48.   
  49.     public String getStorenameen() {  
  50.         return this.storenameen;  
  51.     }  
  52.   
  53.     public void setStorenameen(String storenameen) {  
  54.         this.storenameen = storenameen;  
  55.     }  
  56.   
  57.     public String getStoreno() {  
  58.         return this.storeno;  
  59.     }  
  60.   
  61.     public void setStoreno(String storeno) {  
  62.         this.storeno = storeno;  
  63.     }  
  64.   
  65.     public Integer getBuild_Id() {  
  66.         return this.build_Id;  
  67.     }  
  68.   
  69.     public void setBuild_Id(Integer build_Id) {  
  70.         this.build_Id = build_Id;  
  71.     }  
  72.   
  73.     public Integer getFloor_Id() {  
  74.         return this.floor_Id;  
  75.     }  
  76.   
  77.     public void setFloor_Id(Integer floor_Id) {  
  78.         this.floor_Id = floor_Id;  
  79.     }  
  80.   
  81.     public Integer getArea_Id() {  
  82.         return this.area_Id;  
  83.     }  
  84.   
  85.     public void setArea_Id(Integer area_Id) {  
  86.         this.area_Id = area_Id;  
  87.     }  
  88.   
  89.     public Integer getType_Id() {  
  90.         return this.type_Id;  
  91.     }  
  92.   
  93.     public void setType_Id(Integer type_Id) {  
  94.         this.type_Id = type_Id;  
  95.     }  
  96.   
  97.     public Integer getPoint_Id() {  
  98.         return this.point_Id;  
  99.     }  
  100.   
  101.     public void setPoint_Id(Integer point_Id) {  
  102.         this.point_Id = point_Id;  
  103.     }  
  104.   
  105.     public String getStoreowner() {  
  106.         return this.storeowner;  
  107.     }  
  108.   
  109.     public void setStoreowner(String storeowner) {  
  110.         this.storeowner = storeowner;  
  111.     }  
  112.   
  113.     public String getArea() {  
  114.         return this.area;  
  115.     }  
  116.   
  117.     public void setArea(String area) {  
  118.         this.area = area;  
  119.     }  
  120.   
  121.     public String getRemark() {  
  122.         return this.remark;  
  123.     }  
  124.   
  125.     public void setRemark(String remark) {  
  126.         this.remark = remark;  
  127.     }  
  128.   
  129.     public String getStatus() {  
  130.         return this.status;  
  131.     }  
  132.   
  133.     public void setStatus(String status) {  
  134.         this.status = status;  
  135.     }  
  136.   
  137.     public String getSortno() {  
  138.         return this.sortno;  
  139.     }  
  140.   
  141.     public void setSortno(String sortno) {  
  142.         this.sortno = sortno;  
  143.     }  
  144.   
  145.     public Timestamp getInserttime() {  
  146.         return this.inserttime;  
  147.     }  
  148.   
  149.     public void setInserttime(Timestamp inserttime) {  
  150.         this.inserttime = inserttime;  
  151.     }  
  152.   
  153.     public Timestamp getUpdatetime() {  
  154.         return this.updatetime;  
  155.     }  
  156.   
  157.     public void setUpdatetime(Timestamp updatetime) {  
  158.         this.updatetime = updatetime;  
  159.     }  
  160.   
  161.     public Integer getOperateid() {  
  162.         return this.operateid;  
  163.     }  
  164.   
  165.     public void setOperateid(Integer operateid) {  
  166.         this.operateid = operateid;  
  167.     }  
  168.   
  169. }  

二、jdbc.properties
[html] view plain copy
  1. jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver  
  2. jdbc.url=jdbc:sqlserver://127.0.0.1:1433;databaseName=test  
  3. jdbc.username=sa  
  4. jdbc.password=admin@2013  
  5. jdbc.maxActive=50  
  6. jdbc.maxIdle=10  
  7. jdbc.maxWait=50  
  8. jdbc.defaultAutoCommit=true  

三、Spring配置文件【beans.xml】
[html] view plain copy
  1. <?xml version="1.0" encoding="GB18030"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"  
  4.     xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"  
  5.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans    
  7.       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
  8.       http://www.springframework.org/schema/context    
  9.       http://www.springframework.org/schema/context/spring-context.xsd    
  10.       http://www.springframework.org/schema/aop  
  11.       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  12.       http://www.springframework.org/schema/tx  
  13.       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
  14.       http://www.springframework.org/schema/mvc    
  15.       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd"  
  16.     default-autowire="byName" default-lazy-init="true">  
  17.     <!-- 属性文件读入 -->  
  18.     <bean id="propertyConfigurer"  
  19.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  20.         <property name="locations">  
  21.             <list>  
  22.                 <value>classpath*:config/*.properties</value>  
  23.             </list>  
  24.         </property>  
  25.     </bean>  
  26.     <!-- 数据源定义,使用dbcp数据源 -->  
  27.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  28.         <property name="driverClassName" value="${jdbc.driverClassName}"></property>  
  29.         <property name="url" value="${jdbc.url}"></property>  
  30.         <property name="username" value="${jdbc.username}"></property>  
  31.         <property name="password" value="${jdbc.password}"></property>  
  32.         <property name="maxActive" value="${jdbc.maxActive}"></property>  
  33.         <property name="maxIdle" value="${jdbc.maxIdle}"></property>  
  34.         <property name="maxWait" value="${jdbc.maxWait}"></property>  
  35.         <property name="defaultAutoCommit" value="${jdbc.defaultAutoCommit}"></property>  
  36.     </bean>  
  37.       
  38.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" abstract="false"  
  39.         lazy-init="false" autowire="default" >  
  40.         <property name="dataSource">  
  41.             <ref bean="dataSource" />  
  42.         </property>  
  43.     </bean>  
  44.   
  45.     <bean id="ormDao" class="com.orm.dao.impl.OrmDaoImpl">  
  46.        <property name="template">  
  47.           <ref bean="jdbcTemplate" />  
  48.        </property>  
  49.     </bean>  
  50. </beans>  

四、web.xml
[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
  5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
  6.     <!--  
  7.         Spring ApplicationContext配置文件的路径,可使用通配符，多个路径用,号分隔  
  8.         此参数用于后面的Spring-Context loader  
  9.     -->  
  10.     <context-param>  
  11.         <param-name>contextConfigLocation</param-name>  
  12.         <param-value>classpath*:spring/*.xml</param-value>  
  13.     </context-param>  
  14.     <!--Spring ApplicationContext 载入 -->  
  15.     <listener>  
  16.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  17.     </listener>  
  18.     <!-- 著名 Character Encoding filter -->  
  19.     <filter>  
  20.         <filter-name>encodingFilter</filter-name>  
  21.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  22.         <init-param>  
  23.             <param-name>encoding</param-name>  
  24.             <param-value>GBK</param-value>  
  25.         </init-param>  
  26.     </filter>  
  27.       
  28.   
  29.     <!-- Spring 刷新Introspector防止内存泄露 -->  
  30.     <listener>  
  31.         <listener-class>  
  32.             org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
  33.     </listener>  
  34.     <!-- 
  35.         session超时定义,单位为分钟，清除服务端我们存储在Session中的对象，不清除Tomcat容器存储在Session中的对象 
  36.     -->  
  37.     <session-config>  
  38.         <session-timeout>30</session-timeout>  
  39.     </session-config>  
  40. </web-app>  

五、数据库访问接口【OrmDao.java】
[java] view plain copy
  1. package com.orm.dao;  
  2.   
  3. import java.util.List;  
  4. import java.util.Map;  
  5.   
  6. import com.orm.dto.AreaDto;  
  7. import com.orm.dto.BuildingDto;  
  8. import com.orm.dto.FloorDto;  
  9. import com.orm.dto.StoreDto;  
  10.   
  11. public interface OrmDao {  
  12.     public List<AreaDto> getAreaDtos();  
  13.   
  14.     public List<AreaDto> getAreaDtos1();  
  15.   
  16.     public Map<String, Object> getBuilds();  
  17.   
  18.     public Map<String, Object> getFloors(String build);  
  19.   
  20.     public Map<String, Object> getAreas(String build, String floor);  
  21.   
  22.     public List<StoreDto> getStoreDtos(int buildid, int floorid, int areaid);  
  23.   
  24.     public List<BuildingDto> getBuildingDto();  
  25.   
  26.     public List<FloorDto> getFloorDtos(int buildid);  
  27.   
  28.     public List<AreaDto> getAreaDto(int buildid, int floorid);  
  29.   
  30.     public AreaDto getAreaDto(int id);  
  31.   
  32.     public BuildingDto getBuildingDto(int buildId);  
  33.   
  34.     public FloorDto getFloorDto(int floorId);  
  35.   
  36.     public List<StoreDto> getAllStores();  
  37.   
  38.     public String storeName(int storeId);  
  39.   
  40.     public StoreDto getStoreById(int storeId);  
  41.   
  42.     public int getCountStore();  
  43.   
  44.     public void saveBuild(BuildingDto buildingDto);  
  45.   
  46.     public void deleteBuildById(int buildid);  
  47.   
  48.     public void updateBuildById(BuildingDto buildingDto);  
  49. }  

六、数据库访问接口的实现类【OrmDaoImpl.java】
[java] view plain copy
  1. package com.orm.dao.impl;  
  2.   
  3. import java.sql.ResultSet;  
  4. import java.sql.SQLException;  
  5. import java.util.HashMap;  
  6. import java.util.LinkedHashMap;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. import org.springframework.jdbc.core.BeanPropertyRowMapper;  
  11. import org.springframework.jdbc.core.JdbcTemplate;  
  12. import org.springframework.jdbc.core.RowMapper;  
  13.   
  14. import com.orm.dao.OrmDao;  
  15. import com.orm.dto.AreaDto;  
  16. import com.orm.dto.BuildingDto;  
  17. import com.orm.dto.FloorDto;  
  18. import com.orm.dto.StoreDto;  
  19.   
  20. @SuppressWarnings({ "unchecked", "rawtypes" })  
  21. public class OrmDaoImpl implements OrmDao {  
  22.     private JdbcTemplate template;  
  23.   
  24.     public JdbcTemplate getTemplate() {  
  25.         return template;  
  26.     }  
  27.   
  28.     public void setTemplate(JdbcTemplate template) {  
  29.         this.template = template;  
  30.     }  
  31.   
  32.     public List<AreaDto> getAreaDtos() {  
  33.         String sql = "select * from t_area ";  
  34.         return (List<AreaDto>) template.query(sql, new BeanPropertyRowMapper(AreaDto.class));  
  35.     }  
  36.   
  37.     public List<AreaDto> getAreaDtos1() {  
  38.         String sql = "select * from t_area ";  
  39.         return (List<AreaDto>) template.query(sql, new AreaRowMapper());  
  40.     }  
  41.   
  42.     public Map<String, Object> getBuilds() {  
  43.         String sql = "select buildid,buildname from t_building ";  
  44.         List<BuildingDto> list = this.template.query(sql, new BeanPropertyRowMapper(BuildingDto.class));  
  45.         Map<String, Object> map = new HashMap<String, Object>();  
  46.         for (BuildingDto build : list) {  
  47.             map.put(String.valueOf(build.getBuildid()), build.getBuildname());  
  48.         }  
  49.         return map;  
  50.     }  
  51.   
  52.     public Map<String, Object> getFloors(String build) {  
  53.         String sql = "select floorid ,floorname from t_floor where build_id=?";  
  54.         List<FloorDto> list = this.template.query(sql, new Object[] { build }, new BeanPropertyRowMapper(FloorDto.class));  
  55.         Map<String, Object> map = new LinkedHashMap<String, Object>();  
  56.         for (FloorDto floorDto : list) {  
  57.             System.out.println(floorDto.getFloorid());  
  58.             map.put(String.valueOf(floorDto.getFloorid()), floorDto.getFloorname());  
  59.         }  
  60.         return map;  
  61.     }  
  62.   
  63.     public Map<String, Object> getAreas(String build, String floor) {  
  64.         String sql = "select areaid ,area_name from t_area where build_id=? and floor_id=?";  
  65.         List<AreaDto> list = this.template.query(sql, new Object[] { build, floor }, new BeanPropertyRowMapper(AreaDto.class));  
  66.         Map<String, Object> map = new LinkedHashMap<String, Object>();  
  67.         for (AreaDto areaDto : list) {  
  68.             System.out.println(areaDto.getAreaid());  
  69.             map.put(String.valueOf(areaDto.getAreaid()), areaDto.getArea_name());  
  70.         }  
  71.         return map;  
  72.     }  
  73.   
  74.     public List<StoreDto> getStoreDtos(int buildid, int floorid, int areaid) {  
  75.         String sql = "select * from t_store where build_id=? and floor_id=? and area_id=?";  
  76.         return (List<StoreDto>) template.query(sql, new Object[] { buildid, floorid, areaid }, new BeanPropertyRowMapper(  
  77.                 StoreDto.class));  
  78.     }  
  79.   
  80.     public List<BuildingDto> getBuildingDto() {  
  81.         String sql = "select * from t_building ";  
  82.         return (List<BuildingDto>) template.query(sql, new BeanPropertyRowMapper(BuildingDto.class));  
  83.     }  
  84.   
  85.     public List<FloorDto> getFloorDtos(int buildid) {  
  86.         String sql = "select * from t_floor where build_id=? ";  
  87.         return (List<FloorDto>) template.query(sql, new Object[] { buildid }, new BeanPropertyRowMapper(FloorDto.class));  
  88.     }  
  89.   
  90.     public List<AreaDto> getAreaDto(int buildid, int floorid) {  
  91.         String sql = "select * from t_area where build_id=? and floor_id=?";  
  92.         return (List<AreaDto>) template.query(sql, new Object[] { buildid, floorid }, new BeanPropertyRowMapper(AreaDto.class));  
  93.     }  
  94.   
  95.     public AreaDto getAreaDto(int id) {  
  96.         String sql = "select * from t_area where areaid=?";  
  97.         return template.queryForObject(sql, new Object[] { id }, new BeanPropertyRowMapper(AreaDto.class));  
  98.     }  
  99.   
  100.     public BuildingDto getBuildingDto(int buildId) {  
  101.         String sql = "select * from t_building where buildid=?";  
  102.         return template.queryForObject(sql, new Object[] { buildId }, new BeanPropertyRowMapper(BuildingDto.class));  
  103.     }  
  104.   
  105.     public FloorDto getFloorDto(int floorId) {  
  106.         String sql = "select * from t_floor where floorid=?";  
  107.         return template.queryForObject(sql, new Object[] { floorId }, new BeanPropertyRowMapper(FloorDto.class));  
  108.     }  
  109.   
  110.     public List<StoreDto> getAllStores() {  
  111.         String sql = "select * from t_store ";  
  112.         return (List<StoreDto>) template.query(sql, new BeanPropertyRowMapper(StoreDto.class));  
  113.     }  
  114.   
  115.     public String storeName(int storeId) {  
  116.         String sql = "select storename from t_store where id=?";  
  117.         return template.queryForObject(sql, new Object[] { storeId }, String.class);  
  118.     }  
  119.   
  120.     public StoreDto getStoreById(int storeInt) {  
  121.         String sql = "select * from t_store where id=?";  
  122.         return template.queryForObject(sql, new Object[] { storeInt }, new BeanPropertyRowMapper(StoreDto.class));  
  123.     }  
  124.   
  125.     public int getCountStore() {  
  126.         String sql = "select count(id) from t_store";  
  127.         return this.template.queryForInt(sql);  
  128.     }  
  129.   
  130.     public void saveBuild(BuildingDto buildingDto) {  
  131.     }  
  132.   
  133.     public void deleteBuildById(int buildid) {  
  134.         String sql = "delete from t_store where id=?";  
  135.         this.template.update(sql, buildid);  
  136.     }  
  137.   
  138.     public void updateBuildById(BuildingDto buildingDto) {  
  139.   
  140.     }  
  141. }  
  142.   
  143. class AreaRowMapper implements RowMapper {  
  144.     public Object mapRow(ResultSet rs, int index) throws SQLException {  
  145.         AreaDto areaDto = new AreaDto();  
  146.         areaDto.setAreaid(rs.getInt("areaid"));  
  147.         areaDto.setArea_name(rs.getString("area_name"));  
  148.         areaDto.setArea_detail(rs.getString("area_detail"));  
  149.         areaDto.setBuild_id(rs.getInt("build_id"));  
  150.         areaDto.setFloor_id(rs.getInt("floor_id"));  
  151.         areaDto.setInsert_time(rs.getTimestamp("insert_time"));  
  152.         areaDto.setOperate_id(rs.getInt("operate_id"));  
  153.         areaDto.setUpdate_time(rs.getTimestamp("update_time"));  
  154.         areaDto.setRegion_name(rs.getString("region_name"));  
  155.         areaDto.setSortno(rs.getString("sortno"));  
  156.         return areaDto;  
  157.     }  
  158. }  

七、测试类
[java] view plain copy
  1. package com.orm.test;  
  2.   
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Map.Entry;  
  7. import java.util.Set;  
  8.   
  9. import org.junit.Before;  
  10. import org.junit.Test;  
  11. import org.springframework.context.ApplicationContext;  
  12. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  13.   
  14. import com.orm.dao.OrmDao;  
  15. import com.orm.dto.AreaDto;  
  16.   
  17. public class AreaTest{  
  18.     private ApplicationContext ctx = null;  
  19.     private OrmDao ormDao = null;  
  20.     @Before  
  21.     public void setUp() throws Exception {  
  22.         ctx = new ClassPathXmlApplicationContext("classpath:spring/beans.xml");  
  23.         ormDao = (OrmDao) ctx.getBean("ormDao");  
  24.     }  
  25.     @Test  
  26.     public void getAreaDtosTest(){  
  27.         List<AreaDto> list = this.ormDao.getAreaDtos();  
  28.         for(AreaDto areaDto : list){  
  29.             System.out.println(areaDto.getArea_name());  
  30.         }  
  31.         System.out.println(list.size());  
  32.     }  
  33.     @Test  
  34.     public void getAreaDtosTest1(){  
  35.         List<AreaDto> list = this.ormDao.getAreaDtos1();  
  36.         for(AreaDto areaDto : list){  
  37.             System.out.println(areaDto.getArea_name());  
  38.         }  
  39.         System.out.println(list.size());  
  40.     }  
  41.     @Test  
  42.     public void getBuildsTest(){  
  43.         Map<String, Object> builds = this.ormDao.getBuilds();  
  44.         Iterator<String> keys = builds.keySet().iterator();  
  45.         String key = "";  
  46.         while(keys.hasNext()){  
  47.             key = keys.next();  
  48.             System.out.println("key = "+key+",value = "+builds.get(key));  
  49.         }  
  50.     }  
  51.     @Test  
  52.     public void getFloorsTest(){  
  53.         Map<String, Object> floors = this.ormDao.getFloors("1");  
  54.         System.out.println(floors);  
  55.         Set<Entry<String, Object>> floorSet = floors.entrySet();  
  56.         for(Entry floor : floorSet){  
  57.             System.out.println(floor.getKey()+","+floor.getValue());  
  58.         }  
  59.     }  
  60.     @Test  
  61.     public void getAreasTest(){  
  62.         Map<String, Object> areas = this.ormDao.getAreas("1","1");  
  63.         System.out.println(areas);  
  64.         Set<Entry<String, Object>> areaSet = areas.entrySet();  
  65.         for(Entry area : areaSet){  
  66.             System.out.println(area.getKey()+","+area.getValue());  
  67.         }  
  68.     }  
  69.     @Test  
  70.     public void getCountStoreTest(){  
  71.         System.out.println(this.ormDao.getCountStore());  
  72.     }  
  73. }  

说明：

JdbcTemplate提供的方法很多如：queryForXXX，可以将查询结果以int、long、Object、List、Map来返回，这里有几个需要注意的：

下面是针对老版本的Spring1.2.x的JdbcTemplate操作：使用RowMapperResultReader对象来处理

[java] view plain copy
  1. class UserRowMapper implements RowMapper {  
  2.     public Object mapRow(ResultSet rs, int index) throws SQLException {  
  3.         User user = new User();  
  4.   
  5.         user.setId(rs.getString("user_id"));  
  6.         user.setName(rs.getString("name"));  
  7.         user.setSex(rs.getString("sex").charAt(0));  
  8.         user.setAge(rs.getInt("age"));  
  9.   
  10.         return user;  
  11.     }  
  12. }  
  13.   
  14. public List findAllByRowMapperResultReader() {  
  15.     String sql = "SELECT * FROM USER";  
  16.     return jdbcTemplate.query(sql, new RowMapperResultReader(new UserRowMapper()));  
  17. }  

但是在Spring2及以上的版本中却没有RowMapperResultReader这个对象，所以直接传替封装类来使用：
[java] view plain copy
  1. public List<AreaDto> getAreaDtos1() {  
  2.         String sql = "select * from t_area ";  
  3.         return (List<AreaDto>) template.query(sql, new AreaRowMapper());  
  4.     }  
  5. class AreaRowMapper implements RowMapper {  
  6.     public Object mapRow(ResultSet rs, int index) throws SQLException {  
  7.         AreaDto areaDto = new AreaDto();  
  8.         areaDto.setAreaid(rs.getInt("areaid"));  
  9.         areaDto.setArea_name(rs.getString("area_name"));  
  10.         areaDto.setArea_detail(rs.getString("area_detail"));  
  11.         areaDto.setBuild_id(rs.getInt("build_id"));  
  12.         areaDto.setFloor_id(rs.getInt("floor_id"));  
  13.         areaDto.setInsert_time(rs.getTimestamp("insert_time"));  
  14.         areaDto.setOperate_id(rs.getInt("operate_id"));  
  15.         areaDto.setUpdate_time(rs.getTimestamp("update_time"));  
  16.         areaDto.setRegion_name(rs.getString("region_name"));  
  17.         areaDto.setSortno(rs.getString("sortno"));  
  18.         return areaDto;  
  19.     }  
  20. }  

queryForList方法

此方法返回List数据，但是注意List中的数据却是Map形式，类似：[{AREAID=1, AREA_NAME=1楼报名咨询区}, {AREAID=2, AREA_NAME=2楼教学区}, {AREAID=3, AREA_NAME=3楼课外辅导区}]，其中字段名为key，字段值为value


queryForMap方法

返回Map类型的数据，数据格式为{AREAID=1, AREA_NAME=1楼报名咨询区}，注意：此方法必须只能返回一条记录，如果查询有多条记录就会报错：“org.springframework.dao.IncorrectResultSizeDataAccessException: Incorrect result size: expected 1, actual 2”


如果需要查询数据库返回一个List<T>类型的对象该如何实现？

目前有两种形式：

第一种：

[java] view plain copy
  1. public List<AreaDto> getAreaDtos1() {  
  2.         String sql = "select * from t_area ";  
  3.         return (List<AreaDto>) template.query(sql, new AreaRowMapper());  
  4.     }  
  5. class AreaRowMapper implements RowMapper {  
  6.     public Object mapRow(ResultSet rs, int index) throws SQLException {  
  7.         AreaDto areaDto = new AreaDto();  
  8.         areaDto.setAreaid(rs.getInt("areaid"));  
  9.         areaDto.setArea_name(rs.getString("area_name"));  
  10.         areaDto.setArea_detail(rs.getString("area_detail"));  
  11.         areaDto.setBuild_id(rs.getInt("build_id"));  
  12.         areaDto.setFloor_id(rs.getInt("floor_id"));  
  13.         areaDto.setInsert_time(rs.getTimestamp("insert_time"));  
  14.         areaDto.setOperate_id(rs.getInt("operate_id"));  
  15.         areaDto.setUpdate_time(rs.getTimestamp("update_time"));  
  16.         areaDto.setRegion_name(rs.getString("region_name"));  
  17.         areaDto.setSortno(rs.getString("sortno"));  
  18.         return areaDto;  
  19.     }  
  20. }  

第二种：
[java] view plain copy
  1. public List<AreaDto> getAreaDtos() {  
  2.         String sql = "select * from t_area ";  
  3.         System.out.println(template.queryForList(sql));  
  4.         return (List<AreaDto>) template.query(sql, new BeanPropertyRowMapper(AreaDto.class));  
  5.     }  

很显然采用第二种会更简单。


转载于：http://www.16boke.com/article/detail/15

SSSkyCong
关注
专栏目录
详解在spring中使用JdbcTemplate操作数据库的几种方式
08-18
综上所述，Spring中的JdbcTemplate是实现数据库操作的强大工具，它简化了数据库交互的代码，提供了事务管理和错误处理机制。通过配置数据源和注入JdbcTemplate实例，我们可以方便地执行SQL语句，进行数据的增删改查...
springboot+template模板语法+SQL如何从零开始创建并运行一个实例
最新发布
qq_63462564的博客
03-19 1450
我们可以在浏览器里输入localhost:+端口号运行看看，我这里就是localhost:8282，一般默认端口号是8080，我配置了一下端口，后面会提到，这里你用你控制台显示的端口即可。如果最后运行有错误的话可能文件位置写错了，可以仔细看下我的是怎么样的结构，也可能是依赖包导入的问题，有版本兼容问题，我这里把我的pom.xml文件发出来，可以参考一下。再选选一个模板语法的依赖，thymeleaf，还有数据库的依赖，选择自己对应的数据库，我使用的是MySQL，SQLServer选mmsql。
springBoot整合SqlSessionTemplate使用
人生就像一场戏
11-25 6730
实际开发中我们操作数据库持久化，总是需要写重复的mapper，service，xml浪费了我们大量的时间，在这里推荐大家使用SqlSessionTemplate 1.application.xml配置 server.port=8081 #server.servlet.context-path=/recordLog #数据源必填项 spring.datasource.url=jdbc:mysql://localhost:3306/test?generateSimpleParameterMetadata
SpringTemplate操作数据库（了解）
weixin_44630656的博客
03-20 450
SpringTemplate操作数据库（了解）一、概述二、环境准备2.1 导入JAR包2.2 在Spring配置文件中配置相关的bean三、持久化操作3.1 增删改3.2 批量增删改3.3 查询单行3.4 查询多行3.5 查询单一值四、使用具名参数的JdbcTemplate4.1 关于具名参数4.2 通过IOC容器创建NamedParameterJdbcTemplate对象4.3 具名参数在SQL语句中的格式4.4 具名参数传入五、使用JdbcTemplate实现Dao 一、概述 为了使JDBC更加易于使用
16.Spring中JdbcTemplate模板的使用
actores的博客
11-01 327
1.结构图 2.（方法一：基础使用模板） 2.1实体类：Account package com.itheima.pojo; //Serializable数据序列化 import java.io.Serializable; public class Account implements Serializable { private int id; private String name; private Float money; public int getId()
Spring Boot中使用jdbctemplate 操作MYSQL数据库实例
08-30
在Spring Boot中，JdbcTemplate是一个简单易用的模板类，用于简化数据库操作...通过上述步骤，你可以轻松地在Spring Boot应用中实现对MySQL数据库的读写操作。记得根据实际需求调整配置和SQL语句，以满足你的业务逻辑。
Spring boot 使用JdbcTemplate访问数据库
08-27
在 Spring Boot 中使用 JdbcTemplate 访问数据库，是一种常见且简便的方式，特别适合那些需要对数据库进行基础操作的应用。 JdbcTemplate 是 Spring Framework 提供的一个模板类，它对 JDBC API 进行了封装，使得...
Spring Boot 与 Kotlin 使用JdbcTemplate连接MySQL数据库的方法
08-28
在Spring Boot框架中，结合Kotlin编程语言，我们可以利用JdbcTemplate来轻松地连接和操作MySQL数据库。JdbcTemplate是Spring提供的一种简化数据库访问的工具，它提供了模板方法来执行SQL语句，使得数据库操作更加...
简单介绍如何使用Spring Boot使用JdbcTemplate与MySQL进行数据库操作
09-29
在本文中，我们将深入探讨如何使用Spring Boot集成JdbcTemplate与MySQL数据库进行数据操作。Spring Boot以其简化配置和快速启动的特点，已经成为Java开发者的首选框架。而JdbcTemplate是Spring框架的一部分，它提供...
使用spring jdbc template简化jdbc数据库操作实例代码
09-30
使用spring jdbc template简化jdbc数据库操作实例代码，简化操作，包括详细测试例子。
SpringBoot使用JdbcTemplate操作数据库
08-27
接着，通过实现该接口并使用JdbcTemplate，我们可以实现具体的数据库操作逻辑： ```java @Repository public class UserRepositoryImpl implements UserRepository { private final JdbcTemplate jdbcTemplate; ...
springboot使用JdbcTemplate完成对数据库的增删改查功能
08-28
Spring Boot 使用 JdbcTemplate 实现数据库增删改查功能 概述 Spring Boot 是一个基于 Java 的框架，旨在简化企业级应用程序的开发。JdbcTemplate 是 Spring Framework 中的一个模板类，提供了简洁的数据库操作...
Spring 中jdbcTemplate 实现执行多条sql语句示例
08-31
在Spring框架中，JdbcTemplate是用于简化数据库操作的一个重要工具。它提供了执行SQL语句的能力，包括单条语句执行和批处理。本文将详细解释如何使用JdbcTemplate来执行多条SQL语句，以及其在事务管理中的作用。 ...
详解spring boot中使用JdbcTemplate
08-30
只需要正确配置数据源，Spring Boot会自动创建并注入JdbcTemplate实例，开发者可以直接在服务类或控制器中通过@Autowired注解来使用它，进行数据库的增删查改操作。同时，JdbcTemplate还支持事务管理，可以使用@...
Spring的Template
weixin_33858249的博客
08-31 457
什么是Tenplate? 　　Spring提供的一种操作数据库的技术，是对Jdbc的封装。语法非常接近DBUtils. 　　JdbcTemplate可以直接操作数据库，加快效率，jdbcTemplate也可以为声明式事务准备 为什么用JdbcTemplate进行开发？　　 　　Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注...
Spring JDBC Template使用速查
Koma_zhe的学习笔记
11-14 1642
导入依赖后配置数据源: spring:#yml配置文件 datasource: spark: type: com.alibaba.druid.pool.DruidDataSource url: jdbc:hive2://x.x.x.x:21000/hive driver-class-name: org.apache.hive.jdbc.HiveDriver username: xxx password: xxx initia
【SpringBoot系列】Spring 中的Template一次全理解，解析问题的本质
我是香菜
11-29 2418
在学习spring的过程中，经常能看到各种Template，如果能理解了这个的核心思想是不是一下就可以全部理解所有的Template，也就是掌握事情的本质，做到一通百通，再遇到类似的不会不理解，可以直接做知识迁移，今天来一起理解下 1、设计模式之模板模式 模板模式又叫模板方法模式，是定义问题的主要框架，流程，具体的详细实现留到子类，也就是定义了事情的规则，至于每个小部分在子类中可以自定义。留下大框架，保留灵活性。 模板模式使得子类可以在不改变算法结果的情况下，重新定义某些步骤，属于行为型设计模式。
Spring-mybatis中的 sqlsessionTemplate 如何处理封装的处理Sql
weixin_43689953的博客
11-18 435
/** * 防止sql注入 改造成直接用prepareStatement 预处理sql * * @param sql * @param params * @return */ @Override public List<Map<String, Object>> executeSql(String sql, Object[] params) { log.debug("----【querySer.
Spring Boot与JdbcTemplate的MySQL数据库操作教程
使用Spring Boot与JdbcTemplate进行MySQL数据库操作，可以极大地简化传统的JDBC编程模式，使得开发者可以更加专注于业务逻辑的实现。此外，Spring Boot的自动配置和约定优于配置的原则，也大大降低了项目的配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值