天天看點
傳回

工作四年，分享50個讓你代碼更好的小建議

前言

工作四年，看過很多思考不夠深入的代碼，是以寫一下總結吧，50個讓你代碼更好的小建議。其中的一些點，我以前的文章也寫過啦，這次主要彙總一下。希望大家日常寫代碼多點思考，多點總結，加油！同時哪裡有不對的，也望指出，感謝哈~

  • 公衆号：「撿田螺的小男孩」

1. 僅僅判斷是否存在時，select count 比 select 具體的列，更好。

我們經常遇到類似的業務場景，如，判斷某個使用者​

​userId​

​是否是會員。

「（反例）：」  一些小夥伴會這樣實作，先查從使用者資訊表查出使用者記錄，然後再去判斷是否是會員:

<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如下：

<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邏輯條件，可以調整順序，讓程式更高效

假設業務需求是這樣：如果使用者是會員，并且第一次登陸時，需要發一條通知的短信。假如沒有經過思考，代碼很可能直接這樣寫了。

if(isUserVip && isFirstLogin){
    sendMsgNotify();
}

假設總共有5個請求進來，isUserVip通過的有3個請求，isFirstLogin通過的有1個請求。那麼以上代碼，isUserVip執行的次數為5次，isFirstLogin執行的次數也是3次，如下：

工作四年，分享50個讓你代碼更好的小建議

如果調整一下isUserVip和isFirstLogin的順序呢？

if(isFirstLogin && isUserVip ){
    sendMsg();
}

isFirstLogin執行的次數是5次，isUserVip執行的次數是1次，如下：

工作四年，分享50個讓你代碼更好的小建議

如果你的isFirstLogin，判斷邏輯隻是select count 一下資料庫表，isUserVip也是select count 一下資料庫表的話，顯然，把isFirstLogin放在前面更高效。

3. 寫查詢Sql的時候，隻查你需要用到的字段，還有通用的字段，拒絕反手的select *

「反例：」

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

「正例：」

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

「理由：」

  • 節省資源、減少網絡開銷。
  • 可能用到覆寫索引，減少回表，提高查詢效率。

4. 優化你的程式，拒絕建立不必要的對象

如果你的變量，後面的邏輯判斷，一定會被指派；或者說，隻是一個字元串變量，直接初始化字元串常量就可以了，沒有必要愣是要new String().

反例：

String s = new String ("歡迎關注公衆号：撿田螺的小男孩");

正例：

String s=  "歡迎關注公衆号：撿田螺的小男孩 ”;

5. 初始化集合時，指定容量

阿裡的開發手冊，也明确提到這個點：

工作四年，分享50個讓你代碼更好的小建議

假設你的map要存儲的元素個數是15個左右，最優寫法如下

//initialCapacity = 15/0.75+1=21
 Map map = new HashMap(21);
 
 又因為hashMap的容量跟2的幂有關，是以可以取32的容量
 Map map = new HashMap(32);

6.catch了異常，需要列印出具體的exception，友善更好定位問題

「反例：」

try{
  // do something
}catch(Exception e){
  log.info("撿田螺的小男孩，你的程式有異常啦");
}

「正例：」

try{
  // do something
}catch(Exception e){
  log.info("撿田螺的小男孩，你的程式有異常啦：",e); //把exception列印出來
}

「理由：」

  • 反例中，并沒有把exception出來，到時候排查問題就不好查了啦，到底是SQl寫錯的異常還是IO異常，還是其他呢？是以應該把exception列印到日志中哦~

7. 列印日志的時候，對象沒有覆寫Object的toString的方法，直接把類名列印出來了。

我們在列印日志的時候，經常想看下一個請求參數對象request是什麼。于是很容易有類似以下這些代碼：

publick Response dealWithRequest(Request request){
   log.info("請求參數是：".request.toString)
}

列印結果如下：

請求參數是：local.Request@49476842

這是因為對象的toString方法，預設的實作是“類名@散列碼的無符号十六進制”。是以你看吧，這樣子列印日志就沒啥意思啦，你都不知道列印的是什麼内容。

是以一般對象(尤其作為傳參的對象），「都覆寫重寫toString()方法」：

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)
}

列印結果如下：

請求參數是：Request{age='26', name='公衆号：撿田螺的小男孩'}

8. 一個方法，拒絕過長的參數清單。

假設有這麼一個公有方法，形參有四個。。。

public void getUserInfo（String name,String age,String sex,String mobile){
  // do something ...
}

如果現在需要多傳一個version參數進來，并且你的公有方法是類似dubbo這種對外提供的接口的話，那麼你的接口是不是需要相容老版本啦？

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對象包裝一下這些參數呢~如下：

public void getUserInfo（UserInfoParamDTO userInfoParamDTO){
  // do something ...
}

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

用個DTO對象包裝一下，即使後面有參數變動，也可以不用動對外接口了，好處杠杠的。

9. 使用緩沖流，減少IO操作

「反例：」

/**
 *  公衆号：撿田螺的小男孩
 *  @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));
    }
}

運作結果：

正常流讀寫，總共耗時ms:52

使用​

​FileInputStream​

​​、​

​FileOutputStream​

​​實作檔案讀寫功能，是沒有什麼問題的。但是呢，可以使用緩沖流​

​BufferedReader​

​​、​

​BufferedWriter​

​​、​

​BufferedInputStream​

​​、​

​BufferedOutputStream​

​等，減少IO次數，提高讀寫效率。

❝

如果是不帶緩沖的流，讀取到一個位元組或者字元的，就會直接輸出資料了。而帶緩沖的流，讀取到一個位元組或者字元時，先不輸出，而是等達到緩沖區的最大容量，才一次性輸出。

❞

「正例：」

/**
 *  公衆号：撿田螺的小男孩
 *  @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));
    }
}

運作結果：

緩沖流讀寫，總共耗時ms:12

10. 優化你的程式邏輯，比如前面已經查到的資料，在後面的方法也用到的話，是可以把往下傳參的，減少方法調用/查表

「反例：」

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傳下去的，這樣可以省去一次查表操作，程式更高效。

「正例：」

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枚舉代替。

「反例：」

if("0".equals(userInfo.getVipFlag)){
    //非會員，提示去開通會員
    tipOpenVip(userInfo);
}else if("1".equals(userInfo.getVipFlag)){
    //會員，加勳章傳回
    addMedal（userInfo）;
}

「正例：」

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. 當成員變量值不會改變時，優先定義為靜态常量

「反例：」

public class Task {
    private final long timeout = 10L;
    ...
}

「正例：」

public class Task {
    private static final long TIMEOUT = 10L;
    ...
}

❝

因為如果定義為static，即類靜态常量，在每個執行個體對象中，它隻有一份副本。如果是成員變量，每個執行個體對象中，都各有一份副本。顯然，如果這個變量不會變的話，定義為靜态常量更好一些。

❞

13. 注意檢驗空指針，不要輕易相信業務，說正常邏輯某個參數不可能為空。

NullPointerException 在我們日常開發中非常常見，我們代碼開發過程中，一定要對空指針保持靈敏的嗅覺。

主要有這幾類空指針問題：

  • 包裝類型的空指針問題
  • 級聯調用的空指針問題
  • Equals方法左邊的空指針問題
  • ConcurrentHashMap 類似容器不支援 k-v為 null。
  • 集合，數組直接擷取元素
  • 對象直接擷取屬性

「反例：」

public class NullPointTest {
    public static void main(String[] args) {
        String s = null;
        if (s.equals("666")) { //s可能為空，會導緻空指針問題
            System.out.println("公衆号：撿田螺的小男孩，幹貨滿滿");
        }
    }
}

14，捕獲到的異常，不能忽略它，至少打點日志。

「反例：」

public static void testIgnoreException() throws Exception {
    try {       
        // 搞事情
    } catch (Exception e) {    
        //捕獲了異常，啥事情不做，日志也不打？？
    }
}

「正例：」

public static void testIgnoreException() {
    try {
        // 搞事情
    } catch (Exception e) {     
        log.error("異常了，聯系開發小哥哥看看哈",e); 
    }
}

15. 采用Lambda表達式替換内部匿名類，使代碼更優雅

JDK8出現了新特性-Lambda表達式。Lambda表達式不僅比匿名内部類更加優雅，并且在大多數虛拟機中，都是采用invokeDynamic指令實作，相對于匿名内部類，效率也更高

「反例：」

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);
          }});
      }

「正例：」

public void sortUserInfoList(List<UserInfo> userInfoList){
       userInfoList.sort((user1, user2) -> {
           Long userId1 = user1.getUserId();
           Long userId2 = user2.getUserId();
           return userId1.compareTo(userId2);
       });
   }

16. 通知類（如發郵件，有短信）的代碼，建議異步處理。

假設業務流程這樣：需要在使用者登陸時，添加個短信通知它的粉絲。很容易想到的實作流程如下：

工作四年，分享50個讓你代碼更好的小建議

假設提供sendMsgNotify服務的系統挂了，或者調用sendMsgNotify失敗了，那麼使用者登陸就失敗了。。。一個通知功能導緻了登陸主流程不可用，明顯的撿了芝麻丢西瓜。那麼有沒有魚熊掌兼得的方法呢？有的，給發短信接口捕獲異常處理，或者另開線程異步處理，如下：

工作四年，分享50個讓你代碼更好的小建議

是以，添加通知類等不是非主要，可降級的接口時，應該靜下心來考慮是否會影響主要流程，思考怎麼處理最好。

17. 處理Java日期時，當心YYYY格式設定的問題。

日常開發中，我們經常需要處理日期。我們要當時日期格式化的時候，年份是大寫​

​YYYY​

​的坑。

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));

運作結果：

2019-12-31 轉 YYYY-MM-dd 格式後 2020-12-31

❝

為什麼明明是2019年12月31号，就轉了一下格式，就變成了2020年12月31号了？因為YYYY是基于周來計算年的，它指向當天所在周屬于的年份，一周從周日開始算起，周六結束，隻要本周跨年，那麼這一周就算下一年的了。正确姿勢是使用yyyy格式。

❞

工作四年，分享50個讓你代碼更好的小建議

18. 如果一個類确定不會被繼承，不會拿來搞AOP騷操作，可以指定final修飾符，如用final修飾一個工具類。

「正例：」

public final class Tools {
    public static void testFinal(){
        System.out.println("工具類方法");
    }
}

一個類指定了final修飾符，它不會被繼承了，并且其所有方法都是final的了。Java編譯器會找機會内聯所有的final方法，提升了Java運作效率。

19. static靜态變量不要依賴spring執行個體化變量，可能會導緻初始化出錯

之前看到項目有類似的代碼。靜态變量依賴于spring容器的bean。

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

這個靜态的smsService有可能擷取不到的，因為類加載順序不是确定的，而以上的代碼，靜态的smsService初始化強制依賴spring容器的執行個體了。正确的寫法可以這樣，如下：

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

20. 與類成員變量無關的方法，應當聲明成靜态方法

有些方法，與執行個體成員變量無關，就可以聲明為靜态方法。這一點，工具類用得很多。「反例如下」：

/**
 * 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一下啦,那不就耗資源去「反複建立對象」了嘛！！

BigDecimalUtils bigDecimalUtils = new BigDecimalUtils（）;
bigDecimalUtils.sum(a,b);

是以可以聲明成靜态變量，使用的時候，直接​

​類名.方法​

​調用即可，正例如下：

/**
 * 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捕捉所有可能的異常。

「反例:」

public void test(){
    try{
        //…抛出 IOException 的代碼調用
        //…抛出 SQLException 的代碼調用
    }catch(Exception e){
        //用基類 Exception 捕捉的所有可能的異常，如果多個層次都這樣捕捉，會丢失原始異常的有效資訊哦
        log.info(“Exception in test,exception:{}”, e);
    }
}

「正例：」

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. 函數不要過度封裝，言簡意赅即可。

「反例：」

// 函數封裝
public static boolean isUserVip(Boolean isVip) {
    return Boolean.TRUE.equals(isVip);
}

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

「正例：」

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

函數不要過度封裝，把意思表達清楚即可。并且，方法調用會引起入棧和出棧，導緻消耗更多的CPU和記憶體，過度封裝，會損耗性能的！

23. 如果變量的初值一定會被覆寫，就沒有必要給變量賦初值。

「反例:」

List<UserInfo> userList = new ArrayList<>();
if (isAll) {
    userList = userInfoDAO.queryAll();
} else {
    userList = userInfoDAO.queryActive();
}

「正例：」

List<UserInfo> userList ;
if (isAll) {
    userList = userInfoDAO.queryAll();
} else {
    userList = userInfoDAO.queryActive();
}

24.金額數值計算要使用BigDecimal

看下這個浮點數計算的例子吧：

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");
        }
    }
}

運作結果：

0.30000000000000004
0.19999999999999996
401.49999999999994
1.2329999999999999

❝

因為計算機是以二進制存儲數值的，對于浮點數也是。對于計算機而言，0.1無法精确表達，這就是為什麼浮點數會導緻精确度缺失的。是以，金額計算，一般都是用BigDecimal 類型

❞

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

其實，使用 BigDecimal 表示和計算浮點數，必須使用字元串的構造方法來初始化 BigDecimal，并且，還要關注BigDecimal的幾位小數點，它有八種舍入模式等

25.  注意Arrays.asList的幾個坑

  • 「基本類型不能作為 Arrays.asList方法的參數，否則會被當做一個參數。」 
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 不支援增删操作。」 
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」 
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關閉的：

/*
 * 關注公衆号，撿田螺的小男孩
 */
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）中，通路速度較慢。
❞ 
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一次性查出來的資料量比較多，建議分頁處理。

「反例：」

select user_id,name,age from user_info ;

「正例：」

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

如果偏移量特别大的時候，查詢效率就變得低下。可以這接種方式優化：

//方案一 ：傳回上次查詢的最大記錄(偏移量)
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. 盡量減少對變量的重複計算

一般我們寫代碼的時候，會以以下的方式實作周遊：

for (int i = 0; i < list.size; i++){

}

如果list資料量比較小那還好。如果list比較大時，可以優化成這樣：

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

}

理由：

  • 對方法的調用，即使是隻有一個語句，也是有有消耗的，比如建立棧幀。如果list比較大時，多次調用list.size也是會有資源消耗的。

30. 修改對外老接口的時候，思考接口的相容性。

很多bug都是因為修改了對外老接口，但是卻不做相容導緻的。關鍵這個問題多數是比較嚴重的，可能直接導緻系統發版失敗的。新手程式員很容易就犯這個錯誤了哦~

是以，如果你的需求是在原來接口上修改，，尤其這個接口是對外提供服務的話，一定要考慮接口相容。舉個例子吧，比如dubbo接口，原本是隻接收A，B參數，現在你加了一個參數C，就可以考慮這樣處理。

//老接口
void oldService(A,B);{
  //相容新接口，傳個null代替C
  newService(A,B,null);
}

//新接口，暫時不能删掉老接口，需要做相容。
void newService(A,B,C);

31 代碼采取措施避免運作時錯誤（如數組邊界溢出，被零除等）

日常開發中，我們需要采取措施規避數組邊界溢出，被零整除，空指針等運作時錯誤。

類似代碼比較常見:

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

是以，應該采取措施，預防一下數組邊界溢出，「正例：」

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

32. 注意 ArrayList.toArray() 強轉的坑 

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)

String[] array1 = list.toArray(new String[0]);//可以正常運作

33. 盡量不在循環裡遠端調用、或者資料庫操作，優先考慮批量進行。

程操作或者資料庫操作都是比較耗網絡、IO資源的，是以盡量不在循環裡遠端調用、不在循環裡操作資料庫，能批量一次性查回來盡量不要循環多次去查。（但是呢，也不要一次性查太多資料哈，要分批500一次醬紫）

「正例：」

remoteBatchQuery(param);

「反例：」

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

34. 寫完代碼，腦洞一下多線程執行會怎樣，注意并發一緻性問題

我們經常見的一些業務場景，就是先查下有沒有記錄，再進行對應的操作（比如修改）。但是呢，(查詢+修改)合在一起不是原子操作哦，腦洞下多線程，就會發現有問題了，

「反例：」

if(isAvailable(ticketId){  //非原子操作 
    1、給現金增加操作 
    2、deleteTicketById(ticketId) 
}else{ 
    return "沒有可用現金券";
}

為了更容易了解它，看這個流程圖吧：

工作四年，分享50個讓你代碼更好的小建議
  • 1.線程A加現金
  • 2.線程B加現金
  • 3.線程A删除票标志
  • 4.線程B删除票标志

顯然這樣存在并發問題，正例應該利用資料庫删除操作的原子性，如下：

if(deleteAvailableTicketById(ticketId) == 1){ //原子操作
    1、給現金增加操作 
}else{ 
    return “沒有可用現金券” 
}

35 多線程異步優先考慮恰當的線程池，而不是new thread,同時考慮線程池是否隔離

為什麼優先使用線程池？使用線程池有這幾點好處呀

  • 它幫我們管理線程，避免增加建立線程和銷毀線程的資源損耗。
  • 提高響應速度。
  • 重複利用。

同時呢，盡量不要所有業務都共用一個線程池，需要考慮線程池隔離。就是不同的關鍵業務，配置設定不同的線程池，然後線程池參數也要考慮恰當哈。之前寫過幾篇線程池的，覺得還不錯，有興趣的朋友可以看一下哈

36. 優化程式結構，盡量減少方法的重複調用

「反例：」

public static void listDetail(List<UserInfo> userInfoList) {
        for (int i = 0; i < userInfoList.size(); i++) {
            //重複調用userList.size()方法了
        }
    }

「正例：」

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才使用這個吧，可以看下它的源碼：

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方法實作，進行資料的批量拷貝效率更高。
❞

「反例：」

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;
 }

「正例：」

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吃了，導緻事務失效。

「反例：」

public class TransactionTest{
  public void A(){
    //插入一條資料
    //調用方法B (本地的類調用，事務失效了)
    B();
  }
  
  @Transactional
  public void B(){
    //插入資料
  }
}

「注解的事務方法給本類方法直接調用，事務失效」

43. 使用Executors聲明線程池，newFixedThreadPool的OOM問題 

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 :

工作四年，分享50個讓你代碼更好的小建議

運作結果：

工作四年，分享50個讓你代碼更好的小建議

我們看下源碼，其實newFixedThreadPool使用的是無界隊列！

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列印。

「反例：」

try{
  // do what you want  
}catch(Exception e){
  e.printStackTrace();
}

「正例：」

try{
  // do what you want  
}catch(Exception e){
  log.info("你的程式有異常啦",e);
}

45. 接口需要考慮幂等性

接口是需要考慮幂等性的，尤其搶紅包、轉賬這些重要接口。最直覺的業務場景，就是使用者連着點兩次，你的接口有沒有hold住。

一般幂等技術方案有這幾種:

  • 查詢操作
  • 唯一索引
  • token機制，防止重複送出
  • 資料庫的delete/update操作
  • 樂觀鎖
  • 悲觀鎖
  • Redis、zookeeper 分布式鎖（以前搶紅包需求，用了Redis分布式鎖）
  • 狀态機幂等

46. 對于行數比較多的函數，建議劃分小函數，增強可讀性。

「反例：」

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);
    }
}

「正例：」

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. 你的關鍵業務代碼，一般建議搞點日志保駕護航。

關鍵業務代碼無論身處何地，都應該有足夠的日志保駕護航。

❝

比如：你實作轉賬業務，轉個幾百萬，然後轉失敗了，接着客戶投訴，然後你還沒有列印到日志，想想那種水深火熱的困境下，你卻毫無辦法。。。

❞

那麼，你的轉賬業務都需要那些日志資訊呢？至少，方法調用前，入參需要列印需要吧，接口調用後，需要捕獲一下異常吧，同時列印異常相關日志吧，如下：

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. 某些可變因素，如紅包皮膚等等，做成配置化是否會更好呢。

假如産品提了個紅包需求，聖誕節的時候，紅包皮膚為聖誕節相關的，春節的時候，紅包皮膚等。

反例:

if(duringChristmas){
   img = redPacketChristmasSkin;
}else if(duringSpringFestival){
   img =  redSpringFestivalSkin;
}

如果到了元宵節的時候，營運小姐姐突然又有想法，紅包皮膚換成燈籠相關的，這時候，是不是要去修改代碼了，重新釋出了？從一開始，實作一張紅包皮膚的配置表，将紅包皮膚做成配置化呢？更換紅包皮膚，隻需修改一下表資料就好了。

49，.直接疊代需要使用的集合,無須在額外操作

直接疊代需要使用的集合，無需通過其它操作擷取資料，比較典型就是Map的疊代周遊：

「反例：」

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

「正例：」

Map<Long, UserDO> userMap = ...;
for (Map.Entry<Long, UserDO> userEntry : userMap.entrySet()) {
    Long userId = userEntry.getKey();
    UserDO user = userEntry.getValue();
    ...
}

50. 政策模式+工廠方法優化備援的if else

「反例：」

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("展示守護勳章");
    }
    ...

首先，我們把每個條件邏輯代碼塊，抽象成一個公共的接口，我們根據每個邏輯條件，定義相對應的政策實作類，可得以下代碼：

//勳章接口
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("會員勳章");
    }
}

接下來，我們再定義政策工廠類，用來管理這些勳章實作政策類，如下：

//勳章服務工産類
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);
    }
}

優化後，正例如下：

ublic class Test {
    public static void main(String[] args) {
        String medalType = "guest";
        IMedalService medalService = MedalServicesFactory.getMedalService(medalType);
        medalService.showMedal();
    }
}

參考與感謝

  • Java編碼技巧之高效代碼50例[1]
  • 寫代碼有這些想法，同僚才不會認為你是複制粘貼程式員[2]
  • 寫代碼有這16個好習慣，可以減少80%非業務的bug[3]
  • Java日常開發的21個坑，你踩過幾個？[4]
  • if-else代碼優化的八種方案[5]

Reference

[1]

反例 正例 公衆号
上一篇: 支付寶異步通知處理(完整 上線版)
下一篇: Linux安裝Redis與Redis Desktop Manager連接配接一、 Linux安裝Redis二、 Redis Desktop Manager連接配接Redis

繼續閱讀