(Java与JavaScript)时间该何去何从?

(Java与JavaScript)前后端的时间该何去何从?

---

相信无论是披荆斩棘的老鸟还是楚楚动人的菜鸟对于这两门语言中的时间类都是相爱相杀的!

本章就着眼于前端的JavaScript与后台的Java细说他们各自时间类的应用,以及在实际应用中我们应该怎么去进行时间的交互?

## 一概念:

   -1).JavaScript中使用时间是通过内置的Date对象来实现的。

   -2).Java中使用的时间是通过:

         A.java.util.Date

         B.java.util.Calendar

         C.java.text.SimpleDateFormat

         D.java.sql.Date

         E.java.sql.Time

         F.java.sql.Timestamp

        这6个类来实现的。

   -3).至于有人问这么多时间类,一个不就够了吗?其实不然,别看6个类但是各有各的用处。

         ①.java.util.Date类中的许多方法都被废弃了,所以说在一定程度上Calendar类取代一部分Date类的功能。

      ②.java.text.SimpleDateFormat类的主要作用就是对指定时间格式的时间字符串转换为java.util.Date类型的时间,或者将java.util.Date类型的时间转换为时间字符串。

         ③.java.sql包下的Date/Time/Timestamp时间类主要是与数据库中的时间打交道的。

         ④.java.util包下的时间类型是可以与java.sql包下的时间类型进行互转的,并且时间字符串也是可以与这6个时间类进行互转的。

         ⑤.每一个时间都可以用10位或者13位的long型数值来代表,只要我们获取到了long型数值或者指定格式的时间字符串就会通过Java的6个时间类得出我们想要的时间。

## 二、JavaScript中的时间

> -1).Date实例的创建 -> 四种构造器

  ①.new Date()无参构造器

        let date_1 = new Date();
        console.log(date_1);// 打印 Fri Aug 10 2018 22:51:39 GMT+0800 (中国标准时间)

  ②.new Date(milliseconds)Number型的构造器

        let date_2 = new Date(Date.now());
        console.log(date_2);// Fri Aug 10 2018 22:51:39 GMT+0800 (中国标准时间)

  ③.new Date(dateString);String型的构造器(传递一个有效格式的时间字符串)

        let date_3 = new Date("2018-08-10 22:47:21");
        console.log(date_3);// 打印 Fri Aug 10 2018 22:47:21 GMT+0800 (中国标准时间)

  ④.new Date(年, 月, 日, 时, 分, 秒);

let date_4 = new Date(date_2.getFullYear(), date_2.getMonth(), date_2.getDate(), date_2.getHours(), date_2.getMinutes(), date_2.getSeconds());
        console.log(date_4);// 打印 Fri Aug 10 2018 22:51:39 GMT+0800 (中国标准时间)

这四种构造器都可以用来创建实例并且同时设置时间

> -2).Date实例的8种toXxxString方法(涵盖了JavaScript所支持的原生的时间格式)

        console.log(date_1.toLocaleDateString());// 打印 2018/8/10
        console.log(date_1.toLocaleTimeString());// 打印 下午10:57:46
        console.log(date_1.toLocaleString());// 打印 2018/8/10 下午10:57:46

        console.log(date_1.toDateString());// 打印 Fri Aug 10 2018
        console.log(date_1.toTimeString());// 打印 22:57:46 GMT+0800 (中国标准时间)
        console.log(date_1.toString());// 打印 Fri Aug 10 2018 22:57:46 GMT+0800 (中国标准时间)

        console.log(date_1.toISOString());// 打印 2018-08-10T14:57:46.204Z
        console.log(date_1.toUTCString());// 打印 Fri, 10 Aug 2018 14:57:46 GMT

JavaScript原生支持的时间格式与自定义时间格式

原生格式:

-1).2018/8/10

-2).下午11:16:36

-3).2018/8/10 下午11:16:36

-4).Fri Aug 10 2018

-5).23:16:36 GMT+0800 (中国标准时间)

-6).Fri Aug 10 2018 23:16:36 GMT+0800 (中国标准时间)

-7).2018-08-10T15:16:36.488Z

-8).Fri, 10 Aug 2018 15:16:36 GMT

-9).2018/8/10

自定义格式:(所谓自定义格式就是自己定制,下面就是我定制的比较常用的时间格式)

-1).2018/05/13 06:21:23

-2).2018年05月13日 06:21:23

-3).2018-05-13 06:21:23

-4).2018-05-13 06-21-23

-5).2018/05/13 06-21-23

-6).2018年05月13日 06-21-23

-7).2018年05月13日 06时21分23秒

-8).2018-05-13 06时21分23秒

-9).2018/05/13 06时21分23秒

## 三、数据库中的时间

经过我们的探索诚如上面我们所罗列出来的时间格式,应该足够我们开发用了,其实我想说的是这些时间最终都会被存储在数据库中,那么数据库支持时间吗?答案是肯定的数据库支持时间!!!拿MySQL为例就支持3种时间格式(date、time、datetime)

所以我们在通过后台向数据库存储时间的时候以什么方式存呢?字符串肯定不行...因为人家数据库都已经指定了时间类型了,此时如果稍稍留意的朋友就会想到,我们上面Java支持的6种时间类是不是就有3个关于sql的时间呢(即java.sql.Date、java.sql.Time、java.sql.Timestamp)?这三个正好对应数据库的3种时间类型。

### 四、时间从前端存储到数据库流程

时间从前端到数据库流程图

## 注意:

这里有两点要提:

   A.就是如果我们在前台将时间都转换为类似(注意我这里用的是类似,因为JavaScript没有long类型只有Number类型)long类型的时间串传递到后台,那么后台的适配与格式转换是极为简单的,但是如果在大项目中出于性能考虑,有可能领导会尽量减少前端压力或者说你就想正常的传递正常格式时间的话,前端的压力会减轻,后台的压力就会稍大些...

   B.基于前端的时间过于复杂而且与Java原生的时间格式能对应上的少之又少,所以闲暇之余封了个Java关于适配前端时间的jar包(可以适配最上面我们列举的所有格式的时间,仅需调用几个方法不用关注任何实现就可以成功将其转化成对应的数据库时间类型与格式)。

jar包的事儿我们最后再说,如果有的朋友需要这个jar包对时间进行处理的话,在本文最后会详细介绍使用方法并会附上jar包资源。

## 科普:

顺便科普一下:A中提到的long型时间是个什么概念?

就是类似于这样一个long型的时间串,我们就可以在里边获取到我们想知道的时间。但是有些时候我们获得的long时间并不都是13位的,也会遇到10位的,如果遇到10位的我们应该将其 * 1000,这个在做数据抓取的时候可把我坑苦了 ... 

## 介绍:

由于脱离不了JavaScript的魔爪,我将Java的打印语句由System.out.println变成了Console.log ...

public class Console {

	public static <T> void log(T arg) {
		System.out.println(arg);
	}
}

## 五、Java中的6大时间类的应用(不进行过多赘述常用具体用法在每个代码块中都有书写 - 程序员的基本功阅读代码)

> -1).java.util.Calendar

主要功能:

 -A).设置时间的方式 -> 通过setTime(long型时间)。

 -B).获取long型时间 -> getTimeInMillis() 。

 -C).java.util.Date获取long型时间 -> getTime()。

 -D).java.util.Date类型时间与java.util.Calendar类型时间互转。

-E).获取年月日时分秒等时间 -> (Calendar.YEAR、Calendar.MONTH、Calendar.DAY_OF_MONTH、Calendar.HOUR_OF_DAY、Calendar.MINUTE、Calendar.SECOND)。

        // 测试java.util.Calendar
	@Test
	public void testCalendar() {
		// 创建Calendar实例
		java.util.Calendar cal = Calendar.getInstance();
		// 设置Calendar时间(另一方面也将java.util.Date转换为java.util.Calendar)
		cal.setTime(new java.util.Date(System.currentTimeMillis()));
		// 获取java.util.Date型时间
		java.util.Date date = cal.getTime();
		Console.log("date:" + date);// 打印 date:Sat Aug 11 08:42:48 CST 2018
		
		// 获取13位long型时间
		long longTime = cal.getTimeInMillis();
		Console.log("longTime:" + longTime);// 打印 longTime:1533948168917
		
		int year = cal.get(Calendar.YEAR);
		int month = cal.get(Calendar.MONTH);
		int day = cal.get(Calendar.DAY_OF_MONTH);
		int hour = cal.get(Calendar.HOUR_OF_DAY);
		int minute = cal.get(Calendar.MINUTE);
		int second = cal.get(Calendar.SECOND);
		
		String CalendarTime = year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second;
		Console.log(CalendarTime);// 打印 2018-7-11 8:42:48
		
		// Calendar转换为java.util.Date
		java.util.Date date_change = new java.util.Date(longTime);
		
		// 获取long型时间
		long date_Longtime = date_change.getTime();
		Console.log(date_Longtime);// 打印 1533948168917
		
	}

> -2).java.text.SimpleDateFormat

主要功能:

 -A).通过构造器指定待操作的时间格式。

 -B).调用parse("时间字符串")方法将时间字符串按照构造器指定的时间格式解析为java.util.Date类型的时间。

 -C).调用format(java.util.Date类型时间)方法将java.util.Date类型的时间转换为时间字符串。

 -D).通过这个模式可解析官方特殊指定格式的时间字符串和有规律的时间字符串。

        // 测试java.util.SimpleDateFormat
        @Test
	public void testSimpleDateFormat() throws Exception {
		String pattern = "yyyy-MM-dd HH:mm:ss";
		// 获取SimpleDateFormat类的实例
		java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(pattern);
		// 将时间序列化为字符串
		String format = sdf.format(new java.util.Date(System.currentTimeMillis()));
		Console.log(format);// 打印 2018-08-11 09:02:44
		
		// 将字符串解析为java.util.Date类型的时间
		Date parse = sdf.parse(format);// 该处的时间字符串必须与sdf构造器中指定的格式相符
		Console.log(parse);// 打印 Sat Aug 11 09:02:44 CST 2018
		
		pattern = "yyyy^MM^dd HH%mm%ss";
		String timeStr = "2008^08^08 08%08%08";
		java.text.SimpleDateFormat sdf_1 = new java.text.SimpleDateFormat(pattern);
		Date parse_2 = sdf_1.parse(timeStr);
		Console.log(parse_2);// 打印 Fri Aug 08 08:08:08 CST 2008
		
		pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS Z";
		timeStr = "2018-05-02T21:12:23.000Z";
		// 先将Z换成' UTC'
		timeStr = timeStr.replace("Z", " UTC");
		java.text.SimpleDateFormat sdf_3 = new java.text.SimpleDateFormat(pattern); 
		java.util.Date parse_3 = sdf_3.parse(timeStr);
		Console.log(parse_3);// 打印  Thu May 03 05:12:23 CST 2018
	
		pattern = "EEE, d MMM yyyy HH:mm:ss 'GMT'";
		timeStr = "Wed, 02 May 2018 21:12:23 GMT";
		java.text.SimpleDateFormat sdf_4 = new java.text.SimpleDateFormat(pattern, Locale.UK);
		long longTime = sdf_4.parse(timeStr).getTime() + (60 * 60 * 8 * 1000);
		java.util.Date date = new java.util.Date(longTime);
		Console.log(date);// 打印 Thu May 03 05:12:23 CST 2018
	}

Ⅰ.至于最后解析EEE, d MMM yyyy HH:mm:ss 'GMT'类型时间Wed, 02 May 2018 21:12:23 GMT的时候我们在其long型时间的基础上加上了(60 * 60 *8 * 1000),就是因为GMT时间是美国时间与中国相差8个时区也就是相差8个小时,所以我们要加上(60秒 * 60分钟 * 8小时 * 1000毫秒)才可以得到正确的中国的时间。

Ⅱ.上面我们还解析了一个时间2008^08^08 08%08%08,这个时间看似没有意义,主要就是为了告诉我们这种格式的时间类似^、%这样的分隔符也可以随意使用,只要在一开始你指定对应的解析规则即可,针对这个案例上面指定的解析规则为yyyy^MM^dd HH%mm%ss,如果你想再解析2008&08&08 08#08#08这样的时间,那么你就指定解析规则为yyyy&MM&dd HH#mm#ss即可。

> -3).java.util.Date

这个类就不再过多赘述,唯一用法就是通过构造器传入long型时间来设置时间并且通过getTime方法获取long型时间,其它的方法都已经废弃。

> -4).java.sql.Date

主要功能:

 -A).通过构造器传入long型时间来设置时间 -> 这也是将其它类型时间转换成java.sql.Date类型时间的唯一方法,因为long型时间是大家都有的。

 -B).将java.sql.Date类型时间转换为字符串 -> toString()方法

 -C).将时间字符串转换为java.sql.Date类型时间 -> valueOf("时间字符串")

        // 测试java.sql.Date
	@Test
	public void testSqlDate() {
		// 实例化java.sql.Date类的实例
		java.sql.Date date = new java.sql.Date(System.currentTimeMillis());
		// 将java.sql.Date类转换为字符串
		String dateStr = date.toString();
		Console.log(dateStr);// 打印 2018-08-10
		
		// 将时间字符串转换为java.sql.Date类型
		java.sql.Date sqlDate = java.sql.Date.valueOf(dateStr);
		Console.log(sqlDate);// 打印 2018-08-10
		
	}

> -5).java.sql.Time

主要功能:

 与java.sql.Date类似

        // 测试java.sql.Time
	@Test
	public void testSqlTime() {
		// 创建java.sql.Time类的实例
		java.sql.Time time = new java.sql.Time(System.currentTimeMillis());
		Console.log(time);// 打印 18:50:08
		// 将java.sql.Time类型转换为时间字符串
		String timeStr = time.toString();
		// 将时间字符串转换为java.sql.Time类型
		java.sql.Time sqlTime = java.sql.Time.valueOf(timeStr);
		Console.log(sqlTime);// 打印 18:50:08
	}

> -6).java.sql.Timestamp

主要功能:

 与java.sql.Date类似

        // 测试java.sql.Timestamp
	@Test
	public void testTimestamp() {
		// 创建java.sql.Timestamp类的实例
		java.sql.Timestamp tamp = new java.sql.Timestamp(System.currentTimeMillis());
		Console.log(tamp);// 打印 2018-08-10 18:56:43.484
		// 获取long型时间
		long longTime = tamp.getTime();
		Console.log(longTime);// 打印 1533898603484
		// 将java.sql.Timestamp类转换为时间字符串
		String dateTimeStr = tamp.toString();
		// 将java.sql.Timestamp类型转化为时间字符串
		Timestamp sqlDateTime = java.sql.Timestamp.valueOf(dateTimeStr);
		Console.log(sqlDateTime);// 打印 2018-08-10 18:56:43.484
		
	}

上面的Java中六大时间类已经介绍完毕,说真的没有什么太难,只要贴出的代码全部掌握日常开发是不成问题。

如果仅仅只想了解一下Java与JavaScript中的时间的朋友看到这里就可以就可以离开了,如果还想了解Java后端怎么适配最上面我们列出的所有JavaScript支持的与自定义的时间格式,并存入数据库的操作的话,请看下文。

再贴一下JavaScript支持的时间格式:

原生格式:

-1).2018/8/10

-2).下午11:16:36

-3).2018/8/10 下午11:16:36

-4).Fri Aug 10 2018

-5).23:16:36 GMT+0800 (中国标准时间)

-6).Fri Aug 10 2018 23:16:36 GMT+0800 (中国标准时间)

-7).2018-08-10T15:16:36.488Z

-8).Fri, 10 Aug 2018 15:16:36 GMT

-9).2018/8/10

自定义格式:(所谓自定义格式就是自己定制,下面就是我定制的比较常用的时间格式)

-1).2018/05/13 06:21:23

-2).2018年05月13日 06:21:23

-3).2018-05-13 06:21:23

-4).2018-05-13 06-21-23

-5).2018/05/13 06-21-23

-6).2018年05月13日 06-21-23

-7).2018年05月13日 06时21分23秒

-8).2018-05-13 06时21分23秒

-9).2018/05/13 06时21分23秒

将这些时间最终转换成数据库支持的时间格式:

涉及到的工作量还是蛮大的,所以我就封装了一个jar包(Java.LJ.TimeHelper.utils-1.1.0.jar)用来做(将上面众多格式的时间转换为数据库支持的时间类型)的工作,所以我们接下来只需要了解一下怎么使用Java.LJ.TimeHelper.utils-1.1.0.jar这个jar包中的方法即可。

## 示例:

> -1).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

## 变量time就是待解析的时间

                        java.sql.Timestamp sqlTime = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
			Console.log("sqlTime:" + sqlTime);
			java.sql.Date date = Time.sqlTimeAdapter(time, java.sql.Date.class);
			Console.log("date:" + date);
			java.sql.Time time_1 = Time.sqlTimeAdapter(time, java.sql.Time.class);
			Console.log(time_1);

打印结果:

> -2).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

            java.sql.Timestamp achieveTime = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "yyyy-MM-dd HH:mm:ss")), java.sql.Timestamp.class);
            Console.log(achieveTime);// 打印2018-08-11 10:20:59.0

打印结果:

> -3).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

第一种方式

// 第一种方式
java.sql.Time timeStr = java.sql.Time.valueOf(Time.reformat(time));

第二种方式

// 第二种方式
java.sql.Time timeStr = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "HH:mm:ss")), java.sql.Time.class);
Console.log(timeStr);// 打印 10:36:55

打印结果:

> -4).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

方式一

// 方式一:
java.sql.Date dateStr = java.sql.Date.valueOf(Time.reformat(time));

方式二

// 方式二:
java.sql.Date dateStr = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "yyyy-MM-dd")), java.sql.Date.class);
Console.log(dateStr);// 打印 2018-08-11

打印结果:

> -5).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

                        java.sql.Timestamp isoToSqlTamp = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
			Console.log(isoToSqlTamp);// 打印 2018-08-11 10:31:55.963
			java.sql.Date isoToSqlDate = Time.sqlTimeAdapter(time, java.sql.Date.class);
			Console.log(isoToSqlDate);// 打印 2018-08-11
			java.sql.Time isoToSqlTime = Time.sqlTimeAdapter(time, java.sql.Time.class);
			Console.log(isoToSqlTime);// 打印 10:31:55

打印结果:

> -6).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

java.sql.Timestamp localeToTamp = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "yyyy/MM/dd HH:mm:ss")), java.sql.Timestamp.class);
Console.log(localeToTamp);// 打印 2018-08-11 10:38:42.0
java.sql.Date localeToDate = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "yyyy/MM/dd HH:mm:ss")), java.sql.Date.class);
Console.log(localeToDate);// 打印 2018-08-11
java.sql.Time localeToTime = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "yyyy/MM/dd HH:mm:ss")), java.sql.Time.class);
Console.log(localeToTime);// 打印 10:38:42

打印结果

> -7).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

java.sql.Time localeHalfTime = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.reformat(time), "HH:mm:ss")), java.sql.Time.class);
Console.log(localeHalfTime);// 打印 10:41:21

打印结果:

> -8).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom1Time = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(time, "yyyy/MM/dd HH-mm-ss")), java.sql.Timestamp.class);
Console.log(custom1Time);// 打印 2018-05-13 06:21:23.0

打印结果：

> -9).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

java.sql.Time custom2Time = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(time, "HH-mm-ss")), java.sql.Time.class);
Console.log(custom2Time);// 打印 06:21:23

打印结果:

> -10).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

java.sql.Date custom3Time = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(time, "yyyy/MM/dd")), java.sql.Date.class);
Console.log(custom3Time);// 打印 2018-05-13

打印结果:

> -11).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom4Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom4Time);// 打印 2018-05-13 06:21:23.0

打印结果:

> -12).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom5Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom5Time);// 打印 2018-05-13 06:21:23.0

打印结果:

> -13).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom6Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom6Time);// 打印 2018-05-13 06:21:23.0

打印结果:

> -14).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom7Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom7Time);// 打印 2018-05-13 06:21:23.0

打印结果:

> -15).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom8Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom8Time);// 打印 2018-05-13 06:21:23.0

打印结果:

> -16).前端发送的时间为

通过Java.LJ.TimeHelper.utils-1.1.0.jar进行时间适配

Timestamp custom9Time = Time.sqlTimeAdapter(time, java.sql.Timestamp.class);
Console.log(custom9Time);// 打印 2018-05-03 05:12:23.0

打印结果:

上面我们已经将

原生格式:

-1).2018/8/10

-2).下午11:16:36

-3).2018/8/10 下午11:16:36

-4).Fri Aug 10 2018

-5).23:16:36 GMT+0800 (中国标准时间)

-6).Fri Aug 10 2018 23:16:36 GMT+0800 (中国标准时间)

-7).2018-08-10T15:16:36.488Z

-8).Fri, 10 Aug 2018 15:16:36 GMT

-9).2018/8/10

自定义格式:(所谓自定义格式就是自己定制,下面就是我定制的比较常用的时间格式)

-1).2018/05/13 06:21:23

-2).2018年05月13日 06:21:23

-3).2018-05-13 06:21:23

-4).2018-05-13 06-21-23

-5).2018/05/13 06-21-23

-6).2018年05月13日 06-21-23

-7).2018年05月13日 06时21分23秒

-8).2018-05-13 06时21分23秒

-9).2018/05/13 06时21分23秒

这些格式的时间通过Java.LJ.TimeHelper.utils-1.1.0.jar包一键解析成Java中与数据库时间类型相对应的时间,并且凡是这种2018^02^03 02:04:05或是2018%06%06亦或是12@03@15只要分别指定解析规则(yyyy^MM^dd HH:mm:ss或是yyyy%MM%dd亦或是HH@mm@ss)都可以进行对应的解析。

以上就是我么这一章关于JavaScript内置Date对象讲解、Java中6大时间类的作用、数据库支持的时间类型、Java.LJ.TimeHelper.utils-1.1.0.jar包的使用。

最后来一个案例

jsp代码:(向后台传递时间)

                        // 为btn(实战测试 - dateTime)绑定点击事件
			btns[16].addEventListener('click', function() {
				url = "time/dealTimeRquest";
				
				data = {
						tag: "testDateTime",
						time: "2018/05/13 06时21分23秒",
						date: "2018年05月13日",
						t: "06时21分23秒"
				};
				
				request(url, data, function() {
					
				});
			}, false);
                        //封装request方法
			function request(url, data, foo) {
				J.Ajax(url, data, function() {
					foo();
				});
			}

J.Ajax是我自己封装的Ajax简易的库...

后台代码:(通过Java.LJ.TimeHelper.utils-1.1.0.jar包解析时间并存入数据库)

Controller -> 控制器DealRequest类

@RequestMapping(value="time")
@Controller(value="dealRequest")
public class DealRequest {

	@Autowired
	@Qualifier(value="dealTimeService")
	private DealTimeService dealTimeService;
	
	@RequestMapping(value="dealTimeRquest")
	@ResponseBody
	public void dealTimeRquest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		// 设置字符编码集
		request.setCharacterEncoding("utf-8");
		// 接收前台参数
		String tag = request.getParameter("tag");
		String time = request.getParameter("time");
		String dateStrr = request.getParameter("date");
		String tStr = request.getParameter("t");
		dealTimeService.saveDateTime(time, dateStrr, tStr);
    }
	
}

Service -> DealTimeService 类

package com.YHStudio.Time.service;

import java.sql.Date;
import java.sql.Timestamp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.YHStudio.Time.bean.TimeBean;
import com.YHStudio.Time.dao.Execute;
import com.YHStudio.Time.utils.Time;

/**
 * @author LJ
 * @version 1.0
 * 2018年8月10日
 * 类的作用:保存时间
 */
@Service(value="dealTimeService")
public class DealTimeService {
	
	@Autowired
	@Qualifier(value="achieve")
	private Execute achieve;
	
	@Autowired
	@Qualifier(value="timeBean")
	private TimeBean timeBean;
	
	
	// 创建无参构造器
	public DealTimeService() {
		super();
	}
	
	
	public boolean saveDateTime(String timeStr, String dateStr, String tStr) throws Exception {
		
		java.sql.Timestamp tamp = Time.sqlTimeAdapter(timeStr, java.sql.Timestamp.class);
		java.sql.Date date = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.removeChinaDate(dateStr), "yyyy-MM-dd")), java.sql.Date.class);
		java.sql.Time time = Time.sqlTimeAdapter(String.valueOf(Time.timeToLong(Time.removeChinaTime(tStr), "HH:mm:ss")), java.sql.Time.class);
		timeBean.setDate_1(date);
		timeBean.setDate_2(time);
		timeBean.setDate_3(tamp);
		int num = achieve.saveDateTime(timeBean);
		if(num > 0) {
			return true;
		}
		return false;
	}
	
}

dao -> Execute接口

public interface Execute {

	public abstract int saveDateTime(TimeBean timeBean);
}

Bean -> TimeBean 

@Component(value="timeBean")
public class TimeBean {

	private java.sql.Date date_1;
	private java.sql.Time date_2;
	private java.sql.Timestamp date_3;
	
	// 创建无参构造器
	public TimeBean() {
		super();
	}
	
	// 创建有参构造器
	public TimeBean(java.sql.Date date_1, java.sql.Time date_2, java.sql.Timestamp date_3) {
		this.date_1 = date_1;
		this.date_2 = date_2;
		this.date_3 = date_3;
	}
	
	// 对应的setter、getter方法

	public java.sql.Date getDate_1() {
		return date_1;
	}

	public void setDate_1(java.sql.Date date_1) {
		this.date_1 = date_1;
	}

	public java.sql.Time getDate_2() {
		return date_2;
	}

	public void setDate_2(java.sql.Time date_2) {
		this.date_2 = date_2;
	}

	public java.sql.Timestamp getDate_3() {
		return date_3;
	}

	public void setDate_3(java.sql.Timestamp date_3) {
		this.date_3 = date_3;
	}

	@Override
	public String toString() {
		return "TimeBean [date_1=" + date_1 + ", date_2=" + date_2 + ", date_3=" + date_3 + "]";
	}
	
	
}

UserMapper.xml

MySQL数据库timeDB中的timeTab表

点击按钮

时间由

2018/05/13 06时21分23秒 -> 转换为java.sql.Timestamp类型的 -> 2018-05-13 06:21:23.0

2018年05月13日 -> 转换为java.sql.Date类型的 ->  2018-05-13

06时21分23秒 -> 转换为java.sql.Time类型的 -> 06:21:23

并插入数据库

不知道一路看到现在的你是否会有收获呢?如有疑问或建议请在下面留言看到后我会及时回复!

Java.LJ.TimeHelper.utils-1.1.0.jar

如果没有C币下载不了此资源请加QQ:1848661762