seata源码解析:seata-server启动时都做了哪些操作?

seata源码解析:seata-server启动时都做了哪些操作?_第1张图片

seata-server的主要功能有哪些?

当我们启动一个seata-server的时候,只需要执行一下seata-server.sh脚本即可,这个脚本其实就是调用了io.seata.server.Server的main方法,我们来看一下这个main方法做了哪些操作?

public class Server {
     

    public static void main(String[] args) throws IOException {
     
        // get port first, use to logback.xml
        // 获取监听的端口
        int port = PortHelper.getPort(args);
        System.setProperty(ConfigurationKeys.SERVER_PORT, Integer.toString(port));

        // create logger
        final Logger logger = LoggerFactory.getLogger(Server.class);
        if (ContainerHelper.isRunningInContainer()) {
     
            logger.info("The server is running in container.");
        }

        //initialize the parameter parser
        //Note that the parameter parser should always be the first line to execute.
        //Because, here we need to parse the parameters needed for startup.
        // 解析启动和配置文件中的各种参数
        ParameterParser parameterParser = new ParameterParser(args);

        //initialize the metrics
        // 监控相关
        MetricsManager.get().init();

        System.setProperty(ConfigurationKeys.STORE_MODE, parameterParser.getStoreMode());

        ThreadPoolExecutor workingThreads = new ThreadPoolExecutor(NettyServerConfig.getMinServerPoolSize(),
                NettyServerConfig.getMaxServerPoolSize(), NettyServerConfig.getKeepAliveTime(), TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(NettyServerConfig.getMaxTaskQueueSize()),
                new NamedThreadFactory("ServerHandlerThread", NettyServerConfig.getMaxServerPoolSize()), new ThreadPoolExecutor.CallerRunsPolicy());

        NettyRemotingServer nettyRemotingServer = new NettyRemotingServer(workingThreads);
        //server port
        nettyRemotingServer.setListenPort(parameterParser.getPort());
        // 将serverNode作为雪花算法中的workerId
        UUIDGenerator.init(parameterParser.getServerNode());
        //log store mode : file, db, redis
        // SessionHolder负责事务日志的持久化存储
        // 设置存储模式,有三种可选类型,file,db,redis
        SessionHolder.init(parameterParser.getStoreMode());

        // 创建事务协调器
        DefaultCoordinator coordinator = new DefaultCoordinator(nettyRemotingServer);
        coordinator.init();
        nettyRemotingServer.setHandler(coordinator);
        // register ShutdownHook
        ShutdownHook.getInstance().addDisposable(coordinator);
        ShutdownHook.getInstance().addDisposable(nettyRemotingServer);

        //127.0.0.1 and 0.0.0.0 are not valid here.
        if (NetUtil.isValidIp(parameterParser.getHost(), false)) {
     
            XID.setIpAddress(parameterParser.getHost());
        } else {
     
            XID.setIpAddress(NetUtil.getLocalIp());
        }
        XID.setPort(nettyRemotingServer.getListenPort());

        try {
     
            // 启动nettyServer并阻塞在这里
            nettyRemotingServer.init();
        } catch (Throwable e) {
     
            logger.error("nettyServer init error:{}", e.getMessage(), e);
            System.exit(-1);
        }

        System.exit(0);
    }
}

seata源码解析:seata-server启动时都做了哪些操作?_第2张图片
启动时的操作可以总结为如下

  1. 初始化id生成器,用来生成全局事务id和分支事务id。id生成器的底层用到了雪花算法
  2. 设置存储模式,用来持久化存储事务,有三种模式db,redis,file
  3. 创建事务协调器并初始化
  4. 启动nettyRemotingServer

我们按照消息的处理流程分3篇文章来分析seata-server端的源码

  1. 启动nettyServer负责与 TM RM 进行通信
  2. 事务协调器接收事务相关的消息然后调用事务管理器做相应的操作
  3. 事务管理器通过SessionManager将事务状态进行持久化存储

启动NettyRemotingServer

public void init() {
     
    // registry processor
    // 注册消息处理器
    registerProcessor();
    if (initialized.compareAndSet(false, true)) {
     
        super.init();
    }
}

首先注册消息处理器,消息处理器顾名思义是用来处理消息的,根据消息的不同类型选择不同的消息处理器来处理消息,典型的策略模式,提高了程序的可扩展性

每种消息类型和其对应的处理器关系如下
seata源码解析:seata-server启动时都做了哪些操作?_第3张图片
这种映射关系其实是保存在map中的

// AbstractNettyRemoting
protected final HashMap<Integer/*MessageType*/, Pair<RemotingProcessor, ExecutorService>> processorTable = new HashMap<>(32);

可以看到除了保存消息类型和其对应的处理器,还有一个ExecutorService(线程池),当消息的处理过程需要在IO线程上执行时,对应的线程池为空,当线程池不为空时说明消息的处理过程会在线程池中进行

// AbstractNettyRemotingServer
public void init() {
     
	// 删除超时的消息
    super.init();
    serverBootstrap.start();
}

serverBootstrap#start方法是一个标准的netty启动代码,设置参数,设置ChannelHandler,然后同步阻塞。我们只关心ChannelHandler的处理逻辑

NettyRemotingServer在启动的过程中设置了如下4个ChannelHandler

IdleStateHandler:处理心跳
ProtocolV1Decoder:消息解码器
ProtocolV1Encoder:消息编码器
AbstractNettyRemotingServer.ServerHandler:处理各种消息

@ChannelHandler.Sharable
class ServerHandler extends ChannelDuplexHandler {
     

    /**
     * 处理读取到的消息
     */
    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
     
        if (!(msg instanceof RpcMessage)) {
     
            return;
        }
        processMessage(ctx, (RpcMessage) msg);
    }

}

可以看到ServerHandler类上有@ChannelHandler.Sharable注解,表明所有的连接都会共用这一个ChannelHandler,这样当消息处理的慢时,就会降低并发,所以有的消息处理过程需要放到线程池中进行
seata源码解析:seata-server启动时都做了哪些操作?_第4张图片

消息的处理过程用了策略模式,根据消息类型找到对应的消息处理器RemotingProcessor

// AbstractNettyRemoting
protected void processMessage(ChannelHandlerContext ctx, RpcMessage rpcMessage) throws Exception {
     
    if (LOGGER.isDebugEnabled()) {
     
        LOGGER.debug(String.format("%s msgId:%s, body:%s", this, rpcMessage.getId(), rpcMessage.getBody()));
    }
    Object body = rpcMessage.getBody();
    if (body instanceof MessageTypeAware) {
     
        MessageTypeAware messageTypeAware = (MessageTypeAware) body;
        // 根据消息类型获取对应的处理器
        final Pair<RemotingProcessor, ExecutorService> pair = this.processorTable.get((int) messageTypeAware.getTypeCode());
        if (pair != null) {
     
            // 对应的处理器设置了线程池,则放到线程池中执行
            if (pair.getSecond() != null) {
     
                try {
     
                    pair.getSecond().execute(() -> {
     
                        try {
     
                            pair.getFirst().process(ctx, rpcMessage);
                        } catch (Throwable th) {
     
                            LOGGER.error(FrameworkErrorCode.NetDispatch.getErrCode(), th.getMessage(), th);
                        } finally {
     
                            MDC.clear();
                        }
                    });
                } catch (RejectedExecutionException e) {
     
                    // 线程池拒绝策略之一,抛出RejectedExecutionException
                    LOGGER.error(FrameworkErrorCode.ThreadPoolFull.getErrCode(),
                        "thread pool is full, current max pool size is " + messageExecutor.getActiveCount());
                    if (allowDumpStack) {
     
                        String name = ManagementFactory.getRuntimeMXBean().getName();
                        String pid = name.split("@")[0];
                        int idx = new Random().nextInt(100);
                        try {
     
                            Runtime.getRuntime().exec("jstack " + pid + " >d:/" + idx + ".log");
                        } catch (IOException exx) {
     
                            LOGGER.error(exx.getMessage());
                        }
                        allowDumpStack = false;
                    }
                }
            } else {
     
                // 对应的处理器没有设置线程池,则直接执行
                try {
     
                    pair.getFirst().process(ctx, rpcMessage);
                } catch (Throwable th) {
     
                    LOGGER.error(FrameworkErrorCode.NetDispatch.getErrCode(), th.getMessage(), th);
                }
            }
        } else {
     
            LOGGER.error("This message type [{}] has no processor.", messageTypeAware.getTypeCode());
        }
    } else {
     
        LOGGER.error("This rpcMessage body[{}] is not MessageTypeAware type.", body);
    }
}

好了NettyRemotingServer的启动过程我们就分析完了,下篇文章我们来看消息的处理过程

参考博客

seata server
[1]https://zhuanlan.zhihu.com/p/61981170
[2]http://seata.io/zh-cn/blog/seata-sourcecode-server-bootstrap.html
比较详细
[3]https://my.oschina.net/leitingweb/blog/3150652
好的系列文章
[4]https://blog.csdn.net/weixin_38308374/category_10261111.html

你可能感兴趣的:(分布式事务,java)