Java Code Examples for io.dropwizard.setup.Environment#getObjectMapper()

@Override
public void run(DropwizardConfiguration dropwizardConfiguration, Environment environment) throws Exception {
    environment.lifecycle().manage(guiceBundle.getInjector().getInstance(MongoManaged.class));


    environment.jersey().property(KatharsisProperties.RESOURCE_SEARCH_PACKAGE, "io.katharsis.example.dropwizard.domain");
    environment.jersey().property(KatharsisProperties.RESOURCE_DEFAULT_DOMAIN, "http://localhost:8080");

    KatharsisFeature katharsisFeature = new KatharsisFeature(environment.getObjectMapper(),
            new QueryParamsBuilder(new DefaultQueryParamsParser()),
            new JsonServiceLocator() {
                @Override
                public <T> T getInstance(Class<T> aClass) {
                    return guiceBundle.getInjector().getInstance(aClass);
                }
            });
    environment.jersey().register(katharsisFeature);
}
 

private static void setupInstanceDiscovery(BreakerboxServiceConfiguration configuration,
                                           Environment environment) {
    final Optional<InstanceDiscovery> customInstanceDiscovery = createInstanceDiscovery(configuration, environment);
    if (customInstanceDiscovery.isPresent()) {
        if(configuration.getHystrixStreamSuffix().isPresent()){
            PluginsFactory.setInstanceDiscovery(RegisterClustersInstanceDiscoveryWrapper.wrap(
                    customInstanceDiscovery.get(),configuration.getHystrixStreamSuffix().get()));
        } else {
            PluginsFactory.setInstanceDiscovery(RegisterClustersInstanceDiscoveryWrapper.wrap(
                    customInstanceDiscovery.get()));
        }
    } else {
        final YamlInstanceDiscovery yamlInstanceDiscovery = new YamlInstanceDiscovery(
                configuration.getTurbine(), environment.getValidator(), environment.getObjectMapper());
        PluginsFactory.setInstanceDiscovery(RegisterClustersInstanceDiscoveryWrapper.wrap(yamlInstanceDiscovery));
    }
}
 

public StreamBroadcaster build(Environment environment) {
    StreamBroadcaster broadcaster =
            new KafkaTopicBroadcaster(environment.getName(),
                    environment.getObjectMapper(),
                    bootstrap);

    environment.lifecycle().manage(broadcaster);

    return broadcaster;
}
 

private static void configureObjectMapper(Environment environment) {
    ObjectMapper mapper = environment.getObjectMapper();
    mapper.findAndRegisterModules();

    SimpleModule module = new SimpleModule();
    module.addSerializer(ID.class, new IDSerializer());
    mapper.registerModule(module);
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
}
 

public CommandListener build(Environment environment,
                             EventPublisher applicationEventPublisher, Class aggregateRoot) {
    KafkaCommandListener listener =
            new KafkaCommandListener(boostrap,
                    environment.getName(),
                    environment.getObjectMapper(),
                    applicationEventPublisher,
                    aggregateRoot.getSimpleName());

    environment.lifecycle().manage(listener);

    return listener;
}
 

private EventStore buildJdbcEventStore(EventPublisher publisher, Environment environment) {
    ManagedDataSource ds = database.build(environment.metrics(), "eventstore");
    DBI jdbi = new DBIFactory().build(environment, database, "eventstore");
    updateDatabaseSchema(ds);
    EventStore eventStore = new JdbcEventStore(jdbi, environment.getObjectMapper(), publisher);
    return eventStore;
}
 

private static void configureObjectMapper(Environment environment) {
    ObjectMapper mapper = environment.getObjectMapper();
    mapper.findAndRegisterModules();

    SimpleModule module = new SimpleModule();
    module.addSerializer(ID.class, new IDSerializer());
    mapper.registerModule(module);
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
}
 

@Inject
public MetadataResource(Environment environment, IdentitiesMetadata metadata, Mappers mapper) {
    this.metadata = metadata;
    this.identityTypesByName = Maps.transformValues(metadata, DTO_TYPES_MAPPER);
    this.schemaGenerator = new JsonSchemaGenerator(environment.getObjectMapper());
    this.mapper = mapper;
}
 

@Override
public void run(ProductCatalogConfig configuration, Environment environment) {
  ObjectMapper objectMapper = environment.getObjectMapper();
  objectMapper.enable(INDENT_OUTPUT);
  objectMapper.enable(WRITE_DATES_AS_TIMESTAMPS);

  environment.jersey().register(new ProductResource(new InMemoryProductRepository()));
  configureCors(environment);
  logger.info("ProductCatalogApplication started!");
}
 

@Override
public void run(OrderApplicationConfiguration configuration, Environment environment) throws Exception {
  ObjectMapper objectMapper = environment.getObjectMapper();
  objectMapper.enable(INDENT_OUTPUT);
  objectMapper.enable(WRITE_DATES_AS_TIMESTAMPS);

  OrderProjectionRepository orderRepository = new InMemOrderProjectionRepository();
  DomainEventBus domainEventBus = new GuavaDomainEventBus();
  OrderListDenormalizer orderListDenormalizer = domainEventBus.register(new OrderListDenormalizer(orderRepository));
  OrdersPerDayAggregator ordersPerDayAggregator = domainEventBus.register(new OrdersPerDayAggregator());

  ProductCatalogClient catalogClient = ProductCatalogClient.create(ClientBuilder.newClient(), configuration.productCatalogServiceUrl);

  DomainEventStore domainEventStore = (DomainEventStore) configuration.eventStore.newInstance();
  QueryService queryService = new QueryService(orderListDenormalizer, ordersPerDayAggregator, catalogClient);

  logger.info("Using eventStore: " + domainEventStore.getClass().getName());
  Repository aggregateRepository = new DefaultRepository(domainEventBus, domainEventStore);

  CommandBus commandBus = GuavaCommandBus.asyncGuavaCommandBus();
  commandBus.register(new OrderCommandHandler(aggregateRepository));
  commandBus.register(new PublisherContractCommandHandler(aggregateRepository));

  // Create and register Sagas
  PurchaseRegistrationSaga purchaseRegistrationSaga = new PurchaseRegistrationSaga(queryService, commandBus);
  domainEventBus.register(purchaseRegistrationSaga);

  environment.jersey().register(new QueryResource(queryService, domainEventStore));
  environment.jersey().register(new OrderResource(commandBus));
  environment.jersey().register(new PublisherContractResource(commandBus));
  environment.jersey().setUrlPattern("/service/*");

  environment.admin().addTask(new ReplayEventsTask(domainEventStore, domainEventBus));
  configureCors(environment);
  logger.info("OrderApplication started!");
}
 

private static InstanceDiscovery createClassInstance(Class<InstanceDiscovery> instanceDiscoveryClass,
                                                BreakerboxServiceConfiguration configuration,
                                                Environment environment) throws Exception {
    if(instanceDiscoveryClass.equals(RancherInstanceDiscovery.class)
          && configuration.getRancherInstanceConfiguration().isPresent()) {
        return new RancherInstanceDiscovery(configuration.getRancherInstanceConfiguration().get(), environment.getObjectMapper());
    } else if (instanceDiscoveryClass.equals(YamlInstanceDiscovery.class)) {
        return new YamlInstanceDiscovery(configuration.getTurbine(), environment.getValidator(), environment.getObjectMapper());
    }
    else if (instanceDiscoveryClass.equals(MarathonInstanceDiscovery.class) && configuration.getMarathonClientConfiguration().isPresent()){
        return new MarathonInstanceDiscovery(environment.getObjectMapper(),configuration.getMarathonClientConfiguration().get());
    }
    return instanceDiscoveryClass.getConstructor().newInstance();
}
 

@Override
public void run(ServerConfiguration configuration, Environment environment) throws Exception {

    final DBIFactory factory = new DBIFactory();
    final DBI jdbi = factory.build(environment, configuration.getDataSourceFactory(), "sapData");

    ObjectMapper objectMapper = environment.getObjectMapper();
    SapConfiguration sapConfiguration = configuration.getSapConfig();
    JobConfiguration jobConfiguration = configuration.getJobConfig();
    NiPingServiceBinder niPingServiceBinder = new NiPingServiceBinder(jdbi, objectMapper, sapConfiguration, jobConfiguration);

    ServiceLocator serviceLocator = ServiceLocatorUtilities.bind(niPingServiceBinder);
    SapBasicAuthenticator sapBasicAuthenticator = ServiceLocatorUtilities.getService(serviceLocator, SapBasicAuthenticator.class
            .getName());
    SapOAuthenticator sapOAuthenticator = ServiceLocatorUtilities.getService(serviceLocator, SapOAuthenticator.class.getName());

    final BasicCredentialAuthFilter basicAuthFilter = new BasicCredentialAuthFilter.Builder<BasicAuthUser>()
            .setAuthenticator(sapBasicAuthenticator)
            .buildAuthFilter();
    final AuthFilter oAuthFilter = new OAuthCredentialAuthFilter.Builder<OAuthUser>()
            .setAuthenticator(sapOAuthenticator)
            .setPrefix("Bearer")
            .buildAuthFilter();

    final PolymorphicAuthDynamicFeature feature = new PolymorphicAuthDynamicFeature<UserPrincipal>(ImmutableMap.of(BasicAuthUser
            .class, basicAuthFilter, OAuthUser.class, oAuthFilter));
    final AbstractBinder binder = new PolymorphicAuthValueFactoryProvider.Binder<>(ImmutableSet.of(BasicAuthUser.class, OAuthUser
            .class));
    environment.jersey().register(new AuthFilterDynamicBinding());
    environment.jersey().register(feature);
    environment.jersey().register(binder);

    environment.jersey().register(niPingServiceBinder);
    environment.jersey().packages("com.cloudwise.sap.niping.auth");
    environment.jersey().packages("com.cloudwise.sap.niping.service");
    environment.jersey().packages("com.cloudwise.sap.niping.dao");
    environment.jersey().packages("com.cloudwise.sap.niping.common.vo.converter");
    environment.jersey().packages("com.cloudwise.sap.niping.resource");

    environment.jersey().register(SessionFactoryProvider.class);
    environment.servlets().setSessionHandler(new SessionHandler());
}
 

public CommandDispatcher build(Environment environment) {
    return new KafkaCommandDispatcher(boostrap, environment.getObjectMapper());
}
 

public EventPublisher build(Environment environment) {
    return new KafkaEventPublisher(bootstrap, environment.getObjectMapper());
}
 

@Provides ObjectMapper configuredObjectMapper(Environment environment) {
  return environment.getObjectMapper();
}
 

@Provides
@Singleton
public ObjectMapper objectMapper(Environment environment) {
    return environment.getObjectMapper();
}