2. 程式人生 > >15、Spring事務管理、SSH整合

15、Spring事務管理、SSH整合

阿新 • • 發佈：2018-12-29

Spring 第二天：
1. 代理模式
2. Aop程式設計
3.Spring對Jdbc的支援
JdbcTemplate工具類

思考：
程式的“事務控制”， 可以用aop實現！ 即只需要寫一次，執行時候動態織入到業務方法上。
Spring提供了對事務的管理，開發者只需要按照Spring的方式去做就行。

目標:
1. Spring宣告式事務管理
* XML配置
*註解方式
2. Spring與Hibernate整合
3. SSH整合

  1. 程式中事務控制
    1.1 環境準備
    使用者訪問—》Action –》 Service—》Dao

一個業務的成功： 呼叫的service是執行成功的，意味著service中呼叫的所有的dao是執行成功的。 事務應該在Service層統一控制。

1）沒有應用事務的程式碼：
2）模擬：
在service中呼叫2次dao， 希望其中一個dao執行失敗，整個操作要回滾。

開發步驟：
1. 後臺環境準備
資料庫、表/entity/dao/service
2. dao 的實現用JdbcTemplate
3. 物件建立都有Spring容器完成

1.2 事務控制概述
程式設計式事務控制
自己手動控制事務，就叫做程式設計式事務控制。
Jdbc程式碼：
Conn.setAutoCommite(false); // 設定手動控制事務
Hibernate程式碼：
Session.beginTransaction(); // 開啟一個事務
【細粒度的事務控制： 可以對指定的方法、指定的方法的某幾行新增事務控制】
(比較靈活，但開發起來比較繁瑣： 每次都要開啟、提交、回滾.)

宣告式事務控制
Spring提供了對事務的管理, 這個就叫宣告式事務管理。
Spring提供了對事務控制的實現。使用者如果想用Spring的宣告式事務管理，只需要在配置檔案中配置即可； 不想使用時直接移除配置。這個實現了對事務控制的最大程度的解耦。
Spring宣告式事務管理，核心實現就是基於Aop。
【粗粒度的事務控制： 只能給整個方法應用事務，不可以對方法的某幾行應用事務。】
(因為aop攔截的是方法。)

Spring宣告式事務管理器類：
    Jdbc技術：DataSourceTransactionManager
    Hibernate技術：HibernateTransactionManager
  1. 宣告式事務管理
    步驟：
    1） 引入spring-aop相關的4個jar檔案
    2） 引入aop名稱空間 【XML配置方式需要引入】
    3） 引入tx名稱空間 【事務方式必須引入】
    XML方式實現
  2. DeptDao.java
public class DeptDao {

    // 容器注入JdbcTemplate物件
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void save(Dept dept){
        String sql = "insert into t_dept (deptName) values(?)";
        jdbcTemplate.update(sql,dept.getDeptName());
    }
}
  1. DeptService
public class DeptService {

    // 容器注入dao物件
    private DeptDao deptDao;
    public void setDeptDao(DeptDao deptDao) {
        this.deptDao = deptDao;
    }

    /*
     * 事務控制？
     */
    public void save(Dept dept){
        // 第一次呼叫
        deptDao.save(dept);

        int i = 1/0; // 異常： 整個Service.save()執行成功的要回滾

        // 第二次呼叫
        deptDao.save(dept);
    }
}
  1. App 測試類
@Test
    public void testApp() throws Exception {
        //容器物件
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_tx/bean.xml");

        // 模擬資料
        Dept dept = new Dept();
        dept.setDeptName("測試： 開發部");

        DeptService deptService = (DeptService) ac.getBean("deptService");
        deptService.save(dept);

    }
  1. bean.xml (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:aop="http://www.springframework.org/schema/aop"
    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.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!-- 1. 資料來源物件: C3P0連線池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!-- 2. JdbcTemplate工具類例項 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 3. dao例項 -->
    <bean id="deptDao" class="cn.itcast.a_tx.DeptDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <!-- 4. service例項 -->
    <bean id="deptService" class="cn.itcast.a_tx.DeptService">
        <property name="deptDao" ref="deptDao"></property>
    </bean>

    <!-- #############5. Spring宣告式事務管理配置############### -->
    <!-- 5.1 配置事務管理器類 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 5.2 配置事務增強(如果管理事務?) -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" read-only="false"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5.3 Aop配置： 攔截哪些方法(切入點表表達式) + 應用上面的事務增強配置 -->
    <aop:config>
        <aop:pointcut expression="execution(* cn.itcast.a_tx.DeptService.*())" id="pt"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

</beans>

註解方式實現
使用註解實現Spring的宣告式事務管理，更加簡單！
步驟：
1） 必須引入Aop相關的jar檔案
2） bean.xml中指定註解方式實現宣告式事務管理以及應用的事務管理器類
3）在需要新增事務控制的地方，寫上: @Transactional

@Transactional註解：
1）應用事務的註解
2）定義到方法上： 當前方法應用spring的宣告式事務
3）定義到類上： 當前類的所有的方法都應用Spring宣告式事務管理;
4）定義到父類上： 當執行父類的方法時候應用事務。

Bean.xm

<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!-- 1. 資料來源物件: C3P0連線池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!-- 2. JdbcTemplate工具類例項 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 事務管理器類 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 開啟註解掃描 -->
    <context:component-scan base-package="cn.itcast.b_anno"></context:component-scan>

    <!-- 註解方式實現事務： 指定註解方式實現事務 -->
    <tx:annotation-driven transaction-manager="txManager"/>
</beans>

DeptService

@Service
public class DeptService {

    @Resource
    private DeptDao deptDao;

    /*
     * 事務控制？
     */
    @Transactional
    public void save(Dept dept){
        deptDao.save(dept);
        int i = 1/0;
        deptDao.save(dept);
    }
}

事務屬性

@Transactional(
            readOnly = false,  // 讀寫事務
            timeout = -1,       // 事務的超時時間不限制
            noRollbackFor = ArithmeticException.class,  // 遇到數學異常不回滾
            isolation = Isolation.DEFAULT,              // 事務的隔離級別，資料庫的預設
            propagation = Propagation.REQUIRED          // 事務的傳播行為
    )
    public void save(Dept dept){
        deptDao.save(dept);
        int i = 1/0;
        deptDao.save(dept);
    }

事務傳播行為:
Propagation.REQUIRED
指定當前的方法必須在事務的環境下執行；
如果當前執行的方法，已經存在事務， 就會加入當前的事務；
Propagation.REQUIRED_NEW
指定當前的方法必須在事務的環境下執行；
如果當前執行的方法，已經存在事務： 事務會掛起； 會始終開啟一個新的事務，執行完後； 剛才掛起的事務才繼續執行。

舉例：

Class Log{
        Propagation.REQUIRED  
        insertLog();  
}

    Propagation.REQUIRED
    Void  saveDept(){
        insertLog();    // 加入當前事務
        .. 異常, 會回滾
        saveDept();
    }


    Class Log{
        Propagation.REQUIRED_NEW  
        insertLog();  
}

    Propagation.REQUIRED
    Void  saveDept(){
        insertLog();    // 始終開啟事務
        .. 異常, 日誌不會回滾
        saveDept();
    }

測試步驟：
1）日誌表Log_
2）LogService.java
insertLog();

  1. Spring與Hibernate整合
    Spring與Hibernate整合關鍵點：
    1） Hibernate的SessionFactory物件交給Spring建立；
    2） hibernate事務交給spring的宣告式事務管理。

SSH整合：
Spring與Struts；
Spring與hibernate整合；

SH整合步驟：
1）引入jar包
連線池/資料庫驅動包
Hibernate相關jar
Spring 核心包(5個)
Spring aop 包(4個)
spring-orm-3.2.5.RELEASE.jar 【spring對hibernate的支援】
spring-tx-3.2.5.RELEASE.jar 【事務相關】
2）配置
hibernate.cfg.xml
bean.xml
3）搭建環境、單獨測試

步驟實現

  1. DeptDao.java
// 資料訪問層
public class DeptDao {

    // Spring與Hibernate整合： IOC容器注入
    private SessionFactory sessionFactory;
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    // 儲存一個記錄
    // Spring與Hibernate整合：事務管理交給Spring
    public void save(Dept dept) {
        sessionFactory.getCurrentSession().save(dept);
    }
}
2. DeptService
public class DeptService {

    private DeptDao deptDao;
    public void setDeptDao(DeptDao deptDao) {
        this.deptDao = deptDao;
    }

    public void save(Dept dept){
        deptDao.save(dept);
    }
}
  1. App.java 測試
public class App {

    // 容器
    private ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

    @Test
    public void testApp() throws Exception {
        DeptService deptServie = (DeptService) ac.getBean("deptService");
        System.out.println(deptServie.getClass());

        deptServie.save(new Dept());
    }
}
  1. bean.xml 配置 【Spring管理SessionFactory的3中方式】
<?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:aop="http://www.springframework.org/schema/aop"
    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.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- dao 例項 -->
    <bean id="deptDao" class="cn.itcast.dao.DeptDao">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <!-- service 例項 -->
    <bean id="deptService" class="cn.itcast.service.DeptService">
        <property name="deptDao" ref="deptDao"></property>
    </bean>

    <!-- 資料來源配置 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>

    <!-- ###########Spring與Hibernate整合  start########### -->

    <!-- 方式（1）直接載入hibernate.cfg.xml檔案的方式整合
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
    </bean>    -->

    <!-- 方式（2）連線池交給spring管理  【一部分配置寫到hibernate中，一份分在spring中完成】 
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
        <property name="dataSource" ref="dataSource"></property>
    </bean> -->

    <!-- 【推薦】方式（3）所有的配置全部都在Spring配置檔案中完成 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 注入連線池物件 -->
        <property name="dataSource" ref="dataSource"></property>

        <!-- hibernate常用配置 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>

        <!-- hibernate對映配置 
        <property name="mappingLocations">
            <list>
                <value>classpath:cn/itcast/entity/*.hbm.xml</value>
            </list>
        </property>
        -->
        <property name="mappingDirectoryLocations">
            <list>
                <value>classpath:cn/itcast/entity/</value>
            </list>
        </property>
    </bean>



    <!-- ###########Spring與Hibernate整合  end########### -->

    <!-- 事務配置 -->
    <!-- a. 配置事務管理器類 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- b. 配置事務增強(攔截到方法後如果管理事務?) -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <!-- c. Aop配置 -->
    <aop:config>
         <aop:pointcut expression="execution(* cn.itcast.service.*.*(..))" id="pt"/>
         <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

</beans>

細節

  1. SSH整合
    即：
    Spring與Struts整合
    Spring與Hibernate整合

需求：
JSP頁面顯示員工資訊 （查詢）

整合步驟：
1） 引入SSH Jar檔案
Struts 核心jar
Hibernate 核心jar
Spring
Core 核心功能
Web 對web模組支援
Aop aop支援
Orm 對hibernate支援
Jdbc/tx jdbc支援包、事務相關包

2）配置
    Web.xml
            初始化struts功能、spring容器
    Struts.xml   配置請求路徑與對映action的關係
    Spring.xml  IOC容器配置
        bean-base.xml     【公用資訊】
        bean-service.xml
        bean-dao.xml
        bean-action.xml

3）開發
    Entity/Dao/service/action

相關推薦

15、Spring事務管理、SSH整合

Spring 第二天： 1. 代理模式 2. Aop程式設計 3.Spring對Jdbc的支援 JdbcTemplate工具類 思考： 程式的“事務控制”， 可以用aop實現！ 即只需要寫一次，執行時候動態織入到業務方法上。 Spring提供了對事務的管理，開發者只需要按

SpringBoot學習筆記（三）：SpringBoot整合Mybatis、SpringBoot事務管理、SpringBoot多資料來源

SpringBoot整合Mybatis 第一步我們需要在pom.xml裡面引入mybatis相關的jar包 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artif

微服務、分庫分表、分散式事務管理、APM鏈路跟蹤效能分析演示專案

好多年沒發博，最近有時間整理些東西，分享給大家。 所有內容都在github專案liuzhibin-cn/my-demo中，基於SpringBoot，演示Dubbo微服務 + Mycat, Sharding-Proxy分庫分表 + Seata分散式事務管理 + ZipKin, SkyWalking, PinPo

Java進階學習第二十四天（Spring框架：事務管理、Spring與Hibernate整合）

一、事務控制 1、引入 使用者訪問 > Action > Service > Dao 如何保證： 在service中呼叫2次dao，其中一個dao執行失敗，整個操作要回滾 2、事務控制概述 ① 程式設計式事務控制：自己手動控制事務 Jdbc程式

spring、hibernate事務管理的區別及整合方式

在談Spring事務管理之前我們想一下在我們不用Spring的時候，在Hibernate中我們是怎麼進行資料操作的。在Hibernate中我們每次進行一個操作的的時候我們都是要先開啟事務，然後進行資料操作，然後提交事務，關閉事務，我們這樣做的原因是因為Hibernate

Day3-Spring的事務管理、Spring框架的JDBC模板

今天內容 1. Spring框架的AOP之註解的方式2. Spring框架的JDBC模板3. Spring框架的事務管理 案例一：使用Spring框架的AOP技術對DAO層的功能進行增強 案例一：使用Spring框架的AOP技術對DAO層的功能進行增強 1. 使用Spring框架的

第三天 ： 事務管理 、 三大框架整合開發

事務管理 、 三大框架整合開發 目錄 一、Spring事務管理 1、 事務管理相關API 2、 PlatformTransactionManager 介面詳解 1) 不同平臺事務管理器實現 2) TransactionDefinition 事務隔離級別 3）

spring事務管理（一） 隔離級別、傳播行為

1.事務的定義 事務是指多個操作單元組成的合集，多個單元操作是整體不可分割的，要麼都操作不成功，要麼都成功。其必須遵循四個原則（ACID）。 原子性（Atomicity）：即事務是不可分割的最小工作單元，事務內的操作要麼全做，要麼全不做； 一致性（Consistency

Spring宣告式事務管理、事務的傳播行為xml配置

 1. <tx:method name="insert*" propagation="REQUIRED" />中name的值是ServiceImpl中各個要加入事物管理的方法的方法名。 <!-- 事務管理： Spring宣告式事務管理 。

【Spring Boot】（33）、SpringBoot事務管理@Transactional註解原理

1、依賴包 1.1、 SpringBoot中的依賴包 眾所周知，在SpringBoot中凡是需要跟資料庫打交道的，基本上都要顯式或者隱式新增jdbc的依賴： <dependency> <groupId>org.springfram

Spring事務管理----------整合學習版

XML idt 類定義 dao mda info spring配置 讀取數據 blue 作者：學無先後 達者為先 Spring提供了一流的事務管理。在Spring中可以支持聲明式事務和編程式事務。 一 spring簡介 1 Spring的事務 事

劍指架構師系列-InnoDB存儲引擎、Spring事務與緩存

之前 ner 不提交 變化 def dto suspend 自己實現 更改 事務與鎖是不同的。事務具有ACID屬性： 原子性:持久性：由redo log重做日誌來保證事務的原子性和持久性,一致性：undo log用來保證事務的一致性隔離性:一個事務在操作過程中看到了其他

Spring事務超時、回滾的相關說明

rollback family 數據庫 span ransac return urn 出現 trac 事務超時： @Transactional(timeout = 60) 如果用這個註解描述一個方法的話，線程已經跑到方法裏面，如果已經過去60秒了還沒跑完這個方法並且線程

什麽是事務、事務特性、事務隔離級別、spring事務傳播特性

ons pri table 產生 serializa support enc 不一致 修改 1.什麽是事務： 事務是程序中一系列嚴密的操作，所有操作執行必須成功完成，否則在每個操作所做的更改將會被撤銷，這也是事務的原子性（要麽成功，要麽失敗）。 2.事務特性： 事務特性分為

九、Spring事務

1.什麼是事務？ 邏輯上的一組操作，組成這組操作的各個單元，要麼全都成功，要麼全都失敗。 2.事務的特性？ 原子性：事務不可分割 一致性：事務執行前後資料完整性保持一致 隔離性：一個事務的執行不應該受到其他事務的干擾 永續性：一旦事務結束，資料就持久化到

python之Django的入門08------事務管理、悲觀鎖、樂觀鎖

我們接著上一篇文章的基礎上，來繼續瞭解進一步的Django框架 一.事務管理 在實際專案裡，事務管理是一個很重要的內容。 他可以保證一系列類操作要不全部成功要不全部失敗。也可以保證當多個應用程式在併發訪問資料庫時，可以在這些應用程式之間提供一個隔離方法，以防止

使用SpringAOP實現事務（聲明式事務管理、零配置）

特定 管理器 表示 可能 事務 常量 ger 事務傳播 不可 前言： 聲明式事務管理建立在AOP之上的。其本質是對方法前後進行攔截，然後在目標方法開始之前創建或者加入一個事務，在執行完目標方法之後根據執行情況提交或者回滾事務。聲明式事務最大的優點就是不需要通過編程的方式

(2)、Spring Boot與Mybatis的整合( 多資料來源)

1、背景的介紹有時候我們需要做分庫分表，那麼肯定存在多資料來源，Spring Boot和Mybatis的多資料來源是如何整合的呢？比如說我們現在做了一個浪跡天涯管理的後臺系統，商品資訊是存在itemCenter資料來源中的，而與使用者相關的資訊是存在account資料來源中，

十六、Spring事務異常回滾，捕獲異常不丟擲就不會回滾

最近遇到了事務不回滾的情況，我還考慮說JPA的事務有bug？ 我想多了……. 為了列印清楚日誌，很多方法我都加tyr catch，在catch中列印日誌。但是這邊情況來了，當這個方法異常時候 日誌是列印了，但是加的事務卻沒有回滾。 例： 類似這樣的方法不會回滾 （一個方法出錯，另一個方

實際springMVC專案中自定義異常、spring事務與異常的簡單應用

一、異常相關知識： 非執行時異常(Checked Exception) Java中凡是繼承自Exception但不是繼承自RuntimeException的類都是非執行時異常。 執行時異常（Runtime Exception/Unchecked Excep