Java Parameter类代码示例

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
protected Factory<?> createValueFactory(Parameter parameter) {

    if (!parameter.isAnnotationPresent(Prop.class)) {
        return null;
    }

    String parameterName = parameter.getSourceName();
    if (parameterName == null || parameterName.length() == 0) {
        // Invalid parameter name
        return null;
    }

    MultivaluedParameterExtractor e = get(parameter);
    if (e == null) {
        return null;
    }

    PropertyFactory factory = new PropertyFactory(e, parameter, i18nEnabled);
    serviceLocator.inject(factory);
    return factory;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
/**
 * Converts {@link Parameter} to {@link InputStream} or {@link List} of
 * {@link InputStream} by {@link Parameter} nature
 * 
 * @param parameter
 * @return {@link Object}
 */
private Object getEntityStream(Parameter parameter) {

    Object stream;

    List<String> paramValues = uriParams.get(parameter.getSourceName());
    String value;
    if (CollectionUtils.valid(paramValues)) {
        if (paramValues.size() == PARAM_VALIES_LENGTH) {
            value = CollectionUtils.getFirst(paramValues);
            stream = RequestUtils.textToStream(value);
        } else {
            stream = RequestUtils.textsToStreams(paramValues);
        }
    } else {
        stream = null;
    }

    return stream;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
/**
 * Reads from {@link InputStream} or {@link List} of {@link InputStream} in
 * case that parameters are multi valued
 * 
 * @param stream
 * @param parameter
 * @throws IOException
 */
private void fillParamList(Object stream, Parameter parameter) throws IOException {

    InputStream entityStream;

    if (stream instanceof InputStream) {
        entityStream = ObjectUtils.cast(stream, InputStream.class);
        readFromStream(entityStream, parameter);
    } else if (stream instanceof List) {
        List<InputStream> streamsList = ObjectUtils.cast(stream);
        Iterator<InputStream> streams = streamsList.iterator();
        while (streams.hasNext()) {
            entityStream = streams.next();
            readFromStream(entityStream, parameter);
        }
    }
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
/**
 * Extracts parameters from {@link ContainerRequestContext} instance
 * 
 * @return {@link List}<Object>
 * @throws IOException
 */
public List<Object> extractParams() throws IOException {

    paramsList = new ArrayList<Object>();

    check = check();
    httpHeaders = request.getHeaders();
    uriParams = extractParameters(request);
    Object stream;
    for (Parameter parameter : parameters) {
        reader = RequestUtils.getReader(workers, parameter, mediaType);
        stream = getEntityStream(request, parameter);
        if (ObjectUtils.notNull(stream)) {
            fillParamList(stream, parameter);
        } else {
            addNullParam(parameter);
        }
    }

    return paramsList;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Inject
public RateLimitingFactoryProvider(final MultivaluedParameterExtractorProvider extractorProvider,
                                   final ServiceLocator injector,
                                   final RateLimiterFactoryProvider rateLimiterFactoryProvider) {
    super(extractorProvider, injector, Parameter.Source.UNKNOWN);
    this.requestRateLimiterFactory = rateLimiterFactoryProvider.factory;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
protected Factory<RequestRateLimiterFactory> createValueFactory(final Parameter parameter) {
    final RateLimiting annotation = parameter.getAnnotation(RateLimiting.class);
    if (null == annotation) {
        return null;
    } else {
        return new AbstractContainerRequestValueFactory<RequestRateLimiterFactory>() {
            public RequestRateLimiterFactory provide() {
                return requestRateLimiterFactory;
            }
        };
    }
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
protected Factory<?> createValueFactory(final Parameter parameter) {
    final RateLimiting annotation = parameter.getAnnotation(RateLimiting.class);
    if (null == annotation) {
        return null;
    } else {
        return new AbstractContainerRequestValueFactory<RequestRateLimiterFactory>() {
            public RequestRateLimiterFactory provide() {
                return requestRateLimiterFactory;
            }
        };
    }
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
    protected Factory<?> createValueFactory(Parameter parameter) {

        LOGGER.debug("{}", parameter);
//        parameter.getSourceName()
        JsonParamValueFactory factory = new JsonParamValueFactory(parameter);
        getLocator().inject(factory);
        return factory;
    }
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Inject
protected Pac4JProfileValueFactoryProvider(ProfileManagerFactoryBuilder manager,
        OptionalProfileFactoryBuilder opt, ProfileFactoryBuilder profile,
        MultivaluedParameterExtractorProvider mpep, ServiceLocator locator) {
    super(mpep, locator, Parameter.Source.UNKNOWN);
    this.manager = manager;
    this.optProfile = opt;
    this.profile = profile;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
protected Factory<?> createValueFactory(Parameter parameter) {
    if (parameter.isAnnotationPresent(Pac4JProfileManager.class)) {
        if (ProfileManager.class.isAssignableFrom(parameter.getRawType())) {
            return manager.get();
        }

        throw new IllegalStateException("Cannot inject a Pac4J profile manager into a parameter of type "
                + parameter.getRawType().getName());
    }

    if (parameter.isAnnotationPresent(Pac4JProfile.class)) {
        if (CommonProfile.class.isAssignableFrom(parameter.getRawType())) {
            return profile.get();
        }

        if (Optional.class.isAssignableFrom(parameter.getRawType())) {
            List<ClassTypePair> ctps = ReflectionHelper.getTypeArgumentAndClass(parameter.getRawType());
            ClassTypePair ctp = (ctps.size() == 1) ? ctps.get(0) : null;
            if (ctp == null || CommonProfile.class.isAssignableFrom(ctp.rawClass())) {
                return optProfile.get();
            }
        }

        throw new IllegalStateException(
                "Cannot inject a Pac4J profile into a parameter of type " + parameter.getRawType().getName());
    }

    return null;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Inject
protected CustomAnnotationProvider(
		MultivaluedParameterExtractorProvider mpep,
		ServiceLocator locator) {

	super(mpep, locator, Parameter.Source.UNKNOWN);
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override
protected Factory<String> createValueFactory(Parameter parameter) {
	return new Factory<String>() {
		@Override
		public String provide() {
			return "hello world";
		}

		@Override
		public void dispose(String instance) {  }
	};
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Inject
public AuthValueFactoryProvider(final MultivaluedParameterExtractorProvider extractorProvider,
    final ServiceLocator injector, ClientAuthFactory clientAuthFactory,
    AutomationClientAuthFactory automationClientAuthFactory, UserAuthFactory userAuthFactory) {
  super(extractorProvider, injector, Parameter.Source.UNKNOWN);
  this.clientAuthFactory = clientAuthFactory;
  this.automationClientAuthFactory = automationClientAuthFactory;
  this.userAuthFactory = userAuthFactory;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Override protected Factory<?> createValueFactory(final Parameter parameter) {
  final Class<?> classType = parameter.getRawType();
  final Auth auth = parameter.getAnnotation(Auth.class);

  if (auth == null) {
    return null;
  }

  if (classType.equals(Client.class)) {
    return new AbstractContainerRequestValueFactory<Client>() {
      @Override public Client provide() {
        return clientAuthFactory.provide(getContainerRequest());
      }
    };
  }

  if (classType.equals(AutomationClient.class)) {
    return new AbstractContainerRequestValueFactory<AutomationClient>() {
      @Override public AutomationClient provide() {
        return automationClientAuthFactory.provide(getContainerRequest());
      }
    };
  }

  if (classType.equals(User.class)) {
    return new AbstractContainerRequestValueFactory<User>() {
      @Override public User provide() {
        return userAuthFactory.provide(getContainerRequest());
      }
    };
  }

  return null;
}
 

import org.glassfish.jersey.server.model.Parameter; //导入依赖的package包/类
@Inject
protected ConfigurationFactoryProvider(final MultivaluedParameterExtractorProvider extractorProvider,
        final ServiceLocator injector, final ConfigurationFactoryInfo configInfo) {
    super(extractorProvider, injector, Parameter.Source.UNKNOWN);
    this.configuration = configInfo.configuration;
    this.dataSource = configInfo.dataSource;
    this.multiTenantConnectionProvider = configInfo.multiTenantConnectionProvider;
}