Generics 具有泛型类的Jersey HK2注入

我有一个类似这样的泛型类

public class DAO<T> {

    private final Class<T> clazz;

    public DAO(Class<T> clazz) {
        this.clazz = clazz;
    }
}

公共类DAO{
私人期末班；
公共道（课堂）{
this.clazz=clazz；
}
}

我在Jersey支持的RestFull api中使用它。 我经常使用它，现在我必须这样举例：

private final DAO<Account> accountDAO = new DAO<>(Account.class);

private final DAO accountDAO=新的DAO（Account.class）；

我想使用Jersey的HK2注入库实例化它。 像这样

@Inject
private final DAO<Account> accountDAO

@Inject
私有最终DAO帐户DAO

我很难找到一种通过类型推断进行这种注入的方法。 我看过工厂（org.glassfish.hk2.api.Factory），但还没有找到处理推断的方法

---

你知道怎么做吗？

我在这里假设你在

DAO

实现中确实需要

clazz

由于我一直在考虑这个解决方案，所以我也将在这里提出建议：您可以定义一个定制的注入解析器，该解析器使用泛型来处理

DAO

（确保在应用程序/绑定器中注册它）的创建。如果您不需要

clazz

，代码可能会简化很多

尽管如此，我还是希望有一个更简单的方法，但正如我所说，这是可行的：

@Classes({ MyTest.TestInjectionResolver.class, MyTest.DAO.class })
public class MyTest extends HK2Runner {

    @Inject
    private DAO<Integer> service;

    @Test
    public void doTest() {
        assertNotNull(service);
    }

    @Service
    public static class DAO<T> {

        private final Class<T> clazz;

        @Inject
        public DAO(final Class<T> clazz) {
            this.clazz = clazz;
        }
    }

    @Singleton
    @Rank(Integer.MAX_VALUE)
    @org.jvnet.hk2.annotations.Service
    public static class TestInjectionResolver
            implements org.glassfish.hk2.api.InjectionResolver<Inject> {

        private final org.glassfish.hk2.api.InjectionResolver<Inject> injectionResolver;

        @Inject
        public TestInjectionResolver(
                @Named(org.glassfish.hk2.api.InjectionResolver.SYSTEM_RESOLVER_NAME) final org.glassfish.hk2.api.InjectionResolver<Inject> injectionResolver) {
            this.injectionResolver = injectionResolver;
        }

        @SuppressWarnings("unchecked")
        @Override
        public Object resolve(final Injectee injectee, final ServiceHandle<?> root) {
            final Type requiredType = injectee.getRequiredType();
            if (requiredType instanceof ParameterizedType) {
                final Type rawType = ((ParameterizedType) requiredType).getRawType();
                if (rawType.equals(DAO.class)) {
                    final Class<?> typeArg = (Class<?>) ((ParameterizedType) requiredType).getActualTypeArguments()[0];
                    try {
                        return ((Class<DAO<?>>) rawType).getConstructor(Class.class).newInstance(typeArg);
                    } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return injectionResolver.resolve(injectee, root);
        }

        @Override
        public boolean isConstructorParameterIndicator() {
            return injectionResolver.isConstructorParameterIndicator();
        }

        @Override
        public boolean isMethodParameterIndicator() {
            return injectionResolver.isMethodParameterIndicator();
        }

    }

}

@Classes（{MyTest.testinjectresolver.class，MyTest.DAO.class}）
公共类MyTest扩展了HK2Runner{
@注入
私人DAO服务；
@试验
公共空间doTest（）{
assertNotNull（服务）；
}
@服务
公共静态类DAO{
私人期末班；
@注入
公共DAO（最后一节课）{
this.clazz=clazz；
}
}
@独生子女
@秩（整数最大值）
@org.jvnet.hk2.annotations.Service
公共静态类TestInjectionResolver
实现org.glassfish.hk2.api.InjectionResolver{
私有最终org.glassfish.hk2.api.InjectionResolver InjectionResolver；
@注入
公共测试注入解析器(
@命名（org.glassfish.hk2.api.InjectionResolver.SYSTEM_RESOLVER_NAME）最终org.glassfish.hk2.api.InjectionResolver InjectionResolver{
this.injectionResolver=injectionResolver；
}
@抑制警告（“未选中”）
@凌驾
公共对象解析（最终注入者注入者，最终ServiceHandle根）{
最终类型requiredType=injectee.getRequiredType（）；
if（参数化类型的requiredType实例）{
最终类型rawType=（（ParameteredType）requiredType）.getRawType（）；
if（rawType.equals（DAO.class））{
最终类typeArg=（类）（（ParameterizedType）requiredType）.getActualTypeArguments（）[0]；
试一试{
返回（（类）