javax.validation.constraints.Null Java Examples

/**
 * Take a stab at fixing validation problems ?
 * 
 * @param object
 */
private void validate(Object object) {
	Set<ConstraintViolation<Object>> viols = validator.validate(object);
	for (ConstraintViolation<Object> constraintViolation : viols) {
		if (Null.class.isAssignableFrom(constraintViolation.getConstraintDescriptor().getAnnotation().getClass())) {
			Object o = constraintViolation.getLeafBean();
			Iterator<Node> iterator = constraintViolation.getPropertyPath().iterator();
			String propertyName = null;
			while (iterator.hasNext()) {
				propertyName = iterator.next().getName();
			}
			if (propertyName != null) {
				try {
					PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(o.getClass(), propertyName);
					descriptor.getWriteMethod().invoke(o, new Object[] { null });
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
}
 

/**
 * Determine whether a given field or method is annotated to be not nullable.
 *
 * @param member the field or method to check
 * @return whether member is annotated as nullable or not (returns null if not specified: assumption it is nullable then)
 */
protected Boolean isNullable(MemberScope<?, ?> member) {
    Boolean result;
    if (this.getAnnotationFromFieldOrGetter(member, NotNull.class, NotNull::groups) != null
            || this.getAnnotationFromFieldOrGetter(member, NotBlank.class, NotBlank::groups) != null
            || this.getAnnotationFromFieldOrGetter(member, NotEmpty.class, NotEmpty::groups) != null) {
        // field is specifically NOT nullable
        result = Boolean.FALSE;
    } else if (this.getAnnotationFromFieldOrGetter(member, Null.class, Null::groups) != null) {
        // field is specifically null (and thereby nullable)
        result = Boolean.TRUE;
    } else {
        result = null;
    }
    return result;
}
 

/**
 * performs the discovery based on the configured set of targets in the configuration, (pre-)filtering the returned set applying the filter criteria supplied.
 * The instances discovered are automatically registered at this Discoverer
 * @param applicationIdFilter the (pre-)filter based on ApplicationIds, allowing to early filter the list of instances to discover
 * @param instanceFilter the (pre-)filter based on the Instance instance, allowing to filter the lost if instances to discover
 * @return the list of Instances which were discovered (and registered).
 */
@Null
public List<Instance> discover(@Null Predicate<? super String> applicationIdFilter, @Null Predicate<? super Instance> instanceFilter) {
	log.debug(String.format("We have %d targets configured", this.promregatorConfiguration.getTargets().size()));
	
	List<ResolvedTarget> resolvedTargets = this.targetResolver.resolveTargets(this.promregatorConfiguration.getTargets());
	if (resolvedTargets == null) {
		log.warn("Target resolved was unable to resolve configured targets");
		return Collections.emptyList();
	}
	log.debug(String.format("Raw list contains %d resolved targets", resolvedTargets.size()));
	
	List<Instance> instanceList = this.appInstanceScanner.determineInstancesFromTargets(resolvedTargets, applicationIdFilter, instanceFilter);
	if (instanceList == null) {
		log.warn("Instance Scanner unable to determine instances from provided targets");
		return Collections.emptyList();
	}
	log.debug(String.format("Raw list contains %d instances", instanceList.size()));

	// ensure that the instances are registered / touched properly
	for (Instance instance : instanceList) {
		this.registerInstance(instance);
	}
	
	return instanceList;
}
 

@lombok.Builder(builderClassName = "Builder", toBuilder = true)
public BuildPushResult(
        @NotNull(groups = WhenUpdating.class) @Null(groups = WhenCreatingNew.class) String id,
        @NotNull String buildId,
        @NotNull BuildPushStatus status,
        Integer brewBuildId,
        String brewBuildUrl,
        String logContext,
        String message,
        ProductMilestoneCloseResultRef productMilestoneCloseResult) {
    super(id, buildId, status, brewBuildId, brewBuildUrl, logContext, message);
    this.productMilestoneCloseResult = productMilestoneCloseResult;
}
 

/**
 * @param column   Name of column value to be negated.
 */
public NegateExpression(@Null String column, String alias)
{
  super(column, alias);
  if (this.alias == null) {
    this.alias = "NEGATE(" + column + ")";
  }
}
 

public String handleRequest(@Null Predicate<? super String> applicationIdFilter, @Null Predicate<? super Instance> instanceFilter) throws ScrapingException {
	log.debug("Received request to a metrics endpoint");
	Instant start = Instant.now();
	
	this.up.clear();
	
	List<Instance> instanceList = this.cfDiscoverer.discover(applicationIdFilter, instanceFilter);
	
	if (instanceList == null || instanceList.isEmpty()) {
		throw new ScrapingException("Unable to determine any instance to scrape");
	}
	
	List<MetricsFetcher> callablesPrep = this.createMetricsFetchers(instanceList);
	
	List<Future<HashMap<String, MetricFamilySamples>>> futures = this.startMetricsFetchers(callablesPrep);
	log.debug(String.format("Fetching metrics from %d distinct endpoints", futures.size()));
	
	MergableMetricFamilySamples mmfs = waitForMetricsFetchers(futures);
	
	Instant stop = Instant.now();
	Duration duration = Duration.between(start, stop);
	this.handleScrapeDuration(this.requestRegistry, duration);
	
	if (this.isIncludeGlobalMetrics()) {
		// also add our own (global) metrics
		mmfs.merge(this.gmfspr.determineEnumerationOfMetricFamilySamples(this.collectorRegistry));
	}
	
	// add also our own request-specific metrics
	mmfs.merge(this.gmfspr.determineEnumerationOfMetricFamilySamples(this.requestRegistry));
	
	return mmfs.toType004String();
}
 

@Override
public PropertyModel postProcessInternal(PropertyModel propertyModel) {
    Null nullAnno = propertyModel.getPropertyItem().getAnnotation(Null.class);
    if (nullAnno == null)  return propertyModel;

    propertyModel.setRequired(false);

    return propertyModel;
}
 

@Test
public void testSingleInstance() {
	@Null
	List<Instance> actual = this.cfDiscoverer.discover(appId -> appId.equals(CFAccessorSimulator.APP_UUID_PREFIX+"100"), 
			instance -> (CFAccessorSimulator.APP_UUID_PREFIX+"100:1").equals(instance.getInstanceId()));
	assertThat(actual).hasSize(1);
}
 

@Bean
public AppInstanceScanner appInstanceScanner() {
	return new AppInstanceScanner() {

		@Override
		public List<Instance> determineInstancesFromTargets(List<ResolvedTarget> targets, @Null Predicate<? super String> applicationIdFilter, @Null Predicate<? super Instance> instanceFilter) {
			LinkedList<Instance> result = new LinkedList<>();

			return result;
		}

	};
}
 

public MessageList findMessages(@Null @Email String recipientEmail, Pageable pageRequest) {

        List<MessageEntity> entities;

        if (StringUtils.isBlank(recipientEmail)) {
            entities = messageRepository.findAllByOrderByReceivedDateDesc(pageRequest);
        }
        else {
            entities = messageRepository.findAllForRecipientOrderByReceivedDateDesc(recipientEmail, pageRequest);
        }

        return messageListMapper.toMessageList(entities);
    }
 

@Test
public void testDiscoveryWorks() {
	@Null
	List<Instance> actual = this.cfDiscoverer.discover(null, null);
	assertThat(200).isEqualTo(actual.size());
}
 

private void appendNullValidator(SourceWriter w, JField field) {
	Null nullAnnotation = field.getAnnotation(Null.class);
	if (nullAnnotation != null) {
		w.println(", new NullValidator(\"%s\")", nullAnnotation.message());
	}
}
 

@Override
@Null
protected Object lookup(Object key) {
	return cache.get(key);
}
 

@Override
public void initialize(Null constraintAnnotation) {
}
 

private String resolveNull(Field field) {
	return field.isAnnotationPresent(Null.class) ? "必须为空" : null;
}
 

@Null(groups = Test.class)
public Object getNullGetter() {
    return this.nullGetter;
}
 

public RSocketBrokerResponderHandler(@NotNull ConnectionSetupPayload setupPayload,
                                     @NotNull RSocketCompositeMetadata compositeMetadata,
                                     @NotNull AppMetadata appMetadata,
                                     @NotNull RSocketAppPrincipal principal,
                                     RSocket peerRsocket,
                                     ServiceRoutingSelector routingSelector,
                                     TopicProcessor<CloudEventImpl> eventProcessor,
                                     RSocketBrokerHandlerRegistry handlerRegistry,
                                     ServiceMeshInspector serviceMeshInspector,
                                     @Null RSocket upstreamRSocket) {
    try {
        this.upstreamRSocket = upstreamRSocket;
        RSocketMimeType dataType = RSocketMimeType.valueOfType(setupPayload.dataMimeType());
        if (dataType != null) {
            this.defaultMessageMimeType = new MessageMimeTypeMetadata(dataType);
            this.defaultEncodingBytebuf = constructDefaultDataEncoding();
        }
        this.appMetadata = appMetadata;
        this.id = appMetadata.getId();
        this.uuid = appMetadata.getUuid();
        //app tags hashcode set
        this.appTagsHashCodeSet.add(("id=" + this.id).hashCode());
        this.appTagsHashCodeSet.add(("uuid=" + this.uuid).hashCode());
        if (appMetadata.getIp() != null && !appMetadata.getIp().isEmpty()) {
            this.appTagsHashCodeSet.add(("ip=" + this.appMetadata.getIp()).hashCode());
        }
        if (appMetadata.getMetadata() != null) {
            for (Map.Entry<String, String> entry : appMetadata.getMetadata().entrySet()) {
                this.appTagsHashCodeSet.add((entry.getKey() + "=" + entry.getValue()).hashCode());
            }
        }
        this.principal = principal;
        this.peerRsocket = peerRsocket;
        this.routingSelector = routingSelector;
        this.eventProcessor = eventProcessor;
        this.handlerRegistry = handlerRegistry;
        this.serviceMeshInspector = serviceMeshInspector;
        //publish services metadata
        if (compositeMetadata.contains(RSocketMimeType.ServiceRegistry)) {
            ServiceRegistryMetadata serviceRegistryMetadata = ServiceRegistryMetadata.from(compositeMetadata.getMetadata(RSocketMimeType.ServiceRegistry));
            if (serviceRegistryMetadata.getPublished() != null && !serviceRegistryMetadata.getPublished().isEmpty()) {
                setPeerServices(serviceRegistryMetadata.getPublished());
                registerPublishedServices();
            }
        }
        //new comboOnClose
        this.comboOnClose = Mono.first(super.onClose(), peerRsocket.onClose());
        this.comboOnClose.doOnTerminate(this::unRegisterPublishedServices).subscribeOn(Schedulers.parallel()).subscribe();
    } catch (Exception e) {
        log.error(RsocketErrorCode.message("RST-500400"), e);
    }
}
 

/**
 * 根据用户名获取用户基本信息
 *
 * @param userName
 * @return
 */
@Null
public EUser fetchByName(String userName) {
	return userDao.fetchByName(userName);
}
 

/**
 * determines a list of instances based on a provided list of targets.
 * Note that there may be more or less instances than targets as input. This may
 * have multiple reasons:
 * - one target resolves to multiple instances (e.g. if an application has multiple
 * instances running due to load balancing or fail-over safety)
 * - one target does not resolve to any instance, if the application has been
 * misconfigured or if the application is currently not running.
 * @param targets the list of targets, for which the properties of instances shall be determined
 * @param applicationIdFilter an optional filter function allowing to prefilter results early, indicating whether an application based on its applicationId is in scope or not
 * @param instanceFilter an optional filter function allowing to prefilter results early, indicating whether an instance is in scope or not
 * @return the list of instances containing the access URL and the instance identifier
 */
@Null
List<Instance> determineInstancesFromTargets(List<ResolvedTarget> targets, @Null Predicate<? super String> applicationIdFilter, @Null Predicate<? super Instance> instanceFilter);
 

/**
 * performs the discovery based on the configured set of targets in the configuration, (pre-)filtering the returned set applying the filter criteria supplied.
 * The instances discovered are automatically registered at this Discoverer
 * @param applicationIdFilter the (pre-)filter based on ApplicationIds, allowing to early filter the list of instances to discover
 * @param instanceFilter the (pre-)filter based on the Instance instance, allowing to filter the lost if instances to discover
 * @return the list of Instances which were discovered (and registered).
 */
List<Instance> discover(@Null Predicate<? super String> applicationIdFilter, @Null Predicate<? super Instance> instanceFilter);
 

/**
 * 判断是否拥有可以为空的注解
 * @author Frodez
 * @date 2019-06-11
 */
private boolean hasNullableAnnotation(ResolvedMethodParameter methodParameter) {
	return methodParameter.hasParameterAnnotation(Null.class) || methodParameter.hasParameterAnnotation(Nullable.class) || methodParameter
		.hasParameterAnnotation(reactor.util.annotation.Nullable.class);
}