`
lzkyo
  • 浏览: 468128 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

spring jdbcTemplate使用

SpringSQLBeanAOPDAO 
阅读更多

(1)springJdbcContext.xml

Java代码 复制代码
  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"    
  4.     xmlns:context="http://www.springframework.org/schema/context"    
  5.     xmlns:aop="http://www.springframework.org/schema/aop"    
  6.     xmlns:tx="http://www.springframework.org/schema/tx"    
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd    
  8.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd    
  9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd    
  10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">   
  11.   
  12.     <description>springApp</description>       
  13.     <!-- dataSource for MySQL -->   
  14.     <bean id="dataSource"  
  15.         class="org.apache.commons.dbcp.BasicDataSource"  
  16.         destroy-method="close">   
  17.         <property name="driverClassName"  
  18.             value="com.mysql.jdbc.Driver" />   
  19.         <property name="url"  
  20.             value="jdbc:mysql://localhost:3306/springapp" />   
  21.         <property name="username" value="root" />   
  22.         <property name="password" value="****" />   
  23.     </bean>      
  24.   
  25.     <bean id = "TransactionManager"    
  26.          class = "org.springframework.jdbc.datasource.DataSourceTransactionManager">    
  27.          <property name = "dataSource" ref="dataSource"/>    
  28.     </bean>   
  29.        
  30.     <!--1:配置一个JdbcTemplate实例，并将这个“共享的”，“安全的”实例注入到不同的DAO类中去-->   
  31.     <bean id = "jdbcTemplate"    
  32.          class = "org.springframework.jdbc.core.JdbcTemplate">    
  33.          <property name = "dataSource" ref="dataSource"/>    
  34.     </bean>   
  35.   
  36.     <bean id = "actorJdbcTemplateDao"    
  37.          class = "com.logcd.bo.dao.impl.ActorJdbcTemplateDaoImpl">    
  38.          <property name="jdbcTemplate" ref="jdbcTemplate"/>    
  39.     </bean>   
  40.        
  41.     <!--2:将共享的DataSource实例注入到DAO中，JdbcTemplate实例在DataSource的setter方法中被创建-->   
  42.     <bean id = "actorEventDao"    
  43.          class = "com.logcd.bo.dao.impl.ActorEventDaoImpl">    
  44.          <property name = "dataSource" ref="dataSource"/>    
  45.     </bean>   
  46.   
  47.     <!--利用了拦截器的原理。-->      
  48.    <bean id="transactionInterceptor"     
  49.          class="org.springframework.transaction.interceptor.TransactionInterceptor">      
  50.         <property name="transactionManager">       
  51.                   <ref bean="transactionManager" />      
  52.         </property>      
  53.     <!-- 配置事务属性 -->   
  54.    <property name="transactionAttributes">      
  55.         <props>      
  56.             <prop key="delete*">PROPAGATION_REQUIRED</prop>   
  57.             <prop key="operate*">PROPAGATION_REQUIRED,-Exception</prop>      
  58.             <prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>      
  59.             <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>      
  60.             <prop key="save*">PROPAGATION_REQUIRED</prop>      
  61.             <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>      
  62.        </props>      
  63.    </property>      
  64.    </bean>      
  65.    <bean id="txProxy"     
  66.          class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">      
  67.         <property name="beanNames">      
  68.           <list>      
  69.              <value>*Dao*</value><!--只是为了测试，一般为service-->   
  70.           </list>      
  71.         </property>      
  72.         <property name="interceptorNames">      
  73.           <list>      
  74.              <value>transactionInterceptor</value>      
  75.           </list>      
  76.         </property>      
  77.    </bean>     
  78.   
  79. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

	<description>springApp</description>	
	<!-- dataSource for MySQL -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver" />
		<property name="url"
			value="jdbc:mysql://localhost:3306/springapp" />
		<property name="username" value="root" />
		<property name="password" value="****" />
	</bean>	

	<bean id = "TransactionManager" 
         class = "org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
         <property name = "dataSource" ref="dataSource"/> 
    </bean>
    
    <!--1:配置一个JdbcTemplate实例，并将这个“共享的”，“安全的”实例注入到不同的DAO类中去-->
    <bean id = "jdbcTemplate" 
         class = "org.springframework.jdbc.core.JdbcTemplate"> 
         <property name = "dataSource" ref="dataSource"/> 
    </bean>

    <bean id = "actorJdbcTemplateDao" 
         class = "com.logcd.bo.dao.impl.ActorJdbcTemplateDaoImpl"> 
         <property name="jdbcTemplate" ref="jdbcTemplate"/> 
    </bean>
    
    <!--2:将共享的DataSource实例注入到DAO中，JdbcTemplate实例在DataSource的setter方法中被创建-->
    <bean id = "actorEventDao" 
         class = "com.logcd.bo.dao.impl.ActorEventDaoImpl"> 
         <property name = "dataSource" ref="dataSource"/> 
    </bean>

    <!--利用了拦截器的原理。-->   
   <bean id="transactionInterceptor"  
         class="org.springframework.transaction.interceptor.TransactionInterceptor">   
        <property name="transactionManager">    
                  <ref bean="transactionManager" />   
        </property>   
    <!-- 配置事务属性 -->
   <property name="transactionAttributes">   
        <props>   
            <prop key="delete*">PROPAGATION_REQUIRED</prop>
            <prop key="operate*">PROPAGATION_REQUIRED,-Exception</prop>   
            <prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>   
            <prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>   
            <prop key="save*">PROPAGATION_REQUIRED</prop>   
            <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>   
       </props>   
   </property>   
   </bean>   
   <bean id="txProxy"  
         class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
        <property name="beanNames">   
          <list>   
             <value>*Dao*</value><!--只是为了测试，一般为service-->
          </list>   
        </property>   
        <property name="interceptorNames">   
          <list>   
             <value>transactionInterceptor</value>   
          </list>   
        </property>   
   </bean>  

</beans>


(2)接口：(以第二种方式定义DAO)

Java代码 复制代码
  1. package com.logcd.bo.dao;   
  2.   
  3. import java.util.List;   
  4.   
  5. import org.springframework.jdbc.support.KeyHolder;   
  6.   
  7. import com.logcd.bo.Actor;   
  8.   
  9. public interface ActorEventDao {   
  10.     /**  
  11.      * 根据SQL建表  
  12.      * @param sql  
  13.      */  
  14.     public void createTableBySQL(String sql);   
  15.   
  16.     /**  
  17.      * 统计firstName相同的总数  
  18.      * @param firstName  
  19.      * @return  
  20.      */  
  21.     public int findCountOfActorsByFirstName(String firstName);   
  22.   
  23.     /**  
  24.      * 插入记录并返回自动生成的主键Id  
  25.      * @param ps  
  26.      * @return  
  27.      */  
  28.     public KeyHolder insertActor(final Actor actor);   
  29.   
  30.     /**  
  31.      * 用SimpleJdbcInsert插入一条记录:mysql测试成功  
  32.      */  
  33.     public long inserOneActor(Actor actor);   
  34.        
  35.     /**  
  36.      * 插入/更新/删除数据  
  37.      * @param sql 有参数语句  
  38.      * @param obj 参数值数组  
  39.      */  
  40.     public int operateActor(String sql,Object[] obj);   
  41.   
  42.     /**  
  43.      * 根据SQL查询记录总数  
  44.      * @param sql  
  45.      * @return  
  46.      */  
  47.     public int findRowCountBySQL(String sql);   
  48.   
  49.     /**  
  50.      * 根据Id查找指定对象  
  51.      * @param id  
  52.      * @return  
  53.      */  
  54.     public Actor findActorById(long id);   
  55.   
  56.     /**  
  57.      * 根据Id查找指定对象  
  58.      * @param id  
  59.      * @return  
  60.      */  
  61.     public Actor findActorByIdSimple(long id);   
  62.   
  63.     /**  
  64.      * 返回所有对象  
  65.      * @return  
  66.      */  
  67.     public List findAllActors();   
  68.   
  69.             /**  
  70.      * 批量更新  
  71.      * @param actors  
  72.      * @return  
  73.      */  
  74.     public int[] updateBatchActors(final List actors);   
  75.   
  76.     /**  
  77.      * 批量更新  
  78.      * @param actors  
  79.      * @return  
  80.      */  
  81.     public int[] updateBatchActorsSimple(final List<Actor> actors);   
  82.   
  83. }  
package com.logcd.bo.dao;

import java.util.List;

import org.springframework.jdbc.support.KeyHolder;

import com.logcd.bo.Actor;

public interface ActorEventDao {
	/**
	 * 根据SQL建表
	 * @param sql
	 */
	public void createTableBySQL(String sql);

	/**
	 * 统计firstName相同的总数
	 * @param firstName
	 * @return
	 */
	public int findCountOfActorsByFirstName(String firstName);

	/**
	 * 插入记录并返回自动生成的主键Id
	 * @param ps
	 * @return
	 */
	public KeyHolder insertActor(final Actor actor);

	/**
	 * 用SimpleJdbcInsert插入一条记录:mysql测试成功
	 */
	public long inserOneActor(Actor actor);
	
	/**
	 * 插入/更新/删除数据
	 * @param sql 有参数语句
	 * @param obj 参数值数组
	 */
	public int operateActor(String sql,Object[] obj);

	/**
	 * 根据SQL查询记录总数
	 * @param sql
	 * @return
	 */
	public int findRowCountBySQL(String sql);

	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorById(long id);

	/**
	 * 根据Id查找指定对象
	 * @param id
	 * @return
	 */
	public Actor findActorByIdSimple(long id);

	/**
	 * 返回所有对象
	 * @return
	 */
	public List findAllActors();

         	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActors(final List actors);

	/**
	 * 批量更新
	 * @param actors
	 * @return
	 */
	public int[] updateBatchActorsSimple(final List<Actor> actors);

}


(3)接口实现

Java代码 复制代码
  1. package com.logcd.bo.dao.impl;   
  2.   
  3. import java.sql.Connection;   
  4. import java.sql.PreparedStatement;   
  5. import java.sql.ResultSet;   
  6. import java.sql.SQLException;   
  7. import java.util.List;   
  8.   
  9. import javax.sql.DataSource;   
  10.   
  11. import org.springframework.jdbc.core.JdbcTemplate;   
  12. import org.springframework.jdbc.core.PreparedStatementCreator;   
  13. import org.springframework.jdbc.core.RowMapper;   
  14. import org.springframework.jdbc.support.GeneratedKeyHolder;   
  15. import org.springframework.jdbc.support.KeyHolder;   
  16.   
  17. import com.logcd.bo.Actor;   
  18. import com.logcd.bo.dao.ActorEventDao;   
  19.   
  20. public class ActorEventDaoImpl implements ActorEventDao{   
  21.        
  22.     private JdbcTemplate jdbcTemplate;   
  23.        
  24.     //NamedParameterJdbcTemplate对JdbcTemplate封装，增加了命名参数特性   
  25.     private NamedParameterJdbcTemplate namedParameterJdbcTemplate;   
  26.   
  27.     //SimpleJdbcTemplate对JdbcTemplate封装,某些特性要在java5以上才工作   
  28.     private SimpleJdbcTemplate simpleJdbcTemplate;   
  29.        
  30.     //简化插入数据操作   
  31.     private SimpleJdbcInsert inserActor;   
  32.        
  33.     public void setDataSource(DataSource dataSource){   
  34.         this.jdbcTemplate = new JdbcTemplate(dataSource);   
  35.         this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);   
  36.         this.simpleJdbcTemplate = new SimpleJdbcTemplate(dataSource);   
  37.         this.inserActor = new SimpleJdbcInsert(dataSource)   
  38.         .withTableName("actors")   
  39.         .usingColumns("first_name","last_name")//插入这些字段   
  40.         .usingGeneratedKeyColumns("id");//带回生成的id   
  41.     }   
  42.   
  43.     /**  
  44.      * 用SimpleJdbcInsert插入一条记录  
  45.      */  
  46.     public long inserOneActor(Actor actor){   
  47.         Map<String,Object> parameters = new HashMap<String,Object>();   
  48.         parameters.put("first_name",actor.getFirstName());   
  49.         parameters.put("last_name",actor.getLastName());   
  50.         return inserActor.executeAndReturnKey(parameters).longValue();   
  51.     }   
  52.        
  53.     /**  
  54.      * 统计firstName相同的总数  
  55.      * @param firstName  
  56.      * @return  
  57.      */  
  58.     public int findCountOfActorsByFirstName(String firstName){   
  59.         String sql="select count(0) from actors where first_name = :first_name";   
  60.         SqlParameterSource namedParameters = new MapSqlParameterSource("first_name",firstName);   
  61.         //Map namedParameter = Collections.singletonMap("first_name",firstName);   
  62.         //还有一种Bean封装的方式   
  63.         //SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);   
  64.         return this.namedParameterJdbcTemplate.queryForInt(sql, namedParameters);   
  65.     }   
  66.   
  67.     /**  
  68.      * 根据SQL建表  
  69.      * @param sql  
  70.      */  
  71.     public void createTableBySQL(String sql) {   
  72.         this.jdbcTemplate.execute(sql);   
  73.     }   
  74.        
  75.     /**  
  76.      * 插入记录并返回自动生成的主键Id(MySQL中不行，Oracle可以)  
  77.      * @param ps  
  78.      * @return  
  79.      */  
  80.     public KeyHolder insertActor(final Actor actor){   
  81.         final String addSql = "insert into actors(first_name,last_name) values (?,?)";   
  82.         KeyHolder keyHolder = new GeneratedKeyHolder();   
  83.         this.jdbcTemplate.update(new PreparedStatementCreator(){   
  84.             public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {   
  85.                 PreparedStatement ps =   
  86.                     conn.prepareStatement(addSql, new String[]{"id"});//返回id   
  87.                 ps.setString(1, actor.getFirstName());   
  88.                 ps.setString(2, actor.getLastName());   
  89.                 return ps;   
  90.             }   
  91.                
  92.         });   
  93.         System.out.println(keyHolder.getKey());   
  94.         return keyHolder;   
  95.     }   
  96.        
  97.     /**  
  98.      * 插入/更新/删除数据  
  99.      * @param sql 有参数语句  
  100.      * @param obj 参数值数组  
  101.      */  
  102.     public int operateActor(String sql,Object[] obj){   
  103.         return this.jdbcTemplate.update(sql, obj);   
  104.     }   
  105.   
  106.     /**  
  107.      * 根据SQL查询记录总数  
  108.      * @param sql  
  109.      * @return  
  110.      */  
  111.     public int findRowCountBySQL(String sql){   
  112.         return this.jdbcTemplate.queryForInt(sql);   
  113.     }   
  114.        
  115.     /**  
  116.      * 根据Id查找指定对象  
  117.      * @param id  
  118.      * @return  
  119.      */  
  120.     public Actor findActorById(long id){   
  121.         Actor actor = (Actor) this.jdbcTemplate.queryForObject(   
  122.                 "select id,first_name,last_name from actors where id = ?",   
  123.                 new Object[]{new Long(id)},    
  124.                 new RowMapper(){   
  125.   
  126.                     public Object mapRow(ResultSet rs, int rowNum) throws SQLException {   
  127.                         Actor act = new Actor();   
  128.                         act.setId(rs.getLong("id"));   
  129.                         act.setFirstName(rs.getString("first_name"));   
  130.                         act.setLastName(rs.getString("last_Name"));   
  131.                         return act;   
  132.                     }   
  133.                        
  134.                 });   
  135.         return actor;   
  136.     }   
  137.   
  138.   
  139.     /**  
  140.      * 根据Id查找指定对象  
  141.      * @param id  
  142.      * @return  
  143.      */  
  144.     public Actor findActorByIdSimple(long id){   
  145.         String sql = "select id,first_name,last_name from actors where id = ?";   
  146.            
  147.         ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper<Actor>(){   
  148.             //notice the return type with respect to java 5 covariant return types   
  149.             public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {   
  150.                 Actor act = new Actor();   
  151.                 act.setId(rs.getLong("id"));   
  152.                 act.setFirstName(rs.getString("first_name"));   
  153.                 act.setLastName(rs.getString("last_Name"));   
  154.                 return act;   
  155.             }   
  156.         };   
  157.            
  158.         return this.simpleJdbcTemplate.queryForObject(sql, mapper, id);   
  159.     }   
  160.        
  161.     /**  
  162.      * 返回所有对象  
  163.      * @return  
  164.      */  
  165.     public List findAllActors(){   
  166.         return this.jdbcTemplate.query(   
  167.                 "select id,first_name,last_name from actors",   
  168.                 new ActorMapper());   
  169.     }   
  170.        
  171.     /**  
  172.      * 定义一个静态内部类，在Dao的方法中被共享  
  173.      * @author logcd  
  174.      */  
  175.     private static final class ActorMapper implements RowMapper{   
  176.   
  177.         public Object mapRow(ResultSet rs, int rowNum) throws SQLException {   
  178.             Actor act = new Actor();   
  179.             act.setId(rs.getLong("id"));   
  180.             act.setFirstName(rs.getString("first_name"));   
  181.             act.setLastName(rs.getString("last_Name"));   
  182.             return act;   
  183.         }   
  184.            
  185.     }   
  186. }   
  187.   
  188.     /**  
  189.      * 批量更新  
  190.      * @param actors  
  191.      * @return  
  192.      */  
  193.     public int[] updateBatchActors(final List actors){   
  194.         int[] updateCounts =this.jdbcTemplate.batchUpdate(   
  195.                 "update actors set first_name = ?, last_name = ? where id =? ",    
  196.                 new BatchPreparedStatementSetter(){   
  197.   
  198.                     public int getBatchSize() {   
  199.                         return actors.size();   
  200.                     }   
  201.   
  202.                     public void setValues(PreparedStatement ps, int i) throws SQLException {   
  203.                         ps.setString(1, ((Actor)actors.get(i)).getFirstName());   
  204.                         ps.setString(2, ((Actor)actors.get(i)).getLastName());   
  205.                         ps.setLong(3, ((Actor)actors.get(i)).getId());   
  206.                     }   
  207.                        
  208.                 });   
  209.         return updateCounts;   
  210.     }   
  211.   
  212.     /**  
  213.      * 批量更新  
  214.      * @param actors  
  215.      * @return  
  216.      */  
  217.     public int[] updateBatchActorsSimple(final List<Actor> actors){   
  218.         //如果对象数组与占位符出现位置一一对应   
  219.         //SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(actors.toArray());   
  220.         List<Object[]> batch = new ArrayList<Object[]>();   
  221.         for(Actor actor:actors){   
  222.             Object[] values = new Object[]{//注意顺序   
  223.                     actor.getFirstName(),   
  224.                     actor.getLastName(),   
  225.                     actor.getId()};   
  226.             batch.add(values);   
  227.         }   
  228.         int[] updateCounts = this.simpleJdbcTemplate.batchUpdate(   
  229.                 "update actors set first_name = ?, last_name = ? where id =? ",   
  230.                 batch);   
  231.         return updateCounts;   
  232.     }  
package com.logcd.bo.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

import com.logcd.bo.Actor;
import com.logcd.bo.dao.ActorEventDao;

public class ActorEventDaoImpl implements ActorEventDao{
	
	private JdbcTemplate jdbcTemplate;
	
	//NamedParameterJdbcTemplate对JdbcTemplate封装，增加了命名参数特性
	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

	//SimpleJdbcTemplate对JdbcTemplate封装,某些特性要在java5以上才工作
	private SimpleJdbcTemplate simpleJdbcTemplate;
	
	//简化插入数据操作
	private SimpleJdbcInsert inserActor;
	
	public void setDataSource(DataSource dataSource){
		this.jdbcTemplate = new JdbcTemplate(dataSource);
		this.namedParameterJdbcTemplate = new Name

  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      使用links方式安装Eclipse插件 
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

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

相关推荐

    基于注解的Spring JdbcTemplate

    本教程将深入探讨如何使用基于注解的Spring JdbcTemplate进行数据库操作，特别适合初学者入门学习。 ### 1. Spring JdbcTemplate简介 Spring JdbcTemplate提供了一个面向对象的接口，用于执行SQL查询、更新和存储...

    spring-jdbcTemplate实例工程

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

    SpringJdbcTemplate封装工具类

    SpringJdbcTemplate能够自适应多种数据库，这是因为它的底层使用了JDBC的规范，而不同的数据库厂商都实现了JDBC API。这使得你可以使用相同的代码来连接MySQL、Oracle、PostgreSQL等不同类型的数据库，只需更换相应...

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

    Struts2、Spring和Spring JDBC Template是Java Web开发中常用的三个框架，它们分别负责不同的职责。Struts2作为MVC（Model-View-Controller）框架，主要处理前端请求和业务逻辑；Spring则是一个全面的后端框架，提供...

    Spring JdbcTemplate 常用方法整理

    `JdbcUtils.java`可能是提供了一些数据库连接和JdbcTemplate使用的辅助方法，如数据库连接池的配置，或者封装了JdbcTemplate的执行方法，以提高代码复用性。例如： ```java public class JdbcUtils { private ...

    Spring JdbcTemplate

    这样，整个应用就可以通过Spring的依赖注入机制来获取并使用JdbcTemplate实例。 例如，一个简单的`applicationContext.xml`配置片段可能如下： ```xml &lt;bean id="dataSource" class="org.springframework.jdbc....

    Spring JDBCTemplate连接池jar包

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

    Spring JdbcTemplate调用Oracle存储过程实现CRUD

    使用 Spring JdbcTemplate 调用 Oracle 存储过程实现 CRUD 在本文中，我们将讨论如何使用 Spring JdbcTemplate 调用 Oracle 存储过程来实现 CRUD（Create、Read、Update、Delete）操作。我们将首先编写 Oracle 存储...

    Druid数据库连接池的SpringJDBCTemplate所需的jar包

    Druid数据库连接池的SpringJDBCTemplate所需的jar包，Druid数据库连接池的SpringJDBCTemplate所需的jar包，Druid数据库连接池的SpringJDBCTemplate所需的jar包，Druid数据库连接池的SpringJDBCTemplate所需的jar包，...

    使用Spring JDBCTemplate进行增删改查curd操作

    JdbcTemplate使用PreparedStatement来执行SQL，自动防止SQL注入攻击，因为它会正确地转义参数值。 7. 错误处理 如果数据库操作失败，JdbcTemplate会抛出异常，如`DataAccessException`，使得我们可以快速定位并处理...

    Spring：JdbcTemplate使用指南

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

    使用Spring的JdbcTemplate实现分页功能

    使用Spring的JdbcTemplate实现分页功能

    Spring JdbcTemplate查询实例

    Spring JdbcTemplate是Spring框架中用于简化数据库操作的一个重要组件，它是Spring对JDBC的轻量级封装，旨在提供一种结构良好、易于使用的SQL执行机制，同时保持了JDBC的灵活性。在本实例中，我们将深入探讨Spring ...

    Spring JdbcTemplate例子

    在本例中，我们将深入探讨Spring JdbcTemplate的工作原理、使用方式以及它的优点。 首先，JdbcTemplate的核心理念是通过预编译的SQL语句和参数绑定来防止SQL注入攻击，同时提供事务管理的支持。它提供了大量方法来...

    模仿spring jdbcTemplate的实现

    模仿spring jdbcTemplate的粗略实现，只有很小的参考价值，如果是java初学者可以使用这个封装好的工具进行数据库操作，只需要在db.properties里配置好driver,url等信息

    spring JdbcTemplate query方法使用示例

    spring JdbcTemplate query方法使用示例，欢迎下载借鉴

    Spring JdbcTemplate api

    在Spring框架中，`JdbcTemplate`是一个用于简化JDBC编程的工具类，它采用了模板模式来分离数据库访问中的不变和可变部分，提供了一种更加健壮且易于使用的数据访问机制。`JdbcTemplate`负责处理资源的获取、关闭以及...

    Spring JdbcTemplate.batchUpdate 例子

    在Spring框架中，`JdbcTemplate`是用于简化Java数据库连接（JDBC）操作的一个核心组件。这个类提供了很多方法来执行SQL查询、更新语句，包括批处理操作。本篇文章将详细探讨`batchUpdate`方法及其在实际开发中的应用...

    使用Spring的JdbcTemplate调用Oracle的存储过程

    使用Spring的JdbcTemplate调用Oracle的存储过程

    配制Spring事务和JdbcTemplate使用

    配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用

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