reactor netty 使用tcp 解析dns域名 加入dns缓存 避免每次请求udp解析

在Reactor Netty中使用TCP解析DNS域名并加入DNS缓存，可以有效避免每次请求都通过UDP解析，从而提高性能。以下是一个基本的实现思路：

1. **引入依赖**：首先，确保你的项目中引入了Reactor Netty和DNS解析相关的依赖。

<dependency>
    <groupId>io.projectreactor.netty</groupId>
    <artifactId>reactor-netty</artifactId>
    <version>1.0.7</version>
</dependency>
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-resolver-dns</artifactId>
    <version>4.1.65.Final</version>
</dependency>

2. **创建DNS缓存**：使用一个线程安全的Map来存储DNS解析结果。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class DnsCache {
    private final ConcurrentMap<String, String> cache = new ConcurrentHashMap<>();

    public String get(String host) {
        return cache.get(host);
    }

    public void put(String host, String ip) {
        cache.put(host, ip);
    }
}

3. **配置Reactor Netty使用TCP解析DNS并使用缓存**：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.resolver.dns.DnsAddressResolverGroup;
import io.netty.resolver.dns.DnsServerAddresses;
import io.netty.resolver.dns.DnsQueryContext;
import io.netty.resolver.dns.DnsResponse;
import io.netty.resolver.dns.DnsResponseDecoder;
import io.netty.resolver.dns.DnsNameResolverBuilder;
import io.netty.resolver.dns.DnsCache;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import reactor.netty.tcp.TcpClient;

public class TcpDnsResolver {
    private final DnsCache cache = new DnsCache();

    public String resolve(String host) {
        String ip = cache.get(host);
        if (ip != null) {
            return ip;
        }

        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                     .channel(NioDatagramChannel.class)
                     .option(ChannelOption.SO_BROADCAST, true)
                     .handler(new DnsResponseDecoder());

            DnsAddressResolverGroup resolver = new DnsAddressResolverGroup(DnsServerAddresses.defaults(), new DnsNameResolverBuilder(bootstrap.group().next()));
            Future<InetSocketAddress> future = resolver.resolve(host);
            future.addListener(new GenericFutureListener<Future<InetSocketAddress>>() {
                @Override
                public void operationComplete(Future<InetSocketAddress> future) throws Exception {
                    if (future.isSuccess()) {
                        InetSocketAddress address = future.getNow();
                        cache.put(host, address.getAddress().getHostAddress());
                    }
                }
            });

            return future.get().getAddress().getHostAddress();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            group.shutdownGracefully();
        }
    }
}

4. **使用缓存和TCP解析**：在Reactor Netty中使用TCP解析DNS并使用缓存。

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

public class DnsResolverExample {
    public static void main(String[] args) {
        TcpDnsResolver resolver = new TcpDnsResolver();
        String host = "www.example.com";
        String ip = resolver.resolve(host);
        System.out.println("Resolved IP: " + ip);

        TcpClient client = TcpClient.create()
                                    .host(host)
                                    .port(80)
                                    .connectNow();

        Connection connection = client.block();
        System.out.println("Connection: " + connection);
    }
}

通过上述步骤，你可以使用Reactor Netty通过TCP解析DNS域名，并将解析结果缓存起来，避免每次请求都通过UDP解析，从而提高性能。