老友wan
老友wan

Java代码通过经纬度计算省份。

Java代码通过经纬度计算省份。_第1张图片

Java代码通过经纬度计算省份。_第2张图片Java代码通过经纬度计算省份。_第3张图片

 直接上代码，需要市区县可自己解析

String areaName = addressUtil.getPosition(longitude, latitude);
package com.skyable.device.utils.velicle;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Synchronized;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * @author Administrator
 */
@Component
public class AddressUtil {
    @Autowired
    private JsonUtil jsonUtil;

    private static final List> LIST = new ArrayList<>();
    private static final Map> MAP = new HashMap<>();

    @Synchronized
    public String getPosition(Double longitude, Double latitude) {
        String areaName = "中国";
        Map resultMap = new HashMap<>();
        resultMap.put("code", 500);
        resultMap.put("message", "失败");
        if (longitude == null || latitude == null) {
            return areaName;
        }
        if (LIST.isEmpty()) {
            LIST.addAll(jsonUtil.readJson());
        }
        if (MAP.isEmpty()) {
            for (Map jsonMap : LIST) {
                MAP.put(Integer.valueOf(jsonMap.get("id").toString()), jsonMap);
            }
        }

        double minDistance = 0.0D;
        Map shopAreaMap = new HashMap<>();
        boolean first = true;
        for (Map areaMap : LIST) {
            String level = areaMap.get("level").toString();
            String lng = areaMap.get("lng").toString().replace("\"", "");
            String lat = areaMap.get("lat").toString().replace("\"", "");

            if (!("1".equals(level) || "2".equals(level)) && (!"null".equals(lng)) && (!"null".equals(lat))) {
                double distance = CoordTransform.getDistance(latitude, longitude, Double.parseDouble(lat), Double.parseDouble(lng));
                if (minDistance == 0.0D && first) {
                    minDistance = distance;
                    shopAreaMap = areaMap;
                    first = false;
                } else if (distance < minDistance) {
                    minDistance = distance;
                    shopAreaMap = areaMap;
                }
            }
        }
        if (!shopAreaMap.isEmpty() && shopAreaMap.get("level") != null) {
            int level = Integer.parseInt(shopAreaMap.get("level").toString());

            if (level == 4 || level == 3) {
                Map parentMap = MAP.get(Integer.valueOf(shopAreaMap.get("parentid").toString()));
                if (parentMap != null) {
                    if (level == 4) {
                        Map cityMap = MAP.get(Integer.valueOf(parentMap.get("parentid").toString()));
                        if (cityMap != null) {
                            shopAreaMap = cityMap;
                        }
                        shopAreaMap.put("county", parentMap);
                    } else {
                        shopAreaMap.put("county", shopAreaMap);
                    }
                    shopAreaMap = parentMap;
                }
            }
            shopAreaMap.put("shortname", MAP.get(Integer.valueOf(shopAreaMap.get("parentid").toString())).get("areaname").toString());
        }
        resultMap.put("data", shopAreaMap);
        Object parentId = shopAreaMap.get("parentid");
        for (Map record : LIST) {
            Object id = record.get("id");
            if (parentId.equals(id)) {
                parentId = record.get("parentid");
            }
        }
        for (Map map : LIST) {
            if (map.get("id").equals(parentId)) {
                areaName = map.get("areaname").toString().replaceAll("\"", "");
            }
        }
        return areaName;
    }
}
package com.skyable.device.utils.velicle;

/**
 * @author Administrator
 */
public class CoordTransform {
    private static final double X_PI = 52.359877559829883;
    private static final double PI = 3.141592653589793;
    private static final double A = 6378245.0;
    private static final double EE = 0.006693421622965943;
    public static double getDistance(double x1, double y1, double x2, double y2) {
        double x = (x1 - x2) * PI * A *
                Math.cos((y1 + y2) / 2.0 * PI / 180.0) / 180.0;
        double y = (y2 - y1) * PI * A / 180.0;
        return Math.sqrt(x * x + y * y);
    }
}

package com.skyable.device.utils.velicle;

public class IPEntry {
    public String beginIp;
    public String endIp;
    public String country;
    public String area;

    public IPEntry() {
        this.beginIp = (this.endIp = this.country = this.area = "");
    }

    @Override
    public String toString() {
        return this.area + "  " + this.country + "IP范围:" + this.beginIp + "-" +
                this.endIp;
    }
}

package com.skyable.device.utils.velicle;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.*;

public class IPSeeker {
    private static final String IP_FILE = PropertiesUtil.getProperty("IP_DATA_URL");
    private static final int IP_RECORD_LENGTH = 7;
    private static final byte AREA_FOLLOWED = 1;
    private static final byte NO_AREA = 2;
    private static Hashtable ipCache;
    private static RandomAccessFile ipFile;
    private static MappedByteBuffer mbb;
    private static IPSeeker instance = new IPSeeker();
    private static long ipBegin;
    private static long ipEnd;
    private static IPLocation loc;
    private static byte[] buf;
    private static byte[] b4;
    private static byte[] b3;

    private IPSeeker() {
        ipCache = new Hashtable();
        loc = new IPLocation();
        buf = new byte[100];
        b4 = new byte[4];
        b3 = new byte[3];
        try {
            ipFile = new RandomAccessFile(IP_FILE, "r");
        } catch (FileNotFoundException e) {
            System.out.println(IP_FILE);
            System.out.println("IP地址信息文件没有找到，IP显示功能将无法使用");
            ipFile = null;
        }

        if (ipFile != null) {
            try {
                ipBegin = readLong4(0L);
                ipEnd = readLong4(4L);
                if ((ipBegin == -1L) || (ipEnd == -1L)) {
                    ipFile.close();
                    ipFile = null;
                }
            } catch (IOException e) {
                System.out.println("IP地址信息文件格式有错误，IP显示功能将无法使用");
                ipFile = null;
            }
        }
    }

    public static IPSeeker getInstance() {
        return instance;
    }

    public List getIPEntriesDebug(String s) {
        List ret = new ArrayList();
        long endOffset = ipEnd + 4L;
        for (long offset = ipBegin + 4L; offset <= endOffset; offset += 7L) {
            long temp = readLong3(offset);

            if (temp != -1L) {
                IPLocation loc = getIPLocation(temp);

                if ((loc.country.indexOf(s) != -1) || (loc.area.indexOf(s) != -1)) {
                    IPEntry entry = new IPEntry();
                    entry.country = loc.country;
                    entry.area = loc.area;

                    readIP(offset - 4L, b4);
                    entry.beginIp = Utils.getIpStringFromBytes(b4);

                    readIP(temp, b4);
                    entry.endIp = Utils.getIpStringFromBytes(b4);

                    ret.add(entry);
                }
            }
        }
        return ret;
    }

    public List getIPEntries(String s) {
        List ret = new ArrayList();
        try {
            if (mbb == null) {
                FileChannel fc = ipFile.getChannel();
                mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0L, ipFile.length());
                mbb.order(ByteOrder.LITTLE_ENDIAN);
            }

            int endOffset = (int) ipEnd;
            for (int offset = (int) ipBegin + 4; offset <= endOffset; offset += 7) {
                int temp = readInt3(offset);
                if (temp != -1) {
                    IPLocation loc = getIPLocation(temp);

                    if ((loc.country.indexOf(s) != -1) ||
                            (loc.area.indexOf(s) != -1)) {
                        IPEntry entry = new IPEntry();
                        entry.country = loc.country;
                        entry.area = loc.area;

                        readIP(offset - 4, b4);
                        entry.beginIp = Utils.getIpStringFromBytes(b4);

                        readIP(temp, b4);
                        entry.endIp = Utils.getIpStringFromBytes(b4);

                        ret.add(entry);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return ret;
    }

    private int readInt3(int offset) {
        mbb.position(offset);
        return mbb.getInt() & 0xFFFFFF;
    }

    private int readInt3() {
        return mbb.getInt() & 0xFFFFFF;
    }

    public static String getCountry(byte[] ip) {
        if (ipFile == null) {
            return "错误的IP数据库文件";
        }
        String ipStr = Utils.getIpStringFromBytes(ip);

        if (ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation) ipCache.get(ipStr);
            return loc.country;
        }
        IPLocation loc = getIPLocation(ip);
        ipCache.put(ipStr, loc.getCopy());
        return loc.country;
    }

    public static String getCountry(String ip) {
        return getCountry(Utils.getIpByteArrayFromString(ip));
    }

    public String getArea(byte[] ip) {
        if (ipFile == null) {
            return "错误的IP数据库文件";
        }
        String ipStr = Utils.getIpStringFromBytes(ip);

        if (ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation) ipCache.get(ipStr);
            return loc.area;
        }
        IPLocation loc = getIPLocation(ip);
        ipCache.put(ipStr, loc.getCopy());
        return loc.area;
    }

    public String getArea(String ip) {
        return getArea(Utils.getIpByteArrayFromString(ip));
    }

    private static IPLocation getIPLocation(byte[] ip) {
        IPLocation info = null;
        long offset = locateIP(ip);
        if (offset != -1L) {
            info = getIPLocation(offset);
        }
        if (info == null) {
            info.country = "未知国家";
            info.area = "未知地区";
        }
        return info;
    }

    private long readLong4(long offset) {
        long ret = 0L;
        try {
            ipFile.seek(offset);
            ret |= ipFile.readByte() & 0xFF;
            ret |= ipFile.readByte() << 8 & 0xFF00;
            ret |= ipFile.readByte() << 16 & 0xFF0000;
            return ret | ipFile.readByte() << 24 & 0xFF000000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static long readLong3(long offset) {
        long ret = 0L;
        try {
            ipFile.seek(offset);
            ipFile.readFully(b3);
            ret |= b3[0] & 0xFF;
            ret |= b3[1] << 8 & 0xFF00;
            return ret | b3[2] << 16 & 0xFF0000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static long readLong3() {
        long ret = 0L;
        try {
            ipFile.readFully(b3);
            ret |= b3[0] & 0xFF;
            ret |= b3[1] << 8 & 0xFF00;
            return ret | b3[2] << 16 & 0xFF0000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static void readIP(long offset, byte[] ip) {
        try {
            ipFile.seek(offset);
            ipFile.readFully(ip);
            byte temp = ip[0];
            ip[0] = ip[3];
            ip[3] = temp;
            temp = ip[1];
            ip[1] = ip[2];
            ip[2] = temp;
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    private void readIP(int offset, byte[] ip) {
        mbb.position(offset);
        mbb.get(ip);
        byte temp = ip[0];
        ip[0] = ip[3];
        ip[3] = temp;
        temp = ip[1];
        ip[1] = ip[2];
        ip[2] = temp;
    }

    private static int compareIP(byte[] ip, byte[] beginIp) {
        for (int i = 0; i < 4; i++) {
            int r = compareByte(ip[i], beginIp[i]);
            if (r != 0) {
                return r;
            }
        }
        return 0;
    }

    private static int compareByte(byte b1, byte b2) {
        if ((b1 & 0xFF) > (b2 & 0xFF)) {
            return 1;
        }
        if ((b1 ^ b2) == 0) {
            return 0;
        }
        return -1;
    }

    private static long locateIP(byte[] ip) {
        long m = 0L;

        readIP(ipBegin, b4);
        int r = compareIP(ip, b4);
        if (r == 0) {
            return ipBegin;
        }
        if (r < 0) {
            return -1L;
        }
        long i = ipBegin;
        for (long j = ipEnd; i < j; ) {
            m = getMiddleOffset(i, j);
            readIP(m, b4);
            r = compareIP(ip, b4);

            if (r > 0) {
                i = m;
            } else if (r < 0) {
                if (m == j) {
                    j -= 7L;
                    m = j;
                } else {
                    j = m;
                }
            } else {
                return readLong3(m + 4L);
            }

        }

        m = readLong3(m + 4L);
        readIP(m, b4);
        r = compareIP(ip, b4);
        if (r <= 0) {
            return m;
        }
        return -1L;
    }

    private static long getMiddleOffset(long begin, long end) {
        long records = (end - begin) / 7L;
        records >>= 1;
        if (records == 0L) {
            records = 1L;
        }
        return begin + records * 7L;
    }

    private static IPLocation getIPLocation(long offset) {
        try {
            ipFile.seek(offset + 4L);

            byte b = ipFile.readByte();
            if (b == 1) {
                long countryOffset = readLong3();

                ipFile.seek(countryOffset);

                b = ipFile.readByte();
                if (b == 2) {
                    loc.country = readString(readLong3());
                    ipFile.seek(countryOffset + 4L);
                } else {
                    loc.country = readString(countryOffset);
                }
                loc.area = readArea(ipFile.getFilePointer());
            } else if (b == 2) {
                loc.country = readString(readLong3());
                loc.area = readArea(offset + 8L);
            } else {
                loc.country = readString(ipFile.getFilePointer() - 1L);
                loc.area = readArea(ipFile.getFilePointer());
            }
            return loc;
        } catch (IOException e) {
        }
        return null;
    }

    private IPLocation getIPLocation(int offset) {
        mbb.position(offset + 4);

        byte b = mbb.get();
        if (b == 1) {
            int countryOffset = readInt3();

            mbb.position(countryOffset);

            b = mbb.get();
            if (b == 2) {
                loc.country = readString(readInt3());
                mbb.position(countryOffset + 4);
            } else {
                loc.country = readString(countryOffset);
            }
            loc.area = readArea(mbb.position());
        } else if (b == 2) {
            loc.country = readString(readInt3());
            loc.area = readArea(offset + 8);
        } else {
            loc.country = readString(mbb.position() - 1);
            loc.area = readArea(mbb.position());
        }
        return loc;
    }

    private static String readArea(long offset)
            throws IOException {
        ipFile.seek(offset);
        byte b = ipFile.readByte();
        if ((b == 1) || (b == 2)) {
            long areaOffset = readLong3(offset + 1L);
            if (areaOffset == 0L) {
                return "未知地区";
            }
            return readString(areaOffset);
        }
        return readString(offset);
    }

    private String readArea(int offset) {
        mbb.position(offset);
        byte b = mbb.get();
        if ((b == 1) || (b == 2)) {
            int areaOffset = readInt3();
            if (areaOffset == 0) {
                return "未知地区";
            }
            return readString(areaOffset);
        }
        return readString(offset);
    }

    private static String readString(long offset) {
        try {
            ipFile.seek(offset);

            int i = 0;
            for (buf[i] = ipFile.readByte(); buf[i] != 0; ) {
                buf[(++i)] = ipFile
                        .readByte();
            }

            if (i != 0) {
                return Utils.convertBytesToString(buf, 0, i, "GBK");
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    private String readString(int offset) {
        try {
            mbb.position(offset);

            int i = 0;
            for (buf[i] = mbb.get(); buf[i] != 0; buf[(++i)] = mbb.get()) {
                if (i != 0) {
                    return Utils.convertBytesToString(buf, 0, i, "GBK");
                }
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    public String getAddress(String ip) {
        String country = getCountry(ip).equals(" CZ88.NET") ? "null" :
                getCountry(ip);

        String area = getArea(ip).equals(" CZ88.NET") ? "null" : getArea(ip);
        String address = country + "|" + area;
        return address.trim();
    }

    public static String getAddressByCity(String ip) {
        String country = getCountry(ip).equals(" CZ88.NET") ? "null" :
                getCountry(ip);
        String address = country;
        return address.trim();
    }

    public static Map jqCity(String str) {
        String shortname = "";
        String areaname = "";
        Map map = new HashMap();
        boolean status = str.contains("省");
        if (status) {
            String[] splitstr = str.split("省");

            shortname = splitstr[0] + "省";
            areaname = splitstr[1];
            if (areaname.contains("市")) {
                areaname = areaname.split("市")[0] + "市";
            }
        }
        boolean xj = str.contains("新疆");
        if (xj) {
            String[] splitstr = str.split("新疆");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "新疆";
            areaname = splitstr[1];
        }
        boolean xz = str.contains("西藏");
        if (xz) {
            String[] splitstr = str.split("西藏");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "西藏";
            areaname = splitstr[1];
        }
        boolean nmg = str.contains("内蒙古");
        if (nmg) {
            String[] splitstr = str.split("内蒙古");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "内蒙古";
            areaname = splitstr[1];
        }
        boolean nx = str.contains("宁夏");
        if (nx) {
            String[] splitstr = str.split("宁夏");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "宁夏";
            areaname = splitstr[1];
        }
        boolean gx = str.contains("广西");
        if (gx) {
            String[] splitstr = str.split("广西");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "广西";
            areaname = splitstr[1];
        }
        boolean bjs = str.contains("北京市");

        boolean tjs = str.contains("天津市");

        boolean shs = str.contains("上海市");

        boolean cqs = str.contains("重庆市");

        boolean xg = str.contains("香港");

        boolean am = str.contains("澳门");
        if ((am) || (xg) || (cqs) || (shs) || (tjs) || (bjs)) {
            System.out.println(str);
            shortname = str;
            areaname = str;
        }
        map.put("shortname", shortname);
        map.put("areaname", areaname);
        return map;
    }

    public static void main(String[] args) {
        IPSeeker is = new IPSeeker();

        System.out.println(is.getAddress("119.123.225.83"));

        System.out.println(is.getAddress("14.215.177.39"));

        System.out.println(is.getAddress("113.78.255.221"));

        System.out.println(is.getAddress("182.34.16.127"));

        System.out.println(is.getAddress("180.118.240.225"));

        System.out.println(is.getAddress("119.29.252.90"));

        System.out.println(is.getAddress("61.128.101.255"));

        System.out.println(is.getAddress("110.157.255.255"));

        System.out.println(is.getAddress("220.182.44.228"));

        System.out.println(is.getAddress("1.183.255.255"));

        System.out.println(is.getAddress("123.125.71.38"));

        System.out.println(is.getAddress("203.186.145.250"));

        System.out.println(is.getAddress("111.113.255.255"));

        System.out.println(is.getAddress("180.143.255.255"));
    }

    private class IPLocation {
        public String country;
        public String area;

        public IPLocation() {
            this.country = (this.area = "");
        }

        public IPLocation getCopy() {
            IPLocation ret = new IPLocation();
            ret.country = this.country;
            ret.area = this.area;
            return ret;
        }
    }
}

package com.skyable.device.utils.velicle;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.util.*;

public class JsonToMap {
    public static JsonObject parseJson(String json) {
        JsonParser parser = new JsonParser();
        return parser.parse(json).getAsJsonObject();
    }

    public static Map toMap(String json) {
        return toMap(parseJson(json));
    }

    public static Map toMap(JsonObject json) {
        Map map = new HashMap<>();
        Set> entrySet = json.entrySet();
        for (Map.Entry entry : entrySet) {
            String key = entry.getKey();
            JsonElement value = entry.getValue();
            if (value.isJsonArray()) {
                map.put(key, toList(value.getAsJsonArray()));
            } else if (value.isJsonObject()) {
                map.put(key, toMap(value.getAsJsonObject()));
            } else {
                map.put(key, value);
            }
        }
        return map;
    }

    public static List toList(JsonArray json) {
        List list = new ArrayList<>();
        for (JsonElement element : json) {
            if (element.isJsonArray()) {
                list.add(toList(element.getAsJsonArray()));
            } else if (element.isJsonObject()) {
                list.add(toMap(element.getAsJsonObject()));
            } else {
                list.add(element);
            }
        }
        return list;
    }
}
 
  
package com.skyable.device.utils.velicle;

import com.google.gson.*;
import com.google.gson.stream.JsonReader;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class JsonUtil {
    @Value("${vehicle.jsonFile}")
    private String filePath;

    public List> readJson() {
        List> list = new ArrayList<>();

        if (filePath == null) {
            System.out.println("File path is null.");
            return list;
        }
        try (JsonReader reader = new JsonReader(new FileReader(filePath))) {
            Gson gson = new Gson();
            reader.beginObject(); // Start reading the root object
            while (reader.hasNext()) {
                String name = reader.nextName();
                if ("RECORDS".equals(name)) {
                    reader.beginArray(); // Start reading the array
                    while (reader.hasNext()) {
                        JsonObject subObject = gson.fromJson(reader, JsonObject.class);
                        list.add(subObject.entrySet().stream()
                                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
                    }
                    reader.endArray(); // End reading the array
                } else {
                    reader.skipValue(); // Skip other fields
                }
            }
            reader.endObject(); // End reading the root object
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

}

 
  
package com.skyable.device.utils.velicle;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;

public class PropertiesUtil {
    private static final Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
    private static Properties props;

    static {
        // 更具描述性的文件名
        String fileName = "application.test";
        props = new Properties();
        try (InputStreamReader reader = new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName), "UTF-8")) {
            props.load(reader);
        } catch (IOException e) {
            logger.error("配置文件读取异常", e);
        }
    }

    public static String getProperty(String key) {
        String value = props.getProperty(key.trim());
        return value != null ? value.trim() : null;
    }

    public static String getProperty(String key, String defaultValue) {
        String value = props.getProperty(key.trim());
        return value != null ? value.trim() : defaultValue;
    }
}

 
  
package com.skyable.device.utils.velicle;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.util.StringTokenizer;

/**
 * @author Administrator
 */
public class Utils {
    private static final Logger logger = LoggerFactory.getLogger(Utils.class);

    public static byte[] getIpByteArrayFromString(String ip) {
        byte[] ret = new byte[4];
        StringTokenizer st = new StringTokenizer(ip, ".");
        try {
            ret[0] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[1] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[2] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[3] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
        } catch (Exception e) {
            logger.error("Error while getting IP byte array from string: {}", e.getMessage());
        }
        return ret;
    }

    public static String convertString(String input, String sourceEncoding, String targetEncoding) {
        try {
            return new String(input.getBytes(sourceEncoding), targetEncoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting string: {}", e.getMessage());
        }
        return input;
    }

    public static String convertBytesToString(byte[] byteArray, String encoding) {
        try {
            return new String(byteArray, encoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting bytes to string: {}", e.getMessage());
        }
        return new String(byteArray);
    }

    public static String convertBytesToString(byte[] byteArray, int offset, int length, String encoding) {
        try {
            return new String(byteArray, offset, length, encoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting bytes to string: {}", e.getMessage());
        }
        return new String(byteArray, offset, length);
    }

    public static String getIpStringFromBytes(byte[] ipBytes) {
        StringBuilder sb = new StringBuilder();
        sb.append(ipBytes[0] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[1] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[2] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[3] & 0xFF);
        return sb.toString();
    }
}

 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(基础,java,windows,开发语言)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update
                        iBaoxing
github
                        
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • linux sdl windows.h,Windows下的SDL安装
                        奔跑吧linux内核
linuxsdlwindows.h
                        
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 大伟说成语之唉声叹气
                        求索大伟

                        
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    
                    
    • 
                    
  • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • 高级 ECharts 技巧：自定义图表主题与样式
                        SnowMan1993
echarts信息可视化数据分析
                        
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • Rust基础知识
                        GRKF15
rust开发语言后端
                        
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
    
                    
    • 
                    
  • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    
                    
    • 
                    
  • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
    
                    
    • 
                    
  • ExpRe[25] bash外的其它shell：zsh和fish
                        tritone
ExpRebashlinuxubuntushell
                        
    文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
    
                    
    • 
                                
  • Enum 枚举
                                    120153216
enum枚举
                                    
    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration 
于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样： 
public static final int APPLE_FUJI = 0
    
                                
    • 
                                
  • Java8简明教程
                                    bijian1013
javajdk1.8
                                    
            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。  
一.允许在接口中有默认方法实现 
        Java 8 允许我们使用default关键字，为接口声明添
    
                                
    • 
                                
  • Oracle表维护 快速备份删除数据
                                    cuisuqiang
oracle索引快速备份删除
                                    
    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。 
当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。 
为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。 
为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    
                                
    • 
                                
  • java多态内存分析
                                    麦田的设计者
java内存分析多态原理接口和抽象类
                                    
          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。 
      但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    
                                
    • 
                                
  • Xshell实现Windows上传文件到Linux主机
                                    被触发
windows
                                    
    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛； 
我是怎么操作的： 
1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    
                                
    • 
                                
  • 类的加载ClassLoader
                                    肆无忌惮_
ClassLoader
                                    
    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。 
  
其中重要的方法为findClass(String name)。 
  
如何写一个自己的类加载器呢？ 
首先写一个便于测试的类Student
    
                                
    • 
                                
  • html5写的玫瑰花
                                    知了ing
html5
                                    
    <html>  
<head>  
<title>I Love You!</title>  
<meta charset="utf-8" />  
</head>  
<body>  
<canvas id="c"></canvas>  

    
                                
    • 
                                
  • google的ConcurrentLinkedHashmap源代码解析
                                    矮蛋蛋
LRU
                                    
    原文地址： 
http://janeky.iteye.com/blog/1534352 
简述 
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对 
 
ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见 
 
http://code.google.com/p/concurrentlinke
    
                                
    • 
                                
  • webservice获取访问服务的ip地址
                                    alleni123
webservice
                                    
    1. 首先注入javax.xml.ws.WebServiceContext, 
@Resource 
 private WebServiceContext context; 
 
 
2. 在方法中获取交换请求的对象。 
 
 
javax.xml.ws.handler.MessageContext mc=context.getMessageContext();
com.sun.net.http
    
                                
    • 
                                
  • 菜鸟的java基础提升之道——————>是否值得拥有
                                    百合不是茶

                                    
    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员 
  
  
 java组成：
    
                                
    • 
                                
  • 通过修改Linux服务自动启动指定应用程序
                                    bijian1013
linux
                                    
    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下:  chkconfig

功能说明：检查，设置系统的各种服务。

语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    
                                
    • 
                                
  • spring拦截器的一个简单实例
                                    bijian1013
javaspring拦截器Interceptor
                                    
    Purview接口 
package aop;

public interface Purview {
    void checkLogin();
} 
Purview接口的实现类PurviesImpl.java 
package aop;

public class PurviewImpl implements Purview {
	
    public void check
    
                                
    • 
                                
  • [Velocity二]自定义Velocity指令
                                    bit1129
velocity
                                    
    什么是Velocity指令 
在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令 
  自定义指令(Directive)的一般步骤 
&nbs
    
                                
    • 
                                
  • 【Hive十】Programming Hive学习笔记
                                    bit1129
programming
                                    
     第二章 Getting Started 
1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    
                                
    • 
                                
  • nginx有选择性进行限制
                                    ronin47
nginx 动静　限制
                                    
    http {
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;...

    server {...
       location ~.*\.(gif|png|css|js|icon)$ {
   
    
                                
    • 
                                
  • java-4.-在二元树中找出和为某一值的所有路径 .
                                    bylijinnan
java
                                    
    
/*
	 * 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it.
	 * 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise

    
                                
    • 
                                
  • Netty学习笔记
                                    bylijinnan
javanetty
                                    
    本文是阅读以下两篇文章时： 
 
http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html 
 
http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html 
我的一些笔记 
 
===
    
                                
    • 
                                
  • js获取项目路径
                                    cngolon
js
                                    
    //js获取项目根路径，如： http://localhost:8083/uimcardprj 
function getRootPath(){ 
    //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp 
    var curWwwPath=window.document.locati
    
                                
    • 
                                
  • oracle 的性能优化
                                    cuishikuan
oracleSQL Server
                                    
       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。 
    1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    
                                
    • 
                                
  • Shell变量和数组使用详解
                                    daizj
linuxshell变量数组
                                    
    Shell 变量 
定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如： 
your_name="w3cschool.cc" 
注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则： 
 
 首个字符必须为字母（a-z，A-Z）。 
 中间不能有空格，可以使用下划线（_）。 
 不能使用标点符号。 
 不能使用ba
    
                                
    • 
                                
  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST
                                    dcj3sjt126com
REST
                                    
    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    
                                
    • 
                                
  • [Android]设置Activity为全屏显示的两种方法
                                    dcj3sjt126com
Activity
                                    
    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    
                                
    • 
                                
  • solrcloud 部署方式比较
                                    eksliang
solrCloud
                                    
    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理 
  
谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    
                                
    • 
                                
  • Java synchronized关键字详解
                                    gqdy365
synchronized
                                    
    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html 
 
多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。 
同步机制可以使用synchronized关键字实现。 
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。 
当s
    
                                
    • 
                                
  • js实现登录时记住用户名
                                    hw1287789687
记住我记住密码cookie记住用户名记住账号
                                    
    在页面中如何获取cookie值呢? 
如果是JSP的话,可以通过servlet的对象request 获取cookie,可以 
参考:http://hw1287789687.iteye.com/blog/2050040 
如果要求登录页面是html呢?html页面中如何获取cookie呢? 
直接上代码了 
页面:loginInput.html 
代码: 
<!DOCTYPE html PUB
    
                                
    • 
                                
  • 开发者必备的 Chrome 扩展
                                    justjavac
chrome
                                    
    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench 
ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    
                                
    • 
                                
  • 算法机试题
                                    李亚飞
java算法机试题
                                    
           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。 
       这道题大致意思是：输入一个数，比如4,。这时会输出： 
          &n
    
                                
    • 
                                
  • 正确配置Linux系统ulimit值
                                    字符串
ulimit
                                    
    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    
                                
    • 
                                
  • hibernate调用返回游标的存储过程
                                    Supanccy2013
javaDAOoracleHibernatejdbc
                                    
    注：原创作品，转载请注明出处。 
 
 
    上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。 
    此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。 
 
1，创建oracle中的包，并在该包中创建的游标类型。 
 
---创建oracle的程
    
                                
    • 
                                
  • Spring 4.2新特性-更简单的Application Event
                                    wiselyman
application
                                    
    1.1 Application Event 
 
  Spring 4.1的写法请参考10点睛Spring4.1-Application Event  
  请对比10点睛Spring4.1-Application Event  
  使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低;  
  
1.2 示例 
 
 包依赖 
  
<p
    
                                
    •