java如何避免空指针_Java入门程序员，如何避免无处不在的空指针问题?
目录
烦人的空指针
封装MiniNullWrapper
核心思想
工具类封装
烦人的空指针
Java程序员的整个职业生涯都在和空指针做斗争，不死不休。
来看一段日常开发可能会出现的代码：
public class NullPointerTest {
/*** 需求：根据用户名查找该用户所在的部门名称** @param args*/
public static void main(String[] args) {
String departmentNameOfUser = getDepartmentNameOfUser("test");
System.out.println(departmentNameOfUser);
}
/*** 假设这是A-Service的服务* 这一步很烦！！！** @param username* @return*/
public static String getDepartmentNameOfUser(String username) {
ResultTO resultTO = getUserByName(username);
if (resultTO != null) {
User user = resultTO.getData();
if (user != null) {
Department department = user.getDepartment();
if (department != null) {
return department.getName();
}
}
}
return "未知部门";
}
/*** 假设这是B-Service的服务(不用关注具体逻辑，就是随机模拟返回值，可能为null)** @param username* @return*/
public static ResultTO getUserByName(String username) {
if (username == null || "".equals(username)) {
return null;
}
Department department;
User user;
if (ThreadLocalRandom.current().nextBoolean()) {
department = new Department("总裁办", 10086);
} else {
department = null;
}
if (ThreadLocalRandom.current().nextBoolean()) {
user = new User("周董", 18, department);
user.setDepartment(department);
} else {
user = null;
}
return ResultTO.buildSuccess(user);
}
@Data
@AllArgsConstructor
@NoArgsConstructor
static class User {
private String name;
private Integer age;
private Department department;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
static class Department {
private String name;
private Integer code;
}
@Getter
@Setter
static class ResultTO implements Serializable {
private Boolean success;
private String message;
private T data;
public static ResultTO buildSuccess(T data) {
ResultTO result = new ResultTO<>();
result.setSuccess(true);
result.setMessage("success");
result.setData(data);
return result;
}
public static ResultTO buildFailed(String message) {
ResultTO result = new ResultTO<>();
result.setSuccess(false);
result.setMessage(message);
result.setData(null);
return result;
}
}
}
你会发现，如果一个POJO的层级过深而且恰好作为返回值返回时，调用者将苦不堪言，为了避免空指针不得不写一大堆的if判断，也就是被迫做空指针探测。
一种较为通用的做法是采用“卫函数”：
/*** 假设这是A-Service的服务* 这一步很烦！！！** @param username* @return*/
public static String getDepartmentNameOfUser(String username) {
ResultTO resultTO = getUserByName(username);
if (resultTO == null) {
return "ResultTO为空";
}
User user = resultTO.getData();
if (user == null) {
return "User为空";
}
Department department = user.getDepartment();
if (department == null) {
return "Department为空";
}
return department.getName();
}
虽然避免了过深的if嵌套，逻辑稍微清晰一点，但还是很啰嗦。
封装MiniNullWrapper
我们来尝试封装一个工具类，希望能简化NullPointerException的探测工作。
核心思想
设计一个Wrapper，内部有一个T value字段，用来接收返回值，这样就能把null包裹在内部，稍微安全了一些，因为Wrapper肯定不为null：new Wrapper(value).getXxx()。
但这还不够！因为如果这个value真的是null，而外界getValue()后再次调用的话，仍然会发生NullPointerException。
怎么处理？
其实答案已经出现过了：再次把返回值包装成Wrapper即可。
public static void main(String[] agrs) {
Wrapper resultWrapper = new Wrapper(getDepartmentnameByName(username));
Wrapper userWrapper = new Wrapper(resultWrapper.get()); // resultTO可能为null，所以再次包装 Wrapper departmentWrapper = new Wrapper(userWrapper.get());
Wrapper departmentNameWrapper = new Wrapper(departmentWrapper.get());
// ...}
但上面的代码其实“很傻”：从resultWrapper取出内部的值以后，又塞进新的wrapper...其实是没有意义的，最后那个departmentNameWrapper内部塞的其实还是username
我们应该对value进行判断，当value不为null时往下取一层，这样才能最终一层层剥开value得到最终的值：
public NullWrapper map(Function super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (value是否为null)
// 如果为null，直接用Wrapper包装null，避免直接暴露导致空指针 return new Wrapper(null);
else {
// 如果不为null，那么调用传入的映射规则，【剥掉一层嵌套】，把下一级取出来重新包装为Wrapper return new Wrapper(mapper.apply(value));
}
}
由于不论value是否为null，最终返回的都是Wrapper，而Wrapper有map()，所以可以形成链式调用：
也就是说，每一次map()其实都有可能剥掉一层嵌套，而且过程中不会发生空指针异常！
// 初始化包裹，得到WrapperWrapper wrapper = new Wrapper(firstLevelValue);
// 调用Wrapper#map()尝试向下剥开每一级的嵌套，由于map()返回的也是Wrapper对象，可以链式调用wrapper
.map(firstLevelValue -> firstLevelValue.getSecondLevelValue)
.map(secondLevelValue -> secondLevelValue.getThirdLevelValue)
.map(...)
为什么是有可能？
我们来考虑两种极端的情况：如果每一级value都为null，其实每次map()都是对null进行包装传递、取出、再包装，并没有剥开任何嵌套(null值不存在嵌套)
如果每一级value都不为null，每次map()都剥开一层，这是最理想的效果，离最终需要的value越来越近
第一种情况，其实也没什么，无非就是多new几个Wrapper对象(似乎有点浪费？后面再优化)。
第二种情况，符合我们的预期，但也不能每次剥开又给套上Wrapper吧，丑媳妇最终还是要见公婆。所以，除了map()方法，Wrapper还需要额外提供一个最终获取真实value的方法，比如Wrapper#orElse(T other)，它允许调用者得到未包装的value，但是！有个条件：调用orElse()时必须传一个备用的值，如果value真的为null，则返回备用值代替null(但你如果作死，备用值传null，那也没办法)。
工具类封装
上面讲述的就是Wrapper工具类的核心思想，接着让我们一起来封装一下！
public final class MiniNullWrapper {
/*** 实际值*/
private final T value;
/*** 无参构造，默认包装null*/
private MiniNullWrapper() {
this.value = null;
}
/*** 有参构造器，用来包装外部传入的value** @param value*/
private MiniNullWrapper(T value) {
this.value = value;
}
/*** 静态方法，返回一个包装了null的Wrapper** @param * @return*/
public static MiniNullWrapper empty() {
// 调用无参构造，返回包装了null的Wrapper System.out.println("由于value为null，直接返回包装了null的Wrapper，让流程继续往下");
return new MiniNullWrapper<>();
}
/*** 静态方法，返回一个包装了value的Wrapper(value可能为null)** @param value* @param * @return*/
public static MiniNullWrapper ofNullable(T value) {
// 调用有参构造，返回包装了value的Wrapper return new MiniNullWrapper<>(value);
}
/*** 核心方法：* 1.如果value为null，直接返回空的Wrapper* 2.如果value不为null，则使用mapper对value进行处理，往下剥一层(这是关键，一有机会就要往下剥一层，否则就是原地踏步)** @param mapper* @param * @return*/
public MiniNullWrapper map(Function super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (value == null)
// 按上面说的，如果value为null，我都不处理了。但为了调用者拿到返回值后不会发生空指针，需要用Wrapper包装一下 return MiniNullWrapper.empty();
else {
/** value不为null，那么就要想尽办法将它剥去一层皮。* 由于此时value不为null，即使mapper的apply方法要做的操作是 value.getXxx()/value.setXxx()，都不会空指针* mapper.apply(value)处理后的结果继续用Wrapper包装，此时【新的wrapper里的value】是处理后的数据(下一层)* */
return MiniNullWrapper.ofNullable(mapper.apply(value));
}
}
/*** 终端操作，决定勇敢一次。当你做好面对外面的世界时，就要卸下伪装：直接把value丢出去。* 但为了不祸害别人，给个备选值：other。当你确实是null时，返回other。** @param other* @return*/
public T orElse(T other) {
return value != null ? value : other;
}
// -------- 测试方法 ---------
public static void main(String[] args) {
// 全部不为null Son sonNotNull = new Son("大头儿子");
Father fatherNotNull = new Father();
fatherNotNull.setSon(sonNotNull);
GrandPa grandPaNotNull = new GrandPa();
grandPaNotNull.setFather(fatherNotNull);
// 处理grandPa，观察map()中的处理方法有没有被调用 String sonName1 = MiniNullWrapper.ofNullable(grandPaNotNull)
.map(grandPa -> grandPa.getFather())
.map(father -> father.getSon())
.map(son -> son.getName())
.orElse("没得到儿子的名字");
// 全部为null// GrandPa grandPaNull = new GrandPa();// grandPaNull.setFather(null);// // 处理grandPa，观察map()，你会发现，从grandPa取出father后，由于发现是null，所以father->father.getSon()不会执行，避免了空指针// String sonName2 = MiniNullWrapper.ofNullable(grandPaNull)// .map(grandPa -> grandPa.getFather())// .map(father -> father.getSon())// .map(son -> son.getName())// .orElse("没得到儿子的名字"); }
// ---- 没啥实质内容，就是几个简单的类，我在getter方法中打印了一些信息 ---- static class GrandPa {
private Father father;
public Father getFather() {
System.out.println("GrandPa#getFather被调用了");
return father;
}
public void setFather(Father father) {
this.father = father;
}
}
static class Father {
private Son son;
public Son getSon() {
System.out.println("Father#getSon被调用了");
return son;
}
public void setSon(Son son) {
this.son = son;
}
}
@AllArgsConstructor
static class Son {
private String name;
public String getName() {
System.out.println("Son#getName被调用了");
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
大家先把上面的代码拷到本地消化后，再重新思考下面的问题：
MiniNullWrapper.ofNullable(result)
.map(step1)
.map(step2) // 是否曾担心，在这一步突然出现null，然后空指针异常呢？ .map(step3)
.orElse(step4);
学习MiniNullWrapper后，是否已经有答案了呢？
所以，当你以后使用NullWrapper的map()时，大胆地往下“剥”，不要担心中间是否会出现null导致链路中断：如果value为null，压根不会执行你传入的mapper.apply()，而是创建空的Wrapper继续往下传递！
看到了吧，我们自己封装的MiniNullWrapper已经能够比较优雅地解决空指针了，Java会想不到？所以Java8 引入了Optional这个类，它非常简单，没有任何继承体系：
核心原理和上面的MiniNullWrapper是一样的，用法也相近：
public static String getDepartmentNameOfUser(String username) {
return Optional.ofNullable(getUserByName(username))
.map(ResultTO::getData)
.map(User::getDepartment)
.map(Department::getName)
.orElse("未知部门");
}
或者：
public boolean sendMessage(Long fromId, Long toId, String message) {
// 用户校验：如果用户不存在，直接抛异常 User user = Optional.ofNullable(userService.getUserById(fromId))
.orElseThrow(() -> new BizException(ErrorEnumCode.USER_NOT_EXIST));
// 组装数据并发送...}
也可以是：
public List listSubCities(String provinceCode) {
// 查到就返回，查不到就返回替代值(对于集合而言，尽量返回空集合) return Optional.ofNullable(getCitiesByPid(provinceCode))
.orElse(new ArrayList());
}
日常开发可以试试哟。
博主自己写的Java小册已经开始出售，欢迎加入一起学习。
小册介绍：bravo1988：中级Java程序员如何进阶(小册)zhuanlan.zhihu.com