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 ...
随机推荐
- iOS设置圆角的方法及指定圆角的位置
在iOS开发中,我们经常会遇到设置圆角的问题, 以下是几种设置圆角的方法: 第一种方法: 通过设置layer的属性 代码: UIImageView *imageView = [[UIImageView ...
- django实现分片上传文件
目标:利用django实现上传文件功能 1,先设置路由系统 urls.py from django.conf.urls import url,include from django.contrib i ...
- 项目实战4—haproxy 负载均衡和ACL控制
haproxy实现高级负载均衡实战 环境:随着公司业务的发展,公司负载均衡服务已经实现四层负载均衡,但业务的复杂程度提升,公司要求把mobile手机站点作为单独的服务提供,不在和pc站点一起提供服务 ...
- LuaJavaBridge - Lua 与 Java 互操作的简单解决方案
http://dualface.github.io/blog/2013/01/01/call-java-from-lua/ 最近在游戏里要集成中国移动的 SDK,而这些 SDK 都是用 Java 编写 ...
- ThinkPHP中ajax绑定select下拉框无法显示
html代码: 控制器代码: 其中的<option value="{$vo.gradeId}">{$one.gradeName}</option> 在操作过 ...
- LVS+keepalived快速搭建测试环境
#LVS+keepalived快速搭建测试环境 #LVS+keepalived快速搭建测试环境 #centos6 X64 # LVS 负载均衡模式:DR(直接路由) 192.168.18.31 mas ...
- P1629 邮递员送信
题目描述: 有一个邮递员要送东西,邮局在节点1.他总共要送N-1样东西,其目的地分别是2~N.由于这个城市的交通比较繁忙,因此所有的道路都是单行的,共有M条道路,通过每条道路需要一定的时间.这个邮递员 ...
- ES6模块化
关于ES6模块化 历史上,JavaScript 一直没有模块(module)体系,无法将一个大程序拆分成互相依赖的小文件,再用简单的方法拼装起来.其他语言都有这项功能,比如 Ruby 的require ...
- UWP 邮件反馈
在我们构建App的时候,一个很人性化的设计就是增加邮件反馈渠道,就是让用户直接发邮件给你反馈. 当然,你也可以用系统自带的"反馈中心"(超级无敌难用,还经常打不开),或者使用商店的 ...
- window.open()被拦截问题
最近做项目的时候遇到一个需求,在商品详情页面中点击购买按钮,之后再新标签页中打开生成的订单页面,所以想用window.open()来实现.但是测试的时候发现打开的链接被浏览器拦截. 之后,开始在网上查 ...