面试的时候，面试人员总喜欢问在spring中，
1. 如果一个主线程上有一个事务，在事务中开启了一个线程。子线程跑出异常，对主线程有没有影响，或者主线程产生异常对子线程有没有影响。
这个时候，你只要记住主线程和子线程是不同的事务即可回答上面的问题，主线程跑出异常肯定对子线程没有影响，但是子线程抛出异常对主线程有没有影响，那就要看，抛出的异常是否为事务回滚有需要的异常类型，
如果是肯定会回滚，如果不是就不会回滚。
2.主线程为啥和子线程是不同的事务（在所有的事务传播机制中）
因为 spring 中使用的ThreadLocal变量来保存 事务的执行者，entityManager。而ThreadLocal只能保证在当前线程中获取entityManager。所以主子线程肯定是不同的事务。
JpaTransactionObject txObject = new JpaTransactionObject(); txObject.setSavepointAllowed(isNestedTransactionAllowed()); //事务中的EntityManager 是从当前线程中获取 即ThreadLocal EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(obtainEntityManagerFactory()); if (emHolder != null) { if (logger.isDebugEnabled()) { logger.debug("Found thread-bound EntityManager [" + emHolder.getEntityManager() + "] for JPA transaction"); } txObject.setEntityManagerHolder(emHolder, false); } if (getDataSource() != null) {
//事务中connectionHolder也是从threadLocal中获取。 ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(getDataSource()); txObject.setConnectionHolder(conHolder); }
3.事务的同步
提到同步，首先想到的肯定是多线程。多线程肯定属于不同的事务，事务的同步就是解决多线程之间事务的同步问题。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void saveRequire(Customer customer) throws Exception {
//1.保存客户信息
repository.save(customer);
exectorService.execute(()->{
//2.发送短信或邮件
});
这个例子是 1.保存客户信息，2.发送短信或邮件--由于短信和邮件比较耗时，所以用异步进行操作。 要求：必须在保存客户信息成功后，发送短信和邮件。
上面例子的问题是，发送短信和邮件，执行时，可能在事务完成后执行，也可能在事务完成之前执行。
事务的同步：就是事务完成后，同时执行发送短信和邮件。
因此上面的例子可以更改为
@Transactional(propagation = Propagation.REQUIRED)
public void saveRequire(Customer customer) throws Exception {
//1.保存客户信息
repository.save(customer);
//判断当前事务是否激活
if (TransactionSynchronizationManager.isActualTransactionActive()) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
exectorService.execute(()->{
//2.发送短信或邮件
});
}
});
}else {
exectorService.execute(()->{
//2.发送短信或邮件
});
}
4.事务中的主要对象介绍。
TransactionInfo 事务的对象。
protected final class TransactionInfo { //事务管理器（获取事务） @Nullable private final PlatformTransactionManager transactionManager; //事务属性 （@Transactional(propagation = Propagation.REQUIRED)对应的这个注解的属性） @Nullable private final TransactionAttribute transactionAttribute; //标记@Transactional的类和方法组成的字符串（com.zhou.test.transaction_test.service.impl.User1ServiceImpl.saveRequire） private final String joinpointIdentification; //当前事务的状态（是否是新的事务，是否完成，是否有保存点，当前事务对象，当前被暂停的资源） @Nullable private TransactionStatus transactionStatus; @Nullable
//被暂停的事务（例如require_new 需要一个新的事务，老的事务会被挂起） private TransactionInfo oldTransactionInfo;
JpaTransactionObject 事务对象 （保存在 transactionStatus里面）
private class JpaTransactionObject extends JdbcTransactionObjectSupport { //jpa 操作数据库对象 @Nullable private EntityManagerHolder entityManagerHolder; private boolean newEntityManagerHolder; //可能是jpaTransactionObject（事务暂停） 可能是SavepointManager（netesd，同一个事务回滚到保存点） @Nullable private Object transactionData;
JpaTransactionManager.SuspendedResourcesHolder 暂停的对象
private static class SuspendedResourcesHolder { //数据源操作对象 private final EntityManagerHolder entityManagerHolder; //数据源操作对象 @Nullable private final ConnectionHolder connectionHolder;
TransactionSynchronization 事务的同步类 实现下面的方法，可以在事务执行对应操作时，增加对应的处理。
default void suspend() { } default void resume() { } @Override default void flush() { } default void beforeCommit(boolean readOnly) { } default void beforeCompletion() { } default void afterCommit() { } default void afterCompletion(int status) { }
AbstractPlatformTransactionManager.SuspendedResourcesHolder 暂停的资源
protected static class SuspendedResourcesHolder {
//被暂停的对象，（存放 connectionHolder，entityManagerHoler）
@Nullable
private final Object suspendedResources;
//存放当前事务同步的事件
@Nullable
private List<TransactionSynchronization> suspendedSynchronizations;
DefaultTransactionStatus 事务状态类。
public class DefaultTransactionStatus extends AbstractTransactionStatus { //当前事务对象（JPATransactionObject）。 @Nullable private final Object transaction; private final boolean newTransaction; private final boolean newSynchronization; private final boolean readOnly; private final boolean debug; //暂停的资源（AbstractPlatformTransactionManager.SuspendedResourcesHolder） @Nullable private final Object suspendedResources;
5.nested 中的保存点
依赖的connection 中保存点实现。回滚时，回滚到保存点。
6.事务的回滚原理
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) { if (txInfo != null && txInfo.getTransactionStatus() != null) { if (logger.isTraceEnabled()) { logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex); }
//根据注释transactionAttribute的rollbackFor属性判断此种异常是否回滚，如果找不到需要回滚的指定异常，就根据是否是父类中的RuntimeException和Error进行回滚 if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) { try { txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus()); } catch (TransactionSystemException ex2) { logger.error("Application exception overridden by rollback exception", ex); ex2.initApplicationException(ex); throw ex2; } catch (RuntimeException | Error ex2) { logger.error("Application exception overridden by rollback exception", ex); throw ex2; } }
private void processRollback(DefaultTransactionStatus status, boolean unexpected) { try { boolean unexpectedRollback = unexpected; try { triggerBeforeCompletion(status); if (status.hasSavepoint()) { if (status.isDebug()) { logger.debug("Rolling back transaction to savepoint"); }
//1.回滚的事务的保存点 status.rollbackToHeldSavepoint(); } else if (status.isNewTransaction()) { if (status.isDebug()) { logger.debug("Initiating transaction rollback"); }
//2.如果是新建的事务，直接回滚 doRollback(status); } else { // Participating in larger transaction if (status.hasTransaction()) { if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) { if (status.isDebug()) { logger.debug("Participating transaction failed - marking existing transaction as rollback-only"); }
//3.如果用的已经存在的事务，则标记事务为回滚，等回到主事务中进行回滚 doSetRollbackOnly(status); } else { if (status.isDebug()) { logger.debug("Participating transaction failed - letting transaction originator decide on rollback"); } } } else { logger.debug("Should roll back transaction but cannot - no transaction available"); } // Unexpected rollback only matters here if we're asked to fail early if (!isFailEarlyOnGlobalRollbackOnly()) { unexpectedRollback = false; } } }
事务的处理过程 ：TransactionInterceptor（只需关注事务拦截器即可。）
最后领着大家看下spring 的源码，事务的处理原理：
1.先熟悉下 JPA事务 可以去hibernatenate官网下载实例：https://github.com/hibernate/hibernate-demos
EntityManager entityManager = openEntityManager(); Session session = entityManager.unwrap(Session.class); session.beginTransaction(); Tool tool = new Tool(); tool.setName("Hammer111"); session.save(tool); Future<?> future= exectorService.submit(()->{ Tool tool1 = new Tool(); tool1.setName("Hammer222"); session.save(tool1); throw new RuntimeException(); }); future.get(); session.getTransaction().commit();
2. spring 中处理过程。
主要查看 JpaTransactionManager.getTransaction(@Nullable TransactionDefinition definition)
@Override public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException {
//1.先获取一个事务对象 Object transaction = doGetTransaction();
protected Object doGetTransaction() { JpaTransactionObject txObject = new JpaTransactionObject(); txObject.setSavepointAllowed(isNestedTransactionAllowed()); //2.获取当前线程对应的EntityManagerHolder EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(obtainEntityManagerFactory()); if (emHolder != null) { if (logger.isDebugEnabled()) { logger.debug("Found thread-bound EntityManager [" + emHolder.getEntityManager() + "] for JPA transaction"); } txObject.setEntityManagerHolder(emHolder, false); } if (getDataSource() != null) { ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(getDataSource()); txObject.setConnectionHolder(conHolder); } return txObject; }
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException { Object transaction = doGetTransaction(); // Cache debug flag to avoid repeated checks. boolean debugEnabled = logger.isDebugEnabled(); if (definition == null) { // Use defaults if no transaction definition given. definition = new DefaultTransactionDefinition(); } //3.判断当前是否有一个事务，并且事务是开启的状态 if (isExistingTransaction(transaction)) { // Existing transaction found -> check propagation behavior to find out how to behave. return handleExistingTransaction(definition, transaction, debugEnabled); } // Check definition settings for new transaction. if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) { throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout()); } // No existing transaction found -> check propagation behavior to find out how to proceed. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) { throw new IllegalTransactionStateException( "No existing transaction found for transaction marked with propagation 'mandatory'"); } else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED || definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW || definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) { SuspendedResourcesHolder suspendedResources = suspend(null); if (debugEnabled) { logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition); } try { boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//4.如果当前没有事务，就开启一个事务，并且把这个事务绑定到当前线程 doBegin(transaction, definition); prepareSynchronization(status, definition); return status; } catch (RuntimeException | Error ex) { resume(null, suspendedResources); throw ex; } } else { // Create "empty" transaction: no actual transaction, but potentially synchronization. if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) { logger.warn("Custom isolation level specified but no actual transaction initiated; " + "isolation level will effectively be ignored: " + definition); } boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS); return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null); } }
5.在一个代理类的内部方法互相调用是不会添加切面方法的。（这个时候，如果想在内部方法互相调用时加入代理该怎么办？）
1.启用暴露代理对象属性
@EnableAspectJAutoProxy(exposeProxy=true)
2.内部互相调用时，写法修改。
((Service) AopContext.currentProxy()).callMethodB();
6. JDBC事务
