`

Spring中jdbcTemplate的用法实例（一）

springspring jdbctemplatejdbc 
阅读更多

一、首先配置JdbcTemplate；

要使用Jdbctemplate 对象来完成jdbc 操作。通常情况下，有三种种方式得到JdbcTemplate 对象。 
      第一种方式：我们可以在自己定义的DAO 实现类中注入一个DataSource 引用来完 成JdbcTemplate 的实例化。也就是它是从外部“注入” DataSource 到DAO 中，然后 自己实例化JdbcTemplate，然后将DataSource 设置到JdbcTemplate 对象中。 
      第二种方式： 在 Spring 的 IoC 容器中配置一个 JdbcTemplate 的 bean，将 DataSource 注入进来，然后再把JdbcTemplate 注入到自定义DAO 中。 
      第三种方式: Spring 提供了 org.springframework.jdbc.core.support.JdbcDaoSupport 类 ， 这 个 类 中 定 义 了 JdbcTemplate 属性，也定义了DataSource 属性，当设置DataSource 属性的时候，会创 建jdbcTemplate 的实例，所以我们自己编写的DAO 只需要继承JdbcDaoSupport 类， 然后注入DataSource 即可。提倡采用第三种方法。虽然下面的用法中采用了前两种方法

    

  配置方法有3种：

      1、

Java代码  收藏代码
  1. public class UserServiceImpl implements UserService {  
  2.   
  3.     private JdbcTemplate jdbcTemplate;  
  4.       
  5.     public JdbcTemplate getJdbcTemplate() {  
  6.         return jdbcTemplate;  
  7.     }  
  8.   
  9.                 //注入方法1     
  10.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
  11.         this.jdbcTemplate = jdbcTemplate;  
  12.     }  
  13.   
  14.                //其它方法这里省略……  
  15. }  

 spring配置文件为：

Xml代码  收藏代码
  1. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  2.         <property name = "dataSource" ref="dataSource">  
  3. </bean>  
  4. <bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">  
  5.      <property name="jdbcTemplate" ref="jdbcTemplate"/>  
  6. </bean>  

 

   方法2、

Java代码  收藏代码
  1. public class UserServiceImpl implements UserService {  
  2.   
  3.         private JdbcTemplate jdbcTemplate;  
  4.           
  5.         //注入方法2  
  6.         public void setDataSource(DataSource dataSource) {  
  7.                    this.jdbcTemplate = new JdbcTemplate(dataSource);  
  8.         }  
  9.        
  10.        //其它方法省略……  
  11. }  

  

 spring配置文件为：

Xml代码  收藏代码
  1. <bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">  
  2.        <property name="dataSource" ref="dataSource"/>  
  3. </bean>  

 

方法3：继承JdbcDaoSupport，其内部有个JdbcTemplate ，需要注入DataSource 属性来实例化。

Java代码  收藏代码
  1. public class UserDaoImpl extends JdbcDaoSupport implements UserDao {  
  2.   
  3.     @Override  
  4.     public void save(User user) {  
  5.         String sql = null;  
  6.         this.getJdbcTemplate().update(sql);  
  7.     }  
  8.         //其它方法省略……  
  9. }  

 

spring配置文件：

 

Xml代码  收藏代码
  1. <bean id="userDao" class="com.hxzy.account.jdbcTemplate.UserDaoImpl">  
  2.            <property name="dataSource" ref="dataSource"/>  
  3. </bean>  

 

 

二、常用方法使用

【注意：】jdbcTemplate 中的sql均是用“?”做占位符的

domain User：

Java代码  收藏代码
  1. public class User {  
  2.     private int id;  
  3.     private String username;  
  4.     private String password;  
  5.     private String sex;  
  6.               
  7.                //setter和getter方法省略……  
  8. }  

   

 

UserServiceImpl ：

如果采用第三种方式，则下面的用法中将方法中的 jdbcTemplate 换成 this.getJdbcTemplate()即可。

 

Java代码  收藏代码
  1.      /**   
  2.      * 创建表  
  3.      */   
  4.     public void create(String tableName){ //tb_test1  
  5.         jdbcTemplate.execute("create table "+tableName +" (id integer,user_name varchar2(40),password varchar2(40))");  
  6.     }  
  7.       
  8.     //jdbcTemplate.update适合于insert 、update和delete操作；  
  9.     /**   
  10.      * 第一个参数为执行sql   
  11.      * 第二个参数为参数数据   
  12.      */   
  13.     public void save3(User user) {  
  14.         Assert.isNull(user, "user is not null");  
  15.         jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
  16.                 new Object[]{user.getUsername(),user.getPassword()});  
  17.     }  
  18.       
  19.     /**   
  20.      * 第一个参数为执行sql   
  21.      * 第二个参数为参数数据   
  22.      * 第三个参数为参数类型   
  23.      */   
  24.     @Override  
  25.     public void save(User user) {  
  26.         Assert.isNull(user, "user is not null");  
  27.         jdbcTemplate.update(  
  28.                 "insert into tb_test1(name,password) values(?,?)",   
  29.                 new Object[]{user.getUsername(),user.getPassword()},   
  30.                 new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR}  
  31.                 );  
  32.     }  
  33.   
  34.     //避免sql注入  
  35.     public void save2(final User user) {  
  36.         Assert.isNull(user, "user is not null");  
  37.           
  38.         jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
  39.                 new PreparedStatementSetter(){  
  40.               
  41.                     @Override  
  42.                     public void setValues(PreparedStatement ps) throws SQLException {  
  43.                         ps.setString(1, user.getUsername());  
  44.                         ps.setString(2, user.getPassword());  
  45.                     }  
  46.         });  
  47.           
  48.     }  
  49.       
  50.     public void save4(User user) {  
  51.         Assert.isNull(user, "user is not null");  
  52.         jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   
  53.                              new Object[]{user.getUsername(),user.getPassword()});  
  54.     }  
  55.       
  56.     //返回插入的主键  
  57.     public List save5(final User user) {  
  58.           
  59.         KeyHolder keyHolder = new GeneratedKeyHolder();  
  60.   
  61.         jdbcTemplate.update(new PreparedStatementCreator() {  
  62.                       
  63.                                 @Override  
  64.                                 public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {  
  65.                                     PreparedStatement ps = connection.prepareStatement("insert into tb_test1(name,password) values(?,?)", new String[] {"id"});  
  66.                                     ps.setString(1, user.getUsername());  
  67.                                     ps.setString(2, user.getPassword());  
  68.                                     return ps;  
  69.                                 }  
  70.                             },  
  71.                 keyHolder);  
  72.           
  73.         return keyHolder.getKeyList();  
  74.     }  
  75.       
  76.     @Override  
  77.     public void update(final User user) {  
  78.         jdbcTemplate.update(  
  79.                 "update tb_test1 set name=？,password=？ where id = ?",   
  80.                 new PreparedStatementSetter(){  
  81.                     @Override  
  82.                     public void setValues(PreparedStatement ps) throws SQLException {  
  83.                         ps.setString(1, user.getUsername());  
  84.                         ps.setString(2, user.getPassword());  
  85.                         ps.setInt(3, user.getId());  
  86.                     }  
  87.                 }  
  88.         );  
  89.     }  
  90.   
  91.     @Override  
  92.     public void delete(User user) {  
  93.         Assert.isNull(user, "user is not null");  
  94.         jdbcTemplate.update(  
  95.                 "delete from tb_test1 where id = ?",   
  96.                 new Object[]{user.getId()},   
  97.                 new int[]{java.sql.Types.INTEGER});  
  98.     }  
  99.   
  100.     @Deprecated //因为没有查询条件，所以用处不大  
  101.     public int queryForInt1(){  
  102.         return jdbcTemplate.queryForInt("select count(0) from tb_test1");  
  103.     }  
  104.       
  105.     public int queryForInt2(User user){  
  106.         return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  
  107.                 new Object[]{user.getUsername()});  
  108.     }  
  109.       
  110.     //最全的参数3个  
  111.     public int queryForInt3(User user){  
  112.         return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  
  113.                 new Object[]{user.getUsername()},  
  114.                 new int[]{java.sql.Types.VARCHAR});  
  115.     }  
  116.       
  117.     //可以返回是一个基本类型的值  
  118.     @Deprecated  //因为没有查询条件，所以用处不大  
  119.     public String queryForObject1(User user) {  
  120.         return (String) jdbcTemplate.queryForObject("select username from tb_test1 where id = 100",  
  121.                                                     String.class);  
  122.     }  
  123.       
  124.     //可以返回值是一个对象  
  125.     @Deprecated //因为没有查询条件，所以用处不大  
  126.     public User queryForObject2(User user) {  
  127.         return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100", User.class); //class是结果数据的java类型  
  128.     }  
  129.       
  130.     @Deprecated //因为没有查询条件，所以用处不大  
  131.     public User queryForObject3(User user) {  
  132.         return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100",   
  133.                     new RowMapper(){  
  134.       
  135.                         @Override  
  136.                         public Object mapRow(ResultSet rs, int rowNum)throws SQLException {  
  137.                             User user  = new User();  
  138.                             user.setId(rs.getInt("id"));  
  139.                             user.setUsername(rs.getString("username"));  
  140.                             user.setPassword(rs.getString("password"));  
  141.                             return user;  
  142.                         }  
  143.                     }  
  144.         );   
  145.     }  
  146.       
  147.     public User queryForObject4(User user) {  
  148.         return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",   
  149.                                                     new Object[]{user.getId()},  
  150.                                                     User.class); //class是结果数据的java类型  实际上这里是做反射，将查询的结果和User进行对应复制  
  151.     }  
  152.       
  153.     public User queryForObject5(User user) {  
  154.         return (User) jdbcTemplate.queryForObject(  
  155.                 "select * from tb_test1 where id = ?",   
  156.                 new Object[]{user.getId()},  
  157.                 new RowMapper(){  
  158.   
  159.                     @Override  
  160.                     public Object mapRow(ResultSet rs,int rowNum)throws SQLException {  
  161.                         User user  = new User();  
  162.                         user.setId(rs.getInt("id"));  
  163.                         user.setUsername(rs.getString("username"));  
  164.                         user.setPassword(rs.getString("password"));  
  165.                         return user;  
  166.                     }  
  167.               
  168.         }); //class是结果数据的java类型  
  169.     }  
  170.       
  171.     @Override  
  172.     public User queryForObject(User user) {  
  173.         //方法有返回值  
  174.         return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",  
  175.                 new Object[]{user.getId()},  
  176.                 new int[]{java.sql.Types.INTEGER},   
  177.                 new RowMapper() {  
  178.               
  179.                     @Override  
  180.                     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
  181.                         User user  = new User();  
  182.                         user.setId(rs.getInt("id"));  
  183.                         user.setUsername(rs.getString("username"));  
  184.                         user.setPassword(rs.getString("password"));  
  185.                         return user;  
  186.                     }  
  187.                 }  
  188.         );  
  189.     }  
  190.   
  191.     @SuppressWarnings("unchecked")  
  192.     public List<User> queryForList1(User user) {  
  193.         return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",   
  194.                             new Object[]{user.getUsername()},  
  195.                             User.class);  
  196.     }  
  197.   
  198.     @SuppressWarnings("unchecked")  
  199.     public List<String> queryForList2(User user) {  
  200.         return (List<String>) jdbcTemplate.queryForList("select username from tb_test1 where sex = ?",   
  201.                             new Object[]{user.getSex()},  
  202.                             String.class);  
  203.     }  
  204.       
  205.     @SuppressWarnings("unchecked")  
  206.     //最全的参数查询  
  207.     public List<User> queryForList3(User user) {  
  208.         return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",  
  209.                             new Object[]{user.getUsername()},  
  210.                             new int[]{java.sql.Types.VARCHAR},  
  211.                             User.class);  
  212.     }  
  213.   
  214.     //通过RowCallbackHandler对Select语句得到的每行记录进行解析，并为其创建一个User数据对象。实现了手动的OR映射。  
  215.     public User queryUserById4(String id){  
  216.         final User user  = new User();  
  217.           
  218.         //该方法返回值为void  
  219.         this.jdbcTemplate.query("select * from tb_test1 where id = ?",   
  220.                 new Object[] { id },   
  221.                 new RowCallbackHandler() {     
  222.               
  223.                     @Override    
  224.                     public void processRow(ResultSet rs) throws SQLException {     
  225.                         User user  = new User();  
  226.             user.setId(rs.getInt("id"));  
  227.             user.setUsername(rs.getString("username"));  
  228.             user.setPassword(rs.getString("password"));    
  229.                     }     
  230.         });   
  231.           
  232.         return user;     
  233.     }  
  234.       
  235.     @SuppressWarnings("unchecked")  
  236.     @Override  
  237.     public List<User> list(User user) {  
  238.         return jdbcTemplate.query("select * from tb_test1 where username like '%?%'",   
  239.                 new Object[]{user.getUsername()},   
  240.                 new int[]{java.sql.Types.VARCHAR},   
  241.                 new RowMapper(){  
  242.               
  243.                     @Override  
  244.                     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  
  245.                         User user  = new User();  
  246.                         user.setId(rs.getInt("id"));  
  247.                         user.setUsername(rs.getString("username"));  
  248.                         user.setPassword(rs.getString("password"));  
  249.                         return user;  
  250.                     }  
  251.         });  
  252.     }  
  253.   
  254.     //批量操作    适合于增、删、改操作  
  255.     public int[] batchUpdate(final List users) {  
  256.           
  257.         int[] updateCounts = jdbcTemplate.batchUpdate(  
  258.                 "update tb_test1 set username = ?, password = ? where id = ?",  
  259.                 new BatchPreparedStatementSetter() {  
  260.                       
  261.                         @Override  
  262.                         public void setValues(PreparedStatement ps, int i) throws SQLException {  
  263.                             ps.setString(1, ((User)users.get(i)).getUsername());  
  264.                             ps.setString(2, ((User)users.get(i)).getPassword());  
  265.                             ps.setLong(3, ((User)users.get(i)).getId());  
  266.                         }  
  267.                           
  268.                         @Override  
  269.                         public int getBatchSize() {  
  270.                             return users.size();  
  271.                         }  
  272.                 }   
  273.         );  
  274.           
  275.         return updateCounts;  
  276.     }  
  277.       
  278.     //调用存储过程  
  279.     public void callProcedure(int id){  
  280.         this.jdbcTemplate.update("call SUPPORT.REFRESH_USERS_SUMMARY(?)", new Object[]{Long.valueOf(id)});  
  281. }  

 

其中，batchUpdate适合于批量增、删、改操作；

         update(…)：使用于增、删、改操作；

         execute（）：执行一个独立的sql语句，包括ddl语句；

         queryForInt ：查询出一个整数值

 

 

摘自：http://lehsyh.iteye.com/blog/1579737

分享到：
| 微软雅黑在ＩＥ中显示为宋体
评论
4 楼 zzz2726 2018-01-27  
147-150行：执行出错了
引用

public User queryForObject4(User user) { 
        return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",  
                                                    new Object[]{user.getId()}, 
                                                    User.class);

-------------------------------------------------------------------
Exception in thread "main" org.springframework.jdbc.IncorrectResultSetColumnCountException: Incorrect column count: expected 1, actual 5
3 楼 wendingg 2016-10-25  
2 楼 niu870781892 2016-09-20  
/**  
     * 第一个参数为执行sql  
     * 第二个参数为参数数据  
     */  
    public void save3(User user) { 
        Assert.isNull(user, "user is not null"); 
        jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",  
                new Object[]{user.getUsername(),user.getPassword()}); 
    } 

这样情况下使用，没有带参数类型，和带参数类型有什么区别？
1 楼 tuanz 2016-02-23  
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring-jdbcTemplate实例工程

    在这个实例工程中，我们将深入探讨Spring JdbcTemplate的基本使用、优势以及常见操作。 一、Spring JdbcTemplate简介 Spring JdbcTemplate的出现是为了弥补原生JDBC在编码上的繁琐，它通过模板方法模式，将SQL执行...

    spring jdbctemplate实例

    在本实例中，我们将探讨如何使用Spring JdbcTemplate进行基本的CRUD（创建、读取、更新、删除）操作。 首先，我们需要在Spring配置文件中定义JdbcTemplate bean。这通常通过DataSource（数据源）来完成，例如： ``...

    Spring JdbcTemplate查询实例

    使用JdbcTemplate查询数据，你需要创建一个`JdbcTemplate`实例，通常通过依赖注入的方式从Spring容器中获取。例如： ```java @Autowired private JdbcTemplate jdbcTemplate; ``` 然后，你可以使用`...

    spring的jdbcTemplate小案例

    这通常在Spring配置文件中完成，通过`@Bean`注解创建一个JdbcTemplate实例，并将DataSource注入其中。 ```xml &lt;!-- 配置数据库连接参数 --&gt; &lt;bean id="jdbcTemplate" class="org.springframework.jdbc.core....

    Spring JdbcTemplate 常用方法整理

    本文将深入探讨Spring JdbcTemplate的常用方法，并结合提供的`JsonBean.java`和`JdbcUtils.java`文件，来理解其在实际应用中的使用。 首先，JdbcTemplate的核心功能在于它提供了一系列的方法来执行SQL语句，包括...

    Spring 学习 JdbcTemplate，模板模式，回调

    在这个例子中，我们注入了JdbcTemplate实例，并使用query方法执行SQL查询。传入的RowCallbackHandler将在遍历结果集时被调用，处理每一行数据。 **5. 总结** Spring JdbcTemplate简化了数据库操作，通过模板模式...

    SpringJdbcTemplate封装工具类

    SpringJdbcTemplate是一个模板类，它提供了大量的方法来执行SQL查询、更新、存储过程等操作。这些方法会自动处理JDBC相关的资源关闭、异常转换等细节，使得代码更加整洁和健壮。 2. **数据库自适应** Spring...

    strut2+spring+springjdbctemplate做的简易登录系统

    Spring JDBC Template被用来简化数据库操作，它提供了一种模板方法模式，将SQL执行、结果集处理等细节进行了封装，使得开发者只需要关注SQL语句和处理结果即可。例如，登录验证可能涉及查询用户表，查找与输入用户名...

    一个简单的spring-jdbctemplate扩展

    Spring的JdbcTemplate是Spring框架中的一个核心组件，用于简化数据库操作。它提供了一种模板方法模式，抽象出常见的JDBC代码，使得开发者可以避免编写大量的重复性代码，从而更加专注于业务逻辑。本项目是对Spring ...

    Spring-JdbcTemplate

    `Spring-JdbcTemplate` 是 Spring 框架中的一个核心模块，主要用于简化数据库操作，提供了强大的数据访问功能。它通过模板方法设计模式封装了 SQL 的执行，使得开发者无需直接与 JDBC API 打交道，从而降低了数据库...

    spring的jdbctemplate的crud的基类dao

    在Spring框架中，`JdbcTemplate` 是一个非常重要的组件，它提供了一种简化数据库操作的API，使得开发者能够更安全、高效地与数据库交互。在本文中，我们讨论了如何利用`JdbcTemplate`来实现一个基类DAO（Data Access...

    Spring：JdbcTemplate使用指南

    Spring框架中的JdbcTemplate是数据库操作的核心组件之一，它提供了一种简单、安全的方式来执行SQL查询和更新，而无需手动管理数据库连接。本指南将深入探讨JdbcTemplate的用法，帮助开发者更好地理解和应用这个强大...

    Spring JdbcTemplate例子

    使用Spring JdbcTemplate的第一步是创建一个JdbcTemplate实例。这通常通过Spring的IoC容器（依赖注入）完成，将DataSource配置到JdbcTemplate中。例如： ```java @Autowired private DataSource dataSource; @Bean...

    Spring JdbcTemplate

    **Spring JdbcTemplate**是Spring框架中的一个核心组件，主要用于简化Java数据库访问。它提供了一种模板化的方式来执行SQL语句，使得开发人员可以避免编写大量的重复代码，专注于业务逻辑，而不是底层的数据库交互...

    Spring JDBCTemplate连接池jar包

    总之，Spring JDBCTemplate结合连接池提供了一个高效且易于使用的数据库访问层，它降低了数据库操作的复杂性，同时也提升了系统的性能。正确配置和使用这些库，可以极大地优化我们的数据库应用程序。

    Spring JdbcTemplate api

    在Spring框架中，可以为每个DAO配置单独的`JdbcTemplate`实例，或者让DAO类继承`JdbcDaoSupport`类，这样可以通过调用`getJdbcTemplate()`方法来获取`JdbcTemplate`实例。书中提到的做法是为每个DAO添加一个`...

    Spring--JdbcTemplate.pdf

    描述中提到的"一图详解(脑图)"意味着文档中可能包含了一个清晰的图示，这个图示将详细展示JdbcTemplate在Spring中的使用过程和相关组件的交互。这样的图示对于理解JdbcTemplate的工作原理以及如何在项目中实际应用它...

    spring mvc注解jdbctemplate

    首先，要使用JdbcTemplate，我们需要在Spring配置文件中声明一个JdbcTemplate bean。以下是一个简单的配置示例： ```xml &lt;bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"&gt; ...

    Spring的getBean和JdbcTemplate

    在上述代码中，`@Autowired`注解使得Spring自动将`ApplicationContext`注入到服务方法中，然后我们可以通过`getBean`获取到`JdbcTemplate`实例，执行数据库查询。 总结来说，Spring的`getBean`方法是DI机制的关键，...

    Spring的JDBCTemplate

    为了能够在项目中使用`JDBCTemplate`，首先需要在Spring的配置文件`ApplicationContext`中定义一个`jdbcTemplate` bean，例如： ```xml &lt;bean id="jdbcTemplate" class="org.springframework.jdbc.core....

Magicbox
Global site tag (gtag.js) - Google Analytics