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,声明式事务,自动装载(注解)的更多相关文章

  1. spring boot中的声明式事务管理及编程式事务管理

    这几天在做一个功能,具体的情况是这样的: 项目中原有的几个功能模块中有数据上报的功能,现在需要在这几个功能模块的上报之后生成一条消息记录,然后入库,在写个接口供前台来拉取消息记录. 看到这个需求,首先 ...

  2. 八、Spring之深入理解声明式事务

    Spring之深入理解声明式事务 何为事务? 事务就是把一系列的动作当成一个独立的工作单元,这些动作要么全部完成,要么全部不起作用. 事务的四个属性: 1.原子性(atomicity) 事务是原子性操 ...

  3. spring基于xml的声明式事务控制配置步骤

    <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sp ...

  4. Spring(四)Spring JdbcTemplate&声明式事务

    JdbcTemplate基本使用 01-JdbcTemplate基本使用-概述(了解) JdbcTemplate是spring框架中提供的一个对象,是对原始繁琐的Jdbc API对象的简单封装.spr ...

  5. Spring事务:一种编程式事务,三种声明式事务

    事务隔离级别 隔离级别是指若干个并发的事务之间的隔离程度.TransactionDefinition 接口中定义了五个表示隔离级别的常量: TransactionDefinition.ISOLATIO ...

  6. spring 事物(三)—— 声明式事务管理详解

    spring的事务处理分为两种: 1.编程式事务:在程序中控制事务开始,执行和提交:详情请点此跳转: 2.声明式事务:在Spring配置文件中对事务进行配置,无须在程序中写代码:(建议使用) 我对&q ...

  7. Spring学习笔记:声明式事务管理增删改查业务

    一.关于是事务 以方法为单位,进行事务控制:抛出异常,事务回滚. 最小的执行单位为方法.决定执行成败是通过是否抛出异常来判断的,抛出异常即执行失败 二.声明式事务: 声明式事务(declarative ...

  8. Spring学习笔记3—声明式事务

    1 理解事务 事务:在软件开发领域,全有或全无的操作被称为事务.事务允许我们将几个操作组合成一个要么全部发生要么全部不发生的工作单元. 事务的特性: 原子性:事务是由一个或多个活动所组成的一个工作单元 ...

  9. spring事物配置,声明式事务管理和基于@Transactional注解的使用

    http://blog.csdn.net/bao19901210/article/details/41724355 http://www.cnblogs.com/leiOOlei/p/3725911. ...

  10. spring基于XML的声明式事务控制

    <?xml version="1.0" encoding="utf-8" ?><beans xmlns="http://www.sp ...

随机推荐

  1. vpn服务器搭建

    这里我们用CentOS6.0和Shdowsocks搭建 首先了解几个命令 wget 是一个从网络上自动下载文件的自由工具,支持通过 HTTP.HTTPS.FTP 三个最常见的 TCP/IP协议 下载, ...

  2. 负载均衡手段之DNS轮询

    大多数域名注册商都支持对统一主机添加多条A记录,这就是DNS轮询,DNS服务器将解析请求按照A记录的顺序,随机分配到不同的IP上,这样就完成了简单的负载均衡.下图的例子是:有3台联通服务器.3台电信服 ...

  3. 一篇不错的Gibbs Sampling解释文章,通俗易懂

    http://cos.name/2013/01/lda-math-mcmc-and-gibbs-sampling/  直接原文的链接了.原文写的不错,是中文博客中说的比较明白的了. 但为了保留文章,随 ...

  4. 书籍推荐系列之一 -- 《凤凰项目:一个IT运维的传奇故事》

    博客已经完全更新了名字,新的名字,新的开始,想让自走向新的道路是很难的,走出舒适圈说了好久,也是时候开始行动了,今天就从写博客开始. 今天给大家推荐一本书,<凤凰项目:一个IT运维的传奇故事&g ...

  5. 微信公众号批量爬取java版

    最近需要爬取微信公众号的文章信息.在网上找了找发现微信公众号爬取的难点在于公众号文章链接在pc端是打不开的,要用微信的自带浏览器(拿到微信客户端补充的参数,才可以在其它平台打开),这就给爬虫程序造成很 ...

  6. CCF-201503-3-节日

    问题描述 试题编号: 201503-3 试题名称: 节日 时间限制: 1.0s 内存限制: 256.0MB 问题描述: 问题描述 有一类节日的日期并不是固定的,而是以"a月的第b个星期c&q ...

  7. YiShop_商城网站建设应该注意什么

    现在电子商务迅速发展,而专门搭建商城网站的第三方开发商也很多.现在搭建一个商城网站容易,如何运营一个商城网站才是重点.下面就由YiShop说说电子商城网站建设要思考什么呢(1)建设网站的目的是什么首先 ...

  8. bitcms内容管理系统 3.1版源码发布

    开源bitcms内容管理系统采用ASP.NET MVC5+MySql的组合开发,更适应中小型系统低成本运行. bitcms的主要功能 1.重写了APS.NET MVC的路由机制.bitcms使用路由参 ...

  9. TensorFlow MNIST(手写识别 softmax)实例运行

    TensorFlow MNIST(手写识别 softmax)实例运行 首先要有编译环境,并且已经正确的编译安装,关于环境配置参考:http://www.cnblogs.com/dyufei/p/802 ...

  10. Netty之粘包分包

    粘包现象 客户端在一个for循环内连续发送1000个hello给Netty服务器端, Socket socket = new Socket("127.0.0.1", 10101); ...