Spring事务管理

发表于 2018-04-17

Spring事务管理概述

事务隔离级别

隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：

TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED，MySQL InnoDB 存储引擎隔离级别为 Repeatable Read。
TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

事务传播行为

事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

Spring事务使用方式

Spring提供了对编码式和声明式事务管理的支持，Spring对事务管理是通过事务管理器来实现的

编程式事务：指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。使用TransactionTemplate或者直接使用底层的PlatformTransactionManager做事务管理。
声明式事务：其本质是对方法前后进行拦截(AOP)，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务优点：不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中;

声明式事务缺点：声明式的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别

事务管理器(`org.springframework.*`)	使用场景
`DataSourceTransactionManager`	提供对单个`javax.sql.DataSource`事务管理，用于Spring JDBC抽象框架、iBATIS或MyBatis框架的事务管理；
`JpaTransactionManager`	提供对单个`javax.persistence.EntityManagerFactory`事务支持，用于集成JPA实现框架时的事务管理；
`JtaTransactionManager`	提供对分布式事务管理的支持，并将事务管理委托给Java EE应用服务器事务管理器；

编程式事务

Spring提供了线程安全的TransactionTemplate模板类来处理不变的事务管理逻辑，将变化的部分抽象为回调接口TransactionCallback供用户自定义数据访问逻辑

<!-- 数据源配置 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="#{jdbc['jdbc.driverClassName']}"/>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
<!--事务模板 -->  
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
    <property name="transactionManager" ref="transactionManager"/>  
    <!--ISOLATION_DEFAULT 表示由使用的数据库决定  -->  
    <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>  
    <!-- 事务传播方式 -->  
    <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED" />  
    <!-- <property name="timeout" value="30"/> -->  
</bean>

示例：

public class ServiceImpl {
  
	@autowried
	private TransactionTemplate template;
  
	public void addElement(final Element ele) {
		template.execute(new TransactionCallbackWithoutResult() {
			protected void doInTransactionWithoutResult(TransactionStatus status){
                    // 数据库操作1
                    // 数据库操作2
			}
		});
	}
}

根据默认规则，如果在执行回调方法的过程中抛出了未检查异常(继承自RuntimeException的异常)，或者显式调用了TransacationStatus.setRollbackOnly() 方法，则回滚事务；如果事务执行完成或者抛出了 checked 类型的异常，则提交事务。

不管是使用哪种方式，数据源、事务管理器都是必须的，一般通过XML的Bean配置

声明式事务(常用)

声明式事务可以分为2种：基于XML配置的事务管理或基于注解的事务管理，都是基于AOP实现

基于XML配置的事务管理

   <!-- 数据源配置 -->
   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
         <property name="driverClass" value="#{jdbc['jdbc.driverClassName']}"/>
   </bean>
   <!-- 配置事务管理器 -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource" />
   </bean>
   <!-- 配置事务属性：传播行为、隔离级别、只读、超时时间回滚-->
<tx:advice id="txAdvice" transaction-manager="txManager">
   	<tx:attributes>
   		<tx:method name="create*" propagation="REQUIRED" timeout="300" rollback-	for="java.lang.Exception" />
 		</tx:attributes>
</tx:advice>
   <!-- 配置事务切入点。并把事务切入点与事务属性关联起来 -->
<aop:config>
 		<aop:pointcut id="txPointcut" expression="execution(* com.zsr.test.transaction.service.*ServiceImpl.*(..))" />
 		<aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice" />
</aop:config>

示例：

@Service
public class ServiceImpl implements IService {
	public int createTicket(String isbn) {
		// do something
	}

基于注解的事务管理

通过@Transactional对需要事务增强的Bean接口、实现类或方法进行标注，在容器中配置以启用基于注解的声明式事务。。注解所提供的事务属性信息与XML配置中的事务信息基本一致，只不过是另一种形式的元数据而已

<!-- 数据源配置 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="#{jdbc['jdbc.driverClassName']}"/>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
   <!-- 开启注解方式配置事物 -->
   <tx:annotation-driven transaction-manager="transactionManager"/>

注意：当<tx:annotation-driven/>标签在不指定transaction-manager属性的时候，会默认寻找id固定名为transactionManager的bean作为事务管理器，如果没有id为transactionManager的bean并且在使用@Transactional注解时也没有指定value（事务管理器），程序就会报错

示例：

@Transactional
public class ServiceImpl {
	private DaoA daoA;
	public void addElement(final Element ele) {
		...
	}
}

@Transactional可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，也可以在方法级别使用该标注来覆盖类级别的定义

`Spring @Transactional`的注意事项

@Transactional 注解只被应用到 public 可见度的方法上。如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错，但是这个被注解的方法将不会展示已配置的事务设置。

1
2
3

（1）对于基于接口动态代理的AOP事务增强来说，由于接口的方法是public的，这就要求实现类的实现方法必须是public的（不能是protected，private等），同时不能使用static的修饰符。所以，可以实施接口动态代理的方法只能是使用“public”或“public final”修饰符的方法，其它方法不可能被动态代理，相应的也就不能实施AOP增强，也即不能进行Spring事务增强。
（2）基于CGLib字节码动态代理的方案是通过扩展被增强类，动态创建子类的方式进行AOP增强植入的。由于使用final,static,private修饰符的方法都不能被子类覆盖，相应的，这些方法将不能被实施的AOP增强。

Spring团队的建议在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。当然也可以在接口上使用 @Transactional 注解，但是这将只能当你设置了基于接口的代理时它才生效。因为注解是不能继承的，这就意味着如果你正在使用基于类的代理时(cglib)，那么事务的设置将不能被基于类的代理所识别，而且对象也将不会被事务代理所包装。因此，建议并且在具体的类火方法上使用 @Transactional 注解。
@Transactional 的事务开启，在同一个类中一个方法调用另一个有事务的方法，事务是不会起作用的。
@Transactional 注解标注的方法中不要出现网络调用、比较耗时的处理程序，因为，事务中数据库连接是不会释放的，如果每个事务的处理时间都非常长，那么宝贵的数据库连接资源将很快被耗尽。
Spring使用声明式事务处理，默认情况下，如果操作方法中发生了unchecked异常，所有的操作将rollback；如果发生的异常是checked异常，默认情况下数据库操作还是会提交的。

参考

全面分析 Spring 的编程式事务管理及声明式事务管理

Spring的声明式事务和编程式事务详解

spring事务管理

Spring @Transactional原理及使用

jdk动态代理分析

发表于 2018-04-08

1	疑问：JDK的动态代理为什么不支持对类的代理，只支持接口的代理？

`jdk`动态代理实例

服务接口

package com.zsr.test.proxy;
public interface Hello {
  public void say(String someThing);
}

接口实现类

package com.zsr.test.proxy;
public class HelloImpl implements Hello {
  @Override
  public void say(String someThing) {
    System.out.println("Hello: " + someThing);
  }
}

调用处理类

package com.zsr.test.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class HelloInvocationHandle implements InvocationHandler {
  private Object target;
  public HelloInvocationHandle(Object target) {
    this.target = target;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("Before invocation");
    Object ret = method.invoke(target, args);
    System.out.println("after invocation");
    return ret;
  }
}

运行测试

package com.zsr.test.proxy;
import java.lang.reflect.Proxy;
public class HelloProxyTest {
  public static void main(String[] args) {
    Hello hello = new HelloImpl();
    HelloInvocationHandle helloInvocationHandler = new HelloInvocationHandle(hello);
    // 通过Proxy.newProxyInstance生成代理对象
    Hello helloProxy = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(), hello.getClass().getInterfaces(),
            helloInvocationHandler);
    // 调用say方法
    helloProxy.say("test");
  }
}

结果：

1
2
3

Before invocation
Hello: test
after invocation

`Proxy.newProxyInstance`分析

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /*
         * 动态生成Class的地方，重点是看这里面的方法
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * 获取代理类的实例  
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } 
}

生成代理类Class

 private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        
        // JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，
        // 否则才会通过ProxyClassFactory来创建代理  
        return proxyClassCache.get(loader, interfaces);
    }
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

代理类Class工厂

private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // 所有代理类名字的前缀
        private static final String proxyClassNamePrefix = "$Proxy";
        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();
        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
            ......
            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            // 默认情况下，代理类的完全限定名为：
            // com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1依次递增
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            // ** 生成代理类字节码的地方 ** //
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces);
            try {
               // 根据二进制字节码返回相应的Class实例  
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

反编译代理类

修改测试HelloProxyTest

public class HelloProxyTest {
  public static void main(String[] args) {
    
  //设置为true,会在工程根目录生成$Proxy0.class代理类（com.sun.proxy.$Proxy0.class）
    System.getProperties().put(
        "sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    Hello hello = new HelloImpl();
    HelloInvocationHandle helloInvocationHandler = new HelloInvocationHandle(hello);
    // 通过Proxy.newProxyInstance生成代理对象
    Hello helloProxy = (Hello) Proxy.newProxyInstance(Hello.class.getClassLoader(), hello.getClass().getInterfaces(),
            helloInvocationHandler);
    // 调用say方法
    helloProxy.say("test");
  }
}

注意，当把saveGeneratedFiles属性设置为true时，生成的class文件及其所在的路径都需要提前创建，否则会抛出FileNotFoundException异常；即要在运行当前main方法的路径下创建com/sun/proxy目录，并创建一个$Proxy0.class文件

反编译文件$Proxy0.class

package com.sun.proxy;
import com.zsr.test.proxy.Hello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
// ** 注意这里代理类实现了接口 ** //
public final class $Proxy0 extends Proxy
  implements Hello
{
  private static Method m1;
  private static Method m0;
  private static Method m3;
  private static Method m2;
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final void say(String paramString)
    throws 
  {
    try
    {
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m3 = Class.forName("com.zsr.test.proxy.Hello").getMethod("say", new Class[] { Class.forName("java.lang.String") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

显而易见，动态生成的代理类有如下特性：

继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
代理类实现代理接口的say方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

参考

JDK动态代理源码分析

消息feed系统研究

发表于 2018-03-27

LRUMap

发表于 2018-03-21

无锁hashMap

发表于 2018-03-14