org.glassfish.hk2.api.Factory Java Examples

private <T> void givenInjections(ServiceBindingBuilder<T> bindingBuilder) {
    new MockUp<GuiceComponentProvider>() {
        @Mock
        DynamicConfiguration getConfiguration(final ServiceLocator locator) {
            return dynamicConfiguration;
        }

        @Mock
        ServiceBindingBuilder<T> newFactoryBinder(final Factory<T> factory) {
            return bindingBuilder;
        }

        @Mock
        void addBinding(final BindingBuilder<T> builder, final DynamicConfiguration configuration) {
        }
    };
}
 

private AbstractBinder proxyManagerToHkBinder(MitmProxyManager proxyManager) {
    Factory<MitmProxyManager> proxyManagerFactory = new Factory<MitmProxyManager>() {

        @Override
        public MitmProxyManager provide() {
            return proxyManager;
        }

        @Override
        public void dispose(MitmProxyManager instance) {}
    };

    return new AbstractBinder() {
        @Override
        protected void configure() {
            bindFactory(proxyManagerFactory).to(MitmProxyManager.class);
        }
    };
}
 

protected Factory<? extends P> createValueFactory(final Parameter parameter) {
    final HmacAuth auth = parameter.getAnnotation(HmacAuth.class);
    if (auth != null) {
        // TODO introduce type checking
        return getFactory();
    }
    return null;
}
 

@Override
protected Factory<?> createValueFactory(final Parameter parameter) {
	final Class<?> classType = parameter.getRawType();

	SecurityCheck securityCheck = parameter.getAnnotation(SecurityCheck.class);
	if (securityCheck == null)
		return null;

	if (classType.isAssignableFrom(User.class)) {
		return new SecurityCheckFactory(securityCheck.value(), securityCheck.apiKeyAllowed());
	} else {
		return null;
	}
}
 

@Override
protected Factory<?> createValueFactory(final Parameter parameter) {
	final Class<?> classType = parameter.getRawType();

	Context context = parameter.getAnnotation(Context.class);
	if (context == null)
		return null;

	if (classType.isAssignableFrom(SessionHelper.class)) {
		return new SessionHelperFactory();
	} else {
		return null;
	}
}
 

public <T> Factory<MessageQueue<T>> getQueueFactory(String queueName, Class<T> type) {
    return new Factory<MessageQueue<T>>() {
        @Override
        public MessageQueue<T> provide() {
            return getQueue(queueName, type);
        }

        @Override
        public void dispose(MessageQueue<T> instance) {}
    };
}
 

@Override
protected Factory<?> createValueFactory(Parameter parameter) {
    if (!parameter.isAnnotationPresent(Auth.class)) {
        return null;
    }

    return new AbstractContainerRequestValueFactory<Principal>() {
        public Principal provide() {
            return user;
        }
    };
}
 

@Override
protected Factory<?> createValueFactory(Parameter parameter) {
  Class<?> paramType = parameter.getRawType();
  Auth annotation = parameter.getAnnotation(Auth.class);
  if (annotation != null && paramType.isAssignableFrom(SingularityUser.class)) {
    return authFactory;
  }
  return null;
}
 

@Override
public Factory<?> getValueFactory(Parameter parameter) {
    if (type.equals(parameter.getRawType()) && parameter.isAnnotationPresent(Auth.class)) {
        return this;
    }
    return null;
}
 

protected void configure() {
    bind(PrincipalFactory.class)
            .to(PrincipalFactory.class)
            .to(new TypeLiteral<Factory<P>>() {})
            .in(Singleton.class);
    bind(PrincipalValueFactoryProvider.class)
            .to(AbstractValueFactoryProvider.class)
            .to(ValueFactoryProvider.class)
            .in(Singleton.class);
    bind(PrincipalInjectionResolver.class)
            .to(new TypeLiteral<ParamInjectionResolver<HmacAuth>>() {})
            .to(new TypeLiteral<InjectionResolver<HmacAuth>>() {})
            .in(Singleton.class);
}
 

@Override
public Factory<?> getValueFactory(Parameter parameter) {
    if (type.equals(parameter.getRawType()) && parameter.isAnnotationPresent(Auth.class)) {
        return this;
    }
    return null;
}
 

@Override
protected Factory<?> createValueFactory(Parameter parameter) {
    Class<?> paramType = parameter.getRawType();
    RobeAuth annotation = parameter.getAnnotation(RobeAuth.class);
    if (annotation != null && paramType.isAssignableFrom(BasicToken.class)) {
        return new TokenFactory<>(annotation.required());
    }
    return null;
}
 

@Override
protected Factory<?> createValueFactory(Parameter parameter) {
    Class<?> paramType = parameter.getRawType();
    SearchParam annotation = parameter.getAnnotation(SearchParam.class);
    if (annotation != null && paramType.isAssignableFrom(SearchModel.class)) {
        return new SearchFactory();
    }
    return null;
}
 

@Override protected Factory<?> createValueFactory(final Parameter parameter) {
  final Class<?> classType = parameter.getRawType();
  final Auth auth = parameter.getAnnotation(Auth.class);

  if (auth == null) {
    return null;
  }

  if (classType.equals(Client.class)) {
    return new AbstractContainerRequestValueFactory<Client>() {
      @Override public Client provide() {
        return clientAuthFactory.provide(getContainerRequest());
      }
    };
  }

  if (classType.equals(AutomationClient.class)) {
    return new AbstractContainerRequestValueFactory<AutomationClient>() {
      @Override public AutomationClient provide() {
        return automationClientAuthFactory.provide(getContainerRequest());
      }
    };
  }

  if (classType.equals(User.class)) {
    return new AbstractContainerRequestValueFactory<User>() {
      @Override public User provide() {
        return userAuthFactory.provide(getContainerRequest());
      }
    };
  }

  return null;
}
 

@Override
protected Factory<?> createValueFactory(Parameter parameter) {
    if (parameter.isAnnotationPresent(Pac4JProfileManager.class)) {
        if (ProfileManager.class.isAssignableFrom(parameter.getRawType())) {
            return manager.get();
        }

        throw new IllegalStateException("Cannot inject a Pac4J profile manager into a parameter of type "
                + parameter.getRawType().getName());
    }

    if (parameter.isAnnotationPresent(Pac4JProfile.class)) {
        if (CommonProfile.class.isAssignableFrom(parameter.getRawType())) {
            return profile.get();
        }

        if (Optional.class.isAssignableFrom(parameter.getRawType())) {
            List<ClassTypePair> ctps = ReflectionHelper.getTypeArgumentAndClass(parameter.getRawType());
            ClassTypePair ctp = (ctps.size() == 1) ? ctps.get(0) : null;
            if (ctp == null || CommonProfile.class.isAssignableFrom(ctp.rawClass())) {
                return optProfile.get();
            }
        }

        throw new IllegalStateException(
                "Cannot inject a Pac4J profile into a parameter of type " + parameter.getRawType().getName());
    }

    return null;
}
 

@Override
protected Factory<?> createValueFactory(final Parameter parameter) {
    final RateLimiting annotation = parameter.getAnnotation(RateLimiting.class);
    if (null == annotation) {
        return null;
    } else {
        return new AbstractContainerRequestValueFactory<RequestRateLimiterFactory>() {
            @Override
            public RequestRateLimiterFactory provide() {
                return requestRateLimiterFactory;
            }
        };
    }
}
 

@Override
protected Factory<RequestRateLimiterFactory> createValueFactory(final Parameter parameter) {
    final RateLimiting annotation = parameter.getAnnotation(RateLimiting.class);
    if (null == annotation) {
        return null;
    } else {
        return new AbstractContainerRequestValueFactory<RequestRateLimiterFactory>() {
            @Override
            public RequestRateLimiterFactory provide() {
                return requestRateLimiterFactory;
            }
        };
    }
}
 

public ResourceConfig makeResourceConfig() {
  ClusterConfig clusterConfig = HttpClusterConfig.from(new HttpReplica(uris[serverIndex]),
    remotes());

  if (!logDir.exists() && !logDir.mkdirs())
    logger.warn("failed to create directories for storing logs, bad things will happen");

  StateMachine stateMachine = new StateMachine() {
    int i = 0;

    @Override
    public Object applyOperation(@Nonnull ByteBuffer entry) {
      return i++;
    }
  };

  final JaxRsRaftModule raftModule = new JaxRsRaftModule(clusterConfig, logDir, stateMachine, 1500, transitionListeners, protocolListeners);

  injector = Optional.of(Guice.createInjector(raftModule));

  ResourceConfig resourceConfig = new ResourceConfig();

  Binder binder = new AbstractBinder() {
    @Override
    protected void configure() {
      bindFactory(new Factory<Raft>() {
            @Override
            public Raft provide() {
              return injector.get().getInstance(Raft.class);
            }

            @Override
            public void dispose(Raft raft) {
            }
          }).to(Raft.class);
      
      bindFactory(new Factory<ClusterConfig>() {
        @Override public ClusterConfig provide() {
          return injector.get().getInstance(ClusterConfig.class);
        }

        @Override public void dispose(ClusterConfig instance) {
        }
      }).to(ClusterConfig.class);
    }
  };

  resourceConfig.register(BargeResource.class);
  resourceConfig.register(Jackson.customJacksonProvider());
  resourceConfig.register(binder);

  return resourceConfig;
}
 

/**
 * Get a new factory instance-based service binding builder.
 *
 * @param <T>     service type.
 * @param factory service instance.
 * @return initialized binding builder.
 */
private static <T> ServiceBindingBuilder<T> newFactoryBinder(final Factory<T> factory) {
    return BindingBuilderFactory.newFactoryBinder(factory);
}