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 ...
随机推荐
- Oracle数据库应用
Oracle数据库应用 一:.Oracle数据库应用知识 二:表空间和用户权限管理 表空间: 表空间是数据逻辑结构的一个重要组件,表空间可以存放各种应用对象,如表,索引.而每个表空间由一个或者多个数据 ...
- CTF 文件包含与伪协议
正巧在写代码审计的文章,无意间看到了一篇CTF的代码审计,CTF题目很好,用的姿势正如标题,文件包含和伪协议. 先放出原文链接(http://www.freebuf.com/column/150028 ...
- 老男孩Python全栈开发（92天全）视频教程 自学笔记04
day4课程目录: 逻辑运算符 while循环 day4课程内容梳理: 逻辑运算符 算数运算符:+,-,*,/,%,** 比较运算符:< ,>, ==,<=,>=,!=, 逻辑 ...
- Lucene入门-安装和运行Demo程序
Lucene版本:7.1 一.下载安装包 https://lucene.apache.org/core/downloads.html 二.安装 把4个必备jar包和路径添加到CLASSPATH \lu ...
- Bitmap.Config 说明 ALPHA_8 ARGB_4444 ARGB_8888 RGB_565
这篇文章的目的是了解Bitmap.Config 你可以在使用这个方法的时候会遇到 Bitmap android.graphics.Bitmap.createBitmap(int width, int ...
- 自定义控件，上图下字的Button，图片任意指定大小
最近处在安卓培训期,把自己的所学写成博客和大家分享一下,今天学的是这个自定义控件,上图下字的Button安卓自带,但是苦于无法设置图片大小(可以在代码修改),今天自己做了一个,首先看一下效果图,比较实 ...
- 十五、Hadoop学习笔记————Zookeeper的环境搭建
linux中/opt一般用来存放应用/var目录一般用来存放日志 sample为样例文件,复制一份zoo.cfg文件 配置zoo文件,id为服务器id(整数),host为服务器的ip地址,第一个por ...
- Servlet之会话（Session）以及会话追踪技术（Cookie），（URL重写）和（隐藏表单域）
Session 什么是会话? 会话: Web应用中的会话 指的是一个客户端浏览器与Web服务器之间连续发生的一系列请求和响应的过程 会话状态: Web服务器和浏览器在会话的过程中产生的状态信息 作用: ...
- 【转】如何使用Git上传本地项目到github?(mac版)
原文链接:http://www.cnblogs.com/lijiayi/p/pushtogithub.html 在此假设你已经在 github 上创建好了一个项目,像这样: 并且你已经完成了自己的项目 ...
- 备忘录模式（Memento）
备忘录模式(Memento) 主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类A,A中有各种属性,A可以决定需要备份的属性,备忘录类B是 ...