android netty udp 服务处理

目录

---

---

Netty TCP客户端（TcpClient）

Reactor Netty提供了易于使用和易于配置的TcpClient。它隐藏了创建TCP客户端所需的大部分 Netty功能，并添加了Reactive Streams背压（Reactive Streams是具有无阻塞背压的异步流处理的标准）

连接和断开

要将TCP客户端连接到给定端点，必须创建并配置一个 TcpClient实例。默认情况下，host是localhost和port是12012

创建一个TcpClient：
返回的Connection提供了一个简单的连接 API，包括disposeNow()，它以阻塞方式关闭客户端

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create() // 创建一个TcpClient 准备好配置的实例
				         .connectNow(); // 以阻塞方式连接客户端并等待它完成初始化

		connection.onDispose()
		          .block();
	}
	
}

主机和端口

要连接到特定的host和port，可以将以下配置应用到TCP客户端

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")  // 配置TCP主机
				         .port(80)        // 配置TCP端口    
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

急切初始化

默认情况下，TcpClient资源的初始化是按需进行的。这意味着connect operation吸收了初始化和加载所需的额外时间

当需要预加载这些资源时，可以进行TcpClient如下配置：

import reactor.core.publisher.Mono;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		TcpClient tcpClient =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .handle((inbound, outbound) -> outbound.sendString(Mono.just("hello")));
         // 初始化并加载事件循环组、主机名解析器、本机传输库和用于安全性的本机库
		tcpClient.warmup() 
		         .block();
         // 连接到远程对等方时发生主机名解析
		Connection connection = tcpClient.connectNow(); 

		connection.onDispose()
		          .block();
	}
	
}

写入数据

要将数据发送到给定端点，必须附加一个I/O处理程序。I/O处理程序有权访问以NettyOutbound 能够写入数据

import reactor.core.publisher.Mono;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
                          // 将hello字符串发送到服务端点
				         .handle((inbound, outbound) -> outbound.sendString(Mono.just("hello"))) 
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

当需要更多地控制写入过程时，作为I/O处理程序的替代方案，可以使用Connection#outbound. 与在提供的Publisher完成时关闭连接的I/O处理程序相反（在finite的情况下Publisher），当使用时Connection#outbound，必须显式调用Connection#dispose以关闭连接。

import reactor.core.publisher.Mono;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .connectNow();

		connection.outbound()
		          .sendString(Mono.just("hello 1")) // 将hello 1字符串发送到端点
		          .then()
		          .subscribe();

		connection.outbound()
		          .sendString(Mono.just("hello 2"))  // 将hello 2字符串发送到端点
		          .then()
		          .subscribe(null, null, connection::dispose);  // 将消息发送到端点后关闭连接

		connection.onDispose()
		          .block();
	}
	
}

消费数据

要从给定端点接收数据，必须附加一个I/O处理程序。I/O处理程序有权访问NettyInbound以读取数据

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
                          // 从给定端点接收数据
				         .handle((inbound, outbound) -> inbound.receive().then())
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

当需要对读取过程进行更多控制时（在不同的地方进行不同的数据处理），作为I/O处理程序的替代方案，可以使用 Connection#inbound。与在提供的Publisher完成时关闭连接的 I/O 处理程序相反（在finite的情况下Publisher），当使用Connection#inbound时，必须显式调用Connection#dispose以关闭连接。

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .connectNow();

		connection.inbound()
		          .receive() // 从给定端点接收数据
		          .then()
		          .subscribe();

		connection.onDispose()
		          .block();
	}
	
}

生命周期回调

TcpClient提供了以下生命周期回调函数以便扩展

回调函数	描述
doAfterResolve	在成功解析远程地址后调用
doOnChannelInit	初始化通道时调用
doOnConnect	当通道即将连接时调用
doOnConnected	在通道连接后调用
doOnDisconnected	在通道断开连接后调用
doOnResolve	在即将解析远程地址时调用
doOnResolveError	在远程地址未成功解析的情况下调用

Option和childOption参数设置

Option和childOption参数设置（点击进入…）

TCP-level配置（三种配置）

（1）Channel Options：通道参数选项

默认情况下，TCP客户端配置有以下选项

this.config = new TcpClientConfig(
			provider,
			Collections.singletonMap(ChannelOption.AUTO_READ, false),
			() -> AddressUtils.createUnresolved(NetUtil.LOCALHOST.getHostAddress(), DEFAULT_PORT));

如果需要其他选项或需要更改当前选项，可以应用以下配置：

import io.netty.channel.ChannelOption;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

（2）Wire Logger：连线日志记录

Reactor Netty支持3种不同的格式化程序：

连线日志格式化	描述
AdvancedByteBufFormat#HEX_DUM	同时记录事件和内容。内容将采用十六进制格式（默认）
AdvancedByteBufFormat#SIMPLE	使用此格式启用连线记录时，仅记录事件
AdvancedByteBufFormat#TEXTUAL	同时记录事件和内容。内容将采用纯文本格式

import reactor.netty.DisposableServer;
import reactor.netty.http.server.HttpServer;

public class Application {

	public static void main(String[] args) {
		DisposableServer server =
				HttpServer.create()
                           // 启用连线记录
				          .wiretap(true) 
				          .bindNow();

		server.onDispose()
		      .block();
	}
	
}

当需要更改默认格式化程序时，可以按如下方式进行配置：

import io.netty.handler.logging.LogLevel;
import reactor.netty.DisposableServer;
import reactor.netty.http.server.HttpServer;
import reactor.netty.transport.logging.AdvancedByteBufFormat;

public class Application {

	public static void main(String[] args) {
		DisposableServer server =
				HttpServer.create()
                           // 启用连线记录， AdvancedByteBufFormat#TEXTUAL用于打印内容。
				          .wiretap("logger-name", LogLevel.DEBUG, AdvancedByteBufFormat.TEXTUAL) 
				          .bindNow();

		server.onDispose()
		      .block();
	}
}

（3）Event Loop Group：事件循环组

默认情况下，TCP客户端使用“事件循环组”，其中工作线程的数量等于初始化时运行时可用的处理器数量（但最小值为4）。当需要不同的配置时，可以使用LoopResource#create方法之一

以下清单显示了事件循环组的默认配置：ReactorNetty.java

/**
*默认工作线程数，回退到可用处理器（但最小值为4）
 */
public static final String IO_WORKER_COUNT = "reactor.netty.ioWorkerCount";
/**
 *默认选择器线程计数，回退到-1（无选择器线程）
 */
public static final String IO_SELECT_COUNT = "reactor.netty.ioSelectCount";
/**
 *UDP的默认工作线程数，回退到可用处理器（但最小值为4
 */
public static final String UDP_IO_THREAD_COUNT = "reactor.netty.udp.ioThreadCount";
/**
 * 默认的静默期，保证不会发生对底层循环资源的处置，回退到2秒
 */
public static final String SHUTDOWN_QUIET_PERIOD = "reactor.netty.ioShutdownQuietPeriod";
/**
 * 默认情况下，无论任务是否在静默期内提交，在处理底层资源之前等待的最长时间为15秒。
 */
public static final String SHUTDOWN_TIMEOUT = "reactor.netty.ioShutdownTimeout";
/**
 * 默认值是否首选本机传输（epoll、kqueue），回退在可用时是否首选
 */
public static final String NATIVE = "reactor.netty.native";

如果需要更改这些设置，可以应用以下配置：

import reactor.netty.Connection;
import reactor.netty.resources.LoopResources;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		LoopResources loop = LoopResources.create("event-loop", 1, 4, true);

		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .runOn(loop)
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

连接池

默认情况下，Reactor Netty client（客户端）使用一个“固定”连接池，其中500个为活动通道的最大数量（Channel），1000个为允许保持挂起状态的进一步通道采集尝试的最大数量（对于其余配置，请检查下面的系统属性或构建器配置）。这意味着，如果有人试图获取一个通道，只要创建的通道少于500个，并且由池管理，那么实现就会创建一个新的通道。当达到池中通道的最大数量时，最多会延迟1000次获取通道的新尝试（挂起），直到通道再次返回到池中，并且会因错误而拒绝进一步尝试。

默认“固定”连接池：
①500个为活动通道Channel）
②1000个为允许保持挂起状态的进一步通道采集尝试的最大数量

ReactorNetty.java

/**
默认最大连接数。退回到2个可用处理器（但最小值为16）
 */
public static final String POOL_MAX_CONNECTIONS = "reactor.netty.pool.maxConnections";
/**
 * 出错前的默认采集超时（毫秒）。如果-1在以无限制方式打开新连接之前，永远不会等待获取。后退45秒
 */
public static final String POOL_ACQUIRE_TIMEOUT = "reactor.netty.pool.acquireTimeout";
/**
 * 默认最大空闲时间，fallback -未指定最大空闲时间。
 */
public static final String POOL_MAX_IDLE_TIME = "reactor.netty.pool.maxIdleTime";
/**
 * 默认最大使用寿命，fallback -未指定最大使用寿命
 */
public static final String POOL_MAX_LIFE_TIME = "reactor.netty.pool.maxLifeTime";
/**
 *默认租赁策略（先进先出、后进先出），fallback - fifo
fifo-连接选择为先进先出
lifo -连接选择为后进先出
 */
public static final String POOL_LEASING_STRATEGY = "reactor.netty.pool.leasingStrategy";
/**
 * 与{@link SamplingAllocationStrategy}一起使用的默认{@code getpermitsamplingrate}（介于0d和1d（百分比）之间）。
此策略包装了一个{@link PoolBuilder#sizeBetween（int，int）sizeBetween}{@link AllocationStrategy}，并对{@link AllocationStrategy#getpermissions（int）}的调用进行了示例。回退-未启用。
 */
public static final String POOL_GET_PERMITS_SAMPLING_RATE = "reactor.netty.pool.getPermitsSamplingRate";
/**
 * 与{@link SamplingLocationStrategy}一起使用的默认{@code returnPermitsSamplingRate}（介于0d和1d（百分比）之间）。
此策略包装了一个{@link PoolBuilder#sizeBetween（int，int）sizeBetween}{@link AllocationStrategy}，并对{@link AllocationStrategy#returnpermissions（int）}的调用进行了示例。回退-未启用。
 */
public static final String POOL_RETURN_PERMITS_SAMPLING_RATE = "reactor.netty.pool.returnPermitsSamplingRate";

当需要更改默认设置时，可以进行ConnectionProvider如下配置：

import reactor.netty.Connection;
import reactor.netty.resources.ConnectionProvider;
import reactor.netty.tcp.TcpClient;
import java.time.Duration;

public class Application {

	public static void main(String[] args) {
		ConnectionProvider provider =
				ConnectionProvider.builder("fixed")
                                   // 最大连接数
				                  .maxConnections(50)
				                  // 将连接保持空闲的最长时间配置为 20 秒
				                  .maxIdleTime(Duration.ofSeconds(20))    
				                  // 将连接保持活动的最长时间配置为 60 秒
				                  .maxLifeTime(Duration.ofSeconds(60))    
				                  // 将挂起获取操作的最长时间配置为 60 秒       
				                  .pendingAcquireTimeout(Duration.ofSeconds(60)) 
				                  //每两分钟，将定期检查连接池中是否存在适用于删除的连接
				                  .evictInBackground(Duration.ofSeconds(120))    
				                  .build();

		Connection connection =
				TcpClient.create(provider)
				         .host("example.com")
				         .port(80)
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

当期望高负载时，请谨慎使用具有非常高的最大连接值的连接池。
reactor.netty.http.client.PrematureCloseException由于打开/获取的并发连接过多，可能会遇到 根本原因“连接超时”的异常。

需要禁用连接池，可以应用如下配置：

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.newConnection()
				         .host("example.com")
				         .port(80)
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

（1）disposeInactivePoolsInBackground：检查连接池

启用此选项后，会在后台定期检查连接池，那些在指定时间内为空且不活动的连接池将有资格进行处理。默认情况下，禁用非活动池的这种后台处理。

（2）disposeTimeout：处理超时

当ConnectionProvider#dispose()或ConnectionProvider#disposeLater()被调用时，使用此宽限期超时触发连接池的正常关闭。从那时起，所有获取连接的调用都会快速失败，但会出现异常。但是，对于所提供的Duration，待处理的获取将有机会得到服务。注：拒绝新的获取和计时器立即启动风度，不论认购到Mono的返回ConnectionProvider#disposeLater()。随后的调用返回相同的Mono，有效地从第一个正常关闭调用中获取通知并忽略随后提供的超时。默认情况下，不指定处理超时。

（3）evictInBackground：定期检查符合删除条件的连接

启用此选项后，每个连接池都会根据驱逐标准定期检查符合删除条件的连接maxIdleTime。默认情况下，此后台驱逐是禁用的。

（4）fifo：默认租赁策略 - 先进先出

配置连接池，如果有空闲连接（即池未充分利用），下一次获取操作将获取Least Recently Used连接（LRU，即当前空闲连接中最先释放的连接）。默认租赁策略。

（5）lifo：租赁策略 - 后进先出

配置连接池，如果有空闲连接（即池未充分利用），下一次获取操作将获取Most Recently Used连接（MRU，即当前空闲连接中最后释放的连接）。

（6）maxConnections：连接数

开始挂起之前的最大连接数（每个连接池）。默认：2 * 可用处理器数（但最小值为16）。

（7）maxIdleTime：最大空闲时间

空闲时通道可以关闭的时间（分辨率：ms）。默认值：未指定最大空闲时间。

（8）maxLifeTime：最大寿命

通道有资格关闭的总生命周期（分辨率：ms）。默认值：未指定最大寿命。

（9）metrics：监控指标

启用/禁用与Micrometer的内置集成。ConnectionProvider.MeterRegistrar可以提供与另一个度量系统的集成。默认情况下，metrics未启用。

（10）pendingAcquireMaxCount：挂起队列中的最大额外尝试次数

获取连接以保留在挂起队列中的最大额外尝试次数。如果指定 -1，则挂起队列没有上限。
默认：2 * 最大连接数。

（11）pendingAcquireTimeout：挂起获取必须完成或抛出TimeoutException之前的最长时间

挂起获取必须完成或抛出TimeoutException之前的最长时间（分辨率：毫秒）。如果指定了 -1，则不会应用此类超时。默认值：45秒。

Metrics（监控指标）

TCP客户端支持内置集成的Micrometer，公开了前缀为reactor.netty.connection.provider的所有指标

启用内置集成：

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         .metrics(true)  // 启用与 Micrometer 的内置集成
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

当需要TCP客户端指标与系统集成时，Micrometer或者想提供自己的集成Micrometer，可以提供自己的指标记录器：

import reactor.netty.Connection;
import reactor.netty.channel.ChannelMetricsRecorder;
import reactor.netty.tcp.TcpClient;

import java.net.SocketAddress;
import java.time.Duration;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
				         // 启用 TCP 客户端指标并提供ChannelMetricsRecorder实现
				         .metrics(true, CustomChannelMetricsRecorder::new) 
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

（1）TCP客户端指标的信息

指标名称	类型	描述
reactor.netty.tcp.client.data.received	DistributionSummary	接收的数据量，以字节为单位
reactor.netty.tcp.client.data.sent	DistributionSummary	发送的数据量，以字节为单位
reactor.netty.tcp.client.errors	Counter	发生的错误数
reactor.netty.tcp.client.tls.handshake.time	Timer	TLS握手所花费的时间
reactor.netty.tcp.client.connect.time	Timer	连接到远程地址所花费的时间
reactor.netty.tcp.client.address.resolver	Timer	解析地址所花费的时间

（2）ConnectionProvider指标

指标名称	类型	描述
reactor.netty.connection.provider.total.connections	Gauge	所有连接数，活动或空闲
reactor.netty.connection.provider.active.connections	Gauge	已成功获取且正在使用中的连接数
reactor.netty.connection.provider.max.connections	Gauge	允许的最大活动连接数
reactor.netty.connection.provider.idle.connections	Gauge	空闲连接数
reactor.netty.connection.provider.pending.connections	Gauge	等待连接的请求数
reactor.netty.connection.provider.max.pending.connections	Gauge	等待就绪连接时将排队的最大请求数

（3）ByteBufAllocator metrics（指标）

指标名称	类型	描述
reactor.netty.bytebuf.allocator.used.heap.memory	Gauge	堆内存的字节数
reactor.netty.bytebuf.allocator.used.direct.memory	Gauge	直接内存的字节数
reactor.netty.bytebuf.allocator.used.heap.arenas	Gauge	堆区域的数量（当PooledByteBufAllocator）
reactor.netty.bytebuf.allocator.used.direct.arenas	Gauge	直接竞技场的数量（当PooledByteBufAllocator）
reactor.netty.bytebuf.allocator.used.threadlocal.caches	Gauge	线程本地缓存的数量（当PooledByteBufAllocator）
reactor.netty.bytebuf.allocator.used.small.cache.size	Gauge	小缓存的大小（当PooledByteBufAllocator）
reactor.netty.bytebuf.allocator.used.normal.cache.size	Gauge	正常缓存的大小（当PooledByteBufAllocator）
reactor.netty.bytebuf.allocator.used.chunk.size	Gauge	竞技场的块大小（当PooledByteBufAllocator）

EventLoop metrics（指标）

指标名称	类型	描述
reactor.netty.eventloop.pending.tasks	Gauge	事件循环中待处理的任务数

Unix域套接字

TCP当使用本机传输时，客户端支持Unix域套接字（UDS）

import io.netty.channel.unix.DomainSocketAddress;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
                          // 指定DomainSocketAddress将被使用
				         .remoteAddress(() -> new DomainSocketAddress("/tmp/test.sock")) 
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

主机名解析

默认情况下，TcpClient使用Netty的域名查找机制异步解析域名。这是JVM内置阻塞解析器的替代方案。

当需要更改默认设置时，可以进行TcpClient如下配置：

import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

import java.time.Duration;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
                          // 此解析器执行的每个 DNS 查询的超时将为 500 毫秒
				         .resolver(spec -> spec.queryTimeout(Duration.ofMillis(500))) 
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

有时，可能希望切换到JVM内置解析器。可以进行TcpClient如下配置：

import io.netty.resolver.DefaultAddressResolverGroup;
import reactor.netty.Connection;
import reactor.netty.tcp.TcpClient;

public class Application {

	public static void main(String[] args) {
		Connection connection =
				TcpClient.create()
				         .host("example.com")
				         .port(80)
                          // 	设置JVM内置解析器。
				         .resolver(DefaultAddressResolverGroup.INSTANCE) 
				         .connectNow();

		connection.onDispose()
		          .block();
	}
	
}

可用的配置：

（1）cacheMaxTimeToLive：缓存DNS资源记录的最大生存时间

缓存的DNS资源记录的最大生存时间（分辨率：秒）。如果DNS服务器返回的DNS资源记录的生存时间大于此最大生存时间，则此解析器将忽略来自DNS服务器的生存时间并使用此最大生存时间。默认为Integer.MAX_VALUE.

（2）cacheMinTimeToLive：缓存DNS资源记录的最小生存时间

缓存的DNS资源记录的最小生存时间（分辨率：秒）。如果DNS服务器返回的DNS资源记录的生存时间小于此最小生存时间，则此解析器将忽略来自DNS服务器的生存时间并使用此最小生存时间。默认值：0。

（3）cacheNegativeTimeToLive：失败DNS查询的缓存的生存时间

失败的DNS查询的缓存的生存时间（分辨率：秒）。默认值：0。

（4）completeOncePreferredResolved：解析器会在首选地址类型的所有查询完成后立即通知

启用此设置后，解析器会在首选地址类型的所有查询完成后立即通知。禁用此设置后，解析器会在所有可能的地址类型完成时发出通知。此配置适用于DnsNameResolver#resolveAll(String)。默认：启用

（5）disableOptionalRecord：禁用可选记录的自动包含

禁用可选记录的自动包含，该记录试图向远程DNS服务器提供有关解析器每个响应可以读取多少数据的提示。默认：启用。

（6）disableRecursionDesired：解析器是否必须发送设置了递归所需（RD）标志的DNS查询

指定此解析器是否必须发送设置了递归所需（RD）标志的DNS查询。默认：启用。

（7）hostsFileEntriesResolver：文件条目分解器

设置HostsFileEntriesResolver用于主机文件条目的自定义。默认值：DefaultHostsFileEntriesResolver。

（8）maxPayloadSize：数据报包缓冲区的容量

设置数据报包缓冲区的容量（以字节为单位）。默认值：4096 byte。

（9）maxQueriesPerResolve：解析主机名时允许发送的最大DNS查询数

设置解析主机名时允许发送的最大DNS查询数。默认值：16。

（10）ndots：初始绝对查询之前必须出现在名称中的点数

设置在进行初始绝对查询之前必须出现在名称中的点数。默认值：-1（确定来自Unix上的操作系统的值，否则使用值1）

（11）queryTimeout：解析器执行的每个DNS查询的超时时间

设置此解析器执行的每个DNS查询的超时时间（分辨率：毫秒）。默认值：5000。

（12）resolvedAddressTypes：解析地址的协议族列表

解析地址的协议族列表。

（13）bindAddressSupplier：本地地址的供应商

要绑定到的本地地址的供应商。

（14）roundRobinSelection：服务器地址的随机选择

启用DnsNameResolver的AddressResolver组，如果名称服务器提供多个地址，则该组支持随机选择目标地址。请参阅RoundRobinDnsAddressResolverGroup。默认值：DnsAddressResolverGroup

（15）runOn：在给定资源上执行与DNS服务器的通信

在给定资源上执行与DNS服务器的通信。默认情况下，将使用在客户端级别指定的LoopResources。

（16）searchDomains：解析器的搜索域列表

解析器的搜索域列表。默认情况下，使用系统DNS搜索域填充有效搜索域列表。

（17）trace：解析失败的情况下生成详细跟踪信息

在解析失败的情况下生成详细跟踪信息时，此解析器将使用的特定记录器和日志级别。