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 ...
随机推荐
- SpringBoot之彩色输出
spring.output.ansi.enabled NEVER:禁用ANSI-colored输出(默认项) DETECT:会检查终端是否支持ANSI,是的话就采用彩色输出(推荐项) ALWAYS:总 ...
- maven学习之1
最近用maven的时候各种出问题,打算系统的学习一下maven,搞明白依赖之类的. (一)创建工程: mvn archetype:generate 这样就可以根据提示来建立一个maven项目,常用的有 ...
- JavaScript学习笔记（七）——函数的定义与调用
在学习廖雪峰前辈的JavaScript教程中,遇到了一些需要注意的点,因此作为学习笔记列出来,提醒自己注意! 如果大家有需要,欢迎访问前辈的博客https://www.liaoxuefeng.com/ ...
- 使用Microsoft.AspNetCore.TestHost进行完整的功能测试
简介 Microsoft.AspNetCore.TestHost是可以用于Asp.net Core 的功能测试工具.很多时候我们一个接口写好了,单元测试什么的也都ok了,需要完整调试一下,检查下单元测 ...
- java 之 代理模式（大话设计模式）
java代理模式顾名思义,就类似于大学,我想和冰可乐,可是我又在玩游戏,于是我让我的室友帮我把可乐带回来,简单的来说我的室友就是代理,而买可乐就是需要做的行为.这是笔者理解的代理模式 大话设计模式-类 ...
- [DFS遍历图]UVA10562 Undraw the Trees
传送门: 1. UVA - 10562 2. Vjudge [看图写树] 将题目中给出的树改写为 括号表示法 即 (ROOT (SON1(...) (SON2(...)...(SONn(... ...
- jquery总结（来自于一个讲师的总结）
选择器 基本选择器:id class 标签 eq()查找具体的列表中的元素:$('ul li:eq(n)').eq(n) 层 :div p,div>p 查找:find 选中元素中再查找子元素,p ...
- memcached内存管理
前言 memcached默认情况下采用了名为Slab Allocator的机制来管理内存.在该机制出现以前,内存的分配是通过对所有记录简单地进行malloc和free来进行的.但是,这种方式会导致内存 ...
- Numpy入门 - 数组聚合运算
本节主要讲解numpy的几个常用的聚合运算,包括求和sum.求平均mean和求方差var. 一.求和sum import numpy as np arr = np.array([[1, 2, 3], ...
- VC++下编译 程序“减肥”
在vc6 和 vs 2008下 编译 以下代码,不更改任何编译设置(vc6 40k , s2008 7k). 一.vc6下,Release 模式 编译处理. 1.去掉不必要的 链接库 工程(Pro ...