자바,더 이상 사용 하지 마!=널 이 비 었 어!

머리말
자바 프로그래머 에 게 null 은 골 치 아 픈 것 이다.빈 포인터 이상(NPE)에 시 달 리 는 경우 가 많다.자바 의 발명자 조차도 이것 이 그의 큰 실수 라 는 것 을 인정한다.
그렇다면 코드 에 대량의 판 공 문 구 를 쓰 는 것 을 피 할 수 있 는 방법 은 무엇 일 까?
JDK 8 이 제공 하 는 Optional 을 사용 해 허공 판정 을 피 할 수 있다 는 말 도 있 지만 사용 하기 에는 좀 번거롭다.
저 자 는 일상적인 업무 에서 하나의 도 구 를 봉 하여 대상 구성원 을 빈 칸 으로 판단 하지 않 고 체인 으로 호출 할 수 있 습 니 다.기 존의 if null 논리 와 JDK 8 이 제공 하 는 Optional 보다 더욱 우아 하고 사용 하기 쉬 우 며 공정 실천 에서 인 코딩 효율 을 크게 향상 시 켰 고 코드 를 더욱 정확 하고 우아 하 게 만 들 었 습 니 다.
우아 하지 않 은 판정 공중 호출
자바 개발 에 종사 하고 싶 은 파트너 는 다음 과 같은 괴로운 판 공 논 리 를 만 났 을 것 이다.지금 은 User 류 가 있 고 School 은 그의 구성원 변수 이다.

/**
* @author Axin
* @since 2020-09-20
* @summary   User   
 * （Ps：Data  lombok       ，   get set       ）
*/

@Data
public class User {
 private String name;
 private String gender;
 private School school;
 @Data
 public static class School {
 private String scName;
 private String adress;
 }
}

현재 School 의 구성원 변수 adress 를 얻 으 려 면 일반적인 처리 방식:

public static void main(String[] args) {
 User axin = new User();
 User.School school = new User.School();
 axin.setName("hello");
 if (Objects.nonNull(axin) && Objects.nonNull(axin.getSchool())) {
 User.School userSc = axin.getSchool();
 System.out.println(userSc.getAdress());
 }
}

adress 를 가 져 올 때 School 에 대한 판단 을 해 야 합 니 다.귀 찮 고 사용 할 수 있 습 니 다.JDK 8 을 통 해 제공 하 는 Optional 도구 도 괜 찮 지만 귀 찮 습 니 다.
다음 optionalBean 은 빈 포인터 문 제 를 걱정 하지 않 고 구성원 변 수 를 체인 으로 계속 호출 할 수 있 는 방법 을 제공 합 니 다.
체인 호출 구성원 변수
만약 에 본 고 에서 디자인 한 도구 인 OptionalBean 을 사용한다 면 상기 호출 은 이렇게 간소화 할 수 있다.

public static void main(String[] args) {
 User axin = new User();
 User.School school = new User.School();
 axin.setName("hello");
 // 1.     
 String value1 = OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress).get();
 System.out.println(value1);
}

실행 결과:

그 중에서 User 의 school 변 수 는 비어 있 습 니 다.코드 가 빈 포인터 가 아니 라 null 로 돌아 간 것 을 볼 수 있 습 니 다.이 공 구 는 어떻게 실현 되 었 습 니까?
OptionalBean 도구

/**
* @author Axin
* @since 2020-09-10
* @summary      bean   value    
*/

public final class OptionalBean<T> {
 private static final OptionalBean<?> EMPTY = new OptionalBean<>();
 private final T value;
 private OptionalBean() {
 this.value = null;
 }

 /**
 *         
 * @param value
 */

 private OptionalBean(T value) {
 this.value = Objects.requireNonNull(value);
 }

 /**
 *           bean
 * @param value
 * @param <T>
 * @return
 */

 public static <T> OptionalBean<T> of(T value) {
 return new OptionalBean<>(value);
 }

 /**
 *           bean
 * @param value
 * @param <T>
 * @return
 */

 public static <T> OptionalBean<T> ofNullable(T value) {
 return value == null ? empty() : of(value);
 }

 /**
 *       
 * @param fn
 * @param <R>
 * @return
 */

 public T get() {
 return Objects.isNull(value) ? null : value;
 }

 /**
 *            
 * @param fn
 * @param <R>
 * @return
 */

 public <R> OptionalBean<R> getBean(Function<? super T, ? extends R> fn) {
 return Objects.isNull(value) ? OptionalBean.empty() : OptionalBean.ofNullable(fn.apply(value));
 }

 /**
 *                
 * @param other
 * @return
 */

 public T orElse(T other) {
 return value != null ? value : other;
 }

 /**
 *           lambda        
 * @param other
 * @return
 */

 public T orElseGet(Supplier<? extends T> other) {
 return value != null ? value : other.get();
}

 /**

 *               
 * @param exceptionSupplier
 * @param <X>
 * @return
 * @throws X
 */

 public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
 if (value != null) {
  return value;
 } else {
  throw exceptionSupplier.get();
 }
 }

 public boolean isPresent() {
 return value != null;
 }

 public void ifPresent(Consumer<? super T> consumer) {
 if (value != null)
  consumer.accept(value);
 }

 @Override
 public int hashCode() {
 return Objects.hashCode(value);
 }

 /**
 *     
 * @param <T>
 * @return
 */

 public static<T> OptionalBean<T> empty() {
 @SuppressWarnings("unchecked")
 OptionalBean<T> none = (OptionalBean<T>) EMPTY;
 return none;
 }
}

도구 디자인 은 주로 optional 의 실현 을 참고 한 데다 가 체인 호출 에 대한 확장 은 바로 상기 OptionalBean 이다.
getBean 은 변수 가 비어 있 을 때 포장 빈 값 의 OptionalBean 대상 을 되 돌려 주 는 동시에 일반적인 사용 으로 도 구 를 더욱 쉽게 사용 할 수 있 습 니 다.
사용 설명서
ifPresent(),orElse()등 코드 에서 도 optional 과 같은 확장 방법 을 제공 하 는 것 을 볼 수 있 습 니 다.

public static void main(String[] args) {
 User axin = new User();
 User.School school = new User.School();
 axin.setName("hello");

 // 1.     
 String value1 = OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress).get();
 System.out.println(value1);
 // 2.     isPresent       Optional   
 boolean present = OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress).isPresent();
 System.out.println(present);

 // 3.     ifPresent   
 OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress)
  .ifPresent(adress -> System.out.println(String.format("    :%s", adress)));

 // 4.     orElse
 String value2 = OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress).orElse("   ");
 System.out.println(value2);

 // 5.     orElseThrow
 try {
 String value3 = OptionalBean.ofNullable(axin)
  .getBean(User::getSchool)
  .getBean(User.School::getAdress).orElseThrow(() -> new RuntimeException("    "));
 } catch (Exception e) {
 System.out.println(e.getMessage());
 }

}

run:

총결산
빈 칸 을 판정 하지 않 고 체인 으로 호출 할 수 있 는 도 구 를 설계 하여 코드 를 더욱 정확 하고 우아 하 게 만 들 었 습 니 다.만약 에 본 고가 디자인 한 도구 가 당신 의 어려움 을 해결 할 수 있다 면 프로젝트 에서 사용 하 세 요!
자바 에 대해 서 는 더 이상 사용 하지 마 세 요!=null 판 공 된 글 은 여기까지 소개 되 었 습 니 다.더 많은 관련 자 바 는 사용 하지 않 습 니 다!=null 판 공 내용 은 저희 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!