分类 Java 下的文章

Java 工具类将一个类中的值通过setter和getter传递给另一个类型public static <T> T entityToDto(Object entity, Class<T> dtoType) { T instance; try { instance = dtoType.getDeclaredConstructor().newInstance(); } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { throw new RuntimeException(e); } // 反射entity 获取getter Class<?> entryType = entity.getClass(); Arrays.stream(dtoType.getMethods()).filter( method -> method.getName().startsWith("set") ).forEach(method -> { String methodName = method.getName().replace("set", "get"); try { Object value = entryType.getMethod(methodName).invoke(entity); method.invoke(instance, value); } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ignore) {} }); return instance; }

2022年05月12日
105 阅读
0 评论
1 点赞

2020-05-28

2020年05月28日
271 阅读
4 评论
1 点赞

2020-04-07

Steam第三方登陆来源申明：https://weibo.com/p/1001603922680121320645生成跳转到Steam登录页面的源码开始//Steam使用openid登录的网址 final static String STEAM_LOGIN = "https://steamcommunity.com/openid/login"; public static String getUrl(String returnTo) throws UnsupportedEncodingException { Map<String, String> params = new HashMap<String, String>(); params = new HashMap<String, String>(); params.put("openid.ns", "//specs.openid.net/auth/2.0"); params.put("openid.mode", "checkid_setup"); //登陆成功后要返回url，值得一说的是这个url是可以携带参数的 params.put("openid.return_to", returnTo); //realm的中文解释是领域与范围，我想大概就是你网站域名，授权用户登录你域名下的应用，我这里默认就用传过来的returnTo了 params.put("openid.realm", returnTo); params.put("openid.identity", "//specs.openid.net/auth/2.0/identifier_select"); params.put("openid.claimed_id", "//specs.openid.net/auth/2.0/identifier_select"); return STEAM_LOGIN + "?" + SteamLoginUtil.getUrlParamsByMap(params); } /** * 将url中传递参数转化为map 其中值进行encode * * @param param * aa=11&bb=22&cc=33 * @return * @throws UnsupportedEncodingException */ public static Map<String, String> getUrlParams(String param) throws UnsupportedEncodingException { Map<String, String> map = new HashMap<String, String>(0); if (StringUtils.isBlank(param)) { return map; } String[] params = param.split("&"); for (int i = 0; i < params.length; i++) { String[] p = params[ i ].split("="); if (p.length == 2) { map.put(p[0], URLDecoder.decode(p[ 1 ],"UTF-8")); } } return map; }生成跳转到Steam登录页面的源码结束OK，用上述的代码，传入一个returnTo的参数，就生成一串URL。浏览器打开这个URL就能看见类似如下的画面表明Steam可以授权给你登录，只要用户登录成功，steam就会跳转到你设置的returnTo地址，并且携带一大波参数。虽然返回给你了这些参数，用户还不能立即得到登录授权，为什么呢（如果我现在直接给你授权，我返回给你的参数都是明文的，那岂不是任何一个人都能伪造出这么一串参数来登录你的系统，你咋能放心呢）。其实这个时候openid的机制已经记住了这个用户要登录你的系统，但是你的系统还要确认一下，跟openID说这个用户确实是从我这里发出来的登录请求，我请求你允许他登录我的系统。怎样“请求你~允许他~登录我的系统”呢？这里用了HttpClient去请求openid的提供者。这个过程用户是看不到的，透明的。就相当于你的网站和openid提供者说了句悄悄话。说的就是“请求你~允许他~登录我的系统”。而openid的提供者一查，这用户刚才亮出了身份，确实跟我过说要登录你的系统，OK给你俩授权。你俩自己聊去吧！过程是这样，代码在这里。HttpClient授权验证代码/** * 将steam返回的request参数再次提交steam进行授权，检查是否成功登录，返回steamid算成功，返回空字符串为不成功 * * @param request * @return boolean * @throws ClientProtocolException * @throws IOException */ public static String validate(Map<String,String> request) throws ClientProtocolException, IOException{ //openid.signed这里面的参数用是“，”号隔开的，是提示你返回了哪些参数 Object signed = request.get("openid.signed"); //如果没有openid.signed，那肯定这个请求是不正确的直接跳出即可 if(signed ==null || "".equals(signed)){ return ""; } //此处开始构造HttpClient对象，配置参数，设置访问方法，获取返回值等，进行一次完整访问 HttpClient httpclient = HttpClients.createDefault(); HttpPost httppost = new HttpPost(STEAM_LOGIN+"?"+SteamLoginUtil.getUrlParamsByMap(request)); List<NameValuePair> nvps = new ArrayList<NameValuePair>(); String[] signeds = signed.toString().split(","); for(int i=0;i<signeds.length;i++){ String val = request.get("openid."+signeds[ i ]); nvps.add(new BasicNameValuePair("openid."+signeds[ i ], val==null?"":val)); } nvps.add(new BasicNameValuePair("openid.mode", "check_authentication")); httppost.setEntity(new UrlEncodedFormEntity(nvps)); HttpResponse response = httpclient.execute(httppost); HttpEntity entity = response.getEntity(); if (entity == null) { return ""; } InputStream instreams = entity.getContent(); String result = SteamLoginUtil.convertStreamToString(instreams); //System.out.println("Do something"); System.out.println(result); // Do not need the rest httppost.abort(); //此处是为了将steamid截取出来 String steamid = ""; steamid = request.get("openid.claimed_id"); steamid = steamid.replace("//steamcommunity.com/openid/id/",""); //虽然steamid能从上一次请求参数中截取出来，我们还是要判断HttpClient返回来的消息是否授权了，判断方式是看字符串中是否含有“is_valid:true”，有就是授权成功了，如果没有，就是“is_valid:false”。 if(!result.contains("is_valid:true")){ return ""; } return steamid; } /** * 将输入流读取为一串字符串 * @param is * @return */ public static String convertStreamToString(InputStream is) { BufferedReader reader = new BufferedReader(new InputStreamReader(is)); StringBuilder sb = new StringBuilder(); String line = null; try { while ((line = reader.readLine()) != null) { sb.append(line + "\n"); } } catch (IOException e) { e.printStackTrace(); } finally { try { is.close(); } catch (IOException e) { e.printStackTrace(); } } return sb.toString(); }HttpClient授权验证代码结束验证成功消息如下图源码总结如下import java.util.HashMap; import java.util.Iterator; import java.util.Map.Entry; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; public class StringUtils { public static String parseWhereString (HashMap<String, Object> params,String alias){ StringBuffer buffer = new StringBuffer(); if(params == null || params.isEmpty()){ return ""; }else{ buffer.append(" where "); Set<Entry<String, Object>> set = params.entrySet(); Iterator<Entry<String, Object>> iterator = set.iterator(); Entry<String, Object> entry = null; while(iterator.hasNext()){ buffer.append(" and "); entry = iterator.next(); buffer.append(alias); if (!alias.equals("")) { buffer.append("."); } buffer.append(entry.getKey()); buffer.append("="); buffer.append(" ? "); entry = null; } iterator = null; String temp = buffer.toString(); int location = temp.indexOf("and"); buffer = new StringBuffer(); buffer.append(temp.substring(0, location)); buffer.append(temp.substring(location+4)); temp = null; return buffer.toString(); } } /** * 去掉开头结尾制定字符串 * @param stream * @param trimstr * @return */ public static String sideTrim(String stream, String trimstr) { // null或者空字符串的时候不处理 if (stream == null || stream.length() == 0 || trimstr == null || trimstr.length() == 0) { return stream; } // 结束位置 int epos = 0; // 正规表达式 String regpattern = "[" + trimstr + "]*+"; Pattern pattern = Pattern.compile(regpattern, Pattern.CASE_INSENSITIVE); // 去掉结尾的指定字符 StringBuffer buffer = new StringBuffer(stream).reverse(); Matcher matcher = pattern.matcher(buffer); if (matcher.lookingAt()) { epos = matcher.end(); stream = new StringBuffer(buffer.substring(epos)).reverse().toString(); } // 去掉开头的指定字符 matcher = pattern.matcher(stream); if (matcher.lookingAt()) { epos = matcher.end(); stream = stream.substring(epos); } // 返回处理后的字符串 return stream; } /** * Checks if a String is whitespace, empty ("") or null. * * <pre> * StringUtils.isBlank(null) = true * StringUtils.isBlank("") = true * StringUtils.isBlank(" ") = true * StringUtils.isBlank("bob") = false * StringUtils.isBlank(" bob ") = false * </pre> * * @param str the String to check, may be null * @return <code>true</code> if the String is null, empty or whitespace * @since 2.0 */ public static boolean isBlank(String str) { int strLen; if (str == null || (strLen = str.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)) == false)) { return false; } } return true; } /** * Gets the substring before the last occurrence of a separator. * The separator is not returned. * * A <code>null</code> string input will return <code>null</code>. * An empty ("") string input will return the empty string. * An empty or <code>null</code> separator will return the input string. * * <pre> * StringUtils.substringBeforeLast(null, *) = null * StringUtils.substringBeforeLast("", *) = "" * StringUtils.substringBeforeLast("abcba", "b") = "abc" * StringUtils.substringBeforeLast("abc", "c") = "ab" * StringUtils.substringBeforeLast("a", "a") = "" * StringUtils.substringBeforeLast("a", "z") = "a" * StringUtils.substringBeforeLast("a", null) = "a" * StringUtils.substringBeforeLast("a", "") = "a" * </pre> * * @param str the String to get a substring from, may be null * @param separator the String to search for, may be null * @return the substring before the last occurrence of the separator, * <code>null</code> if null String input * @since 2.0 */ public static String substringBeforeLast(String str, String separator) { if (isEmpty(str) || isEmpty(separator)) { return str; } int pos = str.lastIndexOf(separator); if (pos == -1) { return str; } return str.substring(0, pos); } // Empty checks //----------------------------------------------------------------------- /** * Checks if a String is empty ("") or null. * * <pre> * StringUtils.isEmpty(null) = true * StringUtils.isEmpty("") = true * StringUtils.isEmpty(" ") = false * StringUtils.isEmpty("bob") = false * StringUtils.isEmpty(" bob ") = false * </pre> * * NOTE: This method changed in Lang version 2.0. * It no longer trims the String. * That functionality is available in isBlank(). * * @param str the String to check, may be null * @return <code>true</code> if the String is empty or null */ public static boolean isEmpty(String str) { return str == null || str.length() == 0; } }import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; 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.HttpPost; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.message.BasicNameValuePair; public class SteamLoginUtil { final static String STEAM_LOGIN = "https://steamcommunity.com/openid/login"; /** * 接入steam登录url * * @param returnTo * @param request * @return * @throws UnsupportedEncodingException */ public static String getUrl(String returnTo) throws UnsupportedEncodingException { Map<String, String> params = new HashMap<String, String>(); params = new HashMap<String, String>(); // String loginTicket = request.getAttribute("loginTicket")==null ? "" : // "?lt="+ request.getAttribute("loginTicket").toString(); // params.put("lt", request.getAttribute("loginTicket")==null // ?"":request.getAttribute("loginTicket").toString()); params.put("openid.ns", "http://specs.openid.net/auth/2.0"); params.put("openid.mode", "checkid_setup"); params.put("openid.return_to", returnTo); params.put("openid.realm", returnTo); params.put("openid.identity", "http://specs.openid.net/auth/2.0/identifier_select"); params.put("openid.claimed_id", "http://specs.openid.net/auth/2.0/identifier_select"); return STEAM_LOGIN + "?" + SteamLoginUtil.getUrlParamsByMap(params); } /** * 将数据提交steam进行验证，是否成功登录 * * @param request * @return boolean * @throws ClientProtocolException * @throws IOException */ public static String validate(Map<String, String> request){ RequestConfig defaultRequestConfig = RequestConfig.custom() .setSocketTimeout(5000) .setConnectTimeout(5000) .setConnectionRequestTimeout(5000) .build(); CloseableHttpClient httpclient = null; HttpPost httppost = null; try { Object signed = request.get("openid.signed"); if (signed == null || "".equals(signed)) { return ""; } httpclient = HttpClients.createDefault(); httppost = new HttpPost(STEAM_LOGIN + "?" + SteamLoginUtil.getUrlParamsByMap(request)); httppost.setConfig(defaultRequestConfig); List<NameValuePair> nvps = new ArrayList<NameValuePair>(); String[] signeds = signed.toString().split(","); for (int i = 0; i < signeds.length; i++) { String val = request.get("openid." + signeds[i]); nvps.add(new BasicNameValuePair("openid." + signeds[i], val == null ? "" : val)); } nvps.add(new BasicNameValuePair("openid.mode", "check_authentication")); httppost.setEntity(new UrlEncodedFormEntity(nvps)); HttpResponse response = httpclient.execute(httppost); HttpEntity entity = response.getEntity(); if (entity == null) { return ""; } InputStream instreams = entity.getContent(); String result = SteamLoginUtil.convertStreamToString(instreams); // Do not need the rest httppost.abort(); String steamid = ""; steamid = request.get("openid.claimed_id"); steamid = steamid.replace("https://steamcommunity.com/openid/id/", ""); if (!result.contains("is_valid:true")) { return ""; } return steamid; } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ if(httppost != null){ httppost.releaseConnection(); } if(httpclient != null){ try { httpclient.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } return ""; } /** * 将url中传递参数转化为map 其中值进行encode * * @param param * aa=11&bb=22&cc=33 * @return * @throws UnsupportedEncodingException */ public static Map<String, String> getUrlParams(String param) throws UnsupportedEncodingException { Map<String, String> map = new HashMap<String, String>(0); if (StringUtils.isBlank(param)) { return map; } String[] params = param.split("&"); for (int i = 0; i < params.length; i++) { String[] p = params[i].split("="); if (p.length == 2) { map.put(p[0], URLDecoder.decode(p[1], "UTF-8")); } } return map; } /** * 将map转化为url可携带的参数字符串 * * @param map * @return * @throws UnsupportedEncodingException */ public static String getUrlParamsByMap(Map<String, String> map) throws UnsupportedEncodingException { if (map == null) { return ""; } StringBuffer sb = new StringBuffer(); for (Map.Entry<String, String> entry : map.entrySet()) { // 解码 sb.append(entry.getKey() + "=" + URLEncoder.encode(entry == null ? "" : entry.getValue(), "UTF-8")); sb.append("&"); } String s = sb.toString(); if (s.endsWith("&")) { s = StringUtils.substringBeforeLast(s, "&"); } return s; } public static String convertStreamToString(InputStream is) { BufferedReader reader = new BufferedReader(new InputStreamReader(is)); StringBuilder sb = new StringBuilder(); String line = null; try { while ((line = reader.readLine()) != null) { sb.append(line + "\n"); } } catch (IOException e) { e.printStackTrace(); } finally { try { is.close(); } catch (IOException e) { e.printStackTrace(); } } return sb.toString(); } }

2020年04月07日
209 阅读
0 评论
0 点赞

计算Map初始容量算法在实际开发中经常需要使用到Map，但给Map一个怎样的初始容量比较合理？众所周知是最接近(要大于)数据长度的2的N次方那么，如何计算？欢迎指出错误/** * 计算Map初始容量 * @author 枫铃也 * @since 2019-10-09 15:51 */ public class CapacityUtil { private static final double MODULE = 2; public static int getCapacityFactor(int size) { int n = size; int power = 0; while (n > 1) { power++; n >>>= 1; } int capacity = (int) Math.pow(MODULE, power); if (capacity < size || capacity % MODULE != 0) { capacity *= MODULE; } return capacity; } }欢迎指出错误

2019年10月11日
116 阅读
0 评论
1 点赞

2019-10-10

Java阿拉伯数字转中文数字带单位转换的我只将数字范围定在十万以内的正数并且没考虑 0需要向上调整范围的童鞋自己修改代码呦欢迎指出错误先看效果再看代码不多说屁话上代码/** * @description: 阿拉伯数字转中文数字(不带单位) * @method: numberConvertToBaseChinese * @author: 枫铃也 * @since: 2019-10-10 16:03 * * @return java.lang.String */ public static String numberConvertToBaseChinese(int num) { StringBuffer buffer = new StringBuffer(); char[] nums = {'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'}; char[] baseChar = Integer.toString(num).toCharArray(); for (char c : baseChar) { buffer.append(nums[c - 48]); } return buffer.toString(); } /** * @description: 阿拉伯数字转中文数字(带单位) * @method: numberConvertToChinese * @author: 枫铃也 * @since: 2019-10-10 16:03 * * @return java.lang.String */ public static String numberConvertToChinese(int num) { char[] nums = {'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'}; char[] units = {' ', '十', '百', '千', '万'}; char[] baseChar = Integer.toString(num).toCharArray(); char[] numChar = new char[baseChar.length]; for (int i = 0; i < baseChar.length; i++) { numChar[i] = nums[baseChar[i] - 48]; } char[] unit = new char[numChar.length]; unit = Arrays.copyOf(units, unit.length); StringBuffer buffer = new StringBuffer(); for (int i = 0; i < numChar.length; i++) { if (numChar[i] != nums[0]) { buffer.append(numChar[i]).append(unit[unit.length - i - 1]); }else { buffer.append(numChar[i]); } } int index = 0; while ((index = buffer.indexOf(nums[0] + String.valueOf(nums[0]))) > 0) { buffer.replace(index, index + 2, String.valueOf(nums[0])); } return buffer.toString().substring(0, buffer.length() - 1); }神马，没有注释？我故意的（此处拒绝板砖和拖鞋之类的具有任何杀伤性的物品），嘿嘿自己看懂了才算是有收获欢迎指出错误

2019年10月10日
49 阅读
0 评论
0 点赞

2019年10月09日
61 阅读
0 评论
0 点赞

Java 8 的一些集合操作将一个对象集合中的某一个字段取出来生成一个新的集合List<Store> storeList = storeService.listStore(page, size); List<Integer> collect = storeList.stream().map(s -> s.getStoreId()).collect(Collectors.toList()); //OR List<Integer> collect = storeList.stream().map(Store::getStoreId).collect(Collectors.toList());将List对象集合转化为key为对象ID的MapList<Specification> specifications = specificationService.listSpecification(); Map<Integer, Specification> collect = specifications.stream().collect(Collectors.toMap(Specification::getSpecificationId, Function.identity()));跟据某个属性分组Map<String, List<PersonData>> collect = list.stream().collect(Collectors.groupingBy(PersonData::getType));根据某个属性分组，汇总某个属性Map<String, Integer> collect2 = list.stream().collect(Collectors.groupingBy(PersonData::getType,Collectors.summingInt(PersonData::getAge)));根据某个属性添加条件过滤数据list = list.stream().filter(u -> !u.getType().equals("访客")).collect(Collectors.toList());判断一组对象里面有没有属性值是某个值boolean add = list.stream().anyMatch(m -> "王五".equals(m.getName()));

2019年10月02日
97 阅读
0 评论
0 点赞

日常开发规范注：基于SonarLint 官方网址： SonarLint特殊记录HashMap的大小应该为目标大小/加载因子且为2^n 向上取整HashMap默认的加载因子是0.75 .它在时间和空间成本上寻求了一种折中。如果只装载100个元素的HashMap没有特殊的用途，那么为了在时间和空间上达到最佳性能，HashMap的初始容量可以设为100/0.75 = 133.33。为了防止rehash，向上取整，为134。但是还有另外一个问题，就是hash碰撞的问题。如果我们将HashMap的容量设置为134，那么如何保证其中的哈希碰撞会比较少呢？除非重写hashcode()方法，否则，似乎没有办法保证。那么这里不得不提HashMap如何为元素选择下标的方法了。static int indexFor(int h, int length) { return h & (length-1); }其中h为key哈希后得到的值，length为哈希表的长度。 134-1 = 128 + 6 -1；那么 length-1的二进制值的最后3位为101；假设这100个装载的元素中他们的key在哈希后有得到两个值（h），他们的二进制值除了低3位之外都相同，而第一个值的低3位为011，第二个值的低3位为001；这时候进行java的&预算，011 & 101 = 001 ；001 & 101 = 001；他们的值相等了，那么这个时候就会发生哈希碰撞。除此之外还有一个更加严重的问题，由于在101中第二位是0，那么，无论我们的key在哈希运算之后得到的值h是什么，那么在&运算之后，得到的结果的倒数第二位均为0；因此，对于hash表所有下标的二进制的值而言，只要低位第二位的值为1，（例如0010,0011,0111,1111）那么这个下标所代表的桶将一直是空的，因为代码中的&运算的结果永远不会产生低位第二位为1的值。这就大大地浪费了空间，同时还增加了哈希碰撞的概率。这无疑会降低HashMap的效率。那么如何才能减少这种浪费呢？最佳的方法当然是让length-1的二进制值全部位均为1.那么length的值是多少合适呢？没错，length=2^n。只要将hash表的长度设为2的N次方，那么，所有的哈希桶均有被使用的可能。与134最靠近的2^n无疑是128。如果只修改HashMap的长度而不修改HashMap的加载因子的话，HashMap会进行rehash操作，这是一个代价很大的操作，所以不可取。那么应该选择的就应该是256。而由于空间加大和有效利用哈希桶，这时的哈希碰撞将大大降低，因此HashMap的读取效率会比较高。所以，最后结论就是：HashMap的大小应该设置为256。其实在Java中，无论你的HashMap(x)中的x设置为多少，HashMap的大小都是2^n。2^n是大于x的第一个数。因为HashMap的初始化代码中有以下这行代码：int capacity = 1; while (capacity < initialCapacity) capacity <<= 1;但是这就带来了一个问题，如果x=100，那么HashMap的初始大小应该是128.但是100/128=0.78，已经超过默认加载因子的大小了。因此会resize一次，变成256。所以最好的结果还是256。1. 字符串不应该在循环中使用'+'连接原：Strings are immutable objects, so concatenation doesn't simply add the new String to the end of the existing string. Instead, in each loop iteration, the first String is converted to an intermediate object type, the second string is appended, and then the intermediate object is converted back to a String. Further, performance of these intermediate operations degrades as the String gets longer. Therefore, the use of StringBuilder is preferred. 译：Sring是不可变的对象，所以在进行字符拼接的时候不只是将新的字符串添加到现有字符串的末尾。相反，在每个循环迭代中，先将第一个字符串转换为中间对象类型，再添加第二个字符串，然后将中间对象转换回字符串。此外，随着字符串变长，这些中间操作的性能会下降。因此，最好使用StringBuilder。//不规范代码示例 String str = ""; for (int i = 0; i < arrayOfStrings.length ; ++i) { str = str + arrayOfStrings[i]; } //规范代码示例 StringBuilder bld = new StringBuilder(); for (int i = 0; i < arrayOfStrings.length; ++i) { bld.append(arrayOfStrings[i]); } String str = bld.toString();拓展（1）String是Java的基础类，他可以定义少量的字符串（2）StringBuffer是对String的扩充，他可以拼接大量字符串，但是他的效率比较低，因为他是线程安全的（3）StringBuidder是对StringBuffer的拓展，他提高了效率，但是他是线程不安全的2. 不应该在打印输出或者是记录日志的时候进行运算原：Passing message arguments that require further evaluation into a Guava com.google.common.base.Preconditions check can result in a performance penalty. That's because whether or not they're needed, each argument must be resolved before the method is actually called. Similarly, passing concatenated strings into a logging method can also incur a needless performance hit because the concatenation will be performed every time the method is called, whether or not the log level is low enough to show the message. Instead, you should structure your code to pass static or pre-computed values into Preconditions conditions check and logging calls. Specifically, the built-in string formatting should be used instead of string concatenation, and if the message is the result of a method call, then Preconditions should be skipped altoghether, and the relevant exception should be conditionally thrown instead. 译：程序在调用方法之前，无论是否需要它们都将解析每一个参数并将需要进一步计算的消息参数传递到Guava 而com.google.common.base.Preconditions在检查中可能会导致性能损失。类似的，将连接的字符串传递到日志方法也会导致不必要的性能损失，因为每次调用该方法时都会执行运算或者拼接，无论日志级别是否低到足以显示消息。相反，应该构造代码，将静态值或预计算值传递到Preconditions条件检查和日志记录调用中。具体来说，应该使用内置的字符串格式而不是字符串连接，如果消息是方法调用的结果，则应该跳过先决条件altoghether，而应该有条件地抛出相关异常。//不规范代码示例 // 即使日志级别过高，无法显示调试消息，也会执行字符串连接 logger.log(Level.DEBUG, "Something went wrong: " + message); logger.fine("An exception occurred with message: " + message); LOG.error("Unable to open file " + csvPath, e); Preconditions.checkState(a > 0, "Arg must be positive, but got " + a); //即使使用了判断，可当a>0的时候依旧需要进行拼接 Preconditions.checkState(condition, formatMessage()); Preconditions.checkState(condition, "message: %s", formatMessage()); //规范代码示例 logger.log(Level.SEVERE, "Something went wrong: {0} ", message); // 只有在需要时才应用字符串格式 logger.fine("An exception occurred with message: {}", message); // SLF4J, Log4j logger.log(Level.SEVERE, () -> "Something went wrong: " + message); // 从 Java 8 开始，我们可以使用Supplier，因为它是懒加载的 LOG.error("Unable to open file {0}", csvPath, e); if (LOG.isDebugEnabled() { LOG.debug("Unable to open file " + csvPath, e); } Preconditions.checkState(arg > 0, "Arg must be positive, but got %d", a); if (!condition) { throw new IllegalStateException(formatMessage()); // formatMessage()方法只在条件下调用 } if (!condition) { throw new IllegalStateException("message: " + formatMessage()); }拓展（1）supplier也是是用来创建对象的，但是不同于传统的创建对象语法：new。每次调用get()方法时都会调用构造方法创建一个新对象，示例代码：public class TestSupplier { private int age; TestSupplier(){ System.out.println(age); } public static void main(String[] args) { //创建Supplier容器，声明为TestSupplier类型，此时并不会调用对象的构造方法，即不会创建对象 Supplier<TestSupplier> sup= TestSupplier::new; System.out.println("--------"); //调用get()方法，此时会调用对象的构造方法，即获得到真正对象 sup.get(); //每次get都会调用构造方法，即获取的对象不同 sup.get(); } }运行结果：-------- 0 03.应该使用日志记录异常信息原：Throwable.printStackTrace(...) prints a Throwable and its stack trace to some stream. By default that stream System.Err, which could inadvertently expose sensitive information. Loggers should be used instead to print Throwables, as they have many advantages: ● Users are able to easily retrieve the logs. ● The format of log messages is uniform and allow users to browse the logs easily. This rule raises an issue when printStackTrace is used without arguments, i.e. when the stack trace is printed to the default stream. 译：Throwable.printStackTrace（...）将Throwable及其堆栈跟踪信息打印到某些流。默认情况下，该流System.Err可能会无意间公开敏感信息。应该使用记录器来打印Throwable，因为它们具有许多优点： ● 用户能够轻松检索日志。 ● 日志消息的格式统一，并且允许用户轻松浏览日志。当使用不带参数的printStackTrace时（即，将堆栈跟踪打印到默认流时），此规则会引起问题。//不规范代码示例 try { /* ... */ } catch(Exception e) { e.printStackTrace(); } //规范代码示例 try { /* ... */ } catch(Exception e) { LOGGER.log("context", e); }

2019年09月27日
81 阅读
0 评论
0 点赞

枫铃也

绿水本无忧，因风皱面

青山原不老，为雪白头