spring与jdbc的结合使用

利用spring可以解决事务处理时的许多问题，同spring实现其他的功能相似，spring提供了两种不同的方式实现与jdbc的结合，两种方式是注解和xml配置方式。

1.   spring和jdbc的结合

1）       建立PersonService接口：

public interface PersonService {
    /**
     * 保存Person对象
     *
     * @param person
     */
    public void save(Person person);
 
    /**
     * 得到person对象
     *
     * @param personId
     */
    public Person getPerson(Integer personId);
    /**
     * 得到所有的Person
     * @return
     */
    public List<Person> getPersons();
 
    /**
     * 更新person
     *
     * @param person
     */
    public void update(Person person);
 
    /**
     * 删除person
     */
    public void delete(Integer id);
 
}

2）       编写接口的实现类，并且将该bean纳入到spring的事务管理中（通过注解方式）：

@Transactional
public class PersonServiceBean implements PersonService {
    private JdbcTemplate jdbcTemplate;
 
    public void setDataSource(DataSource dataSource) {
       this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
 
    @Override
    public void delete(Integer id) {
       jdbcTemplate.update("delete fromperson where id=?", new Object[] { id },
              new int[] { java.sql.Types.INTEGER });
       jdbcTemplate.update("delete frompersonsss where id=2", new Object[] { id },
              new int[] { java.sql.Types.INTEGER });
    }
 
    @Override
    public Person getPerson(Integer personId) {
 
       return (Person) jdbcTemplate.queryForObject(
              "select *from person where id=?", new Object[] {personId },
              new PersonRowMapper());
    }
 
    @Transactional(propagation =Propagation.NOT_SUPPORTED)
    @Override
    public List<Person> getPersons() {
 
       return (List<Person>) jdbcTemplate.query("select * from person",
              new PersonRowMapper());
    }
 
    @Override
    public void save(Person person) {
 
       jdbcTemplate.update("insert intoperson(name) values(?)",
              new Object[] { person.getName() },
              new int[] { java.sql.Types.VARCHAR });
    }
 
    @Override
    public void update(Person person) {
       jdbcTemplate.update("updateperson set name=? where id=?",
              new Object[] { person.getName(), person.getId() }, new int[] {
                     java.sql.Types.VARCHAR, java.sql.Types.INTEGER });
 
    }
 
}

3）       注意在bean.xml中的配置：

<?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/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
 
    <context:property-placeholder location="classpath:jdbc.properties" />
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
       destroy-method="close">
       <property name="driverClassName"value="${driverClassName}" />
       <property name="url"value="${url}" />
       <property name="username"value="${username}" />
       <property name="password"value="${password}" />
       <!-- 连接池启动时的初始值 -->
       <property name="initialSize"value="${initialSize}" />
       <!-- 连接池的最大值 -->
       <property name="maxActive"value="${maxActive}" />
       <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
       <property name="maxIdle"value="${maxIdle}" />
       <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
       <property name="minIdle"value="${minIdle}" />
    </bean>
 
    <bean id="txManager"
       class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource"ref="dataSource" />
    </bean>
 
   
    <tx:annotation-driven transaction-manager="txManager"/>
 
    <bean id="personService" class="com.lcq.service.impl.PersonServiceBean">
       <property name="dataSource"ref="dataSource" />
    </bean>
</beans>

4）       编写测试类：

public class PersonServiceTest {
 
    private static PersonService personService;
 
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
 
       try {
           ApplicationContext cxt = new ClassPathXmlApplicationContext(
                  "beans.xml");
           personService = (PersonService) cxt.getBean("personService");
       } catch (Exception e) {
           e.printStackTrace();
       }
 
    }
 
    @Test
    public void save() {
       personService.save(new Person("张三"));
 
    }
 
    @Test
    public void getPerson() {
       System.out.println(personService.getPerson(1).getName());
    }
 
    @Test
    public void update() {
       Person person = personService.getPerson(1);
       person.setName("name");
       personService.update(person);
    }
 
    @Test
    public void del(){
       personService.delete(1);
 
    }
    @Test
    public void getPersons(){
       for(Person person:personService.getPersons())
           System.out.println(person.getName());
    }
                        
}
使用xml的配置方式实现spring与jdbc的结合使用，在bean.xml中的关键配置：
<aop:config>
       <aop:pointcut id="transactionPointcut"
           expression="execution(* com.lcq.service..*.*(..))"/>
       <aop:advisor advice-ref="txAdvice"pointcut-ref="transactionPointcut" />
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="txManager">
       <tx:attributes>
           <tx:method name="get*"read-only="true" propagation="NOT_SUPPORTED"/>
           <tx:method name="*"/>
       </tx:attributes>
</tx:advice>