Java Apache Ignite 2.6无限循环连接客户端到服务器TcpCommunicationSpi

当我启动客户机节点并连接到服务器时，我在服务器日志中得到无限循环的消息

|[2018.08.21 17:01:22.997]|INFO |r-tcp-comm-1-#26|TcpCommunicationSpi           | Accepted incoming communication connection [locAddr=/10.144.193.157:48100, rmtAddr=/10.144.13.223:46208]
|[2018.08.21 17:01:22.999]|INFO |r-tcp-comm-1-#26|TcpCommunicationSpi           | Received incoming connection from remote node while connecting to this node, rejecting [locNode=ce9b6147-671b-4351-a142-d251a1362920, locNodeOrder=1, rmtNode=866f0d34-8d0c-48a7-809a-a89aeaf0e7f4, rmtNodeOrder=3]

我的客户端配置

        IgniteConfiguration igniteConfiguration = new IgniteConfiguration();
        igniteConfiguration.setClientMode(true);
        igniteConfiguration.setPeerClassLoadingEnabled(true);

        TcpCommunicationSpi cspi = new TcpCommunicationSpi();
        cspi.setSocketWriteTimeout(60000);

        TcpDiscoverySpi dspi = new TcpDiscoverySpi();
        TcpDiscoveryVmIpFinder ipFinder = new TcpDiscoveryVmIpFinder();
        ipFinder.setAddresses(Collections.singletonList(igniteHost + ":" + ignitePorts));
        dspi.setIpFinder(ipFinder);

        igniteConfiguration.setDiscoverySpi(dspi);
        igniteConfiguration.setCommunicationSpi(cspi);

我的服务器配置

<property name="discoverySpi">
            <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
                <property name="localPort" value="48500"/>
                <property name="ipFinder">
                    <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder">
                        <property name="addresses">
                            <list>
                                <value>127.0.0.1:48500</value>
                            </list>
                        </property>
                    </bean>
                </property>
            </bean>
        </property>

        <property name="communicationSpi">
            <bean class="org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi">
                <property name="localPort" value="48100"/>
            </bean>
        </property>

127.0.0.1:48500

有时（快速关闭并启动客户端应用程序后），客户端连接到服务器时不会出现问题。我在TcpConnectSpiif块if（ConnectFuture的oldFut实例和&locNode.order（）TcpConnectionSpi中，我看到我将仅在oldFut为null时连接，当这是第一次连接到服务器时，oldFut可以为null，但在另一个块中早期是init oldFut linked object。 如何创建客户端到服务器的稳定连接

---

p.S.我使用带ignite 2.6.0的弹簧靴2.0.3。Ignite bean以Ignition.start（cfg）开始。

这些消息通常表明您的网络拓扑存在问题。确保两个客户端都可以连接到服务器端口，服务器也可以连接到客户端端口。

试试这个

IgniteServer:

import java.util.Arrays;
import java.util.Date;

import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.Ignition;
import org.apache.ignite.cache.CacheAtomicityMode;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.CacheWriteSynchronizationMode;
import org.apache.ignite.cache.query.annotations.QuerySqlField;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;

public class IgniteServer {

  private static final String CACHE_NAME = "EmployeeCache";

  public static void main(String[] args) throws InterruptedException {
    try (Ignite ignite = Ignition.start(igniteInstanceConfiguration())) {
      final IgniteCache<Long, Employee> cache = ignite.getOrCreateCache(igniteCacheConfiguration());

      final Employee employee = new Employee(101L, "OhTeri", new Address("100 Zipline", "Irvine", "CA", 92604),
          new Date(2015, 05, 22));

      cache.put(employee.empId, employee);

      while (true) {
        Thread.currentThread().sleep(300000);
        System.out.println("I will run till you don't kill me....");
      }
    }
  }

  private static IgniteConfiguration igniteInstanceConfiguration() {
    IgniteConfiguration cfg = new IgniteConfiguration();
    TcpDiscoverySpi discovery = new TcpDiscoverySpi();
    TcpDiscoveryVmIpFinder finder = new TcpDiscoveryVmIpFinder();
    finder.setAddresses(Arrays.asList("127.0.0.1:47500..47509"));
    discovery.setIpFinder(finder);
    cfg.setDiscoverySpi(discovery);
    cfg.setPeerClassLoadingEnabled(true);
    return cfg;
  }

  private static CacheConfiguration<Long, Employee> igniteCacheConfiguration() {
    final CacheConfiguration<Long, Employee> cacheCfg = new CacheConfiguration<>(CACHE_NAME);
    cacheCfg.setCacheMode(CacheMode.REPLICATED);
    cacheCfg.setIndexedTypes(Long.class, Employee.class);
    cacheCfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
    cacheCfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
    return cacheCfg;
  }

  private static class Address {
    private final String street;
    private final String city;
    private final String state;
    private final int zip;

    public Address(String street, String city, String state, int zip) {
      this.street = street;
      this.city = city;
      this.state = state;
      this.zip = zip;
    }

    public String getStreet() {
      return street;
    }

    public String getCity() {
      return city;
    }

    public String getState() {
      return state;
    }

    public int getZip() {
      return zip;
    }

    @Override
    public String toString() {
      return "Address{" + "street='" + street + '\'' + ", city='" + city + '\'' + ", state='" + state + '\'' + ", zip="
          + zip + '}';
    }
  }

  public static class Employee {
    @QuerySqlField
    private Long empId;

    @QuerySqlField
    private String name;

    @QuerySqlField
    private Address addr;

    @QuerySqlField(index = true)
    private Date date;

    public Employee() {
      // No-op.
    }

    public Employee(Long empId, String name, Address addr, Date date) {
      this.empId = empId;
      this.name = name;
      this.addr = addr;
      this.date = date;
    }

    public String name() {
      return name;
    }

    public Address address() {
      return addr;
    }

    public Date date() {
      return date;
    }

    public Long getEmpId() {
      return empId;
    }

    public void setEmpId(Long empId) {
      this.empId = empId;
    }

    @Override
    public String toString() {
      return "Employee{" + "empId=" + empId + ", name='" + name + '\'' + ", addr='" + addr + '\'' + ", date=" + date
          + '}';
    }
  }
}

导入java.util.array；
导入java.util.Date；
导入org.apache.ignite.ignite；
导入org.apache.ignite.IgniteCache；
导入org.apache.ignite.Ignition；
导入org.apache.ignite.cache.CacheAtomicityMode；
导入org.apache.ignite.cache.CacheMode；
导入org.apache.ignite.cache.CacheWriteSynchronizationMode；
导入org.apache.ignite.cache.query.annotations.QuerySqlField；
导入org.apache.ignite.configuration.CacheConfiguration；
导入org.apache.ignite.configuration.ignite配置；
导入org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi；
导入org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder；
公共类服务器{
私有静态最终字符串缓存\u NAME=“EmployeeCache”；
公共静态void main（字符串[]args）引发InterruptedException{
尝试（Ignite Ignite=Ignition.start（igniteInstanceConfiguration（）））{
final IgniteCache cache=ignite.getOrCreateCache（igniteCacheConfiguration（））；
最终员工=新员工（101L，“OhTeri”，新地址（“100 Zipline”，“Irvine”，“CA”，92604），
新日期（2015年5月22日）；
cache.put（employee.empId，employee）；
while（true）{
Thread.currentThread（）.sleep（300000）；
System.out.println（“我会一直跑，直到你不杀我……”）；
}
}
}
专用静态IgniteConfiguration igniteInstanceConfiguration（）{
IgniteConfiguration cfg=新IgniteConfiguration（）；
TcpDiscoverySpi discovery=新的TcpDiscoverySpi（）；
TcpDiscoveryVmIpFinder=新的TcpDiscoveryVmIpFinder（）；
finder.setAddresses（Arrays.asList（“127.0.0.1:47500..47509”）；
发现。setIpFinder（finder）；
cfg.setDiscoverySpi（发现）；
cfg.setPeerClassLoadingEnabled（真）；
返回cfg；
}
专用静态缓存配置igniteCacheConfiguration（）{
final CacheConfiguration cacheCfg=新的CacheConfiguration（CACHE\u名称）；
cacheCfg.setCacheMode（CacheMode.REPLICATED）；
cacheCfg.setIndexedTypes（Long.class、Employee.class）；
cacheCfg.setAtomicityMode（CacheAtomicityMode.ATOMIC）；
cacheCfg.setWriteSynchronizationMode（CacheWriteSynchronizationMode.FULL_SYNC）；
返回cacheCfg；
}
私有静态类地址{
私家街;；
私人城市；
私有最终字符串状态；
私人终审法院；
公共广播（字符串街道、字符串城市、字符串州、int-zip）{
这条街；
this.city=城市；
this.state=状态；
this.zip=zip；
}
公共字符串getStreet（）{
返回街;；
}
公共字符串getCity（）{
回归城市；
}
公共字符串getState（）{
返回状态；
}
public int getZip（）{
返回拉链；
}
@凌驾
公共字符串toString（）{
返回“地址{”+“街道=”+“街道+”\“”+”，城市=“+城市+”\“”+”，州=“+州+”\“”+”，邮编=”
+zip+'}'；
}
}
公共静态类雇员{
@QuerySqlField
私人长empId；
@QuerySqlField
私有字符串名称；
@QuerySqlField
私人地址地址；
@QuerySqlField（index=true）
私人日期；
公职人员（）{
//禁止操作。
}
公共雇员（长empId、字符串名称、地址地址、日期）{
this.empId=empId；
this.name=名称；
this.addr=addr；
this.date=日期；
}
公共字符串名称（）{
返回名称；
}
公共广播{
返回地址；
}
公开日期{
返回日期；
}
公共长getEmpId（）{
返回empId；
}
公共无效setEmpId（长empId）{
this.empId=empId；
}
@凌驾
公共字符串toString（）{
返回“Employee{“+”empId=“+empId+”，name=”“+name+'\'''''+”，addr=“+addr+'\''''+”，date=“+date
+ '}';
}
}
}

客户：

import org.apache.ignite.ignite；
导入org.apache.ignite.IgniteCache；
导入org.apache.ignite.Ignition；
导入org.apache.ignite.configuration.ignite配置；
导入org.apache.ignite.spi.communication.tcp.tcpccommunicationspi；
导入org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi；
导入org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder；
导入java.util.array；
公共类客户端{
公共静态void main（字符串[]args）{
最终点火器配置igniteCfg=新点火器配置（）；
igniteCfg.setClientMode（真）；
igniteCfg.setPeerClassLoadingEnabled（真）；
最终TCP通信spi spi=新TCP通信
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.Ignition;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.spi.communication.tcp.TcpCommunicationSpi;
import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;

import java.util.Arrays;

public class IgniteClient {

  public static void main(String[] args) {

    final IgniteConfiguration igniteCfg = new IgniteConfiguration();
    igniteCfg.setClientMode(true);
    igniteCfg.setPeerClassLoadingEnabled(true);

    final TcpCommunicationSpi spi = new TcpCommunicationSpi();
    spi.setSocketWriteTimeout(60000);
    final TcpDiscoverySpi discoverySpi = new TcpDiscoverySpi();
    final TcpDiscoveryVmIpFinder finder = new TcpDiscoveryVmIpFinder();
    finder.setAddresses(Arrays.asList("127.0.0.1:47500..47509"));
    discoverySpi.setIpFinder(finder);

    igniteCfg.setDiscoverySpi(discoverySpi);
    igniteCfg.setCommunicationSpi(spi);

    Ignite ignite = Ignition.start(igniteCfg);

    final IgniteCache<Long, IgniteServer.Employee> cache = ignite.cache("EmployeeCache");
    final IgniteServer.Employee employee = cache.get(101L);
    System.out.println("Employee From Server Cache:" + employee);
  }
}