Spring与JDBC整合

使用Spring+JDBC集成步骤如下:

 

配置数据源,如:

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
	destroy-method="close">
	<property name="driverClassName" value="org.gjt.mm.mysql.Driver" />
	<property name="url"
		value="jdbc:mysql://localhost:3306/spring?useUnicode=true&amp;characterEncoding=UTF-8" />
	<property name="username" value="root" />
	<property name="password" value="mysql" />
	.....略
</bean>

 

配置事务。配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间(如下),事务的配置方式有两种：注解方式和基于XML配置方式。

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	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/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
           http://www.springframework.org/schema/aop h
           ttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context 
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
</beans>

 

为了方便，我们使用属性占位符方式配置数据源

<!-- classpath指明在配置文件在类路径下面  -->
<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>

 

jdbc.properties

driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost\:3306/spring?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=mysql
initialSize=1
maxActive=500
maxIdle=2
minIdle=1

 

采用注解方式配置事务

<bean id="txManager"
	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource" />
</bean>
 <!– 采用@Transactional注解方式使用事务  -->
<tx:annotation-driven transaction-manager="txManager" />

  

综合上述，spring.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/aop http://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">

	<!-- classpath指明在配置文件在类路径下面  -->
	<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="org.spring.service.impl.PersonServiceBean">
		<property name="dataSource" ref="dataSource" />
	</bean>
</beans>

 

Person类

package org.spring.bean;

public class Person {
	private Integer id;
	private String name;

	public Person() {
	}

	public Person(String name) {
		this.name = name;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

 

PersonService

package org.spring.service;

import java.util.List;

import org.spring.bean.Person;

public interface PersonService {
	/**
	 * 保存person
	 * 
	 * @param person
	 */
	public void save(Person person);

	/**
	 * 更新person
	 * 
	 * @param person
	 */
	public void update(Person person);

	/**
	 * 获取person
	 * 
	 * @param personid
	 * @return
	 */
	public Person getPerson(Integer personid);

	/**
	 * 获取所有person
	 * 
	 * @return
	 */
	public List<Person> getPersons();

	/**
	 * 删除指定id的person
	 * 
	 * @param personid
	 */
	public void delete(Integer personid);
}

 

PersonServiceBean

package org.spring.service.impl;

import java.util.List;

import javax.sql.DataSource;

import org.spring.bean.Person;
import org.spring.service.PersonService;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

@Transactional
public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;

	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}

	public void delete(Integer personid) {
		jdbcTemplate
				.update("delete from person where id=?",
						new Object[] { personid },
						new int[] { java.sql.Types.INTEGER });
	}

	public Person getPerson(Integer personid) {
		return (Person) jdbcTemplate.queryForObject(
				"select * from person where id=?", new Object[] { personid },
				new int[] { java.sql.Types.INTEGER }, new PersonRowMapper());
	}

	@SuppressWarnings("unchecked")
	public List<Person> getPersons() {
		return (List<Person>) jdbcTemplate.query("select * from person",
				new PersonRowMapper());
	}

	public void save(Person person) {
		jdbcTemplate.update("insert into person(name) values(?)",
				new Object[] { person.getName() },
				new int[] { java.sql.Types.VARCHAR });
	}

	public void update(Person person) {
		jdbcTemplate.update("update person set name=? where id=?",
				new Object[] { person.getName(), person.getId() }, new int[] {
						java.sql.Types.VARCHAR, java.sql.Types.INTEGER });
	}
}

 

PersonRowMapper

package org.spring.service.impl;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.spring.bean.Person;
import org.springframework.jdbc.core.RowMapper;

public class PersonRowMapper implements RowMapper {

	public Object mapRow(ResultSet rs, int index) throws SQLException {
		Person person = new Person(rs.getString("name"));
		person.setId(rs.getInt("id"));
		return person;
	}
}

 

测试类

package org.spring.junit;

import org.junit.BeforeClass;
import org.junit.Test;
import org.spring.bean.Person;
import org.spring.service.PersonService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class PersonServiceTest {
	private static PersonService personService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			ApplicationContext cxt = new ClassPathXmlApplicationContext(
					"spring.xml");

			personService = (PersonService) cxt.getBean("personService");
		} catch (RuntimeException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void save() {
		for (int i = 0; i < 5; i++)
			personService.save(new Person("spring" + i));
	}

	@Test
	public void getPerson() {
		Person person = personService.getPerson(3);
		System.out.println(person.getName());
	}

	@Test
	public void update() {
		Person person = personService.getPerson(1);
		person.setName("xxx");
		personService.update(person);
	}

	@Test
	public void delete() {
		personService.delete(1);
	}

	@Test
	public void getBeans() {
		for (Person person : personService.getPersons()) {
			System.out.println(person.getName());
		}
	}
}

 

目录结构如下