This call when the transaction does not take effect

In business development , We call a service method of the same class in a class , Transaction failure found , The code is as follows ：

For example, an order is warehoused ：

public class OrderService implements IOrderService {

    @Override
    @Transactional
    public Boolean initOrder() {
        // Initial master order 

        return Boolean.TRUE;
    }
    private Boolean initProdcut(Long productId) {
        // Initialize the item corresponding to the order 
        return Boolean.TRUE;
    }
}

Method initProduct The transaction does not take effect , The scene appears as above .

First, by analyzing that the transaction does not take effect, the steps are as follows ：

1、 Check whether the storage engine is innodb.

2、 Check whether the transaction in the project is effective , Check whether the project correctly opens the transaction .

3、 Check whether the configuration is correct , Main inspection ：@Transactional Annotated rollbackFor The scope of the exception caught is smaller than the exception thrown by the code , Cause not to roll ; Set the... Of the transaction timeout Time , Code execution timed out , Cause the transaction to fail
; By @Transactional Annotation modifies the method , Modifier is not public Or be final modification . Aop There is no way to generate a proxy for it .

4、 Does the project exist this call .

Through analysis, it used to belong to the second 4 spot ; Then I'll pass JDK Dynamic proxy implementation code to analyze why it doesn't work . Check that the user is printing the calling method log while adding a new user , The code is as follows .

User interface ：

public interface IUserService {
    /**
     *  New users 
     * @return
     */
    public  Integer addUser();
    /**
     *  Check user information 
     * @return
     */
    public  Boolean checkUser();
}

The operation user realizes ：

public class UserService implements IUserService {


     @Override
    public Integer addUser() {
        System.out.println(" New users ");
        this.checkUser();
        return 0;
    }

    @Override
    public Boolean checkUser() {
        System.out.println(" Check users ");
        return Boolean.TRUE;
    }
}

Log processor ：

public class LogHanler implements InvocationHandler {

    private Object object;

    public LogHanler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(String.format(" Call method to start :[%s] ", method.getName()));

        Object result = method.invoke(object, args);  //  call  target  Of  method  Method 
        System.out.println(String.format(" End of method call [%s] ", method.getName()));
        return result;

    }
}

function ：

    public static void main(String[] args) {
        UserService userService = new UserService();
        LogHanler logHanler = new LogHanler(userService);
        ClassLoader classLoader = userService.getClass().getClassLoader();
        IUserService o = (IUserService)Proxy.newProxyInstance(classLoader, userService.getClass().getInterfaces(), logHanler);
        o.addUser();
    }

The operation results are as follows ：

 Call method to start :[addUser] 
 New users 
 Check users 
 End of method call [addUser] 

         A careful friend will find it No print call method checkUser. I'm adjusting the code , I pass the dynamic code class into UserService In service . At the same time, I was IUserService Add... In the interface setUserService , The code is adjusted as follows ：

User interface ：

public interface IUserService {
    /**
     *  New users 
     * @return
     */
    public  Integer addUser();
    /**
     *  Check user information 
     * @return
     */
    public  Boolean checkUser();
}

The operation user realizes :

public class UserService implements IUserService {

    private IUserService userService;

     @Override
    public Integer addUser() {
        System.out.println(" New users ");
        userService.checkUser();
        return 0;
    }

    @Override
    public Boolean checkUser() {
        System.out.println(" Check users ");
        return Boolean.TRUE;
    }
}

Run code adjustment ：

    public static void main(String[] args) {
        UserService userService = new UserService();
        LogHanler logHanler = new LogHanler(userService);
        ClassLoader classLoader = userService.getClass().getClassLoader();
        IUserService o = (IUserService)Proxy.newProxyInstance(classLoader, userService.getClass().getInterfaces(), logHanler);
        userService.setUserService(o);
        o.addUser();
    }

The operation results are as follows ：

 Call method to start :[setUserService] 
 End of method call [setUserService] 
 Call method to start :[addUser] 
 New users 
 Call method to start :[checkUser] 
 Check users 
 End of method call [checkUser] 
 End of method call [addUser] 

         The result is the same as we expected ,checkUser Is called the . In fact, I just pass the call instance to UserService In service . We're calling... At the same time addUser I used the proxy example I passed in to call checkUser Method , Used before this call .

          summary ：AOP The agent is the same method used this There is no dynamic proxy implementation , Cause the transaction not to take effect .