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>