Rust异步DNS解析库async-std-resolver使用指南

async-std-resolver是一个基于async-std生态的高性能异步DNS解析库，它提供了简单易用的API来进行域名解析操作。

主要特性

• 完全异步设计，兼容async-std运行时
• 支持A、AAAA、MX、NS、SOA、TXT等多种记录类型查询
• 内置缓存机制提高性能
• 支持自定义DNS服务器配置
• 与async-std生态无缝集成

基本使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
async-std = "1.12"
async-std-resolver = "0.20"

简单查询示例

use async_std_resolver::{resolver, config};

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建解析器配置
    let resolver_config = config::ResolverConfig::default();
    
    // 创建解析器选项
    let resolver_opts = config::ResolverOpts::default();
    
    // 创建解析器实例
    let resolver = resolver(resolver_config, resolver_opts).await?;
    
    // 查询A记录
    let response = resolver.lookup_ip("example.com").await?;
    
    // 打印查询结果
    for ip in response.iter() {
        println!("{}", ip);
    }
    
    Ok(())
}

查询特定记录类型

use async_std_resolver::{resolver, config};
use trust_dns_proto::rr::RecordType;

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resolver = resolver(config::ResolverConfig::default(), config::ResolverOpts::default()).await?;
    
    // 查询MX记录
    let mx_records = resolver.lookup("example.com", RecordType::MX).await?;
    
    for record in mx_records.iter() {
        println!("{:?}", record);
    }
    
    Ok(())
}

高级配置

自定义DNS服务器

use async_std_resolver::{resolver, config};
use std::net::SocketAddr;

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建自定义配置
    let mut resolver_config = config::ResolverConfig::new();
    
    // 添加自定义DNS服务器(如Cloudflare的1.1.1.1)
    resolver_config.add_name_server(config::NameServerConfig {
        socket_addr: SocketAddr::new("1.1.1.1".parse()?, 53),
        protocol: config::Protocol::Udp,
        tls_dns_name: None,
        trust_nx_responses: false,
        bind_addr: None,
    });
    
    let resolver = resolver(resolver_config, config::ResolverOpts::default()).await?;
    
    // 使用自定义DNS服务器查询
    let response = resolver.lookup_ip("rust-lang.org").await?;
    
    println!("查询结果: {:?}", response);
    
    Ok(())
}

超时设置

use async_std_resolver::{resolver, config};
use std::time::Duration;

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut resolver_opts = config::ResolverOpts::default();
    
    // 设置查询超时为5秒
    resolver_opts.timeout = Duration::from_secs(5);
    
    let resolver = resolver(config::ResolverConfig::default(), resolver_opts).await?;
    
    // 查询
    match resolver.lookup_ip("example.com").await {
        Ok(response) => println!("成功: {:?}", response),
        Err(e) => println!("查询失败: {}", e),
    }
    
    Ok(())
}

性能优化建议

1. 复用解析器实例：解析器实例创建成本较高，应尽可能复用
2. 合理使用缓存：默认启用缓存，对于频繁查询的域名可显著提高性能
3. 批量查询：如需查询多个域名，考虑使用join_all等并发方式

use async_std_resolver::{resolver, config};
use async_std::prelude::*;
use futures::future::join_all;

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resolver = resolver(config::ResolverConfig::default(), config::ResolverOpts::default()).await?;
    
    let domains = vec!["example.com", "rust-lang.org", "github.com"];
    
    // 并发查询多个域名
    let queries = domains.into_iter().map(|domain| {
        resolver.lookup_ip(domain)
    }).collect::<Vec<_>>();
    
    let results = join_all(queries).await;
    
    for result in results {
        match result {
            Ok(response) => println!("解析成功: {:?}", response),
            Err(e) => println!("解析失败: {}", e),
        }
    }
    
    Ok(())
}

完整示例代码

下面是一个完整的DNS解析工具示例，结合了上述所有功能：

use async_std_resolver::{resolver, config};
use trust_dns_proto::rr::RecordType;
use std::net::SocketAddr;
use std::time::Duration;
use async_std::prelude::*;
use futures::future::join_all;

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 配置解析器
    let mut resolver_config = config::ResolverConfig::new();
    
    // 添加自定义DNS服务器
    resolver_config.add_name_server(config::NameServerConfig {
        socket_addr: SocketAddr::new("1.1.1.1".parse()?, 53),
        protocol: config::Protocol::Udp,
        tls_dns_name: None,
        trust_nx_responses: false,
        bind_addr: None,
    });
    
    // 设置解析选项
    let mut resolver_opts = config::ResolverOpts::default();
    resolver_opts.timeout = Duration::from_secs(3);
    
    // 2. 创建解析器实例
    let resolver = resolver(resolver_config, resolver_opts).await?;
    
    // 3. 查询单个域名的A记录
    println!("查询 example.com 的A记录:");
    let response = resolver.lookup_ip("example.com").await?;
    for ip in response.iter() {
        println!("IP地址: {}", ip);
    }
    
    // 4. 查询特定记录类型(MX)
    println!("\n查询 example.com 的MX记录:");
    let mx_records = resolver.lookup("example.com", RecordType::MX).await?;
    for record in mx_records.iter() {
        println!("MX记录: {:?}", record);
    }
    
    // 5. 批量查询多个域名
    println!("\n批量查询多个域名:");
    let domains = vec!["rust-lang.org", "github.com", "crates.io"];
    let queries = domains.into_iter().map(|domain| {
        resolver.lookup_ip(domain)
    }).collect::<Vec<_>>();
    
    let results = join_all(queries).await;
    for (i, result) in results.into_iter().enumerate() {
        match result {
            Ok(response) => {
                println!("域名 {} 解析结果:", domains[i]);
                for ip in response.iter() {
                    println!("  {}", ip);
                }
            },
            Err(e) => println!("域名 {} 解析失败: {}", domains[i], e),
        }
    }
    
    Ok(())
}

这个完整示例展示了：

1. 如何配置自定义DNS服务器
2. 如何设置查询超时
3. 如何进行基本的A记录查询
4. 如何查询特定记录类型(MX记录)
5. 如何使用并发方式批量查询多个域名

async-std-resolver为async-std生态提供了强大而灵活的DNS解析能力，适合需要高性能异步网络操作的应用场景。