避坑指南 | 那些年，咱們踩過的 Java 坑

做者：陳昌毅，花名常意，高德地圖技術專家，2018 年加入阿里巴巴，一直從事地圖數據採集的相關工做。

原文：https://mp.weixin.qq.com/s/yDFurUS3HXAZsDfoEQkzSQ

前言

中國有句老話叫"事不過三"，指一我的犯了一樣的錯誤，一次兩次三次還能夠原諒，超過三次就不可原諒了。有人指出這個「三」是虛數，用來泛指屢次，因此"事不過三"不包括「三」。至於"事不過三"包不包括「三」，可能跟每一個人的底線有關係，屬於哲學範疇，不在本文的討論範圍以內。

寫代碼也是如此，同一個代碼「坑」，踩第一次叫"長了經驗"，踩第二次叫"加深印象"，踩第三次叫"不長心眼"，踩三次以上就叫"不可救藥"。在本文中，筆者總結了一些代碼坑，描述了問題現象，進行了問題分析，給出了避坑方法。但願你們在平常編碼中，遇到了這類代碼坑，可以提早避讓開來。

1.對象比較方法

JDK1.7 提供的 Objects.equals 方法，很是方便地實現了對象的比較，有效地避免了繁瑣的空指針檢查。

1.1.問題現象

在 JDK1.7 以前，在判斷一個短整型、整型、長整型包裝數據類型與常量是否相等時，咱們通常這樣寫：

Short shortValue = (short)12345;
System.out.println(shortValue == 12345); // true
System.out.println(12345 == shortValue); // true
Integer intValue = 12345;
System.out.println(intValue == 12345); // true
System.out.println(12345 == intValue); // true
Long longValue = 12345L;
System.out.println(longValue == 12345); // true
System.out.println(12345 == longValue); // true複製代碼

從 JDK1.7 以後，提供了 Objects.equals 方法，並推薦使用函數式編程，更改代碼以下：

Short shortValue = (short)12345;
System.out.println(Objects.equals(shortValue, 12345)); // false
System.out.println(Objects.equals(12345, shortValue)); // false
Integer intValue = 12345;
System.out.println(Objects.equals(intValue, 12345)); // true
System.out.println(Objects.equals(12345, intValue)); // true
Long longValue = 12345L;
System.out.println(Objects.equals(longValue, 12345)); // false
System.out.println(Objects.equals(12345, longValue)); // false複製代碼

爲何直接把==替換爲 Objects.equals 方法會致使輸出結果不同？

1.2.問題分析

經過反編譯第一段代碼，咱們獲得語句"System.out.println(shortValue == 12345);"的字節碼指令以下：

7   getstatic java.lang.System.out : java.io.PrintStream [22]
10  aload_1 [shortValue]
11  invokevirtual java.lang.Short.shortValue() : short [28]
14  sipush 12345
17  if_icmpne 24
20  iconst_1
21  goto 25
24  iconst_0
25  invokevirtual java.io.PrintStream.println(boolean) : void [32]複製代碼

原來，編譯器會判斷包裝數據類型對應的基本數據類型，並採用這個基本數據類型的指令進行比較（好比上面字節碼指令中的sipush和if_icmpne等），至關於編譯器自動對常量進行了數據類型的強制轉化。

爲何採用 Objects.equals 方法後，編譯器不自動對常量進行數據類型的強制轉化？經過反編譯第二段代碼，咱們獲得語句 "System.out.println(Objects.equals(shortValue, 12345));" 的字節碼指令以下：

7   getstatic java.lang.System.out : java.io.PrintStream [22]
10  aload_1 [shortValue]
11  sipush 12345
14  invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [28]
17  invokestatic java.util.Objects.equals(java.lang.Object, java.lang.Object) : boolean [33]
20  invokevirtual java.io.PrintStream.println(boolean) : void [39]複製代碼

原來，編譯器根據字面意思，認爲常量 12345 默認基本數據類型是 int ，因此會自動轉化爲包裝數據類型 Integer 。

在 Java 語言中，整數的默認數據類型是 int ，小數的默認數據類型是 double 。

下面來分析一下 Objects.equals 方法的代碼實現：

public static boolean equals(Object a, Object b) {
   return (a == b) || (a != null && a.equals(b));
}複製代碼

其中，語句 「a.equals(b)」 將會使用到 Short.equals 方法。

Short.equals 方法的代碼實現爲：

public boolean equals(Object obj) {
   if (obj instanceof Short) {
       return value == ((Short)obj).shortValue();
  }
   return false;
}複製代碼

經過代碼實現分析：對應語句"System.out.println(Objects.equals(shortValue, 12345));"，由於 Objects.equals 的兩個參數對象類型不一致，一個是包裝數據類型 Short ，另外一個是包裝數據類型 Integer ，因此最終的比較結果必然是 false 。一樣，語句 「System.out.println(Objects.equals(intValue, 12345));」 ，由於 Objects.equals 的兩個參數對象類型一致，都是包裝數據類型Integer且取值同樣，因此最終的比較結果必然是 true 。

1.3.避坑方法

（1）保持良好的編碼習慣，避免數據類型的自動轉化

爲了不數據類型自動轉化，更科學的寫法是直接聲明常量爲對應的基本數據類型。

第一段代碼能夠這樣寫：

Short shortValue = (short)12345;
System.out.println(shortValue == (short)12345); // true
System.out.println((short)12345 == shortValue); // true
Integer intValue = 12345;
System.out.println(intValue == 12345); // true
System.out.println(12345 == intValue); // true
Long longValue = 12345L;
System.out.println(longValue == 12345L); // true
System.out.println(12345L == longValue); // true複製代碼

第二段代碼能夠這樣寫：

Short shortValue = (short)12345;
System.out.println(Objects.equals(shortValue, (short)12345)); // true
System.out.println(Objects.equals((short)12345, shortValue)); // true
Integer intValue = 12345;
System.out.println(Objects.equals(intValue, 12345)); // true
System.out.println(Objects.equals(12345, intValue)); // true
Long longValue = 12345L;
System.out.println(Objects.equals(longValue, 12345L)); // true
System.out.println(Objects.equals(12345L, longValue)); // true複製代碼

（2）藉助開發工具或插件，及早地發現數據類型不匹配問題

在 Eclipse 的問題窗口中，咱們會看到這樣的提示：

Unlikely argument type for equals(): int seems to be unrelated to Short
Unlikely argument type for equals(): Short seems to be unrelated to int
Unlikely argument type for equals(): int seems to be unrelated to Long
Unlikely argument type for equals(): Long seems to be unrelated to int複製代碼

經過 FindBugs 插件掃描，咱們會看到這樣的警告：

Call to Short.equals(Integer) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Integer.equals(Short) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Long.equals(Integer) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]
Call to Integer.equals(Long) in xxx.Xxx.main(String[]) [Scariest(1), High confidence]複製代碼

（3）進行常規性單元測試，儘可能把問題發如今研發階段

「勿以善小而不爲」，不要由於改動很小就不須要進行單元測試了，每每 Bug 都出如今本身過分自信的代碼中。像這種問題，只要進行一次單元測試，是徹底能夠發現問題的。

2.三元表達式拆包

三元表達式是 Java 編碼中的一個固定語法格式：「條件表達式？表達式 1 ：表達式 2 」。三元表達式的邏輯爲：「若是條件表達式成立，則執行表達式 1 ，不然執行表達式 2 」。

2.1.問題現象

boolean condition = false;
Double value1 = 1.0D;
Double value2 = 2.0D;
Double value3 = null;
Double result = condition ? value1 * value2 : value3; // 拋出空指針異常複製代碼

當條件表達式 condition 等於 false 時，直接把 Double 對象 value3 賦值給 Double 對象result，按道理沒有問題呀，爲何會拋出空指針異常（NullPointerException）？

2.2.問題分析

經過反編譯代碼，咱們獲得語句"Double result = condition ? value1 * value2 : value3;"的字節碼指令以下：

17  iload_1 [condition]
18  ifeq 33
21  aload_2 [value1]
22  invokevirtual java.lang.Double.doubleValue() : double [24]
25  aload_3 [value2]
26  invokevirtual java.lang.Double.doubleValue() : double [24]
29  dmul
30  goto 38
33  aload 4 [value3]
35  invokevirtual java.lang.Double.doubleValue() : double [24]
38  invokestatic java.lang.Double.valueOf(double) : java.lang.Double [16]
41  astore 5 [result]
43  getstatic java.lang.System.out : java.io.PrintStream [28]
46  aload 5 [result]複製代碼

在第 33 行，加載 Double 對象 value3 到操做數棧中；在第 35 行，調用 Double 對象 value3 的 doubleValue 方法。這個時候，因爲 value3 是空對象 null ，調用 doubleValue 方法必然拋出拋出空指針異常。可是，爲何要把空對象 value3 轉化爲基礎數據類型 double ？

查閱相關資料，獲得三元表達式的類型轉化規則：

1. 若兩個表達式類型相同，返回值類型爲該類型；
2. 若兩個表達式類型不一樣，但類型不可轉換，返回值類型爲Object類型；
3. 若兩個表達式類型不一樣，但類型能夠轉化，先把包裝數據類型轉化爲基本數據類型，而後按照基本數據類型的轉換規則（byte<short(char)<int<long<float<double）來轉化，返回值類型爲優先級最高的基本數據類型。

根據規則分析，表達式 1（value1 * value2）計算後返回基礎數據類型 double ，表達式 2（value3） 返回包裝數據類型 Double ，根據三元表達式的類型轉化規則判斷，最終的返回類型爲基礎數據類型 double 。因此，當條件表達式 condition 等於 false 時，須要把空對象 value3 轉化爲基礎數據類型 double ，因而就調用了 value3 的 doubleValue 方法拋出了空指針異常。

能夠用如下案例驗證三元表達式的類型轉化規則：

boolean condition = false;
Double value1 = 1.0D;
Double value2 = 2.0D;
Double value3 = null;
Integer value4 = null;
// 返回類型爲Double,不拋出空指針異常
Double result1 = condition ? value1 : value3;
// 返回類型爲double,會拋出空指針異常
Double result2 = condition ? value1 : value4;
// 返回類型爲double,不拋出空指針異常
Double result3 = !condition ? value1 * value2 : value3;
// 返回類型爲double,會拋出空指針異常
Double result4 = condition ? value1 * value2 : value3;複製代碼

2.3.避坑方法

（1）儘可能避免使用三元表達式，能夠採用 if-else 語句代替

若是三元表達式中有算術計算和包裝數據類型，能夠考慮利用 if-else 語句代替。改寫代碼以下：

boolean condition = false;
Double value1 = 1.0D;
Double value2 = 2.0D;
Double value3 = null;
Double result;
if (condition) {
   result = value1 * value2;
} else {
   result = value3;
}複製代碼

（2）儘可能使用基本數據類型，避免數據類型的自動轉化

若是三元表達式中有算術計算和包裝數據類型，能夠考慮利用 if-else 語句代替。改寫代碼以下：

boolean condition = false;
double value1 = 1.0D;
double value2 = 2.0D;
double value3 = 3.0D;
double result = condition ? value1 * value2 : value3;複製代碼

（3）進行覆蓋性單元測試，儘可能把問題發如今研發階段

像這種問題，只要編寫一些單元測試用例，進行一些覆蓋性測試，是徹底能夠提早發現的。

3.泛型對象賦值

Java 泛型是 JDK1.5 中引入的一個新特性，其本質是參數化類型，即把數據類型作爲一個參數使用。

3.1.問題現象

在作用戶數據分頁查詢時，由於筆誤編寫了以下代碼：

（1）PageDataVO.java：

/** 分頁數據VO類 */
@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class PageDataVO<T> {
   /** 總共數量 */
   private Long totalCount;
   /** 數據列表 */
   private List<T> dataList;
}複製代碼

（2）UserDAO.java：

/** 用戶DAO接口 */
@Mapper
public interface UserDAO {
   /** 統計用戶數量 */
   public Long countUser(@Param("query") UserQueryVO query);
   /** 查詢用戶信息 */
   public List<UserDO> queryUser(@Param("query") UserQueryVO query);
}複製代碼

（3）UserService.java：

/** 用戶服務類 */
@Service
public class UserService {
   /** 用戶DAO */
   @Autowired
   private UserDAO userDAO;

   /** 查詢用戶信息 */
   public PageDataVO<UserVO> queryUser(UserQueryVO query) {
       List<UserDO> dataList = null;
       Long totalCount = userDAO.countUser(query);
       if (Objects.nonNull(totalCount) && totalCount.compareTo(0L) > 0) {
           dataList = userDAO.queryUser(query);
      }
       return new PageDataVO(totalCount, dataList);
  }
}複製代碼

（4）UserController.java：

/** 用戶控制器類 */
@Controller
@RequestMapping("/user")
public class UserController {
   /** 用戶服務 */
   @Autowired
   private UserService userService;

   /** 查詢用戶 */
   @ResponseBody
   @RequestMapping(value = "/query", method = RequestMethod.POST)
   public Result<PageDataVO<UserVO>> queryUser(@RequestBody UserQueryVO query) {
       PageDataVO<UserVO> pageData = userService.queryUser(query);
       return ResultBuilder.success(pageData);
  }
}複製代碼

以上代碼沒有任何編譯問題，可是卻把 UserDO 中一些涉密字段返回給前端。細心的讀者可能已經發現了，在 UserService 類的 queryUser 方法的語句" return new PageDataVO(totalCount, dataList);"中，咱們把List<UserDO>對象dataList賦值給了PageDataVO<UserVO>的List<UserVO>字段dataList。

問題是：爲何開發工具不報編譯錯誤啦？

3.2.問題分析

因爲歷史緣由，參數化類型和原始類型須要兼容。咱們以 ArrayList 舉例子，來看看如何兼容的。

之前的寫法：

ArrayList list = new ArrayList();複製代碼

如今的寫法：

ArrayList<String> list = new ArrayList<String>();複製代碼

考慮到與之前的代碼兼容，各類對象引用之間傳值，必然會出現如下的狀況：

// 第一種狀況
ArrayList list1 = new ArrayList<String>();
// 第二種狀況
ArrayList<String> list2 = new ArrayList();複製代碼

因此， Java 編譯器對以上兩種類型進行了兼容，不會出現編譯錯誤，但會出現編譯告警。可是，個人開發工具在編譯時真沒出現過告警。

再來分析咱們遇到的問題，實際上同時命中了兩種狀況：

（1）把 List<UserDO> 對象賦值給 List ，命中了第一種狀況；

（2）把 PageDataVO 對象賦值給 PageDataVO<UserVO> ，命中了第二種狀況。

最終的效果就是：咱們神奇地把 List<UserDO> 對象賦值給了 List<UserVO> 。

問題的根源就是：咱們在初始化 PageDataVO 對象時，沒有要求強制進行類型檢查。

3.3.避坑方法

（1）在初始化泛型對象時，推薦使用 diamond 語法

在《阿里巴巴 Java 開發手冊》中，有這麼一條推薦規則：

【推薦】集合泛型定義時，在 JDK7 及以上，使用 diamond 語法或全省略。說明：菱形泛型，即 diamond，直接使用<>來指代前邊已經指定的類型。正例：

// <> diamond 方式
HashMap<String, String> userCache = new HashMap<>(16);
// 全省略方式
ArrayList<User> users = new ArrayList(10);複製代碼

其實，初始化泛型對象時，全省略是不推薦的。這樣會避免類型檢查，從而形成上面的問題。

在初始化泛型對象時，推薦使用 diamond 語法，代碼以下：

return new PageDataVO<>(totalCount, dataList);複製代碼

如今，在 Eclipse 的問題窗口中，咱們會看到這樣的錯誤：

Cannot infer type arguments for PageDataVO<>複製代碼

因而，咱們就知道忘了把 List<UserDO> 對象轉化爲 List<UserVO> 對象了。

（2） 在進行單元測試時，須要對比數據內容

在進行單元測試時，運行正常是一個指標，但數據正確纔是更重要的指標。

4.泛型屬性拷貝

Spring 的 BeanUtils.copyProperties 方法，是一個很好用的屬性拷貝工具方法。

4.1.問題現象

根據數據庫開發規範，數據庫表格必須包含 id，gmt_create，gmt_modified 三個字段。其中， id 這個字段，可能根據數據量不一樣，採用 int 或 long 類型（注意：阿里規範要求必須是 long 類型，這裏爲了舉例說明，容許爲 int 或 long 類型）。

因此，把這三個字段抽出來，定義了一個 BaseDO 基類：

/** 基礎DO類 */
@Getter
@Setter
@ToString
public class BaseDO<T> {
   private T id;
   private Date gmtCreate;
   private Date gmtModified;
}複製代碼

針對 user 表，定義了一個 UserDO 類：

/** 用戶DO類 */
@Getter
@Setter
@ToString
public class UserDO extends BaseDO<Long>{
   private String name;
   private String description;
}複製代碼

對於查詢接口，定義了一個 UserVO 類：

/** 用戶VO類 */
@Getter
@Setter
@ToString
public static class UserVO {
   private Long id;
   private String name;
   private String description;
}複製代碼

實現查詢用戶服務接口，實現代碼以下：

/** 用戶服務類 */
@Service
public class UserService {
   /** 用戶DAO */
   @Autowired
   private UserDAO userDAO;

   /** 查詢用戶 */
   public List<UserVO> queryUser(UserQueryVO query) {
       // 查詢用戶信息
       List<UserDO> userDOList = userDAO.queryUser(query);
       if (CollectionUtils.isEmpty()) {
           return Collections.emptyList();
      }

       // 轉化用戶列表
       List<UserVO> userVOList = new ArrayList<>(userDOList.size());
       for (UserDO userDO : userDOList) {
           UserVO userVO = new UserVO();
           BeanUtils.copyProperties(userDO, userVO);
           userVOList.add(userVO);
      }

       // 返回用戶列表
       return userVOList;
  }
}複製代碼

經過測試，咱們會發現一個問題——調用查詢用戶服務接口，用戶 ID 的值並無返回。

[{"description":"This is a tester.","name":"tester"},...]複製代碼

4.2.問題分析

按道理，UserDO 類和 UserVO 類的 id 字段，類型都是 Long 類型，不存在類型不可轉化，應該可以正常賦值。嘗試手工賦值，代碼以下：

for (UserDO userDO : userDOList) {
   UserVO userVO = new UserVO();
   userVO.setId(userDO.getId());
   userVO.setName(userDO.getName());
   userVO.setDescription(userDO.getDescription());
   userVOList.add(userVO);
}複製代碼

通過測試，上面代碼返回結果正常，用戶ID的值成功返回。

那麼，就是 BeanUtils.copyProperties 工具方法的問題了。用 Debug 模式運行，進入到 BeanUtils.copyProperties 工具方法內部，獲得如下數據：

原來， UserDO 類的 getId 方法返回類型不是 Long 類型，而是被泛型還原成了 Object 類型。而下面的 ClassUtils.isAssignable 工具方法，判斷是否可以把 Object 類型賦值給 Long 類型，固然會返回 false 致使不能進行屬性拷貝。

爲何做者不考慮"先獲取屬性值，再判斷可否賦值」？建議代碼以下：

Object value = readMethod.invoke(source);
if (Objects.nonNull(value) && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], value.getClass())) {
  ... // 賦值相關代碼
}複製代碼

4.3.避坑方法

（1）不要盲目地相信第三方工具包，任何工具包都有可能存在問題

在 Java 中，存在不少第三方工具包，好比：Apache 的 commons-lang3 、 commons-collections ， Google 的 guava …… 都是很好用的第三方工具包。可是，不要盲目地相信第三方工具包，任何工具包都有可能存在問題。

（2）若是須要拷貝的屬性較少，能夠手動編碼進行屬性拷貝

用 BeanUtils.copyProperties 反射拷貝屬性，主要優勢是節省了代碼量，主要缺點是致使程序性能降低。因此，若是須要拷貝的屬性較少，能夠手動編碼進行屬性拷貝。

（3）必定要進行單元測試，必定要對比數據內容

在編寫完代碼後，必定要進行單元測試，必定要對比數據內容。切莫想固然地認爲：工具包很成熟、代碼也很簡單，不可能出現問題。

5.Set對象排重

在 Java 語言中， Set 數據結構能夠用於對象排重，常見的 Set 類有 HashSet 、 LinkedHashSet 等。

5.1.問題現象

編寫了一個城市輔助類，從 CSV 文件中讀取城市數據：

/** 城市輔助類 */
@Slf4j
public class CityHelper {
   /** 測試主方法 */
   public static void main(String[] args) {
       Collection<City> cityCollection = readCities2("cities.csv");
       log.info(JSON.toJSONString(cityCollection));
  }

/** 讀取城市 */
   public static Collection<City> readCities(String fileName) {
       try (FileInputStream stream = new FileInputStream(fileName);
           InputStreamReader reader = new InputStreamReader(stream, "GBK");
           CSVParser parser = new CSVParser(reader, CSVFormat.DEFAULT.withHeader())) {
           Set<City> citySet = new HashSet<>(1024);
           Iterator<CSVRecord> iterator = parser.iterator();
           while (iterator.hasNext()) {
               citySet.add(parseCity(iterator.next()));
          }
           return citySet;
      } catch (IOException e) {
           log.warn("讀取全部城市異常", e);
      }
       return Collections.emptyList();
  }

/** 解析城市 */
   private static City parseCity(CSVRecord record) {
       City city = new City();
       city.setCode(record.get(0));
       city.setName(record.get(1));
       return city;
  }

   /** 城市類 */
   @Getter
   @Setter
   @ToString
   private static class City {
       /** 城市編碼 */
       private String code;
       /** 城市名稱 */
       private String name;
  }
}複製代碼

代碼中使用 HashSet 數據結構，目的是爲了不城市數據重複，對讀取的城市數據進行強制排重。

當輸入文件內容以下時：

編碼,名稱
010,北京
020,廣州
010,北京複製代碼

解析後的 JSON 結果以下：

[{"code":"010","name":"北京"},{"code":"020","name":"廣州"},{"code":"010","name":"北京"}]複製代碼

可是，並無對城市「北京」進行排重。

5.2.問題分析

當向集合 Set 中增長對象時，首先集合計算要增長對象的 hashCode ，根據該值來獲得一個位置用來存放當前對象。如在該位置沒有一個對象存在的話，那麼集合 Set 認爲該對象在集合中不存在，直接增長進去。若是在該位置有一個對象存在的話，接着將準備增長到集合中的對象與該位置上的對象進行 equals 方法比較：若是該 equals 方法返回 false ，那麼集合認爲集合中不存在該對象，就把該對象放在這個對象以後；若是 equals 方法返回 true ，那麼就認爲集合中已經存在該對象了，就不會再將該對象增長到集合中了。因此，在哈希表中判斷兩個元素是否重複要使用到 hashCode 方法和 equals 方法。hashCode 方法決定數據在表中的存儲位置，而 equals 方法判斷表中是否存在相同的數據。

分析上面的問題，因爲沒有重寫 City 類的 hashCode 方法和 equals 方法，就會採用 Object 類的 hashCode 方法和 equals 方法。其實現以下：

public native int hashCode();
public boolean equals(Object obj) {
   return (this == obj);
}複製代碼

能夠看出： Object 類的 hashCode 方法是一個本地方法，返回的是對象地址； Object 類的 equals 方法只比較對象是否相等。因此，對於兩條徹底同樣的北京數據，因爲在解析時初始化了不一樣的 City 對象，致使 hashCode 方法和 equals 方法值都不同，必然被 Set 認爲是不一樣的對象，因此沒有進行排重。

那麼，咱們就重寫把 City 類的 hashCode 方法和 equals 方法，代碼以下：

/** 城市類 */
@Getter
@Setter
@ToString
private static class City {
   /** 城市編碼 */
   private String code;
   /** 城市名稱 */
   private String name;

   /** 判斷相等 */
   @Override
   public boolean equals(Object obj) {
       if (obj == this) {
           return true;
      }
       if (Objects.isNull(obj)) {
           return false;
      }
       if (obj.getClass() != this.getClass()) {
           return false;
      }
       return Objects.equals(this.code, ((City)obj).code);
  }

   /** 哈希編碼 */
   @Override
   public int hashCode() {
       return Objects.hashCode(this.code);
  }
}複製代碼

從新支持測試程序，解析後的JSON結果以下：

[{"code":"010","name":"北京"},{"code":"020","name":"廣州"}]複製代碼

結果正確，已經對城市「北京」進行排重。

5.3.避坑方法

（1）當肯定數據惟一時，可使用List代替Set

當肯定解析的城市數據惟一時，就沒有必要進行排重操做，能夠直接使用 List 來存儲。

List<City> citySet = new ArrayList<>(1024);
Iterator<CSVRecord> iterator = parser.iterator();
while (iterator.hasNext()) {
   citySet.add(parseCity(iterator.next()));
}
return citySet;複製代碼

（2） 當肯定數據不惟一時，可使用 Map 代替 Set

當肯定解析的城市數據不惟一時，須要安裝城市名稱進行排重操做，能夠直接使用 Map 進行存儲。爲何不建議實現 City 類的 hashCode 方法，再採用 HashSet 來實現排重呢？首先，不但願把業務邏輯放在模型 DO 類中；其次，把排重字段放在代碼中，便於代碼的閱讀、理解和維護。

Map<String, City> cityMap = new HashMap<>(1024);
Iterator<CSVRecord> iterator = parser.iterator();
while (iterator.hasNext()) {
   City city = parseCity(iterator.next());
   cityMap.put(city.getCode(), city);
}
return cityMap.values();複製代碼

（3）遵循Java語言規範，重寫hashCode方法和equals方法

不重寫hashCode方法和equals方法的自定義類不該該在Set中使用。

6.公有方法代理

SpringCGLIB 代理生成的代理類是一個繼承被代理類，經過重寫被代理類中的非 final 的方法實現代理。因此， SpringCGLIB 代理的類不能是 final 類，代理的方法也不能是final 方法，這是由繼承機制限制的。

6.1.問題現象

這裏舉例一個簡單的例子，只有超級用戶纔有刪除公司的權限，而且全部服務函數被 AOP 攔截處理異常。例子代碼以下：

（1）UserService.java：

/** 用戶服務類 */
@Service
public class UserService {
   /** 超級用戶 */
   private User superUser;

/** 設置超級用戶 */
   public void setSuperUser(User superUser) {
       this.superUser = superUser;
  }

   /** 獲取超級用戶 */
   public final User getSuperUser() {
       return this.superUser;
  }
}複製代碼

（2）CompanyService.java：

/** 公司服務類 */
@Service
public class CompanyService {
   /** 公司DAO */
   @Autowired
   private CompanyDAO companyDAO;
   /** 用戶服務 */
   @Autowired
   private UserService userService;

   /** 刪除公司 */
   public void deleteCompany(Long companyId, Long operatorId) {
       // 設置超級用戶
       userService.setSuperUser(new User(0L, "admin", "超級用戶"));

       // 驗證超級用戶
       if (!Objects.equals(operatorId, userService.getSuperUser().getId())) {
           throw new ExampleException("只有超級用戶才能刪除公司");
      }

       // 刪除公司信息
       companyDAO.delete(companyId, operatorId);
  }
}複製代碼

（3）AopConfiguration.java：

/** AOP配置類 */
@Slf4j
@Aspect
@Configuration
public class AopConfiguration {
   /** 環繞方法 */
   @Around("execution(* org.changyi.springboot.service..*.*(..))")
   public Object around(ProceedingJoinPoint joinPoint) {
       try {
           log.info("開始調用服務方法...");
           return joinPoint.proceed();
      } catch (Throwable e) {
           log.error(e.getMessage(), e);
           throw new ExampleException(e.getMessage(), e);
      }
  }
}複製代碼

當咱們調用 CompanyService的deleteCompany 方法時，竟然也拋出空指針異常（NullPointerException），由於調用 UserService 類的 getSuperUser 方法獲取的超級用戶爲 null 。可是，咱們在 CompanyService 類的 deleteCompany 方法中，每次都經過 UserService 類的 setSuperUser 方法強制指定了超級用戶，按道理經過 UserService 類的 getSuperUser 方法獲取到的超級用戶不該該爲 null 。其實，這個問題也是由 AOP 代理致使的。

6.2.問題分析

使用SpringCGLIB代理類時，Spring會建立一個名爲 UserService$$EnhancerBySpringCGLIB$$???????? 的代理類。反編譯這個代理類，獲得如下主要代碼：

public class UserService$$EnhancerBySpringCGLIB$$a2c3b345 extends UserService implements SpringProxy, Advised, Factory {
  ......
   public final void setSuperUser(User var1) {
       MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
       if (var10000 == null) {
           CGLIB$BIND_CALLBACKS(this);
           var10000 = this.CGLIB$CALLBACK_0;
      }

       if (var10000 != null) {
           var10000.intercept(this, CGLIB$setSuperUser$0$Method, new Object[]{var1}, CGLIB$setSuperUser$0$Proxy);
      } else {
           super.setSuperUser(var1);
      }
  }
  ......
}複製代碼

能夠看出，這個代理類繼承了 UserService 類，代理了 setSuperUser 方法，可是沒有代理 getSuperUser 方法。因此，當咱們調用 setSuperUser 方法時，設置的是原始對象實例的 superUser 字段值；而當咱們調用 getSuperUser 方法時，獲取的是代理對象實例的 superUser 字段值。若是把這兩個方法的 final 修飾符互換，一樣存在獲取超級用戶爲 null 的問題。

6.3.避坑方法

（1）嚴格遵循 CGLIB 代理規範，被代理的類和方法不要加 final 修飾符

嚴格遵循 CGLIB 代理規範，被代理的類和方法不要加 final 修飾符，避免動態代理操做對象實例不一樣（原始對象實例和代理對象實例），從而致使數據不一致或空指針問題。

（2）縮小 CGLIB 代理類的範圍，能不用被代理的類就不要被代理

縮小 CGLIB 代理類的範圍，能不用被代理的類就不要被代理，便可以節省內存開銷，又能夠提升函數調用效率。

7.公有字段代理

在 fastjson 強制升級到 1.2.60 時踩過一個坑，做者爲了開發快速，在 ParseConfig 中定義了：

public class ParseConfig {
   public final SymbolTable symbolTable = new SymbolTable(4096);
  ......
}複製代碼

在咱們的項目中繼承了該類，同時又被 AOP 動態代理了，因而一行代碼引發了一場「血案」。

7.1.問題現象

仍然使用上章的例子，可是把獲取、設置方法刪除，定義了一個公有字段。例子代碼以下：

（1）UserService.java：

/** 用戶服務類 */
@Service
public class UserService {
   /** 超級用戶 */
   public final User superUser = new User(0L, "admin", "超級用戶");
  ......
}複製代碼

（2）CompanyService.java：

/** 公司服務類 */
@Service
public class CompanyService {
   /** 公司DAO */
   @Autowired
   private CompanyDAO companyDAO;
   /** 用戶服務 */
   @Autowired
   private UserService userService;

   /** 刪除公司 */
   public void deleteCompany(Long companyId, Long operatorId) {
       // 驗證超級用戶
       if (!Objects.equals(operatorId, userService.superUser.getId())) {
           throw new ExampleException("只有超級用戶才能刪除公司");
      }

       // 刪除公司信息
       companyDAO.delete(companyId, operatorId);
  }
}複製代碼

（3）AopConfiguration.java：

同上一章 AopConfiguration.java 。

當咱們調用 CompanyService的deleteCompany 方法時，竟然拋出空指針異常（NullPointerException）。通過調試打印，發現是 UserService的superUser 變量爲null。若是把AopConfiguration刪除，就不會出現空指針異常，說明這個問題是由AOP代理致使的。

7.2.問題分析

使用 SpringCGLIB 代理類時， Spring 會建立一個名爲 UserService$$EnhancerBySpringCGLIB$$???????? 的代理類。這個代理類繼承了 UserService 類，並覆蓋了 UserService 類中的全部非 final 的 public 的方法。可是，這個代理類並不調用 super 基類的方法；相反，它會建立的一個成員 userService 並指向原始的 UserService 類對象實例。如今，內存中存在兩個對象實例：一個是原始的 UserService 對象實例，另外一個指向 UserService 的代理對象實例。這個代理類只是一個虛擬代理，它繼承了 UserService 類，而且具備與 UserService 相同的字段，可是它歷來不會去初始化和使用它們。因此，一但經過這個代理類對象實例獲取公有成員變量時，將返回一個默認值 null 。

7.3.避坑方法

（1）當肯定字段不可變時，能夠定義爲公有靜態常量

當肯定字段不可變時，能夠定義爲公有靜態常量，並用類名稱+字段名稱訪問。類名稱+字段名稱訪問公有靜態常量，與類實例的動態代理無關。

/** 用戶服務類 */
@Service
public class UserService {
   /** 超級用戶 */
   public static final User SUPER_USER = new User(0L, "admin", "超級用戶");
  ......
}

/** 使用代碼 */
if (!Objects.equals(operatorId, UserService.SUPER_USER.getId())) {
   throw new ExampleException("只有超級用戶才能刪除公司");
}複製代碼

（2）當肯定字段不可變時，能夠定義爲私有成員變量

當肯定字段不可變時，能夠定義爲私有成員變量，提供一個公有方法獲取該變量值。當該類實例被動態代理時，代理方法會調用被代理方法，從而返回被代理類的成員變量值。

/** 用戶服務類 */
@Service
public class UserService {
   /** 超級用戶 */
   private User superUser = new User(0L, "admin", "超級用戶");
   /** 獲取超級用戶 */
   public User getSuperUser() {
       return this.superUser;
  }
  ......
}

/** 使用代碼 */
if (!Objects.equals(operatorId, userService.getSuperUser().getId())) {
   throw new ExampleException("只有超級用戶才能刪除公司");
}複製代碼

（3）遵循 JavaBean 編碼規範，不要定義公有成員變量

遵循 JavaBean 編碼規範，不要定義公有成員變量。JavaBean 規範以下：

(1)JavaBean類必須是一個公共類，並將其訪問屬性設置爲public，如：public class User{......}(2)JavaBean類必須有一個空的構造函數：類中必須有一個不帶參數的公用構造器(3)一個JavaBean類不該有公共實例變量，類變量都爲private，如：private Integer id;(4)屬性應該經過一組getter/setter方法來訪問。

後記

人類受益於「類比」思惟，觸類旁通就是人類的智慧，每當遇到新生事物時，人們每每用相似的已知事物做爲參考，可以加速對新生事物的認知。而人類又受制於「定勢」思惟，由於已知事物並不能表明新生事物，而人們又容易造成先入爲主的概念，最終致使對新生事物產生誤判。

最後

歡迎關注公衆號：程序員追風，領取一線大廠Java面試題總結+各知識點學習思惟導+一份300頁pdf文檔的Java核心知識點總結！

這些資料的內容都是面試時面試官必問的知識點，篇章包括了不少知識點，其中包括了有基礎知識、Java集合、JVM、多線程併發、spring原理、微服務、Netty 與RPC 、Kafka、日記、設計模式、Java算法、數據庫、Zookeeper、分佈式緩存、數據結構等等。