weixin_33950035
weixin_33950035

深度剖析一站式分布式事务方案Seata-Client

1.背景

在之前的文章中已经介绍过Seata的总体介绍，如何使用以及Seata-Server的原理分析，有兴趣的可以阅读下面的文章：

  • 深度剖析一站式分布式事务方案Seata-Server
  • 解密分布式事务框架-Fescar

这篇文章会介绍Seata中另外两个重要的角色TM(事务管理器)和RM(资源管理器)，首先还是来看看下面这张图:

上一个文章对于 TC的原理已经做了详细介绍，对于TM和RM我们看见在图中都是属于 client的角色,他们分别的功能如下:

  • TM(事务管理器):用来控制整个分布式事务的管理，发起全局事务的Begin/Commit/Rollback。
  • RM(资源管理器):用来注册自己的分支事务，接受TC的Commit或者Rollback请求.

2.Seata-Spring

首先我们来介绍一些Seata-client中Spring模块，Seata通过这个模块对自己的TM和RM进行初始化以及扫描AT模式和TCC模式的注解并初始化这些模式需要的资源。 在Seata的项目中有一个spring模块,里面包含了我们和spring相关的逻辑,GlobalTransactionScanner是其中的核心类:

public class GlobalTransactionScanner extends AbstractAutoProxyCreator implements InitializingBean,ApplicationContextAware,
        DisposableBean
复制代码

上面代码是类的定义，首先它继承了AbstractAutoProxyCreator实现了wrapIfNecessary方法实现我们的方法的切面代理，实现了InitializingBean接口用于初始化我们的客户端，实现了ApplicationContextAware用于保存我们的spring容器，实现了DisposableBean用于优雅关闭。

首先来看继承AbstractAutoProxyCreator实现的wrapIfNecessary

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (PROXYED_SET.contains(beanName)) {
            return bean;
        }
        interceptor = null;
        //check TCC proxy
        if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, applicationContext)) {
            //TCC interceptor， proxy bean of sofa:reference/dubbo:reference, and LocalTCC
            interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));
        } else {
            Class serviceInterface = SpringProxyUtils.findTargetClass(bean);
            Class[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);
            if (!existsAnnotation(new Class[]{serviceInterface})
                    && !existsAnnotation(interfacesIfJdk)) {
                return bean;
            }
            if (interceptor == null) {
                interceptor = new GlobalTransactionalInterceptor(failureHandlerHook);
            }
        }
        if (!AopUtils.isAopProxy(bean)) {
            bean = super.wrapIfNecessary(bean, beanName, cacheKey);
        } else {
            AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
            Advisor[] advisor = buildAdvisors(beanName, getAdvicesAndAdvisorsForBean(null, null, null));
            for (Advisor avr : advisor) {
                advised.addAdvisor(0, avr);
            }
        }
        PROXYED_SET.add(beanName);   
        return bean;
    }
复制代码
  • Step1：检查当前beanName是否已经处理过 如果处理过本次就不处理。
  • Step2：根据注解，找到对应模式的Inteceptor，这里有三种情况第一个TCC，第二个是全局事务管理TM的拦截器，第三个是没有注解，如果没有那么直接返回即可。
  • Step3：将对应的interceptor添加进入当前Bean。

然后再看从InitializingBean中实现的afterPropertiesSet，也就是对Seata的初始化：

    public void afterPropertiesSet() {
        initClient();

    }
    private void initClient() {
     
        //init TM
        TMClient.init(applicationId, txServiceGroup);
        //init RM
        RMClient.init(applicationId, txServiceGroup);
        registerSpringShutdownHook();
    }
    private void registerSpringShutdownHook() {
        if (applicationContext instanceof ConfigurableApplicationContext) {
            ((ConfigurableApplicationContext) applicationContext).registerShutdownHook();
            ShutdownHook.removeRuntimeShutdownHook();
        }
        ShutdownHook.getInstance().addDisposable(TmRpcClient.getInstance(applicationId, txServiceGroup));
        ShutdownHook.getInstance().addDisposable(RmRpcClient.getInstance(applicationId, txServiceGroup));
    }    
复制代码

上面的代码逻辑比较清楚:

  • Step1：初始化TM客户端，这里会向Server注册该TM。
  • Step2：初始化RM客户端，这里会向Server注册该RM。
  • Step3：注册ShutdownHook，后续将TM和RM优雅关闭。

注意这里初始化的时候会初始化两个客户端，分别是TM客户端和RM客户端，很多人认为TM和RM是用的同一个客户端，这里需要注意一下。

2.1 Interceptor

再上面的第一部分逻辑中我们看到我们有两个业务核心Interceptor,一个是GlobalTransactionalInterceptor用来处理全局事务的管理（开启，提交，回滚），另外一个是TccActionInterceptor用来处理TCC模式。熟悉Seata的朋友会问AT模式呢，为什么只有TCC模式，这里AT模式代表着就是自动处理事务，我们不需要有切面

2.1.1 GlobalTransactionalInterceptor

首先来看看GlobalTransactionalInterceptor#invoke：

    public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
        Class targetClass = (methodInvocation.getThis() != null ? AopUtils.getTargetClass(methodInvocation.getThis()) : null);
        Method specificMethod = ClassUtils.getMostSpecificMethod(methodInvocation.getMethod(), targetClass);
        final Method method = BridgeMethodResolver.findBridgedMethod(specificMethod);

        final GlobalTransactional globalTransactionalAnnotation = getAnnotation(method, GlobalTransactional.class);
        final GlobalLock globalLockAnnotation = getAnnotation(method, GlobalLock.class);
        if (globalTransactionalAnnotation != null) {
            return handleGlobalTransaction(methodInvocation, globalTransactionalAnnotation);
        } else if (globalLockAnnotation != null) {
            return handleGlobalLock(methodInvocation);
        } else {
            return methodInvocation.proceed();
        }
    }
复制代码
  • Step1：从代理类中获取到原始的Method
  • Step2: 获取Method中的注解
  • Step3: 如果有@GlobalTransactional注解执行handleGlobalTransaction切面逻辑，这个也是我们全局事务的逻辑。
  • Step4: 如果有@GlobalLock注解，则执行handleGlobalLock切面逻辑，这个注解是用于一些非AT模式的数据库加锁，加上这个注解之后再执行Sql语句之前会查询对应的数据是否加锁，但是他不会加入全局事务。

handleGlobalTransaction逻辑如下：

    private Object handleGlobalTransaction(final MethodInvocation methodInvocation,
                                           final GlobalTransactional globalTrxAnno) throws Throwable {

        return transactionalTemplate.execute(new TransactionalExecutor() {

            @Override
            public Object execute() throws Throwable {
                return methodInvocation.proceed();
            }

        });
    }
    TransactionalTemplate#execute
        public Object execute(TransactionalExecutor business) throws Throwable {
        // 1. get or create a transaction
        GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate();
        // 1.1 get transactionInfo
        TransactionInfo txInfo = business.getTransactionInfo();
        if (txInfo == null) {
            throw new ShouldNeverHappenException("transactionInfo does not exist");
        }
        try {
            // 2. begin transaction
            beginTransaction(txInfo, tx);
            Object rs = null;
            try {
                // Do Your Business
                rs = business.execute();

            } catch (Throwable ex) {
                // 3.the needed business exception to rollback.
                completeTransactionAfterThrowing(txInfo,tx,ex);
                throw ex;
            }
            // 4. everything is fine, commit.
            commitTransaction(tx);
            return rs;
        } finally {
            //5. clear
            triggerAfterCompletion();
            cleanUp();
        }
    }

复制代码

在handleGlobalTransaction中将具体的实现交给了TransactionalTemplate#execute去做了，其中具体的步骤如下:

  • Step1：获取当前的全局事务，如果没有则创建。
  • Step2：获取业务中的事务信息包含超时时间等。
  • Step3：开启全局事务
  • Step4：如果有异常抛出处理异常，rollback。
  • Step5：如果没有异常那么commit全局事务。
  • Step6：清除当前事务上下文信息。

2.1.2 TccActionInterceptor

我们先看看TccActionInterceptor是如何使用:

    @TwoPhaseBusinessAction(name = "TccActionOne" , commitMethod = "commit", rollbackMethod = "rollback")
    public boolean prepare(BusinessActionContext actionContext, int a);

    public boolean commit(BusinessActionContext actionContext);
    
    public boolean rollback(BusinessActionContext actionContext);
复制代码

一般来说会定义三个方法一个是阶段的try方法，另外一个是二阶段的commit和rollback，每个方法的第一个参数是我们事务上下文，这里我们不需要关心他在我们切面中会自行填充处理。

接下来我们再看看TCC相关的拦截器是如何处理的：

public Object invoke(final MethodInvocation invocation) throws Throwable {
		Method method = getActionInterfaceMethod(invocation);
		TwoPhaseBusinessAction businessAction = method.getAnnotation(TwoPhaseBusinessAction.class);	
		//try method
	    if(businessAction != null) {
			if(StringUtils.isBlank(RootContext.getXID())){
				//not in distribute transaction
				return invocation.proceed();
			}
	    	Object[] methodArgs = invocation.getArguments();
	    	//Handler the TCC Aspect
			Map ret = actionInterceptorHandler.proceed(method, methodArgs, businessAction, new Callback(){
				@Override
				public Object execute() throws Throwable {
					return invocation.proceed();
				}
	    	});
	    	//return the final result
	    	return ret.get(Constants.TCC_METHOD_RESULT);
	    }
		return invocation.proceed();
	}
复制代码 
   
     
    
  • Step1：获取原始Method。
    •  
    
  • Step2：判断是否再全局事务中，也就是整个逻辑服务最外层是否执行了GlobalTransactionalInterceptor。如果不再直接执行即可。
    •  
    
  • Step3：执行TCC切面，核心逻辑在actionInterceptorHandler#proceed中。
    •  
   
 
   
再来看看actionInterceptorHandler#proceed这个方法:
 
   
 public Map proceed(Method method, Object[] arguments, TwoPhaseBusinessAction businessAction, Callback targetCallback) throws Throwable {
		Map ret = new HashMap(16);
		
		//TCC name
        String actionName = businessAction.name();
        String xid = RootContext.getXID();
        BusinessActionContext actionContext = new BusinessActionContext();
        actionContext.setXid(xid);
        //set action anme
        actionContext.setActionName(actionName)

        //Creating Branch Record
        String branchId = doTccActionLogStore(method, arguments, businessAction, actionContext);
        actionContext.setBranchId(branchId);
        
        //set the parameter whose type is BusinessActionContext
        Class[] types = method.getParameterTypes();
        int argIndex = 0;
        for (Class cls : types) {
            if (cls.getName().equals(BusinessActionContext.class.getName())) {
            	arguments[argIndex] = actionContext;
                break;
            }
            argIndex++;
        }
        //the final parameters of the try method
        ret.put(Constants.TCC_METHOD_ARGUMENTS, arguments);
        //the final result
        ret.put(Constants.TCC_METHOD_RESULT, targetCallback.execute());
        return ret;
	}

复制代码 
   
     
    
  • Step1：获取一些事务信息，比如TCC名字，本次事务XID等。
    •  
    
  • Step2：创建Branch事务，一个是在本地的context上下文中将它的commit和rollback信息保存起来，另一个是向我们的Seata-Server注册分支事务，用于后续的管理。
    •  
    
  • Step3：填充方法参数，也就是我们的BusinessActionContext。
    •  
   
 
   
2.2 小结
 
   
Spring的几个总要的内容已经剖析完毕，核心类主要是三个，一个Scanner，两个Interceptor。整体来说比较简单，Spring做的基本上也是我们客户端一些初始化的事，接下来我们深入了解一下TM这个角色。
 
   
3. TM 事务管理器
 
   
在上面章节中我们讲了GlobalTransactionalInterceptor这个切面拦截器，我们知道了这个拦截器中做了我们TM应该做的事，事务的开启，事务的提交，事务的回滚。这里只是我们整体逻辑的发起点，其中具体的客户端逻辑在我们的DefaultTransactionManager中，这个类中的代码如下所示：
 
   
public class DefaultTransactionManager implements TransactionManager {

    @Override
    public String begin(String applicationId, String transactionServiceGroup, String name, int timeout)
        throws TransactionException {
        GlobalBeginRequest request = new GlobalBeginRequest();
        request.setTransactionName(name);
        request.setTimeout(timeout);
        GlobalBeginResponse response = (GlobalBeginResponse)syncCall(request);
        return response.getXid();
    }

    @Override
    public GlobalStatus commit(String xid) throws TransactionException {
        GlobalCommitRequest globalCommit = new GlobalCommitRequest();
        globalCommit.setXid(xid);
        GlobalCommitResponse response = (GlobalCommitResponse)syncCall(globalCommit);
        return response.getGlobalStatus();
    }

    @Override
    public GlobalStatus rollback(String xid) throws TransactionException {
        GlobalRollbackRequest globalRollback = new GlobalRollbackRequest();
        globalRollback.setXid(xid);
        GlobalRollbackResponse response = (GlobalRollbackResponse)syncCall(globalRollback);
        return response.getGlobalStatus();
    }

    @Override
    public GlobalStatus getStatus(String xid) throws TransactionException {
        GlobalStatusRequest queryGlobalStatus = new GlobalStatusRequest();
        queryGlobalStatus.setXid(xid);
        GlobalStatusResponse response = (GlobalStatusResponse)syncCall(queryGlobalStatus);
        return response.getGlobalStatus();
    }

    private AbstractTransactionResponse syncCall(AbstractTransactionRequest request) throws TransactionException {
        try {
            return (AbstractTransactionResponse)TmRpcClient.getInstance().sendMsgWithResponse(request);
        } catch (TimeoutException toe) {
            throw new TransactionException(TransactionExceptionCode.IO, toe);
        }
    }
}
复制代码
 
   
在DefaultTransactionManager中整体逻辑比较简单有四个方法：
 
   
     
    
  • begin：向Server发起GlobalBeginRequest请求，用于开启全局事务。
    •  
    
  • commit：向Server发起GlobalCommitRequest请求，用于提交全局事务。
    •  
    
  • rollback：向Server发起GlobalRollbackRequest请求，用于回滚全局事务。
    •  
    
  • getStatus：向Server发起GlobalStatusRequest请求，用于查询全局事务状态信息。
    •  
   
 
   
4. RM 资源管理器
 
   
在Seata中目前管理RM有两种模式：一种是AT模式，需要事务性数据库支持，会自动记录修改前快照和修改后的快照，用于提交和回滚；还有一种是TCC模式，也可以看作是MT模式，用于AT模式不支持的情况，手动进行提交和回滚。接下来将会深入剖析一下这两种模式的实现原理。
 
   
4.1 AT 资源管理
 
   
AT模式下需要使用Seata提供的数据源代理，其整体实现逻辑如下图所示：
 
   
 
   
 
   
在我们的程序中执行一个sql语句，无论你是使用mybatis，还是直接使用jdbcTemplate,都会遵循下面的步骤：
 
   
     
    
  • Step 1：从数据源中获取数据库连接。
    •  
    
  • Step 2: 从连接中获取Statement。
    •  
    
  • Step 3: 通过Statement执行我们的sql语句
    •  
   
 
   
所以我们可以将DataSource，Connection，Statement代理起来然后执行我们的一些特殊的逻辑，完成我们的AT模式。
 
   
4.1.1 DataSourceProxy
 
   
在DataSourceProxy中没有太多的业务逻辑，只是简单的将获取Connection用我们的ConnectionProxy代理类进行了封装,代码如下：
 
   
    public ConnectionProxy getConnection() throws SQLException {
        Connection targetConnection = targetDataSource.getConnection();
        return new ConnectionProxy(this, targetConnection);
    }
复制代码
 
   
首先通过我们代理之前的DataSource获取连接，然后用ConnectionProxy将其代理起来。
 
   
4.1.2 ConnectionProxy
 
   
ConnectionProxy主要做三件事，第一个是生成代理的Statement,第二个是保存我们的连接上下文：加锁的Key,undoLog等，第三个是代理执行我们的本地事务的commit和rollback。
 
   
首先来看看代理生成的Statement：
 
   
    @Override
    public Statement createStatement() throws SQLException {
        Statement targetStatement = getTargetConnection().createStatement();
        return new StatementProxy(this, targetStatement);
    }

    @Override
    public PreparedStatement prepareStatement(String sql) throws SQLException {
        PreparedStatement targetPreparedStatement = getTargetConnection().prepareStatement(sql);
        return new PreparedStatementProxy(this, targetPreparedStatement, sql);
    }
复制代码
 
   
这里也是通过我们原来的连接直接生成Statement，然后将其进行代理。
 
   
接下来看看对我们上下文的管理，大家都知道我们的一个事务其实对应的是一个数据库连接，在这个事务中的所有sql的undolog和lockKey都会在连接的上下文中记录。如下面代码所示：
 
   
    /**
     * append sqlUndoLog
     *
     * @param sqlUndoLog the sql undo log
     */
    public void appendUndoLog(SQLUndoLog sqlUndoLog) {
        context.appendUndoItem(sqlUndoLog);
    }

    /**
     * append lockKey
     *
     * @param lockKey the lock key
     */
    public void appendLockKey(String lockKey) {
        context.appendLockKey(lockKey);
    }
复制代码
 
   
这里的代码很简单，lockKey和undolog都是用list保存，直接add即可。
 
   
当我们的本地事务完成的时候，需要调用Connection的commit或rollback来进行事务的提交或回滚。这里我们也需要代理这两个方法来完成我们对分支事务的处理，先来看看commit方法。
 
   
    public void commit() throws SQLException {
        if (context.inGlobalTransaction()) {
            processGlobalTransactionCommit();
        } else if (context.isGlobalLockRequire()) {
            processLocalCommitWithGlobalLocks();
        } else {
            targetConnection.commit();
        }
    }
    private void processGlobalTransactionCommit() throws SQLException {
        try {
            register();
        } catch (TransactionException e) {
            recognizeLockKeyConflictException(e);
        }
        try {
            if (context.hasUndoLog()) {
                UndoLogManager.flushUndoLogs(this);
            }
            targetConnection.commit();
        } catch (Throwable ex) {
            report(false);
            if (ex instanceof SQLException) {
                throw new SQLException(ex);
            }
        }
        report(true);
        context.reset();
    }
    
复制代码
 
   
     
    
  • Step 1：判断context是否再全局事务中，如果在则进行提交,到Step2。
    •  
    
  • Step 2: 注册分支事务并加上全局锁，如果全局锁加锁失败则抛出异常。
    •  
    
  • Step 3: 如果context中有undolog，那么将Unlog刷至数据库。
    •  
    
  • Step 4: 提交本地事务。
    •  
    
  • Step 5：报告本地事务状态，如果出现异常则报告失败，如果没有问题则报告正常。
    •  
   
 
   
上面介绍了提交事务的流程，当context在全局锁的流程中，会进行全局锁的查询，这里比较简单就不做赘述，如果context都没有在上述的情况中那么会直接进行事务提交。
 
   
对于我们rollback来说代码比较简单：
 
   
    public void rollback() throws SQLException {
        targetConnection.rollback();
        if (context.inGlobalTransaction()) {
            if (context.isBranchRegistered()) {
                report(false);
            }
        }
        context.reset();
    }

复制代码
 
   
     
    
  • Step 1：首先提交本地事务。
    •  
    
  • Step 2：判断是否在全局事务中。
    •  
    
  • Step 3：如果在则判断分支事务是否已经注册。
    •  
    
  • Step 4: 如果已经注册那么直接向客户端报告该事务失败异常。
    •  
   
 
   
 
    
细心的小伙伴可能发现如果我们的本地事务提交或者回滚之后失败，那我们的分布式事务运行结果还能正确吗？这里完全不用担心，再我们的服务端有完善的超时检测，重试等机制，来帮助我们应对这些特殊情况。
 
   
 
   
4.1.3 StatementProxy
 
   
我们一般用statement会调用executeXXX方法来执行我们的sql语句，所以在我们的Proxy中可以利用这个方法，再执行sql的时候做一些我们需要做的逻辑，下面看看execute方法的代码：
 
   
    public boolean execute(String sql) throws SQLException {
        this.targetSQL = sql;
        return ExecuteTemplate.execute(this, new StatementCallback() {
            @Override
            public Boolean execute(T statement, Object... args) throws SQLException {
                return statement.execute((String) args[0]);
            }
        }, sql);
    }
复制代码
 
   
这里直接将逻辑交给我们的ExecuteTemplate去执行，有如下代码：
 
   
    public static  T execute(SQLRecognizer sqlRecognizer,
                                                     StatementProxy statementProxy,
                                                     StatementCallback statementCallback,
                                                     Object... args) throws SQLException {

        if (!RootContext.inGlobalTransaction() && !RootContext.requireGlobalLock()) {
            // Just work as original statement
            return statementCallback.execute(statementProxy.getTargetStatement(), args);
        }

        if (sqlRecognizer == null) {
            sqlRecognizer = SQLVisitorFactory.get(
                    statementProxy.getTargetSQL(),
                    statementProxy.getConnectionProxy().getDbType());
        }
        Executor executor = null;
        if (sqlRecognizer == null) {
            executor = new PlainExecutor(statementProxy, statementCallback);
        } else {
            switch (sqlRecognizer.getSQLType()) {
                case INSERT:
                    executor = new InsertExecutor(statementProxy, statementCallback, sqlRecognizer);
                    break;
                case UPDATE:
                    executor = new UpdateExecutor(statementProxy, statementCallback, sqlRecognizer);
                    break;
                case DELETE:
                    executor = new DeleteExecutor(statementProxy, statementCallback, sqlRecognizer);
                    break;
                case SELECT_FOR_UPDATE:
                    executor = new SelectForUpdateExecutor(statementProxy, statementCallback, sqlRecognizer);
                    break;
                default:
                    executor = new PlainExecutor(statementProxy, statementCallback);
                    break;
            }
        }
        T rs = null;
        try {
            rs = executor.execute(args);
        } catch (Throwable ex) {
            if (!(ex instanceof SQLException)) {
                // Turn other exception into SQLException
                ex = new SQLException(ex);
            }
            throw (SQLException)ex;
        }
        return rs;
    }
}
复制代码
 
   
这里是我们代理执行sql的核心逻辑，步骤如下：
 
   
     
    
  • Step 1：如果不在全局事务且不需要查询全局锁，那么就直接执行原始的Statement。
    •  
    
  • Step 2: 如果没有传入sql识别器，那么我们需要生成sql识别器，这里我们会借用Druid中对sql的解析，我们获取sql的识别器，我们通过这个识别器可以获取到不同类型的sql语句的一些条件，比如说SQLUpdateRecognizer是用于update的sql识别器，我们可以直接获取到表名，条件语句，更新的字段，更新字段的值等。
    •  
    
  • Step 3：根据sql识别器的类型，来生成我们不同类型的执行器。
    •  
    
  • Step 4：通过第三步中的执行器来执行我们的sql语句。
    •  
   
 
   
这里有五种Executor:INSERT,UPDATE,DELETE的执行器会进行undolog记录并且记录全局锁，SELECT_FOR_UPDATE只会进行查询全局锁，有一个默认的代表我们现在还不支持，什么都不会做直接执行我们的sql语句。
 
   
对于INSERT,UPDATE,DELETE的执行器会继承我们的AbstractDMLBaseExecutor：
 
   
    protected T executeAutoCommitFalse(Object[] args) throws Throwable {
        TableRecords beforeImage = beforeImage();
        T result = statementCallback.execute(statementProxy.getTargetStatement(), args);
        TableRecords afterImage = afterImage(beforeImage);
        prepareUndoLog(beforeImage, afterImage);
        return result;
    }

    protected abstract TableRecords beforeImage() throws SQLException;


    protected abstract TableRecords afterImage(TableRecords beforeImage) throws SQLException;
    
复制代码
 
   
在AbstractDMLBaseExecutor中执行逻辑在executeAutoCommitFalse这个方法，步骤如下：
 
   
     
    
  • Step 1：获取执行当前sql之前所受影响行的快照，这里beforeImage会被不同类型的sql语句重新实现。
    •  
    
  • Step 2：执行当前sql语句，并获取结果。
    •  
    
  • Step 3：获取执行sql之后的快照，这里的afterIamge也会被不同类型的sql语句重新实现。
    •  
    
  • Step 4：将undolog准备好，这里会保存到我们的ConnectionContext中。
    •  
   
 
   
    protected void prepareUndoLog(TableRecords beforeImage, TableRecords afterImage) throws SQLException {
        if (beforeImage.getRows().size() == 0 && afterImage.getRows().size() == 0) {
            return;
        }

        ConnectionProxy connectionProxy = statementProxy.getConnectionProxy();

        TableRecords lockKeyRecords = sqlRecognizer.getSQLType() == SQLType.DELETE ? beforeImage : afterImage;
        String lockKeys = buildLockKey(lockKeyRecords);
        connectionProxy.appendLockKey(lockKeys);

        SQLUndoLog sqlUndoLog = buildUndoItem(beforeImage, afterImage);
        connectionProxy.appendUndoLog(sqlUndoLog);
    }
复制代码
 
   
准备UndoLog的时候会获取我们的ConnectionProxy,将我们的Undolog和LockKey保存起来,给后面的本地事务commit和rollback使用，上面已经讲过。
 
   
4.1.4 分支事务的提交和回滚
 
   
上面的4.1.1-4.1.3都是说的是我们分布式事务的第一阶段，也就是将我们的分支事务注册到Server,而第二阶段分支提交和分支回滚都在我们的DataSourceManager中，对于分支事务提交有如下代码：
 
   
public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId, String applicationData) throws TransactionException {
        return asyncWorker.branchCommit(branchType, xid, branchId, resourceId, applicationData);
    }
public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId, String applicationData) throws TransactionException {
        if (!ASYNC_COMMIT_BUFFER.offer(new Phase2Context(branchType, xid, branchId, resourceId, applicationData))) {
            LOGGER.warn("Async commit buffer is FULL. Rejected branch [" + branchId + "/" + xid + "] will be handled by housekeeping later.");
        }
        return BranchStatus.PhaseTwo_Committed;
    }
复制代码
 
   
这里将我们的分支事务提交的信息，放到一个队列中，异步去处理，也就是异步删除我们的undolog数据，因为提交之后undolog数据没用了。
 
   
这里有人可能会问如果当你将这个信息异步提交到队列中的时候，机器宕机，那么就不会执行异步删除undolog的逻辑，那么这条undolog是不是就会成为永久的脏数据呢？这里Seata为了防止这种事出现，会定时扫描某些较老的undolog数据然后进行删除，不会污染我们的数据。
 
   
对于我们的分支事务回滚有如下代码：
 
   
    public BranchStatus branchRollback(BranchType branchType, String xid, long branchId, String resourceId, String applicationData) throws TransactionException {
        DataSourceProxy dataSourceProxy = get(resourceId);
        if (dataSourceProxy == null) {
            throw new ShouldNeverHappenException();
        }
        try {
            UndoLogManager.undo(dataSourceProxy, xid, branchId);
        } catch (TransactionException te) {
            if (te.getCode() == TransactionExceptionCode.BranchRollbackFailed_Unretriable) {
                return BranchStatus.PhaseTwo_RollbackFailed_Unretryable;
            } else {
                return BranchStatus.PhaseTwo_RollbackFailed_Retryable;
            }
        }
        return BranchStatus.PhaseTwo_Rollbacked;

    }
复制代码
 
   
这里会先获取到我们的数据源，接下来调用我们的重做日志管理器的undo方法进行日志重做，undo方法较长这里就不贴上来了，其核心逻辑是查找到我们的undolog然后将里面的快照在我们数据库进行重做。
 
   
4.2 TCC 资源管理
 
   
TCC没有AT模式资源管理这么复杂，部分核心逻辑在之前的Interceptor中已经讲解过了，比如二阶段方法的保存等。这里主要看看TCC的分支事务提交和分支事务回滚，在TCCResourceManager中有：
 
   
	public BranchStatus branchCommit(BranchType branchType, String xid, long branchId, String resourceId,
									 String applicationData) throws TransactionException {
		TCCResource tccResource = (TCCResource) tccResourceCache.get(resourceId);
		if (tccResource == null) {
			throw new ShouldNeverHappenException("TCC resource is not exist, resourceId:" + resourceId);
		}
		Object targetTCCBean = tccResource.getTargetBean();
		Method commitMethod = tccResource.getCommitMethod();
		if (targetTCCBean == null || commitMethod == null) {
			throw new ShouldNeverHappenException("TCC resource is not available, resourceId:" + resourceId);
		}
		boolean result = false;
		//BusinessActionContext
		BusinessActionContext businessActionContext =
				getBusinessActionContext(xid, branchId, resourceId, applicationData);
		Object ret = commitMethod.invoke(targetTCCBean, businessActionContext);
		LOGGER.info("TCC resource commit result :" + ret + ", xid:" + xid + ", branchId:" + branchId + ", resourceId:" +
				resourceId);
		if (ret != null && ret instanceof TwoPhaseResult) {
			result = ((TwoPhaseResult) ret).isSuccess();
		} else {
			result = (boolean) ret;
		}
		return result ? BranchStatus.PhaseTwo_Committed : BranchStatus.PhaseTwo_CommitFailed_Retryable;
	}
复制代码
 
   
步骤如下：
 
   
     
    
  • Step 1：首先查找当前服务是否有该TCC资源，如果没有抛出异常。
    •  
    
  • Step 2：然后找到我们的TCC对象和对应的commit方法。
    •  
    
  • Step 3：然后执行我们的commit方法。
    •  
    
  • Step 4：最后将结果返回给我们的Server,由Server决定是否重试。
    •  
   
 
   
这里的branchRollback方法也比较简单，这里就不做过多分析了。
 
   
总结
 
   
通过上面分析我们知道，Seata的初始化是依赖Spring去进行，我们的全局事务的开启/提交/回滚都是依赖我们的TM事务管理器，而我们的分支事务的管理是依靠我们的RM，其中提供了两个模式AT和TCC，AT模式必须使用数据库，其核心实现是实现数据源的代理，将我们自己的逻辑注入进去。而我们的TCC能弥补我们没有使用数据库的情况，将提交和回滚都交由我们自己实现，其核心实现逻辑是依赖将一个资源的二阶段的方法和我们的目标对象在我们的资源上下文中保存下来，方便我们后续使用。
 
   
最后如果大家对分布式事务感兴趣，欢迎大家使用并阅读Seata的代码，并给我们提出建议。
 
   
 
    
如果大家觉得这篇文章对你有帮助，你的关注和转发是对我最大的支持，O(∩_∩)O:
 
   
 
   
 
   
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(深度剖析一站式分布式事务方案Seata-Client)

        

            

                
    
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片
                        诚芯微科技
社交电子
                        
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
    
                    
    • 
                    
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南）
                        诚芯微科技
社交电子
                        
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • Low Power概念介绍-Voltage Area
                        飞奔的大虎

                        
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
    
                    
    • 
                    
  • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发
                        诚芯微科技
社交电子
                        
    长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
    
                    
    • 
                    
  • OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案
                        RPA中国
人工智能AIGC传媒
                        
    在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
    
                    
    • 
                    
  • Xinference如何注册自定义模型
                        玩人工智能的辣条哥
人工智能AI大模型Xinference
                        
    环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
    
                    
    • 
                    
  • 网络通信流程
                        记得开心一点啊
服务器网络运维
                        
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
    
                    
    • 
                    
  • react-intl——react国际化使用方案
                        苹果酱0567
面试题汇总与解析java开发语言中间件springboot后端
                        
    国际化介绍i18n：internationalization国家化简称，首字母+首尾字母间隔的字母个数+尾字母，类似的还有k8s(Kubernetes)React-intl是React中最受欢迎的库。使用步骤安装#usenpmnpminstallreact-intl-D#useyarn项目入口文件配置//index.tsximportReactfrom"react";importReactDOMf
    
                    
    • 
                    
  • 06选课支付模块之基于消息队列发送支付通知消息
                        echo 云清
学成在线javarabbitmq消息队列支付通知学成在线
                        
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    
                    
    • 
                    
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
                        疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
                        
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
    
                    
    • 
                    
  • 详解：如何设计出健壮的秒杀系统？
                        夜空_2cd3

                        
    作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
    
                    
    • 
                    
  • 《转介绍方法论》学习笔记
                        小可乐的妈妈

                        
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
    
                    
    • 
                    
  • 微信小程序开发注意事项
                        jun778895
微信小程序小程序
                        
    微信小程序开发是一个融合了前端开发、用户体验设计、后端服务（可选）以及微信小程序平台特性的综合性项目。这里，我将详细介绍一个典型的小程序开发项目的全过程，包括项目规划、设计、开发、测试及部署上线等各个环节，并尽量使内容达到或超过2000字的要求。一、项目规划1.1项目背景与目标假设我们要开发一个名为“智慧校园助手”的微信小程序，旨在为学生提供一站式校园生活服务，包括课程表查询、图书馆座位预约、食堂
    
                    
    • 
                    
  • wandb一直上传 解决方案
                        行业边缘的摸鱼怪
bug解决方案服务器linux服务器
                        
    问题描述运行带有wandb的代码时，虽然可以实现及时同步非常方便，但当设置错参数或其他原因不得不使用ctrl+C停止运行时，总会出现wandb一直上传个不停的现象，给在同一终端重新运行新的代码造成困难。解决方案运行以下代码把wandb的进程直接杀死。psaux|grepwandb|grep-vgrep|awk'{print$2}'|xargskill-9参考链接[CLI]:Ctrl+Ctokill
    
                    
    • 
                    
  • 学着不在做孤独的小孩
                        苯妥英钠

                        
    梦境中，经常，绝非偶然的，多次，隔着半个月，或者半年的时光，也许更短，总会梦见自己在里面孤独的面对着自己深深觉得恐怖的事情。在梦里我们没有主导权，没有享受一切的权利，只有被迫式的逃离，却发现自己的内心已经强烈的渴望奔向远方，却无可奈何的发现自己的脚步还在原地，此时身后的黑暗越来越接近自己。等我们长大的时候，我们依然在梦中会被迫的控制住，即使我们可能知道，也多么希望我们自己能有很多的方案去摆脱，或者
    
                    
    • 
                    
  • 程序员如何在AI时代保持核心竞争力
                        nfgo
chatgpt人工智能
                        
    程序员如何在AI时代保持核心竞争力随着AIGC（如ChatGPT、MidJourney、Claude等）大语言模型的相继涌现，AI辅助编程工具逐渐普及，程序员的工作方式正在发生深刻的变革。AI不仅能够自动生成代码，还能优化、调试、甚至提出解决方案。这一趋势让许多人担心：AI会不会最终取代部分编程工作？然而，也有人认为AI是提升效率的得力助手。那么，程序员在这个AI崛起的时代该如何应对？是专注某个领
    
                    
    • 
                    
  • python老是报参数未定义_Python函数默认参数常见问题及解决方案
                        weixin_39935571
python老是报参数未定义
                        
    一、默认参数python为了简化函数的调用，提供了默认参数机制：这样在调用pow函数时，就可以省略最后一个参数不写：在定义有默认参数的函数时，需要注意以下：必选参数必须在前面，默认参数在后；设置何种参数为默认参数？一般来说，将参数值变化小的设置为默认参数。python标准库实践python内建函数：函数签名可以看出，使用print('hellopython')这样的简单调用的打印语句，实际上传入了
    
                    
    • 
                    
  • 程序员架构师主要是做什么_程序员架构师：职责、技能与挑战
                        绿色小猪

                        
    免费备考资料（2024年11月软考）：历年试题+视频课合集+电子讲义点击领取>>>免费刷题：2024年11月软考备考刷题点此进入>>>程序员架构师的角色定位在软件开发领域，程序员架构师是一个至关重要的角色。他们不仅需要深入理解业务需求，还要将其转化为技术上的解决方案。程序员架构师是项目中的技术领航者，负责制定和维护软件系统的整体架构，确保系统的可扩展性、可维护性和性能。他们的工作涉及从概念化到实现
    
                    
    • 
                    
  • 使用datepicker和uploadify的冲突解决（IE双击才能打开附件上传对话框）
                        zhanglb12

                        
    在开发的过程当中，IE的兼容无疑是我们的一块绊脚石，在我们使用的如期的datepicker插件和使用上传附件的uploadify插件的时候，两者就产生冲突，只要点击过时间的插件，uploadify上传框要双才能打开ie浏览器提示错误Missinginstancedataforthisdatepicker解决方案//if(.browser.msie&&'9.0'===.browser.version
    
                    
    • 
                    
  • 加载资源时报错-ERR_CONNECTION_RESET，需要多次请求才能拿到资源的有效解决方案
                        Mebius1916
前端开发前端javascriptreact.js前端框架typescriptvue.js
                        
    初次加载资源时无法正常加载，需要多次刷新、请求才能拿到资源的有效解决方案前言在使用cloudinary进行图片上传并获取图片链接作为用户头像时发现，图片链接网址初次加载会报错：ERR_CONNECTION_RESET必须刷新几次才能获取到，原因可能是cloudinary没有国内的节点，而我用的是在新加坡的节点，所以会导致初次加载的时候被重定向。而这个错误会直接导致用户头像无法加载，因为在img中此
    
                    
    • 
                    
  • metaRTC/webRTC QOS 方案与实践
                        metaRTC
metaRTC解决方案webrtcqos
                        
    概述质量服务(QOS/QualityofService)是指利用各种技术方案提高网络通信质量的技术，网络通信质量需要解决下面两个问题：网络问题：UDP/不稳定网络/弱网下的丢包/延时/乱序/抖动数据量问题：发送数据量超带宽负载和平滑发送拥塞控制是各种技术方案的数据基础，丢包恢复解决丢包问题，抗乱序抖动解决网络乱序抖动问题，流量控制解决平滑发送数据/数据超带宽负载/延时问题。拥塞控制(Congest
    
                    
    • 
                    
  • 2023-05-25
                        季风2026

                        
    育人细无声，光影文传情------南校区射灯投影内容为了丰富校园文化建设，打造全方位、多角度、光影文的育人环境，宣教科特出具“育人细无声，光影文传情”的射灯文化建设方案，拟定投射内容若干，请领导审阅。第一阶段投射内容：校风校训等学校精神。1.南校区大门口：校风：诚朴自信知行合一校训：厚德精技励学创新2.教学楼门口：教风：因材施教德技双馨学风：博学慎思明辨笃行3.宿舍楼门口：团结友善互帮互助包容大度
    
                    
    • 
                    
  • vant-element-ts一起使用存在的问题
                        flynn_
问题总结vue
                        
    由于vant-ui与element-ui部分组件存在冲突，导致在vue-typescript中出现错误:Subsequentpropertydeclarationsmusthavethesametype.Property'$notify'mustbeoftype'ElNotification',butherehastype'Notify'.方案：一个全局导入，一个按需导入,避免冲突的组件同时使用，
    
                    
    • 
                    
  • 全视通智慧病房系统旧病房改造方案
                        2301_78035670
解决方案人工智能大数据
                        
    一、背景介绍在当今医疗技术日新月异的时代，智慧病房作为医院现代化建设的重要一环，正逐步从概念走向现实，深刻改变着患者的就医体验与医护人员的工作模式。智慧病房的改造背景，根植于医疗需求的日益增长、技术创新的不断推动以及对医疗质量与效率的不懈追求之中。二、医疗需求的深刻变革随着人口老龄化的加剧和慢性病患者数量的激增，医疗资源分配不均、医患沟通不畅、患者照护效率低下等问题日益凸显。传统的病房管理模式已难
    
                    
    • 
                    
  • 设计模式】Listener模式和Visitor模式的区别
                        不爱洗脚的小滕
设计模式访问者模式javagolang
                        
    文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
    
                    
    • 
                    
  • python之pyecharts制作可视化数据大屏
                        cesske
大数据
                        
    文章目录前言一、安装Pyecharts二、创建Pyecharts图表三、设计大屏布局四、实时数据更新五、部署和展示总结前言使用Pyecharts制作可视化数据大屏是一个复杂但有趣的过程，因为Pyecharts本身是一个用于生成Echarts图表的Python库，而Echarts是由百度开发的一个开源可视化库，支持丰富的图表类型和高度自定义。然而，Pyecharts本身并不直接提供“大屏”的解决方案
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                                
  • 插入表主键冲突做更新
                                    a-john

                                    
    有以下场景： 
用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 
问题： 
如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 
解决： 
mysql中提供了一个sql语
    
                                
    • 
                                
  • Android xml资源文件中@、@android:type、@*、？、@+含义和区别
                                    Cb123456
@+@?@*
                                    
    一.@代表引用资源 
1.引用自定义资源。格式：@[package:]type/name 
android：text="@string/hello" 
  
2.引用系统资源。格式：@android:type/name 
    android:textColor="@android:color/opaque_red"
    
                                
    • 
                                
  • 数据结构的基本介绍
                                    天子之骄
数据结构散列表树、图线性结构价格标签
                                    
    数据结构的基本介绍 
数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。 
  
经典的数据结构大致如下： 
  
一：线性数据结构 
(1)：列表 
a
    
                                
    • 
                                
  • 通过二维码开放平台的API快速生成二维码
                                    一炮送你回车库
api
                                    
     现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。 
       html代码如下:(二维码将生成在这div下)    
?       1      
 &nbs
    
                                
    • 
                                
  • ImageIO读取一张图片改变大小
                                    3213213333332132
javaIOimageBufferedImage
                                    
    
package com.demo;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

/**
 * @Description 读取一张图片改变大小
 * @author FuJianyon
    
                                
    • 
                                
  • myeclipse集成svn（一针见血）
                                    7454103
eclipseSVNMyEclipse
                                    
                                     &n
    
                                
    • 
                                
  • 装箱与拆箱----autoboxing和unboxing
                                    darkranger
J2SE
                                    
    4.2　自动装箱和拆箱 
 
基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 
 
4.2.1　autoboxing和unboxing 
 
在Java中，所有要处理的东西几乎都是对象(Object)
    
                                
    • 
                                
  • ajax传统的方式制作ajax
                                    aijuans
Ajax
                                    
    //这是前台的代码 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
    
                                
    • 
                                
  • 只用jre的eclipse是怎么编译java源文件的？
                                    avords
javaeclipsejdktomcat
                                    
    eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ 
&nb
    
                                
    • 
                                
  • 前端模块化
                                    bee1314
模块化
                                    
    背景：   前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。       JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
    
                                
    • 
                                
  • 处理百万级以上的数据处理
                                    bijian1013
oraclesql数据库大数据查询
                                    
    一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。 
        2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
    
                                
    • 
                                
  • mac 卸载 java 1.7 或更高版本
                                    征客丶
javaOS
                                    
    卸载 java 1.7 或更高 
sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 
成功执行此命令后，还可以执行 java 与 javac 命令 
 
sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 
成功执行此命令后，还可以执行 java 
    
                                
    • 
                                
  • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析
                                    bit1129
Stream
                                    
    第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 
第二部，Spark Streaming读取Kafka中的数据，进行实时分析 
  
本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 
1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
    
                                
    • 
                                
  • Erlang vs TNSDL
                                    bookjovi
erlang
                                    
      
    TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
    
                                
    • 
                                
  • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个
                                    ljy325
企业应用
                                    
    　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 
 
相关新闻： 
（1）IT行业成五大疾病重灾区：过劳死平均37.9岁 

    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-原型模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * Effective Java 建议使用copy constructor or copy factory来代替clone()方法：
 * 1.public Product copy(Product p){}
 * 2.publi
    
                                
    • 
                                
  • 配置管理---svn工具之权限配置
                                    chenyu19891124
SVN
                                    
    今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 
安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 
pepos 
   component 
   webapps 
在conf里面的auth里赋予的权限配置为 
[groups]
    
                                
    • 
                                
  • 浅谈程序员的数学修养
                                    comsci
设计模式编程算法面试招聘
                                    
             
                        浅谈程序员的数学修养 
    
                                
    • 
                                
  • 批量执行 bulk collect与forall用法
                                    daizj
oraclesqlbulk collectforall
                                    
    BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 
FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。 
    有关FORALL语句的用法请参考：批量SQL之 F
    
                                
    • 
                                
  • Linux下使用rsync最快速删除海量文件的方法
                                    dongwei_6688
OS
                                    
    1、先安装rsync：yum install rsync 
2、建立一个空的文件夹：mkdir /tmp/test 
3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。 

    
                                
    • 
                                
  • Yii CModel中rules验证规格
                                    dcj3sjt126com
rulesyiivalidate
                                    
    Yii cValidator主要用法分析：  
 yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError 
 
    
                                
    • 
                                
  • 基于vagrant的redis主从实验
                                    dcj3sjt126com
vagrant
                                    
    平台: Mac 
工具: Vagrant 
系统: Centos6.5 
实验目的: Redis主从 
  
实现思路 
制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box 
  
制作sentos6.5+redis的box 
  
mkdir vagrant_redis 
cd vagrant_
    
                                
    • 
                                
  • Memcached(二)、Centos安装Memcached服务器
                                    frank1234
centosmemcached
                                    
    一、安装gcc 
rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 
 
开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]：

建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码......


rpm -ivh kernel-head
    
                                
    • 
                                
  • Remove Duplicates from Sorted List
                                    hcx2013
remove
                                    
    Given a sorted linked list, delete all duplicates such that each element appear only once. 
For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
    
                                
    • 
                                
  • Spring4新特性——JSR310日期时间API的支持
                                    jinnianshilongnian
spring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • 浅谈enum与单例设计模式
                                    247687009
java单例
                                    
    在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构
造器，导出静态成员变量，以便调用者访问。

第一种 
package singleton;

public class Singleton {
        //导出全局成员
        public final static Singleton INSTANCE = new S
    
                                
    • 
                                
  • 使用switch条件语句需要注意的几点
                                    openwrt
cbreakswitch
                                    
    1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 
 
int main()
{
    int n = 1;
    switch(n) {
    case 1:
        printf("--1--\n");
    default:
        printf("defa
    
                                
    • 
                                
  • 配置Spring Mybatis JUnit测试环境的应用上下文
                                    schnell18
springmybatisJUnit
                                    
    Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 
 
 单元测试的app context不支持从外部properties文件注入属性 
 @Value注解不能解析带通配符的路径字符串 
 
解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 
第二个问题的具体实例是： 
   
    
                                
    • 
                                
  • Java 定时任务总结一
                                    tuoni
javaspringtimerquartztimertask
                                    
     Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
    
                                
    • 
                                
  • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法
                                    yangshangchuan
rank相似度计算文本相似度词袋模型余弦相似度
                                    
    本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。 
  
最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下： 
    1、注册多个账号（一般10个以上）。 
    2、从多个账号中选择一个账号，发表1-2篇博文
    
                                
    •