我已经能够按照 How to inject an object into jersey request context? 从过滤器注入(inject)我的 Jersey 资源.这使我能够成功地注入(inject)方法参数:

@GET
public Response getTest(@Context MyObject myObject) { // this works

但是，对于 setter/field/constructor 注入(inject)，HK2 工厂在 Jersey 过滤器被调用，这意味着 provide() 方法返回 null:

@Override
public MyObject provide() {
    // returns null because the filter has not yet run,
    // and the property has not yet been set
    return (MyObject)context.getProperty("myObject");
}

有没有办法定义 HK2 Factory 何时运行，以便在过滤器运行之后调用它？如果不是，那么解决方法是将 MyObject 定义为一个接口(interface)，并定义一个额外的实现，在其构造函数中采用 ContainerRequestContext；任何实际使用该实例的尝试都会懒惰地委托(delegate)给在 ContainerRequestContext 的属性上设置的实现(大概在过滤器运行之后您不会实际使用该实例——此时属性将被设置)。

但我想了解是否可以延迟 HK2 Factory 运行的时间点，使其在过滤器之后运行(在方法参数注入(inject)的情况下它已经在过滤器之后运行)。如果不可能，那么我想了解是否有根本原因。

最佳答案

奇怪的是，它只对过滤器上的 @PreMatching 有效(它限制了对某些您可能需要或可能不需要的东西的访问)。不太确定引擎盖下发生了什么，导致它没有它就无法工作:-(。下面是使用 Jersey Test Framework 的完整测试。

import java.io.IOException;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.container.PreMatching;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Context;
import javax.ws.rs.ext.Provider;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.process.internal.RequestScoped;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Assert;
import org.junit.Test;

public class FilterInjectionTest extends JerseyTest {

    private static final String MESSAGE = "Inject OK";
    private static final String OBJ_PROP = "myObject";

    public static class MyObject {

        private final String value;

        public MyObject(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }

    @PreMatching
    @Provider
    public static class MyObjectFilter implements ContainerRequestFilter {

        @Override
        public void filter(ContainerRequestContext context) throws IOException {
            MyObject obj = new MyObject(MESSAGE);
            context.setProperty(OBJ_PROP, obj);
        }
    }

    public static class MyObjectFactory
            extends AbstractContainerRequestValueFactory<MyObject> {

        @Override
        @RequestScoped
        public MyObject provide() {
            return (MyObject) getContainerRequest().getProperty(OBJ_PROP);
        }

        @Override
        public void dispose(MyObject t) {
        }
    }

    @Path("method-param")
    public static class MethodParamResource {

        @GET
        public String getResponse(@Context MyObject myObject) {
            return myObject.getValue();
        }
    }

    @Path("constructor")
    public static class ConstructorResource {

        private final MyObject myObject;

        @Inject
        public ConstructorResource(@Context MyObject myObject) {
            this.myObject = myObject;
        }

        @GET
        public String getResponse() {
            return myObject.getValue();
        }
    }

    @Path("field")
    public static class FieldResource {

        @Inject
        private MyObject myObject;

        @GET
        public String getResponse() {
            return myObject.getValue();
        }
    }

    @Override
    public Application configure() {
        ResourceConfig config = new ResourceConfig();
        config.register(MethodParamResource.class);
        config.register(MyObjectFilter.class);
        config.register(ConstructorResource.class);
        config.register(FieldResource.class);
        config.register(new AbstractBinder() {
            @Override
            protected void configure() {
                bindFactory(MyObjectFactory.class)
                        .to(MyObject.class).in(Singleton.class);
            }
        });
        return config;
    }

    @Test
    public void methoParamInjectionOk() {
        String response = target("method-param").request().get(String.class);
        Assert.assertEquals(MESSAGE, response);
        System.out.println(response);
    }

    @Test
    public void costructorInjectionOk() {
        String response = target("constructor").request().get(String.class);
        Assert.assertEquals(MESSAGE, response);
        System.out.println(response);
    }

    @Test
    public void fieldInjectionOk() {
        String response = target("field").request().get(String.class);
        Assert.assertEquals(MESSAGE, response);
        System.out.println(response);
    }
}

更新

无需将其设为@PreMatching 过滤器的解决方案是注入(inject)javax.inject.Provider。 .这将允许您延迟检索对象。我想构造函数和字段注入(inject)发生的事情是在匹配资源类之后立即创建并注入(inject)。因为过滤器还没有被调用，所以工厂没有对象。它适用于方法注入(inject)，因为它就像任何其他方法调用一样。当方法被调用时，对象被传递给它。下面是带有 javax.inject.Provider

@Path("constructor")
public static class ConstructorResource {

    private final javax.inject.Provider<MyObject> myObjectProvider;

    @Inject
    public ConstructorResource(javax.inject.Provider<MyObject> myObjectProvider) {
        this.myObjectProvider = myObjectProvider;
    }

    @GET
    public String getResponse() {
        return myObjectProvider.get().getValue();
    }
}

@Path("field")
public static class FieldResource {

    @Inject
    private javax.inject.Provider<MyObject> myObjectProvider;;

    @GET
    public String getResponse() {
        return myObjectProvider.get().getValue();
    }
}

关于java - 当 @Context 用于 setter/field/constructor 注入(inject)时，在 Jersey 过滤器之前调用 HK2 工厂，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30854855/