如何让Netty通过系统属性监听所有接口？

我在用，哪用，哪用

启动的Netty仅侦听环回（netstat-tulpn输出：）

，但我想让它听“外面的世界”。我希望启动的Netty接受我的LAN-IP地址（例如，192.168.x.y:21221作为本地地址）上的连接，或者甚至接受到Netty端口的每个传入连接（0.0.0.0:21221作为本地地址）。由于我的框架链以某种方式进行了Netty配置，所以我希望在启动应用程序时使用系统属性进行配置。差不多

    System.setProperty("io.netty.listenAddress", "0.0.0.0");

---

这有可能吗？

您可以通过在（Pact->MockServer->）Netty前面放置一个按钮来实现您的要求

这里有一个完整的例子。有一个反向氧化，使用。如前所述，此示例使用and进行HTTP调用

import au.com.dius.pact.consumer.pact；
import au.com.dius.pact.consumer.PactProviderRule；
进口au.com.dius.pact.consumer.PactVerification；
导入au.com.dius.pact.consumer.dsl.PactDslWithProvider；
导入au.com.dius.pact.model.MockProviderConfig；
导入au.com.dius.pact.model.PactFragment；
导入com.gargoylesoftware.htmlunit.Page；
导入com.gargoylesoftware.htmlunit.WebClient；
导入java.io.IOException；
导入java.net.InetSocketAddress；
导入org.junit.Assert；
导入org.junit.Rule；
导入org.junit.Test；
导入org.littleshoot.proxy.ChainedProxyAdapter；
导入org.littleshoot.proxy.ChainedProxyManager；
导入org.littleshoot.proxy.HttpProxyServer；
导入org.littleshoot.proxy.impl.DefaultHttpProxyServer；
公共类HelloIT{
私有静态最终字符串提供程序\服务\路径=“/PROVIDER endpoint”；
@统治
公共PactProviderRule pactProviderServiceMock
=新的PactProviderRule（“提供程序服务”，this）；
私有最终字符串提供程序ServiceReverseProxy URL；
私有静态HttpProxyServer createReverseProxy（最终MockProviderConfig MockProviderConfig）{
最后一个字符串ip=mockProviderConfig.getHostname（）；
final int-port=mockProviderConfig.getPort（）；
最终ChainedProxyManager cpm=（httpRequest，ChainedProxyManager）->{
final ChainedProxyAdapter chainedProxy=新ChainedProxyAdapter（）{
@凌驾
公共InetSocketAddress getChainedProxyAddress（）{
返回新的InetSocketAddress（ip，端口）；
}
};
添加（chainedProxy）；
};
返回DefaultHttpProxyServer.bootstrap（）
.withChainProxyManager（cpm）
.withPort（0）
.带AllowLocalonly（假）
.使用AllowRequestTooriginServer（true）
.start（）；
}
{
/*
*提供程序服务的Pact mock仅侦听环回。使用反向代理进行交互
*在外部IP上的使用者服务和提供者服务之间。
*/
最终HttpProxyServer提供程序ServiceReverseProxy
=HelloIT.createReverseProxy（pactProviderServiceMock.getConfig（））；
this.ProviderServiceReverseProxy URL
=“http://:”+providerServiceReverseProxy.getListenAddress（）.getPort（）；
}
@契约（消费者=“消费者服务”）
公共PactFragment createFragment（最终PactDslWithProvider生成器）{
返回生成器
.uponReceiving（“某些请求”）
.path（提供程序\服务\路径）
.方法（“获取”）
.willrespondbith（）
.现状（200）
.toFragment（）；
}
@试验
@包装验证
public void index（）引发IOException{
最后一页
=新建WebClient（）.getPage（this.providerServiceReverseProxyUrl+提供者服务路径）；
Assert.assertEquals（200，page.getWebResponse（）.getStatusCode（））；
}
}

您所说的所有接口是什么意思？你想让它听eth*？你有多少个接口？用例是什么？请尽量充分解释你的情况。干杯。啊，明白了，抱歉搞混了。当然，我们可以让它这样做，但我想问你的问题是：；你认为这是公约的责任吗？在我看来，这有点超出了条约的责任范围。我知道您有一个特定的用例，但我认为如果您依赖另一个专门为您的情况而设计的工具，然后您可以根据您的用例进行调整，您会更好。我认为这不是Pact的责任，我认为，这很棘手。首先，我想知道，我的要求是否能满足Netty的要求。希望/也许以后，一个发现的或新的Netty配置可以在中记录/使用/集成。是的，我对Netty的了解有限，但我建议您寻找指向pact mock服务的外部内容。我已经找到了一个解决方法。在声明（Pact->MockServer->）Netty之后，我将使用

    System.setProperty("io.netty.listenAddress", "0.0.0.0");

import au.com.dius.pact.consumer.Pact;
import au.com.dius.pact.consumer.PactProviderRule;
import au.com.dius.pact.consumer.PactVerification;
import au.com.dius.pact.consumer.dsl.PactDslWithProvider;
import au.com.dius.pact.model.MockProviderConfig;
import au.com.dius.pact.model.PactFragment;
import com.gargoylesoftware.htmlunit.Page;
import com.gargoylesoftware.htmlunit.WebClient;
import java.io.IOException;
import java.net.InetSocketAddress;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.littleshoot.proxy.ChainedProxyAdapter;
import org.littleshoot.proxy.ChainedProxyManager;
import org.littleshoot.proxy.HttpProxyServer;
import org.littleshoot.proxy.impl.DefaultHttpProxyServer;

public class HelloIT {

  private static final String PROVIDER_SERVICE_PATH = "/provider-endpoint";

  @Rule
  public PactProviderRule pactProviderServiceMock
    = new PactProviderRule("provider-service", this);

  private final String providerServiceReverseProxyUrl;

  private static HttpProxyServer createReverseProxy(final MockProviderConfig mockProviderConfig) {
    final String ip = mockProviderConfig.getHostname();
    final int port = mockProviderConfig.getPort();

    final ChainedProxyManager cpm = (httpRequest, chainedProxies) -> {
      final ChainedProxyAdapter chainedProxy = new ChainedProxyAdapter() {
        @Override
        public InetSocketAddress getChainedProxyAddress() {
          return new InetSocketAddress(ip, port);
        }
      };
      chainedProxies.add(chainedProxy);
    };

    return DefaultHttpProxyServer.bootstrap()
      .withChainProxyManager(cpm)
      .withPort(0)
      .withAllowLocalOnly(false)
      .withAllowRequestToOriginServer(true)
      .start();
  }

  {
    /*
     * Pact-mock for provider-service listens on loopback only. Using reverse proxy for interaction
     * between consumer-service and provider-service on external IP.
     */
    final HttpProxyServer providerServiceReverseProxy
      = HelloIT.createReverseProxy(pactProviderServiceMock.getConfig());

    this.providerServiceReverseProxyUrl
      = "http://<your-external-IP>:" + providerServiceReverseProxy.getListenAddress().getPort();
  }

  @Pact(consumer = "consumer-service")
  public PactFragment createFragment(final PactDslWithProvider builder) {
    return builder
      .uponReceiving("Some request")
      .path(PROVIDER_SERVICE_PATH)
      .method("GET")
      .willRespondWith()
      .status(200)
      .toFragment();
  }

  @Test
  @PactVerification
  public void index() throws IOException {
    final Page page
      = new WebClient().getPage(this.providerServiceReverseProxyUrl + PROVIDER_SERVICE_PATH);
    Assert.assertEquals(200, page.getWebResponse().getStatusCode());
  }
}