Introduction to Spring framework -- Spring transaction

When integrating mysql, the transaction is proposed. Transaction refers to a set of sql statements. There are multiple sql statements in the set, which may be insert, update, select or delete. We hope that these multiple sql statements succeed or fail at the same time. The execution results of these sql statements are consistent and executed as a whole.

When the operation involves multiple tables or multiple sql statements, second, we need to ensure that these statements are successful to complete my function or fail to ensure that the operation meets the requirements.

How JDBC accesses the database and handles transactions:

Connection conn; conn.commit(); conn.rollback();

How mybatis accesses the database and handles transactions:

SqlSession.commit(); SqlSession.rollback();

hibernate accesses the database and handles transactions in the following ways:

Session.commit(); Session.rollback();

It can be seen from the above that different database access technologies have different objects and methods to deal with transactions. Therefore, it is necessary to understand the principle of transactions used by different database access technologies; We also need to master the transaction processing logic and various methods of processing transactions in a variety of databases. That is, a variety of database access technologies have different transaction processing mechanisms, objects and methods.

5.1.2 transaction management in spring

In the first mock exam, Spring provides a unified model for transaction processing, which can accomplish transaction processing of different database access technologies by unified steps. It is equivalent to using the transaction processing mechanism of spring, which can complete both the transaction processing of mybatis accessing the database and the transaction processing of hibernate accessing the database.

Transaction was originally a concept in the database, at the Dao layer. However, in general, transactions need to be promoted to the business layer, that is, the Service layer. This is done in order to be able to use the characteristics of transactions to manage specific businesses. In Spring, transaction management can be implemented in the following two ways:

① Manage transactions using Spring's transaction annotations

② Manage transactions using AspectJ's AOP configuration

5.2 API of spring transaction management

The steps of Spring's transaction processing model are fixed. Just provide the information used by transactions to Spring.

5.2.1 transaction manager

Spring commits and rolls back transactions internally, using the transaction manager object instead of completing commit and rollback.

The transaction manager is an interface and its many implementation classes.

PlatformTransactionManager interface object: mainly used to complete transaction submission, rollback, and acquisition

Status information.

The PlatformTransactionManager interface has two common implementation classes:

① Data source transaction manager: used when using JDBC or MyBatis for database operations.

② Hibernate transaction manager: used when using hibernate to persist data.

Usage: you need to tell spring what kind of database access count you use, declare the transaction manager implementation class corresponding to the database access count, and use the < bean > declaration in the spring configuration file.

5.2.2 transaction definition interface

The transaction definition interface, TransactionDefinition, defines three types of constants related to transaction description: transaction isolation level, transaction propagation behavior, transaction default timeout, and their operations.

1. Transaction ISOLATION level: there are 4 values. These constants are based on ISOLATION_ At the beginning, it is like ISOLATION_XXX.

① DEFAULT: the DEFAULT transaction isolation level of DB is adopted. MySql defaults to REPEATABLE_READ； Oracle

The default is READ_COMMITTED.

②READ_UNCOMMITTED: read uncommitted. No concurrency issues were resolved.

③READ_COMMITTED: read committed. Solve dirty reading, there are non repeatable reading and unreal reading.

④REPEATABLE_READ: repeatable. Solve dirty reading, non repeatable reading and phantom reading.

⑤ SERIALIZABLE: serialization. There is no concurrency problem.

2. Transaction PROPAGATION behavior: refers to the maintenance of transactions during execution when methods in different transactions call each other. For example, when the method doSome() in transaction A calls the method doOther() in transaction B, the maintenance of the transaction during the call execution is called transaction PROPAGATION behavior. Transaction PROPAGATION behavior is added to the method. Transaction PROPAGATION behavior constants are based on PROPAGATION_ Start with the shape of promotion_ XXX.

①PROPAGATION_REQUIRED: the specified method must be executed within a transaction. If there is a transaction, join it

To the current transaction; If there is no current transaction, a new transaction is created. This communication behavior is the most common choice and

Spring default transaction propagation behavior.

②PROPAGATION_SUPPORTS: the specified method supports the current transaction, but if there is no current transaction, you can also use the

Non transactional execution.

③PROPAGATION_REQUIRES_NEW: always create a new transaction. If there is a current transaction, the current transaction will be deleted

The transaction is suspended until the new transaction is completed.

④PROPAGATION_MANDATORY

⑤PROPAGATION_NESTED

⑥PROPAGATION_NEVER

⑦PROPAGATION_NOT_SUPPORTED

3. Transaction timeout: constant TIMEOUT_DEFAULT defines the default timeout period at the bottom of the transaction and the execution time of sql statements. Indicates the longest execution time of a method. If the execution time of the method exceeds the time, the transaction will be rolled back. The unit is seconds, integer value, and the default is - 1.

5.2.3 timing of spring committing and rolling back transactions

① When your business method is executed successfully and no exception is thrown, spring will automatically commit the transaction after the method is executed. (transaction manager commit)

② When your business method throws a runtime exception or ERROR, spring executes rollback (transaction manager rollback). Definition of runtime exception: RuntimeException and its subclasses, such as NullPointException and NumberFormatException.

③ Commit a transaction when your business method throws a non runtime exception, mainly a checked exception (compile time exception). Checked exception: exceptions that must be handled in code, such as IOException and SQLException.

5.2.4 summarizing Spring transactions

1. It is the transaction manager and its implementation classes that manage transactions.

The first mock exam of 2.Spring is a unified model.

① Specify the transaction manager implementation class to use, using < bean >;

② Specify which classes and methods need to be added to the transaction function;

③ Specify the isolation level, propagation behavior, timeout required by the method.

5.3 instance (Spring instance is not used yet)

5.3.1 creating database tables

1. Sales table

2.goods list

Add data manually:

5.3.2 add dependencies to Maven's pom.xml file

<dependencies>
    <!--unit testing -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
    <!--spring core ioc-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
    <!--do spring Used in transactions-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
    <!--do spring Used in transactions-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
    <!--mybatis rely on-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>
    <!--mybatis and spring Integrated dependencies-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>
    <!--mysql drive-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.9</version>
    </dependency>
    <!--Alibaba's database connection pool-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.12</version>
    </dependency>
</dependencies>

5.3.3 create entity class

package com.bjpowernode.domain;

public class Goods {
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;

    public Goods() {
    }

    public Goods(Integer id, String name, Integer amount, Float price) {
        this.id = id;
        this.name = name;
        this.amount = amount;
        this.price = price;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", amount=" + amount +
                ", price=" + price +
                '}';
    }
}

package com.bjpowernode.domain;

public class Goods {
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;

    public Goods() {
    }

    public Goods(Integer id, String name, Integer amount, Float price) {
        this.id = id;
        this.name = name;
        this.amount = amount;
        this.price = price;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", amount=" + amount +
                ", price=" + price +
                '}';
    }
}

5.3.4 define dao interface and corresponding mapper file

package com.bjpowernode.dao;

import com.bjpowernode.domain.Goods;

public interface GoodsDao {
    //Update inventory
    //goods indicates the product information, id and purchase quantity purchased by the user this time
    int updateGoods(Goods good);

    //Query commodity information
    Goods selectGoods(Integer id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.GoodsDao">
    <select id="selectGoods" resultType="com.bjpowernode.domain.Goods">
        select id,name,amount,price from goods where id=#{gid}
    </select>
    <update id="updateGoods">
        update goods set amount = amount - #{amount} where id=#{id}
    </update>
</mapper>

package com.bjpowernode.dao;

import com.bjpowernode.domain.Sale;

public interface SaleDao {
    //Add sales record
    int insertSale(Sale sale);

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.SaleDao">
    <insert id="insertSale">
        insert into sale(gid,nums) values (#{gid},#{nums})
    </insert>
</mapper>

5.3.5 defining exception classes

Define the exception class notenoughexception that may be thrown by the service layer (the number of goods may not be enough).

package com.bjpowernode.excep;

//Custom runtime exception
public class NotEnoughException extends RuntimeException {
    public NotEnoughException() {
        super();
    }

    public NotEnoughException(String message) {
        super(message);
    }
}

5.3.6 define service interface and its implementation class

package com.bjpowernode.service;

public interface BuyGoodsService {
    //Method of purchasing goods, goodsId: number of purchased goods, Num: quantity purchased
    void buy(Integer goodsId,Integer nums);
}

package com.bjpowernode.service.impl;

import com.bjpowernode.dao.GoodsDao;
import com.bjpowernode.dao.SaleDao;
import com.bjpowernode.domain.Goods;
import com.bjpowernode.domain.Sale;
import com.bjpowernode.excep.NotEnoughException;
import com.bjpowernode.service.BuyGoodsService;

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }

    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("===buy Start of method===");
        //Record sales information and add records to the sales table
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);
        //Update inventory
        Goods goods = goodsDao.selectGoods(goodsId);
        if(goods == null){
            //Item does not exist
            throw new NullPointerException("The number is:" + goodsId + "，Item does not exist");
        }else if(goods.getAmount() < nums){
            //Insufficient inventory of purchased goods
            throw new NotEnoughException("The number is:" + goodsId + "，Insufficient inventory of goods");
        }
        //Modify inventory
        Goods buyGoods = new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
        System.out.println("===buy Method completion===");
    }
}

5.3.7 MyBatis configuration file

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--Set alias-->
    <typeAliases>
        <!--name: Package name of entity class-->
        <package name="com.bjpowernode.domain"/>
    </typeAliases>

    <!--sql mapper(sql Location of the mapping file)-->
    <mappers>
        <!--
            name: Is the package name. All the mapper.xml It can be loaded at one time
        -->
        <package name="com.bjpowernode.dao"/>
    </mappers>
</configuration>

5.3.8 Spring configuration file

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        Write the configuration information of the database in an independent file to modify the configuration content of the database
        spring know jdbc.properties File location
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--Declare data source DataSource，The function is to connect to the database-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set injection DruidDataSource Provides information about linked databases-->
        <!--
            Use the data in the property configuration file, syntax ${key}
        -->
        <property name="url" value="${jdbc.url}"/><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}"/>
        <property name="maxActive" value="${jdbc.max}"/>
    </bean>

    <!--statement mybatis Provided in SqlSessionFactoryBean Class, which is created internally SqlSessionFactory of
        SqlSessionFactory sqlSessionFactory = new ...
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set Injection, assigning the database connection pool to dataSource attribute-->
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis Location of the master profile
            configLocation Property is Resource Type, read configuration file
            Its assignment, using value，Specify the path to the file, using classpath: Indicates the location of the file
        -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>

    <!--establish dao Objects, using SqlSession of getMapper(StudentDao.class)
        MapperScannerConfigurer: Call internally getMapper()Generate each dao Proxy object for the interface.
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--appoint SqlSessionFactory Object id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--Specify the package name, which is dao Package name of the interface
            MapperScannerConfigurer It will scan all interfaces in the package and execute each interface
            once getMapper()Method to get the of each interface dao object
            Created dao Object into spring In the container.  dao The default name of an object is the lowercase initial of the interface name
        -->
        <property name="basePackage" value="com.bjpowernode.dao"/><!--Multiple packages can be used,Comma separated-->
    </bean>

    <!--statement service object-->
    <bean id="buyGoodsService" class="com.bjpowernode.service.impl.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao"/>
        <property name="goodsDao" ref="goodsDao"/>
    </bean>
</beans>

5.3.9 testing

public class MyTest {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //Get service from container
        BuyGoodsService service = (BuyGoodsService) applicationContext.getBean("buyGoodsService");

        //Call method
        service.buy(1001,20);

    }
}

5.4 managing transactions using Spring's transaction annotations

5.4.1 @Transactional annotation

Through @ Transactional annotation, transactions can be woven into corresponding public methods to realize transaction management. The spring framework uses aop to implement the function of adding transactions to business methods, and uses @ Transactional annotation to add transactions@ The Transactional annotation is the spring framework's own annotation, which is placed above the public method to indicate that the current method has transactions. Assign a value to the attribute of the annotation to indicate the specific isolation level, propagation behavior, exception information, etc.

@ All optional properties of Transactional:

① Propagation: used to set transaction propagation properties. The property type is propagation enumeration, and the default value is

Propagation.REQUIRED.

② Isolation: used to set the isolation level of transactions. The property type is isolation enumeration, and the default value is

Isolation.DEFAULT.

③ readOnly: used to set whether the operation of this method on the database is read-only. The attribute is boolean, and the default is

false.

④ Timeout: used to set the timeout period for the connection between this operation and the database. The unit is seconds, the type is int, and the default value is - 1,

That is, there is no time limit.

⑤ rollbackFor: Specifies the exception Class that needs to be rolled back. The type is Class [], and the default value is an empty array. Of course, if there is only one

When an exception class, you can not use an array.

⑥ rollbackForClassName: Specifies the name of the exception class that needs to be rolled back. The type is String [], and the default value is an empty array.

Of course, if there is only one exception class, you can not use an array.

⑦ noRollbackFor: Specifies the exception Class that does not need to be rolled back. The type is Class [], and the default value is an empty array. Of course, if only

When there is an exception class, you can not use an array.

⑧ noRollbackForClassName: Specifies the name of the exception class that does not need to be rolled back. The type is String [], and the default value is null

Group. Of course, if there is only one exception class, you can not use an array.

It should be noted that @ Transactional can only be used on public methods if it is used on methods. For other non-public methods, if the annotation @ Transactional is added, although Spring will not report an error, it will not weave the specified Transaction into the method. Because Spring ignores the @ Transaction annotation on all non public methods. If @ Transaction is annotated on a class, it means that all methods on the class will be woven into the Transaction at execution time.

5.4.2 declaration transaction manager

Declare the transaction manager in the Spring configuration file applicationContext.xml.

<!--use spring Transaction processing for-->
<!--1.Claim transaction manager-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--You need to know the information of the connected database and specify the data source-->
    <property name="dataSource" ref="myDataSource"/>
</bean>

5.4.3 Enable annotation driven

Transaction manager: id of the transaction manager bean.

<!--2.Turn on the transaction annotation driver and tell spring Use annotations to manage transactions and create proxy objects
    transaction-manager: Of the transaction manager object id
-->
<tx:annotation-driven transaction-manager="transactionManager"/>

5.4.4 Add transaction attributes to the public method of the business layer

package com.bjpowernode.service.impl;

import com.bjpowernode.dao.GoodsDao;
import com.bjpowernode.dao.SaleDao;
import com.bjpowernode.domain.Goods;
import com.bjpowernode.domain.Sale;
import com.bjpowernode.excep.NotEnoughException;
import com.bjpowernode.service.BuyGoodsService;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;


public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }


    /**
     *
     *  rollbackFor: Indicates that the specified exception must be rolled back
     *      Processing logic:
     *          1)spring The framework will first check whether the exception thrown by the method is in the property value of rollbackFor
     *            If the exception is in the rollbackFor list, no matter what type of exception it is, it must be rolled back.
     *          2)If the exception you throw is no longer in the rollbackFor list, spring will judge whether the exception is a RuntimeException,
     *            If yes, it must be rolled back.
     */
    /*@Transactional(propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                  NullPointerException.class,NotEnoughException.class
            }
            )*/
    //The DEFAULT value of transaction control is used. The DEFAULT propagation behavior is REQUIRED and the DEFAULT isolation level is DEFAULT
    //By default, a runtime exception is thrown and the transaction is rolled back.
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("===buy Start of method===");
        //Record sales information and add records to the sales table
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);
        //Update inventory
        Goods goods = goodsDao.selectGoods(goodsId);
        if(goods == null){
            //Item does not exist
            throw new NullPointerException("The number is:" + goodsId + "，Item does not exist");
        }else if(goods.getAmount() < nums){
            //Insufficient inventory of purchased goods
            throw new NotEnoughException("The number is:" + goodsId + "，Insufficient inventory of goods");
        }
        //Modify inventory
        Goods buyGoods = new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
        System.out.println("===buy Method completion===");
    }
}

5.4.5 test code

public class MyTest {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //Get service from container
        BuyGoodsService service = (BuyGoodsService) applicationContext.getBean("buyGoodsService");

        //Call method
        service.buy(1001,200);//If the quantity is too large, an exception will be generated and rollback will occur

    }
}

5.4.6 summary

spring uses the aop mechanism to create the proxy object of the class where @ Transactional is located, and adds the transaction function to the method.

Before the execution of your business method, start the transaction first, commit or roll back the transaction after the execution of the business method, and use the aop ring

Bypass notification @ Around:

@ Around("business method name of the transaction function you want to add")

public Object myAround(){

Start the transaction and spring will start it for you

try{

buy(1001,10);

spring's transaction manager. commit();

}catch(Exception e){

spring's transaction manager. rollback();

}

The annotation scheme is suitable for small and medium-sized projects.

5.5 AOP configuration management transactions using AspectJ

It is suitable for large projects. There are many classes and methods, and a large number of configuration transactions are required. Use the aspectj framework function to declare the transactions required by classes and methods in the spring configuration file. In this way, the business method and transaction configuration are completely separated.

5.5.1 adding Aspectj dependency

<!--aspectj rely on-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

5.5.2 declaration transaction manager

<!--Declarative transaction: completely separate from source code-->
<!--1.Claim transaction manager-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="myDataSource"/>
</bean>

5.5.3 configuring transaction notifications

<!--2.Declare the transaction attributes of the business method (isolation level, propagation behavior, timeout)
    id: Custom name, indicating<tx:advice>and</tx:advice>Configuration content between
    transaction-manager: Of the transaction manager object id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--tx:attributes: Configure transaction properties-->
    <tx:attributes>
        <!--tx:method: Configure transaction attributes for specific methods, method There can be multiple methods to set transaction attributes for different methods
            name: Method name, 1)Complete method name without package and class
                           2)Method names can use wildcards*，Represents any character
            propagation: Propagation behavior, enumeration value
            isolation: Isolation level
            rollback-for: The exception class name you specified, the fully qualified class name. If an exception occurs, it must be rolled back.
        -->
        <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT" 
           rollback-for="java.lang.NullPointerException,com.bjpowernode.excep.NotEnoughException"/>
        <!--Use wildcards to specify many methods-->
        <tx:method name="add*" propagation="REQUIRES_NEW"/>
        <!--Specify modification method-->
        <tx:method name="modify*"/>
        <!--Specify the deletion method-->
        <tx:method name="remove*"/>
        <!--Query method, query，search，find-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
    </tx:attributes>
</tx:advice>

5.5.4 configuration of intensifier

<!--to configure aop-->
<aop:config>
    <!--Configure pointcut expression: specify which classes in which packages and methods to use
        id: The name and unique value of the pointcut expression
        expression: Pointcut expressions that specify which classes use transactions, aspectj The proxy object is created
        
        com.bjpowernode.service
        com.crm.service
        com.service
    -->
    <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

    <!--Configuring enhancers: associations advice and pointcut
        advice-ref: Notice, above tx:advice Configuration there
        pointcut-ref: Of pointcut expressions id
    -->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
</aop:config>

5.5.6 test code

public class MyTest {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //Get service from container
        BuyGoodsService service = (BuyGoodsService) applicationContext.getBean("buyGoodsService");
        //Service = com.sun.proxy. $proxy12 (dynamic proxy, AOP)
        System.out.println("service = " + service.getClass().getName());
        //Call method
        service.buy(1001,10);

    }
}

PS: sort out according to the power node course. If there is infringement, contact to delete it.

Tags: MySQL Spring Java framework Transaction

Posted on Tue, 02 Nov 2021 16:18:32 -0400 by spags

Programmer Help