【编程开发】之 Java 开发常用工具 Utils 类

比眉伴天荒 2022-12-16 06:20 197阅读 0赞

## 目录 ##

*  JWT 工具类 JwtUtils
 *  MD5 工具类 MD5Utils
 *  HTTP 请求工具类 HttpClientUtils
 *  随机数工具类 RandomUtils

### JWT 工具类 JwtUtils ###

依赖：

<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.7.0</version>
    </dependency>

工具类文件：JwtUtils.java

import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.Jws;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import org.springframework.util.StringUtils;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Date;
    
    /** * @author 王廷云 * @since 2020/08/16 */
    public class JwtUtils { 
    
        //常量
        public static final long EXPIRE = 1000 * 60 * 60 * 24; //token过期时间
        public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWus2jZWLPHO"; //秘钥
    
        //生成token字符串的方法
        public static String getJwtToken(String id, String nickname){ 
    
            String JwtToken = Jwts.builder()
                    .setHeaderParam("typ", "JWT")
                    .setHeaderParam("alg", "HS256")
    
                    .setSubject("edushop-user")
                    .setIssuedAt(new Date())
                    .setExpiration(new Date(System.currentTimeMillis() + EXPIRE))
    
                    .claim("id", id)  //设置token主体部分 ，存储用户信息
                    .claim("nickname", nickname)
    
                    .signWith(SignatureAlgorithm.HS256, APP_SECRET)
                    .compact();
    
            return JwtToken;
        }
    
        /** * 判断token是否存在与有效 * @param jwtToken * @return */
        public static boolean checkToken(String jwtToken) { 
            if(StringUtils.isEmpty(jwtToken)) return false;
            try { 
                Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
            return true;
        }
    
        /** * 判断token是否存在与有效 * @param request * @return */
        public static boolean checkToken(HttpServletRequest request) { 
            try { 
                String jwtToken = request.getHeader("token");
                if(StringUtils.isEmpty(jwtToken)) return false;
                Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
            return true;
        }
    
        /** * 根据token字符串获取会员id * @param request * @return */
        public static String getMemberIdByJwtToken(HttpServletRequest request) { 
            String jwtToken = request.getHeader("token");
            if(StringUtils.isEmpty(jwtToken)) return "";
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(APP_SECRET).parseClaimsJws(jwtToken);
            Claims claims = claimsJws.getBody();
            return (String)claims.get("id");
        }
    }

### MD5 工具类 MD5Utils.java ###

import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class MD5Utils { 
    
        public static String encrypt(String strSrc) { 
            try { 
                char hexChars[] = {  '0', '1', '2', '3', '4', '5', '6', '7', '8',
                        '9', 'a', 'b', 'c', 'd', 'e', 'f' };
                byte[] bytes = strSrc.getBytes();
                MessageDigest md = MessageDigest.getInstance("MD5");
                md.update(bytes);
                bytes = md.digest();
                int j = bytes.length;
                char[] chars = new char[j * 2];
                int k = 0;
                for (int i = 0; i < bytes.length; i++) { 
                    byte b = bytes[i];
                    chars[k++] = hexChars[b >>> 4 & 0xf];
                    chars[k++] = hexChars[b & 0xf];
                }
                return new String(chars);
            } catch (NoSuchAlgorithmException e) { 
                e.printStackTrace();
                throw new RuntimeException("MD5加密出错！！+" + e);
            }
        }
    
        public static void main(String[] args) { 
            System.out.println(encrypt("123456"));
        }
    }

### HTTP 请求工具类 HttpClientUtils ###

依赖：

<dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.1</version>
    </dependency>
    
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.6</version>
    </dependency>

工具类文件：HttpClientUtils.java

import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.http.Consts;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpResponse;
    import org.apache.http.NameValuePair;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.config.RequestConfig.Builder;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.conn.ConnectTimeoutException;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLContextBuilder;
    import org.apache.http.conn.ssl.TrustStrategy;
    import org.apache.http.conn.ssl.X509HostnameVerifier;
    import org.apache.http.entity.ContentType;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.apache.http.message.BasicNameValuePair;
    
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLException;
    import javax.net.ssl.SSLSession;
    import javax.net.ssl.SSLSocket;
    import java.io.IOException;
    import java.net.SocketTimeoutException;
    import java.security.GeneralSecurityException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    /** * 依赖的jar包有：commons-lang-2.6.jar、httpclient-4.3.2.jar、httpcore-4.3.1.jar、commons-io-2.4.jar */
    public class HttpClientUtils { 
    
        public static final int connTimeout=10000;
        public static final int readTimeout=10000;
        public static final String charset="UTF-8";
        private static HttpClient client = null;
    
        static { 
            PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
            cm.setMaxTotal(128);
            cm.setDefaultMaxPerRoute(128);
            client = HttpClients.custom().setConnectionManager(cm).build();
        }
    
        public static String postParameters(String url, String parameterStr) throws ConnectTimeoutException, SocketTimeoutException, Exception{ 
            return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
        }
    
        public static String postParameters(String url, String parameterStr,String charset, Integer connTimeout, Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception{ 
            return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
        }
    
        public static String postParameters(String url, Map<String, String> params) throws ConnectTimeoutException,
                SocketTimeoutException, Exception { 
            return postForm(url, params, null, connTimeout, readTimeout);
        }
    
        public static String postParameters(String url, Map<String, String> params, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
                SocketTimeoutException, Exception { 
            return postForm(url, params, null, connTimeout, readTimeout);
        }
    
        public static String get(String url) throws Exception { 
            return get(url, charset, null, null);
        }
    
        public static String get(String url, String charset) throws Exception { 
            return get(url, charset, connTimeout, readTimeout);
        }
    
        /** * 发送一个 Post 请求, 使用指定的字符集编码. * * @param url * @param body RequestBody * @param mimeType 例如 application/xml "application/x-www-form-urlencoded" a=1&b=2&c=3 * @param charset 编码 * @param connTimeout 建立链接超时时间,毫秒. * @param readTimeout 响应超时时间,毫秒. * @return ResponseBody, 使用指定的字符集编码. * @throws ConnectTimeoutException 建立链接超时异常 * @throws SocketTimeoutException 响应超时 * @throws Exception */
        public static String post(String url, String body, String mimeType,String charset, Integer connTimeout, Integer readTimeout)
                throws ConnectTimeoutException, SocketTimeoutException, Exception { 
            HttpClient client = null;
            HttpPost post = new HttpPost(url);
            String result = "";
            try { 
                if (StringUtils.isNotBlank(body)) { 
                    HttpEntity entity = new StringEntity(body, ContentType.create(mimeType, charset));
                    post.setEntity(entity);
                }
                // 设置参数
                Builder customReqConf = RequestConfig.custom();
                if (connTimeout != null) { 
                    customReqConf.setConnectTimeout(connTimeout);
                }
                if (readTimeout != null) { 
                    customReqConf.setSocketTimeout(readTimeout);
                }
                post.setConfig(customReqConf.build());
    
                HttpResponse res;
                if (url.startsWith("https")) { 
                    // 执行 Https 请求.
                    client = createSSLInsecureClient();
                    res = client.execute(post);
                } else { 
                    // 执行 Http 请求.
                    client = HttpClientUtils.client;
                    res = client.execute(post);
                }
                result = IOUtils.toString(res.getEntity().getContent(), charset);
            } finally { 
                post.releaseConnection();
                if (url.startsWith("https") && client != null&& client instanceof CloseableHttpClient) { 
                    ((CloseableHttpClient) client).close();
                }
            }
            return result;
        }
    
    
        /** * 提交form表单 * * @param url * @param params * @param connTimeout * @param readTimeout * @return * @throws ConnectTimeoutException * @throws SocketTimeoutException * @throws Exception */
        public static String postForm(String url, Map<String, String> params, Map<String, String> headers, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
                SocketTimeoutException, Exception { 
    
            HttpClient client = null;
            HttpPost post = new HttpPost(url);
            try { 
                if (params != null && !params.isEmpty()) { 
                    List<NameValuePair> formParams = new ArrayList<NameValuePair>();
                    Set<Entry<String, String>> entrySet = params.entrySet();
                    for (Entry<String, String> entry : entrySet) { 
                        formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                    }
                    UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
                    post.setEntity(entity);
                }
    
                if (headers != null && !headers.isEmpty()) { 
                    for (Entry<String, String> entry : headers.entrySet()) { 
                        post.addHeader(entry.getKey(), entry.getValue());
                    }
                }
                // 设置参数
                Builder customReqConf = RequestConfig.custom();
                if (connTimeout != null) { 
                    customReqConf.setConnectTimeout(connTimeout);
                }
                if (readTimeout != null) { 
                    customReqConf.setSocketTimeout(readTimeout);
                }
                post.setConfig(customReqConf.build());
                HttpResponse res = null;
                if (url.startsWith("https")) { 
                    // 执行 Https 请求.
                    client = createSSLInsecureClient();
                    res = client.execute(post);
                } else { 
                    // 执行 Http 请求.
                    client = HttpClientUtils.client;
                    res = client.execute(post);
                }
                return IOUtils.toString(res.getEntity().getContent(), "UTF-8");
            } finally { 
                post.releaseConnection();
                if (url.startsWith("https") && client != null
                        && client instanceof CloseableHttpClient) { 
                    ((CloseableHttpClient) client).close();
                }
            }
        }
    
    
    
    
        /** * 发送一个 GET 请求 * * @param url * @param charset * @param connTimeout 建立链接超时时间,毫秒. * @param readTimeout 响应超时时间,毫秒. * @return * @throws ConnectTimeoutException 建立链接超时 * @throws SocketTimeoutException 响应超时 * @throws Exception */
        public static String get(String url, String charset, Integer connTimeout,Integer readTimeout)
                throws ConnectTimeoutException,SocketTimeoutException, Exception { 
    
            HttpClient client = null;
            HttpGet get = new HttpGet(url);
            String result = "";
            try { 
                // 设置参数
                Builder customReqConf = RequestConfig.custom();
                if (connTimeout != null) { 
                    customReqConf.setConnectTimeout(connTimeout);
                }
                if (readTimeout != null) { 
                    customReqConf.setSocketTimeout(readTimeout);
                }
                get.setConfig(customReqConf.build());
    
                HttpResponse res = null;
    
                if (url.startsWith("https")) { 
                    // 执行 Https 请求.
                    client = createSSLInsecureClient();
                    res = client.execute(get);
                } else { 
                    // 执行 Http 请求.
                    client = HttpClientUtils.client;
                    res = client.execute(get);
                }
    
                result = IOUtils.toString(res.getEntity().getContent(), charset);
            } finally { 
                get.releaseConnection();
                if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) { 
                    ((CloseableHttpClient) client).close();
                }
            }
            return result;
        }
    
    
        /** * 从 response 里获取 charset * * @param ressponse * @return */
        @SuppressWarnings("unused")
        private static String getCharsetFromResponse(HttpResponse ressponse) { 
            // Content-Type:text/html; charset=GBK
            if (ressponse.getEntity() != null  && ressponse.getEntity().getContentType() != null && ressponse.getEntity().getContentType().getValue() != null) { 
                String contentType = ressponse.getEntity().getContentType().getValue();
                if (contentType.contains("charset=")) { 
                    return contentType.substring(contentType.indexOf("charset=") + 8);
                }
            }
            return null;
        }
    
    
    
        /** * 创建 SSL连接 * @return * @throws GeneralSecurityException */
        private static CloseableHttpClient createSSLInsecureClient() throws GeneralSecurityException { 
            try { 
                SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() { 
                    public boolean isTrusted(X509Certificate[] chain,String authType) throws CertificateException { 
                        return true;
                    }
                }).build();
    
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() { 
    
                    @Override
                    public boolean verify(String arg0, SSLSession arg1) { 
                        return true;
                    }
    
                    @Override
                    public void verify(String host, SSLSocket ssl)
                            throws IOException { 
                    }
    
                    @Override
                    public void verify(String host, X509Certificate cert)
                            throws SSLException { 
                    }
    
                    @Override
                    public void verify(String host, String[] cns,
                                       String[] subjectAlts) throws SSLException { 
                    }
    
                });
    
                return HttpClients.custom().setSSLSocketFactory(sslsf).build();
    
            } catch (GeneralSecurityException e) { 
                throw e;
            }
        }
    
        public static void main(String[] args) { 
            try { 
                String str= post("https://localhost:443/ssl/test.shtml","name=12&page=34","application/x-www-form-urlencoded", "UTF-8", 10000, 10000);
                //String str= get("https://localhost:443/ssl/test.shtml?name=12&page=34","GBK");
                /*Map<String,String> map = new HashMap<String,String>(); map.put("name", "111"); map.put("page", "222"); String str= postForm("https://localhost:443/ssl/test.shtml",map,null, 10000, 10000);*/
                System.out.println(str);
            } catch (ConnectTimeoutException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SocketTimeoutException e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (Exception e) { 
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    
    }

### 随机数工具类 RandomUtils ###

import java.text.DecimalFormat;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Random;
    
    /** * 获取随机数 * * @author 王廷云 * */
    public class RandomUtils { 
    
        private static final Random random = new Random();
    
        private static final DecimalFormat fourdf = new DecimalFormat("0000");
    
        private static final DecimalFormat sixdf = new DecimalFormat("000000");
    
        public static String getFourBitRandom() { 
            return fourdf.format(random.nextInt(10000));
        }
    
        public static String getSixBitRandom() { 
            return sixdf.format(random.nextInt(1000000));
        }
    
        /** * 给定数组，抽取n个数据 * @param list * @param n * @return */
        public static ArrayList getRandom(List list, int n) { 
    
            Random random = new Random();
    
            HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
    
            // 生成随机数字并存入HashMap
            for (int i = 0; i < list.size(); i++) { 
    
                int number = random.nextInt(100) + 1;
    
                hashMap.put(number, i);
            }
    
            // 从HashMap导入数组
            Object[] robjs = hashMap.values().toArray();
    
            ArrayList r = new ArrayList();
    
            // 遍历数组并打印数据
            for (int i = 0; i < n; i++) { 
                r.add(list.get((int) robjs[i]));
                System.out.print(list.get((int) robjs[i]) + "\t");
            }
            System.out.print("\n");
            return r;
        }
    }