一、java实体类型与mysql数据库对应的时间类型

二、java.util.Date、java.sql.Date、java.sql.Time、java.sql.Timestamp的区别

• java.util.Date日期格式为：年月日时分秒
• java.sql.Date日期格式为：年月日[只存储日期数据不存储时间数据]
• java.sql.Time日期格式为：时分秒
• java.sql.Timestamp日期格式为：年月日时分秒纳秒（毫微秒）

• 关系：

java.util.Date这个类是java.sql.Date, java.sql.Time, java.slq.Timestamp这三个类的父类。这三个类对java.util.Date类进行了包装。

• 联系：

• java.sql.Date类屏蔽了java.util.Date类的时间有关的方法（形如：hh:mm:ss）,因此，不可以通过这个类访问时间有关的信息，比如，如果你通过sqlDate.getHour()方法去访问小时信息，此方法会抛出一个IllegalArgumentException异常。这是因为java.sql.Date在继承java.util.Date类的时候对父类进行了重写，禁用了时间访问的方法。之所以这么处理，是为了和数据库的Date数据类型相匹配，数据库的Date数据类行只是保存日期有关的字段。

• Java.sql.Time类屏蔽了java.util.Date的日期有关的字段（形如：yyyy-MM-dd）,因此，不能通过这个类访问日期有关的信息，比如：如果你通过sqlTime.getYear()方法去获取年有关的信息，此方法会抛出一个IllegalArgumentException异常。这是因为java.sql.Time在继承java.util.Date类的时候对父类进行了重写，禁用了日期访问的方法。之所以这么处理，是为了和数据库的Time数据类型相匹配，数据库的Time数据类行只是保存时间有关的字段。

• Java.sql.Timestamp字段则对java.util.Date这个类进行了扩充，它在java.util.Date类的基础上增加了毫秒的时间访问控制，因此，你可以通过getNanos（）方法去获取时间的毫微秒数（注意此处获取的时间是以毫微秒为单位的,1秒等于十亿毫微秒），同样的，这也是为了和数据库中的Timestamp数据类型进行匹配。

• 理清了上述四个类的关系，那么java.util.Date和java.util.Calendar类有什么关系呢？

• Java.util.Calendar类是java.util.Date类的一个更加深入，更加全面的替代。Java.util.Calendar类支持java.util.Date的所有功能，此外，Calendar还引入了多语言，多区域的特性，可以根据需要获取不同区域，不同时区的时间，Calendar还增加了比Date更加方便和快捷的许多操作，如获取一年当中的第几个星期，各个月的天数等便捷的方法。

• 注意：

Java.util.Calendar区别与java.util.Date的几个地方也需要注意一下：首先，Calendar增加了毫秒的时间段，通过它可以获取时间点的毫秒值，而java.util.Date只是精确到秒。其次，Calendar过去年的时候是当前年份比如：2010，而Date获取年份的时获取到的是当前年份-1900的一个值（2010-1900=110，因此，你调用getYear后过去的值就是110）。最后Calendar是一个抽象类，之所以能够实例化，是因为此处的Calendar充当了一个类似于工厂的作用，在getInstance方法中实例化了Calendar子类GregorianCalendar，并把它返回给用户使用。

• 针对不同的数据库选用不同的日期类型

• Oracle的Date类型，只需要年月日，选择使用java.sql.Date类型 ·MS
• Sqlserver数据库的DateTime类型，需要年月日时分秒，选择java.sql.Timestamp类型

三、时间属性到前端的封装

• 基于Jackson

 @DateTimeFormat("yyyy-MM-dd")
 @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd", timezone = "GMT+8")
    private Date clDate;

• 基于fastJson

    @DateTimeFormat("yyyy-MM-dd")
    @JSONField(format = "yyyy-MM-dd" )
    private Date clDate;

注意，基于fastJson的方式一定通过实现WebMvcConfigurer接口的消息转换器配置方法configureMessageConverters来将Fastjson的Http消息转换器加入SpringBoot的Http消息转换器列表，同时还要将fastjson的转换器置于默认的消息转换器，不然还是会被jackson先解析了，参考文章

• 这里还有一个坑，通过注解解析的数据，必须是以@ResponseBody注解的方法才能正确起作用，如果不是@ResponseBody的方式，仍然会返回初始格式，比如我这里mysql中使用的数据是date类型的，那么它返回的默认数据还是英文的…
  这里参考这篇文章

四、导出Excel时的坑

我使用easyexcel导出数据的时候，报以下错误：

Can not find ‘Converter’ support class Date.

这是easyexcel没有java.sql.Date的转换器，需要自定义，如下：

public class DateConverter implements Converter<Date> {
    @Override
    public Class supportJavaTypeKey() {
        return Date.class;
    }
    @Override
    public CellDataTypeEnum supportExcelTypeKey() {
        return CellDataTypeEnum.STRING;
    }
    @Override
    public Date convertToJavaData(CellData cellData, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
        //转换成java.sql.Date
        LocalDate parse = LocalDate.parse(cellData.getStringValue(), DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        return Date.valueOf(parse);
    }
    @Override
    public CellData convertToExcelData(Date date, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
        return new CellData<>(date.toLocalDate().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
    }
}

这里的参考文章

五、LocalDate、LocalTime、LocalDateTime 和mysql交互

Java8里面新出来了一些API，LocalDate(对应date)、LocalTime(对应time)、LocalDateTime(对应datetime) 非常好用。如果想要在JDBC中，使用Java8的日期LocalDate、LocalDateTime，则必须要求数据库驱动的版本不能低于4.2

1. 为什么需要LocalDate、LocalTime、LocalDateTime
   Date如果不格式化，打印出的日期可读性差，如下：

Tue Sep 10 09:34:04 CST 2019

使用SimpleDateFormat对时间进行格式化，但SimpleDateFormat是线程不安全的 SimpleDateFormat的format方法最终调用代码：

private StringBuffer format(Date date, StringBuffer toAppendTo,
                              FieldDelegate delegate) {
        // Convert input date to time field list
        calendar.setTime(date);
        boolean useDateFormatSymbols = useDateFormatSymbols();
        for (int i = 0; i < compiledPattern.length; ) {
            int tag = compiledPattern[i] >>> 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] << 16;
                count |= compiledPattern[i++];
            }
            switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                toAppendTo.append((char)count);
                break;
            case TAG_QUOTE_CHARS:
                toAppendTo.append(compiledPattern, i, count);
                i += count;
                break;
            default:
                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                break;
            }
        }
        return toAppendTo;
    }

calendar是共享变量，并且这个共享变量没有做线程安全控制。当多个线程同时使用相同的SimpleDateFormat对象（如用static修饰的SimpleDateFormat）调用format方法时，多个线程会同时调用calendar.setTime方法，可能一个线程刚设置好time值另外的一个线程马上把设置的time值给修改了导致返回的格式化时间可能是错误的。

在多并发情况下使用SimpleDateFormat需格外注意
SimpleDateFormat除了format是线程不安全以外，parse方法也是线程不安全的。parse方法实际调用alb.establish(calendar).getTime()方法来解析，alb.establish(calendar)方法里主要完成了

• 重置日期对象cal的属性值
• 使用calb中中属性设置cal
• 返回设置好的cal对象，但是这三步不是原子操作

• 多线程并发如何保证线程安全

• 避免线程之间共享一个SimpleDateFormat对象，每个线程使用时都创建一次SimpleDateFormat对象 =>创建和销毁对象的开销大
• 对使用format和parse方法的地方进行加锁 => 线程阻塞性能差
• 使用ThreadLocal保证每个线程最多只创建一次SimpleDateFormat对象 => 较好的方法

Date对时间处理比较麻烦，比如想获取某年、某月、某星期，以及n天以后的时间，如果用Date来处理的话真是太难了，你可能会说Date类不是有getYear、getMonth这些方法吗，获取年月日很Easy，但都被弃用。

2. 使用java8全新的日期和时间API

• 创建LocalDate 只获取某年某月

//获取当前年月日
LocalDate localDate = LocalDate.now();
System.out.println("当前的年月日:"+localDate);
//构造指定的年月日
LocalDate localDate1 = LocalDate.of(2019, 9, 10);
System.out.println("指定的年月日:"+localDate1);

• 获取年、月、日、星期几

LocalDate localDate = LocalDate.now();
int year = localDate.getYear();
int year1 = localDate.get(ChronoField.YEAR);
System.out.println("当前年:"+year);
System.out.println("当前年:"+year1);
Month month = localDate.getMonth();
int month1 = localDate.get(ChronoField.MONTH_OF_YEAR);
System.out.println("当前月:"+month);
System.out.println("当前月:"+month1);
int day = localDate.getDayOfMonth();
int day1 = localDate.get(ChronoField.DAY_OF_MONTH);
System.out.println("当前天:"+day);
System.out.println("当前天:"+day1);
DayOfWeek dayOfWeek = localDate.getDayOfWeek();
int dayOfWeek1 = localDate.get(ChronoField.DAY_OF_WEEK);
System.out.println("当前星期:"+dayOfWeek);
System.out.println("当前星期:"+dayOfWeek1);

• 获取时分秒

LocalTime localTime = LocalTime.of(13, 51, 10);
        LocalTime localTime1 = LocalTime.now();
        System.out.println("当前时间："+localTime);
        System.out.println("当前时间："+localTime1);

        //获取时分秒
        //获取小时
        int hour = localTime.getHour();
        int hour1 = localTime.get(ChronoField.HOUR_OF_DAY);
        System.out.println("当前小时："+hour);
        System.out.println("当前小时："+hour1);
        //获取分
        int minute = localTime.getMinute();
        int minute1 =localTime.get(ChronoField.MINUTE_OF_HOUR);
        System.out.println("当前分钟："+minute);
        System.out.println("当前分钟："+minute1);
        //获取秒
        int second = localTime.getMinute();
        int second1 = localTime.get(ChronoField.SECOND_OF_MINUTE);
        System.out.println("当前秒："+second);
        System.out.println("当前秒："+second1);

• 获取年月日时分秒

LocalDateTime localDateTime = LocalDateTime.now();
LocalDateTime localDateTime1 = LocalDateTime.of(2019, Month.SEPTEMBER, 10, 14, 46, 56);
LocalDateTime localDateTime2 = LocalDateTime.of(localDate, localTime);
LocalDateTime localDateTime3 = localDate.atTime(localTime);
LocalDateTime localDateTime4 = localTime.atDate(localDate);

• LocalDateTime格式化

LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))

和SimpleDateFormat相比，DateTimeFormatter是线程安全的。要注意的是，LocalDateTime无法与时间戳进行转换，因为LocalDateTime没有时区，无法确定某一时刻。而ZonedDateTime相当于LocalDateTime加时区的组合，它具有时区，可以与long表示的时间戳进行转换。可以自行了解。

六、关于LocalDateTime的序列化与反序列化

遇到一个LocalDateTime的序列化与反序列化的问题，正常情况下只需要在返回前端的实体类加上以下标签即可以Json格式返回正常的时间类型：

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;

如果不使用该标签，那么返回前端的时间就会显示的不正常，将会以实体类的形式来展示时间。
如果只使用以下格式：

@JsonSerialize(using = LocalDateTimeSerializer.class)
private LocalDateTime createTime;

则返回的数据类似于：[2020,5,16,0,0]。
所以一定要两个标签都加上，@JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)是反序列特定的日期格式。那么如果将时间进行反序列化之后还要数据显示正常，则需要再加上一个标签。

@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;

这里参考

这是我的第一个第一篇博客
成功的加入it、行业，成为这个行业的大佬
java中实体类的学习
POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通 JavaBean，即我们前面封装数据使用的，实体类。实体类就是模型的定义。Domain存放实体类，domain：这一层是用来管理javaBean实体对象的, 实体类==javaBean。

pojo： 简单java对象。与entity、domain、beans、javabean、model、po、pojo实体类一样的。

在Java中，实体类就是一个拥有Set和Get方法的类。实体类通常总是和数据库之类的（所谓持久层数据）联系在一起。这种联系是借由框架（如Hibernate）来建立的。
　　实体类主要是作为数据管理和业务逻辑处理层面上存在的类别； 它们主要在分析阶段区分 实体类的主要职责是存储和管理系统内部的信息，它也可以有行为，甚至很复杂的行为，但这些行为必须与它所代表的实体对象密切相关。
其实就是只有一些属性在里面的类，只不过对应数据库的属性，只是我们叫他实体类。

什么时候得创建实体类？
实体类创建的时候：比如说你创建一个网站登陆的时候，你需要有一个登陆注册的功能，有这个登陆，注册的属性，你就需要创建一个实体类，设置好参数，给相应的对象调用，实体类所具有的属性，用private来进行封装数据库里面表的数据，所封装的表的属性要和数据库的表的字段名要相同，一一对应。

例如你创建一个学生对象，你需要创建一个实体类，封装好相应的属性，参数，例如年龄，性别，身高，成绩，体重，这些属性，参数，并且提供get和set方法。来给个学生这一个对象来调用，就相当于把年龄，性别，身高，成绩，体重这些参数属性，赋给学生对象，使学生对象拥有这些属性。

比如说数据库里有一个学生表，里面有生日，名字，我们从数据库里查出来的数据需要打包成一个实体类，方便数据的传递吧，在方法的参数里面如果传的不是实体类，而是实体类的成员变量的话就会很麻烦，而且，有时候我们需要得到的数据是实体类，比如学生的话，这时候就需要创建实体类啊

一个实体类就对应着一个数据库的表，假如说数据库里有一个关于学生的表，然后表中有着很多行的数据，每一行的数据都有三列分别是姓名、学号和性别 （我们都知道数据库中的数据是以行列的形式存储数据的）然后就对应着我们实体类中的三个属性。然后我们对数据库进行操作的时候，可以去通过我们的实体类对象直接操作每一个属性，不用去把去用数据库中的每一项去操作每一个属性，这样子我们可以省去很多的代码更重要的是代码更加的简洁明了。

对于大量的数据来说用基本数据类型变量做参数显示不合适. 比如,我要把某个学生的所有信息传到下层, 包括姓名、年龄、 学号、 班级…如果拿变量做参数 ，那在你的方法中起码有n个参数 。这样不仅繁琐而且很容易造成参数匹配上的错误， 而如果拿实体对象做参数则方便的多,只要传一个学生实体就可以了,然后在方法里通过实体属性获取或者设置实体对象里的成员属性值 。

java是面向对象语言，提倡将所有事物看成对象，每一个实体就相当于一个对象，一个实体类有独特的属性和方法，用来体现这个对象的特征，比如一个实体类狗，他可能有的属性，就是名字，性别，年龄，种类等等，而有的方法比如狗叫，吃饭等，实体类说到底就是存储这些属性的东西，
什么时候用到实体类，比如你要调用狗的吃饭方法，就要创建一个实体类，然后new一个对象就可以调用实体类的属性。

实体类的应用场景？
所以我们不能说实体类是一定要有的，但是通常在我们编程的过程中，肯定是有很多的实体类的，因为像用户对像，决策对象，书本对象等等，各种各样的对象。跟你数据相关的对象他都会都会有实体类的。

然后你在如果在数据库中有一个用户的表的话，java就要有相应的对象来保存这些数据，所以这个时候就要创建实体类来封装从数据库中查询的结果，相当于主要是封装用户数据，还有商品啊，其他的数据，都可以封装成对象，这个时候就要创建实体类来创建对象保存数据。

在你用springmvc的时候呢，你是不是要接参数，那你接参数的时候，你进来的参数，比如说一个注册界面，他到了后台可能是一个用户对象，那我们用对象来接这个参数的原因就是我们不需要自己去。接受这些参数，他自动化的处理对象，然后呢对象到了这个数据持久层的时候，他就可以直接自动化存储。
也就是要实现整个过程的全自动化，从接入参数到业务处理到数据持久层的时候，这些对象数据都全自动化封装好，那这样程序员。他开发效率就提高了。

而且还有一点，就是以后你的那个界面展示数据的时候，你的数据到界面的那个数据通常都是一个对象，一个集合对象到页面，他才能把这个数据给显示出来，所以在开发当中实体类是用得很多的。

实体类的好处优点作用：
1、对对象实体的封装，体现OO思想。
2、属性可以对字段定义和状态进行判断和过滤
3、把相关信息用一个实体类封装后，我们在程序中可以把实体类作为参数传递，更加方便。
4、说白了就是为了让程序员在对数据库操作的时候不用写SQL语句
5、就是一个数据库表生成一个类，这样做对数据库操作起来方便，编写代码较少提高效率，可以使程序员专注逻辑关系。
6、实体类就是把对某一个表的操作全写在一个类中.
7、在Java开发中经常要定义一些实体类，这些类的定义的好坏会直接影响，编写代码的质量和难易程度，使程序简洁易懂，便于维护，暗合接口不变原则，体现面向对象思想。
8、实体类实际上是对应着数据库里的每张表的,我们把表里的字段封装在一个实体对象里。当你想用哪个字段，通过该实体对象的属性把那个字段提取出来，这比你临时创建一个变量要灵活的多而且便于程序的维护和扩展.在实际的三层结构开发中实体层的作用就是便于层和层之间的数据传递，在程序中作为数据容器用来持久化存储数据用的。实体类通常都是永久性的，它们所具有的属性和关系是长期需要的，有时甚至在系统的整个生存期都需要。

实体类在MVC三层中的作用？
实体类可以当做是数据库与java业务层之间的容器，实体类主要是作为数据管理和业务逻辑处理层面上存在的类别； 它们主要在分析阶段区分实体类的主要职责是存储和管理系统内部的信息，它也可以有行为，甚至很复杂的行为，但这些行为必须与它所代表的实体对象密切相关。
实体类对应数据库中一个表，实体类的每个属性对应表中相应的字段，使用实体类符合面向对象编程的思想，把一个表封装成一个类。因此我们发现在敲登陆的Demo时实体类——Model中我们存放的都是数据库表中对应的列的数据。

表示层中使用实体类：
1、将解析实体对象中封装的数据展示给用户
2、将用户请求的数据封装到实体对象中
业务逻辑层中使用实体类
1、将接收到的实体对象传递到下一层
2、根据用户请求对实体对象中的数据进行处理。
三、在数据访问层中使用实体类
1、将数据库中的数据封装到实体对象中或将多个实体对象封装成集合
2、将实体对象中的数据保存到数据库中
实体类==javaBean，在MVC设计模型中是model，又称模型层，在一般的程序中，我们称它为数据层，就是用来设置数据的属性和一些行为，然后我会提供获取属性和设置属性的get/set方法
实体： 就是能看的到的具体东西，如人;
属性：就是实体的一个特征或部分，如人的属性有性别，年龄等;
实体集：就是一类相似属性的实体的集合，如男人，或老人等 对应的计算机中，是对于面向对象技术来说的，实体类就是一个拥有Set和Get方法的类。实体类通常总是和数据库之类的（所谓持久层数据）联系在一起。这种联系是借由框架（如hibernate）来建立的。

实体类的创建要点和要求：
方法的类建一个entity包来存放，实体类，就是属性类，通常定义在model层里面，实体类就是数据库在Java代码中对应的。在Java中，实体类就是一个拥有Set和Get方法的类，实体类中的构造方法+set方法+get方法，获取和改变成员变量的值。构造函数，初始化成员变量JavaBean规范规定只使用get/set访问成员变量。
使用实体类需注意以下几点：
1、实体类的名字尽量和数据库的表的名字对应相同。（PS；最好通过驼峰命名及注释，让自己和team知道这个实体类是哪个表）
2、实体类应该实现java.io.Serializable接口（PS:启用其序列化功能）。
3、实体类应该有个无参的构造方法。
4、实体类应该有个有参（所有的参数）的构造方法。
5、实体类有属性和方法，一般的实体类对应一个数据表，其中的属性对应数据库中表的字段，方法主要有getter和setter方法。
6、属性一般是private类型，方法为public类型，对于数据库自动生成的ID字段对应的属性的set方法为private。
7、实体类还应该有个属性serialVersionUID。例如：private static final long serialVersionUID = -6125297654796395674L。
8、属性一般是private类型，方法位public类型，对于数据库自动生成的ID字段对应的属性的set方法应为private。

其次说定义：实体类主要是作为数据管理和业务逻辑处理层面上存在的类别； 它们主要在分析阶段区分 实体类的主要职责是存储和管理系统内部的信息，它也可以有行为，甚至很复杂的行为，但这些行为必须与它所代表的实体对象密切相关。实体类实际上就是 俗称的 POJO（Plain Old Java Objects）简单的Java对象一般不实现特殊框架下的接口，在程序中仅仅作为数据容器用来持久化存储数据用的，它的属性为private 这样写的目的在于封装，不让外部对其进行直接修改和操作，同时又提供了set方法让外部对它进行更改，通过get方法让外部能得到它的值。

最近看了看大佬写的代码发现，在实体类中大佬实现了Serializable接口。
老实说：这个结果我以前貌似学过，但是一直没用过，所以看着一脸懵逼。
但是大佬总不可能乱写啊，谁会没事多写两单词。。。

所以我就去查了查Serializable接口。
下面，我们就来介绍下Serializable接口。

1. 什么是Serializable接口

Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。一个类只有实现了Serializable接口，它的对象才能被序列化。

Serializable序列化接口没有任何方法或者字段，只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流，同时也可以通过ObjectInputStream再将其解析为对象。例如，我们可以将序列化对象写入文件后，再次从文件中读取它并反序列化成对象，也就是说，可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

而这一点对于面向对象的编程语言来说是非常重要的，因为无论什么编程语言，其底层涉及IO操作的部分还是由操作系统其帮其完成的，而底层IO操作都是以字节流的方式进行的，所以写操作都涉及将编程语言数据类型转换为字节流，而读操作则又涉及将字节流转化为编程语言类型的特定数据类型。而Java作为一门面向对象的编程语言，对象作为其主要数据的类型载体，为了完成对象数据的读写操作，也就需要一种方式来让JVM知道在进行IO操作时如何将对象数据转换为字节流，以及如何将字节流数据转换为特定的对象，而Serializable接口就承担了这样一个角色。

2. 什么是序列化

序列化是指把对象转换为字节序列的过程，我们称之为对象的序列化，就是把内存中的这些对象变成一连串的字节(bytes)描述的过程。

而反序列化则相反，就是把持久化的字节文件数据恢复为对象的过程。

3. 为什么要序列化对象

• 把对象转换为字节序列的过程称为对象的序列化
• 把字节序列恢复为对象的过程称为对象的反序列化

4. 什么情况下需要序列化

常用场景：

1. 需要把内存中的对象状态数据保存到一个文件或者数据库中的时候，这个场景是比较常见的，例如我们利用mybatis框架编写持久层insert对象数据到数据库中时;
2. 网络通信时需要用套接字在网络中传送对象时，如我们使用RPC协议进行网络通信时;

当我们需要把对象的状态信息通过网络进行传输，或者需要将对象的状态信息持久化，以便将来使用时都需要把对象进行序列化。

那为什么还要继承Serializable。那是存储对象在存储介质中，以便在下次使用的时候，可以很快捷的重建一个副本。

因为Serializable就相当于一个标识接口，这个Serializable接口其实是给jvm看的，告诉jvm，我不对这个类做序列化了，你(jvm)帮我序列化就好了。

Serializable接口就是Java提供用来进行高效率的异地共享实例对象的机制，实现这个接口即可。

5. 为什么要定义serialversionUID变量

对于JVM来说，要进行持久化的类必须要有一个标记，只有持有这个标记JVM才允许类创建的对象可以通过其IO系统转换为字节数据，从而实现持久化，而这个标记就是Serializable接口。而在反序列化的过程中则需要使用serialVersionUID来确定由那个类来加载这个对象，所以我们在实现Serializable接口的时候，一般还会要去尽量显示地定义serialVersionUID.

如果我们在序列化中没有显示地声明serialVersionUID，则序列化运行时将会根据该类的各个方面计算该类默认的serialVersionUID值。但是，Java官方强烈建议所有要序列化的类都显示地声明serialVersionUID字段，因为如果高度依赖于JVM默认生成serialVersionUID，可能会导致其与编译器的实现细节耦合，这样可能会导致在反序列化的过程中发生意外的InvalidClassException异常。因此，为了保证跨不同Java编译器实现的serialVersionUID值的一致，实现Serializable接口的必须显示地声明serialVersionUID字段。

此外serialVersionUID字段地声明要尽可能使用private关键字修饰，这是因为该字段的声明只适用于声明的类，该字段作为成员变量被子类继承是没有用处的!有个特殊的地方需要注意的是，数组类是不能显示地声明serialVersionUID的，因为它们始终具有默认计算的值，不过数组类反序列化过程中也是放弃了匹配serialVersionUID值的要求。