Comment faites-vous la carte plusieurs paramètres de requête pour les champs de haricot sur Jersey OBTENIR une demande?

Vous pouvez utiliser com.sun.jersey.spi.inject.InjectableProvider.

import java.util.List;
import java.util.Map.Entry;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.Provider;
import org.springframework.beans.BeanUtils;
import com.sun.jersey.api.core.HttpContext;
import com.sun.jersey.api.model.Parameter;
import com.sun.jersey.core.spi.component.ComponentContext;
import com.sun.jersey.core.spi.component.ComponentScope;
import com.sun.jersey.spi.inject.Injectable;
import com.sun.jersey.spi.inject.InjectableProvider;
@Provider
public final class ParameterBeanProvider implements InjectableProvider<QueryParam, Parameter> {
@Context
private final HttpContext hc;
public ParameterBeanProvider(@Context HttpContext hc) {
this.hc = hc;
}
@Override
public ComponentScope getScope() {
return ComponentScope.PerRequest;
}
@Override
public Injectable<ParameterBean> getInjectable(ComponentContext ic, final QueryParam a, final Parameter c) {
if (ParameterBean.class != c.getParameterClass()) {
return null;
}
return new Injectable<ParameterBean>() {
public ParameterBean getValue() {
ParameterBean parameterBean = new ParameterBean();
MultivaluedMap<String, String> params = hc.getUriInfo().getQueryParameters();
//Populate the parameter bean properties
for (Entry<String, List<String>> param : params.entrySet()) {
String key = param.getKey();
Object value = param.getValue().iterator().next();
//set the property
BeanUtils.setProperty(parameterBean, key, value);
}
return parameterBean;
}
};
}
}

Dans vos ressources, vous avez juste à utiliser @QueryParam("valueWeDontCare").

@GET
@Path("find")
@Produces(MediaType.APPLICATION_XML)
public FindResponse find(@QueryParam("paramBean") ParameterBean paramBean) {
String prop1 = paramBean.getProp1();
String prop2 = paramBean.getProp2();
String prop3 = paramBean.getProp3();
String prop4 = paramBean.getProp4();
}

Le fournisseur sera automatiquement appelé.

Essayer quelque chose comme cela. Utilisation UriInfo pour obtenir tous les paramètres de la requête dans une carte et essayez d'y accéder. Ceci est fait en place de passer des paramètres individuels.

//showing only the relavent code
public FindResponse find( @Context UriInfo allUri ) {
MultivaluedMap<String, String> mpAllQueParams = allUri.getQueryParameters();
String prop1 = mpAllQueParams.getFirst("prop1");
}

Vous pourriez vouloir utiliser l'approche suivante. C'est un très conforme à la norme de la solution et il n'y a pas de hacks là. La solution ci-dessus fonctionne également mais qui est un peu hacky parce qu'il suggère qu'il ne traite que le corps de la requête alors qu'il extrait les données du contexte.

Dans mon cas, j'ai voulu créer une annotation qui permettrait à la carte des paramètres de requête "limite" et "offset" à un seul objet. La solution est comme suit:

@Provider
public class SelectorParamValueFactoryProvider extends AbstractValueFactoryProvider {
public static final String OFFSET_PARAM = "offset";
public static final String LIMIT_PARAM = "limit";
@Singleton
public static final class InjectionResolver extends ParamInjectionResolver<SelectorParam> {
public InjectionResolver() {
super(SelectorParamValueFactoryProvider.class);
}
}
private static final class SelectorParamValueFactory extends AbstractContainerRequestValueFactory<Selector> {
@Context
private ResourceContext  context;
private Parameter parameter;
public SelectorParamValueFactory(Parameter parameter) {
this.parameter = parameter;
}
public Selector provide() {
UriInfo uriInfo = context.getResource(UriInfo.class);
MultivaluedMap<String, String> params = uriInfo.getQueryParameters();
SelectorParam selectorParam = parameter.getAnnotation(SelectorParam.class);
long offset = selectorParam.defaultOffset();
if(params.containsKey(OFFSET_PARAM)) {
String offsetString = params.getFirst(OFFSET_PARAM);
offset = Long.parseLong(offsetString);
}
int limit = selectorParam.defaultLimit();
if(params.containsKey(LIMIT_PARAM)) {
String limitString = params.getFirst(LIMIT_PARAM);
limit = Integer.parseInt(limitString);
}
return new BookmarkSelector(offset, limit);
}
}
@Inject
public SelectorParamValueFactoryProvider(MultivaluedParameterExtractorProvider mpep, ServiceLocator injector) {
super(mpep, injector, Parameter.Source.UNKNOWN);
}
@Override
public AbstractContainerRequestValueFactory<?> createValueFactory(Parameter parameter) {
Class<?> classType = parameter.getRawType();
if (classType == null || (!classType.equals(Selector.class))) {
return null;
}
return new SelectorParamValueFactory(parameter);
}
}

Ce que vous devez faire est de l'enregistrement.

public class JerseyApplication extends ResourceConfig {
public JerseyApplication() {
register(JacksonFeature.class);
register(new InjectionBinder());
}
private static final class InjectionBinder extends AbstractBinder {
@Override
protected void configure() {
bind(SelectorParamValueFactoryProvider.class).to(ValueFactoryProvider.class).in(Singleton.class);
bind(SelectorParamValueFactoryProvider.InjectionResolver.class).to(
new TypeLiteral<InjectionResolver<SelectorParam>>() {
}).in(Singleton.class);
}
}
}

Vous avez aussi besoin de l'annotation elle-même

@Target({java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.FIELD})
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
public @interface SelectorParam {
long defaultOffset() default 0;
int defaultLimit() default 25;
}

et un haricot

public class BookmarkSelector implements Bookmark, Selector {
private long offset;
private int limit;
public BookmarkSelector(long offset, int limit) {
this.offset = offset;
this.limit = limit;
}
@Override
public long getOffset() {
return 0;
}
@Override
public int getLimit() {
return 0;
}
@Override
public boolean matches(Object object) {
return false;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
BookmarkSelector that = (BookmarkSelector) o;
if (limit != that.limit) return false;
if (offset != that.offset) return false;
return true;
}
@Override
public int hashCode() {
int result = (int) (offset ^ (offset >>> 32));
result = 31 * result + limit;
return result;
}
}

Alors vous pouvez l'utiliser comme ceci

@GET
@Path(GET_ONE)
public SingleResult<ItemDTO> getOne(@NotNull @PathParam(ID_PARAM) String itemId, @SelectorParam Selector selector) {
Item item = auditService.getOneItem(ItemId.create(itemId));
return singleResult(mapOne(Item.class, ItemDTO.class).select(selector).using(item));
}