景

問題和思考：

1. 序列化參數有枚舉屬性，序列化端增加一個枚舉，能否正常反序列化？
2. 序列化子類，它和父類有同名參數，反序列化時，同名參數能否能正常賦值？
3. 序列化對象增加參數，反序列化類不增加參數，能否正常反序列化？
4. 用于序列化傳輸的屬性，用包裝器比較好，還是基本類型比較好？

為什么要使用序列化和反序列化

1.程序在運行過程中，產生的數據，不能一直保存在內存中，需要暫時或永久存儲到介質（如磁盤、數據庫、文件）里進行保存，也可能通過網絡發送給協作者。程序獲取原數據，需要從介質，或網絡傳輸獲得。傳輸的過程中，只能使用二進制流進行傳輸。

2.簡單的場景，基本類型數據傳輸。通過雙方約定好參數類型，數據接收方按照既定規則對二進制流進行反序列化。

3.復雜的場景，傳輸數據的參數類型可能包括：基本類型、包裝器類型、自定義類、枚舉、時間類型、字符串、容器等。很難簡單通過約定來反序列化二進制流。需要一個通用的協議，共雙方使用，進行序列化和反序列化。

三種序列化協議及對比

對比

Father father=new Father();
father.name="廚師";
father.comment="川菜館";
father.simpleInt=1;
father.boxInt=new Integer(10);
father.simpleDouble=1;
father.boxDouble=new Double(10);
father.bigDecimal=new BigDecimal(11.5);

運行結果：

jdk序列化結果長度：626，耗時：55
jdk反序列化結果：Father{version=0, name='廚師', comment='川菜館', boxInt=10, simpleInt=1, boxDouble=10.0, simpleDouble=1.0, bigDecimal=11.5}耗時：87

hessian序列化結果長度：182，耗時：56
hessian反序列化結果：Father{version=0, name='廚師', comment='川菜館', boxInt=10, simpleInt=1, boxDouble=10.0, simpleDouble=1.0, bigDecimal=11.5}耗時：7

Fastjson序列化結果長度：119，耗時：225
Fastjson反序列化結果：Father{version=0, name='廚師', comment='川菜館', boxInt=10, simpleInt=1, boxDouble=10.0, simpleDouble=1.0, bigDecimal=11.5}耗時：69

分析：

• jdk 序列化耗時最短，但是序列化結果長度最長，是其它兩種的 3 ～ 5 倍。
• fastjson 序列化結果長度最短，但是耗時是其它兩種的 4 倍左右。
• hessian 序列化耗時與 jdk 差別不大，遠小于 fastjson 序列化耗時。且與 jdk 相比，序列化結果占用空間非常有優勢。另外，hessian 的反序列化速度最快，耗時是其它兩種的 1/10。
• 綜上比較，hessian 在序列化和反序列化表現中，性能最優。

Hessian 序列化實戰

實驗準備

父類

public class Father implements Serializable {

    /**
     * 靜態類型不會被序列化
     */
    private static final long serialVersionUID=1L;

    /**
     * transient 不會被序列化
     */
    transient int version=0;

    /**
     * 名稱
     */
    public String name;

    /**
     * 備注
     */
    public String comment;

    /**
     * 包裝器類型1
     */
    public Integer boxInt;

    /**
     * 基本類型1
     */
    public int simpleInt;

    /**
     * 包裝器類型2
     */
    public Double boxDouble;

    /**
     * 基本類型2
     */
    public double simpleDouble;

    /**
     * BigDecimal
     */
    public BigDecimal bigDecimal;

    public Father() {
    }

    @Override
    public String toString() {
        return "Father{" +
                "version=" + version +
                ", name='" + name + '\'' +
                ", comment='" + comment + '\'' +
                ", boxInt=" + boxInt +
                ", simpleInt=" + simpleInt +
                ", boxDouble=" + boxDouble +
                ", simpleDouble=" + simpleDouble +
                ", bigDecimal=" + bigDecimal +
                '}';
    }
}

子類

public class Son extends Father {

    /**
     * 名稱，與father同名屬性
     */
    public String name;

    /**
     * 自定義類
     */
    public Attributes attributes;

    /**
     * 枚舉
     */
    public Color color;

    public Son() {
    }

}

屬性-自定義類

public class Attributes implements Serializable {

    private static final long serialVersionUID=1L;

    public int value;

    public String msg;

    public Attributes() {
    }

    public Attributes(int value, String msg) {
        this.value=value;
        this.msg=msg;
    }

}

枚舉

public enum Color {

    RED(1, "red"),
    YELLOW(2, "yellow")
    ;

    public int value;

    public String msg;

    Color() {
    }

    Color(int value, String msg) {
        this.value=value;
        this.msg=msg;
    }
}

使用到的對象及屬性設置

Son son=new Son();
son.name="廚師";    // 父子類同名字段，只給子類屬性賦值
son.comment="川菜館";
son.simpleInt=1;
son.boxInt=new Integer(10);
son.simpleDouble=1;
son.boxDouble=new Double(10);
son.bigDecimal=new BigDecimal(11.5);
son.color=Color.RED;
son.attributes=new Attributes(11, "hello");

運行結果分析

使用 Hessian 序列化，結果寫入文件，使用 vim 打開。使用 16 進制方式查看，查看命令：%!xxd

00000000: 4307 6474 6f2e 536f 6e9a 046e 616d 6504  C.dto.Son..name.
00000010: 6e61 6d65 0763 6f6d 6d65 6e74 0662 6f78  name.comment.box
00000020: 496e 7409 7369 6d70 6c65 496e 7409 626f  Int.simpleInt.bo
00000030: 7844 6f75 626c 650c 7369 6d70 6c65 446f  xDouble.simpleDo
00000040: 7562 6c65 0a61 7474 7269 6275 7465 7305  uble.attributes.
00000050: 636f 6c6f 720a 6269 6744 6563 696d 616c  color.bigDecimal
00000060: 6002 e58e a8e5 b888 4e03 e5b7 9de8 8f9c  `.......N.......
00000070: e9a6 869a 915d 0a5c 430e 6474 6f2e 4174  .....].\C.dto.At
00000080: 7472 6962 7574 6573 9205 7661 6c75 6503  tributes..value.
00000090: 6d73 6761 9b05 6865 6c6c 6f43 0964 746f  msga..helloC.dto
000000a0: 2e43 6f6c 6f72 9104 6e61 6d65 6203 5245  .Color..nameb.RE
000000b0: 4443 146a 6176 612e 6d61 7468 2e42 6967  DC.java.math.Big
000000c0: 4465 6369 6d61 6c91 0576 616c 7565 6304  Decimal..valuec.
000000d0: 3131 2e35 0a                             11.5.

對其中的十六進制數逐個分析，可以拆解為一下結構：參考 hessian 官方文檔，鏈接：http://hessian.caucho.com/doc/hessian-serialization.html

序列化原理

序列化規則：

1.被序列化的類必須實現了 Serializable 接口

2.靜態屬性和 transient 變量，不會被序列化。

3.枚舉類型在序列化后，存儲的是枚舉變量的名字

4.序列化結果的結構：類定義開始標識 C -> 類名長度+類名 -> 屬性數量 -> （逐個）屬性名長度+屬性名 -> 開始實例化標識 -> （按照屬性名順序，逐個設置）屬性值（發現某個屬性是一個對象，循環這個過程）

反序列化

通俗原理圖：

解釋：這是前邊的序列化文件，可以對著這個結構理解反序列化的過程。

解釋：讀取到“C”之后，它就知道接下來是一個類的定義，接著就開始讀取類名，屬性個數和每個屬性的名稱。并把這個類的定義緩存到一個_classDefs 的 list 里。

解釋：通過讀取序列化文件，獲得類名后，會加載這個類，并生成這個類的反序列化器。這里會生成一個_fieldMap，key 為反序列化端這個類所有屬性的名稱，value 為屬性對應的反序列化器。

解釋：讀到 6 打頭的 2 位十六進制數時，開始類的實例化和賦值。

遺留問題解答：

• 增加枚舉類型，反序列化不能正常讀取。

• 原因：枚舉類型序列化結果中，枚舉屬性對應的值是枚舉名。反序列化時，通過枚舉類類名+枚舉名反射生成枚舉對象。枚舉名找不到就會報錯。

• 反序列化為子類型，同名屬性值無法正常賦值。

• 序列化對象增加參數，反序列化可以正常運行。

• 原因：反序列化時，是先通過類名加載同名類，并生成同名類的反序列化器，同名類每個屬性對應的反序列化器存儲在一個 map 中。在反序列化二進制文件時，通過讀取到的屬性名，到 map 中獲取對應的反序列化器。若獲取不到，默認是 NullFieldDeserializer.DESER。待到讀值的時候，僅讀值，不作 set 操作

• 序列化和反序列化雙方都使用對象類型時，更改屬性類型，若序列化方不傳輸數據，序列化結果是‘N’，能正常反序列化。但是對于一方是基本類型，更改屬性類型后，因為 hessian 對于基本類型使用不同范圍的值域，所以無法正常序列化。

參考文檔：

• https://zhuanlan.zhihu.com/p/44787200
• https://paper.seebug.org/1131/
• hessian 官方文檔：序列化規則http://hessian.caucho.com/doc/hessian-serialization.html#anchor10
• ASCII 編碼對照表http://ascii.911cha.com/

信大多數的Java后端開發者都聽說過MyBatis，但是用過JPA的人卻相對較少，有些人可能沒有聽說過。JPA在國外比較火用的人也比較多，國內大多被MyBatis的簡單易上手所吸引。相對的，JPA和MyBatis二者之間并沒有可比性，它們所在的層次不一樣，MyBatis和Hibernate一樣屬于ORM層級，而JPA則是在ORM之上Spring做了一些高度的封裝，使之更便于使用。很多人覺得它的學習成本比較高，其實不然。接下來盤點下JPA中的一些使用方法。

JPA官方文檔：https://docs.spring.io/spring-data/jpa/docs/2.5.3/reference/html

依賴引入

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

使用SQL進行CRUD

編寫SQL語句是最基礎的操作，它支持JPQL、HQL（語法無關數據庫類型，底層會自動生成對應數據庫的SQL如MySQL）和原生SQL（需要開發者保證語法與當前連接的數據庫一致）。

示例代碼，以下使用了JPQL的語法

@Repository
public interface UserDao extends JpaRepository<User, Long> {
    //獲取某條數據
    @Query(value="select user from User r where r.username=:username")
    User findFirstByUsername(@Param("username") String username);

    //也可以獲取某一個字段，而不是整行數據
    @Query(value="select user.username from User r where r.id=:id")
    String getUsernameById(@Param("id") Long id);

    //刪除一條數據，注意這里不寫SQL語句也是可以的，語義判定，后面會講
    @Modifying
    void deleteUserById(Long id)
}

保存和更新則更加簡單，直接調用save方法，傳入實體類實例。

public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    @Override
    @Transactional(rollbackFor=Throwable.class)
    public void createUser(User user) {
        //創建和更新都是使用的save
        userDao.save(user);
    }
}

以上就是最基礎最簡單的用法。

如何執行數據庫原生SQL？

上面的章節都是使用了數據庫無關的JPQL語法格式，如果想執行某數據庫特有的SQL函數時，可以指定使用原生SQL，如下代碼引用了官方文檔：

public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value="SELECT * FROM USERS WHERE LASTNAME=?1",
    countQuery="SELECT count(*) FROM USERS WHERE LASTNAME=?1",
    nativeQuery=true)
  Page<User> findByLastname(String lastname, Pageable pageable);
}

以上代碼中使用nativeQuery=true指定了使用原生的SQL，值得注意的是，如果后期更換了數據庫服務，比如從MySQL改為了Oracle，這塊代碼就極有可能不兼容。 Pageable pageable是分頁信息。

無需寫SQL，根據方法語義自動生成實現方法

先看下如下代碼

public interface UserRepository extends Repository<User, Long> {
  List<User> findByEmailAddressAndLastname(String emailAddress, String lastname);
}

可以看出，我沒有寫任何SQL，也不需要實現該接口，就可以直接使用該接口進行查詢。這就是JPA的智能語義分析機制，它在源碼中的實現原理是運行時生成一個代理類，注入到依賴的bean中，根據方法的語義生成實際執行的SQL語句。

如上述代碼中方法名findByEmailAddressAndLastname中的findBy便是一個查詢的主題關鍵字，EmailAddress和Lastname是User表中的字段，And則是判斷的關鍵字。于是，該方法名的含義是根據email地址和lastname查詢用戶列表。那么在生成代理方法時就會根據這些關鍵字生成SQL語句。

常用的主題關鍵字有findBy、getBy、deleteXxxBy、countXxxBy等，條件判斷的關鍵字有And、Or、In等。

更多的關鍵字及用法可以查閱官方文檔：https://docs.spring.io/spring-data/jpa/docs/2.5.3/reference/html/#appendix.query.method.predicate

如何只查詢部分字段并自動填充返回Pojo/DTO實例？

查詢整行數據是很有可能造成回表查詢的，除非是聚簇索引下使用主鍵查詢，因此大多數情況下是只查詢業務關心的字段，而不是整行數據。

通常情況下，一個表對應了一個實體類

以下是一個實體類的定義示例：

@javax.persistence.Table(name="test_user", uniqueConstraints={@UniqueConstraint(columnNames={"username", "emailAddress"})})
@javax.persistence.Entity
public class User implements Serializable {
    private Long id;
    private String role;
    private String username;
    private String emailAddress;
    @Id
    @GenericGenerator(name="snowFlakeIdGenerator", strategy="自定義的id生成策略類")
    @GeneratedValue(generator="snowFlakeIdGenerator")
    @JsonFormat(shape=JsonFormat.Shape.STRING) //Java中的long比js中的長，使用String傳輸
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id=id;
    }
    public String getRole() {
        return role;
    }
    public void setRole(String role) {
        this.role=role;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username=username;
    }
}

接下來定義一個對外接口中用于傳輸的DTO類

package com.demo.dto;

public class UserInfoDTO {
    private Long id;
    private String username;
    private String emailAddress;
    //定義一個有參的構造函數，用于在JPQL語句中構建DTO的實例
    public UserInfoDTO(Long id, String username, String emailAddress) {
        this.id=id;
        this.username=username;
        this.emailAddress=emailAddress;
    }
    public UserInfoDTO() {
        
    }
    // 以下Set、Get方法省略
}

查詢部分字段，并將字段構造成Pojo/DTO對象

public interface UserRepository extends Repository<User, Long> {
    //注意這里返回的是UserInfoDTO而不是User，因此需要編寫JPQL語句
    @Query(value="select new com.demo.dto.UserInfoDTO(r.id, r.username, r.emailAddress) from User r where r.username=:username")
    UserInfoDTO getUserInfoByName(String username);
}

代碼中select new com.demo.dto.UserInfoDTO(r.id, r.username, r.emailAddress)是將查到的id、username、emailAddress字段作為構造參數傳入構建UserInfoDTO實例，沒有進行整表查詢。

其返回的UserInfoDTO實例就是最終需要的，不需要先查出來User在進行復制。

多表連接查詢

在JPA中也可以直接使用JPQL進行多表連接查詢。上一章節講到了可以將查詢到的結果返回自定義的類，只需要重載一個有參的構造函數。與普通的SQL無異，在JPQL的語句中也可以使用left join等關鍵字，將需要的字段信息傳入構造函數中即可。

SELECT * FROM T_NEWS_TEXT
< if test="startdate !=null and startdate !='' and enddate !=null and endate !=''">
AND PUBLISHTIME >=#{startdate} AND PUBLISHTIME <=#{enddate}
AND PUBLISHTIME >=SYSDATE - 7 AND PUBLISHTIME <=SYSDATE

SELECT * FROM T_NEWS_TEXT
WHERE PUBLISHTIME >=DECODE(#{startdate},NULL,SYSDATE-7, #{startdate}) AND PUBLISHTIME <=DECODE(#{enddate},NULL,SYSDATE,#{enddate})

SELECT * FROM TEST
WHERE COL1 > 1 -- 這里是注釋AND COL2=#{a}

 CDATA內部所有東西都會被解析器忽略
select type, shopCouId, imgPath 
from adinfo
WHERE delFlg='0'
and fromDate < #{date} and toDate >=#{date}

SELECT sum(b.netCnt) + #{netCnt,jdbcType=INTEGER}
FROM collectcnt b
WHERE b.shopId=#{shopId,jdbcType=INTEGER}
AND b.delflg='0' 
newCnt=newCnt + 1,
netCnt=netCnt +1,
sumCnt=sumCnt + 1,
AND o.oTime LIKE CONCAT('%',#{sdate},'%')

當數據庫字段類型是整數，如果參數變量為空字符串或者NULL，Mybatis會自動將參數賦值0，所以如果要判斷整數參數的多種狀態在傳遞數值到Mapper之前就要判斷是否為空字符串和NULL并將相應的狀態數值賦值給該參數，否則參數值等于空字符串、NULL和0得到的結果是一樣的。
一般情況下，涉及到int類型的操作的時候，在Service中會統一把數字類型先變成字符串類型，然后再傳遞到Mapper中操作。