zuojunyuan
zuojunyuan

Spring-tx模块分析

Spring-tx模块负责在spring框架中实现事务管理功能。以aop切面的方式将事务注入到业务代码中，并实现不同类型的事务管理器。这篇文章主要介绍Spring-tx模块aop切面的相关实现类型

TransactionAttributeSourceAdvisor:使用TransactionAttributeSourcePointcut来确定拦截位置

类型定义：

public class TransactionAttributeSourceAdvisor extends AbstractPointcutAdvisor

属性：

@Nullable
private TransactionInterceptor transactionInterceptor;

private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
		@Override
		protected TransactionAttributeSource getTransactionAttributeSource() {
			return (transactionInterceptor != null ? transactionInterceptor.getTransactionAttributeSource() : null);
		}
	};

核心方法：

@Override
public Advice getAdvice() {
	Assert.state(this.transactionInterceptor != null, "No TransactionInterceptor set");
	return this.transactionInterceptor;
}

@Override
public Pointcut getPointcut() {
	return this.pointcut;
}

TransactionAttributeSourcePointcut具体实现：

abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {

	@Override
	public boolean matches(Method method, @Nullable Class targetClass) {
		if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
			return false;
		}
		TransactionAttributeSource tas = getTransactionAttributeSource();
		return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
	}

	@Override
	public boolean equals(Object other) {
		if (this == other) {
			return true;
		}
		if (!(other instanceof TransactionAttributeSourcePointcut)) {
			return false;
		}
		TransactionAttributeSourcePointcut otherPc = (TransactionAttributeSourcePointcut) other;
		return ObjectUtils.nullSafeEquals(getTransactionAttributeSource(), otherPc.getTransactionAttributeSource());
	}

	@Override
	public int hashCode() {
		return TransactionAttributeSourcePointcut.class.hashCode();
	}

	@Override
	public String toString() {
		return getClass().getName() + ": " + getTransactionAttributeSource();
	}


	/**
	 * Obtain the underlying TransactionAttributeSource (may be {@code null}).
	 * To be implemented by subclasses.
	 */
	@Nullable
	protected abstract TransactionAttributeSource getTransactionAttributeSource();

}

TransactionAttributeSource：使用策略模式获取事务元数据

/**
 * Strategy interface used by {@link TransactionInterceptor} for metadata retrieval.
 *
 * 
Implementations know how to source transaction attributes, whether from configuration,
 * metadata attributes at source level (such as Java 5 annotations), or anywhere else.
 *
 * @author Rod Johnson
 * @since 15.04.2003
 * @see TransactionInterceptor#setTransactionAttributeSource
 * @see TransactionProxyFactoryBean#setTransactionAttributeSource
 * @see org.springframework.transaction.annotation.AnnotationTransactionAttributeSource
 */
public interface TransactionAttributeSource {

	/**
	 * Return the transaction attribute for the given method,
	 * or {@code null} if the method is non-transactional.
	 * @param method the method to introspect
	 * @param targetClass the target class (may be {@code null},
	 * in which case the declaring class of the method must be used)
	 * @return TransactionAttribute the matching transaction attribute,
	 * or {@code null} if none found
	 */
	@Nullable
	TransactionAttribute getTransactionAttribute(Method method, @Nullable Class targetClass);

}

 UML结构图如下：

这里重点介绍下AbstractFallbackTransactionAttributeSource和AnnotationTransactionAttributeSource

AbstractFallbackTransactionAttributeSource：根据targetClass和method生成TransactionAttribute

核心方法：

1.getTransactionAttribute

/**
	 * Determine the transaction attribute for this method invocation.
	 * 
Defaults to the class's transaction attribute if no method attribute is found.
	 * @param method the method for the current invocation (never {@code null})
	 * @param targetClass the target class for this invocation (may be {@code null})
	 * @return TransactionAttribute for this method, or {@code null} if the method
	 * is not transactional
	 */
	@Override
	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class targetClass) {
		if (method.getDeclaringClass() == Object.class) {
			return null;
		}

		// First, see if we have a cached value.
		Object cacheKey = getCacheKey(method, targetClass);
		Object cached = this.attributeCache.get(cacheKey);
		if (cached != null) {
			// Value will either be canonical value indicating there is no transaction attribute,
			// or an actual transaction attribute.
			if (cached == NULL_TRANSACTION_ATTRIBUTE) {
				return null;
			}
			else {
				return (TransactionAttribute) cached;
			}
		}
		else {
			// We need to work it out.
			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
			// Put it in the cache.
			if (txAttr == null) {
				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
			}
			else {
				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
				if (txAttr instanceof DefaultTransactionAttribute) {
					((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
				}
				this.attributeCache.put(cacheKey, txAttr);
			}
			return txAttr;
		}
	}

备注：通过调用computeTransactionAttribute方法来获取TransactionalAttribute

2.computeTransactionAttribute

/**
	 * Same signature as {@link #getTransactionAttribute}, but doesn't cache the result.
	 * {@link #getTransactionAttribute} is effectively a caching decorator for this method.
	 * 
As of 4.1.8, this method can be overridden.
	 * @since 4.1.8
	 * @see #getTransactionAttribute
	 */
	@Nullable
	protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class targetClass) {
		// Don't allow no-public methods as required.
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}

		// Ignore CGLIB subclasses - introspect the actual user class.
		Class userClass = (targetClass != null ? ClassUtils.getUserClass(targetClass) : null);
		// The method may be on an interface, but we need attributes from the target class.
		// If the target class is null, the method will be unchanged.
		Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
		// If we are dealing with method with generic parameters, find the original method.
		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

		// First try is the method in the target class.
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}

		// Second try is the transaction attribute on the target class.
		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
			return txAttr;
		}

		if (specificMethod != method) {
			// Fallback is to look at the original method.
			txAttr = findTransactionAttribute(method);
			if (txAttr != null) {
				return txAttr;
			}
			// Last fallback is the class of the original method.
			txAttr = findTransactionAttribute(method.getDeclaringClass());
			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
				return txAttr;
			}
		}

		return null;
	}

需要子类扩展的方法如下：

1.protected abstract TransactionAttribute findTransactionAttribute(Method method);

2.protected abstract TransactionAttribute findTransactionAttribute(Class clazz);

AnnotationTransactionAttributeSource：读取类或者方法上的@Transactional注解内容来生成TransactionAttribute

属性：

private static final boolean jta12Present = ClassUtils.isPresent(
			"javax.transaction.Transactional", AnnotationTransactionAttributeSource.class.getClassLoader());

	private static final boolean ejb3Present = ClassUtils.isPresent(
			"javax.ejb.TransactionAttribute", AnnotationTransactionAttributeSource.class.getClassLoader());

	private final boolean publicMethodsOnly;

	private final Set annotationParsers;

核心方法：

1.findTransactionAttribute

@Override
	protected TransactionAttribute findTransactionAttribute(Method method) {
		return determineTransactionAttribute(method);
	}

	@Override
	protected TransactionAttribute findTransactionAttribute(Class clazz) {
		return determineTransactionAttribute(clazz);
	}

	/**
	 * Determine the transaction attribute for the given method or class.
	 * 
This implementation delegates to configured
	 * {@link TransactionAnnotationParser TransactionAnnotationParsers}
	 * for parsing known annotations into Spring's metadata attribute class.
	 * Returns {@code null} if it's not transactional.
	 * 
Can be overridden to support custom annotations that carry transaction metadata.
	 * @param ae the annotated method or class
	 * @return TransactionAttribute the configured transaction attribute,
	 * or {@code null} if none was found
	 */
	@Nullable
	protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {
		for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
			TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);
			if (attr != null) {
				return attr;
			}
		}
		return null;
	}

备注：使用TransactionAnnotationParser类型的parseTransactionAnnotation方法进行AnnotatedElement到TransactionAttribute之间的转变

具体可以参考SpringTransactionAnnotationParser

protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
		Propagation propagation = attributes.getEnum("propagation");
		rbta.setPropagationBehavior(propagation.value());
		Isolation isolation = attributes.getEnum("isolation");
		rbta.setIsolationLevel(isolation.value());
		rbta.setTimeout(attributes.getNumber("timeout").intValue());
		rbta.setReadOnly(attributes.getBoolean("readOnly"));
		rbta.setQualifier(attributes.getString("value"));
		ArrayList rollBackRules = new ArrayList<>();
		Class[] rbf = attributes.getClassArray("rollbackFor");
		for (Class rbRule : rbf) {
			RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
			rollBackRules.add(rule);
		}
		String[] rbfc = attributes.getStringArray("rollbackForClassName");
		for (String rbRule : rbfc) {
			RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
			rollBackRules.add(rule);
		}
		Class[] nrbf = attributes.getClassArray("noRollbackFor");
		for (Class rbRule : nrbf) {
			NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
			rollBackRules.add(rule);
		}
		String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
		for (String rbRule : nrbfc) {
			NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
			rollBackRules.add(rule);
		}
		rbta.getRollbackRules().addAll(rollBackRules);
		return rbta;
	}

AnnotationTransactionAspect：通过AspectJ方式根据org.springframework.transaction.annotation.Transactional注解生成事务proxy

UML类图如下：

Spring-tx模块分析_第1张图片

构造函数如下：

public AnnotationTransactionAspect() {
	super(new AnnotationTransactionAttributeSource(false));
}

备注：使用AnnotationTransactionAttributeSource获取TransactionAttribute

Pointcut定义：

/**
	 * Matches the execution of any public method in a type with the Transactional
	 * annotation, or any subtype of a type with the Transactional annotation.
	 */
	private pointcut executionOfAnyPublicMethodInAtTransactionalType() :
		execution(public * ((@Transactional *)+).*(..)) && within(@Transactional *);

	/**
	 * Matches the execution of any method with the Transactional annotation.
	 */
	private pointcut executionOfTransactionalMethod() :
		execution(@Transactional * *(..));

	/**
	 * Definition of pointcut from super aspect - matched join points
	 * will have Spring transaction management applied.
	 */
	protected pointcut transactionalMethodExecution(Object txObject) :
		(executionOfAnyPublicMethodInAtTransactionalType() || executionOfTransactionalMethod() ) && this(txObject);

around方法定义：

@SuppressAjWarnings("adviceDidNotMatch")
	Object around(final Object txObject): transactionalMethodExecution(txObject) {
		MethodSignature methodSignature = (MethodSignature) thisJoinPoint.getSignature();
		// Adapt to TransactionAspectSupport's invokeWithinTransaction...
		try {
			return invokeWithinTransaction(methodSignature.getMethod(), txObject.getClass(), new InvocationCallback() {
				public Object proceedWithInvocation() throws Throwable {
					return proceed(txObject);
				}
			});
		}
		catch (RuntimeException | Error ex) {
			throw ex;
		}
		catch (Throwable thr) {
			Rethrower.rethrow(thr);
			throw new IllegalStateException("Should never get here", thr);
		}
	}

TransactionAspectSupport：实际运行事务的工作类

核心方法：

1.invokeWithinTransaction

/**
	 * General delegate for around-advice-based subclasses, delegating to several other template
	 * methods on this class. Able to handle {@link CallbackPreferringPlatformTransactionManager}
	 * as well as regular {@link PlatformTransactionManager} implementations.
	 * @param method the Method being invoked
	 * @param targetClass the target class that we're invoking the method on
	 * @param invocation the callback to use for proceeding with the target invocation
	 * @return the return value of the method, if any
	 * @throws Throwable propagated from the target invocation
	 */
	@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		TransactionAttributeSource tas = getTransactionAttributeSource();
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				// target invocation exception
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else {
			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
					TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
					try {
						return invocation.proceedWithInvocation();
					}
					catch (Throwable ex) {
						if (txAttr.rollbackOn(ex)) {
							// A RuntimeException: will lead to a rollback.
							if (ex instanceof RuntimeException) {
								throw (RuntimeException) ex;
							}
							else {
								throw new ThrowableHolderException(ex);
							}
						}
						else {
							// A normal return value: will lead to a commit.
							return new ThrowableHolder(ex);
						}
					}
					finally {
						cleanupTransactionInfo(txInfo);
					}
				});

				// Check result: It might indicate a Throwable to rethrow.
				if (result instanceof ThrowableHolder) {
					throw ((ThrowableHolder) result).getThrowable();
				}
				else {
					return result;
				}
			}
			catch (ThrowableHolderException ex) {
				throw ex.getCause();
			}
		}
	}

备注：

1.通过getTransactionAttributeSource()获取TransactionAttributeSource

2.TransactionAttributeSource根据method和targetClass获取TransactionAttribute

3.根据TransactionAttribute筛选PlatformTransactionManager

4.获取执行方法描述符methodIdentification

5.执行事务(具体流程见下图)

                       Spring-tx模块分析_第2张图片

2.determineTransactionManager

/**
	 * Determine the specific transaction manager to use for the given transaction.
	 */
	@Nullable
	protected PlatformTransactionManager determineTransactionManager(@Nullable TransactionAttribute txAttr) {
		// Do not attempt to lookup tx manager if no tx attributes are set
		if (txAttr == null || this.beanFactory == null) {
			return getTransactionManager();
		}

		String qualifier = txAttr.getQualifier();
		if (StringUtils.hasText(qualifier)) {
			return determineQualifiedTransactionManager(this.beanFactory, qualifier);
		}
		else if (StringUtils.hasText(this.transactionManagerBeanName)) {
			return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
		}
		else {
			PlatformTransactionManager defaultTransactionManager = getTransactionManager();
			if (defaultTransactionManager == null) {
				defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
				if (defaultTransactionManager == null) {
					defaultTransactionManager = this.beanFactory.getBean(PlatformTransactionManager.class);
					this.transactionManagerCache.putIfAbsent(
							DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
				}
			}
			return defaultTransactionManager;
		}
	}

	private PlatformTransactionManager determineQualifiedTransactionManager(BeanFactory beanFactory, String qualifier) {
		PlatformTransactionManager txManager = this.transactionManagerCache.get(qualifier);
		if (txManager == null) {
			txManager = BeanFactoryAnnotationUtils.qualifiedBeanOfType(
					beanFactory, PlatformTransactionManager.class, qualifier);
			this.transactionManagerCache.putIfAbsent(qualifier, txManager);
		}
		return txManager;
	}

备注：

1.使用TransactionAttribute的qualifier属性获取PlatformTransactionManager

2.使用transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY)获取PlatformTransactionManager

3.使用beanFactory.getBean(PlatformTransactionManager.class)获取PlatformTransactionManager

TransactionInterceptor：业务方法事务拦截器

类型定义：

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable

构造器：

/**
	 * Create a new TransactionInterceptor.
	 * 
Transaction manager and transaction attributes still need to be set.
	 * @see #setTransactionManager
	 * @see #setTransactionAttributes(java.util.Properties)
	 * @see #setTransactionAttributeSource(TransactionAttributeSource)
	 */
	public TransactionInterceptor() {
	}

	/**
	 * Create a new TransactionInterceptor.
	 * @param ptm the default transaction manager to perform the actual transaction management
	 * @param attributes the transaction attributes in properties format
	 * @see #setTransactionManager
	 * @see #setTransactionAttributes(java.util.Properties)
	 */
	public TransactionInterceptor(PlatformTransactionManager ptm, Properties attributes) {
		setTransactionManager(ptm);
		setTransactionAttributes(attributes);
	}

	/**
	 * Create a new TransactionInterceptor.
	 * @param ptm the default transaction manager to perform the actual transaction management
	 * @param tas the attribute source to be used to find transaction attributes
	 * @see #setTransactionManager
	 * @see #setTransactionAttributeSource(TransactionAttributeSource)
	 */
	public TransactionInterceptor(PlatformTransactionManager ptm, TransactionAttributeSource tas) {
		setTransactionManager(ptm);
		setTransactionAttributeSource(tas);
	}

核心方法：

1.invoke

@Override
	@Nullable
	public Object invoke(final MethodInvocation invocation) throws Throwable {
		// Work out the target class: may be {@code null}.
		// The TransactionAttributeSource should be passed the target class
		// as well as the method, which may be from an interface.
		Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// Adapt to TransactionAspectSupport's invokeWithinTransaction...
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}

TransactionProxyFactoryBean:声明式事务管理Proxy的工厂类，根据transactionManager,transactionAttributes创建事务管理Proxy

类型定义：

public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean
		implements BeanFactoryAware

AbstractSingletonProxyFactoryBean类型定义：

public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
		implements FactoryBean, BeanClassLoaderAware, InitializingBean 
  
属性：
 
  
private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();

	@Nullable
	private Pointcut pointcut;  
@Nullable
	private Object target;

	@Nullable
	private Class[] proxyInterfaces;

	@Nullable
	private Object[] preInterceptors;

	@Nullable
	private Object[] postInterceptors;

	/** Default is global AdvisorAdapterRegistry */
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();

	@Nullable
	private transient ClassLoader proxyClassLoader;

	@Nullable
	private Object proxy;
 
  
核心方法：
 
  
1.afterPropertiesSet
 
  
@Override
	public void afterPropertiesSet() {
		if (this.target == null) {
			throw new IllegalArgumentException("Property 'target' is required");
		}
		if (this.target instanceof String) {
			throw new IllegalArgumentException("'target' needs to be a bean reference, not a bean name as value");
		}
		if (this.proxyClassLoader == null) {
			this.proxyClassLoader = ClassUtils.getDefaultClassLoader();
		}

		ProxyFactory proxyFactory = new ProxyFactory();

		if (this.preInterceptors != null) {
			for (Object interceptor : this.preInterceptors) {
				proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));
			}
		}

		// Add the main interceptor (typically an Advisor).
		proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(createMainInterceptor()));

		if (this.postInterceptors != null) {
			for (Object interceptor : this.postInterceptors) {
				proxyFactory.addAdvisor(this.advisorAdapterRegistry.wrap(interceptor));
			}
		}

		proxyFactory.copyFrom(this);

		TargetSource targetSource = createTargetSource(this.target);
		proxyFactory.setTargetSource(targetSource);

		if (this.proxyInterfaces != null) {
			proxyFactory.setInterfaces(this.proxyInterfaces);
		}
		else if (!isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			Class targetClass = targetSource.getTargetClass();
			if (targetClass != null) {
				proxyFactory.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
			}
		}

		postProcessProxyFactory(proxyFactory);

		this.proxy = proxyFactory.getProxy(this.proxyClassLoader);
	}
 
  
     执行流程如下：
 
  
     1.创建ProxyFactory对象
 
  
     2.将preInterceptors的内容添加到ProxyFactory对象的advisors列表中
 
  
     3.将createMainInterceptor()的返回添加到ProxyFactory对象的advisors列表中
 
  
     4.将postInterceptors的内容添加到ProxyFactory对象的advisors列表中
 
  
     5.设置target和proxyInterfaces
 
  
     6.创建proxy
 
  
2.getObject和getObjectType
 
  
@Override
public Object getObject() {
	if (this.proxy == null) {
			throw new FactoryBeanNotInitializedException();
	}
	return this.proxy;
}

@Override
public Class getObjectType() {
	if (this.proxy != null) {
		return this.proxy.getClass();
	}
	if (this.proxyInterfaces != null && this.proxyInterfaces.length == 1) {
		return this.proxyInterfaces[0];
	}
	if (this.target instanceof TargetSource) {
		return ((TargetSource) this.target).getTargetClass();
	}
	if (this.target != null) {
		return this.target.getClass();
	}
	return null;
}
 
  
3.createMainInterceptor
 
  
/**
	 * Creates an advisor for this FactoryBean's TransactionInterceptor.
	 */
	@Override
	protected Object createMainInterceptor() {
		this.transactionInterceptor.afterPropertiesSet();
		if (this.pointcut != null) {
			return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);
		}
		else {
			// Rely on default pointcut.
			return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);
		}
	}
 
  
AbstractPlatformTransactionManager：具体平台事务管理器的抽象基类，使用模板方法设计模式实现Spring的标准事务工作流;
 
  
子类必须重写改变事务状态的方法： 1. begin 2. suspend 3.resume 4.commit 5.rollback
 
  
UML类图结构如下：
 
  
Spring-tx模块分析_第3张图片
 
  
实现功能：
 
  
     1.确定是否存在现有事务(挂起旧事务和开始新事务);
 
  
      2.应用适当的事务传播行为;
 
  
      3.必要时暂停并恢复事务；
 
  
      4.检查事务提交上的仅回滚(rollback-only)标记；
 
  
      5.在回滚中(实际回滚或设置回滚(setting rollback-only))进行适当的修改;(todo:两种回滚方式的区别）
 
  
      6.触发注册的事务同步((Transaction synchronization)回调
 
  
      7.提交事务
 
  
  事务同步(Transaction synchronization) 回调详解:
 
  
  事务同步是注册回调的一种通用机制。一般在事务完成时间调用的。两种应用场景：
 
  
   1.JDBC、Hibernate、JPA等框架的数据访问支持类在运行JTA事务时使用：事务开始前开启事务同步回调注册，事务结束后关闭 事务同步回调
 
  
   2.应用程序中的自定义同步需求
 
  
  事务执行流程如下：
 
  
                 Spring-tx模块分析_第4张图片
 
  
核心方法：
 
  
1.getTransaction
 
  
Spring-tx模块分析_第5张图片
 
  
2.suspend
 
  
@Nullable
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
   if (TransactionSynchronizationManager.isSynchronizationActive()) {
      List suspendedSynchronizations = doSuspendSynchronization();
      try {
         Object suspendedResources = null;
         if (transaction != null) {
            suspendedResources = doSuspend(transaction);
         }
         String name = TransactionSynchronizationManager.getCurrentTransactionName();
         TransactionSynchronizationManager.setCurrentTransactionName(null);
         boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
         TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
         Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
         TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
         boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
         TransactionSynchronizationManager.setActualTransactionActive(false);
         return new SuspendedResourcesHolder(
               suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
      }
      catch (RuntimeException | Error ex) {
         // doSuspend failed - original transaction is still active...
         doResumeSynchronization(suspendedSynchronizations);
         throw ex;
      }
   }
   else if (transaction != null) {
      // Transaction active but no synchronization active.
      Object suspendedResources = doSuspend(transaction);
      return new SuspendedResourcesHolder(suspendedResources);
   }
   else {
      // Neither transaction nor synchronization active.
      return null;
   }
}
 
  
业务流程如下：
 
  
     
   
  1.  
    挂起列表中的事务同步回调对象(TransactionSynchronization)
     
    2.  
   
  2.  
    挂起事务
     
    3.  
   
  3.  
    重置TransactionSynchronizationManager内容，返回TransactionSynchronizationManager之前保存的内容
     
    4.  
  
 
  
3.newTransactionStatus
 
  
protected DefaultTransactionStatus newTransactionStatus(
      TransactionDefinition definition, @Nullable Object transaction, boolean newTransaction,
      boolean newSynchronization, boolean debug, @Nullable Object suspendedResources) {

   boolean actualNewSynchronization = newSynchronization &&
         !TransactionSynchronizationManager.isSynchronizationActive();
   return new DefaultTransactionStatus(
         transaction, newTransaction, actualNewSynchronization,
         definition.isReadOnly(), debug, suspendedResources);
}
 
  
 备注：返回新的TransactionStatus对象
 
  
4.prepareSynchronization
 
  
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
   if (status.isNewSynchronization()) {
      TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
      TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
            definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
                  definition.getIsolationLevel() : null);
      TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
      TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
      TransactionSynchronizationManager.initSynchronization();
   }
}
 
  
备注：将DefaultTransactionStatus和TransactionDefinition内容保存到TransactionSynchronizationManager
 
  
DataSourceTransactionManager:描述：针对数据库JDBC connection的事务管理器,通过DataSource的工厂方法来获取JDBC connection。可以做为JtaTransactionManager的替代类
 
  
DataSource的获取方式包括：
 
  
1.TransactionAwareDataSourceProxy 2.LazyConnectionDataSourceProxy
 
  
属性如下:
 
  
@Nullable
private javax.sql.DataSource dataSource;
private boolean enforceReadOnly = false;
 
  
备注：dataSource是必须赋值的
 
  
核心方法：
 
  
1.dogetTransaction()
 
  
@Override
	protected Object doGetTransaction() {
		DataSourceTransactionObject txObject = new DataSourceTransactionObject();
		txObject.setSavepointAllowed(isNestedTransactionAllowed());
		ConnectionHolder conHolder =
				(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
		txObject.setConnectionHolder(conHolder, false);
		return txObject;
	}
 
  
具体流程如下：
 
  
     
   
  1.  
    初始化DataSourceTransactionObject对象(该对象在整个事务执行流程中作为上下文存在)
     
    2.  
   
  2.  
    DataSourceTransactionObject对象绑定DataSource在threadlocal保存的Connection
     
    3.  
  
 
  
2.isExistingTransaction(Object transaction)
 
  
@Override
	protected boolean isExistingTransaction(Object transaction) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
	}
 
  
备注：判断当前connection是否存在并且是否开启了事务
 
  
3.doBegin(Object transaction, TransactionDefinition definition)
 
  
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		Connection con = null;

		try {
			if (!txObject.hasConnectionHolder() ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				Connection newCon = obtainDataSource().getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}

			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();

			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);

			// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
			// so we don't want to do it unnecessarily (for example if we've explicitly
			// configured the connection pool to set it already).
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				con.setAutoCommit(false);
			}

			prepareTransactionalConnection(con, definition);
			txObject.getConnectionHolder().setTransactionActive(true);

			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}

			// Bind the connection holder to the thread.
			if (txObject.isNewConnectionHolder()) {
				TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
			}
		}

		catch (Throwable ex) {
			if (txObject.isNewConnectionHolder()) {
				DataSourceUtils.releaseConnection(con, obtainDataSource());
				txObject.setConnectionHolder(null, false);
			}
			throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
		}
 
  
主要业务流程如下：
 
  
     
   
  1.  
    如果DataSourceTransactionObject的connection为空或者connection的事务同步(SynchronizedWithTransaction)已经开启, DataSourceTransactionObject对象设置新的connection
     
    2.  
   
  2.  
    DataSourceTransactionObject的connection开启事务同步(SynchronizedWithTransaction)，保存当前的隔离级别，设置是否开启自动提交(默认开启)
     
    根据TransactionDefinition.isReadOnly属性生成优化语句("SET TRANSACTION READ ONLY")
     
    3.  
   
  3.  
    DataSourceTransactionObject的connection设置成拥有事务(TransactionActive)
     
    4.  
  
 
  
     4. 如果DataSourceTransactionObject的connection是新生成的，将datasource和connection的对应关系保存到threadlocal
 
  
5.doSuspend
 
  
@Override
	protected Object doSuspend(Object transaction) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
		txObject.setConnectionHolder(null);
		return TransactionSynchronizationManager.unbindResource(obtainDataSource());
	}
 
  
6.doResume
 
  
@Override
	protected void doResume(@Nullable Object transaction, Object suspendedResources) {
		TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
	}
 
  
7.doCommit
 
  
@Override
	protected void doCommit(DefaultTransactionStatus status) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
		Connection con = txObject.getConnectionHolder().getConnection();
		if (status.isDebug()) {
			logger.debug("Committing JDBC transaction on Connection [" + con + "]");
		}
		try {
			con.commit();
		}
		catch (SQLException ex) {
			throw new TransactionSystemException("Could not commit JDBC transaction", ex);
		}
	}
 
  
8.doCleanupAfterCompletion
 
  
@Override
	protected void doCleanupAfterCompletion(Object transaction) {
		DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;

		// Remove the connection holder from the thread, if exposed.
		if (txObject.isNewConnectionHolder()) {
			TransactionSynchronizationManager.unbindResource(obtainDataSource());
		}

		// Reset connection.
		Connection con = txObject.getConnectionHolder().getConnection();
		try {
			if (txObject.isMustRestoreAutoCommit()) {
				con.setAutoCommit(true);
			}
			DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
		}
		catch (Throwable ex) {
			logger.debug("Could not reset JDBC Connection after transaction", ex);
		}

		if (txObject.isNewConnectionHolder()) {
			if (logger.isDebugEnabled()) {
				logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
			}
			DataSourceUtils.releaseConnection(con, this.dataSource);
		}

		txObject.getConnectionHolder().clear();
	}
 
  
备注：进行资源清理等操作
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring源码分析)

        

            

                
    
                    
  • redo log —— MySQL宕机时数据不丢失的原理
                        天堂2013
MySQLMySQLredologjava
                        
    扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析、Java并发编程和Netty源码系列文章。问题在开始阅读本文之前，可以先思考一下下面两个问题。众所周知，MySQL有四大特性：ACID，其中D指的是持久性（Durability），它的含义是MySQL的事务一旦提交，它对数据库的改变是永久性的，即数据不会丢失，那么MySQL究竟是如何实现的呢？MySQL数
    
                    
    • 
                    
  • 【Spring源码分析】解析配置类-ConfigurationClassPostProcessor源码分析
                        假正经的小柴
Java源码分析spring数据库前端
                        
    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
    
                    
    • 
                    
  • 【Spring源码分析】循环依赖的底层源码剖析
                        假正经的小柴
Java源码分析spring数据库java
                        
    循环依赖的底层源码剖析一、预知知识二、循环依赖的底层源码剖析1.Spring是如何存储半成品Bean的？getEarlyBeanReference方法的源码分析2.Spring是如何解决的循环依赖呢？测试3.哪些循环依赖Spring是无法解决的呢？@Async引起的循环依赖解决方案单构造注入引起的循环依赖解决方案三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spr
    
                    
    • 
                    
  • 【Spring源码分析】推断构造方法
                        假正经的小柴
Java源码分析springjava数据库
                        
    推断构造方法源码解析一、确认候选构造——AutowireAnnotationBeanPostProcessor#determineCandidateConstructors二、autowireConstructor方法源码解析三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码
    
                    
    • 
                    
  • 【Spring源码分析】@Resource注入的源码解析
                        假正经的小柴
Java源码分析springjava数据库
                        
    @Resource注入的源码解析一、绪论二、CommonAnnotationBeanPostProcessor源码分析postProcessMergedBeanDefinition源码解析postProcessProperties源码解析ResourceElement构造函数分析inject方法解析三、总结不愿看这段可跳过系列：话是针对可能是刷到这篇博客的人写的（而非订阅从头到尾跟着去阅读的）：还
    
                    
    • 
                    
  • 【Spring源码分析】Spring的启动流程源码解析
                        假正经的小柴
Java源码分析spring数据库java
                        
    阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
    
                    
    • 
                    
  • 【Spring源码分析】37-Spring MVC的异常处理
                        一直不懂
SpringFramework源码分析
                        
    在SpringMVC中处理HTTP请求时如果抛出异常会使用DispatcherServlet#processHandlerException()处理，这个方法内部使用SpringMVC默认的注册的HandlerExceptionResolver进行处理。@NullableprotectedModelAndViewprocessHandlerException(HttpServletRequestr
    
                    
    • 
                    
  • 模拟mybatis实现接口依赖注入
                        瞿大官人

                        
    一、前言这一节基于前面两节mybatis中Mapper注入spring源码分析与mybatis接口依赖注入源码分析的理论，手动实现将接口放入Spring工厂中，并且能够依赖注入。二、实践这里先把已写好的类贴出来，下面会一一介绍。这篇文章的两个目的如下。image.png目的一：将TestInterface接口放入Spring的工厂中.@ComponentpublicinterfaceTestInt
    
                    
    • 
                    
  • Spring源码分析七：JdbcTemplate连接数据库原理
                        进击的猫
Spring源码分析springJdbcTemplate数据库原理
                        
    文章目录（一）Spring连接数据库程序1、创建数据库表2、创建实体PO3、创建mapper映射4、创建业务接口5、创建业务接口实现类6、Spring配置文件7、测试类（二）JdbcTemplate核心原理1、update方法（执行DML语句）2、execute底层方法（底层核心，DDL）（1）获取数据库连接（2）用户查询参数设置（3）执行回调方法（4）告警处理（5）资源释放3、query方法（执
    
                    
    • 
                    
  • Spring源码分析九：JdbcTemplate 的源码分析
                        猫吻鱼
#源码分析篇
                        
    文章目录一、前言二、JdbcTemplate二、核心方法-execute1.获取数据库连接2.应用用户设定的数据参数3.告警处理4.资源释放三、execute的回调1.Update中的回调函数2.query功能的实现四、其他一、前言本文是笔者阅读Spring源码的记录文章，由于本人技术水平有限，在文章中难免出现错误，如有发现，感谢各位指正。在阅读过程中也创建了一些衍生文章，衍生文章的意义是因为自己
    
                    
    • 
                    
  • Spring源码分析：refresh()
                        weixin_44145526
Spring源码springjava后端
                        
    refresh()中共有13个方法，分别为1.prepareRefresh()容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等protectedvoidprepareRefresh(){//spring启动时间this.startupDate=System.currentTimeMillis();//spring标记为未关闭this.closed.set(false);//spring
    
                    
    • 
                    
  • 【Spring源码分析】从源码角度去熟悉依赖注入（二）
                        假正经的小柴
Java源码分析spring数据库sql
                        
    从源码角度去熟悉依赖注入（二）一、AutowiredFieldElement注入分析二、AutowiredMethodElement注入分析三、doResolveDependency源码分析1.@Value注解解析测试${}和#{}2.resolveMultipleBeans筛选特殊类型（处理多Bean）测试findAutowireCandidates方法解析isAutowireCandidate
    
                    
    • 
                    
  • Spring系列之Spring常用注解总结
                        Java耕耘者

                        
    喜欢底层源码的朋友可以来交流探讨。交流群：818491202验证：33关注公众号领资料搜索公众号【Java耕耘者】,回复【Java】，即可获取大量优质电子书和一份Java高级架构资料、Spring源码分析、Dubbo、Redis、Netty、zookeeper、Springcloud、分布式等视频资料文正传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物，这么做有两
    
                    
    • 
                    
  • 【Spring源码分析】扫描并注册BeanDefinition逻辑
                        假正经的小柴
Java源码分析springjava后端
                        
    扫描并注册BeanDefinition逻辑一、ClassPathBeanDefinitionScanner扫描源码分析doScan扫描的具体逻辑findCandidateComponents方法解析generateBeanName方法解析checkCandidate方法解析二、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】Be
    
                    
    • 
                    
  • Spring源码分析：IOC容器的刷新 - refresh()
                        GeekInk小火龙
springspringboot
                        
    面试常见问题：bean生命周期循环依赖三级缓存FactoryBean和beanFactoryApplicationContext和BeanFactory的区别设计模式bean定义信息BeanDefinition读取xml配置文件，通过抽象接口BeanDefinitionReader读取配置文件规范，源码当中的ConfigurableListableBeanFactory部分内容就是读取.xml配置
    
                    
    • 
                    
  • 【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑
                        假正经的小柴
Java源码分析springjava后端
                        
    执行流程之非懒加载单例Bean的实例化逻辑preInstantiateSingletons()源码分析合并BeanDefinitiongetMergedLocalBeanDefinitionBean的分类【普通Bean、FactoryBean】Bean的创建逻辑实例化前源码分析总结在经过扫描操作获取到可用的BeanDefinition集后，接下来会进行实例化前的操作：将单例且非懒加载的BeanDe
    
                    
    • 
                    
  • 【Spring源码分析】从源码角度去熟悉依赖注入（一）
                        假正经的小柴
Java源码分析springjava后端源码分析
                        
    从源码角度去熟悉依赖注入一、全局出发引出各种依赖注入策略二、@Autowired依赖注入源码分析属性注入源码分析（AutowiredFieldElement.inject）方法注入源码分析（AutowiredMethodElement.inject）流程图其实在上篇阐述非懒加载单例Bean的实例化逻辑的时候，就有阐述过AbstractAutowireCapableBeanFactory#creat
    
                    
    • 
                    
  • 【Spring源码分析】BeanFactory系列接口解读
                        假正经的小柴
Java源码分析spring原型模式javascript
                        
    认识Bean工厂一、认识Bean工厂BeanFactoryListableBeanFactoryHierarchicalBeanFactoryAutowireCapableBeanFactoryConfigurableBeanFactoryConfigurableListableBeanFactory二、总结一、认识Bean工厂SpringBean工厂是Spring框架提供的一种机制，用于创建和管
    
                    
    • 
                    
  • Spring源码分析（四）SpringMVC
                        万里墨香
#Spring源码分析
                        
    文章目录ContextLoaderListenerDispatcherServlet初始化九大组件MultipartResolverLocaleResolverThemeResolverHandlerMapping初始化BeanNameUrlHandlerMappingRequestMappingHandlerMapping获取HandlerExecutionChainBeanNameUrlHan
    
                    
    • 
                    
  • 【spring源码分析】@Conditional的使用以及分析
                        吴巴格
spring源码spring数据库mysqlspringboot
                        
    @Conditional@Conditional一、基本信息二、注解描述三、注解源码四、主要功能五、最佳实践在@Bean上使用在@Configuration上使用自定义组合注解六、时序图七、源码分析八、注意事项九、总结最佳实践总结源码分析总结一、基本信息转载自github，在此作为个人备份(https://blog.csdn.net/duzhuang2399/article/details/133
    
                    
    • 
                    
  • 【spring源码分析】@Autowired的使用以及分析
                        吴巴格
spring源码springjava后端
                        
    @Autowired@Autowired一、基本信息二、注解描述三、接口源码四、主要功能五、最佳实践六、时序图七、源码分析前置条件收集阶段注入阶段八、注意事项九、总结最佳实践总结源码分析总结一、基本信息转载自github，在此作为个人备份二、注解描述@Autowired注解，用于实现依赖注入（DependencyInjection,DI）。当我们在Spring中定义了一个Bean并想要使用另一个B
    
                    
    • 
                    
  • 【spring源码分析】@ComponentScan的使用以及分析
                        吴巴格
spring源码springjava后端springboot
                        
    @ComponentScan@ComponentScan一、基本信息二、注解描述三、注解源码四、主要功能五、最佳实践六、时序图七、源码分析八、注意事项九、总结最佳实践总结源码分析总结一、基本信息转载自github，在此作为个人备份二、注解描述@ComponentScan注解，用于自动扫描特定包（和其子包）中的组件，并自动注册为Spring容器中的bean。当我们使用SpringBoot，它默认会扫
    
                    
    • 
                    
  • Spring源码分析之——AOP动态代理的选择
                        lsunwing
SpringSpringAOP动态代理
                        
    上一篇《Spring源码分析之——AOP的原理及初始化细节》讲到AOP的原理和细节，这一篇补充一下动态代理的选择代码细节。我们知道动态代理分两种，JDK动态代理和Cglib动态代理，那么Spring选用的哪个呢？右半部分可以看到AopProxy下面有Cglib和JDK两种，至于创建哪种，是左边工厂DefaultAopProxyFactory负责创建的，带着这个图看源码。1、后置处理器判断是否需要动
    
                    
    • 
                    
  • Spring源码分析---BeanFactory 后置处理器 05
                        渣渣龙_拽得很
Spring源码springjava后端
                        
    来源：Spring5.1常见的BeanFactory后置处理器先引入要用到的依赖：org.mybatis.spring.bootmybatis-spring-boot-starter2.3.0com.alibabadruid-spring-boot-starter1.2.15mysqlmysql-connector-java需要用到的类信息：packagetest.bean.a05;@Config
    
                    
    • 
                    
  • spring源码分析-XML对应BeanDefinition存入BeanDefinitionRegistry流程
                        普通小马鹿~
springxml
                        
    1.流程图2.源码分析刷新容器其实就是初始化容器创建bean其中有对xml的解析就是一下这些信息（用spring中的这些信息来解析dom）这个map存在DefaultListbleBeanFactory中
    
                    
    • 
                    
  • Spring源码分析（三） XmlBeanDefinitionReader
                        skyguard

                        
    之前的文章说过，在ioc容器启动时,ApplicationContext的refresh方法里初始化容器,在XmlWebApplicationContext的loadBeanDefinitions方法里调用XmlBeanDefinitionReader读取xml配置文件,那么XmlBeanDefinitionReader是怎么读取配置文件的呢。这篇文章我们就来说一下。先来看一下XmlBeanDef
    
                    
    • 
                    
  • Spring源码分析（四） AnnotationConfigBeanDefinitionParser
                        skyguard

                        
    之前我们说了XmlBeanDefinitionReader是怎么读取xml配置文件的，那么其实我们都知道,spring的bean配置有2种方式，一种是xml文件配置,一种是注解配置,那么spring是怎么解析注解并注册到ioc容器中的呢,这篇文章我们就来看看spring是怎么做的。这里我们就要介绍一个类AnnotationConfigBeanDefinitionParser,这个类实现了BeanD
    
                    
    • 
                    
  • 聊一聊Spring Bean 的生命周期
                        虚无火星车
springjavamybatis
                        
    讲一讲SpringBean的生命周期算是面试时候一道非常经典的问题了！如果没有研究过Spring源码，单纯去背面试题，这个问题也是可以回答出来的，但是单纯的背缺乏理解，而且面试一紧张，就容易背岔了。但是如果你从头到尾看了松哥的Spring源码分析，那么这个问题就不需要背了，就根据自己对Spring源码的理解讲出来就行了。在前面的文章中，松哥和大家分析了Spring中Bean的创建是在createB
    
                    
    • 
                    
  • Spring源码分析之Spring的事务管理
                        yinlongfei_love
做技术的小笔记javaSpring
                        
    背景Spring统一的事务管理方式非常的巧妙和有趣，为了一探究竟，我们来深入研究，探索一番，这里从源码级别来一层一层的拨开它简单操作下面的具体原理PlatformTransactionManager我们先来看一下关系类图Spring为了方便事务的管理和统一，在PlatformTransactionManager中设计的内容非常的简单，只有三个方法。从方法名中我们可以看出，这个接口在顶层设计时需要完
    
                    
    • 
                    
  • Spring源码分析二十四 ： cglib 的代理过程
                        猫吻鱼
#源码分析篇spring
                        
    文章目录一、前言1.org.springframework.cglib.proxy.Callback二、代理对象的创建1.CglibAopProxy#getCallbacks2.ProxyCallbackFilter三、Cglib的拦截器1.aopInterceptor1.1ProxyFactory#getInterceptorsAndDynamicInterceptionAdvice1.2Cgl
    
                    
    • 
                                
  • sql统计相同项个数并按名次显示
                                    朱辉辉33
javaoracle
                                    
    现在有如下这样一个表： 
A表 
ID Name time 
------------------------------ 
0001 aaa 2006-11-18 
0002 ccc 2006-11-18 
0003 eee 2006-11-18 
0004 aaa 2006-11-18 
0005 eee 2006-11-18 
0004 aaa 2006-11-18 
0002 ccc 20
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列-目录
                                    白糖_
JQuery Mobile
                                    
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。 
  
从现在起，往后一段时间，我打算
    
                                
    • 
                                
  • 如何给线程池命名
                                    daysinsun
线程池
                                    
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下： 
    
public class Named
    
                                
    • 
                                
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
                                    周凡杨
html解析errorreadyState
                                    
      
错误：  IE   中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"      
  
  
现象：  同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    
                                
    • 
                                
  • java上传
                                    g21121
java
                                    
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 
下面是servlet的代码： 
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    
                                
    • 
                                
  • SpringMVC配置学习
                                    510888780
springmvc
                                    
    spring MVC配置详解 
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 
 
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    
                                
    • 
                                
  • spring mvc-jfreeChart 柱图(1)
                                    布衣凌宇
jfreechart
                                    
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 
第二步：配置web.xml; 
web.xml代码如下 
<servlet> 
    <servlet-name>jfreechart</servlet-nam
    
                                
    • 
                                
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    
                                
    • 
                                
  • java 线程池使用 Runnable&Callable&Future
                                    antlove
javathreadRunnablecallablefuture
                                    
    1. 创建线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 
  
2. 执行一次线程，调用Runnable接口实现 
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    
                                
    • 
                                
  • XML语法元素结构的总结
                                    百合不是茶
xml树结构
                                    
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    
                                
    • 
                                
  • 改变eclipse编码格式
                                    bijian1013
eclipse编码格式
                                    
    1.改变整个工作空间的编码格式 
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。 
        Eclipse->window->preferences->General->workspace-
    
                                
    • 
                                
  • javascript中return的设计缺陷
                                    bijian1013
JavaScriptAngularJS
                                    
    代码1： 
<script>
var gisService = (function(window) 
{ 

    return
    {
        name:function ()
        {
            alert(1);
        }
    };

})(this);

gisService.name();
&l
    
                                
    • 
                                
  • 【持久化框架MyBatis3八】Spring集成MyBatis3
                                    bit1129
Mybatis3
                                    
    pom.xml配置 
Maven的pom中主要包括： 
 
 MyBatis 
 MyBatis-Spring 
 Spring 
 MySQL-Connector-Java 
 Druid 
 applicationContext.xml配置     
<?xml version="1.0" encoding="UTF-8"?>
&
    
                                
    • 
                                
  • java web项目启动时自动加载自定义properties文件
                                    bitray
javaWeb监听器相对路径
                                    
    创建一个类 
public class ContextInitListener implements ServletContextListener 
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 
 
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 
 

    <listener>
        <des
    
                                
    • 
                                
  • 用nginx区分文件大小做出不同响应
                                    ronin47

                                    
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    
                                
    • 
                                
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Random;

public class ContinuousPoker {

    /**
     * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
     * 2-10为数字本身，A为1，J为1
    
                                
    • 
                                
  • 翟鸿燊老师语录
                                    ccii
翟鸿燊
                                    
    一、国学应用智慧TAT之亮剑精神A 
1. 角色就是人格 
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。 
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    
                                
    • 
                                
  • [光速与宇宙]进行光速飞行的一些问题
                                    comsci
问题
                                    
     
 
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家 
    仅仅是猜想。。。未经官方证实 
 
 
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    
                                
    • 
                                
  • oracle undo解析
                                    cwqcwqmax9
oracle
                                    
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 
 
Undo是干嘛用的？         &nb
    
                                
    • 
                                
  • java中各种集合的详细介绍
                                    dashuaifu
java集合
                                    
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    
                                
    • 
                                
  • 卸载windows服务的方法
                                    dcj3sjt126com
windowsservice
                                    
    卸载Windows服务的方法 
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    
                                
    • 
                                
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
                                    dcj3sjt126com
iosxcode
                                    
           
      
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html 
Excerpt: 
 
 You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    
                                
    • 
                                
  • 2014之C++学习笔记（一）
                                    Etwo
C++EtwoEtwoiterator迭代器
                                    
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    
                                
    • 
                                
  • js跨越获取数据问题记录
                                    haifengwuch
jsonpjsonAjax
                                    
    js的跨越问题，普通的ajax无法获取服务器返回的值。 
 
  第一种解决方案，通过getson，后台配合方式，实现。 
Java后台代码： 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException { 
String ca
    
                                
    • 
                                
  • 蓝色jQuery导航条
                                    ini
JavaScripthtmljqueryWebhtml5
                                    
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    
                                
    • 
                                
  • linux部署jdk,tomcat,mysql
                                    kerryg
jdktomcatlinuxmysql
                                    
    1、安装java环境jdk: 
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。 
   1.1）、卸载： 
     （rpm -qa :查询已经安装哪些软件包； 
       rmp -q 软件包：查询指定包是否已
    
                                
    • 
                                
  • DOMContentLoaded VS onload VS onreadystatechange
                                    mutongwu
jqueryjs
                                    
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 
 
2. onload是最早支持的事件，要求所有资源加载完毕触发。 
 
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    
                                
    • 
                                
  • sql批量插入数据
                                    qifeifei
批量插入
                                    
    hi， 
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。 
   
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    
                                
    • 
                                
  • log4j打印日志文件 如何实现相对路径到 项目工程下
                                    thinkfreer
Weblog4j应用服务器日志
                                    
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 
 
 
需求： 
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    
                                
    • 
                                
  • linux下mysql-5.6.23.tar.gz安装与配置
                                    笑我痴狂
mysqllinuxunix
                                    
    1.卸载系统默认的mysql 
 
[root@localhost ~]# rpm -qa | grep mysql 
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    
                                
    •