是的，Jersey 在 2.x 中使自定义注入的创建变得更加复杂。您需要了解 Jersey 2.x 中自定义注入的几个主要组件
您可以在Custom Injection and Lifecycle Management 中阅读有关自定义注入的更多信息。文档的一个缺点是缺乏对如何注入参数值的解释。您可以简单地实现InjectResolver，并且可以使用自定义注释注入字段，但是为了注入方法参数，我们需要ValueFactoryProvider。
幸运的是，我们可以扩展一些抽象类（文档也没有提及），这将使生活变得更轻松。我必须在source code of the org.glassfish.jersey.server.internal.inject package 上搜索一下才能弄清楚。
这是一个完整的示例，可帮助您入门。
Token（可注入对象）
public class Token {
private final String token;
public Token(String token) { this.token = token; }
public String getToken() { return token; }
}
@TokenParam（我们的注入注解）
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.PARAMETER, ElementType.FIELD})
public @interface TokenParam {
boolean someAttribute() default true;
}
TokenFactory（根据第一个要点实现Factory，但我们只是扩展AbstractContainerRequestValueFactory。在那里我们可以访问ContainerRequestContext。注意，所有这些HK2组件，我们可以在其中注入其他依赖，例如TokenAuthenticator，我们稍后会绑定到HK2。
import javax.inject.Inject;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
public class TokenFactory extends AbstractContainerRequestValueFactory<Token> {
private final TokenAuthenticator tokenAuthenticator;
@Inject
public TokenFactory(TokenAuthenticator tokenAuthenticator) {
this.tokenAuthenticator = tokenAuthenticator;
}
@Override
public Token provide() {
String auth = getContainerRequest().getHeaderString(HttpHeaders.AUTHORIZATION);
try {
if (tokenAuthenticator.authenticate(auth).get() == null) {
throw new WebApplicationException(Response.Status.FORBIDDEN);
}
} catch (AuthenticationException ex) {
Logger.getLogger(TokenFactory.class.getName()).log(Level.SEVERE, null, ex);
}
return new Token("New Token");
}
}
TokenParamInjectionResolver（每个要点二实现InjectResolver。我只是扩展ParamInjectionResolver。如果您对幕后发生的事情感兴趣，您可以在源代码中找到该课程我链接到的代码）
import org.glassfish.jersey.server.internal.inject.ParamInjectionResolver;
public class TokenParamInjectionResolver extends ParamInjectionResolver {
public TokenParamInjectionResolver() {
super(TokenFactoryProvider.class);
}
}
TokenFactoryProvider（根据第三个要点实现ValueFactoryProvider。我只是扩展AbstractValueFactoryProvider。同样，您可以查看源代码以了解底层细节）
import javax.inject.Inject;
import org.glassfish.hk2.api.Factory;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.jersey.server.internal.inject.AbstractValueFactoryProvider;
import org.glassfish.jersey.server.internal.inject.MultivaluedParameterExtractorProvider;
import org.glassfish.jersey.server.model.Parameter;
public class TokenFactoryProvider extends AbstractValueFactoryProvider {
private final TokenFactory tokenFactory;
@Inject
public TokenFactoryProvider(
final MultivaluedParameterExtractorProvider extractorProvider,
ServiceLocator locator,
TokenFactory tokenFactory) {
super(extractorProvider, locator, Parameter.Source.UNKNOWN);
this.tokenFactory = tokenFactory;
}
@Override
protected Factory<?> createValueFactory(Parameter parameter) {
Class<?> paramType = parameter.getRawType();
TokenParam annotation = parameter.getAnnotation(TokenParam.class);
if (annotation != null && paramType.isAssignableFrom(Token.class)) {
return tokenFactory;
}
return null;
}
}
TokenFeature（这里我们绑定了上面看到的所有组件，甚至是TokenAuthentictor，我已经省略了，但是如果你通常使用Dropwizard Authenticator。我还使用了一个Feature。我倾向于这样做来包装自定义功能的组件。这也是您可以决定所有范围的地方。请注意，某些组件必须在 Singleton 范围内）
import javax.inject.Singleton;
import javax.ws.rs.core.Feature;
import javax.ws.rs.core.FeatureContext;
import org.glassfish.hk2.api.InjectionResolver;
import org.glassfish.hk2.api.TypeLiteral;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.spi.internal.ValueFactoryProvider;
public class TokenFeature implements Feature {
@Override
public boolean configure(FeatureContext context) {
context.register(new AbstractBinder(){
@Override
public void configure() {
bind(TokenAuthenticator.class)
.to(TokenAuthenticator.class)
.in(Singleton.class);
bind(TokenFactory.class).to(TokenFactory.class)
.in(Singleton.class);
bind(TokenFactoryProvider.class)
.to(ValueFactoryProvider.class)
.in(Singleton.class);
bind(TokenParamInjectionResolver.class)
.to(new TypeLiteral<InjectionResolver<TokenParam>>(){})
.in(Singleton.class);
}
});
return true;
}
}
最后只需注册功能
register(TokenFeature.class);
现在您应该能够将Token 与@TokenParam 以及您通常的实体主体注入（如果我们没有实现ValueFactoryProvider，这是不可能的
@POST
@Consumes(MediaType.APPLICATION_JSON)
public String postToken(@TokenParam Token token, User user) {
}
更新
对于您的特定用例来说，这是一个半-@$$ 示例。更好的方法可能是在您的Factory 类中有一个克隆方法，并使用一些参数创建一个新的TokenFactory（也许您可以从您的注解. For example, in the TokenFactory 中获得类似的东西
public class TokenFactory extends AbstractContainerRequestValueFactory<Token> {
public TokenFactory clone(boolean someAttribute) {
return new TokenFactory(authenticator, someAttribute);
}
在TokenFactoryProvider ine createValueFactory 方法中，然后调用克隆方法
TokenParam annotation = parameter.getAnnotation(TokenParam.class);
if (annotation != null && paramType.isAssignableFrom(Token.class)) {
return tokenFactory.clone(annotation.someAttribute());
}
或者您实际上可以在方法内创建工厂。你有选择。
更新 2
另见
更新 3
从 Jersey 2.26 开始，依赖注入发生了变化。您将需要查看 this post 以了解代码在实现相同注入时的变化。