org.glassfish.jersey.internal.inject.InjectionManager Java Examples

@Override
protected void configure() {
    checkHkFirstMode();
    final EnumSet<DispatcherType> types = context.option(GuiceFilterRegistration);
    final boolean guiceServletSupport = !types.isEmpty();

    // injector not available at this point, so using provider
    final InjectorProvider provider = new InjectorProvider(application);
    install(new GuiceBindingsModule(provider, guiceServletSupport));
    final GuiceFeature component =
            new GuiceFeature(provider, context.stat(), context.lifecycle(), context.option(UseHkBridge));
    bind(InjectionManager.class).toProvider(component);
    // avoid registration when called within guice report
    if (currentStage() != Stage.TOOL) {
        environment.jersey().register(component);
    }

    if (guiceServletSupport) {
        install(new GuiceWebModule(environment, types));
    }
}
 

@SuppressWarnings("unchecked")
@Test
public void delegateRequest_ValidRequestAndReferencesGiven_ShouldSetReferencesOnRequestInitialization() {
	Context context = mock(Context.class);
	DefaultServiceRequest request = new DefaultServiceRequest(null, new HashMap<>(), URI.create("/"), "GET");

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, request);

	Ref<ServiceRequest> serviceRequestRef = mock(Ref.class);
	Ref<Context> contextRef = mock(Ref.class);

	InjectionManager injectionManager = mock(InjectionManager.class);
	when(injectionManager.getInstance(SERVICE_REQUEST_TYPE)).thenReturn(serviceRequestRef);
	when(injectionManager.getInstance(AbstractLambdaContextReferencingBinder.LAMBDA_CONTEXT_TYPE)).thenReturn(contextRef);

	requestScopedInitializer.initialize(injectionManager);

	verify(serviceRequestRef).set(request);
	verify(contextRef).set(context);
}
 

@SuppressWarnings("unchecked")
@Test
public void delegateRequest_ValidRequestAndReferencesGiven_ShouldSetReferencesOnRequestInitialization() {
	Context context = mock(Context.class);
	DefaultGatewayRequest request = new DefaultGatewayRequest();
	request.setPath("/");
	request.setHttpMethod("GET");

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, request);

	Ref<GatewayRequest> gatewayRequestRef = mock(Ref.class);
	Ref<Context> contextRef = mock(Ref.class);


	InjectionManager injectionManager = mock(InjectionManager.class);
	when(injectionManager.getInstance(GATEWAY_REQUEST_TYPE)).thenReturn(gatewayRequestRef);
	when(injectionManager.getInstance(AbstractLambdaContextReferencingBinder.LAMBDA_CONTEXT_TYPE)).thenReturn(contextRef);

	requestScopedInitializer.initialize(injectionManager);

	verify(gatewayRequestRef).set(request);
	verify(contextRef).set(context);
}
 

@SuppressWarnings("unchecked")
@Test
public void delegateRequest_ValidRequestAndReferencesGiven_ShouldSetReferencesOnRequestInitialization() {

	Context context = mock(Context.class);
	SNS sns = new SNS();
	sns.setTopicArn(":t");
	SNSRecord snsRecord = new SNSRecord();
	snsRecord.setSns(sns);

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, snsRecord);

	Ref<SNSRecord> snsRef = mock(Ref.class);
	Ref<Context> contextRef = mock(Ref.class);

	InjectionManager injectionManager = mock(InjectionManager.class);
	when(injectionManager.getInstance(SNS_RECORD_TYPE)).thenReturn(snsRef);
	when(injectionManager.getInstance(AbstractLambdaContextReferencingBinder.LAMBDA_CONTEXT_TYPE)).thenReturn(contextRef);

	requestScopedInitializer.initialize(injectionManager);

	verify(snsRef).set(snsRecord);
	verify(contextRef).set(context);
}
 

/**
 * /path?filter=p.in(1,2)c.eq('ddd')d.startWith('a')or(f.eq('a')g.startWith(2))
 *
 * @param queryParams uri query params
 * @param query       query
 * @param manager     a {@link InjectionManager} object.
 * @param <T>         a T object.
 */
public static <T> void applyFilter(MultivaluedMap<String, String> queryParams,
                                   SpiQuery<T> query,
                                   InjectionManager manager) {
    List<String> wheres = queryParams.get(FILTER_PARAM_NAME);
    if (wheres != null && wheres.size() > 0) {
        EbeanExprInvoker invoker = new EbeanExprInvoker(query, manager);
        WhereExprApplier<T> applier = WhereExprApplier.create(query.where());
        for (String w : wheres) {
            QueryDSL.invoke(
                    w,
                    invoker,
                    applier
            );
        }
    }
}
 

/**
 * apply uri query parameter on query
 *
 * @param queryParams  uri query params
 * @param query        Query
 * @param needPageList need page list
 * @param manager      a {@link InjectionManager} object.
 * @return page list count or null
 * @see #applyFetchProperties
 * @see #applyFilter
 * @see #applyOrderBy
 * @see #applyPageList
 */
@SuppressWarnings("unchecked")
public static FutureRowCount applyUriQuery(MultivaluedMap<String, String> queryParams,
                                           SpiQuery query,
                                           InjectionManager manager, boolean needPageList) {
    Set<String> inv = query.validate();
    applyFetchProperties(queryParams, query);
    applyFilter(queryParams, query, manager);
    applyOrderBy(queryParams, query);

    EbeanUtils.checkQuery(
            (SpiQuery<?>) query,
            inv,
            null,
            manager
    );
    if (needPageList)
        return applyPageList(queryParams, query);
    return null;
}
 

@Inject
public BackendServiceFactory(InjectionManager serviceLocator) {
	awsLambdaClient = new AWSLambdaClient();
	awsLambdaClient.configureRegion(BACKEND_SERVICE_REGION);
	backendService = Feign.builder()
			.client(FeignLambdaServiceInvokerClient.builder()
					.setRegion(BACKEND_SERVICE_REGION)
					.setFunctionName(BACKEND_SERVICE_FUNCTION_NAME)
					.build())
			.decoder(new JacksonDecoder())
			.encoder(new JacksonEncoder())
			.logger(new Slf4jLogger())
			.target(new LambdaServiceFunctionTarget<BackendService>(BackendService.class) {
				@Override
				public Request apply(RequestTemplate input) {
					// TODO inject the context directly => requires the context to be bound as proxy
					Context lambdaContext = serviceLocator.getInstance(Context.class);
					// propagate the AWS request ID => the called service can log the original AWS request ID
					input.header("X-Base-Aws-Request-Id", lambdaContext.getAwsRequestId());
					return super.apply(input);
				}
			});
}
 

@Override
public boolean configure(FeatureContext context) {
	InjectionManager injectionManager = InjectionManagerProvider.getInjectionManager(context);
	ServiceLocator locator;
	if (injectionManager instanceof ImmediateHk2InjectionManager) {
		locator = ((ImmediateHk2InjectionManager) injectionManager).getServiceLocator();
	} else if (injectionManager instanceof DelayedHk2InjectionManager) {
		locator = ((DelayedHk2InjectionManager) injectionManager).getServiceLocator();
	} else {
		throw new IllegalStateException("expected an hk2 injection manager");
	}
	GuiceBridge.getGuiceBridge().initializeGuiceBridge(locator);
	// register all your modules, here
	Injector injector = Guice.createInjector(new GreetingModule());
	GuiceIntoHK2Bridge guiceBridge = locator.getService(GuiceIntoHK2Bridge.class);
	guiceBridge.bridgeGuiceInjector(injector);
	return true;
}
 

@Override
@SuppressWarnings("unchecked")
public T get() {
    // HK2 by default proxy instances to delay actual instance creation, which could harm guice scopes logic
    // for example: if guice request scope transfer used ServletScopes.transferRequest and we try to obtain
    // it will try to use proxy instance in separate thread which will perform HK2 checks for request scope
    // and fail. Instead, we always resolve actual instance and let guice properly control scoping
    final T res = injector.get().getInstance(InjectionManager.class).getInstance(type);
    return res instanceof ProxyCtl ? (T) ((ProxyCtl) res).__make() : res;
}
 

@Override
public void onStartup(Container container) {
    InjectionManager injectionManager = container.getApplicationHandler().getInjectionManager();
    if (injectionManager instanceof ImmediateHk2InjectionManager) {
        app.serviceLocator = ((ImmediateHk2InjectionManager) injectionManager).getServiceLocator();
    } else if (injectionManager instanceof DelayedHk2InjectionManager) {
        app.serviceLocator = ((DelayedHk2InjectionManager) injectionManager).getServiceLocator();
    } else {
        throw new ApplicationException("unknown injection manager");
    }
    app.onStartup();
}
 

/**
 * <p>getStreamingProcess.</p>
 *
 * @param entity a T object.
 * @param manager manager
 * @param <T> a T object.
 * @return a {@link ameba.message.internal.StreamingProcess} object.
 */
@SuppressWarnings("unchecked")
public static <T> StreamingProcess<T> getStreamingProcess(T entity, InjectionManager manager) {
    for (StreamingProcess process : getStreamingProcesses(manager)) {
        if (process.isSupported(entity)) {
            return process;
        }
    }
    return null;
}
 

/**
 * <p>checkQuery.</p>
 *
 * @param query     a {@link io.ebean.Query} object.
 * @param whitelist a {@link java.util.Set} object.
 * @param blacklist a {@link java.util.Set} object.
 * @param manager   a {@link InjectionManager} object.
 */
public static void checkQuery(Query<?> query, Set<String> whitelist,
                              Set<String> blacklist, InjectionManager manager) {
    ResourceInfo resource = manager.getInstance(ResourceInfo.class);
    Class<?> rc = resource.getResourceClass();
    Set<String> wl = null, bl = null;
    if (rc != null) {
        Filter filter = rc.getAnnotation(Filter.class);

        if (filter != null) {
            if (filter.whitelist().length > 0) {
                wl = Sets.newLinkedHashSet();
                Collections.addAll(wl, filter.whitelist());
            }
            if (filter.blacklist().length > 0) {
                bl = Sets.newLinkedHashSet();
                Collections.addAll(bl, filter.blacklist());
            }
        }
    }

    if (whitelist != null) {
        if (wl == null) {
            wl = Sets.newLinkedHashSet();
        }
        wl.addAll(whitelist);
    }

    if (blacklist != null) {
        if (bl == null) {
            bl = Sets.newLinkedHashSet();
        }
        bl.addAll(blacklist);
    }
    checkQuery((SpiQuery) query, wl, bl, manager.getInstance(Application.Mode.class).isProd());
}
 

protected InjectionManager getInjectionManager() {
    try {
        return (InjectionManager) injectionManagerField.get(this);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}
 

@Test
public void delegateRequest_ValidRequestAndNoReferencesGiven_ShouldNotFailOnRequestInitialization() {
	JsonObject jsonRequest = new WebActionRequestBuilder()
			.setHttpMethod("GET")
			.setPath("/")
			.buildJson();

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(jsonRequest);

	InjectionManager injectionManager = mock(InjectionManager.class);
	requestScopedInitializer.initialize(injectionManager);
}
 

@Override
public void onShutdown(final Container container) {
    final ApplicationHandler handler = container.getApplicationHandler();
    final InjectionManager injectionManager = handler.getInjectionManager();

    // Call @PreDestroy method on Application.
    injectionManager.preDestroy(getWrappedApplication(handler.getConfiguration()));
    // Shutdown ServiceLocator.
    injectionManager.shutdown();
}
 

/**
 * Creates new instance.
 *
 * @param manager a {@link InjectionManager} object.
 */
@Inject
public OptionsMethodProcessor(InjectionManager manager) {
    methodList = Lists.newArrayList();

    methodList.add(new ModelProcessorUtil.Method(HttpMethod.OPTIONS, WILDCARD_TYPE, WILDCARD_TYPE,
            GenericOptionsInflector.class));

    generators = Providers.getAllRankedSortedProviders(manager, OptionsResponseGenerator.class);
}
 

@Test
public void delegateRequest_ValidRequestAndNoReferencesGiven_ShouldNotFailOnRequestInitialization() {

	Context context = mock(Context.class);
	SNS sns = new SNS();
	sns.setTopicArn(":t");
	SNSRecord snsRecord = new SNSRecord();
	snsRecord.setSns(sns);

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, snsRecord);

	InjectionManager injectionManager = mock(InjectionManager.class);
	requestScopedInitializer.initialize(injectionManager);
}
 

@Test
public void delegateRequest_ValidRequestAndNoReferencesGiven_ShouldNotFailOnRequestInitialization() {

	Context context = mock(Context.class);
	DefaultGatewayRequest request = new DefaultGatewayRequest();
	request.setPath("/");
	request.setHttpMethod("GET");

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, request);

	InjectionManager injectionManager = mock(InjectionManager.class);
	requestScopedInitializer.initialize(injectionManager);
}
 

@Test
public void delegateRequest_ValidRequestAndNoReferencesGiven_ShouldNotFailOnRequestInitialization() {
	Context context = mock(Context.class);
	DefaultServiceRequest request = new DefaultServiceRequest(null, new HashMap<>(), URI.create("/"), "GET");

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(context, request);

	InjectionManager injectionManager = mock(InjectionManager.class);
	requestScopedInitializer.initialize(injectionManager);
}
 

public void initialize(InjectionManager injectionManager) {
    if (injectionManager instanceof ImmediateHk2InjectionManager) {
        initialize(((ImmediateHk2InjectionManager) injectionManager).getServiceLocator());
    } else if (injectionManager instanceof DelayedHk2InjectionManager) {
        initialize(((DelayedHk2InjectionManager) injectionManager).getServiceLocator());
    } else {
        throw SeedException.createNew(Jersey2ErrorCode.UNSUPPORTED_JERSEY_DEPENDENCY_INJECTION);
    }
}
 

/**
 * <p>Constructor for DefaultServerEndpointConfig.</p>
 *
 * @param manager a manager
 * @param endpointClass  a {@link java.lang.Class} endpoint class.
 * @param webSocketConf  a {@link ameba.websocket.WebSocket} object.
 */
public DefaultServerEndpointConfig(final InjectionManager manager,
                                   Class endpointClass,
                                   final WebSocket webSocketConf) {
    path = webSocketConf.path();
    subprotocols = Arrays.asList(webSocketConf.subprotocols());
    encoders = Lists.newArrayList(webSocketConf.encoders());
    decoders = Lists.newArrayList(webSocketConf.decoders());
    for (Class<? extends Extension> extensionClass : webSocketConf.extensions()) {
        extensions.add(Injections.getOrCreate(manager, extensionClass));
    }
    final WebSocketEndpointProvider provider = manager.getInstance(WebSocketEndpointProvider.class);

    final EndpointMeta endpointMeta = provider.parseMeta(endpointClass, webSocketConf);

    final ServerEndpointConfig.Configurator cfgr =
            Injections.getOrCreate(manager, webSocketConf.configurator());
    serverEndpointConfigurator = new ServerEndpointConfig.Configurator() {

        @Override
        public String getNegotiatedSubprotocol(List<String> supported, List<String> requested) {
            return cfgr.getNegotiatedSubprotocol(supported, requested);
        }

        @Override
        public List<Extension> getNegotiatedExtensions(List<Extension> installed, List<Extension> requested) {
            return cfgr.getNegotiatedExtensions(installed, requested);
        }

        @Override
        public boolean checkOrigin(String originHeaderValue) {
            return cfgr.checkOrigin(originHeaderValue);
        }

        @Override
        public void modifyHandshake(ServerEndpointConfig sec,
                                    HandshakeRequest request, HandshakeResponse response) {
            cfgr.modifyHandshake(sec, request, response);
        }

        @Override
        public <T> T getEndpointInstance(Class<T> eClass) throws InstantiationException {
            if (EndpointDelegate.class.equals(eClass)) {
                return eClass.cast(new EndpointDelegate(endpointMeta));
            }
            return cfgr.getEndpointInstance(eClass);
        }
    };
}
 

public AbstractAnnotatedEndpointMeta(Class endpointClass, InjectionManager manager) {
    super(endpointClass);
    this.manager = manager;
}
 

public GuiceBridgeActivator(final InjectionManager injectionManager, final Injector injector) {
    this.injectionManager = injectionManager;
    this.injector = injector;
}
 

public JerseyConfigRenderer(final InjectionManager manager, final boolean guiceFirstMode) {
    this.manager = manager;
    this.guiceFirstMode = guiceFirstMode;
}
 

public InjectionManager getInjectionManager() {
    if (!initialized) {
        initialize();
    }
    return jerseyFilter.getApplicationHandler().getInjectionManager();
}
 

@Inject
public LambdaContextSetter(LambdaContextProvider lambdaContextProvider, InjectionManager injectionManager) {
	this.lambdaContextProvider = lambdaContextProvider;
	this.injectionManager = injectionManager;
}
 

@Test
public void delegateJsonRequest_ValidRequestAndReferencesGiven_ShouldSetReferencesOnRequestInitialization() {

	WebActionRequestBuilder requestBuilder = new WebActionRequestBuilder()
			.setHttpMethod("GET")
			.setPath("/");

	JsonObject jsonRequest = requestBuilder.buildJson();
	DefaultWebActionRequest request = requestBuilder.build();

	RequestScopedInitializer requestScopedInitializer = getSetRequestScopedInitializer(jsonRequest);

	@SuppressWarnings("unchecked")
	Ref<WebActionRequest> gatewayRequestRef = mock(Ref.class);

	InjectionManager injectionManager = mock(InjectionManager.class);
	when(injectionManager.getInstance(WEB_ACTION_REQUEST_TYPE)).thenReturn(gatewayRequestRef);

	requestScopedInitializer.initialize(injectionManager);

	verify(gatewayRequestRef).set(request);
}
 

public RemoteResolver(InjectionManager injectionManager, ClientMethodInvoker methodInvoker, Client client) {
    this.injectionManager = injectionManager;
    this.clientMethodInvoker = methodInvoker;
    this.client = client;
}
 

@Override
public InjectionManager get() {
    return Preconditions.checkNotNull(injectionManager, "Jersey InjectionManager is not yet available");
}
 

public void jerseyConfiguration(final InjectionManager injectionManager) {
    this.context.setInjectionManager(injectionManager);
    broadcast(new JerseyConfigurationEvent(context));
}