Seata源码—3.全局事务注解扫描器的初始化
大纲1.全局事务注解扫描器继承的父类与实现的接口
2.全局事务注解扫描器的核心变量
3.Spring容器初始化后初始化Seata客户端的源码
4.TM全局事务管理器客户端初始化的源码
5.TM组件的Netty网络通信客户端初始化源码
6.Seata框架的SPI动态扩展机制源码
7.向Seata客户端注册网络请求处理器的源码
8.Seata客户端的定时调度任务源码
9.Seata客户端初始化Netty Bootstrap的源码
10.Seata客户端的寻址机制与连接服务端的源码
11.RM分支事务资源管理器客户端初始化的源码
12.全局事务注解扫描器扫描Bean是否有Seata注解
13.Seata全局事务拦截器的创建和初始化
14.基于Spring AOP创建全局事务动态代理的源码
15.全局事务注解扫描器的初始化总结
如下的代码都是位于seata-spring模块下。
1.全局事务注解扫描器继承的父类与实现的接口
在dubbo-business.xml配置文件中，会引入全局事务注解扫描器GlobalTransactionScanner。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">
<dubbo:application name="dubbo-demo-app">
<dubbo:parameter key="qos.enable" value="false"/>
<dubbo:parameter key="qos.accept.foreign.ip" value="false"/>
<dubbo:parameter key="qos.port" value="33333"/>
</dubbo:application>
<dubbo:registry address="zookeeper://localhost:2181" />
<dubbo:reference id="orderService" check="false" interface="io.seata.samples.dubbo.service.OrderService"/>
<dubbo:reference id="stockService" check="false" interface="io.seata.samples.dubbo.service.StockService"/>
<bean id="business" >
<property name="orderService" ref="orderService"/>
<property name="stockService" ref="stockService"/>
</bean>
<bean >
<constructor-arg value="dubbo-demo-app"/>
<constructor-arg value="my_test_tx_group"/>
</bean>
</beans>全局事务注解扫描器GlobalTransactionScanner的继承父类和实现接口：
继承父类：AbstractAutoProxyCreator——Spring的动态代理自动创建者；
实现接口：ConfigurationChangeListener——关注配置变更事件的监听器；
实现接口：InitializingBean——Spring Bean的初始化回调；
实现接口：ApplicationContextAware——让Spring Bean获取到Spring容器；
实现接口：DisposableBean——支持可抛弃Bean；//AbstractAutoProxyCreator：Spring的动态代理自动创建者
//ConfigurationChangeListener：关注配置变更事件的监听器
//InitializingBean：Spring Bean初始化回调
//ApplicationContextAware：让Bean可以获取Spring容器
//DisposableBean：支持可抛弃Bean
public class GlobalTransactionScanner extends AbstractAutoProxyCreator
implements ConfigurationChangeListener, InitializingBean, ApplicationContextAware, DisposableBean {
...
...
}
2.全局事务注解扫描器的核心变量
(1)ConfigurationChangeListener接口
(2)InitializingBean接口
(3)ApplicationContextAware接口
(4)DisposableBean接口
(5)GlobalTransactionScanner核心变量
(1)ConfigurationChangeListener接口
实现了该接口的Bean，可以处理配置变更的事件。
//实现了该ConfigurationChangeListener接口的Bean：
//在发生配置变更事件时，可以进行相应的处理
public interface ConfigurationChangeListener {
int CORE_LISTENER_THREAD = 1;
int MAX_LISTENER_THREAD = 1;
//默认的线程池
ExecutorService EXECUTOR_SERVICE = new ThreadPoolExecutor(
CORE_LISTENER_THREAD, MAX_LISTENER_THREAD,
Integer.MAX_VALUE, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(),
new NamedThreadFactory("configListenerOperate", MAX_LISTENER_THREAD)
);
//处理配置变更的事件
void onChangeEvent(ConfigurationChangeEvent event);
//配置变更事件的默认处理：获取默认的线程池来处理配置变更的事件
default void onProcessEvent(ConfigurationChangeEvent event) {
getExecutorService().submit(() -> {
//处理配置变更事件前的回调
beforeEvent();
//进行具体的配置变更事件处理
onChangeEvent(event);
//处理配置变更事件后的回调
afterEvent();
});
}
//关闭线程池
default void onShutDown() {
getExecutorService().shutdownNow();
}
//获取线程池
default ExecutorService getExecutorService() {
return EXECUTOR_SERVICE;
}
//处理配置变更事件前的默认回调
default void beforeEvent() {
}
//处理配置变更事件后的默认回调
default void afterEvent() {
}
}(2)InitializingBean接口
实现了该接口的Bean，可以在初始化后进行回调。
//实现了该InitializingBean接口的Bean：
//它的所有properties属性被BeanFactory设置之后，
//可以通过afterPropertiesSet()这个回调方法，来处理一些特殊的初始化操作
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}(3)ApplicationContextAware接口
实现了该接口的Bean，可以获取Spring容器。
//实现了该ApplicationContextAware接口的Bean：
//可以通过setApplicationContext()方法将Spring容器注入到这个Bean里面
//注入 == set属性，代理 == wrap包装
public interface ApplicationContextAware extends Aware {
void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}(4)DisposableBean接口
实现了该接口的Bean，可以在Spring容器被销毁时进行相应的回调处理。
//实现了该DisposableBean接口的Bean：
//当Spring容器被销毁时，可以通过destroy()方法释放资源
public interface DisposableBean {
void destroy() throws Exception;
}(5)GlobalTransactionScanner核心变量
//AbstractAutoProxyCreator：Spring的动态代理自动创建者
//ConfigurationChangeListener：关注配置变更事件的监听器
//InitializingBean：Spring Bean初始化回调
//ApplicationContextAware：用来获取Spring容器
//DisposableBean：支持可抛弃Bean
public class GlobalTransactionScanner extends AbstractAutoProxyCreator
implements ConfigurationChangeListener, InitializingBean, ApplicationContextAware, DisposableBean {
private static final long serialVersionUID = 1L;
private static final Logger LOGGER = LoggerFactory.getLogger(GlobalTransactionScanner.class);
private static final int AT_MODE = 1;
private static final int MT_MODE = 2;
private static final int ORDER_NUM = 1024;
private static final int DEFAULT_MODE = AT_MODE + MT_MODE;
private static final String SPRING_TRANSACTION_INTERCEPTOR_CLASS_NAME = "org.springframework.transaction.interceptor.TransactionInterceptor";
private static final Set<String> PROXYED_SET = new HashSet<>();
private static final Set<String> EXCLUDE_BEAN_NAME_SET = new HashSet<>();
private static final Set<ScannerChecker> SCANNER_CHECKER_SET = new LinkedHashSet<>();
//Spring容器
private static ConfigurableListableBeanFactory beanFactory;
//Spring AOP里对方法进行拦截的拦截器
private MethodInterceptor interceptor;
//对添加了@GlobalTransactional注解的方法进行拦截的AOP拦截器
private MethodInterceptor globalTransactionalInterceptor;
//应用程序ID，在XML里配置时注入进来的
private final String applicationId;
//分布式事务组
private final String txServiceGroup;
//分布式事务模式，默认就是AT事务
private final int mode;
//与阿里云整合使用的，accessKey和secretKey是进行身份认证和安全访问时需要用到
private String accessKey;
private String secretKey;
//是否禁用全局事务，默认是false
private volatile boolean disableGlobalTransaction = ConfigurationFactory.getInstance().getBoolean(ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION, DEFAULT_DISABLE_GLOBAL_TRANSACTION);
//确保初始化方法仅仅调用一次的CAS变量
//通过Atomic CAS操作可以确保多线程并发下，方法只被调用一次
//只有一个线程可以成功对initialized原子变量进行CAS操作
private final AtomicBoolean initialized = new AtomicBoolean(false);
//全局事务失败时会有一个handler处理钩子
//比如当开启全局事务失败、提交全局事务失败、回滚全局事务失败、回滚重试全局事务失败时，都会在FailureHandler有相应的回调入口
private final FailureHandler failureHandlerHook;
//Spring容器
private ApplicationContext applicationContext;
...
}
3.Spring容器初始化完触发Seata客户端初始化
Spring容器启动和初始化完毕后，会调用InitializingBean的afterPropertiesSet()方法进行回调。
GlobalTransactionScanner.afterPropertiesSet()方法会调用initClient()方法，并且会通过CAS操作确保initClient()方法仅执行一次。
initClient()方法是全局事务注解扫描器GlobalTransactionScanner的核心方法，它会负责对Seata客户端进行初始化。
对于Seata客户端来说，有两个重要的组件：一个是TM(即Transaction Manager)全局事务管理器，另一个是RM(即Resource Manager)分支事务资源管理器。
在initClient()方法中，会先调用TMClient的init()方法对TM全局事务管理器客户端进行初始化，然后调用RMClient的init()方法对RM分支事务资源管理器客户端进行初始化。
//AbstractAutoProxyCreator：Spring的动态代理自动创建者
//ConfigurationChangeListener：关注配置变更事件的监听器
//InitializingBean：Spring Bean初始化回调
//ApplicationContextAware：让Bean可以获取Spring容器
//DisposableBean：支持可抛弃Bean
public class GlobalTransactionScanner extends AbstractAutoProxyCreator
implements ConfigurationChangeListener, InitializingBean, ApplicationContextAware, DisposableBean {
...
//确保初始化方法仅仅调用一次的CAS变量
//通过Atomic CAS操作可以确保多线程并发下，方法只被调用一次
//只有一个线程可以成功对initialized原子变量进行CAS操作
private final AtomicBoolean initialized = new AtomicBoolean(false);
...
public GlobalTransactionScanner(String applicationId, String txServiceGroup, int mode, FailureHandler failureHandlerHook) {
setOrder(ORDER_NUM);
//启用对目标class创建动态代理
setProxyTargetClass(true);
//设置应用程序ID
this.applicationId = applicationId;
//设置分布式事务服务分组
this.txServiceGroup = txServiceGroup;
//设置分布式事务模式，默认是AT
this.mode = mode;
//设置全局事务失败回调钩子
this.failureHandlerHook = failureHandlerHook;
}
//DisposableBean接口的回调方法
//当Spring容器被销毁、系统停止时，所做的一些资源销毁和释放
@Override
public void destroy() {
ShutdownHook.getInstance().destroyAll();
}
//InitializingBean接口的回调方法
//Spring容器启动和初始化完毕后，会调用如下的afterPropertiesSet()方法进行回调
@Override
public void afterPropertiesSet() {
//是否禁用了全局事务，默认是false
if (disableGlobalTransaction) {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Global transaction is disabled.");
}
ConfigurationCache.addConfigListener(ConfigurationKeys.DISABLE_GLOBAL_TRANSACTION, (ConfigurationChangeListener)this);
return;
}
//通过CAS操作确保initClient()初始化动作仅仅执行一次
if (initialized.compareAndSet(false, true)) {
//initClient()方法会对Seata Client进行初始化，比如和Seata Server建立长连接
//seata-samples的业务服务、订单服务、库存服务、账号服务的spring.xml配置文件里都配置了GlobalTransactionScanner这个Bean
//而GlobalTransactionScanner这个Bean伴随着Spring容器的初始化完毕，都会回调其初始化逻辑initClient()
initClient();
}
}
//initClient()是核心方法，负责对Seata Client客户端进行初始化
private void initClient() {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Initializing Global Transaction Clients ... ");
}
//对于Seata Client来说，最重要的组件有两个：
//一个是TM，即Transaction Manager，全局事务管理器
//一个是RM，即Resource Manager，分支事务资源管理器
//init TM
//TMClient.init()会对TM全局事务管理器客户端进行初始化
TMClient.init(applicationId, txServiceGroup, accessKey, secretKey);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Transaction Manager Client is initialized. applicationId[{}] txServiceGroup[{}]", applicationId, txServiceGroup);
}
//init RM
//RMClient.init()会对RM分支事务资源管理器客户端进行初始化
RMClient.init(applicationId, txServiceGroup);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Resource Manager is initialized. applicationId[{}] txServiceGroup[{}]", applicationId, txServiceGroup);
}
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Global Transaction Clients are initialized. ");
}
//注册Spring容器被销毁时的回调钩子，释放TM和RM两个组件的一些资源
registerSpringShutdownHook();
}
private void registerSpringShutdownHook() {
if (applicationContext instanceof ConfigurableApplicationContext) {
((ConfigurableApplicationContext) applicationContext).registerShutdownHook();
ShutdownHook.removeRuntimeShutdownHook();
}
ShutdownHook.getInstance().addDisposable(TmNettyRemotingClient.getInstance(applicationId, txServiceGroup));
ShutdownHook.getInstance().addDisposable(RmNettyRemotingClient.getInstance(applicationId, txServiceGroup));
}
...
}
4.TM全局事务管理器客户端初始化的源码
TM全局事务管理器在进行初始化之前，会先通过TmNettyRemotingClient的getInstance()方法获取TM组件的Netty网络通信客户端实例，该方法使用了Double Check双重检查机制。
对TM组件的Netty网络通信客户端实例TmNettyRemotingClient进行实例化时，会传入一个创建好的Netty网络通信客户端配置实例NettyClientConfig，以及一个创建好的线程池messageExecutor。
public class TMClient {
public static void init(String applicationId, String transactionServiceGroup) {
init(applicationId, transactionServiceGroup, null, null);
}
public static void init(String applicationId, String transactionServiceGroup, String accessKey, String secretKey) {
//获取TM组件的Netty网络通信客户端实例
TmNettyRemotingClient tmNettyRemotingClient = TmNettyRemotingClient.getInstance(applicationId, transactionServiceGroup, accessKey, secretKey);
tmNettyRemotingClient.init();
}
}
public final class TmNettyRemotingClient extends AbstractNettyRemotingClient {
...
public static TmNettyRemotingClient getInstance() {
//Java并发编程里经典的Double Check
if (instance == null) {
synchronized (TmNettyRemotingClient.class) {
if (instance == null) {
//创建一个NettyClientConfig，作为Netty网络通信客户端的配置
NettyClientConfig nettyClientConfig = new NettyClientConfig();
//创建一个线程池
final ThreadPoolExecutor messageExecutor = new ThreadPoolExecutor(
nettyClientConfig.getClientWorkerThreads(), nettyClientConfig.getClientWorkerThreads(),
KEEP_ALIVE_TIME, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(MAX_QUEUE_SIZE),
new NamedThreadFactory(nettyClientConfig.getTmDispatchThreadPrefix(), nettyClientConfig.getClientWorkerThreads()),
RejectedPolicies.runsOldestTaskPolicy()
);
instance = new TmNettyRemotingClient(nettyClientConfig, null, messageExecutor);
}
}
}
return instance;
}
private TmNettyRemotingClient(NettyClientConfig nettyClientConfig, EventExecutorGroup eventExecutorGroup, ThreadPoolExecutor messageExecutor) {
super(nettyClientConfig, eventExecutorGroup, messageExecutor, NettyPoolKey.TransactionRole.TMROLE);
//安全认证signer数字签名组件
//EnhancedServiceLoader对一个接口进行加载，类似于Seata SPI机制
this.signer = EnhancedServiceLoader.load(AuthSigner.class);
}
...
}
public class NettyClientConfig extends NettyBaseConfig {
private int connectTimeoutMillis = 10000;//连接超时时间
private int clientSocketSndBufSize = 153600;//客户端Socket发送Buffer大小
private int clientSocketRcvBufSize = 153600;//客户端Socket接收Buffer大小
private int clientWorkerThreads = WORKER_THREAD_SIZE;//客户端工作线程
private final Class<? extends Channel> clientChannelClazz = CLIENT_CHANNEL_CLAZZ;//客户端Channel类
private int perHostMaxConn = 2;//每个host的最大连接数
private static final int PER_HOST_MIN_CONN = 2;
private int pendingConnSize = Integer.MAX_VALUE;
private static final long RPC_RM_REQUEST_TIMEOUT = CONFIG.getLong(ConfigurationKeys.RPC_RM_REQUEST_TIMEOUT, DEFAULT_RPC_RM_REQUEST_TIMEOUT);
private static final long RPC_TM_REQUEST_TIMEOUT = CONFIG.getLong(ConfigurationKeys.RPC_TM_REQUEST_TIMEOUT, DEFAULT_RPC_TM_REQUEST_TIMEOUT);
private static String vgroup;
private static String clientAppName;
private static int clientType;
private static int maxInactiveChannelCheck = 10;
private static final int MAX_NOT_WRITEABLE_RETRY = 2000;
private static final int MAX_CHECK_ALIVE_RETRY = 300;
private static final int CHECK_ALIVE_INTERVAL = 10;
private static final String SOCKET_ADDRESS_START_CHAR = "/";
private static final long MAX_ACQUIRE_CONN_MILLS = 60 * 1000L;
private static final String RPC_DISPATCH_THREAD_PREFIX = "rpcDispatch";
private static final int DEFAULT_MAX_POOL_ACTIVE = 1;
private static final int DEFAULT_MIN_POOL_IDLE = 0;
private static final boolean DEFAULT_POOL_TEST_BORROW = true;
private static final boolean DEFAULT_POOL_TEST_RETURN = true;
private static final boolean DEFAULT_POOL_LIFO = true;
private static final boolean ENABLE_CLIENT_BATCH_SEND_REQUEST = CONFIG.getBoolean(ConfigurationKeys.ENABLE_CLIENT_BATCH_SEND_REQUEST, DEFAULT_ENABLE_CLIENT_BATCH_SEND_REQUEST);
...
}
public abstract class AbstractNettyRemotingClient extends AbstractNettyRemoting implements RemotingClient {
...
private final NettyClientBootstrap clientBootstrap;
private NettyClientChannelManager clientChannelManager;
...
public AbstractNettyRemotingClient(NettyClientConfig nettyClientConfig, EventExecutorGroup eventExecutorGroup, ThreadPoolExecutor messageExecutor, NettyPoolKey.TransactionRole transactionRole) {
super(messageExecutor);
this.transactionRole = transactionRole;
clientBootstrap = new NettyClientBootstrap(nettyClientConfig, eventExecutorGroup, transactionRole);
clientBootstrap.setChannelHandlers(new ClientHandler());
clientChannelManager = new NettyClientChannelManager(new NettyPoolableFactory(this, clientBootstrap), getPoolKeyFunction(), nettyClientConfig);
}
...
}
15.全局事务注解扫描器的初始化总结
全局事务注解扫描器GlobalTransactionScanner的初始化主要做了如下三项工作：
一.初始化TM全局事务管理器客户端
二.初始化RM分支事务资源管理器客户端
三.对添加了Seata相关注解的Bean创建全局事务动态代理
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]