java - Utilizando Jersey 2.0, ¿cómo se registra una instancia enlazable por solicitud?

dependency-injection jersey-2.0

Question

... si la instancia necesita construirse manualmente, tal vez por una clase de fábrica de terceros? Anteriormente, (Jersey 1.x), harías algo como esto:

public class MyInjectableProvider extends PerRequestTypeInjectableProvider<Context, MyInjectable> {
public MyInjectableProvider() {
super(MyInjectable.class);
}
@Override
public Injectable<MyInjectable> getInjectable(ComponentContext ic, Context context) {
MyInjectable myInjectableInstance = //...
return new Injectable<MyInjectable>() {
@Override
public MyInjectable getValue() {
return myInjectableInstance;
}
};
}
}

La clase local anónima puede acceder a una instancia para regresar dentro de algún alcance. Esto es útil cuando no está trabajando con clases que tienen constructores predeterminados, pero deben construirse para cada solicitud.

Jersey 2.0 cambió a HK2 como marco de inyección de dependencias, pero, por desgracia, la página de migración ( https://jersey.java.net/documentation/latest/migration.html ) no proporciona un ejemplo de este tipo de enlace, y La documentación HK2 no proporciona ejemplos utilizando un AbstractBinder.

Para elaborar un poco más, estoy tratando de proporcionar instancias JPA EntityManager de recursos locales e independientes del contenedor a mis recursos. Estos deben ser obtenidos de una clase de fábrica de singleton, y solo deben quedarse para una sola "unidad de trabajo", que es una solicitud en mi caso. Soy consciente de que existen soluciones alternativas (solo inyecte la fábrica o enlace a un threadlocal), pero la solución anterior me pareció elegante y me gustaría recrearla si es posible.

EDITAR:
Después de revisar un poco los javadocs HK2, descubrí que se puede lograr algo similar de la siguiente manera:

public class MyInjectableProvider extends AbstractBinder
implements Factory<MyInjectable> {
@Override
protected void configure() {
bindFactory(this).to(MyInjectable.class);
}
@Override
public MyInjectable provide() {
return getMyInjectable();
}
@Override
public void dispose(MyInjectable instance) {}
}

Y para registrarlo ...

public class MyResourceConfig extends ResourceConfig {
public MyResourceConfig() {
register(new MyInjectableProvider());
}
}

Esto "parece funcionar", pero también parece poco claro. dispose () nunca se llama, por ejemplo. Además, este enlace parece comportarse implícitamente como RequestScoped. Modificación de la configuración a bindFactory(this).to(MyInjectable.class).in(RequestScoped.class); no parece realmente cambiar el comportamiento ¿Me estoy perdiendo algo, o es esta la solución deseada?

Answer 1

En lugar de Factory<T>.dispose(T) , el registro con el Factory<T>.dispose(T) puede hacer la mayoría de lo que desea. Se requerirá un adaptador CloseableFactory . CloseableService closes() todos los recursos registrados al salir del alcance de la solicitud.

Para un ejemplo específico, vea la sección de ConnectionFactory continuación.

import org.glassfish.hk2.api.Factory;
import org.glassfish.jersey.server.CloseableService;
import javax.inject.Inject;
import javax.ws.rs.InternalServerErrorException;
import java.sql.Connection;
import java.sql.SQLException;
import static com.google.common.base.Preconditions.checkNotNull;
public class ConnectionFactory implements Factory<Connection> {
private final CloseableService closeableService;
@Inject
public ConnectionFactory(CloseableService closeableService) {
this.closeableService = checkNotNull(closeableService);
}
public Connection provide() {
final Connection connection;
try {
connection = acquireConnection();
} catch (SQLException e) {
throw new InternalServerErrorException(e);
}
try {
closeableService.add(new CloseableConnection(connection));
} catch (Throwable t) {
closeQuietly(connection);
throw runtime(t);
}
return connection;
}
public void dispose(Connection connection) {
closeQuietly(connection);
}
private static RuntimeException runtime(Throwable t) {
throw ConnectionFactory.<RuntimeException>unchecked(t);
}
private static <T extends Throwable> T unchecked(Throwable t) throws T {
throw (T) t;
}
private static void closeQuietly(Connection connection) {
try {
connection.close();
} catch (SQLException ignore) {}
}
}

A continuación se muestra una versión menos general de un CloseableFactory - un CloseableConnection .

import java.io.Closeable;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import static com.google.common.base.Preconditions.checkNotNull;
public final class CloseableConnection implements Closeable {
private final Connection connection;
public CloseableConnection(Connection connection) {
this.connection = checkNotNull(connection);
}
public void close() throws IOException {
try {
connection.close();
} catch (SQLException e) {
throw new IOException(e);
}
}
}