mybatis中的selectAll方法为什么空指针

mybatis中的selectAll方法空指针是因为数据库中某个字段是关键字导致。第一个Mybatis程序中如果报空指针异常，这是因为你的MybatisUtils.java包中已经在外部声明过sqlSessionFactory。

mybatis中的selectAll方法空指针解决方法

在yml文件中添加配置，但是当mapper的返回值为Integer的时候并不管用，在后台sql语句中加入isnull函数处理，此处使用的是sqlserver数据库，当为空的时候给数值0，这样就能正常处理了。

在项目中的mybats升级使用了jdk8的LocalDateTime等后，数据库timesstamp字段有的记录是null，导致查询时出现错误，不能把null转换为LocalDateTime，通过跟踪代码发现问题出在mysql的驱动上。

怎么才能愉快地处理日期和时间？答案是：立刻升级到Java 8！

Java 8新增了LocalDate和LocalTime接口，为什么要搞一套全新的处理日期和时间的API？因为旧的java.util.Date实在是太难用了。

java.util.Date月份从0开始，一月是0，十二月是11，变态吧！java.time.LocalDate月份和星期都改成了enum，就不可能再用错了。

java.util.Date和SimpleDateFormatter都不是线程安全的，而LocalDate和LocalTime和最基本的String一样，是不变类型，不但线程安全，而且不能修改。

java.util.Date是一个“万能接口”，它包含日期、时间，还有毫秒数，如果你只想用java.util.Date存储日期，或者只存储时间，那么，只有你知道哪些部分的数据是有用的，哪些部分的数据是不能用的。在新的Java 8中，日期和时间被明确划分为LocalDate和LocalTime，LocalDate无法包含时间，LocalTime无法包含日期。当然，LocalDateTime才能同时包含日期和时间。

新接口更好用的原因是考虑到了日期时间的 *** 作，经常发生往前推或往后推几天的情况。用java.util.Date配合Calendar要写好多代码，而且一般的开发人员还不一定能写对。

LocalDate

看看新的LocalDate怎么用：

// 取当前日期：

LocalDate today = LocalDate.now()// ->2014-12-24

// 根据年月日取日期，12月就是12：

LocalDate crischristmas = LocalDate.of(2014, 12, 25)// ->2014-12-25

// 根据字符串取：

LocalDate endOfFeb = LocalDate.parse("2014-02-28")// 严格按照ISO yyyy-MM-dd验证，02写成2都不行，当然也有一个重载方法允许自己定义格式

LocalDate.parse("2014-02-29")// 无效日期无法通过：DateTimeParseException: Invalid date

日期转换经常遇到，比如：

// 取本月第1天：

LocalDate firstDayOfThisMonth = today.with(TemporalAdjusters.firstDayOfMonth())// 2014-12-01

// 取本月第2天：

LocalDate secondDayOfThisMonth = today.withDayOfMonth(2)// 2014-12-02

// 取本月最后一天，再也不用计算是28，29，30还是31：

LocalDate lastDayOfThisMonth = today.with(TemporalAdjusters.lastDayOfMonth())// 2014-12-31

// 取下一天：

LocalDate firstDayOf2015 = lastDayOfThisMonth.plusDays(1)// 变成了2015-01-01

// 取2015年1月第一个周一，这个计算用Calendar要死掉很多脑细胞：

LocalDate firstMondayOf2015 = LocalDate.parse("2015-01-01").with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY))// 2015-01-05

LocalTime

LocalTime只包含时间，以前用java.util.Date怎么才能只表示时间呢？答案是，假装忽略日期。

LocalTime包含毫秒：

LocalTime now = LocalTime.now()// 11:09:09.240

你可能想清除毫秒数：

LocalTime now = LocalTime.now().withNano(0))// 11:09:09

构造时间也很简单：

LocalTime zero = LocalTime.of(0, 0, 0)// 00:00:00

LocalTime mid = LocalTime.parse("12:00:00")// 12:00:00

时间也是按照ISO格式识别，但可以识别以下3种格式：

12:00

12:01:02

12:01:02.345

JDBC

最新JDBC映射将把数据库的日期类型和Java 8的新类型关联起来：

SQL ->Java

--------------------------

date ->LocalDate

time ->LocalTime

timestamp ->LocalDateTime

再也不会出现映射到java.util.Date其中日期或时间某些部分为0的情况了。

在旧版本的jdk中，Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text.SimpleDateFormat包中定义。

java.util.Date是在除了SQL语句的情况下面使用的。

java.sql.Date是针对SQL语句使用的，它只包含日期而没有时间部分

它们都有getTime方法返回毫秒数，自然就可以直接构建。 java.util.Date 是 java.sql.Date 的父类，前者是常用的表示时间的类，我们通常格式化或者得到当前时间都是用他，后者之后在读写数据库的时候用他，因为PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date。

java.sql.Date转为java.util.Date

java.sql.Date date=new java.sql.Date()

java.util.Date d=new java.util.Date (date.getTime())

java.util.Date转为java.sql.Date

java.util.Date utilDate=new Date()

java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime())

java.util.Date utilDate=new Date()

java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime())

java.sql.Time sTime=new java.sql.Time(utilDate.getTime())

java.sql.Timestamp stp=new java.sql.Timestamp(utilDate.getTime())

这里所有时间日期都可以被SimpleDateFormat格式化format()

SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss")

f.format(stp)

f.format(sTime)

f.format(sqlDate)

f.format(utilDate)

java.sql.Date sqlDate=java.sql.Date.valueOf(" 2005-12-12")

utilDate=new java.util.Date(sqlDate.getTime())

另类取得年月日的方法：

import java.text.SimpleDateFormat

import java.util.*

java.util.Date date = new java.util.Date()

//如果希望得到YYYYMMDD的格式SimpleDateFormat

sy1=new SimpleDateFormat("yyyyMMDD")

String dateFormat=sy1.format(date)

//如果希望分开得到年，月，日SimpleDateFormat

sy=new SimpleDateFormat("yyyy")

SimpleDateFormat sm=new SimpleDateFormat("MM")

SimpleDateFormat sd=new SimpleDateFormat("dd")

String syear=sy.format(date)

String smon=sm.format(date)

String sday=sd.format(date)

注意啦！！！在JAVA 8中有了日期的新的表示方式。在java.time包中。

   Java 8日期/时间（ Date/Time）API是开发人员最受追捧的变化之一，Java从一开始就没有对日期时间处理的一致性方法，因此日期/时间API也是除Java核心API以外另一项倍受欢迎的内容。

为什么我们需要新的Java日期/时间API？

    在开始研究Java 8日期/时间API之前，让我们先来看一下为什么我们需要这样一个新的API。在Java中，现有的与日期和时间相关的类存在诸多问题，其中有：

1. Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。

2. java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。

3. 对于时间、时间戳、格式化以及解析，并没有一些明确定义的类。对于格式化和解析的需求，我们有java.text.DateFormat抽象类，但通常情况下，SimpleDateFormat类被用于此类需求。

4. 所有的日期类都是可变的，因此他们都不是线程安全的，这是Java日期类最大的问题之一。

5. 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar java.util.TimeZone类，但他们同样存在上述所有的问题。

     在现有的日期和日历类中定义的方法还存在一些其他的问题，但以上问题已经很清晰地表明：Java需要一个健壮的日期/时间类。这也是为什么Joda Time在Java日期/时间需求中扮演了高质量替换的重要角色。

Java 8日期/时间API是JSR-310的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时间API的一些设计原则是：

1. 不变性：新的日期/时间API中，所有的类都是不可变的，这对多线程环境有好处。

2. 关注点分离：新的API将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。

3. 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。

4. 实用 *** 作：所有新的日期/时间API类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。

5. 可扩展性：新的日期/时间API是工作在ISO-8601日历系统上的，但我们也可以将其应用在非IOS的日历上。

Java日期/时间API包含以下相应的包。

1. java.time包：这是新的Java日期/时间API的基础包，所有的主要基础类都是这个包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的，在绝大多数情况下，这些类能够有效地处理一些公共的需求。

2. java.time.chrono包：这个包为非ISO的日历系统定义了一些泛化的API，我们可以扩展AbstractChronology类来创建自己的日历系统。

3. java.time.format包：这个包包含能够格式化和解析日期时间对象的类，在绝大多数情况下，我们不应该直接使用它们，因为java.time包中相应的类已经提供了格式化和解析的方法。

4. java.time.temporal包：这个包包含一些时态对象，我们可以用其找出关于日期/时间对象的某个特定日期或时间，比如说，可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法，因为它们都具有“withXXX”的格式。

5. java.time.zone包：这个包包含支持不同时区以及相关规则的类。

新旧API的对比图：

新API的示例代码：

public class TimeIntroduction {

    public static void testClock() throws InterruptedException {

        //时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。  

        Clock c1 = Clock.systemUTC() //系统默认UTC时钟（当前瞬时时间 System.currentTimeMillis()）  

        System.out.println(c1.millis()) //每次调用将返回当前瞬时时间（UTC）  

        Clock c2 = Clock.systemDefaultZone() //系统默认时区时钟（当前瞬时时间）  

        Clock c31 = Clock.system(ZoneId.of("Europe/Paris")) //巴黎时区  

        System.out.println(c31.millis()) //每次调用将返回当前瞬时时间（UTC）  

        Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"))//上海时区  

        System.out.println(c32.millis())//每次调用将返回当前瞬时时间（UTC）  

        Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"))//固定上海时区时钟  

        System.out.println(c4.millis())

        Thread.sleep(1000)

        System.out.println(c4.millis()) //不变 即时钟时钟在那一个点不动  

        Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)) //相对于系统默认时钟两秒的时钟  

        System.out.println(c1.millis())

        System.out.println(c5.millis())

    }

    public static void testInstant() {

        //瞬时时间 相当于以前的System.currentTimeMillis()  

        Instant instant1 = Instant.now()

        System.out.println(instant1.getEpochSecond())//精确到秒 得到相对于1970-01-01 00:00:00 UTC的一个时间  

        System.out.println(instant1.toEpochMilli()) //精确到毫秒  

        Clock clock1 = Clock.systemUTC() //获取系统UTC默认时钟  

        Instant instant2 = Instant.now(clock1)//得到时钟的瞬时时间  

        System.out.println(instant2.toEpochMilli())

        Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()) //固定瞬时时间时钟  

        Instant instant3 = Instant.now(clock2)//得到时钟的瞬时时间  

        System.out.println(instant3.toEpochMilli())//equals instant1  

    }

    public static void testLocalDateTime() {

        //使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() -->即相对于 ZoneId.systemDefault()默认时区  

        LocalDateTime now = LocalDateTime.now()

        System.out.println(now)

//自定义时区  

        LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"))

        System.out.println(now2)//会以相应的时区显示日期  

//自定义时钟  

        Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"))

        LocalDateTime now3 = LocalDateTime.now(clock)

        System.out.println(now3)//会以相应的时区显示日期  

//不需要写什么相对时间 如java.util.Date 年是相对于1900 月是从0开始  

//2013-12-31 23:59  

        LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59)

//年月日 时分秒 纳秒  

        LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11)

//使用瞬时时间 + 时区  

        Instant instant = Instant.now()

        LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault())

        System.out.println(d3)

//解析String--->LocalDateTime  

        LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59")

        System.out.println(d4)

        LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999")//999毫秒 等价于999000000纳秒  

        System.out.println(d5)

//使用DateTimeFormatter API 解析 和 格式化  

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss")

        LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23:59:59", formatter)

        System.out.println(formatter.format(d6))

//时间获取  

        System.out.println(d6.getYear())

        System.out.println(d6.getMonth())

        System.out.println(d6.getDayOfYear())

        System.out.println(d6.getDayOfMonth())

        System.out.println(d6.getDayOfWeek())

        System.out.println(d6.getHour())

        System.out.println(d6.getMinute())

        System.out.println(d6.getSecond())

        System.out.println(d6.getNano())

//时间增减  

        LocalDateTime d7 = d6.minusDays(1)

        LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS)

//LocalDate 即年月日 无时分秒  

//LocalTime即时分秒 无年月日  

//API和LocalDateTime类似就不演示了  

    }

    public static void testZonedDateTime() {

        //即带有时区的date-time 存储纳秒、时区和时差（避免与本地date-time歧义）。  

//API和LocalDateTime类似，只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])  

        ZonedDateTime now = ZonedDateTime.now()

        System.out.println(now)

        ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"))

        System.out.println(now2)

//其他的用法也是类似的 就不介绍了  

        ZonedDateTime z1 = ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]")

        System.out.println(z1)

    }

    public static void testDuration() {

        //表示两个瞬时时间的时间段  

        Duration d1 = Duration.between(Instant.ofEpochMilli(System.currentTimeMillis() - 12323123), Instant.now())

//得到相应的时差  

        System.out.println(d1.toDays())

        System.out.println(d1.toHours())

        System.out.println(d1.toMinutes())

        System.out.println(d1.toMillis())

        System.out.println(d1.toNanos())

//1天时差 类似的还有如ofHours()  

        Duration d2 = Duration.ofDays(1)

        System.out.println(d2.toDays())

    }

    public static void testChronology() {

        //提供对java.util.Calendar的替换，提供对年历系统的支持  

        Chronology c = HijrahChronology.INSTANCE

        ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now())

        System.out.println(d)

    }

    /**

     * 新旧日期转换

     */

    public static void testNewOldDateConversion(){

        Instant instant=new Date().toInstant()

        Date date=Date.from(instant)

        System.out.println(instant)

        System.out.println(date)

    }

    public static void main(String[] args) throws InterruptedException {

        testClock()

        testInstant()

        testLocalDateTime()

        testZonedDateTime()

        testDuration()

        testChronology()

        testNewOldDateConversion()

    }

}

---