anotaciones de enlace de Guice personalizadas con los parámetros

Question

He creado correctamente una anotación de enlace de Guice para inyectar instancias de subproceso único java.util.concurrent.ExecutorService en un constructor.

He aquí un ejemplo de uso:

public class ContainsSingleThreadedExecutorService { 


    private final ExecutorService executorService; 

    @Inject 
    public ContainsSingleThreadedExecutorService(@SingleThreaded ExecutorService executorService) { 

     this.executorService = executorService; 
    } 

} 

ahora quiero crear una anotación similar para los ejecutores de subprocesos múltiples, especificando el tamaño ThreadPool en la anotación. Por ejemplo:

public class ContainsMultiThreadedExecutorService { 


    private final ExecutorService executorService; 

    @Inject 
    public ContainsMultiThreadedExecutorService(@MultiThreaded(poolSize = 5) ExecutorService executorService) { 

     this.executorService = executorService; 
    } 

} 

¿Alguien por ahí sabe cómo puedo acceder al valor del parámetro "poolSize" de un proveedor de Guice?

Answer 1

Mire NamedImpl que implementa @Named y el método Names.named(). Creo que deberías tener la misma implementación.

ACTUALIZADO Guice compara anotaciones por hashCode(). Por lo tanto, si no usa @MultiThreaded(poolSize = 5), debe asignarlo antes de la creación de instancias. Parece solución sucia, pero se puede escribir como SMT

for (int i = 1; i < 20; i++){ 
     bind(ExecutorService.class).annotatedWith(Qualifiers.withValue(i)).toProvider(new DependencyProvider(i)); 
    } 

Si desea hacer esto. Recuerde que su MultiThreadedImpl debe anular hashCode de manera adecuada. Podría ser smt como

@Override 
public int hashCode() { 
    return (127 * "poolSize".hashCode())^value; 
} 

Answer 2

No se puede. No es así como se deben usar las anotaciones obligatorias ... el parámetro solo serviría para diferenciar un ExecutorService enlazado con @MultiThreaded(poolSize = 5) de un límite con @MultiThreaded(poolSize = 2). No son metadatos para ayudar a configurar un Provider.

Si se inyecta algo anotado con @MultiThreaded(poolSize = 5), debe tener algo enlazado con la anotación @MultiThreaded(poolSize = 5). Si luego desea cambiar el tamaño de la agrupación que está utilizando en todos esos lugares, debe cambiar poolSize = 5 a poolSize = 4 tanto en el lugar (s) donde lo vincula como en todos los lugares donde lo inyecta. Esto no tiene mucho sentido para mí.

En lugar de vincular ExecutorService por cuántos subprocesos tienen en su grupo de subprocesos, debe vincularlos de acuerdo con lo que desea utilizarlos. Luego puedes ajustar el número de hilos que cada uno usa en un lugar.

Answer 3

Puedes hacer este tipo de cosas (una vez lo hice casi exactamente) con Guice, pero Guice realmente necesita saber de antemano lo que es vinculante. Por lo que tendría que hacer algo como:

for (int i=1; i < 100; i++) { 
    ExecutorService svc = Executors.newFixedThreadPool(i); 
    bind (ExecutorService.class).annotatedWith(new MultiThreadedImpl(i)).toInstance(svc); 
} 

(o, más probablemente, se unen a un proveedor que inicializa con pereza él).

Esto es lo suficientemente feo que probablemente no quiera hacerlo. Es más útil simplemente usar @Named y tener un puñado de instancias de ExecutorService que están vinculadas a un nombre específico para lo que son útiles, de todos modos, entonces puede configurar cuántos hilos se usan en un lugar, en lugar de tener que preguntarse "¿Alguien está usando un ExecutorService de 73 hilos?"

Answer 4

Sí, puede hacerlo. sin iterador todas las situaciones.

En realidad, tengo casi el mismo problema que el suyo. Here es mi respuesta y pregunta, con todo mi código. Solo sé cómo hacer con campo no parámetro, pero creo que esto no es un gran problema, ¿no?

Siga CustomInjections en wiki, sabrá cómo hacerlo.