个人代码小册子

待我称王封你为后i 2022-12-27 01:59 112阅读 0赞

代码 小册子

优秀代码记录:

*   解决 ToString 的问题
    
        @ToString(exclude = {  "mobileHCode", "electronicCode", "teleCode", "cityName", "provTelecode","proviceCode" })
        利用注解 @ToString(exclude = { "字段名称","字段名称"})
 *  注意细节
    
     *      public QueryMyProductOfferResDTO getQueryTelecomMemberLevelRes(String productNo) { 
                    QueryMyProductOfferResDTO result = new QueryMyProductOfferResDTO();
                    QueryMobileHResponse response = getQueryUserInfo(productNo);
                    // 接口调用失败 非电信号码 返回空
                    if (StringUtils.isEmpty(response.getCarrierName()) || 	SwitchType.OFF.getSwitchType().equals(queryTelecomMemberSwitch) || !"dx".equals(response.getCarrierName())) { 
                    return result;
                    }
                    String cacheKey = StringUtils.join(new String[]{ ConstantRedisPrefixKey.CACHE_KEY_TELECOM_MEMBER_LEVEL_USER_INFO, productNo}, Constant.SEPARATOR_UNDERLINE);
                    result = (QueryMyProductOfferResDTO) redisClient.getObject(cacheKey);
                    if (result != null) { 
                        return result;
                    }
                    // 调用 5g 接口查询用户的5g套餐档次
                    QueryMyProductOfferReqDTO reqDTO = new QueryMyProductOfferReqDTO();
                    try { 
                        result = telecomUserInfo.queryMyProductOffer(reqDTO).getResult();
                    } catch (Exception e) { 
                        log.error("log getQueryTelecomMemberLevelRes 查询用户订购的套餐销售品以及附着叠加包 异常用户的手机号:{}", productNo);
                        redisClient.setObject(cacheKey, result, 2, TimeUnit.MINUTES);
                        return result;
                    }
                    redisClient.setObject(cacheKey, result, TimeUtils.getTimeDiffToNextDate() + 30L, TimeUnit.SECONDS);
                    return result;
                }
     *  上面代码的发现的问题 redis如果获取不到会进行设置null 到 result == null 的值
     *  如果产生了异常 返回出去的是Null 的值
 *  Maven 包升级 解决包的冲突
    
     *  原有包不存在 需要 从新进行引入
     *  影响 Spring 的发版的问题包,进行 排掉不引用 hibernate-validator
        
         *  反向的打包的时候也需要干净一些
 *  String.contains() 谨慎使用
    
     *  contains 是包含的关系 比如字符串中"1234AABBCC".contains 答案是true 注意使用的场景
 *  最近 年轻人不讲码德 惊人传Null 来欺负我,我大意了 NullException 的注意的地方 来自码出高效
    
     *  > 【推荐】防止NPE，是程序员的基本修养，注意NPE产生的场景：  
        > 1）返回类型为基本数据类型，return包装数据类型的对象时，自动拆箱有可能产生NPE。  
        > 反例：public int f() \{ return Integer对象\}， 如果为null，自动解箱抛NPE。  
        > 2） 数据库的查询结果可能为null。  
        > 3） 集合里的元素即使isNotEmpty，取出的数据元素也可能为null。  
        > 4） 远程调用返回对象时，一律要求进行空指针判断，防止NPE。  
        > 5） 对于Session中获取的数据，建议NPE检查，避免空指针。  
        > 6） 级联调用obj.getA().getB().getC()；一连串调用，易产生NPE。  
        > 正例：**使用JDK8的Optional类来防止NPE问题。**
     *  
 *  HashMap 的遍历操作 结合网上总结11种
    
     *  使用**迭代器**和**Map.Entry**
        
         *      long i = 0;
                Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
                while (it.hasNext()) { 
                    Map.Entry<Integer, Integer> pair = it.next();
                    i += pair.getKey() + pair.getValue();
                }
     *  使用**foreach**和**Map.Entry**
        
         *      long i = 0;
                for (Map.Entry<Integer, Integer> pair : map.entrySet()) { 
                    i += pair.getKey() + pair.getValue();
                }
     *  从Java 8使用**forEach**
     *      final long[] i = { 0};
            map.forEach((k, v) -> i[0] += k + v);
     *  使用**keySet**和**foreach**
     *      long i = 0;
            for (Integer key : map.keySet()) { 
                i += key + map.get(key);
            }
     *  使用**keySet**和**迭代器**
     *      long i = 0;
            Iterator<Integer> itr2 = map.keySet().iterator();
            while (itr2.hasNext()) { 
                Integer key = itr2.next();
                i += key + map.get(key);
            }
     *  使用**for**和**Map.Entry**
     *      long i = 0;
            for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { 
                Map.Entry<Integer, Integer> entry = entries.next();
                i += entry.getKey() + entry.getValue();
            }
     *  使用Java 8 **Stream API**
     *      final long[] i = { 0};
            map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
     *  **并行**使用Java 8 **Stream API**
     *      final long[] i = { 0};
            map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
     *  使用**IterableMap**的`Apache Collections`
     *      long i = 0;
            MapIterator<Integer, Integer> it = iterableMap.mapIterator();
            while (it.hasNext()) { 
                i += it.next() + it.getValue();
            }
     *  使用Eclipse **MutableMap**（CS）集合
     *      final long[] i = { 0};
            mutableMap.forEachKeyValue((key, value) -> { 
                i[0] += key + value;
            });
     *  在Java 8中，使用新的lambdas功能来快速
     *      Map<String,String> map = new HashMap<>();
             map.put("SomeKey", "SomeValue");
             map.forEach( (k,v) -> [do something with key and value] );
            
             // such as
             map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));
     *  测试用例代码
        
         *      package other_examples;
                
                import org.apache.commons.collections4.IterableMap;
                import org.apache.commons.collections4.MapIterator;
                import org.apache.commons.collections4.map.HashedMap;
                import org.eclipse.collections.api.map.MutableMap;
                import org.eclipse.collections.impl.map.mutable.UnifiedMap;
                import org.openjdk.jmh.annotations.*;
                import org.openjdk.jmh.runner.Runner;
                import org.openjdk.jmh.runner.RunnerException;
                import org.openjdk.jmh.runner.options.Options;
                import org.openjdk.jmh.runner.options.OptionsBuilder;
                
                import java.io.IOException;
                import java.util.HashMap;
                import java.util.Iterator;
                import java.util.Map;
                import java.util.concurrent.TimeUnit;
                import java.util.stream.Collector;
                import java.util.stream.Collectors;
                
                /** * Created by vvedenin on 2/21/2016. */
                @State(Scope.Benchmark)
                public class IterateThroughHashMapTest { 
                    private final static Integer SIZE = 100;
                
                    @Param({ "100","1000"})
                    public int size;
                
                    private Map<Integer, Integer> map = new HashMap<>(SIZE);
                
                    /** 1. Using iterator and Map.Entry **/
                    @Benchmark
                    public long test1_UsingWhileAndMapEntry() throws IOException { 
                        long i = 0;
                        Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
                        while (it.hasNext()) { 
                            Map.Entry<Integer, Integer> pair = it.next();
                            i += pair.getKey() + pair.getValue();
                        }
                        return i;
                    }
                
                    /** 2. Using foreach and Map.Entry **/
                    @Benchmark
                    public long test2_UsingForEachAndMapEntry() throws IOException { 
                        long i = 0;
                        for (Map.Entry<Integer, Integer> pair : map.entrySet()) { 
                            i += pair.getKey() + pair.getValue();
                        }
                        return i;
                    }
                
                    /** 3. Using foreach from Java 8 **/
                    @Benchmark
                    public long test3_UsingForEachAndJava8() throws IOException { 
                        final long[] i = { 0};
                        map.forEach((k, v) -> i[0] += k + v);
                        return i[0];
                    }
                
                    /** 4. Using keySet and foreach **/
                    @Benchmark
                    public long test4_UsingKeySetAndForEach() throws IOException { 
                        long i = 0;
                        for (Integer key : map.keySet()) { 
                            i += key + map.get(key);
                        }
                        return i;
                    }
                
                    /** 5. Using keySet and iterator **/
                    @Benchmark
                    public long test5_UsingKeySetAndIterator() throws IOException { 
                        long i = 0;
                        Iterator<Integer> itr2 = map.keySet().iterator();
                        while (itr2.hasNext()) { 
                            Integer key = itr2.next();
                            i += key + map.get(key);
                        }
                        return i;
                    }
                
                    /** 6. Using for and Map.Entry **/
                    @Benchmark
                    public long test6_UsingForAndIterator() throws IOException { 
                        long i = 0;
                        for (Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator(); entries.hasNext(); ) { 
                            Map.Entry<Integer, Integer> entry = entries.next();
                            i += entry.getKey() + entry.getValue();
                        }
                        return i;
                    }
                
                    /** 7. Using Java 8 Stream Api **/
                    @Benchmark
                    public long test7_UsingJava8StreamApi() throws IOException { 
                        final long[] i = { 0};
                        map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());
                        return i[0];
                    }
                
                    /** 8. Using Java 8 Stream Api parallel **/
                    @Benchmark
                    public long test8_UsingJava8StreamApiParallel() throws IOException { 
                        final long[] i = { 0};
                        map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());
                        return i[0];
                    }
                
                    /** 9. Using Apache IterableMap **/
                    private IterableMap<Integer, Integer> iterableMap = new HashedMap<>(SIZE);
                    @Benchmark
                    public long test9_UsingApacheIterableMap() throws IOException { 
                        long i = 0;
                        MapIterator<Integer, Integer> it = iterableMap.mapIterator();
                        while (it.hasNext()) { 
                            i += it.next() + it.getValue();
                        }
                        return i;
                    }
                
                    /** 10. Using MutableMap of Eclipse (CS) collections **/
                    private MutableMap<Integer, Integer> mutableMap = UnifiedMap.newMap(SIZE);
                    @Benchmark
                    public long test10_UsingEclipseMap() throws IOException { 
                        final long[] i = { 0};
                        mutableMap.forEachKeyValue((key, value) -> { 
                            i[0] += key + value;
                        });
                        return i[0];
                    }
                
                    /** 11. Using Java 8 Stream Api 2 **/
                    @Benchmark
                    public long test11_UsingJava8StreamApi2() throws IOException { 
                        return map.entrySet().stream().mapToLong(e -> e.getKey() + e.getValue()).sum();
                    }
                
                    /** 12. Using Java 8 Stream Api parallel 2 **/
                    @Benchmark
                    public long test12_UsingJava8StreamApiparallel2() throws IOException { 
                        return map.entrySet().parallelStream().mapToLong(e -> e.getKey() + e.getValue()).sum();
                    }
                
                    @TearDown(Level.Iteration)
                    public void tearDown() { 
                        map = new HashMap<>(size);
                        iterableMap = new HashedMap<>(size);
                        mutableMap = UnifiedMap.newMap(size);
                        for (int i = 0; i < size; i++) { 
                            map.put(i, i);
                            mutableMap.put(i, i);
                            iterableMap.put(i, i);
                        }
                    }
                
                    public static void main(String[] args) throws RunnerException { 
                        Options opt = new OptionsBuilder()
                                .include(IterateThroughHashMapTest.class.getSimpleName())
                                .timeUnit(TimeUnit.MICROSECONDS)
                                .warmupIterations(3)
                                .measurementIterations(5)
                                .param("size","100",/*"500","900","1300","1700","2100","2500","5000","10000","15000","20000","25000" ,*/ "30000")
                                .forks(1)
                                .mode(Mode.AverageTime)
                                .build();
                
                        new Runner(opt).run();
                    }
                }

发现的个人 技术栈问题

*  Steam 流不会