spring事物(2)-----手寫spring註解事務&&事務傳播行為

阿新 • • 發佈：2018-11-20

一，spring事務的註解

1.1，spring自帶的@Transactional例子

package com.qingruihappy1.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
    @Autowired
     
private JdbcTemplate jdbcTemplate;

    public void add(String name, Integer age) {
        String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";
        int updateResult = jdbcTemplate.update(sql, name, age);
        System.out.println("updateResult:" + updateResult);
    }

}

package com.qingruihappy1.service;

//user 服務層
public interface UserService {

    public void add();

}

package com.qingruihappy1.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.qingruihappy1.dao.UserDao;
import com.qingruihappy1.service.UserService;



 
//user 服務層
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

     //宣告：@Transactional 或者XML方式
     //方法執行開始執行前，開啟提交事務
     @Transactional
     public void add() {
     userDao.add("test001", 20);
     int i = 1 / 0;
     System.out.println("################" + i);
     userDao.add("test002", 21);
     
         //注意下面的程式碼是不會回滾的，因為異常給吃掉了，所以是不會回滾的。
     //因為回滾的機制在異常中的，現在吃掉異常之後就不會進入異常的方法中，所以自然而然的不會回滾的。
/*     try {
        userDao.add("test001", 20);
         int i = 1 / 0;
         System.out.println("################" + i);
         userDao.add("test002", 21);
    } catch (Exception e) {
        e.printStackTrace();
    }*/
    
     }
    // 方法執行完畢之後，才會提交事務



}

<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">
    <context:component-scan
        base-package="com"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy> <!-- 開啟事物註解 -->
    <!-- 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://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>


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

    <!-- 3.配置事務 -->
    <bean id="dataSourceTransactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 開啟註解事務 注意自定義註解的時候把它註釋掉，用spring自帶的話則加上 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
</beans>

測試：

package com.qingruihappy1.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.qingruihappy1.service.UserService;


public class Test001 {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) applicationContext.getBean("userServiceImpl");
        userService.add();
    }

}

1.2，自定義註解案例

package com.qingruihappy2.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Target(value = ElementType.METHOD) 設定註解許可權<br>
 * @author qingruihappy
 *
 */
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
// @interface 定義註解
public @interface AddAnnotation {

    // 手寫Spring事務註解
    int userId() default 0;

    String userName() default "預設名稱";

    String[]arrays();
}

package com.qingruihappy2.annotation;

import java.lang.reflect.Method;

public class User {

    @AddAnnotation(userName = "張三", userId = 18, arrays = { "1" })
    public void add() {

    }

    public void del() {

    }

    public static void main(String[] args) throws ClassNotFoundException {
        // 怎麼樣獲取到方法上註解資訊 反射機制
        Class<?> forName = Class.forName("com.qingruihappy2.annotation.User");
        // 獲取到當前類（不包含繼承）所有的方法
        Method[] declaredMethods = forName.getDeclaredMethods();
        for (Method method : declaredMethods) {
            // 獲取該方法上是否存在註解
            System.out.println("####方法名稱" + method.getName());
            AddAnnotation addAnnotation = method.getAnnotation(AddAnnotation.class);
            if (addAnnotation == null) {
                // 該方法上沒有註解
                System.out.println("該方法上沒有加註解..");
                continue;
            }
            // 在該方法上查詢到該註解
            System.out.println("userId:" + addAnnotation.userId());
            System.out.println("userName:" + addAnnotation.userName());
            System.out.println("arrays:" + addAnnotation.arrays());
            System.out.println();
        }
    }

}

####方法名稱add
userId:18
userName:張三
arrays:[Ljava.lang.String;@18760838

####方法名稱main
該方法上沒有加註解..
####方法名稱del
該方法上沒有加註解..

1.3，手寫spring註解事務

步驟

package com.qingruihappy3.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoa {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void add(String name, Integer age) {
        String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";
        int updateResult = jdbcTemplate.update(sql, name, age);
        System.out.println("updateResult:" + updateResult);
    }

}

package com.qingruihappy3.service;

//user 服務層
public interface UserService {

    public void add();

    public void del();
}

package com.qingruihappy3.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.qingruihappy3.annotation.ExtTransaction;
import com.qingruihappy3.dao.UserDaoa;
import com.qingruihappy3.service.UserService;

//user 服務層
@Service
public class UserServiceImpla implements UserService {
    @Autowired
    private UserDaoa userDao;

    /*
     * 宣告：@Transactional 或者XML方式 方法執行開始執行前，開啟提交事務
     */
    @ExtTransaction
    public void add() {
        userDao.add("test001", 20);
         int i = 1 / 0;
         System.out.println("################" + i);
        userDao.add("test002", 21);
        // 獲取當前事務，手動進行回滾
    }

    // 方法執行完畢之後，才會提交事務
    public void del() {
        System.out.println("del");
    }

}

註解：

package com.qingruihappy3.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 事務註解 設定傳播行為
@Target({ ElementType.METHOD })//只在方法上起作用
@Retention(RetentionPolicy.RUNTIME)//執行時的註解
public @interface ExtTransaction {

}

工具類

package com.qingruihappy3.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;

// 程式設計事務（需要手動begin 手動回滾 手都提交）
@Component
@Scope("prototype") // 每個事務都是新的例項 目的解決執行緒安全問題 多例子 prototype就是多例的。
public class TransactionUtils {

    // 全域性接受事務狀態 TransactionStatus宣告為全域性的原因就是讓每個事務都建立一個例項，防止出現執行緒安全的問題
    private TransactionStatus transactionStatus;
    // 獲取事務源
    @Autowired
    private DataSourceTransactionManager dataSourceTransactionManager;

    // 開啟事務
    public TransactionStatus begin() {
        System.out.println("開啟事務");
        transactionStatus = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
        return transactionStatus;
    }

    // 提交事務
    public void commit(TransactionStatus transaction) {
        System.out.println("提交事務");
        dataSourceTransactionManager.commit(transaction);
    }

    // 回滾事務
    public void rollback() {
        System.out.println("回滾事務...");
        dataSourceTransactionManager.rollback(transactionStatus);
    }

}

切面類：

package com.qingruihappy3.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import com.qingruihappy3.annotation.ExtTransaction;
import com.qingruihappy3.transaction.TransactionUtils;



//  自定義事務註解具體實現
@Aspect
@Component
public class AopExtTransaction {
    // 一個事務例項子 針對一個事務
    @Autowired
    private TransactionUtils transactionUtils;

    // 使用異常通知進行 回滾事務
    @AfterThrowing("execution(* com.qingruihappy3.service.*.*.*(..))")
    public void afterThrowing() {
        // 獲取當前事務進行回滾
        // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        transactionUtils.rollback();
    }

    // 環繞通知 在方法之前和之後處理事情
    @Around("execution(* com.qingruihappy3.service.*.*.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {

        // 1.獲取該方法上是否加上註解
        ExtTransaction extTransaction = getMethodExtTransaction(pjp);
        TransactionStatus transactionStatus = begin(extTransaction);
        // 2.呼叫目標代理物件方法
        pjp.proceed();
        // 3.判斷該方法上是否就上註解
        commit(transactionStatus);
    }

    private TransactionStatus begin(ExtTransaction extTransaction) {
        if (extTransaction == null) {
            return null;
        }
        // 2.如果存在事務註解,開啟事務
        return transactionUtils.begin();
    }

    private void commit(TransactionStatus transactionStatus) {
        if (transactionStatus != null) {
            // 5.如果存在註解,提交事務
            transactionUtils.commit(transactionStatus);
        }

    }

    // 獲取方法上是否存在事務註解
    private ExtTransaction getMethodExtTransaction(ProceedingJoinPoint pjp)
            throws NoSuchMethodException, SecurityException {
        String methodName = pjp.getSignature().getName();
        // 獲取目標物件
        Class<?> classTarget = pjp.getTarget().getClass();
        // 獲取目標物件型別
        Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        // 獲取目標物件方法
        Method objMethod = classTarget.getMethod(methodName, par);
        ExtTransaction extTransaction = objMethod.getAnnotation(ExtTransaction.class);
        return extTransaction;
    }

}

package com.qingruihappy3;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.qingruihappy3.service.UserService;


public class Test001 {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) applicationContext.getBean("userServiceImpla");
        userService.add();
    }

}

二：事務的傳播行為

我們通過一張圖引入

這個怎麼實現呢？

我們來看這7中傳播行為

Propagation（key屬性確定代理應該給哪個方法增加事務行為。這樣的屬性最重要的部份是傳播行為。）有以下選項可供使用：

PROPAGATION_REQUIRED--支援當前事務，如果當前沒有事務，就新建一個事務。這是最常見的選擇。

PROPAGATION_SUPPORTS--支援當前事務，如果當前沒有事務，就以非事務方式執行。

PROPAGATION_MANDATORY--支援當前事務，如果當前沒有事務，就丟擲異常。

PROPAGATION_REQUIRES_NEW--新建事務，如果當前存在事務，把當前事務掛起。

PROPAGATION_NOT_SUPPORTED--以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。

PROPAGATION_NEVER--以非事務方式執行，如果當前存在事務，則丟擲異常。

我們通過程式碼來看：

package com.qingruihappy4.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class LogDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void add(String name) {
        String sql = "INSERT INTO t_log(log_name) VALUES(?);";
        int updateResult = jdbcTemplate.update(sql, name);
        System.out.println("##LogDao##updateResult:" + updateResult);
    }

}

package com.qingruihappy4.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoc {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void add(String name, Integer age) {
        String sql = "INSERT INTO t_users(NAME, age) VALUES(?,?);";
        int updateResult = jdbcTemplate.update(sql, name, age);
        System.out.println("updateResult:" + updateResult);
    }

}

package com.qingruihappy4.service;

public interface LogService {

    public void addLog();

}

package com.qingruihappy4.service;

//user 服務層
public interface UserService {

    public void add();

    public void del();
}

package com.qingruihappy4.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.qingruihappy4.dao.LogDao;
import com.qingruihappy4.service.LogService;



@Service
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW)關鍵就是這一行程式碼
    public void addLog() {
        logDao.add("addLog" + System.currentTimeMillis());
    }

}

package com.qingruihappy4.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.qingruihappy4.dao.UserDaoc;
import com.qingruihappy4.service.LogService;
import com.qingruihappy4.service.UserService;



//user 服務層
@Service
public class UserServiceImplc implements UserService {
    @Autowired
    private UserDaoc userDao;
    @Autowired
    private LogService logService;
    
    @Transactional
    public void add() {
        // 呼叫介面的時候 介面失敗 需要回滾，但是日誌記錄不需要回滾。
        logService.addLog(); // 後面程式發生錯誤，不能影響到我的回滾### 正常當addLog方法執行完畢，就應該提交事務
        userDao.add("test001", 20);
        int i = 1 / 0;
        System.out.println("################");
        userDao.add("test002", 21);

    }
    // 方法執行完畢之後，才會提交事務

    public void del() {
        System.out.println("del");
    }

}

package com.qingruihappy4;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.qingruihappy4.service.UserService;


public class Test001 {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) applicationContext.getBean("userServiceImplc");
        userService.add();
    }

}

關鍵就是上面標紅的程式碼。定義一個兩套事務互不影響的。

spring事物(2)-----手寫spring註解事務&&事務傳播行為

一，spring事務的註解 1.1，spring自帶的@Transactional例子 package com.qingruihappy1.dao; import org.springframework.beans.factory.annotation.Autowired; imp

Spring學習之——手寫Spring原始碼V2.0(實現IOC、DI、MVC、AOP)

前言在上一篇《Spring學習之——手寫Spring原始碼(V1.0)》中，我實現了一個Mini版本的Spring框架，在這幾天，博主又看了不少關於Spring原始碼解析的視訊，受益匪淺，也對Spring的各元件有了自己的理解和認識，於是乎，在空閒時間把之前手寫Spring的程式碼重

手寫spring事務（註解版本）

1.首先自定義一個事務註解（類似於@Transactional） package com.itmayiedu.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retentio

手寫Spring註解事務（利用AOP技術 + 註解 + Spring程式設計式事務）

1.參考下面的文章搭建一個無事務管理的SSM操作資料庫的框架 Spring 使用Druid資料來源整合 Mybatis 2.AOP技術參考 AOP技術應用實現 3.第一步首先實現Sprin

手寫Spring事務註解框架【視訊教程】

課程大綱：第一節(原始碼分析課程概述)第二節(AOP技術概述)第三節(AOP技術原理)第四節(靜態代理設計模式) 擊開啟連結第五節(動態代理設計模式)第六節(使用SpringAOP技術面向切面程式設計)

基於註解方式純手寫spring-ioc

1.定義註解 @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface ExtService { } 2.工具類 https://blog.csdn.net/qq_419882

Spring系列之手寫註解與配置檔案的解析

目錄 Spring系列之IOC的原理及手動實現 Spring系列之DI的原理及手動實現 Spring系列之AOP的原理及手動實現引入在前面我們已經完成了IOC，DI，AOP的實現，基本的功能都已經完成了，我們的手寫框架也能勉強使用起來。為了讓我們的框架能夠使用起來比較簡單，這一節我

手寫Spring之IOC基於註解動態建立物件

上一篇部落格介紹瞭如何基於xml配置檔案在執行時建立例項物件，這篇部落格將介紹基於註解方式怎樣實現物件的建立。廢話不多說，直接上程式碼。首先還是建立專案，由於這次不需要使用第三方的API，建立一

手寫Spring MVC框架（包含Java註解的實現）

主要從以下幾點入手：一、瞭解SpringMVC執行流程及九大元件二、梳理自己的SpringMVC的設計思路三、實現自己的SpringMVC框架瞭解SpringMVC執行流程及九大元件執行流程：1.使用者傳送請求->DispatcherServlet；使用者向服務

純手寫Spring IoC容器之自定義註解實現

由於我在CSDN編輯器上寫這篇文章的時候，在貼上圖片上來的時候總是出現了卡頓，所以就另外寫了一個word文件裡面了，具體的實現過程請下載，裡面有文件、原始碼、資料庫sql檔案連結：https://pan.baidu.com/s/1La2FIhlVKSt7JLh393V8I

手寫Spring事務框架

程式設計事務實現概述所謂程式設計式事務指的是通過編碼方式實現事務，即類似於JDBC程式設計實現事務管理。管理使用TransactionTemplate或者直接使用底層的PlatformTransactionManager。對於程式設計式事務管理，spring推薦使用T

手寫 Spring 事務、IOC、DI 和 MVC

for keyset lds 請求遍歷 nts cts pro del Spring AOP 原理什麽是 AOP？ AOP 即面向切面編程，利用 AOP 可以對業務進行解耦，提高重用性，提高開發效率應用場景：日誌記錄，性能統計，安全控制，事務處理，異常處理 AOP 底

阿裏微服務專家手寫Spring Boot 實現一個簡單的自動配置模塊

微服務簡單的 AR AI tps ble 免費 VM 知識體系為了更好的理解 Spring Boot 的自動配置和工作原理，我們自己來實現一個簡單的自動配置模塊。假設，現在項目需要一個功能，需要自動記錄項目發布者的相關信息，我們如何通過 Spring Boot 的

我是這樣手寫Spring的，麻雀雖小，五臟俱全

很多精華 red 自己執行 dispatch xml文件 pom.xml 描述人見人愛的Spring已然不僅僅只是一個框架了。如今，Spring已然成為了一個生態。但深入了解Spring的卻寥寥無幾。這裏，我帶大家一起來看看，我是如何手寫Spring的。我將結合對Sp

我是這樣手寫Spring的，麻雀雖小五臟俱全

人見人愛的Spring已然不僅僅只是一個框架了。如今，Spring已然成為了一個生態。但深入瞭解Spring的卻寥寥無幾。這裡，我帶大家一起來看看，我是如何手寫Spring的。我將結合對Spring十多年的研究經驗，用不到400行程式碼來描述SpringIOC、DI、MVC的精華設計思想，並

帶你手寫spring：IOC與DI

前言依稀記得在2016年剛畢業的時候，在京面試某公司的時候技術總監和我聊到了spring，我比較欣賞一個音樂人Rod Johnson以一人之力造就了spring。當時的個人水平僅僅是知道spring，會簡單使用。當面試官問到我對原始碼的閱讀時，問我大概多久的時間能吃懂spring原始碼，我給了一個答案是1

阿里頂級Java架構師，教你這樣手寫Spring！

人見人愛的Spring已然不僅僅只是一個框架了。如今，Spring已然成為了一個生態。但深入瞭解Spring的卻寥寥無幾。這裡，我帶大家一起來看看，我是如何手寫Spring的。我將結合對Spring十多年的研究經驗，用不到400行程式碼來描述SpringIOC、DI、MVC的精華設計思想，並保證基本

一個老程序員是如何手寫Spring MVC的

c4c class 介紹圖片用戶 stp 使用輸入功能人見人愛的Spring已然不僅僅只是一個框架了。如今，Spring已然成為了一個生態。但深入了解Spring的卻寥寥無幾。這裏，我帶大家一起來看看，我是如何手寫Spring的。我將結合對Spring十多年的研究

spring事物(2)-----手寫spring註解事務&&事務傳播行為

一，spring事務的註解

1.1，spring自帶的@Transactional例子

1.2，自定義註解案例

1.3，手寫spring註解事務

二：事務的傳播行為

spring事物(2)-----手寫spring註解事務&&事務傳播行為

Spring學習之——手寫Spring原始碼V2.0(實現IOC、DI、MVC、AOP)

手寫spring事務（註解版本）

手寫Spring註解事務（利用AOP技術 + 註解 + Spring程式設計式事務）

手寫Spring事務註解框架【視訊教程】

基於註解方式純手寫spring-ioc

Spring系列之手寫註解與配置檔案的解析

手寫Spring之IOC基於註解動態建立物件

手寫Spring MVC框架（包含Java註解的實現）

純手寫Spring IoC容器之自定義註解實現

手寫Spring事務框架

手寫 Spring 事務、IOC、DI 和 MVC

阿裏微服務專家手寫Spring Boot 實現一個簡單的自動配置模塊

我是這樣手寫Spring的，麻雀雖小，五臟俱全

我是這樣手寫Spring的，麻雀雖小五臟俱全

帶你手寫spring：IOC與DI

阿里頂級Java架構師，教你這樣手寫Spring！

一個老程序員是如何手寫Spring MVC的

一個老程式設計師是如何手寫Spring MVC的？

分享我是如何手寫Spring MVC全過程

spring事物(2)-----手寫spring註解事務&&事務傳播行為

一，spring事務的註解

1.1，spring自帶的@Transactional例子

1.2，自定義註解案例

1.3，手寫spring註解事務

二：事務的傳播行為

相關推薦