1import java.io.IOException;
                                      2import java.net.InetAddress;
                                      3import java.net.InetSocketAddress;
                                      4import java.net.Socket;
                                      5import java.net.UnknownHostException;
                                      6import java.time.LocalDateTime;
                                      7import java.time.format.DateTimeFormatter;
                                      8import java.util.*;
                                      9import java.util.concurrent.*;
                                     10
                                     11/**
                                     12 * IPv6检测工具 - Java实现
                                     13 * 检测网站是否支持IPv6访问
                                     14 */
                                     15public class IPv6CheckTool {
                                     16    
                                     17    private final List<String> defaultNameservers;
                                     18    private final int timeout;
                                     19    
                                     20    public IPv6CheckTool() {
                                     21        this.defaultNameservers = Arrays.asList(
                                     22            "2001:4860:4860::8888",  // Google DNS IPv6
                                     23            "2001:4860:4860::8844",  // Google DNS IPv6备用
                                     24            "2606:4700:4700::1111",  // Cloudflare DNS IPv6
                                     25            "2606:4700:4700::1001"   // Cloudflare DNS IPv6备用
                                     26        );
                                     27        this.timeout = 10000; // 10秒
                                     28    }
                                     29    
                                     30    /**
                                     31     * 测试结果类
                                     32     */
                                     33    public static class TestResult {
                                     34        private String test;
                                     35        private String status;
                                     36        private String statusText;
                                     37        private String details;
                                     38        private List<String> ipv6Addresses;
                                     39        private Map<String, Object> additionalData;
                                     40        
                                     41        public TestResult(String test, String status, String statusText, String details) {
                                     42            this.test = test;
                                     43            this.status = status;
                                     44            this.statusText = statusText;
                                     45            this.details = details;
                                     46            this.ipv6Addresses = new ArrayList<>();
                                     47            this.additionalData = new HashMap<>();
                                     48        }
                                     49        
                                     50        // Getters and Setters
                                     51        public String getTest() { return test; }
                                     52        public void setTest(String test) { this.test = test; }
                                     53        
                                     54        public String getStatus() { return status; }
                                     55        public void setStatus(String status) { this.status = status; }
                                     56        
                                     57        public String getStatusText() { return statusText; }
                                     58        public void setStatusText(String statusText) { this.statusText = statusText; }
                                     59        
                                     60        public String getDetails() { return details; }
                                     61        public void setDetails(String details) { this.details = details; }
                                     62        
                                     63        public List<String> getIpv6Addresses() { return ipv6Addresses; }
                                     64        public void setIpv6Addresses(List<String> ipv6Addresses) { this.ipv6Addresses = ipv6Addresses; }
                                     65        
                                     66        public Map<String, Object> getAdditionalData() { return additionalData; }
                                     67        public void setAdditionalData(Map<String, Object> additionalData) { this.additionalData = additionalData; }
                                     68    }
                                     69    
                                     70    /**
                                     71     * 检测结果类
                                     72     */
                                     73    public static class CheckResult {
                                     74        private String domain;
                                     75        private String timestamp;
                                     76        private List<TestResult> tests;
                                     77        private Map<String, Object> summary;
                                     78        
                                     79        public CheckResult(String domain) {
                                     80            this.domain = domain;
                                     81            this.timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                                     82            this.tests = new ArrayList<>();
                                     83            this.summary = new HashMap<>();
                                     84        }
                                     85        
                                     86        // Getters and Setters
                                     87        public String getDomain() { return domain; }
                                     88        public void setDomain(String domain) { this.domain = domain; }
                                     89        
                                     90        public String getTimestamp() { return timestamp; }
                                     91        public void setTimestamp(String timestamp) { this.timestamp = timestamp; }
                                     92        
                                     93        public List<TestResult> getTests() { return tests; }
                                     94        public void setTests(List<TestResult> tests) { this.tests = tests; }
                                     95        
                                     96        public Map<String, Object> getSummary() { return summary; }
                                     97        public void setSummary(Map<String, Object> summary) { this.summary = summary; }
                                     98    }
                                     99    
                                    100    /**
                                    101     * 检测选项类
                                    102     */
                                    103    public static class CheckOptions {
                                    104        private boolean checkAAAA = true;
                                    105        private boolean checkConnectivity = true;
                                    106        private boolean checkDNS = true;
                                    107        private boolean checkLatency = true;
                                    108        
                                    109        public CheckOptions() {}
                                    110        
                                    111        public CheckOptions(boolean checkAAAA, boolean checkConnectivity, boolean checkDNS, boolean checkLatency) {
                                    112            this.checkAAAA = checkAAAA;
                                    113            this.checkConnectivity = checkConnectivity;
                                    114            this.checkDNS = checkDNS;
                                    115            this.checkLatency = checkLatency;
                                    116        }
                                    117        
                                    118        // Getters and Setters
                                    119        public boolean isCheckAAAA() { return checkAAAA; }
                                    120        public void setCheckAAAA(boolean checkAAAA) { this.checkAAAA = checkAAAA; }
                                    121        
                                    122        public boolean isCheckConnectivity() { return checkConnectivity; }
                                    123        public void setCheckConnectivity(boolean checkConnectivity) { this.checkConnectivity = checkConnectivity; }
                                    124        
                                    125        public boolean isCheckDNS() { return checkDNS; }
                                    126        public void setCheckDNS(boolean checkDNS) { this.checkDNS = checkDNS; }
                                    127        
                                    128        public boolean isCheckLatency() { return checkLatency; }
                                    129        public void setCheckLatency(boolean checkLatency) { this.checkLatency = checkLatency; }
                                    130    }
                                    131    
                                    132    /**
                                    133     * 检测域名的IPv6支持情况
                                    134     */
                                    135    public CheckResult checkIPv6Support(String domain, CheckOptions options) {
                                    136        CheckResult result = new CheckResult(domain);
                                    137        
                                    138        try {
                                    139            // 检测AAAA记录
                                    140            if (options.isCheckAAAA()) {
                                    141                TestResult aaaaResult = checkAAAARecord(domain);
                                    142                result.getTests().add(aaaaResult);
                                    143            }
                                    144            
                                    145            // 检测IPv6连通性
                                    146            if (options.isCheckConnectivity()) {
                                    147                TestResult connectivityResult = checkIPv6Connectivity(domain);
                                    148                result.getTests().add(connectivityResult);
                                    149            }
                                    150            
                                    151            // 检测DNS解析
                                    152            if (options.isCheckDNS()) {
                                    153                TestResult dnsResult = checkDNSResolution(domain);
                                    154                result.getTests().add(dnsResult);
                                    155            }
                                    156            
                                    157            // 检测网络延迟
                                    158            if (options.isCheckLatency()) {
                                    159                TestResult latencyResult = checkLatency(domain);
                                    160                result.getTests().add(latencyResult);
                                    161            }
                                    162            
                                    163            // 生成总结
                                    164            result.setSummary(generateSummary(result.getTests()));
                                    165            
                                    166        } catch (Exception e) {
                                    167            System.err.println("IPv6检测失败: " + e.getMessage());
                                    168            throw new RuntimeException(e);
                                    169        }
                                    170        
                                    171        return result;
                                    172    }
                                    173    
                                    174    /**
                                    175     * 检测AAAA记录
                                    176     */
                                    177    private TestResult checkAAAARecord(String domain) {
                                    178        List<String> ipv6Addresses = new ArrayList<>();
                                    179        
                                    180        try {
                                    181            // 使用InetAddress查询IPv6地址
                                    182            InetAddress[] addresses = InetAddress.getAllByName(domain);
                                    183            for (InetAddress address : addresses) {
                                    184                if (address.getHostAddress().contains(":")) { // IPv6地址包含冒号
                                    185                    ipv6Addresses.add(address.getHostAddress());
                                    186                }
                                    187            }
                                    188            
                                    189            if (!ipv6Addresses.isEmpty()) {
                                    190                TestResult result = new TestResult(
                                    191                    "AAAA记录检测",
                                    192                    "success",
                                    193                    "支持",
                                    194                    "找到 " + ipv6Addresses.size() + " 个IPv6地址记录"
                                    195                );
                                    196                result.setIpv6Addresses(ipv6Addresses);
                                    197                return result;
                                    198            } else {
                                    199                TestResult result = new TestResult(
                                    200                    "AAAA记录检测",
                                    201                    "error",
                                    202                    "不支持",
                                    203                    "域名未配置IPv6地址记录"
                                    204                );
                                    205                result.setIpv6Addresses(new ArrayList<>());
                                    206                return result;
                                    207            }
                                    208            
                                    209        } catch (UnknownHostException e) {
                                    210            TestResult result = new TestResult(
                                    211                "AAAA记录检测",
                                    212                "error",
                                    213                "检测失败",
                                    214                "DNS查询失败: " + e.getMessage()
                                    215            );
                                    216            result.setIpv6Addresses(new ArrayList<>());
                                    217            return result;
                                    218        }
                                    219    }
                                    220    
                                    221    /**
                                    222     * 检测IPv6连通性
                                    223     */
                                    224    private TestResult checkIPv6Connectivity(String domain) {
                                    225        // 首先获取IPv6地址
                                    226        TestResult aaaaResult = checkAAAARecord(domain);
                                    227        
                                    228        if ("error".equals(aaaaResult.getStatus())) {
                                    229            TestResult result = new TestResult(
                                    230                "IPv6连通性检测",
                                    231                "error",
                                    232                "无法检测",
                                    233                "无法获取IPv6地址进行连通性检测"
                                    234            );
                                    235            result.setIpv6Addresses(new ArrayList<>());
                                    236            return result;
                                    237        }
                                    238        
                                    239        // 测试IPv6地址连通性
                                    240        List<Map<String, Object>> connectivityResults = new ArrayList<>();
                                    241        int reachableCount = 0;
                                    242        
                                    243        for (String ipv6Address : aaaaResult.getIpv6Addresses()) {
                                    244            long startTime = System.currentTimeMillis();
                                    245            boolean reachable = false;
                                    246            long latency = 0;
                                    247            
                                    248            try (Socket socket = new Socket()) {
                                    249                socket.connect(new InetSocketAddress(ipv6Address, 80), 5000);
                                    250                reachable = true;
                                    251                latency = System.currentTimeMillis() - startTime;
                                    252                reachableCount++;
                                    253            } catch (IOException e) {
                                    254                // 连接失败
                                    255            }
                                    256            
                                    257            Map<String, Object> result = new HashMap<>();
                                    258            result.put("ipv6_address", ipv6Address);
                                    259            result.put("reachable", reachable);
                                    260            result.put("latency", latency);
                                    261            connectivityResults.add(result);
                                    262        }
                                    263        
                                    264        int totalCount = connectivityResults.size();
                                    265        
                                    266        if (reachableCount == totalCount) {
                                    267            TestResult result = new TestResult(
                                    268                "IPv6连通性检测",
                                    269                "success",
                                    270                "完全可达",
                                    271                "所有 " + totalCount + " 个IPv6地址都可以访问"
                                    272            );
                                    273            result.setIpv6Addresses(aaaaResult.getIpv6Addresses());
                                    274            result.getAdditionalData().put("connectivity_results", connectivityResults);
                                    275            return result;
                                    276        } else if (reachableCount > 0) {
                                    277            TestResult result = new TestResult(
                                    278                "IPv6连通性检测",
                                    279                "warning",
                                    280                "部分可达",
                                    281                reachableCount + "/" + totalCount + " 个IPv6地址可以访问"
                                    282            );
                                    283            result.setIpv6Addresses(aaaaResult.getIpv6Addresses());
                                    284            result.getAdditionalData().put("connectivity_results", connectivityResults);
                                    285            return result;
                                    286        } else {
                                    287            TestResult result = new TestResult(
                                    288                "IPv6连通性检测",
                                    289                "error",
                                    290                "不可达",
                                    291                "所有IPv6地址都无法访问"
                                    292            );
                                    293            result.setIpv6Addresses(aaaaResult.getIpv6Addresses());
                                    294            result.getAdditionalData().put("connectivity_results", connectivityResults);
                                    295            return result;
                                    296        }
                                    297    }
                                    298    
                                    299    /**
                                    300     * 检测DNS解析
                                    301     */
                                    302    private TestResult checkDNSResolution(String domain) {
                                    303        List<String> ipv6Addresses = new ArrayList<>();
                                    304        
                                    305        try {
                                    306            // 使用InetAddress查询IPv6地址
                                    307            InetAddress[] addresses = InetAddress.getAllByName(domain);
                                    308            for (InetAddress address : addresses) {
                                    309                if (address.getHostAddress().contains(":")) { // IPv6地址包含冒号
                                    310                    ipv6Addresses.add(address.getHostAddress());
                                    311                }
                                    312            }
                                    313            
                                    314            if (!ipv6Addresses.isEmpty()) {
                                    315                TestResult result = new TestResult(
                                    316                    "DNS解析检测",
                                    317                    "success",
                                    318                    "正常",
                                    319                    "IPv6 DNS解析正常"
                                    320                );
                                    321                result.setIpv6Addresses(ipv6Addresses);
                                    322                return result;
                                    323            } else {
                                    324                TestResult result = new TestResult(
                                    325                    "DNS解析检测",
                                    326                    "warning",
                                    327                    "部分正常",
                                    328                    "IPv6 DNS解析部分正常"
                                    329                );
                                    330                result.setIpv6Addresses(new ArrayList<>());
                                    331                return result;
                                    332            }
                                    333            
                                    334        } catch (UnknownHostException e) {
                                    335            TestResult result = new TestResult(
                                    336                "DNS解析检测",
                                    337                "error",
                                    338                "异常",
                                    339                "DNS解析异常: " + e.getMessage()
                                    340            );
                                    341            result.setIpv6Addresses(new ArrayList<>());
                                    342            return result;
                                    343        }
                                    344    }
                                    345    
                                    346    /**
                                    347     * 检测网络延迟
                                    348     */
                                    349    private TestResult checkLatency(String domain) {
                                    350        // 获取IPv6地址
                                    351        TestResult aaaaResult = checkAAAARecord(domain);
                                    352        
                                    353        if ("error".equals(aaaaResult.getStatus())) {
                                    354            TestResult result = new TestResult(
                                    355                "网络延迟检测",
                                    356                "error",
                                    357                "无法检测",
                                    358                "无法获取IPv6地址进行延迟检测"
                                    359            );
                                    360            result.setIpv6Addresses(new ArrayList<>());
                                    361            return result;
                                    362        }
                                    363        
                                    364        // 测试延迟
                                    365        List<Map<String, Object>> latencyResults = new ArrayList<>();
                                    366        double totalLatency = 0;
                                    367        int validCount = 0;
                                    368        
                                    369        for (String ipv6Address : aaaaResult.getIpv6Addresses()) {
                                    370            long startTime = System.currentTimeMillis();
                                    371            double latency = 0;
                                    372            String status;
                                    373            
                                    374            try (Socket socket = new Socket()) {
                                    375                socket.connect(new InetSocketAddress(ipv6Address, 80), 5000);
                                    376                latency = System.currentTimeMillis() - startTime;
                                    377                totalLatency += latency;
                                    378                validCount++;
                                    379                
                                    380                if (latency < 100) {
                                    381                    status = "excellent";
                                    382                } else if (latency < 200) {
                                    383                    status = "good";
                                    384                } else {
                                    385                    status = "poor";
                                    386                }
                                    387            } catch (IOException e) {
                                    388                latency = 0;
                                    389                status = "failed";
                                    390            }
                                    391            
                                    392            Map<String, Object> result = new HashMap<>();
                                    393            result.put("ipv6_address", ipv6Address);
                                    394            result.put("latency", latency);
                                    395            result.put("status", status);
                                    396            latencyResults.add(result);
                                    397        }
                                    398        
                                    399        double avgLatency = 0;
                                    400        String resultStatus, statusText, details;
                                    401        
                                    402        if (validCount > 0) {
                                    403            avgLatency = totalLatency / validCount;
                                    404            if (avgLatency < 100) {
                                    405                resultStatus = "success";
                                    406                statusText = "优秀";
                                    407            } else if (avgLatency < 200) {
                                    408                resultStatus = "warning";
                                    409                statusText = "良好";
                                    410            } else {
                                    411                resultStatus = "error";
                                    412                statusText = "较差";
                                    413            }
                                    414            details = String.format("平均延迟: %.1fms", avgLatency);
                                    415        } else {
                                    416            resultStatus = "error";
                                    417            statusText = "检测失败";
                                    418            details = "无法获取有效延迟数据";
                                    419            avgLatency = 0;
                                    420        }
                                    421        
                                    422        TestResult result = new TestResult(
                                    423            "网络延迟检测",
                                    424            resultStatus,
                                    425            statusText,
                                    426            details
                                    427        );
                                    428        result.setIpv6Addresses(aaaaResult.getIpv6Addresses());
                                    429        result.getAdditionalData().put("latency_results", latencyResults);
                                    430        result.getAdditionalData().put("average_latency", avgLatency);
                                    431        
                                    432        return result;
                                    433    }
                                    434    
                                    435    /**
                                    436     * 生成检测总结
                                    437     */
                                    438    private Map<String, Object> generateSummary(List<TestResult> tests) {
                                    439        int successCount = 0;
                                    440        int warningCount = 0;
                                    441        int errorCount = 0;
                                    442        
                                    443        for (TestResult test : tests) {
                                    444            switch (test.getStatus()) {
                                    445                case "success":
                                    446                    successCount++;
                                    447                    break;
                                    448                case "warning":
                                    449                    warningCount++;
                                    450                    break;
                                    451                case "error":
                                    452                    errorCount++;
                                    453                    break;
                                    454            }
                                    455        }
                                    456        
                                    457        int totalCount = tests.size();
                                    458        String status, title, message;
                                    459        
                                    460        if (successCount == totalCount) {
                                    461            status = "success";
                                    462            title = "IPv6支持良好";
                                    463            message = "所有 " + totalCount + " 个检测项目都通过，该网站完全支持IPv6访问。";
                                    464        } else if (successCount > 0 || warningCount > 0) {
                                    465            status = "warning";
                                    466            title = "IPv6部分支持";
                                    467            message = successCount + " 个项目通过，" + warningCount + " 个项目警告，" + errorCount + " 个项目失败。该网站对IPv6的支持有限。";
                                    468        } else {
                                    469            status = "error";
                                    470            title = "IPv6不支持";
                                    471            message = "所有 " + totalCount + " 个检测项目都失败，该网站不支持IPv6访问。";
                                    472        }
                                    473        
                                    474        Map<String, Object> summary = new HashMap<>();
                                    475        summary.put("status", status);
                                    476        summary.put("title", title);
                                    477        summary.put("message", message);
                                    478        
                                    479        Map<String, Integer> statistics = new HashMap<>();
                                    480        statistics.put("total", totalCount);
                                    481        statistics.put("success", successCount);
                                    482        statistics.put("warning", warningCount);
                                    483        statistics.put("error", errorCount);
                                    484        summary.put("statistics", statistics);
                                    485        
                                    486        return summary;
                                    487    }
                                    488    
                                    489    /**
                                    490     * 批量检测多个域名
                                    491     */
                                    492    public Map<String, Object> batchCheck(List<String> domains, CheckOptions options) {
                                    493        Map<String, Object> results = new HashMap<>();
                                    494        ExecutorService executor = Executors.newFixedThreadPool(5);
                                    495        
                                    496        try {
                                    497            List<Future<Map.Entry<String, Object>>> futures = new ArrayList<>();
                                    498            
                                    499            for (String domain : domains) {
                                    500                Future<Map.Entry<String, Object>> future = executor.submit(() -> {
                                    501                    try {
                                    502                        CheckResult result = checkIPv6Support(domain, options);
                                    503                        return new AbstractMap.SimpleEntry<>(domain, result);
                                    504                    } catch (Exception e) {
                                    505                        Map<String, Object> errorResult = new HashMap<>();
                                    506                        errorResult.put("error", e.getMessage());
                                    507                        errorResult.put("domain", domain);
                                    508                        errorResult.put("timestamp", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                                    509                        return new AbstractMap.SimpleEntry<>(domain, errorResult);
                                    510                    }
                                    511                });
                                    512                futures.add(future);
                                    513            }
                                    514            
                                    515            for (Future<Map.Entry<String, Object>> future : futures) {
                                    516                try {
                                    517                    Map.Entry<String, Object> entry = future.get();
                                    518                    results.put(entry.getKey(), entry.getValue());
                                    519                } catch (Exception e) {
                                    520                    System.err.println("批量检测失败: " + e.getMessage());
                                    521                }
                                    522            }
                                    523            
                                    524        } finally {
                                    525            executor.shutdown();
                                    526        }
                                    527        
                                    528        return results;
                                    529    }
                                    530    
                                    531    /**
                                    532     * 验证IPv6地址格式
                                    533     */
                                    534    public boolean isValidIPv6(String ipv6) {
                                    535        try {
                                    536            InetAddress.getByName(ipv6);
                                    537            return ipv6.contains(":");
                                    538        } catch (UnknownHostException e) {
                                    539            return false;
                                    540        }
                                    541    }
                                    542    
                                    543    /**
                                    544     * 使用示例
                                    545     */
                                    546    public static void main(String[] args) {
                                    547        IPv6CheckTool ipv6Tool = new IPv6CheckTool();
                                    548        
                                    549        try {
                                    550            // 单个域名检测
                                    551            System.out.println("检测单个域名:");
                                    552            CheckResult result = ipv6Tool.checkIPv6Support("google.com", new CheckOptions(true, true, true, true));
                                    553            System.out.println("域名: " + result.getDomain());
                                    554            System.out.println("时间: " + result.getTimestamp());
                                    555            System.out.println("测试数量: " + result.getTests().size());
                                    556            System.out.println("总结: " + result.getSummary());
                                    557            
                                    558            // 批量检测
                                    559            System.out.println("\n批量检测:");
                                    560            List<String> domains = Arrays.asList("google.com", "github.com", "facebook.com");
                                    561            Map<String, Object> batchResults = ipv6Tool.batchCheck(domains, new CheckOptions(true, false, true, false));
                                    562            System.out.println("批量检测结果: " + batchResults.size() + " 个域名");
                                    563            
                                    564        } catch (Exception e) {
                                    565            System.err.println("检测失败: " + e.getMessage());
                                    566        }
                                    567    }
                                    568}
                                    

  1package main
                                      2
                                      3import (
                                      4	"encoding/json"
                                      5	"fmt"
                                      6	"net"
                                      7	"sync"
                                      8	"time"
                                      9)
                                     10
                                     11// TestResult 测试结果结构体
                                     12type TestResult struct {
                                     13	Test           string                 `json:"test"`
                                     14	Status         string                 `json:"status"`
                                     15	StatusText     string                 `json:"status_text"`
                                     16	Details        string                 `json:"details"`
                                     17	IPv6Addresses  []string               `json:"ipv6_addresses"`
                                     18	AdditionalData map[string]interface{} `json:"additional_data,omitempty"`
                                     19}
                                     20
                                     21// CheckResult 检测结果结构体
                                     22type CheckResult struct {
                                     23	Domain    string                 `json:"domain"`
                                     24	Timestamp string                 `json:"timestamp"`
                                     25	Tests     []TestResult           `json:"tests"`
                                     26	Summary   map[string]interface{} `json:"summary"`
                                     27}
                                     28
                                     29// Summary 总结信息结构体
                                     30type Summary struct {
                                     31	Status      string                 `json:"status"`
                                     32	Title       string                 `json:"title"`
                                     33	Message     string                 `json:"message"`
                                     34	Statistics  map[string]int         `json:"statistics"`
                                     35}
                                     36
                                     37// IPv6CheckTool IPv6检测工具
                                     38type IPv6CheckTool struct {
                                     39	defaultNameservers []string
                                     40	timeout            time.Duration
                                     41}
                                     42
                                     43// NewIPv6CheckTool 创建新的IPv6检测工具实例
                                     44func NewIPv6CheckTool() *IPv6CheckTool {
                                     45	return &IPv6CheckTool{
                                     46		defaultNameservers: []string{
                                     47			"2001:4860:4860::8888",  // Google DNS IPv6
                                     48			"2001:4860:4860::8844",  // Google DNS IPv6备用
                                     49			"2606:4700:4700::1111",  // Cloudflare DNS IPv6
                                     50			"2606:4700:4700::1001",  // Cloudflare DNS IPv6备用
                                     51		},
                                     52		timeout: 10 * time.Second,
                                     53	}
                                     54}
                                     55
                                     56// CheckOptions 检测选项
                                     57type CheckOptions struct {
                                     58	CheckAAAA       bool `json:"check_aaaa"`
                                     59	CheckConnectivity bool `json:"check_connectivity"`
                                     60	CheckDNS        bool `json:"check_dns"`
                                     61	CheckLatency    bool `json:"check_latency"`
                                     62}
                                     63
                                     64// CheckIPv6Support 检测域名的IPv6支持情况
                                     65func (t *IPv6CheckTool) CheckIPv6Support(domain string, options CheckOptions) (*CheckResult, error) {
                                     66	result := &CheckResult{
                                     67		Domain:    domain,
                                     68		Timestamp: time.Now().Format("2006-01-02 15:04:05"),
                                     69		Tests:     []TestResult{},
                                     70	}
                                     71
                                     72	// 检测AAAA记录
                                     73	if options.CheckAAAA {
                                     74		aaaaResult := t.checkAAAARecord(domain)
                                     75		result.Tests = append(result.Tests, aaaaResult)
                                     76	}
                                     77
                                     78	// 检测IPv6连通性
                                     79	if options.CheckConnectivity {
                                     80		connectivityResult := t.checkIPv6Connectivity(domain)
                                     81		result.Tests = append(result.Tests, connectivityResult)
                                     82	}
                                     83
                                     84	// 检测DNS解析
                                     85	if options.CheckDNS {
                                     86		dnsResult := t.checkDNSResolution(domain)
                                     87		result.Tests = append(result.Tests, dnsResult)
                                     88	}
                                     89
                                     90	// 检测网络延迟
                                     91	if options.CheckLatency {
                                     92		latencyResult := t.checkLatency(domain)
                                     93		result.Tests = append(result.Tests, latencyResult)
                                     94	}
                                     95
                                     96	// 生成总结
                                     97	result.Summary = t.generateSummary(result.Tests)
                                     98
                                     99	return result, nil
                                    100}
                                    101
                                    102// checkAAAARecord 检测AAAA记录
                                    103func (t *IPv6CheckTool) checkAAAARecord(domain string) TestResult {
                                    104	ipv6Addresses := []string{}
                                    105
                                    106	// 使用net.LookupIP查询IPv6地址
                                    107	ips, err := net.LookupIP(domain)
                                    108	if err == nil {
                                    109		for _, ip := range ips {
                                    110			if ip.To4() == nil && ip.To16() != nil {
                                    111				ipv6Addresses = append(ipv6Addresses, ip.String())
                                    112			}
                                    113		}
                                    114	}
                                    115
                                    116	if len(ipv6Addresses) > 0 {
                                    117		return TestResult{
                                    118			Test:          "AAAA记录检测",
                                    119			Status:        "success",
                                    120			StatusText:    "支持",
                                    121			Details:       fmt.Sprintf("找到 %d 个IPv6地址记录", len(ipv6Addresses)),
                                    122			IPv6Addresses: ipv6Addresses,
                                    123		}
                                    124	} else {
                                    125		return TestResult{
                                    126			Test:          "AAAA记录检测",
                                    127			Status:        "error",
                                    128			StatusText:    "不支持",
                                    129			Details:       "域名未配置IPv6地址记录",
                                    130			IPv6Addresses: []string{},
                                    131		}
                                    132	}
                                    133}
                                    134
                                    135// checkIPv6Connectivity 检测IPv6连通性
                                    136func (t *IPv6CheckTool) checkIPv6Connectivity(domain string) TestResult {
                                    137	// 首先获取IPv6地址
                                    138	aaaaResult := t.checkAAAARecord(domain)
                                    139
                                    140	if aaaaResult.Status == "error" {
                                    141		return TestResult{
                                    142			Test:          "IPv6连通性检测",
                                    143			Status:        "error",
                                    144			StatusText:    "无法检测",
                                    145			Details:       "无法获取IPv6地址进行连通性检测",
                                    146			IPv6Addresses: []string{},
                                    147		}
                                    148	}
                                    149
                                    150	// 测试IPv6地址连通性
                                    151	connectivityResults := []map[string]interface{}{}
                                    152	reachableCount := 0
                                    153
                                    154	for _, ipv6Address := range aaaaResult.IPv6Addresses {
                                    155		startTime := time.Now()
                                    156		reachable := false
                                    157		var latency float64
                                    158
                                    159		// 尝试连接IPv6地址
                                    160		conn, err := net.DialTimeout("tcp6", net.JoinHostPort(ipv6Address, "80"), 5*time.Second)
                                    161		if err == nil {
                                    162			conn.Close()
                                    163			reachable = true
                                    164			latency = float64(time.Since(startTime).Milliseconds())
                                    165			reachableCount++
                                    166		}
                                    167
                                    168		connectivityResults = append(connectivityResults, map[string]interface{}{
                                    169			"ipv6_address": ipv6Address,
                                    170			"reachable":    reachable,
                                    171			"latency":      latency,
                                    172		})
                                    173	}
                                    174
                                    175	totalCount := len(connectivityResults)
                                    176
                                    177	if reachableCount == totalCount {
                                    178		return TestResult{
                                    179			Test:          "IPv6连通性检测",
                                    180			Status:        "success",
                                    181			StatusText:    "完全可达",
                                    182			Details:       fmt.Sprintf("所有 %d 个IPv6地址都可以访问", totalCount),
                                    183			IPv6Addresses: aaaaResult.IPv6Addresses,
                                    184			AdditionalData: map[string]interface{}{
                                    185				"connectivity_results": connectivityResults,
                                    186			},
                                    187		}
                                    188	} else if reachableCount > 0 {
                                    189		return TestResult{
                                    190			Test:          "IPv6连通性检测",
                                    191			Status:        "warning",
                                    192			StatusText:    "部分可达",
                                    193			Details:       fmt.Sprintf("%d/%d 个IPv6地址可以访问", reachableCount, totalCount),
                                    194			IPv6Addresses: aaaaResult.IPv6Addresses,
                                    195			AdditionalData: map[string]interface{}{
                                    196				"connectivity_results": connectivityResults,
                                    197			},
                                    198		}
                                    199	} else {
                                    200		return TestResult{
                                    201			Test:          "IPv6连通性检测",
                                    202			Status:        "error",
                                    203			StatusText:    "不可达",
                                    204			Details:       "所有IPv6地址都无法访问",
                                    205			IPv6Addresses: aaaaResult.IPv6Addresses,
                                    206			AdditionalData: map[string]interface{}{
                                    207				"connectivity_results": connectivityResults,
                                    208			},
                                    209		}
                                    210	}
                                    211}
                                    212
                                    213// checkDNSResolution 检测DNS解析
                                    214func (t *IPv6CheckTool) checkDNSResolution(domain string) TestResult {
                                    215	ipv6Addresses := []string{}
                                    216
                                    217	// 使用net.LookupIP查询IPv6地址
                                    218	ips, err := net.LookupIP(domain)
                                    219	if err == nil {
                                    220		for _, ip := range ips {
                                    221			if ip.To4() == nil && ip.To16() != nil {
                                    222				ipv6Addresses = append(ipv6Addresses, ip.String())
                                    223			}
                                    224		}
                                    225	}
                                    226
                                    227	if len(ipv6Addresses) > 0 {
                                    228		return TestResult{
                                    229			Test:          "DNS解析检测",
                                    230			Status:        "success",
                                    231			StatusText:    "正常",
                                    232			Details:       "IPv6 DNS解析正常",
                                    233			IPv6Addresses: ipv6Addresses,
                                    234		}
                                    235	} else {
                                    236		return TestResult{
                                    237			Test:          "DNS解析检测",
                                    238			Status:        "warning",
                                    239			StatusText:    "部分正常",
                                    240			Details:       "IPv6 DNS解析部分正常",
                                    241			IPv6Addresses: []string{},
                                    242		}
                                    243	}
                                    244}
                                    245
                                    246// checkLatency 检测网络延迟
                                    247func (t *IPv6CheckTool) checkLatency(domain string) TestResult {
                                    248	// 获取IPv6地址
                                    249	aaaaResult := t.checkAAAARecord(domain)
                                    250
                                    251	if aaaaResult.Status == "error" {
                                    252		return TestResult{
                                    253			Test:          "网络延迟检测",
                                    254			Status:        "error",
                                    255			StatusText:    "无法检测",
                                    256			Details:       "无法获取IPv6地址进行延迟检测",
                                    257			IPv6Addresses: []string{},
                                    258		}
                                    259	}
                                    260
                                    261	// 测试延迟
                                    262	latencyResults := []map[string]interface{}{}
                                    263	var totalLatency float64
                                    264	validCount := 0
                                    265
                                    266	for _, ipv6Address := range aaaaResult.IPv6Addresses {
                                    267		startTime := time.Now()
                                    268		var latency float64
                                    269		var status string
                                    270
                                    271		// 尝试连接IPv6地址
                                    272		conn, err := net.DialTimeout("tcp6", net.JoinHostPort(ipv6Address, "80"), 5*time.Second)
                                    273		if err == nil {
                                    274			conn.Close()
                                    275			latency = float64(time.Since(startTime).Milliseconds())
                                    276			totalLatency += latency
                                    277			validCount++
                                    278
                                    279			if latency < 100 {
                                    280				status = "excellent"
                                    281			} else if latency < 200 {
                                    282				status = "good"
                                    283			} else {
                                    284				status = "poor"
                                    285			}
                                    286		} else {
                                    287			latency = 0
                                    288			status = "failed"
                                    289		}
                                    290
                                    291		latencyResults = append(latencyResults, map[string]interface{}{
                                    292			"ipv6_address": ipv6Address,
                                    293			"latency":      latency,
                                    294			"status":       status,
                                    295		})
                                    296	}
                                    297
                                    298	var avgLatency float64
                                    299	var resultStatus, statusText, details string
                                    300
                                    301	if validCount > 0 {
                                    302		avgLatency = totalLatency / float64(validCount)
                                    303		if avgLatency < 100 {
                                    304			resultStatus = "success"
                                    305			statusText = "优秀"
                                    306		} else if avgLatency < 200 {
                                    307			resultStatus = "warning"
                                    308			statusText = "良好"
                                    309		} else {
                                    310			resultStatus = "error"
                                    311			statusText = "较差"
                                    312		}
                                    313		details = fmt.Sprintf("平均延迟: %.1fms", avgLatency)
                                    314	} else {
                                    315		resultStatus = "error"
                                    316		statusText = "检测失败"
                                    317		details = "无法获取有效延迟数据"
                                    318		avgLatency = 0
                                    319	}
                                    320
                                    321	return TestResult{
                                    322		Test:          "网络延迟检测",
                                    323		Status:        resultStatus,
                                    324		StatusText:    statusText,
                                    325		Details:       details,
                                    326		IPv6Addresses: aaaaResult.IPv6Addresses,
                                    327		AdditionalData: map[string]interface{}{
                                    328			"latency_results":  latencyResults,
                                    329			"average_latency": avgLatency,
                                    330		},
                                    331	}
                                    332}
                                    333
                                    334// generateSummary 生成检测总结
                                    335func (t *IPv6CheckTool) generateSummary(tests []TestResult) map[string]interface{} {
                                    336	successCount := 0
                                    337	warningCount := 0
                                    338	errorCount := 0
                                    339
                                    340	for _, test := range tests {
                                    341		switch test.Status {
                                    342		case "success":
                                    343			successCount++
                                    344		case "warning":
                                    345			warningCount++
                                    346		case "error":
                                    347			errorCount++
                                    348		}
                                    349	}
                                    350
                                    351	totalCount := len(tests)
                                    352	var status, title, message string
                                    353
                                    354	if successCount == totalCount {
                                    355		status = "success"
                                    356		title = "IPv6支持良好"
                                    357		message = fmt.Sprintf("所有 %d 个检测项目都通过，该网站完全支持IPv6访问。", totalCount)
                                    358	} else if successCount > 0 || warningCount > 0 {
                                    359		status = "warning"
                                    360		title = "IPv6部分支持"
                                    361		message = fmt.Sprintf("%d 个项目通过，%d 个项目警告，%d 个项目失败。该网站对IPv6的支持有限。", successCount, warningCount, errorCount)
                                    362	} else {
                                    363		status = "error"
                                    364		title = "IPv6不支持"
                                    365		message = fmt.Sprintf("所有 %d 个检测项目都失败，该网站不支持IPv6访问。", totalCount)
                                    366	}
                                    367
                                    368	return map[string]interface{}{
                                    369		"status": status,
                                    370		"title":  title,
                                    371		"message": message,
                                    372		"statistics": map[string]int{
                                    373			"total":   totalCount,
                                    374			"success": successCount,
                                    375			"warning": warningCount,
                                    376			"error":   errorCount,
                                    377		},
                                    378	}
                                    379}
                                    380
                                    381// BatchCheck 批量检测多个域名
                                    382func (t *IPv6CheckTool) BatchCheck(domains []string, options CheckOptions) map[string]interface{} {
                                    383	results := make(map[string]interface{})
                                    384	var mu sync.Mutex
                                    385	var wg sync.WaitGroup
                                    386
                                    387	// 限制并发数
                                    388	semaphore := make(chan struct{}, 5)
                                    389
                                    390	for _, domain := range domains {
                                    391		wg.Add(1)
                                    392		go func(d string) {
                                    393			defer wg.Done()
                                    394			semaphore <- struct{}{}
                                    395			defer func() { <-semaphore }()
                                    396
                                    397			result, err := t.CheckIPv6Support(d, options)
                                    398			mu.Lock()
                                    399			if err != nil {
                                    400				results[d] = map[string]interface{}{
                                    401					"error":     err.Error(),
                                    402					"domain":    d,
                                    403					"timestamp": time.Now().Format("2006-01-02 15:04:05"),
                                    404				}
                                    405			} else {
                                    406				results[d] = result
                                    407			}
                                    408			mu.Unlock()
                                    409		}(domain)
                                    410	}
                                    411
                                    412	wg.Wait()
                                    413	return results
                                    414}
                                    415
                                    416// IsValidIPv6 验证IPv6地址格式
                                    417func (t *IPv6CheckTool) IsValidIPv6(ipv6 string) bool {
                                    418	ip := net.ParseIP(ipv6)
                                    419	return ip != nil && ip.To4() == nil && ip.To16() != nil
                                    420}
                                    421
                                    422// 使用示例
                                    423func main() {
                                    424	ipv6Tool := NewIPv6CheckTool()
                                    425
                                    426	// 单个域名检测
                                    427	fmt.Println("检测单个域名:")
                                    428	result, err := ipv6Tool.CheckIPv6Support("google.com", CheckOptions{
                                    429		CheckAAAA:       true,
                                    430		CheckConnectivity: true,
                                    431		CheckDNS:        true,
                                    432		CheckLatency:    true,
                                    433	})
                                    434
                                    435	if err != nil {
                                    436		fmt.Printf("检测失败: %v\n", err)
                                    437		return
                                    438	}
                                    439
                                    440	jsonData, _ := json.MarshalIndent(result, "", "  ")
                                    441	fmt.Println(string(jsonData))
                                    442
                                    443	// 批量检测
                                    444	fmt.Println("\n批量检测:")
                                    445	batchResults := ipv6Tool.BatchCheck([]string{"google.com", "github.com", "facebook.com"}, CheckOptions{
                                    446		CheckAAAA:       true,
                                    447		CheckConnectivity: false,
                                    448	})
                                    449
                                    450	jsonData, _ = json.MarshalIndent(batchResults, "", "  ")
                                    451	fmt.Println(string(jsonData))
                                    452}