Example usage for com.fasterxml.jackson.databind.module SimpleModule SimpleModule

List of usage examples for com.fasterxml.jackson.databind.module SimpleModule SimpleModule

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.module SimpleModule SimpleModule.

Prototype

public SimpleModule(Version version) 

Source Link

Document

Convenience constructor that will use specified Version, including name from Version#getArtifactId()

Usage

From source file:org.wisdom.content.json.JsonSingletonTest.java

@Test
public void testModules() {
    final SimpleModule module = new SimpleModule("test");
    json.bindModule(module);/*from   ww  w .ja  v a  2s.  com*/
    json.unbindModule(module);
}

From source file:io.seldon.api.state.PredictionAlgorithmStore.java

@Override
public void configUpdated(String client, String configKey, String configValue) {
    SimpleModule module = new SimpleModule("PredictionStrategyDeserializerModule");
    module.addDeserializer(Strategy.class, new PredictionStrategyDeserializer());
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(module);/*from  w w  w .j  av a2 s  .  co  m*/
    if (configKey.equals(ALG_KEY)) {
        logger.info("Received new algorithm config for " + client + ": " + configValue);
        try {
            Strategy configStrategy = mapper.readValue(configValue, Strategy.class);
            if (configStrategy instanceof AlgorithmConfig) {
                List<PredictionAlgorithmStrategy> strategies = new ArrayList<>();
                AlgorithmConfig config = (AlgorithmConfig) configStrategy;
                for (Algorithm algorithm : config.algorithms) {
                    PredictionAlgorithmStrategy strategy = toAlgorithmStrategy(algorithm);
                    strategies.add(strategy);
                }
                List<FeatureTransformerStrategy> featureTransformerStrategies = new ArrayList<>();
                if (config.transformers != null)
                    for (Transformer transformer : config.transformers) {
                        FeatureTransformerStrategy strategy = toFeatureTransformerStrategy(transformer);
                        featureTransformerStrategies.add(strategy);
                    }
                predictionStore.put(client,
                        new SimplePredictionStrategy(PredictionStrategy.DEFAULT_NAME,
                                Collections.unmodifiableList(featureTransformerStrategies),
                                Collections.unmodifiableList(strategies)));
                logger.info("Successfully added new algorithm config for " + client);
            } else if (configStrategy instanceof TestConfig) {
                TestConfig config = (TestConfig) configStrategy;
                //TestConfig config = mapper.readValue(configValue, TestConfig.class);

                List<VariationPredictionStrategy.Variation> variations = new ArrayList<>();
                for (TestVariation var : config.variations) {
                    List<PredictionAlgorithmStrategy> strategies = new ArrayList<>();
                    for (Algorithm alg : var.config.algorithms) {
                        PredictionAlgorithmStrategy strategy = toAlgorithmStrategy(alg);
                        strategies.add(strategy);
                    }
                    List<FeatureTransformerStrategy> featureTransformerStrategies = new ArrayList<>();
                    if (var.config.transformers != null)
                        for (Transformer transformer : var.config.transformers) {
                            FeatureTransformerStrategy strategy = toFeatureTransformerStrategy(transformer);
                            featureTransformerStrategies.add(strategy);
                        }
                    //Need to add combiner here 
                    variations
                            .add(new VariationPredictionStrategy.Variation(
                                    new SimplePredictionStrategy(var.label,
                                            Collections.unmodifiableList(featureTransformerStrategies),
                                            Collections.unmodifiableList(strategies)),
                                    new BigDecimal(var.ratio)));

                }
                predictionStore.put(client, VariationPredictionStrategy.build(variations));
                logger.info("Succesfully added " + variations.size() + " variation test for " + client);
            } else {
                logger.error("Unknown type for algorithm config");
            }
        } catch (IOException | BeansException e) {
            logger.error("Couldn't update algorithms for client " + client, e);
        }
    }

}

From source file:org.jberet.support.io.MappingJsonFactoryObjectFactory.java

static void configureCustomSerializersAndDeserializers(final ObjectMapper objectMapper,
        final String customSerializers, final String customDeserializers, final String customDataTypeModules,
        final ClassLoader classLoader) throws Exception {
    if (customDeserializers != null || customSerializers != null) {
        final SimpleModule simpleModule = new SimpleModule("custom-serializer-deserializer-module");
        if (customSerializers != null) {
            final StringTokenizer st = new StringTokenizer(customSerializers, ", ");
            while (st.hasMoreTokens()) {
                final Class<?> aClass = classLoader.loadClass(st.nextToken());
                simpleModule.addSerializer(aClass, (JsonSerializer) aClass.newInstance());
            }/*from w w w .  j a  va 2s .c  om*/
        }
        if (customDeserializers != null) {
            final StringTokenizer st = new StringTokenizer(customDeserializers, ", ");
            while (st.hasMoreTokens()) {
                final Class<?> aClass = classLoader.loadClass(st.nextToken());
                simpleModule.addDeserializer(aClass, (JsonDeserializer) aClass.newInstance());
            }
        }
        objectMapper.registerModule(simpleModule);
    }
    if (customDataTypeModules != null) {
        final StringTokenizer st = new StringTokenizer(customDataTypeModules, ", ");
        while (st.hasMoreTokens()) {
            final Class<?> aClass = classLoader.loadClass(st.nextToken());
            objectMapper.registerModule((Module) aClass.newInstance());
        }
    }
}

From source file:monasca.api.MonApiApplication.java

@Override
@SuppressWarnings("unchecked")
public void run(ApiConfig config, Environment environment) throws Exception {
    /** Wire services */
    Injector.registerModules(new MonApiModule(environment, config));

    /** Configure resources */
    environment.jersey().register(Injector.getInstance(VersionResource.class));
    environment.jersey().register(Injector.getInstance(AlarmDefinitionResource.class));
    environment.jersey().register(Injector.getInstance(AlarmResource.class));
    environment.jersey().register(Injector.getInstance(DimensionResource.class));
    environment.jersey().register(Injector.getInstance(MetricResource.class));
    environment.jersey().register(Injector.getInstance(MeasurementResource.class));
    environment.jersey().register(Injector.getInstance(StatisticResource.class));
    environment.jersey().register(Injector.getInstance(NotificationMethodResource.class));
    environment.jersey().register(Injector.getInstance(NotificationMethodTypesResource.class));

    /** Configure providers */
    removeExceptionMappers(environment.jersey().getResourceConfig().getSingletons());
    environment.jersey().register(new EntityExistsExceptionMapper());
    environment.jersey().register(new EntityNotFoundExceptionMapper());
    environment.jersey().register(new IllegalArgumentExceptionMapper());
    environment.jersey().register(new InvalidEntityExceptionMapper());
    environment.jersey().register(new JsonProcessingExceptionMapper());
    environment.jersey().register(new JsonMappingExceptionManager());
    environment.jersey().register(new ConstraintViolationExceptionMapper());
    environment.jersey().register(new ThrowableExceptionMapper<Throwable>() {
    });//from  ww w  .ja v  a  2  s.  c o  m
    environment.jersey().register(new MultipleMetricsExceptionMapper());

    /** Configure Jackson */
    environment.getObjectMapper()
            .setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
    environment.getObjectMapper().enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
    environment.getObjectMapper().disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    environment.getObjectMapper().disable(DeserializationFeature.WRAP_EXCEPTIONS);
    SimpleModule module = new SimpleModule("SerializationModule");
    module.addSerializer(new SubAlarmExpressionSerializer());
    environment.getObjectMapper().registerModule(module);

    /** Configure CORS filter */
    Dynamic corsFilter = environment.servlets().addFilter("cors", CrossOriginFilter.class);
    corsFilter.addMappingForUrlPatterns(null, true, "/*");
    corsFilter.setInitParameter("allowedOrigins", "*");
    corsFilter.setInitParameter("allowedHeaders", "X-Requested-With,Content-Type,Accept,Origin,X-Auth-Token");
    corsFilter.setInitParameter("allowedMethods", "OPTIONS,GET,HEAD");

    if (config.middleware.enabled) {
        ensureHasValue(config.middleware.serverVIP, "serverVIP", "enabled", "true");
        ensureHasValue(config.middleware.serverPort, "serverPort", "enabled", "true");
        ensureHasValue(config.middleware.adminAuthMethod, "adminAuthMethod", "enabled", "true");
        if ("password".equalsIgnoreCase(config.middleware.adminAuthMethod)) {
            ensureHasValue(config.middleware.adminUser, "adminUser", "adminAuthMethod", "password");
            ensureHasValue(config.middleware.adminPassword, "adminPassword", "adminAuthMethod", "password");
        } else if ("token".equalsIgnoreCase(config.middleware.adminAuthMethod)) {
            ensureHasValue(config.middleware.adminToken, "adminToken", "adminAuthMethod", "token");
        } else {
            throw new Exception(
                    String.format("Invalid value '%s' for adminAuthMethod. Must be either password or token",
                            config.middleware.adminAuthMethod));
        }
        if (config.middleware.defaultAuthorizedRoles == null
                || config.middleware.defaultAuthorizedRoles.isEmpty()) {
            ensureHasValue(null, "defaultAuthorizedRoles", "enabled", "true");
        }
        if (config.middleware.connSSLClientAuth) {
            ensureHasValue(config.middleware.keystore, "keystore", "connSSLClientAuth", "true");
            ensureHasValue(config.middleware.keystorePassword, "keystorePassword", "connSSLClientAuth", "true");
        }
        Map<String, String> authInitParams = new HashMap<String, String>();
        authInitParams.put("ServerVIP", config.middleware.serverVIP);
        authInitParams.put("ServerPort", config.middleware.serverPort);
        authInitParams.put(AuthConstants.USE_HTTPS, String.valueOf(config.middleware.useHttps));
        authInitParams.put("ConnTimeout", config.middleware.connTimeout);
        authInitParams.put("ConnSSLClientAuth", String.valueOf(config.middleware.connSSLClientAuth));
        authInitParams.put("ConnPoolMaxActive", config.middleware.connPoolMaxActive);
        authInitParams.put("ConnPoolMaxIdle", config.middleware.connPoolMaxActive);
        authInitParams.put("ConnPoolEvictPeriod", config.middleware.connPoolEvictPeriod);
        authInitParams.put("ConnPoolMinIdleTime", config.middleware.connPoolMinIdleTime);
        authInitParams.put("ConnRetryTimes", config.middleware.connRetryTimes);
        authInitParams.put("ConnRetryInterval", config.middleware.connRetryInterval);
        authInitParams.put("AdminToken", config.middleware.adminToken);
        authInitParams.put("TimeToCacheToken", config.middleware.timeToCacheToken);
        authInitParams.put("AdminAuthMethod", config.middleware.adminAuthMethod);
        authInitParams.put("AdminUser", config.middleware.adminUser);
        authInitParams.put("AdminPassword", config.middleware.adminPassword);
        authInitParams.put(AuthConstants.ADMIN_PROJECT_ID, config.middleware.adminProjectId);
        authInitParams.put(AuthConstants.ADMIN_PROJECT_NAME, config.middleware.adminProjectName);
        authInitParams.put(AuthConstants.ADMIN_USER_DOMAIN_ID, config.middleware.adminUserDomainId);
        authInitParams.put(AuthConstants.ADMIN_USER_DOMAIN_NAME, config.middleware.adminUserDomainName);
        authInitParams.put(AuthConstants.ADMIN_PROJECT_DOMAIN_ID, config.middleware.adminProjectDomainId);
        authInitParams.put(AuthConstants.ADMIN_PROJECT_DOMAIN_NAME, config.middleware.adminProjectDomainName);
        authInitParams.put("MaxTokenCacheSize", config.middleware.maxTokenCacheSize);
        setIfNotNull(authInitParams, AuthConstants.TRUSTSTORE, config.middleware.truststore);
        setIfNotNull(authInitParams, AuthConstants.TRUSTSTORE_PASS, config.middleware.truststorePassword);
        setIfNotNull(authInitParams, AuthConstants.KEYSTORE, config.middleware.keystore);
        setIfNotNull(authInitParams, AuthConstants.KEYSTORE_PASS, config.middleware.keystorePassword);

        /** Configure auth filters */
        Dynamic preAuthenticationFilter = environment.servlets().addFilter("pre-auth",
                new PreAuthenticationFilter());
        preAuthenticationFilter.addMappingForUrlPatterns(null, true, "/");
        preAuthenticationFilter.addMappingForUrlPatterns(null, true, "/v2.0/*");

        Dynamic tokenAuthFilter = environment.servlets().addFilter("token-auth", new TokenAuth());
        tokenAuthFilter.addMappingForUrlPatterns(null, true, "/");
        tokenAuthFilter.addMappingForUrlPatterns(null, true, "/v2.0/*");
        tokenAuthFilter.setInitParameters(authInitParams);

        Dynamic postAuthenticationFilter = environment.servlets().addFilter("post-auth",
                new PostAuthenticationFilter(config.middleware.defaultAuthorizedRoles,
                        config.middleware.agentAuthorizedRoles, config.middleware.readOnlyAuthorizedRoles));
        postAuthenticationFilter.addMappingForUrlPatterns(null, true, "/");
        postAuthenticationFilter.addMappingForUrlPatterns(null, true, "/v2.0/*");

        environment.jersey().getResourceConfig().getContainerRequestFilters()
                .add(new RoleAuthorizationFilter());
    } else {
        Dynamic mockAuthenticationFilter = environment.servlets().addFilter("mock-auth",
                new MockAuthenticationFilter());
        mockAuthenticationFilter.addMappingForUrlPatterns(null, true, "/");
        mockAuthenticationFilter.addMappingForUrlPatterns(null, true, "/v2.0/*");
    }
}

From source file:org.opencommercesearch.client.ProductApi.java

private void initMapper() {
    mapper = new ObjectMapper().setDateFormat(new ISO8601DateFormat())
            .setSerializationInclusion(JsonInclude.Include.NON_NULL);
    SimpleModule module = new SimpleModule("InterfaceMapper");
    module.addAbstractTypeMapping(Product.class, DefaultProduct.class);
    mapper.registerModule(module);/*from  w  w  w  .  j a  v a  2  s  .  co  m*/
}

From source file:io.seldon.api.state.ClientAlgorithmStore.java

@Override
public void configUpdated(String client, String configKey, String configValue) {
    SimpleModule module = new SimpleModule("StrategyDeserializerModule");
    module.addDeserializer(Strategy.class, new StrategyDeserializer());
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(module);/*from  w w  w.  java 2 s  .  c o  m*/
    if (configKey.equals(ALG_KEY)) {
        logger.info("Received new algorithm config for " + client + ": " + configValue);
        try {
            List<AlgorithmStrategy> strategies = new ArrayList<>();
            Map<String, AlgorithmStrategy> stratMap = new HashMap<>();
            AlgorithmConfig config = mapper.readValue(configValue, AlgorithmConfig.class);
            for (Algorithm algorithm : config.algorithms) {
                AlgorithmStrategy strategy = toAlgorithmStrategy(algorithm);
                strategies.add(strategy);
            }
            AlgorithmResultsCombiner combiner = applicationContext.getBean(config.combiner,
                    AlgorithmResultsCombiner.class);
            Map<Integer, Double> actionWeightMap = toActionWeightMap(config.actionWeights);
            store.put(client, new SimpleClientStrategy(Collections.unmodifiableList(strategies), combiner,
                    config.diversityLevel, ClientStrategy.DEFAULT_NAME, actionWeightMap));
            storeMap.put(client, Collections.unmodifiableMap(stratMap));
            logger.info("Successfully added new algorithm config for " + client);
        } catch (IOException | BeansException e) {
            logger.error("Couldn't update algorithms for client " + client, e);
        }
    } else if (configKey.equals(TESTING_SWITCH_KEY)) {
        // not json as its so simple
        Boolean onOff = BooleanUtils.toBooleanObject(configValue);
        if (onOff == null) {
            logger.error("Couldn't set testing switch for client " + client + ", input was " + configValue);
        } else {
            logger.info("Testing switch for client " + client + " moving from '"
                    + BooleanUtils.toStringOnOff(testingOnOff.get(client)) + "' to '"
                    + BooleanUtils.toStringOnOff(onOff) + "'");
            testingOnOff.put(client, BooleanUtils.toBooleanObject(configValue));
        }
    } else if (configKey.equals(TEST)) {
        logger.info("Received new testing config for " + client + ":" + configValue);
        try {
            TestConfig config = mapper.readValue(configValue, TestConfig.class);
            List<VariationTestingClientStrategy.Variation> variations = new ArrayList<>();
            for (TestVariation var : config.variations) {
                List<AlgorithmStrategy> strategies = new ArrayList<>();
                for (Algorithm alg : var.config.algorithms) {
                    AlgorithmStrategy strategy = toAlgorithmStrategy(alg);
                    strategies.add(strategy);
                }
                AlgorithmResultsCombiner combiner = applicationContext.getBean(var.config.combiner,
                        AlgorithmResultsCombiner.class);
                Map<Integer, Double> actionWeightMap = toActionWeightMap(var.config.actionWeights);
                variations.add(new VariationTestingClientStrategy.Variation(
                        new SimpleClientStrategy(Collections.unmodifiableList(strategies), combiner,
                                var.config.diversityLevel, var.label, actionWeightMap),
                        new BigDecimal(var.ratio)));

            }
            tests.put(client, VariationTestingClientStrategy.build(variations));
            logger.info("Succesfully added " + variations.size() + " variation test for " + client);
        } catch (NumberFormatException | IOException e) {
            logger.error("Couldn't add test for client " + client, e);
        }
    } else if (configKey.equals(RECTAG)) {
        logger.info("Received new rectag config for " + client + ": " + configValue);
        try {
            RecTagConfig config = mapper.readValue(configValue, RecTagConfig.class);
            if (config.defaultStrategy == null) {
                logger.error("Couldn't read rectag config as there was no default alg");
                return;
            }

            ClientStrategy defStrategy = toStrategy(config.defaultStrategy);
            Map<String, ClientStrategy> recTagStrats = new HashMap<>();
            for (Map.Entry<String, Strategy> entry : config.recTagToStrategy.entrySet()) {
                recTagStrats.put(entry.getKey(), toStrategy(entry.getValue()));
            }
            recTagStrategies.put(client, new RecTagClientStrategy(defStrategy, recTagStrats));
            logger.info("Successfully added rec tag strategy for " + client);
        } catch (NumberFormatException | IOException e) {
            logger.error("Couldn't add rectag strategy for client " + client, e);
        }

    }
}

From source file:capital.scalable.restdocs.jackson.FieldDocumentationGeneratorTest.java

@Test
public void testGenerateDocumentationForExternalSerializer() throws Exception {
    // given//from  ww w.  j  a va  2s.  c  o  m
    ObjectMapper mapper = createMapper();

    JavadocReader javadocReader = mock(JavadocReader.class);
    when(javadocReader.resolveFieldComment(ExternalSerializer.class, "bigDecimal")).thenReturn("A decimal");

    ConstraintReader constraintReader = mock(ConstraintReader.class);

    SimpleModule testModule = new SimpleModule("TestModule");
    testModule.addSerializer(new BigDecimalSerializer());
    mapper.registerModule(testModule);

    FieldDocumentationGenerator generator = new FieldDocumentationGenerator(mapper.writer(), javadocReader,
            constraintReader);
    Type type = ExternalSerializer.class;

    // when
    List<ExtendedFieldDescriptor> fieldDescriptions = cast(
            generator.generateDocumentation(type, mapper.getTypeFactory()));

    // then
    assertThat(fieldDescriptions.size(), is(1));
    assertThat(fieldDescriptions.get(0), is(descriptor("bigDecimal", "Decimal", "A decimal", "true")));
}

From source file:uk.ac.cam.cl.dtg.segue.dao.content.ContentMapper.java

/**
 * Creates a brand new object mapper./*from  ww w. j  a  va 2s . c  o  m*/
 * This should be used sparingly as it is resource intensive to maintain these things.
 * 
 * @return ObjectMapper that has been configured to handle the segue recursive object model.
 */
public ObjectMapper generateNewPreconfiguredContentMapper() {
    ContentBaseDeserializer contentDeserializer = new ContentBaseDeserializer();
    contentDeserializer.registerTypeMap(jsonTypes);

    ChoiceDeserializer choiceDeserializer = new ChoiceDeserializer(contentDeserializer);

    QuestionValidationResponseDeserializer validationResponseDeserializer = new QuestionValidationResponseDeserializer(
            contentDeserializer, choiceDeserializer);

    SimpleModule contentDeserializerModule = new SimpleModule("ContentDeserializerModule");
    contentDeserializerModule.addDeserializer(ContentBase.class, contentDeserializer);
    contentDeserializerModule.addDeserializer(Choice.class, choiceDeserializer);
    contentDeserializerModule.addDeserializer(QuestionValidationResponse.class, validationResponseDeserializer);

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(contentDeserializerModule);

    return objectMapper;
}

From source file:org.springside.examples.showcase.demos.utilities.json.JsonDemo.java

/**
 * ????MoneyLong./*from  w  w w.  java 2  s .c o  m*/
 */
@Test
public void customConverter() {

    JsonMapper newMapper = JsonMapper.nonEmptyMapper();

    SimpleModule moneyModule = new SimpleModule("MoneyModule");
    moneyModule.addSerializer(new MoneySerializer());
    moneyModule.addDeserializer(Money.class, new MoneyDeserializer());
    newMapper.getMapper().registerModule(moneyModule);

    // tojson
    User user = new User();
    user.setName("foo");
    user.setSalary(new Money(1.2));

    String jsonString = newMapper.toJson(user);

    assertThat(jsonString).isEqualTo("{\"name\":\"foo\",\"salary\":\"1.2\"}");

    // from
    User resultUser = newMapper.fromJson(jsonString, User.class);
    assertThat(resultUser.getSalary().value).isEqualTo(1.2);

}