百度360必应搜狗淘宝本站头条
vba高级教程svn连接scheduledtaskmybatis plus结构体数组
当前位置：网站首页 > 编程网 > 正文

编写小逻辑程序实现hosts文件的清理

yuyutoo 2025-04-02 00:09 5 浏览 0 评论

说明：

在开发过程中，经常会写很多如下的域名绑定到hosts上

192.168.0.1 sit.myweb.cn
192.168.0.1 uat.myweb.cn
192.168.0.2 uat.myweb.cn

但有些系统比较复杂，涉及很多域名地址，导致重复添加的时候，host文件会变得很乱

其实，豆包AI已经能自动帮我们过滤重复的域名配置，或者覆盖保留最新的

自己头铁，写了一个小程序实现

上代码和上图：

package com.zx.app.work.uni.enums.common.tool;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.zx.app.ba.tool.util.JsonUtil;
import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * 
资源类型

 * @author SH.YE
 */
@AllArgsConstructor
@Getter
public enum HostClearActionEnum {

    LIST_ALL("list-all", "列出所有"),
    LIST_ONE("list-one", "列出单条的"),
    LIST_MORE("list-more", "列出重复的"),
    SAVE_FIRST("save-first", "保存第一条"),
    SAVE_LAST("save-last", "保存最后一条"),
    UNKNOWN("unknown", ""),
    ;



    private final String code;
    /**
     * 描述
     */
    private final String desc;


    public static HostClearActionEnum getItem(String pCode, HostClearActionEnum defaultValue) {
        if (pCode == null || pCode.isEmpty()) {
            return defaultValue;
        }
        for (HostClearActionEnum item : HostClearActionEnum.values()) {
            if (pCode.equals(item.getCode())) {
                return item;
            }
        }
        return defaultValue;
    }


    /**
     * 获得枚举的数据源Key-Value
     *
     * @return
     */
    public static Map getList() {
        Map result = new LinkedHashMap();

        for (HostClearActionEnum item : HostClearActionEnum.values()) {
            result.put(item.getCode(), item.getDesc());
        }

        return result;
    }


    protected static String toJson() {
        JSONArray dataList = new JSONArray();
        JSONObject item = null;
        for (HostClearActionEnum em : HostClearActionEnum.values()) {
            item = new JSONObject();
            dataList.add(item);
            item.put("id", em.getCode());
            item.put("name", em.getDesc());
        }

        return dataList.toJSONString();
    }

    public static void main(String[] args) {

        String str = toJson();
        System.out.println(str);

    }
}




package com.zx.app.work.uni.item.co.common.tool;

import lombok.Data;

import java.util.List;

@Data
public class HostClearContainer {
    private List list;
}

package com.zx.app.work.uni.item.co.common.tool;

import lombok.Data;

import java.util.List;

@Data
public class HostClearCo {
    private String comment;
    private String data;
    private List ipList;
}

package com.zx.app.work.uni.item.cp.common.tool;

import lombok.Data;

@Data
public class HostClearCp {
    /**
     * 
list-all

     * 
save-last

     * 
save-first

     * 
HostClearActionEnum

     */
    private String action;
    private Integer outCommentFlag;
    private String input;
}

package com.zx.app.work.uni.bs.common.tool;


import com.zx.app.ba.tool.enums.BooleanEnum;
import com.zx.app.ba.tool.item.common.StrLeftRightItem;
import com.zx.app.ba.tool.util.StrUniUtil;
import com.zx.app.work.uni.enums.common.action.MybatisConvertActionEnum;
import com.zx.app.work.uni.enums.common.tool.HostClearActionEnum;
import com.zx.app.work.uni.item.co.common.tool.HostClearCo;
import com.zx.app.work.uni.item.co.common.tool.HostClearContainer;
import com.zx.app.work.uni.item.cp.common.tool.HostClearCp;
import com.zx.app.work.uni.item.cp.common.tool.MybatisConvertToolCp;

import java.util.ArrayList;
import java.util.List;

/**
 * @author SH.YE
 */
public class HostClearBs {

    protected HostClearCo findHostClearCo(List hostList, String data) {
        for (HostClearCo each : hostList) {
            if (data.equalsIgnoreCase(each.getData())) {
                return each;
            }
        }

        return null;
    }

    public HostClearContainer convertResultForList(HostClearContainer hcc, boolean moreFlag) {
        HostClearContainer result = new HostClearContainer();
        List list = new ArrayList<>();
        result.setList(list);
        if (moreFlag) {
            for (HostClearCo each : hcc.getList()) {
                if (each.getIpList().size() > 1) {
                    list.add(each);
                }
            }

            return result;

        }
        for (HostClearCo each : hcc.getList()) {
            if (each.getIpList().size() == 1) {
                list.add(each);
            }

        }
        return result;
    }


    public String convertResultForSave(HostClearContainer hcc, boolean lastFlag, boolean outCommentFlag) {
        StringBuilder result = new StringBuilder();

        if (lastFlag) {
            for (HostClearCo each : hcc.getList()) {
                if (each.getIpList().isEmpty()) {
                    continue;
                }

                if (outCommentFlag) {
                    if (StrUniUtil.strIsNotTrimEmpty(each.getComment())) {
                        result.append(each.getComment());
                    }
                }

                result.append(each.getIpList().get(each.getIpList().size() - 1) + " " + each.getData() + '\n');
            }

            return result.toString();
        }

        for (HostClearCo each : hcc.getList()) {
            if (each.getIpList().isEmpty()) {
                continue;
            }

            if (outCommentFlag) {
                if (StrUniUtil.strIsNotTrimEmpty(each.getComment())) {
                    result.append(each.getComment());
                }
            }

            result.append(each.getIpList().get(0) + " " + each.getData() + '\n');
        }

        return result.toString();
    }

    public Object convertResult(HostClearContainer hcc, HostClearActionEnum actionEnum, boolean outCommentFlag) {
        switch (actionEnum) {
            case LIST_MORE:
                return convertResultForList(hcc, true);
            case LIST_ONE:
                return convertResultForList(hcc, false);
            case SAVE_FIRST:
                return convertResultForSave(hcc, false, outCommentFlag);
            case SAVE_LAST:
                return convertResultForSave(hcc, true, outCommentFlag);
            case LIST_ALL:
            case UNKNOWN:
            default:
                return hcc;
        }
    }

    public Object toResult(HostClearCp cp) {
        HostClearActionEnum actionEnum = HostClearActionEnum.getItem(cp.getAction(), HostClearActionEnum.UNKNOWN);

        switch (actionEnum) {
            case LIST_ALL:
            case LIST_ONE:
            case LIST_MORE:
            case SAVE_LAST:
            case SAVE_FIRST:
                break;
            case UNKNOWN:
            default:
                return "未知逻辑";
        }

        HostClearContainer hcc = new HostClearContainer();
        List hcList = new ArrayList<>();
        hcc.setList(hcList);

        StringBuilder commentSb = null;
        String strComment = null;
        StrLeftRightItem lrItem = null;
        HostClearCo co = null;
        List hostList = StrUniUtil.strSplitRnToArray(cp.getInput(), true, false);
        for (String each : hostList) {
            if (StrUniUtil.strIsTrimEmpty(each)) {
                continue;
            }

            if (each.startsWith("#")) {
                if (commentSb == null) {
                    commentSb = new StringBuilder();
                }
                commentSb.append(each + '\n');
                continue;
            }

            lrItem = StrUniUtil.toStrLeftRightItem(each, " ", true);
            if (StrUniUtil.strIsTrimEmpty(lrItem.getRightData())) {
                continue;
            }

            strComment = (commentSb == null) ? "" : commentSb.toString();
            commentSb = null;
            co = findHostClearCo(hcList, lrItem.getRightData());
            if (co == null) {
                co = new HostClearCo();
                co.setIpList(new ArrayList<>());
                hcList.add(co);

                co.setData(lrItem.getRightData());
                co.setComment(strComment);
                co.getIpList().add(lrItem.getLeftData());

                continue;
            }

            co.getIpList().add(lrItem.getLeftData());
            co.setComment(co.getComment() + strComment);
        }

        return convertResult(hcc, actionEnum, BooleanEnum.dataIsTrue(cp.getOutCommentFlag()));
    }
}


// region 字符串是否过滤空格后为空

/**
 * 字符串是否过滤空格后为空
 *
 * @param str
 * @return
 */
public static boolean strIsTrimEmpty(String str) {
    return (str == null || str.trim().isEmpty());
}

// endregion 字符串是否过滤空格后为空

// region 字符串是否过滤空格后非空

/**
 * 字符串是否过滤空格后非空
 *
 * @param str
 * @return
 */
public static boolean strIsNotTrimEmpty(String str) {
    return !strIsTrimEmpty(str);
}

// endregion 字符串是否过滤空格后非空

public static List strSplitRnToArray(String str, boolean trimFlag) {
    return strSplitToArray(str, "" + '\n', trimFlag, false);
}

public static List strSplitRnToArray(String str, boolean trimFlag, boolean removeRepeaterFlag) {
    return strSplitToArray(str, "" + '\n', trimFlag, removeRepeaterFlag);
}

public static List strSplitRnToArrayByParams(String str, boolean trimFlag, boolean lowerFlag, boolean removeRepeaterFlag) {
    List result = new ArrayList<>();
    if (str == null || str.isEmpty()) {
        return result;
    }

    String splitChar = "" + '\n';
    String[] sA = str.split(splitChar);
    String strAdd = null;
    for (String each : sA) {
        if (each == null) {
            continue;
        }

        if (trimFlag) {
            strAdd = each.trim();
        } else {
            strAdd = each;
        }

        if (strAdd.isEmpty()) {
            continue;
        }

        if (lowerFlag) {
            strAdd = strAdd.toLowerCase();
        }

        if (removeRepeaterFlag && result.contains(strAdd)) {
            continue;
        }

        result.add(strAdd);
    }

    return result;
}


界面效果：


相关推荐

ETCD 故障恢复（etc常见故障）

概述Kubernetes集群外部ETCD节点故障，导致kube-apiserver无法启动。...

在Ubuntu 16.04 LTS服务器上安装FreeRADIUS和Daloradius的方法

FreeRADIUS为AAARadiusLinux下开源解决方案，DaloRadius为图形化web管理工具。...

如何排查服务器被黑客入侵的迹象（黑客 抓取服务器数据）

---排查服务器是否被黑客入侵需要系统性地检查多个关键点，以下是一份详细的排查指南，包含具体命令、工具和应对策略：---###**一、快速初步检查**####1.**检查异常登录记录**...

使用 Fail Ban 日志分析 SSH 攻击行为

通过分析`fail2ban`日志可以识别和应对SSH暴力破解等攻击行为。以下是详细的操作流程和关键分析方法：---###**一、Fail2ban日志位置**Fail2ban的日志路径因系统配置...

《5 个实用技巧，提升你的服务器安全性，避免被黑客盯上!》

服务器的安全性至关重要，特别是在如今网络攻击频繁的情况下。如果你的服务器存在漏洞，黑客可能会利用这些漏洞进行攻击，甚至窃取数据。今天我们就来聊聊5个实用技巧，帮助你提升服务器的安全性，让你的系统更...

聊聊Spring AI Alibaba的YuQueDocumentReader

序本文主要研究一下SpringAIAlibaba的YuQueDocumentReaderYuQueDocumentReader...

Mac Docker环境，利用Canal实现MySQL同步ES

Canal的使用使用docker环境安装mysql、canal、elasticsearch，基于binlog利用canal实现mysql的数据同步到elasticsearch中，并在springboo...

RustDesk:开源远程控制工具的技术架构与全场景部署实战

一、开源远程控制领域的革新者1.1行业痛点与解决方案...

长安汽车一代CS75Plus2020款安装高德地图7.5

不用破解原车机，一代CS75Plus2020款，安装车机版高德地图7.5，有红绿灯读秒！废话不多讲，安装步骤如下：一、在拨号状态输入：在电话拨号界面，输入:*#518200#*（进入安卓设置界面，...

Zookeeper使用详解之常见操作篇（zookeeper ui）

一、Zookeeper的数据结构对于ZooKeeper而言，其存储结构类似于文件系统，也是一个树形目录服务，并通过Key-Value键值对的形式进行数据存储。其中，Key由斜线间隔的路径元素构成。对...

zk源码—4.会话的实现原理一（会话层的基本功能是什么）

大纲1.创建会话...

Zookeeper 可观测性最佳实践（zookeeper能够确保）

Zookeeper介绍ZooKeeper是一个开源的分布式协调服务，用于管理和协调分布式系统中的节点。它提供了一种高效、可靠的方式来解决分布式系统中的常见问题，如数据同步、配置管理、命名服务和集群...

服务器密码错误被锁定怎么解决（服务器密码错几次锁）

#服务器密码错误被锁定解决方案当服务器因多次密码错误导致账户被锁定时，可以按照以下步骤进行排查和解决：##一、确认锁定状态###1.检查账户锁定状态（Linux）```bash#查看账户锁定...

zk基础—4.zk实现分布式功能（分布式zk的使用）

大纲1.zk实现数据发布订阅...

《死神魂魄觉醒》卡死问题终极解决方案:从原理到实战的深度解析

在《死神魂魄觉醒》的斩魄刀交锋中，游戏卡死犹如突现的虚圈屏障，阻断玩家与尸魂界的连接。本文将从技术架构、解决方案、预防策略三个维度，深度剖析卡死问题的成因与应对之策，助力玩家突破次元壁障，畅享灵魂共鸣...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表