标签：toc local tab 容器 配置 构造 llb 记录 osi
<!-- 加载properties文件中 信息 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置数据源 -->
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
</bean>
其中，新建 jdbc.properties 文件
内容：
jdbc.username=root jdbc.password=123456 jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/jdbc_template
③在IOC容器中配置JdbcTemplate对象的bean，并将数据源对象装配到JdbcTemplate对象中
<!-- 配置JdbcTemplate对应的bean， 并装配dataSource数据源属性-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="comboPooledDataSource"></property>
</bean>
@Test
public void test() throws SQLException{
ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource bean = ioc.getBean(DataSource.class);
System.out.println(bean.getConnection());
}
实验2：将emp_id=5的记录的salary字段更新为1300.00【更新操作】
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
@Test
public void test() throws SQLException{
String sql = "UPDATE employee SET salary = ? WHERE emp_id = ?";
bean.update(sql, 1300,5);//第一个是sql语句，后面的按着顺序传入参数即可，这个update方法是接收的可变参数！
}
}
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
@Test
public void test() throws SQLException{
String sql="INSERT INTO employee(emp_name,salary) VALUES(?,?)";
List<Object[]> list = new ArrayList<Object[]>();
list.add(new Object[]{"Tom2015",1000});
list.add(new Object[]{"Tom2016",2000});
list.add(new Object[]{"Tom2017",3000});
bean.batchUpdate(sql, list);
}
}
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
@Test
public void test(){
//需要注意的是：sql语句中的别名要与对应实体类的属性名保持一致！
String sql = "SELECT emp_id AS empId,emp_name AS empName,salary FROM employee WHERE emp_id=?";
//RowMapper是一个接口,这里我们使用其子类
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<Employee>(Employee.class);
//最后一个参数是可变参数，用于向sql语句中依次传递参数!
Employee employee = bean.queryForObject(sql, rowMapper, 5);
System.out.println(employee);
}
}
实验5：查询salary>4000的数据库记录，封装为List集合返回
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
@Test
public void test(){
//需要注意的是：sql语句中的别名要与对应实体类的属性名保持一致！
String sql = "SELECT emp_id AS empId,emp_name AS empName,salary FROM employee WHERE salary > ?";
//RowMapper是一个接口,这里我们使用其子类
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<Employee>(Employee.class);
//该query方法查询出来的是一个list列表,query方法的最后一个参数是可变参数！
List<Employee> list = bean.query(sql, rowMapper, 4000);
for (Employee employee : list) {
System.out.println(employee);
}
}
}
实验6：查询最大salary
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
@Test
public void test01(){
String sql = "SELECT MAX(salary) FROM employee";
//需要指定返回值的类型,而且类型必须是包装类型
Double maxSalary = bean.queryForObject(sql, Double.class);
System.out.println(maxSalary);
}
}
实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值
<!-- 为了执行带有具名参数的SQL语句，需要配置NamedParameterJdbcTemplate -->
<!-- 该NamedParameterJdbcTemplate类没有无参构造器，需要传入JdbcTemplate对象或者数据源对象[DataSource] -->
<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<!-- 不能使用property标签配置 -->
<constructor-arg ref="jdbcTemplate"></constructor-arg>
</bean>
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test01(){
NamedParameterJdbcTemplate bean2 = ioc.getBean(NamedParameterJdbcTemplate.class);
String sql="INSERT INTO employee(emp_name,salary) VALUES(:paramName,:paramSalary)";//具名参数与map 的key 值相同
Map<String,Object> paramMap = new HashMap<String,Object>();
paramMap.put("paramName","张学友" );
paramMap.put("paramSalary",1000);
bean2.update(sql, paramMap);
}
}
实验8：重复实验7，以SqlParameterSource形式传入参数值
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test01(){
NamedParameterJdbcTemplate bean2 = ioc.getBean(NamedParameterJdbcTemplate.class);
String sql="INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
//该BeanPropertySqlParameterSource类构造器需要一个对象参数，该对象参数是一个封装了sql语句参数的对象！
//此时要求对象的属性名要和sql中的参数名保持一致！这里我们使用Employee对象来完成
Employee employee= new Employee("郭富城", 1500);
//以实体对象的形式封装具名参数和值
SqlParameterSource source = new BeanPropertySqlParameterSource(employee);
bean2.update(sql, source);
}
}
@Repository
public class JdbcTemplateDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public void update(){
String sql = "DELETE FROM employee where emp_id = ?";
jdbcTemplate.update(sql, 15);
}
}
public class TestJDBCTemplate {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
private JdbcTemplate bean = ioc.getBean(JdbcTemplate.class);
private JdbcTemplateDao dao = ioc.getBean(JdbcTemplateDao.class);
@Test
public void testEmployeeDao(){
dao.update();
}
}
<context:component-scan base-package="com.neuedu"></context:component-scan>
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
</bean>
<!-- 以上时JdbcTemplate配置所需 -->
<!-- 配置事务管理器 -->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="comboPooledDataSource"></property>
</bean>
<!-- 开启基于注解的声明式事务 -->
<!-- 有时候不需要transaction-manager 因为默认值为transactionManager -->
<!-- 如果事务管理器的id为transactionManager就不用写 -->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
public class TestDataSource {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() throws Exception {
DataSource bean = ioc.getBean(DataSource.class);
System.out.println(bean.getConnection());
}
}
@Repository
public class BookDao {
@Autowired
private JdbcTemplate template;
public double findPriceByIsbn(String isbn){
String sql = "SELECT price FROM book WHERE isbn = ?";
Double price = template.queryForObject(sql, Double.class, isbn);
return price;
}
public void updateBookStock(String isbn){
String sql="UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";
template.update(sql, isbn);
}
public void updateAccount(String username,Double price){
String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
template.update(sql, price,username);
}
//演示事务的传播机制
public void updateBookPrice(double price,String isbn){
String sql ="UPDATE book SET price = ? WHERE isbn = ?";
template.update(sql, price,isbn);
}
}
7.创建 Service 层
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
bookDao.updateBookStock(isbn);
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bookDao.updateAccount(username, price);
}
@Transactional
public void updateBookPrice(double price,String isbn){
bookDao.updateBookPrice(price, isbn);
}
}
public class TestBookService {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test() {
BookService bean = ioc.getBean(BookService.class);
bean.doCash("ISBN-001", "Tom");
}
}
@Transactional(propagation=Propagation.REQUIRED)
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
bookDao.updateBookStock(isbn);
bookDao.updateAccount(username, price);
}
@Transactional(propagation=Propagation.REQUIRED)
public void updateBookPrice(double price,String isbn){
bookDao.updateBookPrice(price, isbn);
}
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
bookDao.updateBookStock(isbn);
bookDao.updateAccount(username, price);
}
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void updateBookPrice(double price,String isbn){
bookDao.updateBookPrice(price, isbn);
}
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.READ_COMMITTED)
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
System.out.println(price);
bookDao.updateBookStock(isbn);
bookDao.updateAccount(username, price);
}
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.READ_COMMITTED
,noRollbackFor={ArithmeticException.class}
)
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
bookDao.updateBookStock(isbn);
int i = 10/0;//异常
bookDao.updateAccount(username, price);
}
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.READ_COMMITTED
,noRollbackFor={ArithmeticException.class}
,timeout=3)
public void doCash(String isbn,String username){
double price = bookDao.findPriceByIsbn(isbn);
bookDao.updateBookStock(isbn);
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) {
e.printStackTrace();
}
bookDao.updateAccount(username, price);
}
Spring（四）-- JdbcTemplate、声明式事务
标签：toc local tab 容器 配置 构造 llb 记录 osi
原文地址：http://www.cnblogs.com/lwj-0923/p/7460221.html
