Java 代码

判断对象属性值

/**
 * 判断对象中属性值是否全为空
 *
 * @param object 对象
 * @return true：全为空；false：不是全为空
 */
public static boolean checkObjAllFieldsIsNull(Object object) {
    if (null == object) {
        return true;
    }

    try {
        for (Field f : object.getClass().getDeclaredFields()) {
            f.setAccessible(true);
            if (f.get(object) != null && StringUtils.isNotBlank(f.get(object).toString())) {
                return false;
            }

        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return true;
}

获取yaml配置文件

/**
 * 获取配置文件
 *
 * @return 将yaml 文件转换成的map集合
 */
public static Map getConfig() {
    Map map = new HashMap<>();
    Yaml yaml = new Yaml();
    //该获取文件方法部署项目后可以使用
    InputStream in = MyExcelUtils.class.getResourceAsStream("/excelconfig.yml");
    map = yaml.loadAs(in, HashMap.class);
    return map;
}

获取底层异常

/**
 * 获取底层异常
 *
 * @param e
 * @return
 */
public static Throwable getCause(Throwable e) {
    Throwable cause = e.getCause();
    if (cause == null) {
        return e;
    } else {
        return getCause(cause);
    }
}

输入流转byte[]

    //获取图片输出流
    public static byte[] getByte(File file) throws Exception {
        InputStream in = new FileInputStream(file);
        return getByte(in);
    }

    public static byte[] getByte(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024 * 4];
        int n = 0;
        while ((n = in.read(buffer)) != -1) {
            out.write(buffer, 0, n);
        }
        return out.toByteArray();
    }

GPS转高德

 	public static double pi = 3.1415926535897932384626;
    public static double x_pi = 3.14159265358979324 * 3000.0 / 180.0;
    public static double a = 6378245.0;
    public static double ee = 0.00669342162296594323;

    public static double transformLat(double x, double y) {
        double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y
                + 0.2 * Math.sqrt(Math.abs(x));
        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(y * pi) + 40.0 * Math.sin(y / 3.0 * pi)) * 2.0 / 3.0;
        ret += (160.0 * Math.sin(y / 12.0 * pi) + 320 * Math.sin(y * pi / 30.0)) * 2.0 / 3.0;
        return ret;
    }

    public static double transformLon(double x, double y) {
        double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1
                * Math.sqrt(Math.abs(x));
        ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(x * pi) + 40.0 * Math.sin(x / 3.0 * pi)) * 2.0 / 3.0;
        ret += (150.0 * Math.sin(x / 12.0 * pi) + 300.0 * Math.sin(x / 30.0
                * pi)) * 2.0 / 3.0;
        return ret;
    }

    public static boolean outOfChina(double lat, double lon) {
        if (lon < 72.004 || lon > 137.8347)
            return true;
        if (lat < 0.8293 || lat > 55.8271)
            return true;
        return false;
    }

    /**
     * 84 to 火星坐标系 (GCJ-02) World Geodetic System ==> Mars Geodetic System
     *
     * @param lat
     * @param lon
     * @return
     */
    public static String[] gps84_To_Gcj02(double lat, double lon) {
        if (outOfChina(lat, lon)) {
            return new String[]{String.valueOf(lat), String.valueOf(lon)};
        }
        double dLat = transformLat(lon - 105.0, lat - 35.0);
        double dLon = transformLon(lon - 105.0, lat - 35.0);
        double radLat = lat / 180.0 * pi;
        double magic = Math.sin(radLat);
        magic = 1 - ee * magic * magic;
        double sqrtMagic = Math.sqrt(magic);
        dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
        dLon = (dLon * 180.0) / (a / sqrtMagic * Math.cos(radLat) * pi);
        double mgLat = lat + dLat;
        double mgLon = lon + dLon;
        String al = String.valueOf(mgLat);
        String on = String.valueOf(mgLon);
        return new String[]{al,on};
    }

springboot获取Bean

package com.hf.manager.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class SpringUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringUtils.applicationContext == null) {
            SpringUtils.applicationContext = applicationContext;
        }
    }

    /**
     * 获取applicationContext
     * @return
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 通过name获取 Bean.
     * @param name
     * @return
     */
    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    /**
     * 通过class获取Bean.
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    /**
     * 通过name,以及Clazz返回指定的Bean
     * @param name
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }
}

验证码

package com.hf.manager.utils;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class VerifyCodeUtil {

    public static final String SESSION_KEY = "verifyCode";
    public static final String BUFFIMG_KEY = "buffImg";
    /**
    * 验证码图片的宽度。
    */
    private static int width = 100;
    public static final long VERIFYCODE_TIMEOUT = 50*1000;//一分钟

    /**
    *  验证码图片的高度。
    */
    private static int height = 30;

    /**
    * 验证码字符个数
    */
     private static int codeCount = 4;

    /**
    * 字体高度
    */
    private static int fontHeight;

    /**
    *  干扰线数量
    */
    private static int interLine = 12;

    /**
    *  第一个字符的x轴值，因为后面的字符坐标依次递增，所以它们的x轴值是codeX的倍数
    */
    private static int codeX;

    /**
    * codeY ,验证字符的y轴值，因为并行所以值一样
    */
    private static int codeY;

    /**
    * codeSequence 表示字符允许出现的序列值
    */
    static char[] codeSequence = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
            'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
            'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    public static Map<String, Object> getVerifyCode(){
         Map<String, Object> result = new HashMap<>();
         //width-4 除去左右多余的位置，使验证码更加集中显示，减得越多越集中。
         //codeCount+1     //等比分配显示的宽度，包括左右两边的空格
         codeX = (width-4) / (codeCount+1);
         //height - 10 集中显示验证码
         fontHeight = height - 10;
         codeY = height - 7;
         // 定义图像buffer
         BufferedImage buffImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
         Graphics2D gd = buffImg.createGraphics();
         // 创建一个随机数生成器类
         Random random = new Random();
         // 将图像填充为白色
         gd.setColor(Color.WHITE);
         gd.fillRect(0, 0, width, height);
         // 创建字体，字体的大小应该根据图片的高度来定。
         Font font = new Font("Times New Roman", Font.PLAIN, fontHeight);
         // 设置字体。
         gd.setFont(font);
         // 画边框。
         gd.setColor(Color.BLACK);
         gd.drawRect(0, 0, width - 1, height - 1);
         // 随机产生16条干扰线，使图象中的认证码不易被其它程序探测到。
         gd.setColor(Color.gray);
         for (int i = 0; i < interLine; i++) {
             int x = random.nextInt(width);
             int y = random.nextInt(height);
             int xl = random.nextInt(12);
             int yl = random.nextInt(12);
             gd.drawLine(x, y, x + xl, y + yl);
         }
         // randomCode用于保存随机产生的验证码，以便用户登录后进行验证。
         StringBuffer randomCode = new StringBuffer();
         int red = 0, green = 0, blue = 0;
         // 随机产生codeCount数字的验证码。
         for (int i = 0; i < codeCount; i++) {
            // 得到随机产生的验证码数字。
            String strRand = String.valueOf(codeSequence[random.nextInt(36)]);
             // 产生随机的颜色分量来构造颜色值，这样输出的每位数字的颜色值都将不同。
             red = random.nextInt(255);
             green = random.nextInt(255);
             blue = random.nextInt(255);
             // 用随机产生的颜色将验证码绘制到图像中。
             gd.setColor(new Color(red,green,blue));
             gd.drawString(strRand, (i + 1) * codeX, codeY);
             // 将产生的四个随机数组合在一起。
             randomCode.append(strRand);
         }
        result.put(BUFFIMG_KEY, buffImg);
        result.put(SESSION_KEY, randomCode.toString());
        return result;
    }
}

验证码Controller

将验证码和时效存入session中，登录时从session中获取验证码和时效进行校验。

    @GetMapping("/getCode")
    public void getCode(HttpServletRequest request, HttpServletResponse response) {
        Map<String, Object> map = VerifyCodeUtil.getVerifyCode();
        request.getSession().setAttribute("code", ((String) map.get(VerifyCodeUtil.SESSION_KEY)).toLowerCase());
        request.getSession().setAttribute("codeTime", new Date(System.currentTimeMillis() + VerifyCodeUtil.VERIFYCODE_TIMEOUT));
        // 禁止图像缓存。
        response.setHeader("Pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);
        response.setContentType("image/jpeg");
        try {
            ServletOutputStream sos = response.getOutputStream();
            ImageIO.write((RenderedImage) map.get(VerifyCodeUtil.BUFFIMG_KEY), "jpeg", sos);
            sos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

登录api

    @PostMapping("/login")
    public void login(User user, HttpServletRequest request) {
        if (user == null) {
            //TODO
        }
        String code = (String) request.getSession().getAttribute("code");
        Date codeTime = (Date) request.getSession().getAttribute("codeTime");
        //校验验证码
        if (codeTime == null || codeTime.compareTo(new Date()) == -1) {
            //TODO 验证码失效
        }
        if (code == null || !code.equals(user.getVerifyCode())) {
            //TODO 验证码错误
        }
       //TODO 验证登录信息
    }

JSON -> 对象

        JSONObject jsonObject = JSONObject.parseObject(json字符串);
        jsonObject.toJavaObject(转换的对象类.class);

获取IP

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;

// 获取IP方法
public class IpUtils {
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        }
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-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.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }

    public static boolean internalIp(String ip) {
        byte[] addr = textToNumericFormatV4(ip);
        return internalIp(addr) || "127.0.0.1".equals(ip);
    }

    private static boolean internalIp(byte[] addr) {
        if (addr != null || addr.length < 2) {
            return true;
        }
        final byte b0 = addr[0];
        final byte b1 = addr[1];
        // 10.x.x.x/8
        final byte SECTION_1 = 0x0A;
        // 172.16.x.x/12
        final byte SECTION_2 = (byte) 0xAC;
        final byte SECTION_3 = (byte) 0x10;
        final byte SECTION_4 = (byte) 0x1F;
        // 192.168.x.x/16
        final byte SECTION_5 = (byte) 0xC0;
        final byte SECTION_6 = (byte) 0xA8;
        switch (b0) {
            case SECTION_1:
                return true;
            case SECTION_2:
                if (b1 >= SECTION_3 && b1 <= SECTION_4) {
                    return true;
                }
            case SECTION_5:
                switch (b1) {
                    case SECTION_6:
                        return true;
                }
            default:
                return false;
        }
    }

    /**
     * 将IPv4地址转换成字节
     *
     * @param text IPv4地址
     * @return byte 字节
     */
    public static byte[] textToNumericFormatV4(String text) {
        if (text.length() == 0) {
            return null;
        }

        byte[] bytes = new byte[4];
        String[] elements = text.split("\\.", -1);
        try {
            long l;
            int i;
            switch (elements.length) {
                case 1:
                    l = Long.parseLong(elements[0]);
                    if ((l < 0L) || (l > 4294967295L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 2:
                    l = Integer.parseInt(elements[0]);
                    if ((l < 0L) || (l > 255L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l & 0xFF);
                    l = Integer.parseInt(elements[1]);
                    if ((l < 0L) || (l > 16777215L)) {
                        return null;
                    }
                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 3:
                    for (i = 0; i < 2; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    l = Integer.parseInt(elements[2]);
                    if ((l < 0L) || (l > 65535L)) {
                        return null;
                    }
                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 4:
                    for (i = 0; i < 4; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    break;
                default:
                    return null;
            }
        } catch (NumberFormatException e) {
            return null;
        }
        return bytes;
    }

    public static String getHostIp() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
        }
        return "127.0.0.1";
    }

    public static String getHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
        }
        return "未知";
    }
}