一个面试题：计算时间偏移量，怎么设计你的程序？

计算时间偏移量，例如，计算当前时间向前偏移 30 秒的时间，我们利用java.util.Calendar很容易实现。

1.     Calendar cal = Calendar.getInstance();
2.     cal.setTime(new Date());
3.     cal.add(Calendar.SECOND, -30);
4.     System.out.println(cal.getTime());

复制代码

 
我在进行面试的时候，关于程序设计，有问过应聘者这样的问题。
那么，我们怎么封装这么一个工具类呢？这个工具类提供哪些工具方法呢？每个方法又当怎么实现呢？
下面这段优秀的代码节选自hutool-DateUtil（hutool-all-4.5.18.jar ，maven坐标：cn.hutool:hutool-all:4.5.18），香香的，甜甜的，pretty，graceful，pretty graceful.
坦白说，写出来这个util并不难，你可以写出来你的代码，然后做个比较，看看与优秀代码的差距。

1.     // --------------------------------------------------- Offset for now
2.     /**
3.      * 昨天
4.      *
5.      * @return 昨天
6.      */
7.     public static DateTime yesterday() {
8.         return offsetDay(new DateTime(), -1);
9.     }
11.     /**
12.      * 明天
13.      *
14.      * @return 明天
15.      * @since 3.0.1
16.      */
17.     public static DateTime tomorrow() {
18.         return offsetDay(new DateTime(), 1);
19.     }
21.     /**
22.      * 上周
23.      *
24.      * @return 上周
25.      */
26.     public static DateTime lastWeek() {
27.         return offsetWeek(new DateTime(), -1);
28.     }
30.     /**
31.      * 下周
32.      *
33.      * @return 下周
34.      * @since 3.0.1
35.      */
36.     public static DateTime nextWeek() {
37.         return offsetWeek(new DateTime(), 1);
38.     }
40.     /**
41.      * 上个月
42.      *
43.      * @return 上个月
44.      */
45.     public static DateTime lastMonth() {
46.         return offsetMonth(new DateTime(), -1);
47.     }
49.     /**
50.      * 下个月
51.      *
52.      * @return 下个月
53.      * @since 3.0.1
54.      */
55.     public static DateTime nextMonth() {
56.         return offsetMonth(new DateTime(), 1);
57.     }
59.     /**
60.      * 偏移毫秒数
61.      *
62.      * @param date 日期
63.      * @param offset 偏移毫秒数，正数向未来偏移，负数向历史偏移
64.      * @return 偏移后的日期
65.      */
66.     public static DateTime offsetMillisecond(Date date, int offset) {
67.         return offset(date, DateField.MILLISECOND, offset);
68.     }
70.     /**
71.      * 偏移秒数
72.      *
73.      * @param date 日期
74.      * @param offset 偏移秒数，正数向未来偏移，负数向历史偏移
75.      * @return 偏移后的日期
76.      */
77.     public static DateTime offsetSecond(Date date, int offset) {
78.         return offset(date, DateField.SECOND, offset);
79.     }
81.     /**
82.      * 偏移分钟
83.      *
84.      * @param date 日期
85.      * @param offset 偏移分钟数，正数向未来偏移，负数向历史偏移
86.      * @return 偏移后的日期
87.      */
88.     public static DateTime offsetMinute(Date date, int offset) {
89.         return offset(date, DateField.MINUTE, offset);
90.     }
92.     /**
93.      * 偏移小时
94.      *
95.      * @param date 日期
96.      * @param offset 偏移小时数，正数向未来偏移，负数向历史偏移
97.      * @return 偏移后的日期
98.      */
99.     public static DateTime offsetHour(Date date, int offset) {
100.         return offset(date, DateField.HOUR_OF_DAY, offset);
101.     }
103.     /**
104.      * 偏移天
105.      *
106.      * @param date 日期
107.      * @param offset 偏移天数，正数向未来偏移，负数向历史偏移
108.      * @return 偏移后的日期
109.      */
110.     public static DateTime offsetDay(Date date, int offset) {
111.         return offset(date, DateField.DAY_OF_YEAR, offset);
112.     }
114.     /**
115.      * 偏移周
116.      *
117.      * @param date 日期
118.      * @param offset 偏移周数，正数向未来偏移，负数向历史偏移
119.      * @return 偏移后的日期
120.      */
121.     public static DateTime offsetWeek(Date date, int offset) {
122.         return offset(date, DateField.WEEK_OF_YEAR, offset);
123.     }
125.     /**
126.      * 偏移月
127.      *
128.      * @param date 日期
129.      * @param offset 偏移月数，正数向未来偏移，负数向历史偏移
130.      * @return 偏移后的日期
131.      */
132.     public static DateTime offsetMonth(Date date, int offset) {
133.         return offset(date, DateField.MONTH, offset);
134.     }
136.     /**
137.      * 获取指定日期偏移指定时间后的时间
138.      *
139.      * @param date 基准日期
140.      * @param dateField 偏移的粒度大小（小时、天、月等）{@link DateField}
141.      * @param offset 偏移量，正数为向后偏移，负数为向前偏移
142.      * @return 偏移后的日期
143.      */
144.     public static DateTime offset(Date date, DateField dateField, int offset) {
145.         Calendar cal = Calendar.getInstance();
146.         cal.setTime(date);
147.         cal.add(dateField.getValue(), offset);
148.         return new DateTime(cal.getTime());
149.     }
151.     // ------------------------------------ Offset end ----------------------------------------------

复制代码

 

为什么说这么代码比较香呢？你品，你细品！

• 易读。注意各个方法尤其是以“offset”开头的方法的签名，包括方法名、方法参数，包括javadoc，相当清晰，易读易理解。另外，这几个方法整体来看，像极了我们母语中的排比句。
  
• 丰富。按不同的时间单位（如秒、分钟、小时、天、周和月）偏移日期时间值，定义了丰富的方法，各种姿势满足你。
  
• 易用。除了offsetMinute/offsetSecond等offsetXxx方法，还提供了yesterday / tomorrow / lastWeek / nextWeek / lastMonth /nextMonth等拿来即用的方法，不必再调用offsetXxx。
  
• 简洁。计算时间偏移量的算法是相同的，所以，这些方法内部均调用一个通用的 offset 方法，该方法使用 DateField 枚举值指定要偏移的时间单位和偏移量。
  
• 包容。【中途被其他同学打断，一下子断片了。。。】
  

 
同样，关于本地缓存工具，分享一段我曾经写的LocalCacheUtil工具类。

1. import cn.hutool.cache.Cache;
2. import cn.hutool.cache.CacheUtil;
3. import lombok.extern.slf4j.Slf4j;
5. import java.util.Collection;
6. import java.util.concurrent.TimeUnit;
7. import java.util.function.Supplier;
9. /**
10. * 本地缓存工具
11. */
12. @Slf4j
13. public class LocalCacheUtil {
14.     private static Cache<String, Object> lfuCache = CacheUtil.newLFUCache(256, TimeUnit.MINUTES.toMillis(30));
15.     private static Cache<String, Object> timedCache = CacheUtil.newTimedCache(TimeUnit.DAYS.toMillis(1));//过期时间给个默认值
17.     /**
18.      * 从本地缓存获取数据。如果没有，则设置。（策略：最少使用原则）
19.      *
20.      * @param key
21.      * @param supplier
22.      * @param <T>
23.      * @return
24.      *
25.      * @see #lfuCache
26.      */
27.     public static <T> T getCache(String key, Supplier<T> supplier) {
28.         return getCache(key, false, supplier);
29.     }
31.     /**
32.      * 从本地缓存获取数据。如果没有，则设置。（策略：最少使用原则）
33.      *
34.      * @param key
35.      * @param cacheNullOrEmpty 是否缓存null或空集合
36.      * @param supplier
37.      * @param <T>
38.      * @return
39.      *
40.      * @see #lfuCache
41.      */
42.     public static <T> T getCache(String key, boolean cacheNullOrEmpty, Supplier<T> supplier) {
43.         return getCache(lfuCache, key, null, cacheNullOrEmpty, supplier);
44.     }
46.     /**
47.      * 获取缓存。如果没有，则设置
48.      *
49.      * @param key
50.      * @param seconds
51.      * @param supplier 缓存数据提供者
52.      * @param <T>
53.      * @return
54.      */
55.     public static <T> T getCache(String key, long seconds, Supplier<T> supplier) {
56.         return getCache(key, seconds, false, supplier);
57.     }
59.     /**
60.      * 删除缓存
61.      *
62.      * @param key 缓存key
63.      */
64.     public static void removeCache(String key) {
65.         timedCache.remove(key);
66.     }
68.     /**
69.      * 获取缓存。如果没有，则设置
70.      *
71.      * @param key
72.      * @param seconds
73.      * @param cacheNullOrEmpty 是否缓存null或空集合
74.      * @param supplier         缓存数据提供者
75.      * @param <T>
76.      * @return
77.      */
78.     public static <T> T getCache(String key, long seconds, boolean cacheNullOrEmpty, Supplier<T> supplier) {
79.         return getCache(timedCache, key, seconds, cacheNullOrEmpty, supplier);
80.     }
82.     private static <T> T getCache(Cache<String, Object> myCache, String key, Long seconds, boolean cacheNullOrEmpty, Supplier<T> supplier) {
83.         if (myCache.containsKey(key)) {
84.             return (T) myCache.get(key);
85.         } else {
86.             T result = supplier.get();
87.             if (!cacheNullOrEmpty) {
88.                 if (result == null) {
89.                     log.info("设置缓存---value为null，不设置--- key={}", key);
90.                     return null;
91.                 } else if (result instanceof Collection && ((Collection) result).size() == 0) {
92.                     log.info("设置缓存---value是个空集合，不设置--- key={}", key);
93.                     return null;
94.                 }
95.             }
96.             log.info("设置缓存 key={}", key);
97.             if (seconds == null) {
98.                 myCache.put(key, result);
99.             } else {
100.                 myCache.put(key, result, TimeUnit.SECONDS.toMillis(seconds));
101.             }
102.             return result;
103.         }
104.     }
106. }

复制代码

View Code 

另外，在这个DateUtil工具类中，有一个弃用的offsetDate方法如下。

1.     /**
2.      * 获取指定日期偏移指定时间后的时间
3.      *
4.      * @param date 基准日期
5.      * @param dateField 偏移的粒度大小（小时、天、月等）{@link DateField}
6.      * @param offset 偏移量，正数为向后偏移，负数为向前偏移
7.      * @return 偏移后的日期
8.      * @deprecated please use {@link DateUtil#offset(Date, DateField, int)}
9.      */
10.     @Deprecated
11.     public static DateTime offsetDate(Date date, DateField dateField, int offset) {
12.         return offset(date, dateField, offset);
13.     }

复制代码

作为一个不断迭代升级的Java工具库，显然hutool不能轻易将之前的方法直接去掉，这会遭到骂娘的。因此，hutool的开发者标记了@Deprecated，并在方法的javadoc里明确指引出来，调用另一个offset(Date, DateField, int)重载。--——————这是一个优秀编码风格，标记弃用，请向使用者描述背景（弃用原因）或告知使用者应该怎么办。
那么，现在，我们来思考一下：为什么弃用这个offsetDate方法改用offset方法呢？欢迎评论区交流！
我在公司内部的软件系统中，一直在践行关于弃用方法的这一优秀编码行为。只是后来，随着开发经验和意识的增强，在行为上做了一些调整。即，我不再一味地标记弃用，而是斩草除根，对于不合理的方法，优秀采用的方式是直接干掉方法并修改对方法的调用，这么做的出发点有三：①我们是中小型内部企业应用系统，工具或组件都是对内使用，具备内部修改的条件；②团队成员编码意识良莠不齐，被明确标记了弃用的方法，有时仍被使用；③最好的方式是一次做好，避免时间一长自己都忘了这些冗余代码了。
 
The End.
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！