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 ...
随机推荐
- spring4新特性-泛型依赖注入
1 文件结构 2 具体类 2.1两个抽象类,在Service里面写公共的方法,在各自的具体实现类里面写各自的方法 package repo;import model.User;/** * Crea ...
- Iterator & Iterable 和 Comparable&Comparator
java.lang.Iterator & java.lang.Iterable Iterator和Iterable的区别和联系 iterator是具有迭代状态的对象.它允许你检查它是否有更多的 ...
- 解决No enclosing instance of type * is accessible
写一个内部类,并在构造函数中初始化时,遇到报错,搜索问题后发现,有网友出现过类似的问题,下面这个是说的浅显明白的,并确实解决了问题.于是,以下内容照搬过来,不再多费键盘了. public class ...
- 一、Hadoop学习笔记————概述
hadoop使用java编写,版本较为混乱,初学者可从1.2.1开始学习
- 关于Unity里动态加载图片
Resources.Load 使用该方法可以动态加载资源 过程: 1.首先需要在Project面板里创建一个名为Resources的文件夹(名字必须是这个 不能写错啊) 2.把要加载的游戏对象放到该目 ...
- 巧-微信公众号-操作返回键问题-angularjs开发 SPA
在解决这个问题之前,一直处在很苦逼的状态,因为 现在绝大多数 前端模块都是 SPA 模式:所以由此而来出了许多的问题,当然我现在提的这个只是其中一个: 说一下解决方案: 1.技术栈 angularjs ...
- 项目实战6—Mysql实现企业级日志管理、备份与恢复实战
Mysql实现企业级日志管理.备份与恢复实战 环境背景:随着业务的发展,公司业务和规模不断扩大,网站积累了大量的用户信息和数据,对于一家互联网公司来说,用户和业务数据是根基.一旦公司的数据错乱或者丢失 ...
- POJ 3923 HDU 2487 Ugly Windows 简单计算
Ugly Windows Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Tot ...
- SpringBoot零基础入门指南--搭建Springboot然后能够在浏览器返回数据
File->new Project 修改默认包名,根据自己的喜好修改 选择初始化需要导入的包,尽量不要一开始就导入很多,特别是数据库,不然启动可能会有问题,创建好的目录如下: 配置文件写在app ...
- 为什么要初始化CSS?
因为浏览器的兼容问题,不同浏览器对有些标签的默认值是不同的,如果没对CSS初始化往往会出现浏览器之间的页面显示差异. 当然,初始化样式会对SEO有一定的影响,但鱼和熊掌不可兼得,但力求影响最小的情况下 ...