java - 如何将UriInfo对象注入(inject)到非资源类中

在修改项目代码的过程中，我发现我没有机会将UriInfo对象插入资源类（使用@Context注释）
不幸的是，我无法更改方法或构造函数签名来在资源中检索uriinfo并将其传递给服务类。

是否可以将UriInfo插入普通类（不是jax-rs）？
也许有些说法可以说Jersey不仅扫描资源类，还扫描自定义类？
编辑：

这是一些代码示例

@Path("path")
public class JerseyResource {
   @Get
   public Responce executeMethod(@QueryParam Criteria criteria, @QueryParam ObjType type) {
        return RestUtils.chooseServiceByType(type).process(criteria);
   }
}

RestUtils.chooseServiceByType（type）可以返回约15个不同的实例。
而且仅适用于1个实例（即Type2LogicProcessorServiceImpl），我需要在process（criteria）方法中访问uriInfo对象

谢谢，
迪玛

最佳答案

您将需要将该类作为服务绑定到Jersey的DI框架HK2中。泽西岛大部分注射使用HK2，包括@Context注射。由于@Context与DI绑定，因此您的服务是否与DI绑定，因此您可以在服务中接受@Context注入。

例如，如果您有这个Service类

public class Service {

    @Context
    UriInfo uriInfo;

    public String getUri() {
        return uriInfo.getRequestUri().toASCIIString();
    }
}

然后您需要将其绑定

public class Binder extends AbstractBinder {
    @Override
    protected void configure() {
        bind(Service.class).to(Service.class);
    }
}

然后在Jersey上注册活页夹。在ResourceConfig中，您可以执行

public class AppConfig extends ResourceConfig {
    public AppConfig() {
        register(new Binder());
    }
}

如果使用的是web.xml，则无法直接注册活页夹。您将需要使用Feature并发现该功能。在那里您可以注册活页夹。

@Provider
public class BinderFeature implements Feature {
    @Override
    public boolean configure(FeatureContext ctx) {
        ctx.register(new Binder());
        return true;
    }
}

然后可以将Service注入资源类

@Path("uri")
public class UriResource {

    @Inject
    Service service;

    @GET
    public String get() {
        return service.getUri();
    }
}

有关更多信息：


Custom Injection and Lifecycle Management来自Jersey文档。
上面的HK2链接可获取有关直接与HK2合作的更多信息




更新

看看下面的测试。都可以通过单个测试依赖项来运行

<dependency>
    <groupId>org.glassfish.jersey.test-framework.providers</groupId>
    <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
    <version>${jersey2.version}</version>
    <scope>test</scope>
</dependency>

我要做的是使用HK2 Factory注入查询参数ObjType，并获得Service（现在只是接口的超级类型）。如果它是需要UriInfo的类型，则将其显式地注入ServiceLocator。工厂和定位器可能对您来说是新概念，因此，如果您想了解更多信息，我将浏览上面提供的两个文档链接。

import java.util.logging.Logger;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;

import org.glassfish.hk2.api.Factory;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.filter.LoggingFilter;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;

import org.junit.Test;
import static junit.framework.Assert.assertEquals;

public class UriInfoTest extends JerseyTest {

    public static interface Service {
        String getUri();
    }

    public static class ServiceOne implements Service {

        @Context
        UriInfo uriInfo;

        @Override
        public String getUri() {
            return uriInfo.getRequestUri().toASCIIString();
        }
    }

    public static class ServiceTwo implements Service {
        @Override
        public String getUri() {
            return "Blah";
        }
    }

    public static class ObjType {
        String param;
        public ObjType(String param) {
            this.param = param;
        }
    }

    static class RestUtils {
        static Service getServiceByType(ObjType type) {
            switch (type.param) {
                case "one": return new ServiceOne();
                case "two": return new ServiceTwo();
                default: return new ServiceOne();
            }
        }
    }

    public static class ServiceFactory implements Factory<Service> {

        @QueryParam("type")
        ObjType type;

        @Inject
        ServiceLocator locator;

        @Override
        public Service provide() {
            Service service = RestUtils.getServiceByType(type);
            if (service instanceof ServiceOne) {
                locator.inject(service);
            }
            return service;
        }

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

    public static class Binder extends AbstractBinder {
        @Override
        protected void configure() {
            bindFactory(ServiceFactory.class).to(Service.class);
        }
    }

    @Path("uri")
    public static class UriResource {

        @Inject
        Service service;

        @GET
        public String get() {
            return service.getUri();
        }
    }

    @Override
    public ResourceConfig configure() {
        return new ResourceConfig(UriResource.class)
                .register(new Binder())
                .register(new LoggingFilter(Logger.getAnonymousLogger(), true));
    }

    @Test
    public void doit() {
        Response response = target("uri").queryParam("type", "one").request().get();
        assertEquals(200, response.getStatus());
        String message = response.readEntity(String.class);
        assertEquals("http://localhost:9998/uri?type=one", message);
        response.close();
    }
}