原文: 工作四年,分享50个让你代码更好的小建议; 作者: 捡田螺的小男孩

工作四年,分享50个让你代码更好的小建议


文章目录

前言

工作四年,看过很多思考不够深入的代码,因此写一下总结吧,50个让你代码更好的小建议。其中的一些点,我以前的文章也写过啦,这次主要汇总一下。希望大家日常写代码多点思考,多点总结,加油!同时哪里有不对的,也望指出,感谢哈~

  • 公众号:「捡田螺的小男孩」

1. 仅仅判断是否存在时,select count 比 select 具体的列,更好。

我们经常遇到类似的业务场景,如,判断某个用户userId是否是会员。

「(反例):」 一些小伙伴会这样实现,先查从用户信息表查出用户记录,然后再去判断是否是会员:

1
2
3
4
5
6
7
8
9
<select id="selectUserByUserId" resultMap="BaseResultMap">  
     selct user_id , vip_flag from  user_info where user_id =#{userId};  
 </select>

boolean isVip (String userId){  
 UserInfo userInfo = userInfoDAp.selectUserByUserId(userId);  
 return UserInfo!=null && "Y".equals(userInfo.getVipFlag())  
}

「(正例):」 针对这种业务场景,其实更好的实现,是直接select count一下,或者select limit 1如下:

1
2
3
4
5
6
7
8
9
<select id="countVipUserByUserId" resultType="java.lang.Integer">  
     selct count(1) from  user_info where user_id =#{userId} and vip_flag ='Y';  
 </select>

  boolean isVip (String userId){  
  int vipNum = userInfoDAp.countVipUserByUserId(userId);  
  return vipNum>0  
}

2. 复杂的if逻辑条件,可以调整顺序,让程序更高效

假设业务需求是这样:如果用户是会员,并且第一次登陆时,需要发一条通知的短信。假如没有经过思考,代码很可能直接这样写了。

1
2
3
if(isUserVip && isFirstLogin){  
    sendMsgNotify();  
}  

假设总共有5个请求进来,isUserVip通过的有3个请求,isFirstLogin通过的有1个请求。那么以上代码,isUserVip执行的次数为5次,isFirstLogin执行的次数也是3次,如下:

图片

如果调整一下isUserVip和isFirstLogin的顺序呢?

1
2
3
if(isFirstLogin && isUserVip ){  
    sendMsg();  
}  

isFirstLogin执行的次数是5次,isUserVip执行的次数是1次,如下:

图片

如果你的isFirstLogin,判断逻辑只是select count 一下数据库表,isUserVip也是select count 一下数据库表的话,显然,把isFirstLogin放在前面更高效。

3. 写查询Sql的时候,只查你需要用到的字段,还有通用的字段,拒绝反手的select *

「反例:」

1
select * from user_info where user_id =#{userId};  

「正例:」

1
 select user_id , vip_flag from  user_info where user_id =#{userId};

「理由:」

  • 节省资源、减少网络开销。

  • 可能用到覆盖索引,减少回表,提高查询效率。

4. 优化你的程序,拒绝创建不必要的对象

如果你的变量,后面的逻辑判断,一定会被赋值;或者说,只是一个字符串变量,直接初始化字符串常量就可以了,没有必要愣是要new String().

反例:

1
String s = new String ("欢迎关注公众号:捡田螺的小男孩");  

正例:

1
String s=  "欢迎关注公众号:捡田螺的小男孩 ”;  

5. 初始化集合时,指定容量

阿里的开发手册,也明确提到这个点:图片

假设你的map要存储的元素个数是15个左右,最优写法如下

1
2
3
4
5
 //initialCapacity = 15/0.75+1=21  
 Map map = new HashMap(21);

  又因为hashMap的容量跟2的幂有关,所以可以取32的容量  
 Map map = new HashMap(32);

6.catch了异常,需要打印出具体的exception,方便更好定位问题

「反例:」

1
2
3
4
5
try{  
  // do something  
}catch(Exception e){  
  log.info("捡田螺的小男孩,你的程序有异常啦");  
}  

「正例:」

1
2
3
4
5
try{  
  // do something  
}catch(Exception e){  
  log.info("捡田螺的小男孩,你的程序有异常啦:",e); //把exception打印出来  
}  

「理由:」

  • 反例中,并没有把exception出来,到时候排查问题就不好查了啦,到底是SQl写错的异常还是IO异常,还是其他呢?所以应该把exception打印到日志中哦~

7. 打印日志的时候,对象没有覆盖Object的toString的方法,直接把类名打印出来了。

我们在打印日志的时候,经常想看下一个请求参数对象request是什么。于是很容易有类似以下这些代码:

1
2
3
publick Response dealWithRequest(Request request){  
   log.info("请求参数是:".request.toString)  
}  

打印结果如下:

1
请求参数是:local.Request@49476842  

这是因为对象的toString方法,默认的实现是“类名@散列码的无符号十六进制”。所以你看吧,这样子打印日志就没啥意思啦,你都不知道打印的是什么内容。

所以一般对象(尤其作为传参的对象),「都覆盖重写toString()方法」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Request {

    private String age;

    private String name;

    @Override  
    public String toString() {  
        return "Request{" +  
                "age='" + age + '\'' +  
                ", name='" + name + '\'' +  
                '}';  
    }  
}

publick Response dealWithRequest(Request request){  
   log.info("

请求参数是:".request.toString)  
}  

打印结果如下:

1
请求参数是:Request{age='26', name='公众号:捡田螺的小男孩'}  

8. 一个方法,拒绝过长的参数列表。

假设有这么一个公有方法,形参有四个。。。

1
2
3
public void getUserInfo(String name,String age,String sex,String mobile){  
  // do something ...  
}  

如果现在需要多传一个version参数进来,并且你的公有方法是类似dubbo这种对外提供的接口的话,那么你的接口是不是需要兼容老版本啦?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public void getUserInfo(String name,String age,String sex,String mobile){  
  // do something ...  
}

/**  

 * 新接口调这里  
   */  
   public void getNewUserInfo(String name,String age,String sex,String mobile,String version){  
     // do something ...  
   }

所以呢,一般一个方法的参数,一般不宜过长。过长的参数列表,不仅看起来不优雅,并且接口升级时,可能还要考虑新老版本兼容。如果参数实在是多怎么办呢?可以用个DTO对象包装一下这些参数呢~如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public void getUserInfo(UserInfoParamDTO userInfoParamDTO){  
  // do something ...  
}

class UserInfoParamDTO{  
  private String name;  
  private String age;   
  private String sex;  
  private String mobile;  
}

用个DTO对象包装一下,即使后面有参数变动,也可以不用动对外接口了,好处杠杠的。

9. 使用缓冲流,减少IO操作

「反例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
/**  

 *  公众号:捡田螺的小男孩  
 *  @desc: 复制一张图片文件  
    */  
    public class MainTest {  
        public static void main(String[] args) throws FileNotFoundException {  
            long begin = System.currentTimeMillis();  
            try (FileInputStream input = new FileInputStream("C:/456.png");  
                 FileOutputStream output = new FileOutputStream("C:/789.png")) {  
                byte[] bytes = new byte[1024];  
                int i;  
                while ((i = input.read(bytes)) != -1) {  
                    output.write(bytes,0,i);  
                }  
            } catch (IOException e) {  
                log.error("复制文件发生异常",e);  
            }  
            log.info("常规流读写,总共耗时ms:"+(System.currentTimeMillis() - begin));  
        }  
    }  

运行结果:

1
常规流读写,总共耗时ms:52  

使用FileInputStreamFileOutputStream实现文件读写功能,是没有什么问题的。但是呢,可以使用缓冲流BufferedReaderBufferedWriterBufferedInputStreamBufferedOutputStream等,减少IO次数,提高读写效率。

如果是不带缓冲的流,读取到一个字节或者字符的,就会直接输出数据了。而带缓冲的流,读取到一个字节或者字符时,先不输出,而是等达到缓冲区的最大容量,才一次性输出。

「正例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
/**  

 *  公众号:捡田螺的小男孩  
 *  @desc: 复制一张图片文件  
    */  
    public class MainTest {  
        public static void main(String[] args) throws FileNotFoundException {  
            long begin = System.currentTimeMillis();  
            try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:/456.png"));  
            BufferedOutputStream  bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:/789.png"))) {  
                byte[] bytes = new byte[1024];  
                int i;  
                while ((i = input.read(bytes)) != -1) {  
                    output.write(bytes,0,i);  
                }  
            } catch (IOException e) {  
                log.error("复制文件发生异常",e);  
            }  
            log.info("总共耗时ms"+(System.currentTimeMillis() - begin));  
        }  
    }  

运行结果:

1
缓冲流读写,总共耗时ms:12  

10. 优化你的程序逻辑,比如前面已经查到的数据,在后面的方法也用到的话,是可以把往下传参的,减少方法调用/查表

「反例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public Response dealRequest(Request request){

        UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);  
     if(Objects.isNull(request)){  
       return ;  
     }

       insertUserVip(request.getUserId);

   }

private int insertUserVip(String userId){  
      //又查了一次   
      UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);  
      //插入用户vip流水  
      insertUserVipFlow(userInfo);  
      ....  
}

很显然,以上程序代码,已经查到 userInfo,然后又把userId传下去,又查多了一次。。。实际上,可以把userInfo传下去的,这样可以省去一次查表操作,程序更高效。

「正例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
public Response dealRequest(Request request){

        UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId);  
    if(Objects.isNull(request)){  
       return ;  
     }

       insertUserVip(userInfo);  
}

private int insertUserVip(UserInfo userInfo){  
      //插入用户vip流水  
      insertUserVipFlow(userInfo);  
      ....  
}

11. 不要为了方便,直接在代码中使用0,1等魔法值,应该要用enum枚举代替。

「反例:」

1
2
3
4
5
6
7
if("0".equals(userInfo.getVipFlag)){  
    //非会员,提示去开通会员  
    tipOpenVip(userInfo);  
}else if("1".equals(userInfo.getVipFlag)){  
    //会员,加勋章返回  
    addMedal(userInfo);  
}  

「正例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
if(UserVipEnum.NOT_VIP.getCode.equals(userInfo.getVipFlag)){  
    //非会员,提示去开通会员  
    tipOpenVip(userInfo);  
}else if(UserVipEnum.VIP.getCode.equals(userInfo.getVipFlag)){  
    //会员,加勋章返回  
    addMedal(userInfo);  
}

public enum UserVipEnum {

    NOT_VIP("0","非会员"),  
    VIP("1","会员"), ;

    private String code;   
    private String desc;

    UserVipEnum(String code, String desc) {  
        this.code = code;  
        this.desc = desc;  
    }  
}

写代码的时候,不要一时兴起,就直接使用魔法值哈。使用魔法值,维护代码起来很难受的。

12. 当成员变量值不会改变时,优先定义为静态常量

「反例:」

1
2
3
    private final long timeout = 10L;  
    ...  
}  

「正例:」

1
2
3
    private static final long TIMEOUT = 10L;  
    ...  
}  

因为如果定义为static,即类静态常量,在每个实例对象中,它只有一份副本。如果是成员变量,每个实例对象中,都各有一份副本。显然,如果这个变量不会变的话,定义为静态常量更好一些。

13. 注意检验空指针,不要轻易相信业务,说正常逻辑某个参数不可能为空。

NullPointerException 在我们日常开发中非常常见,我们代码开发过程中,一定要对空指针保持灵敏的嗅觉。

主要有这几类空指针问题:

  • 包装类型的空指针问题

  • 级联调用的空指针问题

  • Equals方法左边的空指针问题

  • ConcurrentHashMap 类似容器不支持 k-v为 null。

  • 集合,数组直接获取元素

  • 对象直接获取属性

「反例:」

1
2
3
4
5
6
7
8
public class NullPointTest {  
    public static void main(String[] args) {  
        String s = null;  
        if (s.equals("666")) { //s可能为空,会导致空指针问题  
            System.out.println("公众号:捡田螺的小男孩,干货满满");  
        }  
    }  
}  

14,捕获到的异常,不能忽略它,至少打点日志。

「反例:」

1
2
3
4
5
6
7
public static void testIgnoreException() throws Exception {  
    try {         
        // 搞事情  
    } catch (Exception e) {      
        //捕获了异常,啥事情不做,日志也不打??  
    }  
}

「正例:」

1
2
3
4
5
6
7
public static void testIgnoreException() {  
    try {  
        // 搞事情  
    } catch (Exception e) {       
        log.error("异常了,联系开发小哥哥看看哈",e);   
    }  
}  

15. 采用Lambda表达式替换内部匿名类,使代码更优雅

JDK8出现了新特性-Lambda表达式。Lambda表达式不仅比匿名内部类更加优雅,并且在大多数虚拟机中,都是采用invokeDynamic指令实现,相对于匿名内部类,效率也更高

「反例:」

1
2
3
4
5
6
7
8
9
public void sortUserInfoList(List<UserInfo> userInfoList){  
     userInfoList.sort(new Comparator<UserInfo>() {  
         @Override  
         public int compare(UserInfo user1, UserInfo user2) {  
             Long userId1 = user1.getUserId();  
             Long userId2 = user2.getUserId();  
             return userId1.compareTo(userId2);  
         }});  
     }

「正例:」

1
2
3
4
5
6
7
public void sortUserInfoList(List<UserInfo> userInfoList){  
      userInfoList.sort((user1, user2) -> {  
          Long userId1 = user1.getUserId();  
          Long userId2 = user2.getUserId();  
          return userId1.compareTo(userId2);  
      });  
  }

16. 通知类(如发邮件,有短信)的代码,建议异步处理。

假设业务流程这样:需要在用户登陆时,添加个短信通知它的粉丝。很容易想到的实现流程如下:

图片

假设提供sendMsgNotify服务的系统挂了,或者调用sendMsgNotify失败了,那么用户登陆就失败了。。。一个通知功能导致了登陆主流程不可用,明显的捡了芝麻丢西瓜。那么有没有鱼熊掌兼得的方法呢?有的,给发短信接口捕获异常处理,或者另开线程异步处理,如下:

图片

因此,添加通知类等不是非主要,可降级的接口时,应该静下心来考虑是否会影响主要流程,思考怎么处理最好。

17. 处理Java日期时,当心YYYY格式设置的问题。

日常开发中,我们经常需要处理日期。我们要当时日期格式化的时候,年份是大写YYYY的坑。

1
2
3
4
5
6
7
8
Calendar calendar = Calendar.getInstance();  
calendar.set(2019, Calendar.DECEMBER, 31);

Date testDate = calendar.getTime();

SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd");  
System.out.println("2019-12-31 转 YYYY-MM-dd 格式后 " + dtf.format(testDate));

运行结果:

1
2019-12-31 转 YYYY-MM-dd 格式后 2020-12-31  

为什么明明是2019年12月31号,就转了一下格式,就变成了2020年12月31号了?因为YYYY是基于周来计算年的,它指向当天所在周属于的年份,一周从周日开始算起,周六结束,只要本周跨年,那么这一周就算下一年的了。正确姿势是使用yyyy格式。

图片

18. 如果一个类确定不会被继承,不会拿来搞AOP骚操作,可以指定final修饰符,如用final修饰一个工具类。

「正例:」

1
2
3
4
5
public final class Tools {  
    public static void testFinal(){  
        System.out.println("工具类方法");  
    }  
}  

一个类指定了final修饰符,它不会被继承了,并且其所有方法都是final的了。Java编译器会找机会内联所有的final方法,提升了Java运行效率。

19. static静态变量不要依赖spring实例化变量,可能会导致初始化出错

之前看到项目有类似的代码。静态变量依赖于spring容器的bean。

1
private static SmsService smsService = SpringContextUtils.getBean(SmsService.class);

这个静态的smsService有可能获取不到的,因为类加载顺序不是确定的,而以上的代码,静态的smsService初始化强制依赖spring容器的实例了。正确的写法可以这样,如下:

1
2
3
4
5
6
7
8
9
private static SmsService  smsService =null;

 //使用到的时候采取获取  
public static SmsService getSmsService(){  
  if(smsService==null){  
     smsService = SpringContextUtils.getBean(SmsService.class);  
  }  
  return smsService;  
}

20. 与类成员变量无关的方法,应当声明成静态方法

有些方法,与实例成员变量无关,就可以声明为静态方法。这一点,工具类用得很多。「反例如下」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
/**  

 * BigDecimal的工具类  
   */  
   public class BigDecimalUtils {

     public  BigDecimal ifNullSetZERO(BigDecimal in) {  
        return in != null ? in : BigDecimal.ZERO;  
    }

     public BigDecimal sum(BigDecimal ...in){  
        BigDecimal result = BigDecimal.ZERO;  
        for (int i = 0; i < in.length; i++){  
            result = result.add(ifNullSetZERO(in[i]));  
        }  
        return result;  
    }

因为BigDecimalUtils工具类的方法都没有static修饰,所以,你要使用的时候,每次都要new一下啦,那不就耗资源去**「反复创建对象」**了嘛!!

1
2
BigDecimalUtils bigDecimalUtils = new BigDecimalUtils();  
bigDecimalUtils.sum(a,b);  

所以可以声明成静态变量,使用的时候,直接类名.方法调用即可,正例如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
/**  

 * BigDecimal的工具类  
   */  
   public class BigDecimalUtils {

     public static  BigDecimal ifNullSetZERO(BigDecimal in) {  
        return in != null ? in : BigDecimal.ZERO;  
    }

     public static BigDecimal sum(BigDecimal ...in){  
        BigDecimal result = BigDecimal.ZERO;  
        for (int i = 0; i < in.length; i++){  
            result = result.add(ifNullSetZERO(in[i]));  
        }  
        return result;  
    }

21. 不要用一个Exception捕捉所有可能的异常。

「反例:」

1
2
3
4
5
6
7
8
9
public void test(){  
    try{  
        //…抛出 IOException 的代码调用  
        //…抛出 SQLException 的代码调用  
    }catch(Exception e){  
        //用基类 Exception 捕捉的所有可能的异常,如果多个层次都这样捕捉,会丢失原始异常的有效信息哦  
        log.info(“Exception in test,exception:{}”, e);  
    }  
}

「正例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public void test(){  
    try{  
        //…抛出 IOException 的代码调用  
        //…抛出 SQLException 的代码调用  
    }catch(IOException e){  
        //仅仅捕捉 IOException  
        log.info(“IOException in test,exception:{}”, e);  
    }catch(SQLException e){  
        //仅仅捕捉 SQLException  
        log.info(“SQLException in test,exception:{}”, e);  
    }  
}  

22. 函数不要过度封装,言简意赅即可。

「反例:」

1
2
3
4
5
6
7
8
// 函数封装  
public static boolean isUserVip(Boolean isVip) {  
    return Boolean.TRUE.equals(isVip);  
}

// 使用代码  
boolean isVip = isVip(user.getUserVip());

「正例:」

1
boolean isVip = Boolean.TRUE.equals(user.getUserVip());  

函数不要过度封装,把意思表达清楚即可。并且,方法调用会引起入栈和出栈,导致消耗更多的CPU和内存,过度封装,会损耗性能的!

23. 如果变量的初值一定会被覆盖,就没有必要给变量赋初值。

「反例:」

1
2
3
4
5
6
List<UserInfo> userList = new ArrayList<>();  
if (isAll) {  
    userList = userInfoDAO.queryAll();  
} else {  
    userList = userInfoDAO.queryActive();  
}

「正例:」

1
2
3
4
5
6
List<UserInfo> userList ;  
if (isAll) {  
    userList = userInfoDAO.queryAll();  
} else {  
    userList = userInfoDAO.queryActive();  
}

24.金额数值计算要使用BigDecimal

看下这个浮点数计算的例子吧:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class DoubleTest {  
    public static void main(String[] args) {  
        System.out.println(0.1+0.2);  
        System.out.println(1.0-0.8);  
        System.out.println(4.015*100);  
        System.out.println(123.3/100);

        double amount1 = 3.15;  
        double amount2 = 2.10;  
        if (amount1 - amount2 == 1.05){  
            System.out.println("OK");  
        }  
    }  
}

运行结果:

1
2
3
0.19999999999999996  
401.49999999999994  
1.2329999999999999  

因为计算机是以二进制存储数值的,对于浮点数也是。对于计算机而言,0.1无法精确表达,这就是为什么浮点数会导致精确度缺失的。因此,金额计算,一般都是用BigDecimal 类型

1
2
3
System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));  
//output:  
0.3000000000000000166533453693773481063544750213623046875  

其实,使用 BigDecimal 表示和计算浮点数,必须使用字符串的构造方法来初始化 BigDecimal,并且,还要关注BigDecimal的几位小数点,它有八种舍入模式等

25. 注意Arrays.asList的几个坑

  • 「基本类型不能作为 Arrays.asList方法的参数,否则会被当做一个参数。」
1
2
3
4
5
6
7
8
9
public class ArrayAsListTest {  
    public static void main(String[] args) {  
        int[] array = {1, 2, 3};  
        List list = Arrays.asList(array);  
        System.out.println(list.size());  
    }  
}  
//运行结果  
1  
  • 「Arrays.asList 返回的 List 不支持增删操作。」
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class ArrayAsListTest {  
    public static void main(String[] args) {  
        String[] array = {"1", "2", "3"};  
        List list = Arrays.asList(array);  
        list.add("5");  
        System.out.println(list.size());  
    }  
}

// 运行结果  
Exception in thread "main" java.lang.UnsupportedOperationException  
 at java.util.AbstractList.add(AbstractList.java:148)  
 at java.util.AbstractList.add(AbstractList.java:108)  
 at object.ArrayAsListTest.main(ArrayAsListTest.java:11)

Arrays.asList 返回的 List 并不是我们期望的 java.util.ArrayList,而是 Arrays 的内部类ArrayList。内部类的ArrayList没有实现add方法,而是父类的add方法的实现,是会抛出异常的呢。

  • 「使用Arrays.asLis的时候,对原始数组的修改会影响到我们获得的那个List」
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class ArrayAsListTest {  
    public static void main(String[] args) {  
        String[] arr = {"1", "2", "3"};  
        List list = Arrays.asList(arr);  
        arr[1] = "4";  
        System.out.println("原始数组"+Arrays.toString(arr));  
        System.out.println("list数组" + list);  
    }  
}

//运行结果  
原始数组[1, 4, 3]  
list数组[1, 4, 3]

26,及时关闭IO资源流

应该大家都有过这样的经历,windows系统桌面如果打开太多文件或者系统软件,就会觉得电脑很卡。当然,我们linux服务器也一样,平时操作文件,或者数据库连接,IO资源流如果没关闭,那么这个IO资源就会被它占着,这样别人就没有办法用了,这就造成资源浪费。

所以使用完IO流,记得关闭哈。可以使用try-with-resource关闭的:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
/*  

 * 关注公众号,捡田螺的小男孩  
   */  
   try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) {  
       // use resources     
   } catch (FileNotFoundException e) {  
       log.error(e);  
   } catch (IOException e) {  
       log.error(e);  
   }  

27. 尽量使用函数内的基本类型临时变量

  • 在方法函数内,基本类型参数以及临时变量,都是保存在栈中的,访问速度比较快。

  • 对象类型的参数和临时变量的引用都保存在栈中,内容都保存在堆中,访问速度较慢。

  • 在类中,任何类型的成员变量都保存在堆(Heap)中,访问速度较慢。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public class AccumulatorUtil {

    private double result = 0.0D;  
    //反例  
    public void addAllOne( double[] values) {  
        for(double value : values) {  
            result += value;  
        }  
    }  
    //正例,先在方法内声明一个局部临时变量,累加完后,再赋值给方法外的成员变量  
    public void addAl1Two(double[] values) {  
        double sum = 0.0D;  
        for(double value : values) {  
            sum += value;  
        }  
        result += sum;  
    }  
}

28. 如果数据库一次查询的数量过多,建议分页处理。

如果你的Sql一次性查出来的数据量比较多,建议分页处理。

「反例:」

1
select user_id,name,age from user_info ;

「正例:」

1
select user_id,name,age from user_info limit #{offset},#{pageSize};  

如果偏移量特别大的时候,查询效率就变得低下。可以这接种方式优化:

1
2
3
4
5
6
7
8
//方案一 :返回上次查询的最大记录(偏移量)  
select id,name from user_info where id>10000 limit #{pageSize}.

//方案二:order by + 索引  
select id,name from user_info order by id  limit #{offset},#{pageSize}

//方案三:在业务允许的情况下限制页数:

29. 尽量减少对变量的重复计算

一般我们写代码的时候,会以以下的方式实现遍历:

1
2
3
4
for (int i = 0; i < list.size; i++){

}

如果list数据量比较小那还好。如果list比较大时,可以优化成这样:

1
2
3
4
for (int i = 0,  length = list.size; i < length; i++){

}

理由:

  • 对方法的调用,即使是只有一个语句,也是有有消耗的,比如创建栈帧。如果list比较大时,多次调用list.size也是会有资源消耗的。

30. 修改对外老接口的时候,思考接口的兼容性。

很多bug都是因为修改了对外老接口,但是却不做兼容导致的。关键这个问题多数是比较严重的,可能直接导致系统发版失败的。新手程序员很容易就犯这个错误了哦~

所以,如果你的需求是在原来接口上修改,,尤其这个接口是对外提供服务的话,一定要考虑接口兼容。举个例子吧,比如dubbo接口,原本是只接收A,B参数,现在你加了一个参数C,就可以考虑这样处理。

1
2
3
4
5
6
7
8
9
//老接口  
void oldService(A,B);{  
  //兼容新接口,传个null代替C  
  newService(A,B,null);  
}

//新接口,暂时不能删掉老接口,需要做兼容。  
void newService(A,B,C);

31 代码采取措施避免运行时错误(如数组边界溢出,被零除等)

日常开发中,我们需要采取措施规避数组边界溢出,被零整除,空指针等运行时错误。

类似代码比较常见:

1
String name = list.get(1).getName(); //list可能越界,因为不一定有2个元素哈  

所以,应该采取措施,预防一下数组边界溢出,「正例:」

1
2
3
if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){  
  String name = list.get(1).getName();   
}  

32. 注意 ArrayList.toArray() 强转的坑

1
2
3
4
5
6
7
public class ArrayListTest {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<String>(1);  
        list.add("公众号:捡田螺的小男孩");  
        String[] array21 = (String[])list.toArray();//类型转换异常  
    }  
}

因为返回的是Object类型,Object类型数组强转String数组,会发生ClassCastException。解决方案是,使用toArray()重载方法toArray(T[] a)

1
String[] array1 = list.toArray(new String[0]);//可以正常运行  

33. 尽量不在循环里远程调用、或者数据库操作,优先考虑批量进行。

程操作或者数据库操作都是比较耗网络、IO资源的,所以尽量不在循环里远程调用、不在循环里操作数据库,能批量一次性查回来尽量不要循环多次去查。(但是呢,也不要一次性查太多数据哈,要分批500一次酱紫)

「正例:」

1
remoteBatchQuery(param);  

「反例:」

1
2
3
for(int i=0;i<n;i++){  
  remoteSingleQuery(param)  
}  

34. 写完代码,脑洞一下多线程执行会怎样,注意并发一致性问题

我们经常见的一些业务场景,就是先查下有没有记录,再进行对应的操作(比如修改)。但是呢,(查询+修改)合在一起不是原子操作哦,脑洞下多线程,就会发现有问题了,

「反例:」

1
2
3
4
5
6
if(isAvailable(ticketId){  //非原子操作   
    1、给现金增加操作   
    2、deleteTicketById(ticketId)   
}else{   
    return "没有可用现金券";  
}

为了更容易理解它,看这个流程图吧:图片

  • 1.线程A加现金

  • 2.线程B加现金

  • 3.线程A删除票标志

  • 4.线程B删除票标志

显然这样存在并发问题,正例应该利用数据库删除操作的原子性,如下:

1
2
3
4
5
if(deleteAvailableTicketById(ticketId) == 1){ //原子操作  
    1、给现金增加操作   
}else{   
    return “没有可用现金券”   
}  

35 多线程异步优先考虑恰当的线程池,而不是new thread,同时考虑线程池是否隔离

为什么优先使用线程池?使用线程池有这几点好处呀

  • 它帮我们管理线程,避免增加创建线程和销毁线程的资源损耗。

  • 提高响应速度。

  • 重复利用。

同时呢,尽量不要所有业务都共用一个线程池,需要考虑线程池隔离。就是不同的关键业务,分配不同的线程池,然后线程池参数也要考虑恰当哈。之前写过几篇线程池的,觉得还不错,有兴趣的朋友可以看一下哈

36. 优化程序结构,尽量减少方法的重复调用

「反例:」

1
2
3
4
5
public static void listDetail(List<UserInfo> userInfoList) {  
       for (int i = 0; i < userInfoList.size(); i++) {  
           //重复调用userList.size()方法了  
       }  
   }

「正例:」

1
2
3
4
5
6
public static void listDetail(List<UserInfo> userInfoList) {  
       int length = userInfoList.size();  
       for (int i = 0; i < length; i++) {  
           //减少调用userList.size()方法,只在length变量调了一次。  
       }  
   }

37,直接大文件或者一次性从数据库读取太多数据到内存,可能导致OOM问题

如果一次性把大文件或者数据库太多数据达到内存,是会导致OOM的。所以,为什么查询DB数据库,一般都建议分批。

读取文件的话,一般文件不会太大,才使用Files.readAllLines()。为什么呢?因为它是直接把文件都读到内存的,预估下不会OOM才使用这个吧,可以看下它的源码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public static List<String> readAllLines(Path path, Charset cs) throws IOException {  
    try (BufferedReader reader = newBufferedReader(path, cs)) {  
        List<String> result = new ArrayList<>();  
        for (;;) {  
            String line = reader.readLine();  
            if (line == null)  
                break;  
            result.add(line);  
        }  
        return result;  
    }  
}  

如果是太大的文件,可以使用Files.line()按需读取,当时读取文件这些,一般是使用完需要关闭资源流的哈。

38. 调用第三方接口,需要考虑异常处理,安全性,超时重试这几个点。

日常开发中,经常需要调用第三方服务,或者分布式远程服务的的话,需要考虑:

  • 异常处理(比如,你调别人的接口,如果异常了,怎么处理,是重试还是当做失败)

  • 超时(没法预估对方接口一般多久返回,一般设置个超时断开时间,以保护你的接口)

  • 重试次数(你的接口调失败,需不需要重试,需要站在业务上角度思考这个问题)

简单一个例子,你一个http请求调别人的服务,需要考虑设置connect-time,和retry次数。

39 不要使用循环拷贝集合,尽量使用JDK提供的方法拷贝集合

  • JDK提供原生API方法,可以直接指定集合的容量,避免多次扩容损耗性能。

  • 这些方法的底层调用System.arraycopy方法实现,进行数据的批量拷贝效率更高。

「反例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public List<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {  
     List<UserInfo> userList = new ArrayList<>(user1List.size() + user2List.size());  
     for (UserInfo user : user1List) {  
         userList.add(user);  
     }  
     for (UserInfo user : user2List) {  
         userList.add(user);  
     }

     return user1List;  
 }

「正例:」

1
2
3
4
5
6
public List<UserInfo> copyMergeList(List<UserInfo> user1List, List<UserInfo> user2List) {  
     List<UserInfo> userList = new ArrayList<>(user1List.size() + user2List.size());  
     userList.addAll(user1List);  
     userList.addAll(user2List);  
     return user1List;  
 }  

40. 对于复杂的代码逻辑,添加清楚的注释

写代码的时候,是没有必要写太多的注释的,好的方法变量命名就是最好的注释。但是,如果是业务逻辑很复杂的代码,真的非常有必要写清楚注释。清楚的注释,更有利于后面的维护。

41. 多线程情况下,考虑线性安全问题

在高并发情况下,HashMap可能会出现死循环。因为它是非线性安全的,可以考虑使用ConcurrentHashMap。所以这个也尽量养成习惯,不要上来反手就是一个new HashMap();

  • Hashmap、Arraylist、LinkedList、TreeMap等都是线性不安全的;

  • Vector、Hashtable、ConcurrentHashMap等都是线性安全的

42. 使用spring事务功能时,注意这几个事务未生效的坑

日常业务开发中,我们经常跟事务打交道,事务失效主要有以下几个场景:

  • 底层数据库引擎不支持事务

  • 在非public修饰的方法使用

  • rollbackFor属性设置错误

  • 本类方法直接调用

  • 异常被try…catch吃了,导致事务失效。

「反例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class TransactionTest{  
  public void A(){  
    //插入一条数据  
    //调用方法B (本地的类调用,事务失效了)  
    B();  
  }

    @Transactional  
  public void B(){  
    //插入数据  
  }  
}

「注解的事务方法给本类方法直接调用,事务失效」

43. 使用Executors声明线程池,newFixedThreadPool的OOM问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
ExecutorService executor = Executors.newFixedThreadPool(10);  
       for (int i = 0; i < Integer.MAX_VALUE; i++) {  
           executor.execute(() -> {  
               try {  
                   Thread.sleep(10000);  
               } catch (InterruptedException e) {  
                   //do nothing  
               }  
           });  
       }

IDE指定JVM参数:-Xmx8m -Xms8m :

图片

运行结果:

图片

我们看下源码,其实newFixedThreadPool使用的是无界队列!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
public static ExecutorService newFixedThreadPool(int nThreads) {  
    return new ThreadPoolExecutor(nThreads, nThreads,  
                                  0L, TimeUnit.MILLISECONDS,  
                                  new LinkedBlockingQueue<Runnable>());  
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E>  
        implements BlockingQueue<E>, java.io.Serializable {  
    ...  
    /**  

   * Creates a {@code LinkedBlockingQueue} with a capacity of  
      {@link Integer#MAX_VALUE}.  
          */  
         public LinkedBlockingQueue() {  
             this(Integer.MAX_VALUE);  
         }  
     ...  
     }

newFixedThreadPool线程池的核心线程数是固定的,它使用了近乎于无界的LinkedBlockingQueue阻塞队列。当核心线程用完后,任务会入队到阻塞队列,如果任务执行的时间比较长,没有释放,会导致越来越多的任务堆积到阻塞队列,最后导致机器的内存使用不停的飙升,造成JVM OOM。

44. catch住异常后,尽量不要使用e.printStackTrace(),而是使用log打印。

「反例:」

1
2
3
4
5
try{  
  // do what you want    
}catch(Exception e){  
  e.printStackTrace();  
}  

「正例:」

1
2
3
4
5
try{  
  // do what you want    
}catch(Exception e){  
  log.info("你的程序有异常啦",e);  
}  

45. 接口需要考虑幂等性

接口是需要考虑幂等性的,尤其抢红包、转账这些重要接口。最直观的业务场景,就是用户连着点两次,你的接口有没有hold住。

一般幂等技术方案有这几种:

  • 查询操作

  • 唯一索引

  • token机制,防止重复提交

  • 数据库的delete/update操作

  • 乐观锁

  • 悲观锁

  • Redis、zookeeper 分布式锁(以前抢红包需求,用了Redis分布式锁)

  • 状态机幂等

46. 对于行数比较多的函数,建议划分小函数,增强可读性。

「反例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test {  
    private String name;  
    private Vector<Order> orders = new Vector<Order>();

    public void printOwing() {  
        //print banner  
        System.out.println("****************");  
        System.out.println("*****customer Owes *****");  
        System.out.println("****************");

        //calculate totalAmount  
        Enumeration env = orders.elements();  
        double totalAmount = 0.0;  
        while (env.hasMoreElements()) {  
            Order order = (Order) env.nextElement();  
            totalAmount += order.getAmout();  
        }

        //print details  
        System.out.println("name:" + name);  
        System.out.println("amount:" + totalAmount);  
    }  
}

「正例:」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class Test {  
    private String name;  
    private Vector<Order> orders = new Vector<Order>();

    public void printOwing() {

        //print banner  
        printBanner();  
        //calculate totalAmount  
        double totalAmount = getTotalAmount();  
        //print details  
        printDetail(totalAmount);  
    }

    void printBanner(){  
        System.out.println("****************");  
        System.out.println("*****customer Owes *****");  
        System.out.println("****************");  
    }

    double getTotalAmount(){  
        Enumeration env = orders.elements();  
        double totalAmount = 0.0;  
        while (env.hasMoreElements()) {  
            Order order = (Order) env.nextElement();  
            totalAmount += order.getAmout();  
        }  
        return totalAmount;  
    }

    void printDetail(double totalAmount){  
        System.out.println("name:" + name);  
        System.out.println("amount:" + totalAmount);  
    }

    }

一个过于冗长的函数或者一段需要注释才能让人理解用途的代码,可以考虑把它切分成一个功能明确的函数单元,并定义清晰简短的函数名,这样会让代码变得更加优雅。

47. 你的关键业务代码,一般建议搞点日志保驾护航。

关键业务代码无论身处何地,都应该有足够的日志保驾护航。

比如:你实现转账业务,转个几百万,然后转失败了,接着客户投诉,然后你还没有打印到日志,想想那种水深火热的困境下,你却毫无办法。。。

那么,你的转账业务都需要那些日志信息呢?至少,方法调用前,入参需要打印需要吧,接口调用后,需要捕获一下异常吧,同时打印异常相关日志吧,如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public void transfer(TransferDTO transferDTO){  
    log.info("invoke tranfer begin");  
    //打印入参  
    log.info("invoke tranfer,paramters:{}",transferDTO);  
    try {  
      res=  transferService.transfer(transferDTO);  
    }catch(Exception e){  
     log.error("transfer fail,cifno:{},account:{}",transferDTO.getCifno(),  
     transferDTO.getaccount())  
     log.error("transfer fail,exception:{}",e);  
    }  
    log.info("invoke tranfer end");  
    }  

除了打印足够的日志,我们还需要注意一点是,日志级别别混淆使用,别本该打印info的日志,你却打印成error级别,告警半夜三更催你起来排查问题就不好了。

48. 某些可变因素,如红包皮肤等等,做成配置化是否会更好呢。

假如产品提了个红包需求,圣诞节的时候,红包皮肤为圣诞节相关的,春节的时候,红包皮肤等。

反例:

1
2
3
4
5
if(duringChristmas){  
   img = redPacketChristmasSkin;  
}else if(duringSpringFestival){  
   img =  redSpringFestivalSkin;  
}  

如果到了元宵节的时候,运营小姐姐突然又有想法,红包皮肤换成灯笼相关的,这时候,是不是要去修改代码了,重新发布了?从一开始,实现一张红包皮肤的配置表,将红包皮肤做成配置化呢?更换红包皮肤,只需修改一下表数据就好了。

49,.直接迭代需要使用的集合,无须在额外操作

直接迭代需要使用的集合,无需通过其它操作获取数据,比较典型就是Map的迭代遍历:

「反例:」

1
2
3
4
5
Map<Long, UserDO> userMap = ...;  
for (Long userId : userMap.keySet()) {  
    UserDO user = userMap.get(userId);  
    ...  
}  

「正例:」

1
2
3
4
5
6
Map<Long, UserDO> userMap = ...;  
for (Map.Entry<Long, UserDO> userEntry : userMap.entrySet()) {  
    Long userId = userEntry.getKey();  
    UserDO user = userEntry.getValue();  
    ...  
}  

50. 策略模式+工厂方法优化冗余的if else

「反例:」

1
2
3
4
5
6
7
8
9
String medalType = "guest";  
   if ("guest".equals(medalType)) {  
       System.out.println("嘉宾勋章");  
    } else if ("vip".equals(medalType)) {  
       System.out.println("会员勋章");  
   } else if ("guard".equals(medalType)) {  
       System.out.println("展示守护勋章");  
   }  
   ...

首先,我们把每个条件逻辑代码块,抽象成一个公共的接口,我们根据每个逻辑条件,定义相对应的策略实现类,可得以下代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//勋章接口  
public interface IMedalService {  
    void showMedal();  
}

//守护勋章策略实现类  
public class GuardMedalServiceImpl implements IMedalService {  
    @Override  
    public void showMedal() {  
        System.out.println("展示守护勋章");  
    }  
}  
//嘉宾勋章策略实现类  
public class GuestMedalServiceImpl implements IMedalService {  
    @Override  
    public void showMedal() {  
        System.out.println("嘉宾勋章");  
    }  
}  
//VIP勋章策略实现类  
public class VipMedalServiceImpl implements IMedalService {  
    @Override  
    public void showMedal() {  
        System.out.println("会员勋章");  
    }  
}

接下来,我们再定义策略工厂类,用来管理这些勋章实现策略类,如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
//勋章服务工产类  
public class MedalServicesFactory {

    private static final Map<String, IMedalService> map = new HashMap<>();  
    static {  
        map.put("guard", new GuardMedalServiceImpl());  
        map.put("vip", new VipMedalServiceImpl());  
        map.put("guest", new GuestMedalServiceImpl());  
    }  
    public static IMedalService getMedalService(String medalType) {  
        return map.get(medalType);  
    }  
}

优化后,正例如下:

1
2
3
4
5
6
7
ublic class Test {  
    public static void main(String[] args) {  
        String medalType = "guest";  
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);  
        medalService.showMedal();  
    }  
}  

Reference

  1. Java编码技巧之高效代码50例
  2. 写代码有这些想法,同事才不会认为你是复制粘贴程序员
  3. 写代码有这16个好习惯,可以减少80%非业务的bug
  4. Java日常开发的21个坑,你踩过几个?
  5. if-else代码优化的八种方案