JDK动态代理实现自己的事务管理器

spring aop介绍

spring提供了五种通知类型
  • Interception Around
    JointPoint前后调用,实现此类需要实现接口MethodInterceptor。
  • Before通知
    需要实现接口MethodBeforeAdvice。
  • After Returning 通知
    需要实现接口AfterReturningAdvice。
  • Throw通知
    需要实现接口ThrowsAdvice
  • Introduction通知
    需要实现接口IntroductionAdvisor和IntroductionInterceptor。

怎样实现自己的事务管理器

  • 定义业务service接口
package com.july.testspring.transaction;

public interface StudentService {
    public boolean insert(StudentDemo demo);

    public boolean insert2(StudentDemo studentDemo);
}
  • 定义DO类
package com.july.testspring.transaction;

import java.io.Serializable;

public class StudentDemo implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private int id;
    
    private String name;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "StudentDemo [id=" + id + ", name=" + name + "]";
    }
    
}
  • 业务service接口实现
package com.july.testspring.transaction;

public class StudentServiceImpl implements StudentService {

    @Override
    public boolean insert(StudentDemo demo) {
        System.out.println("insert success!");
        return true;
    }

    @Override
    public boolean insert2(StudentDemo studentDemo) {
        System.out.println(1/0);
        return false;
    }
}
  • 定义Advice通知类
package com.july.testspring.transaction;

import java.lang.reflect.Method;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.util.StringUtils;

public class MyTransactionInterceptor implements MethodInterceptor {
    
    final ThreadLocal<TransactionInfo> transactionThread = new ThreadLocal<TransactionInfo>();

    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        
        
        Class targetClass = (methodInvocation.getThis() != null) ? methodInvocation.getThis().getClass() : null;
        //
        if(methodInvocation.getMethod().getName().equals("toString")) {
            return "";
        }
        
        //begin Transaction
        TransactionInfo txInfo = createTransactionIfNecessary(methodInvocation.getMethod(), methodInvocation);
        Object retVal = null;
        try {
            retVal = methodInvocation.proceed();
        }catch (Throwable e) {
            //回滚相关事务  父类或子类实现
            doCloseTransactionAfterThrowing(geTransactionInfo(), e);
            throw e;
        } finally {
            //设置transaction 状态
            TransactionInfo info = geTransactionInfo();
            info.setSuccessStatus(StatusType.SUCCESS);
            doFinally(info);
        }
        //commit
        doCommitTransactionAfterReturning(geTransactionInfo());
        return retVal;
    }
    
    
    private void doFinally(TransactionInfo transactionInfo) {
        setTransactionInfo(transactionInfo);
    }

    private void doCommitTransactionAfterReturning(com.july.testspring.transaction.TransactionInfo geTransactionInfo) {
        System.out.println("docommit");
    }

    private void doCloseTransactionAfterThrowing(com.july.testspring.transaction.TransactionInfo geTransactionInfo,
            Throwable e) {
        System.out.println("rollback transaction");
        
    }

    private com.july.testspring.transaction.TransactionInfo createTransactionIfNecessary(Method method,
            MethodInvocation methodInvocation) {
        System.out.println("begin transation");
        TransactionInfo transactionInfo = new TransactionInfo();
        setTransactionInfo(transactionInfo);
        return transactionInfo;
    }

    public TransactionInfo geTransactionInfo() {
        return transactionThread.get();
    }
    
    public void setTransactionInfo(TransactionInfo transactionInfo) {
        transactionThread.set(transactionInfo);
    }
}
  • JDK动态代理InvocationHandler，实现InvocationHandler接口。

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.Advised;

public class ProxyFactory implements InvocationHandler {
    
    public Object target;
    
    Advice advisor = (Advice) new MyTransactionInterceptor();
    
    public ProxyFactory(Object target) {
        this.target = target;
    }
    
    
    
    /*private static class ProxyFactoryClient {
        private static final ProxyFactory PROXY_FACTORY = new ProxyFactory();
    }*/
    
    /**
     * 创建代理
     * 
     * @param classzz
     * @return
     */
    public <T> T createProxy(Class<?> target) {
        return (T) Proxy.newProxyInstance(getClassLoader(),getMethodInterceptor(target), this);
    }

    private Class[] getMethodInterceptor(Class<?> target) {
        return target.getInterfaces();
    }



    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation methodInvocation = new TransactionMethodInvocation(args, target, method, this.advisor);
        return methodInvocation.proceed();
    }
    
    
    
    private ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }
    
}
  • 实现MethodInvocation接口 TransactionMethodInvocation
package com.july.testspring.transaction;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.List;

import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.Advisor;

public class TransactionMethodInvocation implements MethodInvocation{
    
    protected Object[] arguments;
    
    protected final Object target;

    protected final Method method;
    
    Advice interceptorsAndDynamicMethodMatchers;
    
    private int currentInterceptorIndex = -1;

    public TransactionMethodInvocation(Object[] arguments,Object target,Method method,Advice interceptorsAndDynamicMethodMatchers) {
        this.arguments = arguments;
        this.target = target;
        this.method = method;
        this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
    }
    
    @Override
    public Object[] getArguments() {
        return this.arguments;
    }

    @Override
    public AccessibleObject getStaticPart() {
        return this.method;
    }

    @Override
    public Object getThis() {
        return this.target;
    }

    @Override
    public Object proceed() throws Throwable {
        if(++currentInterceptorIndex == 1) {
             return this.method.invoke(this.target, this.arguments);
        }
        return ((MethodInterceptor) interceptorsAndDynamicMethodMatchers).invoke(this);
    }

    @Override
    public Method getMethod() {
        return this.method;
    }

}
  • 定义TransactionInfo 事务相关信息

import java.util.concurrent.atomic.AtomicLong;

public class TransactionInfo {
    //1 成功  0 失败
    private volatile int status = 0;
    
    private final AtomicLong atomicLong = new AtomicLong();
    
    public void setSuccessStatus(StatusType type) {
        if(type.getCode() != status) {
            atomicLong.compareAndSet(0, type.getCode());
        }
    }
    
    public void setFailStatus(StatusType type) {
        if(type.getCode() != status) {
            atomicLong.compareAndSet(1, type.getCode());
        }
    }
}
  • 测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.july.testspring.service.UserService;
import com.july.testspring.service.impl.UserServiceImpl;

public class Test {
    
    public static void main(String[] args) {
        StudentService userService2 = new ProxyFactory(new StudentServiceImpl()).createProxy(StudentServiceImpl.class);
        System.out.println("开始执行insert方法");
        System.out.println("方法返回值 ： " + userService2.insert(new StudentDemo()));
        
        System.out.println("====================================");
        
        System.out.println("开始执行insert2方法");
        System.out.println(userService2.insert2(new StudentDemo()));
    }
}
  • 运行结果
begin transation
insert success!
docommit
方法返回值 ： true
====================================
开始执行insert2方法
begin transation
rollback transaction
Exception in thread "main" java.lang.reflect.UndeclaredThrowableException
    at com.sun.proxy.$Proxy0.insert2(Unknown Source)
    at com.july.testspring.transaction.Test.main(Test.java:26)
Caused by: java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.july.testspring.transaction.TransactionMethodInvocation.proceed(TransactionMethodInvocation.java:49)
    at com.july.testspring.transaction.MyTransactionInterceptor.invoke(MyTransactionInterceptor.java:26)
    at com.july.testspring.transaction.TransactionMethodInvocation.proceed(TransactionMethodInvocation.java:51)
    at com.july.testspring.transaction.ProxyFactory.invoke(ProxyFactory.java:51)
    ... 2 more
Caused by: java.lang.ArithmeticException: / by zero
    at com.july.testspring.transaction.StudentServiceImpl.insert2(StudentServiceImpl.java:13)
    ... 10 more
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,981评论 19赞 139
  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,970评论 6赞 342
  • JDK动态代理以及Spring AOP使用介绍
    0.前言 本文主要想阐述的问题如下：什么动态代理（AOP）以及如何用JDK的Proxy和InvocationHan...
    SYFHEHE阅读 2,321评论 1赞 7
  • Spring中常见面试题
    什么是Spring Spring是一个开源的Java EE开发框架。Spring框架的核心功能可以应用在任何Jav...
    jemmm阅读 16,561评论 1赞 133
  • spring事务管理
    对大多数Java开发者来说，Spring事务管理是Spring应用中最常用的功能，使用也比较简单。本文主要从三个方...
    sherlockyb阅读 3,238评论 0赞 18