HTTP4.5.9工具类/时间工具类

HTTP4.5.9工具类

package com.xinyunfu.utils;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * @author XRZ
 * @date 2019/8/15
 * @Description :
 */
public class HttpClientUtils {

    public static String doGet(String url) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        String result = "";
        try {
            // 通过址默认配置创建一个httpClient实例
            httpClient = HttpClients.createDefault();
            // 创建httpGet远程连接实例
            HttpGet httpGet = new HttpGet(url);
            // 设置请求头信息，鉴权
            httpGet.setHeader("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // 设置配置请求参数
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 连接主机服务超时时间
                    .setConnectionRequestTimeout(35000)// 请求超时时间
                    .setSocketTimeout(60000)// 数据读取超时时间
                    .build();
            // 为httpGet实例设置配置
            httpGet.setConfig(requestConfig);
            // 执行get请求得到返回对象
            response = httpClient.execute(httpGet);
            // 通过返回对象获取返回数据
            HttpEntity entity = response.getEntity();
            // 通过EntityUtils中的toString方法将结果转换为字符串
            result = EntityUtils.toString(entity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    public static String doPost(String url, Map<String, Object> paramMap) {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse httpResponse = null;
        String result = "";
        // 创建httpClient实例
        httpClient = HttpClients.createDefault();
        // 创建httpPost远程连接实例
        HttpPost httpPost = new HttpPost(url);
        // 配置请求参数实例
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(35000)// 设置连接主机服务超时时间
                .setConnectionRequestTimeout(35000)// 设置连接请求超时时间
                .setSocketTimeout(60000)// 设置读取数据连接超时时间
                .build();
        // 为httpPost实例设置配置
        httpPost.setConfig(requestConfig);
        // 设置请求头
        httpPost.addHeader("Content-Type", "application/x-www-form-urlencoded");
        // 封装post请求参数
        if (null != paramMap && paramMap.size() > 0) {
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            // 通过map集成entrySet方法获取entity
            Set<Map.Entry<String, Object>> entrySet = paramMap.entrySet();
            // 循环遍历，获取迭代器
            Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Object> mapEntry = iterator.next();
                nvps.add(new BasicNameValuePair(mapEntry.getKey(), mapEntry.getValue().toString()));
            }

            // 为httpPost设置封装好的请求参数
            try {
                httpPost.setEntity(new UrlEncodedFormEntity(nvps, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        try {
            // httpClient对象执行post请求,并返回响应参数对象
            httpResponse = httpClient.execute(httpPost);
            // 从响应对象中获取响应内容
            HttpEntity entity = httpResponse.getEntity();
            result = EntityUtils.toString(entity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != httpResponse) {
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
}

时间工具类

package com.xinyunfu.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

/**
 * @author XRZ
 * @date 2019/7/8 0008
 * @Description : 时间工具类
 */
@Component
public class TimeUtils {

    /**
     * 未付款订单的限时 （12小时）
     */
    public static long ORDER_UNPAID;

    /**
     * 已取消订单自动删除的限时 （7天）
     */
    public static long ORDER_AUTO_DELETE;

    /**
     * 自动确认收货的限时 （7天）
     */
    public static long ORDER_AUTO_COMFIRM_GOODS;

    /**
     * 延迟释放券的时长 （15分钟）
     */
    public static long ORDER_RELEASE_COUPON;


    @Value("${order.unpaid}")
    public void setOrderUnpaid(long orderUnpaid) {
        ORDER_UNPAID = orderUnpaid;
    }
    @Value("${order.auto.delete}")
    public void setOrderAutoDelete(long orderAutoDelete) {
        ORDER_AUTO_DELETE = orderAutoDelete;
    }
    @Value("${order.auto.comfirmGoods}")
    public void setOrderAutoComfirmGoods(long orderAutoComfirmGoods) { ORDER_AUTO_COMFIRM_GOODS = orderAutoComfirmGoods; }
//    @Value("${order.releaseCoupon}")
//    public void setOrderReleaseCoupon(long orderReleaseCoupon) {
//        ORDER_RELEASE_COUPON = orderReleaseCoupon;
//    }

    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    /**
     * 获取1年后的日期
     * @return
     */
    public static String getNextTime(){
        return LocalDateTime.now().minusYears(-1).format(formatter);
    }
    /**
     * 获取指定 毫秒数 后的时间
     * @return  yyyy-MM-dd HH:mm:ss
     */
    public static String payTimeOut(long s){
        return LocalDateTime.now().minusSeconds(-(s/1000)).format(formatter2);
    }


    /**
     * 获取当前时间
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String getDate(){
        return sdf.format(new Date());
    }

    /**
     * 获取指定日期时间
     * @param timestamp
     * @return yyyy-MM-dd
     */
    public static String getStr(Timestamp timestamp){
        return sdf2.format(new Date(timestamp.getTime()));
    }

    /**
     * 获取指定日期时间
     * @param timestamp
     * @return yyyy-MM-dd HH:mm:sss
     */
    public static String getStr2(Timestamp timestamp){
        return sdf.format(new Date(timestamp.getTime()));
    }

    /**
     * 获取剩余时间
     *
     *          未来时间 = 下单时间 + 限时时间
     *          剩余时间 = 未来时间 - 当前时间
     *
     * @param timeLimit 限时时间
     * @param startTime 下单时间/发货时间
     * @return 剩余时间 （XX天XX分XX秒）
     */
    public static String getStrTime(long timeLimit,long startTime){
        //  未来时间 = 当前时间 + 限时时间
        long time = startTime + timeLimit;
        return getStrDateTime(time,System.currentTimeMillis());
    }

    /**
     * 0天0小时15分钟30秒
     * @param after  未来时间
     * @param before 过去时间
     * @return 0天0小时15分钟30秒
     */
    private  static String getStrDateTime(long after,long before) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        long ns = 1000;
        long diff = after - before;
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
         long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟" + sec + "秒";
    }



}