精华内容
下载资源
问答
  • 2021-02-12 16:08:37

    今天进行IP巡检时用到了PINGIP地址,以获取该IP址是否可用,查了一些文档后,发现了两种PING的方法,但试用后,还是发现第一种比较好用,如果在局域网内,当然,第二种更有效率: 上面上代码

    // 方法一 最常用的 PING 方法

    Runtime runtime =Runtime.getRuntime(); // 获取当前程序的运行进对象

    Process process = null; //声明处理类对象

    String line = null; //返回行信息

    InputStream is = null; //输入流

    InputStreamReader isr = null;// 字节流

    BufferedReader br = null;

    String ip = "www.baidu.com";

    boolean res = false;// 结果

    try {

    process =runtime.exec("ping " + ip); // PING

    is =process.getInputStream(); // 实例化输入流

    isr = newInputStreamReader(is);// 把输入流转换成字节流

    br = newBufferedReader(isr);// 从字节中读取文本

    while ((line= br.readLine()) != null) {

    if(line.contains("TTL")) {

    res= true;

    break;

    }

    }

    is.close();

    isr.close();

    br.close();

    if (res){

    System.out.println("ping通  ...");

    } else{

    System.out.println("ping不通...");

    }

    } catch (IOException e) {

    System.out.println(e);

    runtime.exit(1);

    }

    //方法二 下面代码为 JDK1.5PING的新方法但不能用,因为 该PING请求端口为7 而大型网站会关闭不需要的端口防止入侵

    InetAddress address;

    try {

    address =InetAddress.getByName("www.weibo.com");

    System.out.println("Name:" + address.getHostName());

    System.out.println("Addr:" + address.getHostAddress());

    System.out.println("Reach:" + address.isReachable(3000)); //是否能通信 返回true或false

    System.out.println(address.toString());

    } catch (Exception e) {

    e.printStackTrace();

    }

    更多相关内容
  • JAVA配置 ip2region IPIP地址查询

    千次阅读 2019-01-30 18:25:53
    1、添加依赖 <dependency> <groupId&...ip2region</artifactId> <version>1.7</version> </dependency> 2、工具类

    1、添加依赖

    <dependency>
        <groupId>org.lionsoul</groupId>
        <artifactId>ip2region</artifactId>
        <version>1.7</version>
    </dependency>

    2、工具类

    public class IPUtil {
    
        public static String getCityInfo(String ip){
            //db
            String dbPath = IPUtil.class.getResource("/ip2region.db").getPath();
            File file = new File(dbPath);
            if ( file.exists() == false ) {
                System.out.println("Error: Invalid ip2region.db file");
            }
            //查询算法
            int algorithm = DbSearcher.BTREE_ALGORITHM; //B-tree
            //DbSearcher.BINARY_ALGORITHM //Binary
            //DbSearcher.MEMORY_ALGORITYM //Memory
            try {
                DbConfig config = new DbConfig();
                DbSearcher searcher = new DbSearcher(config, dbPath);
                //define the method
                Method method = null;
                switch ( algorithm )
                {
                    case DbSearcher.BTREE_ALGORITHM:
                        method = searcher.getClass().getMethod("btreeSearch", String.class);
                        break;
                    case DbSearcher.BINARY_ALGORITHM:
                        method = searcher.getClass().getMethod("binarySearch", String.class);
                        break;
                    case DbSearcher.MEMORY_ALGORITYM:
                        method = searcher.getClass().getMethod("memorySearch", String.class);
                        break;
                }
                DataBlock dataBlock = null;
                if (Util.isIpAddress(ip) == false ) {
                    System.out.println("Error: Invalid ip address");
                }
                dataBlock  = (DataBlock) method.invoke(searcher, ip);
                return dataBlock.getRegion();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    3、下载文件ip2region.db到resources文件夹下

        $ git clone https://gitee.com/lionsoul/ip2region.git

        下载这个项目之后到data/文件夹下面找到ip2region.db复制到项目resources下

    展开全文
  • 获取网络资源,使用动态代理ip解决单个ip访问次数限制问题
  • JAVA获取IP地址

    千次阅读 2021-11-11 11:38:42
    1、nginx 代理后客户端获取不到真实的ip需要nginx添加配置 location /api { proxy_pass http://127.0.0.1:8181/; #以下为新增 proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; #获取...

    1、nginx 代理后客户端获取不到真实的ip需要nginx添加配置

        location /api {
            proxy_pass http://127.0.0.1:8181/;
            #以下为新增
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;  #获取客户端真实IP
            proxy_set_header REMOTE-HOST $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

    添加配置后进行重启:进入nginx可执行目录sbin下,输入命令./nginx -s reload 即可

    2、搜集的各种获取IP地址的方法

    package com.sany.utils;
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.text.SimpleDateFormat;
    import com.fasterxml.jackson.annotation.JsonInclude;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.sany.vo.IpVo;
    import org.apache.commons.lang3.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class IPUtils {
    
    
        private final static Logger logger = LoggerFactory.getLogger(IPUtils.class);
    
        public static String getVisitorIp(HttpServletRequest request){
            // 优先取 X-Real-IP
            String ip = request.getHeader("X-Real-IP");
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
                ip = request.getHeader("x-forwarded-for");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)){
                ip = request.getRemoteAddr();
                if ("0:0:0:0:0:0:0:1".equals(ip))
                {
                    ip = "unknown";
                }
            }
            if ("unknown".equalsIgnoreCase(ip)){
                ip = "unknown";
                return ip;
            }
            int index = ip.indexOf(',');
            if (index >= 0){
                ip = ip.substring(0, index);
            }
            return ip;
        }
    
        public static final String UN_KNOWN = "unknown";
        public static String getIp(HttpServletRequest request) {
            String ip = request.getHeader("X-Requested-For");
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("X-Forwarded-For");
            }
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isBlank(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
            return StringUtils.isBlank(ip) ? null : ip.split(",")[0];
        }
    
        /**
         * 获取用户真实IP地址,不使用request.getRemoteAddr()的原因是有可能用户使用了代理软件方式避免真实IP地址,
         * 可是,如果通过了多级反向代理的话,X-Forwarded-For的值并不止一个,而是一串IP值
         *
         * @return ip
         */
        public static String getIpAddrs(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for");
            System.out.println("x-forwarded-for ip: " + ip);
            logger.info("x-forwarded-for ip: {}" , ip);
            if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
                // 多次反向代理后会有多个ip值,第一个ip才是真实ip
                if( ip.indexOf(",")!=-1 ){
                    ip = ip.split(",")[0];
                }
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
                System.out.println("Proxy-Client-IP ip: " + ip);
                logger.info("Proxy-Client-IP ip: {}" , ip);
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
                logger.info("WL-Proxy-Client-IP ip: {} " , ip);
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
                logger.info("HTTP_CLIENT_IP ip: {} " ,ip);
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
                logger.info("HTTP_X_FORWARDED_FOR ip: {}" , ip);
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("X-Real-IP");
                logger.info("X-Real-IP ip: {}" , ip);
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
                logger.info("getRemoteAddr ip: {}" , ip);
            }
            logger.info("获取客户端ip:{} " ,ip);
            return ip;
        }
    
        /**
         * 获取访问者的ip地址
         * 注:要外网访问才能获取到外网地址,如果你在局域网甚至本机上访问,获得的是内网或者本机的ip
         */
        public static String getIpAddr(HttpServletRequest request) {
            String ipAddress = null;
            try {
                //X-Forwarded-For:Squid 服务代理
                String ipAddresses = request.getHeader("X-Forwarded-For");
    
                if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
                    //Proxy-Client-IP:apache 服务代理
                    ipAddresses = request.getHeader("Proxy-Client-IP");
                }
    
                if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
                    //WL-Proxy-Client-IP:weblogic 服务代理
                    ipAddresses = request.getHeader("WL-Proxy-Client-IP");
                }
    
                if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
                    //HTTP_CLIENT_IP:有些代理服务器
                    ipAddresses = request.getHeader("HTTP_CLIENT_IP");
                }
    
                if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
                    //X-Real-IP:nginx服务代理
                    ipAddresses = request.getHeader("X-Real-IP");
                }
    
                //有些网络通过多层代理,那么获取到的ip就会有多个,一般都是通过逗号(,)分割开来,并且第一个ip为客户端的真实IP
                if (ipAddresses != null && ipAddresses.length() != 0) {
                    ipAddress = ipAddresses.split(",")[0];
                }
    
                //还是不能获取到,最后再通过request.getRemoteAddr();获取
                if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
                    ipAddress = request.getRemoteAddr();
                }
            } catch (Exception e) {
                ipAddress = "";
            }
            return ipAddress;
        }
    
        /**
         * 调用太平洋网络IP地址查询Web接口(http://whois.pconline.com.cn/),返回ip、地理位置
         */
        public static IpVo getIpVo(String ip){
            //查本机
            String url = "http://whois.pconline.com.cn/ipJson.jsp?json=true";
    
            //查指定ip
            if(!StringUtils.isEmpty(ip)){
                url = "http://whois.pconline.com.cn/ipJson.jsp?json=true&ip=" + ip;
            }
    
            StringBuilder inputLine = new StringBuilder();
            String read;
            try {
                HttpURLConnection urlConnection = (HttpURLConnection) new URL(url).openConnection();
                urlConnection.setRequestProperty("Charset", "GBK");
                BufferedReader in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "GBK"));
                while ((read = in.readLine()) != null) {
                    inputLine.append(read);
                }
                in.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            //返回格式
            /*
            {
                ip: "58.63.47.115",
                pro: "广东省",
                proCode: "440000",
                city: "广州市",
                cityCode: "440100",
                region: "天河区",
                regionCode: "440106",
                addr: "广东省广州市天河区 电信",
                regionNames: "",
                err: ""
            }
             */
    
            IpVo ipVo = null;
            try {
                ObjectMapper mapper = new ObjectMapper();
                //当属性的值为空(null或者"")时,不进行序列化,可以减少数据传输
                mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
                //设置日期格式
                mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
                //转换成IpVo
                ipVo = mapper.readValue(new String(inputLine.toString().getBytes("GBK"), "GBK"), IpVo.class);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return ipVo;
        }
    
        /**
         * 直接根据访问者的Request,返回ip、地理位置
         */
        public static IpVo getIpVoByRequest(HttpServletRequest request){
            return IPUtils.getIpVo(IPUtils.getIpAddr(request));
        }
    
        /**
         * 获取客户端IP
         **/
        public static String getClientIp(HttpServletRequest request){
            if (request.getHeader("x-forwarded-for") == null){
                return request.getRemoteAddr();
            }
            return request.getHeader("x-forwarded-for");
        }
    
    
        /*
            终极大法:java获取不了,就用js来获取
            <!-- js获取客户ip -->
            <script src="http://whois.pconline.com.cn/ipJson.jsp"></script>
         */
    
        //测试
        public static void main(String[] args) {
            //获取本机ip
            System.out.println(getIpVo(null));
    
        }
    
    }

    展开全文
  • 有些项目的接口是需要权限访问,比如限制IP、做权限控制,等等方案,本文是限制ip权限设置访问策略。 先看测试效果: 测试: 注意访问需要输入:http://127.0.0.1:8981/ 在配置文件加上本地的ip 10.9.160.135 去掉...

    有些项目的接口是需要权限访问,比如限制IP、做权限控制,等等方案,本文是限制ip权限设置访问策略。

    先看测试效果:

    测试:

    注意访问需要输入:http://127.0.0.1:8981/

    在配置文件加上本地的ip 10.9.160.135
    在这里插入图片描述
    去掉本地ip 10.9.160.135 提示非法字符
    在这里插入图片描述
    看一下项目结构,新建一个创建IPLimitInterceptor类,在springmvc配置文件配置、新建一个ip校验工具类 IPWhiteListUtil、ip配置文件: ipwhite.properties。
    在这里插入图片描述再看代码实现

    创建IPLimitInterceptor类
    PLimitInterceptor继承HandlerInterceptorAdapter父类

    import java.net.InetAddress;
    
    import java.util.Properties;
    
    import javax.servlet.http.HttpServletRequest;
    
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.core.io.support.PropertiesLoaderUtils;
    
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    public class IPLimitInterceptor extends HandlerInterceptorAdapter {
    
             @Override
             public boolean preHandle(HttpServletRequest request,
    
                                HttpServletResponse response, Object handler) throws Exception {undefined
    
                               String ip = getIpAddress(request);
    
                               //读取ip白名单配置文件ipwhite.properties
    
                               Properties properties = PropertiesLoaderUtils.loadAllProperties("ipwhite.properties");
    
                                String ipWhilte = properties.getProperty("ipWhilte");
    
                                System.out.println(ipWhilte);
    
                                //判断请求ip地址 是否在白名单呢
    
                     if(IPWhiteListUtil.checkLoginIP(ip,ipWhilte)) {undefined
    
                         return super.preHandle(request, response, handler);
    
                     }
    
                     throw new Exception("IP非法访问!");
    
     
    
             }
    
             //获取配置请求的ip地址
    
             private String getIpAddress(HttpServletRequest request) {undefined
    
            String ip = request.getHeader("x-forwarded-for");
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("Proxy-Client-IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("WL-Proxy-Client-IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("HTTP_CLIENT_IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getRemoteAddr();
    
                System.out.println("访问ip="+ip);
    
                if(ip.equals("127.0.0.1")){    
    
                    //根据网卡取本机配置的IP    
    
                    InetAddress inet=null;    
    
                    try {    
    
                        inet = InetAddress.getLocalHost();    
    
                    } catch (Exception e) {    
    
                        e.printStackTrace();    
    
                    }    
    
                    ip= inet.getHostAddress();    
    
                } 
    
            }
    
            //对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割   
    
            if(ip!=null && ip.length()>15){ //"***.***.***.***".length() = 15   
    
                if(ip.indexOf(",")>0){   
    
                    ip = ip.substring(0,ip.indexOf(","));   
    
                }   
    
            }   
    
            System.out.println("访问ip========="+ip);
    
            return ip;
    
        }
    
    }
    

    在springmvc配置文件配置:

    <mvc:interceptors>
    
        <!-- IP鉴权拦截器 -->
    
         <mvc:interceptor>
    
            <mvc:mapping path="/**"/>
    
            <bean class="com.*.*.ipwhite.IPLimitInterceptor"></bean>
    
         </mvc:interceptor>
    
       </mvc:interceptors>
    

    在这里插入图片描述
    再新建一个ip校验类 IPWhiteListUtil

    /**
     * IP校验类的方法
     */
    import java.util.ArrayList;
    
    import java.util.HashSet;
    
    import java.util.List;
    
    import java.util.Set;
    
    import java.util.regex.Pattern;
    
    
    
    public class IPWhiteListUtil {
        // IP的正则
        private static Pattern pattern = Pattern
                .compile("(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})");
        /**
         *
         * getAvaliIpList:(根据IP白名单设置获取可用的IP列表).
         * @return
         */
    
        private static Set getAvaliIpList(String allowIp) {
            Set<String> ipList = new HashSet();
            for (String allow : allowIp.replaceAll("\\s", "").split(";")) {
                if (allow.indexOf("*") > -1) {
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList();
                    for (int i = 0; i < ips.length; i++)
                        if (ips[i].indexOf("*") > -1) {
                                tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
                    StringBuffer fromIP = new StringBuffer();
                    StringBuffer endIP = new StringBuffer();
                    for (int i = 0; i < 4; i++){
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    }
                    fromIP.deleteCharAt(fromIP.length() - 1);
                    endIP.deleteCharAt(endIP.length() - 1);
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]",
                                s.split(";")[0])
                                + "-"
                                + endIP.toString().replace("[*]", s.split(";")[1]);
    
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
    
                } else {
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
            }
            return ipList;
        }
    
        private static Set getAvaliIpList(Set<String> ipSet) {
            Set<String> ipList = new HashSet();
            for (String allow : ipSet) {
                if (allow.indexOf("*") > -1) {
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList();
                    for (int i = 0; i < ips.length; i++)
                        if (ips[i].indexOf("*") > -1) {
                                tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
                    StringBuffer fromIP = new StringBuffer();
                    StringBuffer endIP = new StringBuffer();
                    for (int i = 0; i < 4; i++) {
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    }
                    fromIP.deleteCharAt(fromIP.length() - 1);
    
                    endIP.deleteCharAt(endIP.length() - 1);
    
    
    
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]",
                                s.split(";")[0])
                                + "-"
                                + endIP.toString().replace("[*]", s.split(";")[1]);
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
                } else {
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
            }
            return ipList;
        }
    
        /**
    
         * 对单个IP节点进行范围限定
    
         *
    
         * @param arg
    
         * @return 返回限定后的IP范围,格式为List[10;19, 100;199]
    
         */
    
        private static List complete(String arg) {
            List com = new ArrayList();
            if (arg.length() == 1) {
                com.add("0;255");
            } else if (arg.length() == 2) {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
                String s2 = complete(arg, 2);
                if (s2 != null){
                    com.add(s2);
                }
            } else {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
            }
            return com;
        }
        private static String complete(String arg, int length) {
    
            String from = "";
    
            String end = "";
    
            if (length == 1) {
    
                    from = arg.replace("*", "0");
    
                end = arg.replace("*", "9");
    
            } else {
    
                    from = arg.replace("*", "00");
    
                end = arg.replace("*", "99");
    
            }
    
            if (Integer.valueOf(from) > 255){
                return null;
            }
            if (Integer.valueOf(end) > 255){
                end = "255";
            }
            return from + ";" + end;
    
        }
    
    
    
        /**
    
         * 在添加至白名单时进行格式校验
    
         *
    
         * @param ip
    
         * @return
    
         */
    
        private static boolean validate(String ip) {
    
            for (String s : ip.split("-")){
                if (!pattern.matcher(s).matches()) {
    
                    return false;
    
                }
            }
            return true;
    
        }
    
    
    
        /**
    
         *
    
         * checkLoginIP:(根据IP,及可用Ip列表来判断ip是否包含在白名单之中).
    
         * @param ip
    
         * @param ipList
    
         * @return
    
         */
    
        private static boolean checkLoginIP(String ip, Set<String> ipList) {
            if (ipList.contains(ip)){
                return true;
            }else {
                for (String allow : ipList) {
                    if (allow.indexOf("-") > -1) {
                        String[] from = allow.split("-")[0].split("\\.");
                        String[] end = allow.split("-")[1].split("\\.");
                        String[] tag = ip.split("\\.");
                        // 对IP从左到右进行逐段匹配
                        boolean check = true;
                        for (int i = 0; i < 4; i++) {
                            int s = Integer.valueOf(from[i]);
                            int t = Integer.valueOf(tag[i]);
                            int e = Integer.valueOf(end[i]);
                            if (!(s <= t && t <= e)) {
                                check = false;
                                break;
                            }
                        }
                        if (check) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    
    
    
        /**
    
         *
    
         * checkLoginIP:(根据IP地址,及IP白名单设置规则判断IP是否包含在白名单).
    
         * @param ip
    
         * @param ipWhiteConfig
    
         * @return
    
         */
    
        public static boolean checkLoginIP(String ip,String ipWhiteConfig){
    
            Set ipList = getAvaliIpList(ipWhiteConfig);
    
            return checkLoginIP(ip, ipList);
    
        }
    
    
    
        /**
    
         *
    
         * ip在ipList中,则返回true
    
         * @param ip
    
         * @param ipList
    
         * @return
    
         */
    
        public static boolean checkIpList(String ip,List<String> ipList){
    
            Set<String> ipSet = new HashSet();
    
            for(String ipStr : ipList){
    
                if(!ipStr.trim().startsWith("#")){
    
                    ipSet.add(ipStr.trim());
    
                }
    
            }
    
            ipSet = getAvaliIpList(ipSet);
    
            return checkLoginIP(ip, ipSet);
    
        }
    
        // 测试
    
        public static void main(String[] args) {
    
            String ipWhilte = "192.168.1.1;" +                 //设置单个IP的白名单
                    "192.168.2.*;" +                 //设置ip通配符,对一个ip段进行匹配
                    "192.168.3.17-192.168.3.38";     //设置一个IP范围
            System.out.println(ipWhilte);
            boolean flag = checkLoginIP("192.168.2.2",ipWhilte);
            boolean flag2 = checkLoginIP("192.168.1.2",ipWhilte);
            boolean flag3 = checkLoginIP("192.168.3.16",ipWhilte);
            boolean flag4 = checkLoginIP("192.168.3.17",ipWhilte);
            System.out.println(flag);  //true
            System.out.println(flag2);  //false
            System.out.println(flag3);  //false
            System.out.println(flag4);  //true
        }
    }
    
    

    #配置白名单-可改成数据库获取或配置文件配置

    #//设置单个IP的白名单 “192.168.1.1;”

    #//设置ip通配符,对一个ip段进行匹配 “192.168.2.*;”

    #//设置一个IP范围 “192.168.12.17-192.168.12.150”

    ipWhilte = 192.168.1.1;192.168.2.*;192.168.2.17-192.168.12.150;10.9.160.135;

    测试:

    注意访问需要输入:http://127.0.0.1:8981/hello

    在配置文件加上本地的ip 10.9.160.135
    在这里插入图片描述
    去掉本地ip 10.9.160.135 提示非法字符
    在这里插入图片描述

    展开全文
  • 通过Java网络爬虫爬取指定代理ip网上的ip,利用了jsoup、httpclient技术实现
  • java 设置代理ip

    万次阅读 2016-05-17 10:23:43
    java设置代理IP的两种方式。第一种简便快捷,第二种可以避免代理失效时使用本地连接访问网络。
  • Java获取指定主机的IP地址以下实例演示了如何使用 InetAddress 类的 InetAddress.getByName() 方法来获取指定主机(网址)的IP地址:Main.java 文件import java.net.InetAddress;import java.net.UnknownHostException...
  • java获取Centos7服务器网卡ip 子网掩码 默认网关 DNS 同时设置网卡 及 重启网卡参考
  • java多线程代理IP

    2017-11-30 09:35:46
    多线程代理IP池,一直看到有关这方面的技术... 需要主要的是,代理ip获取成功后是放在redis里面的,有关redis的参数配置在baseDB里面配置。当然对于没有开redis,我也进行处理放在了static里面。难者不会会者不难-=-。
  • java动态设置IP

    千次阅读 2015-04-02 00:44:31
    工作需要要写一个spider访问XXX网站,但是由于我访问频率很高经常被XX网站封IP(我知道这是不道德的,但是没办法)。为了突破IP限制需要动态替换代理ip。  代码如下:  Java代码  import java.io...
  • Java-TLS-连接 使用 Java 通过 TLS 连接到 IP 地址(需要正确的证书、IP 和端口号)
  • 通过JAVA解析IP地址

    千次阅读 2021-02-27 13:23:04
    如何用Java获得一个域名的IP地址呢?提供这个功能的类叫做java.net.InetAddress。我们假设现在有这样一个域名,他用一个静态的 getByName来重新获得一个InetAddress,然后得到能够读出的IP地址。下面的代码是很基本...
  • Java基础 IP地址

    千次阅读 2022-03-26 13:14:07
    ip地址 1、概念:用于唯一标识网络中每台计算机/主机 2、查看ip地址ipconfig 3、ip地址的表示形式:点分十进制 xx.xx.xx.xx 4、每个十进制数的范围:0~255 5、ip地址的组成=网络地址+主机地址,比如192.168.16....
  • React性,无阻塞的Java库,用于KNX Net / IP通信。 该库的目的是让开发人员允许其应用程序通过其KNX Net / IP设备(KNX路由器或KNX接口)与KNX world通信。 支持隧道和路由模式。 有关演示应用程序,请参见 。 ...
  • Java - ip2region - 使用篇

    千次阅读 2022-04-27 16:02:00
    Java - ip2region - 使用篇 本篇主要介绍 ip2region, ip2region 支持很多客户端,本次主要以Java来介绍 在进行系统开发时,我们一般会涉及到获取到用户的具体位置信息,一般有两个方法: 根据GPS 定位的信息 ...
  • 工具类: springboot 获取访问接口的请求的IP地址 ...问题: ...nginx代理需要做一些配置(如果是微服务,直接在网关服务的nginx做配置即可) #得到请求真实IP proxy_set_header X-Real-IP $...
  • 网络代理,网络爬虫刷IPJava版,最新有效刷ip方法 Java代码,包括代理ip采集,设置代理服务、获取列表,刷IP,网页解析等知识
  • 通过java 验证机器与某ip地址能否联通的工具类。配置ip地址就可以测试使用了。
  • JAVA获取本地IP

    2022-02-16 16:29:17
    Java获取本地IP
  • java获取本机外网ip

    2015-08-13 20:23:06
    通过url链接到一个网址,该网址返回自己的ip地址(通过代理服务器访问)
  • 关于黑名单IP设置

    2021-03-16 12:23:37
    最近在做一个项目的时候,需要做一个自动的黑名单设置,也就是将一天内重复出错的超过一定次数的手机号,和IP给加入黑名单里面,下次请求的时候先判断是否在黑名单里。这个是获取IP地址的方法1 private stringGetIP...
  • Java获取真实Ip地址

    千次阅读 多人点赞 2021-09-09 16:59:56
    Java获取真实Ip地址
  • java根据ip获取定位(实用粗略定位)

    千次阅读 2021-11-20 11:19:19
    项目老大接了一个政府的...2.下面是根据ip获取经纬度,然后根据经纬度获取经纬度地址。 @RestController @RequestMapping("/hh") @CrossOrigin(origins = "*",maxAge = 3600) public class testController { //这
  • java中的IP地址问题

    千次阅读 2021-02-12 20:22:01
    其中的InetAddress就是java中用来处理ip地址格式数据的类,通过 InetAddress.getName(server)(其中server相信是server端的ip地址)就 处理了server的ip地址格式, 返回一个inetaddress 对象。 这些只是我的一些...
  • java拦截ip和限制ip访问接口的次数

    千次阅读 2019-05-31 17:40:54
    本文出自付付讶的博客 ... 这两天因为公司需求需要加一个限制ip请求次数的功能,限制某些ip一天只能访问10次,现在总结一下(因为是老项目所以用的是servlet) 用到的jar包:commons-lang3-3.8.1.jar 用到...
  • 15.java获取当前主机ip

    千次阅读 2022-01-30 12:30:11
    java提供了InetAddress类代表IP地址,InerAddress下有两个子类 分别是Iner4Address和Iner6Address,他们分别代表IPv4和IPv6地址 InerAddress没有构造方法,而是提供了静态方法来获取InerAddress实例 InerAddress...
  • java获取客户端IP地址工具类

    千次阅读 2021-11-01 15:19:15
    代码如下自取: import lombok.extern.slf4j.Slf4j; ... import java.net.InetAddress;... * @Title 获取客户端ip地址类 * @Author YangWanJie * @Date 2021/6/30 16:08 * @versioin V1.0 **/ @Slf
  • 本博文主要介绍如何通过前端请求获取用户的ip,再通过调用第三方的api,获取数据data,分析数据,获取想要的ip所属国家/区域/城市,以及经纬度等等.目前博主所使用的api属于免费的,查看其他博主的博客,阿里/百度/新浪的都...
  • Java防伪造ip,Nginx方法

    千次阅读 2021-06-15 13:39:33
    问题:伪造ip发送请求,获取到的ip为:111.111.111.111 效果:经处理,获取的ip为...解决:配置nginx即可。 若项目没有使用代理,如nginx,则只需修改代码。 String ip = request.getRemoteAddr(); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 542,634
精华内容 217,053
关键字:

java配置ip

java 订阅