dubbo源码分析4-- ReferenceBean 获取消费者代理对象
主要工作
-
获取invoker对象
a)注册消费端的临时节点
b) 订阅以下的节点
/dubbo/com.test.ITestService/providers
/dubbo/com.test.ITestService/configurators
/dubbo/com.test.ITestService/routers
c) 当这些节点下的子节点发生变化: 刷新本地的RequestDirector的本地urlInvokerMap列表
第一次初始化invoker，创建DubboInvoker。启动netty客户端连接 -
将invoker包装在代理对象Proxy$0中。返回代理对象
流程
主流程
消费端接口初始化或者有提供者节点变化时，通知更新本地zookeeper缓存文件
消费端接口初始化或者有提供者节点变化时，通知更新本地的invoker列表 urlInvokerMap
在更新本地的invoker列表时，没有生成过Invoker，需要指定Invoker且netty客户端连接服务端
入口
ReferenceBean 实现了FactoryBean, 那么在从io容器获取Bean时，就调用了Object getObject()
private transient volatile T ref; //保存代理对象
当有对象时，直接返回，否则初始化
public synchronized T get() {
if (destroyed) {
throw new IllegalStateException("Already destroyed!");
}
if (ref == null) {
init();
}
return ref;
}
init()组装参数，最终调用 ref = createProxy(map);
- 封装urls
用户指定URL，指定的URL可能是对点对直连地址；否则通过注册中心配置拼装URL
//用户指定URL，指定的URL可能是对点对直连地址，也可能是注册中心URL
if (url != null && url.length() > 0) {
String[] us = Constants.SEMICOLON_SPLIT_PATTERN.split(url);
if (us != null && us.length > 0) {
for (String u : us) {
URL url = URL.valueOf(u);
if (url.getPath() == null || url.getPath().length() == 0) {
url = url.setPath(interfaceName);
}
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
urls.add(url.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
} else {
urls.add(ClusterUtils.mergeUrl(url, map));
}
}
}
} else {
//通过注册中心配置拼装URL
List us = loadRegistries(false);
if (us != null && !us.isEmpty()) {
for (URL u : us) {
URL monitorUrl = loadMonitor(u);
if (monitorUrl != null) {
map.put(Constants.MONITOR_KEY, URL.encode(monitorUrl.toFullString()));
}
urls.add(u.addParameterAndEncoded(Constants.REFER_KEY, StringUtils.toQueryString(map)));
}
}
if (urls == null || urls.isEmpty()) {
throw new IllegalStateException();
}
}
- 获取invoker
if (urls.size() == 1) {
invoker = refprotocol.refer(interfaceClass, urls.get(0));
} else {
List> invokers = new ArrayList>();
URL registryURL = null;
for (URL url : urls) {
invokers.add(refprotocol.refer(interfaceClass, url));
if (Constants.REGISTRY_PROTOCOL.equals(url.getProtocol())) {
registryURL = url;
}
}
//有注册中心的地址, StaticDirectory
if (registryURL != null) {
URL u = registryURL.addParameter(Constants.CLUSTER_KEY, AvailableCluster.NAME);
invoker = cluster.join(new StaticDirectory(u, invokers));
} else { // not a registry url
invoker = cluster.join(new StaticDirectory(invokers));
}
}
获取invoker对象
refprotocol.refer(interfaceClass, url)
refprotocol这里的对象是RegistryProtocol
1.获取Registry:ZookeeperRegistry
//将registry协议改成zookeeper。
url = url.setProtocol(url.getParameter(Constants.REGISTRY_KEY, Constants.DEFAULT_REGISTRY)).removeParameter(Constants.REGISTRY_KEY);
Registry registry = registryFactory.getRegistry(url);
if (RegistryService.class.equals(type)) {
return proxyFactory.getInvoker((T) registry, type, url);
}
2.向zookeeper注册consumer://10.118.14.24/com.test.ITestService节点
registry.register(subscribeUrl.addParameters(Constants.CATEGORY_KEY, Constants.CONSUMERS_CATEGORY,
Constants.CHECK_KEY, String.valueOf(false)));
a)将url保存到注册列表中
b)创建提供者的临时节点
c)出现异常时，开启启动时检测，直接抛出异常；否则记录到failedRegistered,等待定时重新注册
3.创建RegistryDirectory，并且订阅consumer://10.118.14.24/com.test.ITestService
consumer://10.118.14.24/com.test.ITestService?category=providers,configurators,routers&side=consumer…
RegistryDirectory directory = new RegistryDirectory(type, url);
directory.setRegistry(registry);
directory.setProtocol(protocol);
URL subscribeUrl = new URL(Constants.CONSUMER_PROTOCOL, NetUtils.getLocalHost(), 0,
type.getName(), directory.getUrl().getParameters());
//加参数category：providers,configurators,routers
directory.subscribe(subscribeUrl.addParameter(Constants.CATEGORY_KEY,
Constants.PROVIDERS_CATEGORY
+ "," + Constants.CONFIGURATORS_CATEGORY
+ "," + Constants.ROUTERS_CATEGORY));
4.cluster.join(directory);
默认是FailoverCluster， 所以返回的invoker对象是MockClusterInvoker(FailoverClusterInvoker)
mock=com.alibaba.dubbo.rpc.cluster.support.wrapper.MockClusterWrapper
failover=com.alibaba.dubbo.rpc.cluster.support.FailoverCluster
failfast=com.alibaba.dubbo.rpc.cluster.support.FailfastCluster
failsafe=com.alibaba.dubbo.rpc.cluster.support.FailsafeCluster
failback=com.alibaba.dubbo.rpc.cluster.support.FailbackCluster
forking=com.alibaba.dubbo.rpc.cluster.support.ForkingCluster
available=com.alibaba.dubbo.rpc.cluster.support.AvailableCluster
mergeable=com.alibaba.dubbo.rpc.cluster.support.MergeableCluster
broadcast=com.alibaba.dubbo.rpc.cluster.support.BroadcastCluster
创建代理对象
上面创建了invoker对象
proxyFactory.getProxy(invoker)
StubProxyFactoryWrapper(JavassistProxyFactory)
stub=com.alibaba.dubbo.rpc.proxy.wrapper.StubProxyFactoryWrapper
jdk=com.alibaba.dubbo.rpc.proxy.jdk.JdkProxyFactory
javassist=com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory
- JavassistProxyFactory创建代理对象
获取代理方法
public T getProxy(Invoker invoker, Class[] interfaces) {
return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
}
拦截器
public class InvokerInvocationHandler implements InvocationHandler {
private final Invoker invoker;
public InvokerInvocationHandler(Invoker handler){
this.invoker = handler;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
Class[] parameterTypes = method.getParameterTypes();
if (method.getDeclaringClass() == Object.class) {
return method.invoke(invoker, args);
}
if ("toString".equals(methodName) && parameterTypes.length == 0) {
return invoker.toString();
}
if ("hashCode".equals(methodName) && parameterTypes.length == 0) {
return invoker.hashCode();
}
if ("equals".equals(methodName) && parameterTypes.length == 1) {
return invoker.equals(args[0]);
}
return invoker.invoke(new RpcInvocation(method, args)).recreate();
}
}
总结
从ioc获取的对象是代理对象Proxy$0
交给InvokerInvocationHandler进行处理->MockClusterInvoker -> FailoverClusterInvoker-> RegistryDirectory->invoke列表
以下是分支流程=======================
zookeeper 订阅
RegistryDirectory 实现了NotifyListener， 本身就是个监听器
调用RegistryDirectory的subscribe，registry就是ZookeeperRegistry
而订阅直接交给registry去处理， 而其中的this是RegistryDirectory
public void subscribe(URL url) {
setConsumerUrl(url);
registry.subscribe(url, this);
}
一：url和RegistryDirectory保存在subscribed中
consumer://10.118.14.24/com.test.ITestService?category=providers,configurators,routers&side=consumer…
二：ZookeeperRegistry 订阅url
调用ZookeeperRegistry.doSubscribe(final URL url, final NotifyListener listener) ;
consumer://10.118.14.24/10.118.14.24/com.test.ITestService?category=providers,configurators,routers&default.check=false&default.cluster=failfast&default.timeout=60000&dubbo=2.8.4&interface=com.insaic.itbase.service.BusinessNoGeneratorService&logger=slf4j&methods=test,save&pid=10132&revision=1.0-20191223.094125-383&side=consumer×tamp=1577323081022&version=1.0.0
- I) 创建接口下providers、configurators、routers的路径，并且增加他们的子节点变化监听器
/dubbo/com.test.ITestService/providers
/dubbo/com.test.ITestService/configurators
/dubbo/com.test.ITestService/routers
private String[] toCategoriesPath(URL url) {
String[] categroies;
//接口是* ,那么categroies 就是全量
if (Constants.ANY_VALUE.equals(url.getParameter(Constants.CATEGORY_KEY))) {
categroies = new String[] {Constants.PROVIDERS_CATEGORY, Constants.CONSUMERS_CATEGORY,
Constants.ROUTERS_CATEGORY, Constants.CONFIGURATORS_CATEGORY};
} else {
//从url中获取category
categroies = url.getParameter(Constants.CATEGORY_KEY, new String[] {Constants.DEFAULT_CATEGORY});
}
String[] paths = new String[categroies.length];
for (int i = 0; i < categroies.length; i ++) {
//dubbo+接口+category
paths[i] = toServicePath(url) + Constants.PATH_SEPARATOR + categroies[i];
}
return paths;
}
以下是遍历这些路径path
-------> 1. 获取ChildListener子节点监听器
查看是否创建了监听器
没有，对/dubbo/com.test.ITestService/providers
/dubbo/com.test.ITestService/configurators
/dubbo/com.test.ITestService/routers
初始化监听器
子节点变化通知当前节点子节点有变化，见下一节
ConcurrentMap listeners = zkListeners.get(url);
if (listeners == null) {
zkListeners.putIfAbsent(url, new ConcurrentHashMap());
listeners = zkListeners.get(url);
}
ChildListener zkListener = listeners.get(listener);
if (zkListener == null) {
listeners.putIfAbsent(listener, new ChildListener() {
public void childChanged(String parentPath, List currentChilds) {
ZookeeperRegistry.this.notify(url, listener, toUrlsWithEmpty(url, parentPath, currentChilds));
}
});
zkListener = listeners.get(listener);
}
------->2. 创建持久化节点，并且增加子节点监听器
/dubbo/com.test.ITestService/providers
/dubbo/com.test.ITestService/configurators
/dubbo/com.test.ITestService/routers
zkClient.create(path, false);
List children = zkClient.addChildListener(path, zkListener);
------->3. 获取当前com.test.ITestService的下的providers、routes、configurators所有的子节点
在第一步遍历providers时，当前子节点是
dubbo://10.118.22.51:20710/com.test.ITestService?default.cluster=failfast&default.timeout=3000&dubbo=2.8.4&generic=false&interface=com.test.ITestService&logger=slf4j&methods=test,save&pid=3091&revision=1.0.0&side=provider×tamp=1576650287438&version=1.0.0
当configurators和routers当前没有子节点，就封装成
configurators：
empty://10.118.14.24/com.test.ITestService?&category=configurators&side=consumer×tamp=1577329888735&version=1.0.0
routers：
empty://10.118.14.24/com.test.ITestService?&category=routers&side=consumer×tamp=1577329888735&version=1.0.0
List children = zkClient.addChildListener(path, zkListener);
if (children != null) {
urls.addAll(toUrlsWithEmpty(url, path, children));
}
//当没有子节点时，对consumer地址将协议改成empty，增加对应的category
private List toUrlsWithEmpty(URL consumer, String path, List providers) {
List urls = toUrlsWithoutEmpty(consumer, providers);
if (urls.isEmpty()) {
int i = path.lastIndexOf('/');
String category = i < 0 ? path : path.substring(i + 1);
URL empty = consumer.setProtocol(Constants.EMPTY_PROTOCOL).addParameter(Constants.CATEGORY_KEY, category);
urls.add(empty);
}
return urls;
}
- II)通知子节点发生变化
见下一节
订阅节点的子节点发生变化
notify(url, listener, urls);
url：消费者的url
urls： com.test.ITestService的下的providers、routes、configurators变化的子节点。
listener： RegistryDirectory
- 场景
1. 在订阅初始化的时候 (providers、routes、configurators全量)
url: 当前节点
consumer://10.118.14.24/com.test.ITestService?category=providers,configurators,routers&default.check=false&default.cluster=failfast&default.timeout=60000&dubbo=2.8.4&side=consumer×tamp=1577329888735&version=1.0.0…
listener: RegistryDirectory
urls：当前com.test.ITestService的下的providers、routes、configurators所有的子节点
dubbo://10.118.22.51:20710/com.test.ITestService?default.cluster=failfast&default.timeout=3000&dubbo=2.8.4&generic=false&interface=com.test.ITestService&logger=slf4j&methods=test,save&pid=3091&revision=1.0.0&side=provider×tamp=1576650287438&version=1.0.0
empty://10.118.14.24/com.test.ITestService?&category=configurators&side=consumer×tamp=1577329888735&version=1.0.0
empty://10.118.14.24/com.test.ITestService?&category=routers&side=consumer×tamp=1577329888735&version=1.0.0
2. 子节点发生变化时(providers、routes、configurators哪个有变化才调用)
new ChildListener() {
public void childChanged(String parentPath, List currentChilds) {
ZookeeperRegistry.this.notify(url, listener,
toUrlsWithEmpty(url, parentPath, currentChilds));
}
});
providers、routes、configurators任意一个的子节点发生变化就调用notify。
url: 当前的消费者url
currentChilds是所有的子节点路径
parentPath：providers、routes、configurators
- 源码
1. 对当前的url进行分类。按照category（providers、routes、configurators）分类， 并且放入到notified中
Map> result = new HashMap>();
for (URL u : urls) {
if (UrlUtils.isMatch(url, u)) {
String category = u.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
List categoryList = result.get(category);
if (categoryList == null) {
categoryList = new ArrayList();
result.put(category, categoryList);
}
categoryList.add(u);
}
}
2. 保存urls到文件中和properties
private void saveProperties(URL url) {
if (file == null) {
return;
}
//组装内容
StringBuilder buf = new StringBuilder();
Map> categoryNotified = notified.get(url);
if (categoryNotified != null) {
for (List us : categoryNotified.values()) {
for (URL u : us) {
if (buf.length() > 0) {
//空格分隔符
buf.append(' ');
}
buf.append(u.toFullString());
}
}
}
//放入到properties
properties.setProperty(url.getServiceKey(), buf.toString());
long version = lastCacheChanged.incrementAndGet();
//保存文件
if (syncSaveFile) {
doSaveProperties(version);
} else {
registryCacheExecutor.execute(new SaveProperties(version));
}
}
先创建dubbo-registry-10.118.22.55.cache.lock 空文件， 对空文件进行上锁，保存文件。然后再释放锁。
public void doSaveProperties(long version) {
// 当前版本小于最后一次，不再保存
if(version < lastCacheChanged.get()){
return;
}
if (file == null) {
return;
}
Properties newProperties = new Properties();
// 保存之前先读取一遍，防止多个注册中心之间冲突
InputStream in = null;
if (file.exists()) {
in = new FileInputStream(file);
newProperties.load(in);
}
// 保存
try {
newProperties.putAll(properties);
//先创建dubbo-registry-10.118.22.55.cache.lock 空文件
File lockfile = new File(file.getAbsolutePath() + ".lock");
if (!lockfile.exists()) {
lockfile.createNewFile();
}
//先对空文件进行上锁
RandomAccessFile raf = new RandomAccessFile(lockfile, "rw");
try {
FileChannel channel = raf.getChannel();
try {
FileLock lock = channel.tryLock();
if (lock == null) {
throw new IOException("");
}
// 保存
try {
if (! file.exists()) {
file.createNewFile();
}
FileOutputStream outputFile = new FileOutputStream(file);
try {
newProperties.store(outputFile, "Dubbo Registry Cache");
} finally {
outputFile.close();
}
} finally {
lock.release();
}
} finally {
channel.close();
}
} finally {
raf.close();
}
} catch (Throwable e) {
if (version < lastCacheChanged.get()) {
return;
} else {
registryCacheExecutor.execute(new SaveProperties(lastCacheChanged.incrementAndGet()));
}
logger.warn("Failed to save registry store file, cause: " + e.getMessage(), e);
}
}
3.listener.notify(categoryList); 刷新本地的invoker
见下一节
RegistryDirectory.notify 刷新本地的invoker列表
- 分类
routerUrls ： category是routers或者protocol是route
configuratorUrls ： category是configurators或者override是route
invokerUrls ： category是providers
List invokerUrls = new ArrayList();
List routerUrls = new ArrayList();
List configuratorUrls = new ArrayList();
for (URL url : urls) {
String protocol = url.getProtocol();
String category = url.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
if ("routers".equals(category) || "route".equals(protocol)) {
routerUrls.add(url);
} else if ("configurators".equals(category) || "override".equals(protocol)) {
configuratorUrls.add(url);
} else if (“”providers“”.equals(category)) {
invokerUrls.add(url);
}
}
- 获取List
configurators
对configuratorUrls 循环处理， configuratorFactory.getConfigurator(url)
根据协议来判断来做处理
override=com.alibaba.dubbo.rpc.cluster.configurator.override.OverrideConfiguratorFactory
absent=com.alibaba.dubbo.rpc.cluster.configurator.absent.AbsentConfiguratorFactory
- 获取List
routers
Router router = routerFactory.getRouter(url);
file=com.alibaba.dubbo.rpc.cluster.router.file.FileRouterFactory
script=com.alibaba.dubbo.rpc.cluster.router.script.ScriptRouterFactory
condition=com.alibaba.dubbo.rpc.cluster.router.condition.ConditionRouterFactory
- 刷新本地的invoker列表
最终将生成的invoker列表保存在本地urlInvokerMap中
private void refreshInvoker(List invokerUrls){
//....
this.forbidden = false; // 允许访问
//旧的invoker列表
Map> oldUrlInvokerMap = this.urlInvokerMap;
if (invokerUrls.size() ==0 ){
return;
}
// 将URL列表转成Invoker列表
Map> newUrlInvokerMap = toInvokers(invokerUrls) ;
// 换方法名映射Invoker列表
Map>> newMethodInvokerMap = toMethodInvokers(newUrlInvokerMap);
//没有新的invoker，则不再处理
if (newUrlInvokerMap == null || newUrlInvokerMap.size() == 0 ){
return ;
}
this.methodInvokerMap = multiGroup ? toMergeMethodInvokerMap(newMethodInvokerMap) : newMethodInvokerMap;
//保存到本地urlInvokerMap中
this.urlInvokerMap = newUrlInvokerMap;
try{
//销毁未使用的invoker列表（在旧的invoker列表中，不在新的invoker列表）
destroyUnusedInvokers(oldUrlInvokerMap,newUrlInvokerMap);
}catch (Exception e) {
logger.warn("destroyUnusedInvokers error. ", e);
}
}
重点：获取新的invoker列表
a) 合并url参数 顺序为override >Consumer > Provider
b) 查看urlInvokerMap中是否有了，没有重新生成消费端的invoker代理对象
new InvokerDelegete(protocol.refer(serviceType, url), url, providerUrl);见下一节
c)销毁 未使用的invoker列表( in(老的invoker列表) and not in（新的invoker列表）)
private Map> toInvokers(List urls) {
Map> newUrlInvokerMap = new HashMap>();
if(urls == null || urls.size() == 0){
return newUrlInvokerMap;
}
Set keys = new HashSet();
String queryProtocols = this.queryMap.get(Constants.PROTOCOL_KEY);
for (URL providerUrl : urls) {
if (Constants.EMPTY_PROTOCOL.equals(providerUrl.getProtocol())) {
continue;
}
//查看协议是否支持
if (! ExtensionLoader.getExtensionLoader(Protocol.class).hasExtension(providerUrl.getProtocol())) {
continue;
}
//合并url (提供者的url和消费者的url进行合并)
URL url = mergeUrl(providerUrl);
String key = url.toFullString(); // URL参数是排序的
if (keys.contains(key)) { // 重复URL
continue;
}
keys.add(key);
// 缓存key为没有合并消费端参数的URL，不管消费端如何合并参数，如果服务端URL发生变化，则重新refer
Map> localUrlInvokerMap = this.urlInvokerMap; // local reference
Invoker invoker = localUrlInvokerMap == null ? null : localUrlInvokerMap.get(key);
if (invoker == null) { // 缓存中没有，重新refer
//...查看是否增加disabled或者enabled
boolean enabled = true;
if (enabled) {
invoker = new InvokerDelegete(protocol.refer(serviceType, url), url, providerUrl);
}
if (invoker != null) { // 将新的引用放入缓存
newUrlInvokerMap.put(key, invoker);
}
}else {
newUrlInvokerMap.put(key, invoker);
}
}
keys.clear();
return newUrlInvokerMap;
}
合并url参数 顺序为override > -D >Consumer > Provider
private URL mergeUrl(URL providerUrl){
providerUrl = ClusterUtils.mergeUrl(providerUrl, queryMap); // 合并消费端参数
//对提供者进行处理
List localConfigurators = this.configurators;
if (localConfigurators != null && localConfigurators.size() > 0) {
for (Configurator configurator : localConfigurators) {
providerUrl = configurator.configure(providerUrl);
}
}
providerUrl = providerUrl.addParameter(Constants.CHECK_KEY, String.valueOf(false)); // 不检查连接是否成功，总是创建Invoker！
//directoryUrl 与 override 合并是在notify的最后，这里不能够处理
this.overrideDirectoryUrl = this.overrideDirectoryUrl.addParametersIfAbsent(providerUrl.getParameters()); // 合并提供者参数
return providerUrl;
}
DubboProtocol.refer
ProtocolFilterWrapper:
过滤所有的consumer下的Filter，循环对invoker进行包装
- 创建DubboInvoker并且保存在invokers
public Invoker refer(Class serviceType, URL url) throws RpcException {
optimizeSerialization(url);
DubboInvoker invoker = new DubboInvoker(serviceType, url, getClients(url), invokers);
invokers.add(invoker);
return invoker;
}
- 初始化netty客户端
private ExchangeClient[] getClients(URL url){
//是否共享连接
boolean service_share_connect = false;
int connections = url.getParameter(Constants.CONNECTIONS_KEY, 0);
//如果connections不配置，则共享连接，否则每服务每连接
if (connections == 0){
service_share_connect = true;
connections = 1;
}
ExchangeClient[] clients = new ExchangeClient[connections];
for (int i = 0; i < clients.length; i++) {
if (service_share_connect){
clients[i] = getSharedClient(url);
} else {
clients[i] = initClient(url);
}
}
return clients;
}
/**
*获取共享连接
*/
private ExchangeClient getSharedClient(URL url){
String key = url.getAddress();
ReferenceCountExchangeClient client = referenceClientMap.get(key);
if ( client != null ){
if ( !client.isClosed()){
client.incrementAndGetCount();
return client;
} else {
referenceClientMap.remove(key);
}
}
ExchangeClient exchagneclient = initClient(url);
client = new ReferenceCountExchangeClient(exchagneclient, ghostClientMap);
referenceClientMap.put(key, client);
ghostClientMap.remove(key);
return client;
}
初始化客户端
/**
* 创建新连接.
*/
private ExchangeClient initClient(URL url) {。
//默认开启heartbeat
url = url.addParameterIfAbsent(Constants.HEARTBEAT_KEY, String.valueOf(Constants.DEFAULT_HEARTBEAT));
ExchangeClient client ;
try {
//设置连接应该是lazy的
if (url.getParameter(Constants.LAZY_CONNECT_KEY, false)){
client = new LazyConnectExchangeClient(url ,requestHandler);
} else {
client = Exchangers.connect(url ,requestHandler);
}
} catch (RemotingException e) {
throw new RpcException("Fail to create remoting client for service(" + url
+ "): " + e.getMessage(), e);
}
return client;
}
netty客户端连接
创建客户端连接 Exchangers.connect(url ,requestHandler)
new HeaderExchangeClient(Transporters.connect(url, new DecodeHandler(new HeaderExchangeHandler(handler))))
- HeaderExchangeClient
初始化时，开启定时心跳
this.channel = new HeaderExchangeChannel(client);
定时发送心跳数据给服务端，并且超时了，重连服务端
heatbeatTimer = scheduled.scheduleWithFixedDelay(
new HeartBeatTask( new HeartBeatTask.ChannelProvider() {
public Collection getChannels() {
return Collections.singletonList( HeaderExchangeClient.this );
}
}, heartbeat, heartbeatTimeout),
heartbeat, heartbeat, TimeUnit.MILLISECONDS );
//上次读取的时间
Long lastRead = ( Long ) channel.getAttribute(
HeaderExchangeHandler.KEY_READ_TIMESTAMP );
//上次写入的时间
Long lastWrite = ( Long ) channel.getAttribute(
HeaderExchangeHandler.KEY_WRITE_TIMESTAMP );
//在时间内， 发送心跳信息给服务端
if ( ( lastRead != null && now - lastRead > heartbeat )
|| ( lastWrite != null && now - lastWrite > heartbeat ) ) {
Request req = new Request();
req.setVersion( "2.0.0" );
req.setTwoWay( true );
req.setEvent( Request.HEARTBEAT_EVENT );
channel.send( req );
}
//超时了，重连
if ( lastRead != null && now - lastRead > heartbeatTimeout ) {
if (channel instanceof Client) {
((Client)channel).reconnect();
} else {
channel.close();
}
}
- netty客户端初始化 new NettyClient
初始化
protected void doOpen() throws Throwable {
NettyHelper.setNettyLoggerFactory();
bootstrap = new ClientBootstrap(channelFactory);
// config
// @see org.jboss.netty.channel.socket.SocketChannelConfig
bootstrap.setOption("keepAlive", true);
bootstrap.setOption("tcpNoDelay", true);
bootstrap.setOption("connectTimeoutMillis", getTimeout());
final NettyHandler nettyHandler = new NettyHandler(getUrl(), this);
bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() {
NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyClient.this);
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("decoder", adapter.getDecoder());
pipeline.addLast("encoder", adapter.getEncoder());
pipeline.addLast("handler", nettyHandler);
return pipeline;
}
});
}
连接
启动定时，查看是否连接，没有的话，重新连接
protected void connect() throws RemotingException {
connectLock.lock();
try {
if (isConnected()) {
return;
}
//启动
initConnectStatusCheckCommand();
doConnect();
if (! isConnected()) {
throw new RemotingException();
}
reconnect_count.set(0);
reconnect_error_log_flag.set(false);
} finally {
connectLock.unlock();
}
}
等待服务器的响应
protected void doConnect() throws Throwable {
long start = System.currentTimeMillis();
ChannelFuture future = bootstrap.connect(getConnectAddress());
try{
//等待
boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);
//连接成功
if (ret && future.isSuccess()) {
Channel newChannel = future.getChannel();
newChannel.setInterestOps(Channel.OP_READ_WRITE);
try {
// 关闭旧的连接
Channel oldChannel = NettyClient.this.channel; // copy reference
if (oldChannel != null) {
try {
oldChannel.close();
} finally {
NettyChannel.removeChannelIfDisconnected(oldChannel);
}
}
} finally {
//新连接也是关闭的，将新连接关闭
if (NettyClient.this.isClosed()) {
try {
newChannel.close();
} finally {
NettyClient.this.channel = null;
NettyChannel.removeChannelIfDisconnected(newChannel);
}
} else {
//赋值
NettyClient.this.channel = newChannel;
}
}
} else if (future.getCause() != null) {
throw new RemotingException();
} else {
throw new RemotingException();
}
}finally{
if (! isConnected()) {
future.cancel();
}
}
}