懒加载语法（参数校验使用）

矫情吗；* 2022-12-01 15:35 110阅读 0赞

@RequiredArgsConstructor
    @EqualsAndHashCode
    public class Lazy<T> implements Supplier<T> {
    
    	private final Supplier<T> supplier;
    	private T value = null;
    	private boolean resolved = false;
    
    	/**
    	 * Creates a new {@link Lazy} to produce an object lazily.
    	 *
    	 * @param <T>
    	 *            the type of which to produce an object of eventually.
    	 * @param supplier
    	 *            the {@link Supplier} to create the object lazily.
    	 * @return
    	 */
    	public static <T> Lazy<T> of(Supplier<T> supplier) {
    		return new Lazy<>(supplier);
    	}
    
    	/**
    	 * Returns the value created by the configured {@link Supplier}. Will return
    	 * the calculated instance for subsequent lookups.
    	 *
    	 * @return
    	 */
    	@Override
    	public T get() {
    		return getNullable();
    	}
    
    	/**
    	 * Returns the value of the lazy computation or the given default value in
    	 * case the computation yields {@literal null}.
    	 *
    	 * @param value
    	 * @return
    	 */
    	public T orElse(T value) {
    		return orElseGet(() -> value);
    	}
    
    	/**
    	 * Returns the value of the lazy computation or the value produced by the
    	 * given {@link Supplier} in case the original value is {@literal null}.
    	 *
    	 * @param supplier
    	 *            must not be {@literal null}.
    	 * @return
    	 */
    	public T orElseGet(Supplier<T> supplier) {
    
    		if (Objects.isNull(supplier)) {
    			throw new IllegalArgumentException(
    					"Default value supplier must not be null!");
    		}
    
    		T nullable = getNullable();
    
    		return nullable == null ? supplier.get() : nullable;
    	}
    
    	/**
    	 * Creates a new {@link Lazy} with the given {@link Function} lazily applied
    	 * to the current one.
    	 *
    	 * @param function
    	 *            must not be {@literal null}.
    	 * @return
    	 */
    	public <S> Lazy<S> map(Function<T, S> function) {
    
    		if (Objects.isNull(function)) {
    			throw new IllegalArgumentException("Function must not be null!");
    		}
    
    		return Lazy.of(() -> function.apply(get()));
    	}
    
    	/**
    	 * Creates a new {@link Lazy} with the given {@link Function} lazily applied
    	 * to the current one.
    	 *
    	 * @param function
    	 *            must not be {@literal null}.
    	 * @return
    	 */
    	public <S> Lazy<S> flatMap(Function<T, Lazy<S>> function) {
    
    		if (Objects.isNull(function)) {
    			throw new IllegalArgumentException("Function must not be null!");
    		}
    
    		return Lazy.of(() -> function.apply(get()).get());
    	}
    
    	/**
    	 * Returns the value of the lazy evaluation.
    	 *
    	 * @return
    	 */
    	private T getNullable() {
    
    		T value = this.value;
    
    		if (this.resolved) {
    			return value;
    		}
    
    		value = supplier.get();
    
    		this.value = value;
    		this.resolved = true;
    
    		return value;
    	}
    
    }

// 活动
    		Supplier<FissionEntity> fissionSp = Lazy.of(() -> {
    
    			if (Objects.isNull(cardSp.get())) {
    				return null;
    			}
    
    			// 可能存在多个活动
    			List<FissionEntity> fissionList = fissionCacheService
    					.getRegisterFission(cardSp.get().getId());
    
    			// 查询出有效且最近的一个活动
    			return fissionList.stream().filter(FissionHelper::isEffective)
    					.findFirst().orElse(null);
    		});