spring+JdbcTemple+dbcp数据源 的注解实现

在本例中使用spring为我们提供的jdbc的模版来对spring进行开发。有了spring模版后，程序里就不用再对数据连接进行管理。

所有的 bean均通过自动扫描方式进行注入的。这样可以有效的减少beans.xml中bean的配置。

1、新建一个java项目。名字为 springjdbc。
2、在新建的项目中加入spring、jdbc、dbcp需要的jar包
aspectjrt.jar,aspectjweaver.jar,cglib-nodep-2.1_3.jar,common-annotations.jar,log4j-1.2.14.jar,commons-dbcp.jar,commons-logging.jar,commons-pool.jar,spring.jar.mysql.jar，junit.jar
加入一上jar包
3、在str目录里加下beans.xml配置文件,并对数据库连接池与事务进行配置(事务用注解进行配置).在beans里要加上事务的xml声明。也就是表示事务的头文件。

<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"><!-- spring事务 tx-->

	<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/test?useUnicode=true&amp;characterEncoding=UTF-8" />
		<property name="username" value="root" />
		<property name="password" value="123" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="1" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="500" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="2" />
		<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="1" />
	</bean>
	
	<!-- 在事务中注入dataSource -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!--  在JdbcTemplate中注入 dataSource -->
	<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<!-- 以注解的方式对事务进行管理 -->
	<tx:annotation-driven transaction-manager="txManager"/>
	<!-- 打开自动扫描 -->
	<context:component-scan base-package="cn.ehoo"/>
</beans>

4、编写person.java

package cn.ehoo.bean;

/**
 * @author whp
 * @Email [e-mail]
 * @Jan 4, 2011
 * 
 */
public class Person {
	private Long id;
	private String name;

	public Long getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

}

5、编写personService.java与PersonServiceBean.java类。

PersonService.java接口类

package cn.ehoo.service;

import java.util.List;

import cn.ehoo.bean.Person;

/**
 * @author whp
 * @Email [e-mail]
 * @Jan 4, 2011
 * 
 */
public interface PersonService {
	/**
	 * 保存
	 * @param person
	 */
	public void save(Person person);
	/**
	 *更新
	 * @param person
	 */
	public void update(Person person);
	/**
	 * 获取
	 * @param person
	 */
	public Person getPerson(Long personId);
	/**
	 * 获取所有
	 * @param person
	 */
	public List<Person> getPersons();
	/**
	 * 删除指定记录
	 * @param person
	 */
	public void delete(Long personId) throws Exception;

}

PersonServiceBean.java类

package cn.ehoo.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import cn.ehoo.bean.Person;
import cn.ehoo.service.PersonService;

/**
 * @author whp
 * @Email [e-mail]
 * @Jan 4, 2011
 * 
 */
@Service("personService")
@Transactional//代表事务要交给spring容器来管理
public class PersonServiceBean implements PersonService {
	 @Resource private JdbcTemplate jdbcTemplate ;//jdbcTemplate已经在beans.xml文件中进行注入.
	public PersonServiceBean() {
	}

	@Override
	public void save(Person person) {
		//第一个参数结构化查询语言语句,第二个参数占位符的替换,第三个参数是相应参数的类型
		jdbcTemplate.update("insert into person(name) values(?)", new Object[] { person.getName() }, new int[] { java.sql.Types.VARCHAR });
	}

	@Override
	public Person getPerson(Long personId) {
		System.out.println(jdbcTemplate);
		return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[] {personId }, new PersonRowMapper());
	}
	@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true,timeout=30)//这个方法不需要事务 readOnly=true只读  timeout=30超时时间,默认是30S
	@SuppressWarnings("unchecked")
	@Override
	public List<Person> getPersons() {
		return jdbcTemplate.query("select * from person", new PersonRowMapper());
	}

	@Override          
	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.BIGINT});
	}
	@Transactional(noRollbackFor =RuntimeException.class)
	@Override //@Transactional(rollbackFor =Exception.class)//对于能check的例外，spring默认是不会回滚的，如果想进行回滚，可以用rollbackFor进行回滚。
	public void delete(Long personId) throws Exception{//对于用户运行其的uncheck例外，spring容器默认会对事务进行回滚，check是会回滚的
		jdbcTemplate.update("delete from person where id=?", new Object[] {personId}, new int[] {java.sql.Types.BIGINT});
		//throw new RuntimeException("运行其例外");//对于RuntimeException的例外，默认是会进行回滚的，可以用@Transactional(noRollbackFor =RuntimeException.class)设置成不回滚
		throw new Exception("运行其例外");//对于Exception的例外，默认是不会回滚的，可以用@Transactional(rollbackFor =Exception.class)设置成回滚
	}

}

6、PersonRowMapper.java这个类的主要做用是。在对PersonServiceBean.java里的方法getPerson使用。因为在请用getPerson方法后，里面要有一个回调，在回调方法里对perosn类时行填充。

package cn.ehoo.service.impl;

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

import org.springframework.jdbc.core.RowMapper;

import cn.ehoo.bean.Person;

/**
 * @author whp
 * @Email [e-mail]
 * @Jan 5, 2011
 * 
 */
public class PersonRowMapper implements RowMapper {
	@Override
	public Object mapRow(ResultSet rs, int index) throws SQLException {
		Person person = new Person();
		person.setId(rs.getLong("id"));
		person.setName(rs.getString("name"));
		return person;
	}
}

7、junit进行测试。

package junit.test;

import java.util.List;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.ehoo.bean.Person;
import cn.ehoo.service.PersonService;

/**
 * @author whp
 * @Email [e-mail]
 * @Jan 4, 2011
 * 
 */
public class AOPTest {
	static PersonService personService;
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		AbstractApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
		personService = (PersonService) cxt.getBean("personService");
	}

	/**
	 * @author whp
	 * @Email [e-mail]
	 * @Jan 4, 2011
	 * 
	 */
	
	public static void main(String[] args) {
		try {
			setUpBeforeClass();
			Person person = personService.getPerson(2L);
			System.out.println(person.getName()); 
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void getPerson(){
		Person person = personService.getPerson(2L);
		System.out.println(person.getName()+"===="); 
	}
	
	@Test
	public void save(){
		Person person = new Person();
		person.setName("whp100");
		 personService.save(person);
		System.out.println(person.getName()+"===="); 
	}
	
	@Test
	public void update(){
		Person person = new Person();
		person.setId(15L);
		person.setName("whp100");
		 personService.update(person);
		System.out.println(person.getName()+"===="); 
	}
	
	
	@Test
	public void getPersons(){
		List<Person > persons =  personService.getPersons();
		System.out.println(persons.size()+"===="); 
	}
	
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}
}