未城居士
未城居士

Spring事务杂记

org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction

public final TransactionStatus getTransaction(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();
       }

       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);
               doBegin(transaction, definition);
               prepareSynchronization(status, definition);
               return status;
           }
           catch (RuntimeException ex) {
               resume(null, suspendedResources);
               throw ex;
           }
           catch (Error err) {
               resume(null, suspendedResources);
               throw err;
           }
       }
       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);
       }
   }

属性处理

    protected TransactionInfo prepareTransactionInfo(PlatformTransactionManager tm,
            TransactionAttribute txAttr, String joinpointIdentification, TransactionStatus status) {

        TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
        if (txAttr != null) {
            // We need a transaction for this method...
            if (logger.isTraceEnabled()) {
                logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
            }
            // The transaction manager will flag an error if an incompatible tx already exists.
            txInfo.newTransactionStatus(status);
        }
        else {
            // The TransactionInfo.hasTransaction() method will return false. We created it only
            // to preserve the integrity of the ThreadLocal stack maintained in this class.
            if (logger.isTraceEnabled())
                logger.trace("Don't need to create transaction for [" + joinpointIdentification +
                        "]: This method isn't transactional.");
        }

        // We always bind the TransactionInfo to the thread, even if we didn't create
        // a new transaction here. This guarantees that the TransactionInfo stack
        // will be managed correctly even if no transaction was created by this aspect.
        txInfo.bindToThread();
        return txInfo;
    }
Spring事务杂记_第1张图片
image.png
Spring事务杂记_第2张图片
image.png 
protected final class TransactionInfo {

        private final PlatformTransactionManager transactionManager;

        private final TransactionAttribute transactionAttribute;

        private final String joinpointIdentification;

        private TransactionStatus transactionStatus;

        private TransactionInfo oldTransactionInfo;
        
}

org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

protected Object invokeWithinTransaction(Method method, Class targetClass, final InvocationCallback invocation)
            throws Throwable {

        // If the transaction attribute is null, the method is non-transactional.
        final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        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 {
            final ThrowableHolder throwableHolder = new ThrowableHolder();

            // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
            try {
                Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
                        new TransactionCallback() {
                            @Override
                            public Object doInTransaction(TransactionStatus 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.
                                        throwableHolder.throwable = ex;
                                        return null;
                                    }
                                }
                                finally {
                                    cleanupTransactionInfo(txInfo);
                                }
                            }
                        });

                // Check result state: It might indicate a Throwable to rethrow.
                if (throwableHolder.throwable != null) {
                    throw throwableHolder.throwable;
                }
                return result;
            }
            catch (ThrowableHolderException ex) {
                throw ex.getCause();
            }
            catch (TransactionSystemException ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                    ex2.initApplicationException(throwableHolder.throwable);
                }
                throw ex2;
            }
            catch (Throwable ex2) {
                if (throwableHolder.throwable != null) {
                    logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                }
                throw ex2;
            }
        }
    }
 
 
    @Override
    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, new InvocationCallback() {
            @Override
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }

 
 
这是切面AOP的包
 org.springframework.aop.framework.ReflectiveMethodInvocation#proceed
 
 
@Override
    public Object proceed() throws Throwable {
        //  We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

 
 
上面的反射包会走到下面的类，
 
 
    /**
     * Implementation of AOP Alliance MethodInvocation used by this AOP proxy.
     */
    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

        private final MethodProxy methodProxy;

        private final boolean publicMethod;

        public CglibMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
                Class targetClass, List interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {

            super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);
            this.methodProxy = methodProxy;
            this.publicMethod = Modifier.isPublic(method.getModifiers());
        }

        /**
         * Gives a marginal performance improvement versus using reflection to
         * invoke the target when invoking public methods.
         */
        @Override
        protected Object invokeJoinpoint() throws Throwable {
            if (this.publicMethod) {
                return this.methodProxy.invoke(this.target, this.arguments);
            }
            else {
                return super.invokeJoinpoint();
            }
        }
    }
 
 
反射invoke后会走到真正的方法
 org.springframework.cglib.proxy.MethodProxy#invoke
 
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;

        try {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // May be null. Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            // Get the interception chain for this method.
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }

            // Massage return value if necessary.
            Class returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                // Special case: it returned "this" and the return type of the method
                // is type-compatible. Note that we can't help if the target sets
                // a reference to itself in another returned object.
                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
 
 
org.springframework.aop.framework.JdkDynamicAopProxy#invoke
 
 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;

        try {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // May be null. Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            // Get the interception chain for this method.
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }

            // Massage return value if necessary.
            Class returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                // Special case: it returned "this" and the return type of the method
                // is type-compatible. Note that we can't help if the target sets
                // a reference to itself in another returned object.
                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
 
 
获取目标类
 TargetSource targetSource = this.advised.targetSource;
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 通过链，创建invocation
 执行方法
 retVal = invocation.proceed();
 
 
会走到
 org.springframework.transaction.interceptor.TransactionInterceptor#invoke
 
 
    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, new InvocationCallback() {
            @Override
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }

 
 
很明显，有进行事务处理的逻辑
 
 
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
 
 
 
  
 
   
 Spring事务杂记_第3张图片 
   
 
  
 
  

    image.png 
  
 
 
 
 
调用路线：
 org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor#intercept
 org.springframework.aop.framework.CglibAopProxy.CglibMethodInvocation
 org.springframework.aop.framework.CglibAopProxy#processReturnType
 
 
org.springframework.aop.framework.JdkDynamicAopProxy#invoke
 
 
chain
 
 
org.springframework.aop.framework.ReflectiveMethodInvocation#proceed
 org.springframework.transaction.interceptor.TransactionInterceptor#invoke
 org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction
 
 
     
  
  • org.springframework.transaction.interceptor.TransactionAspectSupport#createTransactionIfNecessary
    •  
  
  • org.springframework.transaction.support.AbstractPlatformTransactionManager#getTransaction
    •  
  
  • org.springframework.transaction.support.AbstractPlatformTransactionManager#handleExistingTransaction
    •  
  
  • org.springframework.transaction.interceptor.TransactionAspectSupport#prepareTransactionInfo
     回调
     org.springframework.aop.framework.ReflectiveMethodInvocation#proceed
    •  
 
 
 
org.springframework.aop.framework.ReflectiveMethodInvocation#invokeJoinpoint
 org.springframework.aop.support.AopUtils#invokeJoinpointUsingReflection
 java.lang.reflect.Method#invoke
 com.gongdao.middleware.api.impl.LocalServiceImpl#newTransitionMethod
 org.springframework.transaction.interceptor.TransactionAspectSupport#cleanupTransactionInfo
 org.springframework.transaction.interceptor.TransactionAspectSupport#cleanupTransactionInfo
 org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo#restoreThreadLocalStatus
 org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturning
 org.springframework.transaction.support.AbstractPlatformTransactionManager#commit
 org.springframework.transaction.support.AbstractPlatformTransactionManager#processCommit
 com.gongdao.middleware.db.GongDaoDataSourceTransactionManager#doCommit
 org.springframework.transaction.support.AbstractPlatformTransactionManager#triggerAfterCommit
 org.springframework.transaction.support.AbstractPlatformTransactionManager#triggerAfterCompletion
 ......
 org.springframework.transaction.support.AbstractPlatformTransactionManager#cleanupAfterCompletion
 com.gongdao.middleware.db.GongDaoDataSourceTransactionManager#doCleanupAfterCompletion
 
 
 
  
 
   
 Spring事务杂记_第4张图片 
   
 
  
 
  

    image.png 
  
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring事务杂记)

        

            

                
    
                    
  • 厦门自由行之第一天:
                        大苏子在广漂

                        
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • 家庭杂记 2022.03.14
                        怡然自得的花花

                        
    1今天是孩子们居家学习的第一天，姐姐的第一次网课的第一堂课是班队课。老师在给孩子们讲了一些关于YQ当中在家学习时，如果遇到一些心理上的问题要如何去化解和处理的方法。晚上我和老马在讨论的时候就觉得现在的老师们或者说现在的教学在这一点上还是真是和我们那时候比起来进步了不少，开始更多地在关心孩子们的心理健康。我们所在片区虽然是FF区，但老马为了不给同事们造成一些心理压力，也主动提出了居家办公，可能接下来
    
                    
    • 
                    
  • 大四合院杂记(四十三，六相公的梦想就是吃饱饭)
                        高领001

                        
    四十三，六相公的梦想就是吃饱饭六相公是村里的五保户，一直单门独户，我们这些小屁孩的，小一点的喜欢听他讲故事，稍微大一点了，就会跟着更大一点的孩子瞎起哄：“相公相公，穿个花衣衫，娶个麻子婆，生个孩子没屁眼！”听他讲故事那时候，他很高兴，他喜欢讲他小时候受苦的故事，解放前，给财主放牛，吃不饱，穿不暖，还会挨打。他那时的梦想就是能吃饱饭。因为他是孤儿，住的地方是茅草棚子，夏天外面下大雨，里面下小雨；冬天
    
                    
    • 
                    
  • 放风筝杂记
                        心和

                        
    今天，我从平台买的风筝到了。正好是星期天，正好春暖，正好有和煦的微风，儿子自己挑的风筝，收到，他自然高兴，欢喜打开，安装好，我们俩一起去东边麦田里放风筝。我长这么大，还是第一次放飞风筝。儿子小，他把放风筝的任务交给了我，在我的记忆中，风筝开始要起跑才能飞起，我试了两次，不是这样。应该是边放飞边松拉线，风筝就上飞了，我放着轮里的线，它边随着线的增长而飘摇向上，直到我将线放的很长很长，它飞得很高很高，
    
                    
    • 
                    
  • Spring事务传播行为详解（超详细）
                        yuans_
springspring事务传播行为
                        
    文章出自：Spring事务传播行为详解前言Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正
    
                    
    • 
                    
  • Spring事务传播行为详解
                        Aries263
spring数据库java
                        
    在Spring框架中，事务管理是一个至关重要的部分，它确保了数据的一致性和完整性。Spring提供了灵活的事务传播行为，允许开发者根据具体场景选择不同的事务管理方式。本文将详细介绍Spring的七种事务传播行为，并通过示例代码来展示它们的具体应用。1.Spring事务传播行为概述Spring事务的传播行为定义了当一个事务方法被另一个事务方法调用时，两个方法之间的事务应该如何协调和传播。Spring
    
                    
    • 
                    
  • 元日杂记
                        花委尘

                        
    2019年的元旦，难得睡了个懒觉。醒来，朋友圈一片喜气洋洋迎新岁，各种群内红包漫天洒。我羡慕生活中这些无忧无虑，活色生香，离我似乎总远了一米。出门兜了一圈，天气倒随我，没有见雪为晴，而是一种逼仄的阴冷。说是白天，却有一种奇怪的亮，是老天爷一种似笑非笑，似哭非哭的表情。大概他也在尴尬着，摆不平雨雪风晴各路人马。我对这位老天爷很是无奈，因为他摆平了我。我在他面前谨小慎微，言听计从，可是他不偏爱我。自从
    
                    
    • 
                    
  • 如何利用马桶时间？
                        琴弦X

                        
    琴弦一．读闲书马上、枕上、厕上。这是古人读闲书的三个指定位置。三日不读书，你就会有像没洗澡一样，一声脏污秽亏。古人还云：“有书真富贵，无事小神仙”。闲人读闲书，可以说是地上神仙，享尽人间清福。闲中觅伴书为上，身外无求睡最安，是非荣辱不到处，卷书一榻清昼眠。于是我总坐在马桶上翻个几页，不管是漫话杂志，还是画册小集，亦或是小诗杂记，还真有些，身心一起清的感觉。二．写杂记。趁着如此轻松，静谧之际，写上几
    
                    
    • 
                    
  • 病中杂记
                        Aaron_Swartz

                        
    ＊以前，总是认为自己喜欢运动，便可以疏忽对身体的照料。然，昨２日突染感冒，发烧。当夜甚是痛苦，整夜不得眠，欲求药而不得，只能忍着。中间起来好几回，都是弄水给自己喝。以至于两日不敢洗澡，衣物也不敢更换。白天到公司效率低下，然吾心中纵使有百般不愿，也只能独自承受，旁人亦不得见，意志消沉，天线落下。回到家中，暖气亦坏，其中心情，可想而知。但皆此种种，皆有因果，不造恶业，不得恶果。不做好事，焉得福报。回家
    
                    
    • 
                    
  • 刘大杰《中国文学发展史》读书笔记48
                        小神仙记录薄

                        
    短篇小说的进展（一）严格地说起来，我国六朝时代的小说，还没有成形。这并不是因其内容的荒谬，而是因其形式与描写的拙劣与贫弱。六朝的作品，只是一些没有结构的残丛小语式的杂记，叙事没有布置，文笔亦极俗浅，实在还算不得小说。中国的文言短篇小说，在艺术上发生价值，在文学史上获得地位，是起于唐代的传奇。那些传奇，建立了相当完满的短篇小说的形式，由杂记式的残丛小语，变为洋洋大篇的文字，由三言两语的记录，变为非常
    
                    
    • 
                    
  • 日常杂记
                        沙雕少女最优秀

                        
    今天10月5日，日更第二天，今天的天气极其寒冷，两个字形容，那就是“真爽”！不知怎么的，大部分地区强降温，着实让许多人都受不了，关键是昨天已经和朋友约好出来游玩，怎么也没想到这么冷的天气，因为只是国庆回家，没有拿太厚的衣服，但家里的衣服又全都搬到了学校，就这样，我成了没有厚衣服穿的小孩。图片发自App骑电动车走在路上，耳边风声呼呼，大树的叶子也被吹得呼啦啦全掉了下来，给人一种好清冷的感觉，路上也有
    
                    
    • 
                    
  • 2020杂记（106）万物都有自己的节奏
                        宁超群

                        
    1我不仅入睡难，醒得早，睡眠还很浅，半夜有一丁点声音就会醒过来，半天睡不着。偏偏卧室外面的空地正在修建学校和市场，有时候通夜都是机器的轰鸣声。最近一段时间，醒得越来越早，醒后就再也睡不着。凌晨五点左右，会全身发热。白天老是犯困，身体总是僵着，像是黏着牛皮糖一样，连脑袋也不灵光了，做事效率越来越低。“我是不是早更了？”我跟朋友开玩笑。“啥早更？你现在更已经是正常时间段了。”“你找打哦！”“你的身体节
    
                    
    • 
                    
  • 日常杂记
                        气体_81bd

                        
    随着孩子一天天长大，专职宝妈的心中也因为和社会越来越脱节而心生惶恐，最近的状态就是：如果哪天看书了，心情就好点，否则就处于急躁加恐慌。这不，刚刚妈妈接了个电话，是一个从小看我长大的叔叔的，他听到我专职在家带孩子，很是诧异，居然连问了三遍确认，我听到了，心中更是无奈，看娃娃真的是占据太多时间，完全没有自己的空间，不知道什么时候能好点呢？还好，有盼头，等她上幼儿园了，我就可以重新回职场了，但是这之前真
    
                    
    • 
                    
  • 2024最新Java岗面试清单：15个技术模块（程序员必备）
                        2401_85125308
java面试开发语言
                        
    Spring的AOP和IOC是什么？使用场景有哪些？Spring事务，事务的属性，数据库隔离级别Spring和SpringMVC，MyBatis以及SpringBoot的注解分别有哪些？SpringCould组件有哪些，它们的作用是什么？微服务的CAP是什么？BASE是什么？HashMap底层实现原理，红黑树，B+树，B树的结构原理，CAS（比较与交换）实现原理Redis支持的数据类型以及使用场景
    
                    
    • 
                    
  • 2020杂记（102）整合资源进课堂
                        宁超群

                        
    【摘录】制作《银汤匙》研究笔记时，先生会借助词典、百科事典等彻底查阅，但即便如此，也依然会有搞不清楚的地方。那该怎么办呢？据说，先生是直接写信向当时健在的《银汤匙》作者中勘助先生求教。《全世界都想上的课》P37【感悟】仅从桥本先生对教材的研究精神，我们也会被他折服，期待着能上他的课。借助工具书彻底查阅，我们平时在做教学准备的时候，也会用到，不算稀奇。但是桥本先生能够主动去联系作者来解答疑惑，却是我
    
                    
    • 
                    
  • 回乡杂记|三三探幽
                        之川_f6c2

                        
    我知道影子没有求用，但是我要找回我的影子。我已经走了很久的路，很远很远。我记得我穿过了一片松林，厚厚的绵软的松针让双脚无比舒适。不时，在路边看到松针层凸起的小包，我轻轻地将它扒开，一朵或几朵奶黄而油滑的菌子显露出来，鲜艳而丰满，让我精神倍振。我记得我经过了一片坟堆，荒凉、破败，夕阳斜照残碑，我有时弯腰辨认碑上的字迹。生不闻名，死或留志，这或许也是人生一点安慰。我坐在一个垮落的坟旁，想起了写聊斋的蒲
    
                    
    • 
                    
  • 【生活杂记】夜游黄鹤楼
                        7未末

                        
    夜游黄鹤楼明天正式对外开放了，今天是预演出，在开场前的半小时，我被通知去观看。好在距离黄鹤楼很近，10分钟后，我准时到达。没有看到预告，一切都是未知，我随着人流停留在了第一处表演区，幻彩留影，明月当空，秋风送爽，夜登黄鹤楼，可谓精神气爽。一切好似没有发生即使这么大的疫情面前，黄鹤楼经历这场疫情洗礼后，经过半年的策划，惊艳在武汉人民面前，除了震撼，就是骄傲。黄鹤一去不复返，白云千载空悠悠。黄鹤楼在1
    
                    
    • 
                    
  • 上海杂记（一）
                        隔壁的小宝

                        
    上次游历祖国的大好河山还是差不多8年前。现在想来，只记得去了西安古城。那段稀稀散散的记忆，如今却怎么也没办法想起来当时游历的心情。或许是因为时间太过长久，也或许是因为那时的注意力更多的在于游玩，而并不是细细体会一座城市独特的魅力。我暗暗想，阔别十七年之后，今年在去上海上课时一定要用心感受这座城市的物，景与生活。我是个北方人，在北京生活了多年早已习惯了北方初春满天飞舞的白絮，盛夏令人汗流浃背的闷热，
    
                    
    • 
                    
  • 杂记
                        那只树懒

                        
    在支付宝玩打卡，突然好多小哥哥要加我好友，妈耶，这是什么情况(゜ロ゜)？这么多空窗期的单身汪吗？如果是真的，在学校不应该又大把女孩可以追吗，何必在虚拟世界里这么累⊙﹏⊙。况且网上聊天和当面聊天感觉也不一样呐，就像在实体店和网络上购物一个道理。只不过实体店看好可以网上下单，人，倒是没有同款。呐呐呐呐，也可能是我头像太好看了(｡･ω･｡)ﾉ
    
                    
    • 
                    
  • 【杂记-浅谈LACP链路聚合技术】
                        叫我小虎就行了
网络工程进阶知识LCAP链路聚合
                        
    浅谈LACP链路聚合技术一、LACP协议概述二、LACP的工作原理及要点三、LACP的配置与协商一、LACP协议概述1、概念①LinkAggregationControlProtocol，LACP，即链路聚合协议，它可以将多个物理链路聚合成一个逻辑链路，以提高带宽和冗余性。LACP通过链路聚合控制协议数据单元（LACPDU）与对端设备交互信息，维护链路聚合组的形成和运行状态。②链路聚合并不具备天然
    
                    
    • 
                    
  • 期中考试后杂记
                        悠之不语斋

                        
    期中考试后杂记期中考试结束了。为期两天的期中考试今天终于结束了，早上7:20，最后一场生物考试结束了，学生们脸上有抑制不住的喜悦，看得出考试后还很放松。是呀，接连两个周周六补课，周日下午4:00到校，休息时间都被挤走了。这次难得有自由时间，难怪她们欢喜至极。学生离校后，我继续评卷，组里消息说，一定要在上午离校之前评完，只有加班了。直到七年级学生离校走完，评卷工作才结束。罗同学，找我汇报了卫生打扫的
    
                    
    • 
                    
  • Spring的事务控制
                        咸鱼有梦想呀

                        
    一、Spring的事务控制分层开发，事务处理位于业务层，Spring提供了分层设计业务层的事务处理解决方案。Spring提供了一组事务控制的接口。这组接口是在spring-tx-4.2.4.RELEASE.jar中。Spring的事务都是基于AOP的，既可以使用配置的方法实现，也可以使用注解的方法实现。二、Spring事务控制的API介绍PlatformTransactionManager这个接口
    
                    
    • 
                    
  • 杂记
                        何洁1981

                        
    每一代人都有其鲜明特色，这可能也是一种时代特色。也有些是一种年龄特色，也许是成长中某一阶段的特色。最大的善意：不给别人添麻烦。昨晚很冷，零下十几度了。我看到老大在群上说，她家里停电停暖了，家里黑漆漆的，冻的受不了。我家六楼的房子八月初才装修完，虽然说是用的无醛板，但家里两个孩子都太小，考虑了下还是没有入住，准备在放上半年。于是我告诉她，可以到我家去住，水电暖气应有尽有。她同意了，最终确没有来，因为
    
                    
    • 
                    
  • 《论语》共读·每天一句话
                        边丽红

                        
    阳货19孺悲欲见孔子，孔子辞以疾。将命者出户，取瑟而歌，使之闻之。*今译：孺悲想拜见孔子，孔子以生病为由拒绝了。传话的人刚出门，孔子便取下瑟来边弹边唱，故意让孺悲听见。注解：1.孺悲，是鲁国人，《礼记·杂记》有记载：“恤由之丧，哀公使孺悲之孔子学士丧礼，士丧礼于是乎书。”孺悲曾经奉鲁哀公之命，来向孔子学习士的丧礼礼仪规范，并且书写传下来，所以孺悲也算是孔子的学生。2.孔子不见他，大概是另一次，他不
    
                    
    • 
                    
  • 20210307-周末杂记
                        Aubzhang

                        
    20210307-周末杂记。周末对于小商人来说逐步将成为稀缺品。年少打工岁月，不懂何为压力，对于周末无比期待，到了周末也就是休息与享受，现在想来时光流逝却并无积累，甚是可惜。随着年龄增长，角色转换，肩上责任逐步增加，对于时间、人生、自我的认知有了转变，外部环境与内心欲望使人无法停下来，倒是挺享受周末工作的那种感觉——寂寞、精神、自由、努力、无助、无奈、兴奋、疯狂、焦躁、忧郁、幸福，一个中年男人的状
    
                    
    • 
                    
  • 一个爱喝酒的女人是什么样子
                        简枝残春

                        
    已经很久不写文了，但是有趣的事还是得坚持记录一下，过了很久再来翻翻，真真是一种时光的味道徜徉其中[得意]喝酒趣事杂记一图片发自App到古镇已临近傍晚，天色略显昏沉，但溪头古镇却是热闹。在印象中，中国人卖东西是是热闹非凡，各类贩夫走卒使出十八般武艺喊买。不不不，大错特错，这个地方的人，只要看到新奇古怪的东西就往上凑，商贩甚至来不及叫卖，东西就已经买完了，然后催促着旁边的丈人去取货，感觉东西都是不要钱
    
                    
    • 
                    
  • 2020-02-04
                        张林茂

                        
    《杂记3》冬日六点夜未明大饼豆腐裹腹中工作闲暇把棋下输多赢少犯头疼人不为己不可能利他思维更盛行劝君凡事好处想悲欢离合转头空与人为善是习惯吃好睡好我看行
    
                    
    • 
                    
  • 心情杂记1
                        往事随风轻烟一缕

                        
    每逢冬天变异常的焦躁不安，兴许是因为天气寒冷，兴许是因为别的。这段时间莫名其妙的变得懒懒散散，啥事都不想做，被毕业论文忙的晕头转向，却还是没多少头绪，每周一本书的生活也没有继续，整个人堕落不堪，整天浑浑噩噩，一睁眼一闭眼就一天。
    
                    
    • 
                    
  • 黑屋子（348）杂记
                        山的儿女2

                        
    网络日记散记随笔一、自我管理保持情绪稳定，为人处事不要闹情绪。人在发怒时，基本丧失了理智，智商几乎为零。我们之所以会在一些人事面前，情绪彻底失去控制，是因为遇到了问题，遇到了难题和苦难。要想事情顺利进展，我们的标的还是解决问题、走出苦难。而发怒、职责和抱怨除了伤害了自己和相关当事人，破坏了周边环境的愉悦、和睦气氛，于解决问题是没有任何意义的。而且，这种负面情绪对人体能量的耗损，比正常工作、学习、生
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIPHPandroidlinux
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
                                    bozch
.net.net mvc
                                    
    在.net mvc5中，在执行某一操作的时候，出现了如下错误： 
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  
&
    
                                
    • 
                                
  • Java 对象大小的计算
                                    e200702084
java
                                    
                              Java对象的大小 
 
如何计算一个对象的大小呢？ 
 
 
   
    
                                
    • 
                                
  • Mybatis Spring
                                    171815164
mybatis
                                    
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    
                                
    • 
                                
  • JVM 不稳定参数
                                    g21121
jvm
                                    
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    
                                
    • 
                                
  • 用户自动登录网站
                                    永夜-极光
用户
                                    
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 
2.思路:将用户的信息保存为cookie 
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    
                                
    • 
                                
  • centos7 安装后失去win7的引导记录
                                    程序员是怎么炼成的
操作系统
                                    
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    
                                
    • 
                                
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
                                    aijuans
oracle
                                    
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio_V3.2发布了
                                    無為子
AOPoraclemysqljavaeeG4Studio
                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。 
  
访问G4Studio网站  
http://www.g4it.org      
G4Studio_V3.2版本变更日志 
功能新增 
(1).新增了系统右下角滑出提示窗口功能。 
(2).新增了文件资源的Zip压缩和解压缩
    
                                
    • 
                                
  • Oracle常用的单行函数应用技巧总结
                                    百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数
                                    
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 
一:字符函数: 
   .UPPER(字符串) 将字符串转为大写
   .LOWER (字符串) 将字符串转为小写 
   .INITCAP(字符串) 将首字母大写
   .LENGTH (字符串) 字符串的长度
   .REPLACE(字符串,'A','_') 将字符串字符A转换成_

    
                                
    • 
                                
  • Mockito异常测试实例
                                    bijian1013
java单元测试mockito
                                    
    Mockito异常测试实例： 
package com.bijian.study;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;

import org.mockito.
    
                                
    • 
                                
  • GA与量子恒道统计
                                    Bill_chen
JavaScript浏览器百度Google防火墙
                                    
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下： 
  
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    
                                
    • 
                                
  • 【Linux命令三】Top命令
                                    bit1129
linux命令
                                    
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： 
  
  
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total,   4 running, 198 sl
    
                                
    • 
                                
  • spring四种依赖注入方式
                                    白糖_
spring
                                    
       平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    
                                
    • 
                                
  • angular.injector
                                    boyitech
AngularJSAngularJS API
                                    
    angular.injector 
   描述:   创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.        使用方法:   angular.injector(modules, [strictDi])        参数详解:      Param Type Details   mod
    
                                
    • 
                                
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
                                    bylijinnan
Integer
                                    
    

public class PC {

	/**
	 * 题目：生产者-消费者。
	 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
	 */
	
	private static final Integer[] val=new Integer[10];
	private static
    
                                
    • 
                                
  • 使用Struts2.2.1配置
                                    Chen.H
apachespringWebxmlstruts
                                    
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar 
struts2-core-2.2.1.jar struts2-sp
    
                                
    • 
                                
  • [职业与教育]青春之歌
                                    comsci
教育
                                    
     
 
       每个人都有自己的青春之歌............但是我要说的却不是青春... 
 
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... 
 
  &nbs
    
                                
    • 
                                
  • oracle连接(join)中使用using关键字
                                    daizj
JOINoraclesqlusing
                                    
    在oracle连接(join)中使用using关键字 
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. 
Evaluate the following SQL statement: 
SELECT oi.order_id, product_id, order_date 
FRO
    
                                
    • 
                                
  • NIO示例
                                    daysinsun
nio
                                    
    NIO服务端代码： 
 

public class NIOServer {
	
	private Selector selector;

	
	public void startServer(int port) throws IOException {

		ServerSocketChannel serverChannel = ServerSocketChannel.open(
    
                                
    • 
                                
  • C语言学习homework1
                                    dcj3sjt126com
chomework
                                    
    0、 课堂练习做完 
1、使用sizeof计算出你所知道的所有的类型占用的空间。 
int x; 
sizeof(x); 
  
sizeof(int); 
  
# include <stdio.h>

int main(void)
{
	int x1;
	char x2;
	double x3;
	float x4;

	printf(&quo
    
                                
    • 
                                
  • select in order by , mysql排序
                                    dcj3sjt126com
mysql
                                    
    If i select like this: 
SELECT id FROM users WHERE id IN(3,4,8,1); 
This by default will select users in this order 
1,3,4,8, 
I would like to select them in the same order that i put IN() values so: 
    
                                
    • 
                                
  • 页面校验-新建项目
                                    fanxiaolong
页面校验
                                    
    $(document).ready(
	function() {
			var flag = true;
		$('#changeform').submit(function() {
			var projectScValNull = true;
			var s ="";
			var parent_id = $("#parent_id").v
    
                                
    • 
                                
  • Ehcache（02）——ehcache.xml简介
                                    234390216
ehcacheehcache.xml简介
                                    
    ehcache.xml简介 
  
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    
                                
    • 
                                
  • junit 4.11中三个新功能
                                    jackyrong
java
                                    
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 
 
 


import static org.junit.Assert.assertEquals;
 
import java.util.Arrays;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    
                                
    • 
                                
  • 国外程序员爱用苹果Mac电脑的10大理由
                                    php教程分享
windowsPHPunixMicrosoftperl
                                    
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 
1、Mac OS X 是基于 Unix 的 
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    
                                
    • 
                                
  • 位运算、异或的实际应用
                                    wenjinglian
位运算
                                    
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。 
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。 
      三． 位操作与空间压缩，针对筛素数进行空间压缩。 
   &n
    
                                
    • 
                                
  • weblogic部署项目出现的一些问题（持续补充中……）
                                    Everyday都不同
weblogic部署失败
                                    
    好吧，weblogic的问题确实…… 
  
问题一： 
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    
                                
    • 
                                
  • tomcat7性能调优（01）
                                    toknowme
tomcat7
                                    
      
    
Tomcat优化：   1、最大连接数最大线程等设置    
<Connector port="8082" protocol="HTTP/1.1" 
               useBodyEncodingForURI="t
    
                                
    • 
                                
  • PO VO DAO DTO BO TO概念与区别
                                    xp9802
javaDAO设计模式bean领域模型
                                    
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    
                                
    •