声明式事务管理

声明事务管理(数据库连接池)

1.dao

 1 package com.zhidi.dao;
 2
 3 import java.sql.Connection;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7
 8 import javax.sql.DataSource;
 9
10 import org.hibernate.Session;
11 import org.hibernate.SessionFactory;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.stereotype.Repository;
14
15 import com.zhidi.entity.Emp;
16
17 @Repository
18 public class EmpDao {
19     @Autowired
20     private DataSource dataSource;
21     @Autowired
22     private SessionFactory sessionFactory;
23
24     public void query() {
25         try {
26             Connection connection = dataSource.getConnection();
27             PreparedStatement statement = connection.prepareStatement("select * from emp");
28             ResultSet set = statement.executeQuery();
29             while (set.next()) {
30                 String name = set.getString("ename");
31                 System.out.println(name);
32             }
33         } catch (SQLException e) {
34             e.printStackTrace();
35         }
36     }
37
38     public void get(Integer id) {
39         Session session = sessionFactory.getCurrentSession();
40         session.beginTransaction();
41         session.get(Emp.class, id);
42         session.getTransaction().commit();
43     }
44
45     public Emp getById(Integer id)
46     {
47         Session session = sessionFactory.getCurrentSession();
48         Emp emp=(Emp)session.get(Emp.class, id);
49         return emp;
50     }
51
52     public void delete(Integer id)
53     {
54        Session session = sessionFactory.getCurrentSession();
55        Emp emp=    getById(id);
56        session.delete(emp);
57
58     }
59 }

2.entity

 1 package com.zhidi.entity;
 2
 3 import java.util.Date;
 4
 5 import javax.persistence.Entity;
 6 import javax.persistence.GeneratedValue;
 7 import javax.persistence.GenerationType;
 8 import javax.persistence.Id;
 9 import javax.persistence.Table;
10 import javax.persistence.Temporal;
11 import javax.persistence.TemporalType;
12
13 @Entity
14 @Table(name = "emp")
15 public class Emp {
16     @Id
17     @GeneratedValue(strategy = GenerationType.AUTO)
18     private Integer empno;
19     private String ename;
20     @Temporal(TemporalType.DATE)
21     private Date hiredate;
22
23     public Integer getEmpno() {
24         return empno;
25     }
26
27     public void setEmpno(Integer empno) {
28         this.empno = empno;
29     }
30
31     public String getEname() {
32         return ename;
33     }
34
35     public void setEname(String ename) {
36         this.ename = ename;
37     }
38
39     public Date getHiredate() {
40         return hiredate;
41     }
42
43     public void setHiredate(Date hierdate) {
44         this.hiredate = hierdate;
45     }
46
47 }

3.service

 1 package com.zhidi.service;
 2
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Service;
 5 import org.springframework.transaction.annotation.Propagation;
 6 import org.springframework.transaction.annotation.Transactional;
 7
 8 import com.zhidi.dao.EmpDao;
 9 import com.zhidi.entity.Emp;
10 @Transactional
11 @Service
12 public class EmpService {
13     @Autowired
14     private EmpDao empDao;
15     @Transactional(propagation=Propagation.SUPPORTS,readOnly=true)
16     public Emp getById(Integer id)
17     {
18         return empDao.getById(id);
19     }
20
21     public void deleteById(Integer id)
22     {
23         empDao.delete(id);
24     }
25
26 }

4.test

 1 package com.zhidi.test;
 2
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5
 6 import com.zhidi.dao.EmpDao;
 7
 8 public class TestEmp {
 9
10     public static void main(String[] args) {
11         @SuppressWarnings("resource")
12         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
13         EmpDao empDao = context.getBean(EmpDao.class);
14         empDao.query();
15
16         empDao.get(7965);
17     }
18 }

 1 package com.zhidi.test;
 2
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5
 6 import com.zhidi.entity.Emp;
 7 import com.zhidi.service.EmpService;
 8
 9 public class TestTx {
10
11     public static void main(String[] args) {
12         @SuppressWarnings("resource")
13         ApplicationContext context =new ClassPathXmlApplicationContext("applicationContext.xml");
14         EmpService service=context.getBean(EmpService.class);
15         Emp emp=service.getById(7959);
16         System.out.println(emp.getEname());
17
18         service.deleteById(7951);
19
20     }
21
22 }

5.applicationContext.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
 4     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
 7         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 8         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
 9
10     <!-- 打开配置 -->
11     <!-- <context:component-scan base-package="com.zhidi" /> -->
12     <context:property-placeholder location="jdpc.properties" />
13     <!-- 将c3p0交给Spring的IOC容器管理 -->
14     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
15         <!-- 必要的配置 -->
16         <property name="driverClass" value="${jdpc.driverClass}" />
17         <property name="jdbcUrl" value="${jdpc.url}" />
18         <property name="user" value="${jdpc.userName}" />
19         <property name="password" value="${jdpc.password}" />
20         <!-- 初始化连接数 -->
21         <property name="initialPoolSize" value="3" />
22         <!-- 最大连接数 -->
23         <property name="maxPoolSize" value="10" />
24         <!-- 最小连接数 -->
25         <property name="minPoolSize" value="1"></property>
26         <!-- 最大的连接时间8小时 -->
27         <property name="maxConnectionAge" value="28800"></property>
28         <!-- 需要防止8小时陷阱,需要设置时间小于8小时 -->
29         <!-- 设置为6小时 -->
30         <property name="maxIdleTime" value="21600"></property>
31     </bean>
32
33     <!-- 将LocalSessionFactoryBean交给Spring的IOC容器管理 -->
34     <bean id="sessionFactory"
35         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
36         <!-- 将c3p0的数据源注入到SessionFactory -->
37         <property name="dataSource" ref="dataSource"></property>
38         <!-- 指定hibernate的配置信息 -->
39         <property name="hibernateProperties">
40             <props>
41                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
42                 <prop key="hibernate.show_sql">true</prop>
43                 <prop key="hibernate.format_sql">true</prop>
44                 <!-- 删掉或者把 thread改为org.springframework.orm.hibernate4.SpringSessionContext-->
45                 <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop>
46             </props>
47         </property>
48         <!-- 指定扫描@entity的实体类 -->
49         <property name="packagesToScan" value="com.zhidi.entity" />
50     </bean>
51
52     <!-- 定义hibernate的事务管理 -->
53     <bean id="transactionManager"
54         class="org.springframework.orm.hibernate4.HibernateTransactionManager">
55         <!-- 将sessionFactory注入事务管理器中 -->
56         <property name="sessionFactory" ref="sessionFactory" />
57     </bean>
58     <!-- 开启事务管理的配置 -->
59     <tx:annotation-driven transaction-manager="transactionManager"/>
60
61     <!-- 配置事务管理 -->
62     <!-- <tx:advice id="txAdvice" transaction-manager="transactionManager">
63         为不同的目标方法指定不同的事务属性
64         <tx:attributes>
65             name指定该事务属性对应的方法 propagation指事务的传播特性 read-only只读
66             <tx:method name="add*" propagation="REQUIRED" />
67             <tx:method name="save*" propagation="REQUIRED" />
68             <tx:method name="delete*" propagation="REQUIRED" />
69             <tx:method name="modeif*" propagation="REQUIRED" />
70             <tx:method name="update*" propagation="REQUIRED" />
71             <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
72             <tx:method name="query*" propagation="SUPPORTS" read-only="true" />
73             <tx:method name="search*" propagation="SUPPORTS" read-only="true" />
74             <tx:method name="*" propagation="SUPPORTS" read-only="true" />
75         </tx:attributes>
76     </tx:advice> -->
77
78     <!-- 定义事务处理的AOP切面 -->
79      <aop:config>
80         <aop:advisor advice-ref="txAdvice"
81             pointcut="execution(* com.zhidi.service..*.*(..))" />
82     </aop:config>
83
84 </beans>

6.properties

1 jdpc.driverClass=com.mysql.jdbc.Driver
2 jdpc.url=jdbc:mysql://localhost:3306/db_hibernate
3 jdpc.userName=root
4 jdpc.password=775297

 1 ### direct log messages to stdout ###
 2 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 3 log4j.appender.stdout.Target=System.out
 4 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 5 log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 6
 7 ### direct messages to file hibernate.log ###
 8 #log4j.appender.file=org.apache.log4j.FileAppender
 9 #log4j.appender.file.File=hibernate.log
10 #log4j.appender.file.layout=org.apache.log4j.PatternLayout
11 #log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
12
13 ### set log levels - for more verbose logging change ‘info‘ to ‘debug‘ ###
14
15 log4j.rootLogger=warn, stdout
16
17 #log4j.logger.org.hibernate=info
18 log4j.logger.org.hibernate=debug
19
20 ### log HQL query parser activity
21 #log4j.logger.org.hibernate.hql.ast.AST=debug
22
23 ### log just the SQL
24 #log4j.logger.org.hibernate.SQL=debug
25
26 ### log JDBC bind parameters ###
27 log4j.logger.org.hibernate.type=info
28 #log4j.logger.org.hibernate.type=debug
29
30 ### log schema export/update ###
31 log4j.logger.org.hibernate.tool.hbm2ddl=debug
32
33 ### log HQL parse trees
34 #log4j.logger.org.hibernate.hql=debug
35
36 ### log cache activity ###
37 #log4j.logger.org.hibernate.cache=debug
38
39 ### log transaction activity
40 #log4j.logger.org.hibernate.transaction=debug
41
42 ### log JDBC resource acquisition
43 #log4j.logger.org.hibernate.jdbc=debug
44
45 ### enable the following line if you want to track down connection ###
46 ### leakages when using DriverManagerConnectionProvider ###
47 #log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

时间: 2024-10-26 17:36:27

声明式事务管理的相关文章

注解方式实现声明式事务管理

使用注解实现Spring的声明式事务管理,更加简单! 步骤: 1) 必须引入Aop相关的jar文件 2) bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类 3)在需要添加事务控制的地方,写上: @Transactional @Transactional注解: 1)应用事务的注解 2)定义到方法上: 当前方法应用spring的声明式事务 3)定义到类上:   当前类的所有的方法都应用Spring声明式事务管理; 4)定义到父类上: 当执行父类的方法时候应用事务. 修改bean

Spring声明式事务管理(基于注解方式实现)

----------------------siwuxie095 Spring 声明式事务管理(基于注解方式实现) 以转账为例 1.导入相关 jar 包(共 10 个包) (1)导入核心 jar 包和日志相关的 jar 包 (2)导入 JdbcTemplate 的 jar 包 (3)导入 MySQL 的 JDBC 驱动包 mysql-connector-java 下载链接: https://dev.mysql.com/downloads/connector/j/ (4)导入 AOP 的 jar

spring 声明式事务管理

简单理解事务: 比如你去ATM机取1000块钱,大体有两个步骤:首先输入密码金额,银行卡扣掉1000元钱:然后ATM出1000元钱.这两个步骤必须是要么都执行要么都不执行.如果银行卡扣除了1000块但是ATM出钱失败的话,你将会损失1000元:如果银行卡扣钱失败但是ATM却出了1000块,那么银行将损失1000元.所以,如果一个步骤成功另一个步骤失败对双方都不是好事,如果不管哪一个步骤失败了以后,整个取钱过程都能回滚,也就是完全取消所有操作的话,这对双方都是极好的. 当这两个步骤提交了,执行完毕

spring aop 声明式事务管理

Spring使用AOP来完成声明式的事务管理   有annotation和xml两种形式 代码和上一篇基本相近,再贴一遍 两个实体类 package com.ouc.wkp.model; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; @Entity(name = "t_log") public class Log { priva

spring 声明式事务管理注解方式实现

使用注解实现Spring的声明式事务管理,更加简单! 步骤: 1) 必须引入Aop相关的jar文件 2) bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类 3)在需要添加事务控制的地方,写上: @Transactional @Transactional注解: 1)应用事务的注解 2)定义到方法上: 当前方法应用spring的声明式事务 3)定义到类上:   当前类的所有的方法都应用Spring声明式事务管理; 4)定义到父类上: 当执行父类的方法时候应用事务. 案例: 1.

全面分析 Spring 的编程式事务管理及声明式事务管理--转

开始之前 关于本教程 本教程将深入讲解 Spring 简单而强大的事务管理功能,包括编程式事务和声明式事务.通过对本教程的学习,您将能够理解 Spring 事务管理的本质,并灵活运用之. 先决条件 本教程假定您已经掌握了 Java 基础知识,并对 Spring 有一定了解.您还需要具备基本的事务管理的知识,比如:事务的定义,隔离级别的概念,等等.本文将直接使用这些概念而不做详细解释.另外,您最好掌握数据库的基础知识,虽然这不是必须. 系统需求 要试验这份教程中的工具和示例,硬件配置需求为:至少带

spring声明式事务管理

Spring 的声明式事务管理在底层是建立在 AOP 的基础之上的.其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务. 声明式事务管理分为两种:1.配置文件   2.注解 1.配置文件(声明式事务管理)用法: 在applicationContext.xml配置文件中配置①事务管理器(事务管理者).②事务参数(事务通知).③AOP配置 如下: applicationContext.xml配置文件代码 1 <!-- 事务管理器(

spring mvc + mybatis + spring aop声明式事务管理没有作用

在最近的一个项目中,采用springMVC.mybatis,发现一个很恼人的问题:事务管理不起作用!!网上查阅了大量的资料,尝试了各种解决办法,亦未能解决问题! spring版本:3.0.5 mybatis版本:3.2.2 1.applicationContext.xml配置: mvc + mybatis + spring aop声明式事务管理没有作用" title="spring mvc + mybatis + spring aop声明式事务管理没有作用">2.spr

Spring学习之Spring的声明式事务管理详解

声明式事务管理 大多数Spring用户选择声明式事务管理的原因是,这个是对应用代码影响最小的选择,因此也最符合 非侵入式 轻量级容器的理念. Spring声明式事务管理可以在任何环境下使用.只需更改配置文件, 它就可以和JDBC.JDO.Hibernate或其他的事务机制一起工作. Spring的声明式事务管理可以被应用到任何类(以及那个类的实例)上. Spring提供了声明式的回滚规则. Spring允许你通过AOP定制事务行为.(例如,如果需要,你可以在事务回滚中插入定制的行为. 你也可以增

SpringMVC、MyBatis声明式事务管理

采用的基本搭建环境:SpringMVC.MyBatis.MySQL.tomcat         Spring事务管理分解了传统的全局事务管理和本地事务管理的劣势,使得在任何环境中都可以使用统一的事务管理模型,你可以写一次代码,然后在不同的环境从你的代码里面配置不同的事务管理策略,Spring提供两种事务管理策略:一种是声明式事务管理策略,另一种是编程式事务管理策略,这里主要介绍声明式事务管理策略         由于采用的是SpringMVC. MyBatis,故统一采用了标注来声明Servi