Spring框架（三） JDBCTemplate，声明式事务，自动装载（注解）
JDBCTemplate
按照标准正常项目的结构
结构图：
model层
dao层 实现 dao：（DateBase Access Object） 数据访问对象，dao层只用来访问数据库和模型层
service层 实现 处理业务逻辑
util层
controller层 控制层
这样的包结构就是一个完整的MVC框架结构
controller层跟页面交互，接受请求，调用哪个方法，传给service层，service层在从dao层调用数据库模板，dao层调用数据库和model层，查询数据库
先在dao层声明方法，在实现方法
在service层声明方法，在实现方法
spring配置
<?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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
</bean>
<!-- 引入 数据库 属性文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<bean id="userService" class="com.maya.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<!-- 这种注入方式需要有get/set方法 -->
<bean id="userDao" class="com.maya.dao.impl.UserDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- dateSource数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 声明Spring提供的事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 引入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
model：
package com.maya.model;
public class User {
private Integer id;
private String uname;
private String upassword;
public User() {
super();
// TODO Auto-generated constructor stub
}
public User(Integer id, String uname, String upassword) {
super();
this.id = id;
this.uname = uname;
this.upassword = upassword;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpassword() {
return upassword;
}
public void setUpassword(String upassword) {
this.upassword = upassword;
}
@Override
public String toString() {
return "User [id=" + id + ", uname=" + uname + ", upassword=" + upassword + "]";
}
}
dao层 接口：
package com.maya.dao;
import java.util.List;
import com.maya.model.User;
public interface UserDao {
public List<User> selectAllUser();
public int insertUser(User u);
public int updateUser(User u);
public int deleteUser(int id);
//持久化查询，
public List<User> selectAllUserRowMapper();
}
dao层实现：
package com.maya.dao.impl;
import java.util.ArrayList;
import java.util.List;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.transaction.annotation.Transactional;
import com.maya.dao.UserDao;
import com.maya.model.User;
public class UserDaoImpl implements UserDao {
private JdbcTemplate jdbcTemplate;
@Override
public List<User> selectAllUser() {
String sql="select * from p_user";
SqlRowSet srs=jdbcTemplate.queryForRowSet(sql);
List<User> ulist=new ArrayList<User>();
while(srs.next()){
User u=new User();
u.setId(srs.getInt(1));
u.setUname(srs.getString(2));
u.setUpassword(srs.getString(3));
ulist.add(u);
}
return ulist;
}
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
//手动抛出异常的方法
public void runTime(){
throw new RuntimeException("异常！！！");
}
@Override
@Transactional
public int insertUser(User u) {
String sql="insert into p_user values(test1.nextval,?,?)";
int i=jdbcTemplate.update(sql, u.getUname(),u.getUpassword());
System.out.println("UserDao的返回值："+i);
//runTime();
return i;
}
@Override
public int updateUser(User u) {
String sql="update p_user p set p.uname=? ,p.upassword=? where p.id=? ";
int i=jdbcTemplate.update(sql, u.getUname(),u.getUpassword(),u.getId());
return 1;
}
@Override
public int deleteUser(int id) {
String sql="delete p_user p where p.id=?";
int i=jdbcTemplate.update(sql,id);
return 1;
}
@Override
public List<User> selectAllUserRowMapper() {
String sql="select * from p_user";
List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
return list;
}
}
service层 接口：
package com.maya.service;
import java.util.List;
import com.maya.model.User;
public interface UserService {
public List<User> selectAllUser();
public int insertUser(User u);
public int updateUser(User u);
public int deleteUser(int id);
//持久化查询，
public List<User> selectAllUserRowMapper();
}
service层 实现：
package com.maya.service.impl;
import java.util.List;
import com.maya.dao.UserDao;
import com.maya.model.User;
import com.maya.service.UserService;
public class UserServiceImpl implements UserService{
private UserDao userDao;
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public List<User> selectAllUser() {
List<User> list=userDao.selectAllUser();
return list;
}
@Override
public int insertUser(User u) {
//直接返回结果
return userDao.insertUser(u);
}
@Override
public int updateUser(User u) {
int i=userDao.updateUser(u);
return i;
}
@Override
public int deleteUser(int id) {
int i=userDao.deleteUser(id);
return i;
}
@Override
public List<User> selectAllUserRowMapper() {
List<User> list=userDao.selectAllUserRowMapper();
return list;
}
}
测试：
package com.maya.controller;
import static org.junit.Assert.*;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.maya.model.User;
import com.maya.service.UserService;
public class JuintTest {
private ClassPathXmlApplicationContext cac;
private UserService userservice;
@Before
public void setUp() throws Exception {
//加载spring-all.xml配置文件
cac=new ClassPathXmlApplicationContext("spring-all.xml");
userservice=(UserService)cac.getBean("userService");
}
@After
public void tearDown() throws Exception {
cac.close();
}
@Test
public void test() {
// List<User> ulist=userservice.selectAllUser();
// for(User u:ulist){
// System.out.println(u);
// }
// List<User> ulist=userservice.selectAllUserRowMapper();
// for(User u:ulist){
// System.out.println(u);
// }
// User u1=new User(null,"0927姓名","999");
// int iu1=userservice.insertUser(u1);
// System.out.println(iu1);
// User u2=new User(10,"update","999");
// int iu2=userservice.updateUser(u2);
// System.out.println(iu2);
int iu3=userservice.deleteUser(122);
System.out.println(iu3);
}
}
声明式事务
引入数据源 开启事务注解驱动 并引入
添加注解
模拟异常
执行方法后抛出异常
回滚
数据米有添加进去
如果去掉注解，数据会添加进去
dao层 实现：
//手动抛出异常的方法
public void runTime(){
throw new RuntimeException("异常！！！");
}
@Override
@Transactional
public int insertUser(User u) {
String sql="insert into p_user values(test1.nextval,?,?)";
int i=jdbcTemplate.update(sql, u.getUname(),u.getUpassword());
System.out.println("UserDao的返回值："+i);
runTime();
return i;
}
自动装配：
不需要get/set方法
在实现类添加注解，Spring启动扫描到注解：
@Repository //或 @Component @Resource 据说差别不大哦
然后添加到Spring容器里
然后向下扫描到@Autowired
不声明的时候默认根据类型进行属性注入
需要设置属性：
//userservice=(UserService)cac.getBean("userService");
userservice=(UserService)cac.getBean(UserService.class);
配置文件：
<?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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
</bean>
<!-- 引入 数据库 属性文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置Spring扫描器
spring加载的时候先去扫描包下的内容，会扫描到一些注解
-->
<context:component-scan base-package="com.maya"></context:component-scan>
<!-- <bean id="userService" class="com.maya.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
这种注入方式需要有get/set方法
<bean id="userDao" class="com.maya.dao.impl.UserDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean> -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- dateSource数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 声明Spring提供的事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 引入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
实现类：
package com.maya.dao.impl;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import com.maya.dao.UserDao;
import com.maya.model.User;
@Repository //或 @Component @Resource 据说差别不大哦
public class UserDaoImpl implements UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public List<User> selectAllUser() {
String sql="select * from p_user";
SqlRowSet srs=jdbcTemplate.queryForRowSet(sql);
List<User> ulist=new ArrayList<User>();
while(srs.next()){
User u=new User();
u.setId(srs.getInt(1));
u.setUname(srs.getString(2));
u.setUpassword(srs.getString(3));
ulist.add(u);
}
return ulist;
}
// public JdbcTemplate getJdbcTemplate() {
// return jdbcTemplate;
// }
//
// public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
// this.jdbcTemplate = jdbcTemplate;
// }
//手动抛出异常的方法
public void runTime(){
throw new RuntimeException("异常！！！");
}
@Override
@Transactional
public int insertUser(User u) {
String sql="insert into p_user values(test1.nextval,?,?)";
int i=jdbcTemplate.update(sql, u.getUname(),u.getUpassword());
System.out.println("UserDao的返回值："+i);
runTime();
return i;
}
@Override
public int updateUser(User u) {
String sql="update p_user p set p.uname=? ,p.upassword=? where p.id=? ";
int i=jdbcTemplate.update(sql, u.getUname(),u.getUpassword(),u.getId());
return 1;
}
@Override
public int deleteUser(int id) {
String sql="delete p_user p where p.id=?";
int i=jdbcTemplate.update(sql,id);
return 1;
}
@Override
public List<User> selectAllUserRowMapper() {
String sql="select * from p_user";
List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
return list;
}
}
package com.maya.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.maya.dao.UserDao;
import com.maya.model.User;
import com.maya.service.UserService;
@Repository //或 @Component @Resource 据说差别不大哦
public class UserServiceImpl implements UserService{
@Autowired
private UserDao userDao;
// public UserDao getUserDao() {
// return userDao;
// }
//
// public void setUserDao(UserDao userDao) {
// this.userDao = userDao;
// }
@Override
public List<User> selectAllUser() {
List<User> list=userDao.selectAllUser();
return list;
}
@Override
public int insertUser(User u) {
//直接返回结果
return userDao.insertUser(u);
}
@Override
public int updateUser(User u) {
int i=userDao.updateUser(u);
return i;
}
@Override
public int deleteUser(int id) {
int i=userDao.deleteUser(id);
return i;
}
@Override
public List<User> selectAllUserRowMapper() {
List<User> list=userDao.selectAllUserRowMapper();
return list;
}
}
测试：
package com.maya.controller;
import static org.junit.Assert.*;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.maya.model.User;
import com.maya.service.UserService;
public class JuintTest {
private ClassPathXmlApplicationContext cac;
private UserService userservice;
@Before
public void setUp() throws Exception {
//加载spring-all.xml配置文件
cac=new ClassPathXmlApplicationContext("spring-all.xml");
//userservice=(UserService)cac.getBean("userService");
userservice=(UserService)cac.getBean(UserService.class);
}
@After
public void tearDown() throws Exception {
cac.close();
}
@Test
public void test() {
List<User> ulist=userservice.selectAllUser();
for(User u:ulist){
System.out.println(u);
}
// List<User> ulist=userservice.selectAllUserRowMapper();
// for(User u:ulist){
// System.out.println(u);
// }
// User u1=new User(null,"0927姓名","999");
// int iu1=userservice.insertUser(u1);
// System.out.println(iu1);
// User u2=new User(10,"update","999");
// int iu2=userservice.updateUser(u2);
// System.out.println(iu2);
// int iu3=userservice.deleteUser(122);
// System.out.println(iu3);
}
}
Spring框架（三） JDBCTemplate，声明式事务，自动装载（注解）的更多相关文章
- spring boot中的声明式事务管理及编程式事务管理
这几天在做一个功能,具体的情况是这样的: 项目中原有的几个功能模块中有数据上报的功能,现在需要在这几个功能模块的上报之后生成一条消息记录,然后入库,在写个接口供前台来拉取消息记录. 看到这个需求,首先 ...
- 八、Spring之深入理解声明式事务
Spring之深入理解声明式事务 何为事务? 事务就是把一系列的动作当成一个独立的工作单元,这些动作要么全部完成,要么全部不起作用. 事务的四个属性: 1.原子性(atomicity) 事务是原子性操 ...
- spring基于xml的声明式事务控制配置步骤
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sp ...
- Spring(四）Spring JdbcTemplate&声明式事务
JdbcTemplate基本使用 01-JdbcTemplate基本使用-概述(了解) JdbcTemplate是spring框架中提供的一个对象,是对原始繁琐的Jdbc API对象的简单封装.spr ...
- Spring事务：一种编程式事务，三种声明式事务
事务隔离级别 隔离级别是指若干个并发的事务之间的隔离程度.TransactionDefinition 接口中定义了五个表示隔离级别的常量: TransactionDefinition.ISOLATIO ...
- spring 事物（三）—— 声明式事务管理详解
spring的事务处理分为两种: 1.编程式事务:在程序中控制事务开始,执行和提交:详情请点此跳转: 2.声明式事务:在Spring配置文件中对事务进行配置,无须在程序中写代码:(建议使用) 我对&q ...
- Spring学习笔记：声明式事务管理增删改查业务
一.关于是事务 以方法为单位,进行事务控制:抛出异常,事务回滚. 最小的执行单位为方法.决定执行成败是通过是否抛出异常来判断的,抛出异常即执行失败 二.声明式事务: 声明式事务(declarative ...
- Spring学习笔记3—声明式事务
1 理解事务 事务:在软件开发领域,全有或全无的操作被称为事务.事务允许我们将几个操作组合成一个要么全部发生要么全部不发生的工作单元. 事务的特性: 原子性:事务是由一个或多个活动所组成的一个工作单元 ...
- spring事物配置，声明式事务管理和基于@Transactional注解的使用
http://blog.csdn.net/bao19901210/article/details/41724355 http://www.cnblogs.com/leiOOlei/p/3725911. ...
- spring基于XML的声明式事务控制
<?xml version="1.0" encoding="utf-8" ?><beans xmlns="http://www.sp ...
随机推荐
- SpringAware
哈哈,终于把分布式的课程演讲给混过去了,下面开始随便自己学点东西. 正题:SpringAware--------在实际项目中,用到spring容器的本省功能资源,这是Bean必须意识到Spring容器 ...
- MVC-1(javabean+jsp+servlet+jdbc)
这是一篇最初版本的mvc设计模式的demo.路要一步一步走,弄明白这其中的逻辑,对后面掌握ssh,ssm等框架大有裨益. 计算机系的同学们也要为毕设做准备了,希望可以帮你们迈出自己做毕设的第一步(微笑 ...
- 1455:An Easy Problem
传送门:http://noi.openjudge.cn/ch0406/1455/ /-24作业 //#include "stdafx.h" #include<bits/std ...
- AIO5销售发货单numeric算数溢出报错：将numeric转换成数据类型numeric时出现算数溢出错误
问题描述: 销售发货单报错算数溢出:将numeric转换成数据类型numeric时出现算数溢出错误.具体如下图: 当销售发货单的数量为>7万时,报错 当销售发货单的数量为<7万时,单据正常 ...
- 通用Adapter设计，SparseArray+泛型+回调的使用
看到题目,我相信聪明的各位已经有一定想法了. 一个Adapter,最简单的优化就是使用泛型,他可以省去非常多的代码,不过在此之上,我们还可以继续优化,优化他的好基友是:ViewHolder. 在过去, ...
- 阿里云Https部署网站
0.开始之前 文章图片很多,注意流量 首先你得准备好一个已经备案成功的域名,并且有一个在阿里云的服务器部署了的网站. 然后就是你迫切的希望升级网站为HTTPS部署. 那么我们开始吧! 1.申请CA证书 ...
- Java设计模式之单例模式详解
在Java开发过程中,很多场景下都会碰到或要用到单例模式,在设计模式里也是经常作为指导学习的热门模式之一,相信每位开发同事都用到过.我们总是沿着前辈的足迹去做设定好的思路,往往没去探究为何这么做,所以 ...
- 网页设计——4.html基本标签链接，图片，表格
今天主要认识一个有趣的html标签 1.超链接标签a 基本结构:<a href="url" >内容 </a> url就是网页地址. 但直接用这种超链接,会自 ...
- javascript设计模式——模板方法模式
前面的话 在javascript开发中用到继承的场景其实并不是很多,很多时候喜欢用mix-in的方式给对象扩展属性.但这不代表继承在javascript里没有用武之地,虽然没有真正的类和继承机制,但可 ...
- Python2/3中的urllib库
urllib库对照速查表 Python2.X Python3.X urllib urllib.request, urllib.error, urllib.parse urllib2 urllib.re ...