@Override protected boolean supports(Class<?> clazz) { JavaType javaType = getJavaType(clazz); AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>(); if (this.objectMapper.canDeserialize(javaType, causeRef)) { return true; } Throwable cause = causeRef.get(); if (cause != null) { String msg = "Failed to evaluate deserialization for type " + javaType; if (logger.isDebugEnabled()) { logger.warn(msg, cause); } else { logger.warn(msg + ": " + cause); } } return false; }
@Override public void encode(OutputStream out, Object object) throws Exception { Class<?> clazz = object.getClass(); JsonGenerator generator = constructGenerator(out); JavaType type = mapper.getTypeFactory().constructType(clazz); ObjectWriter writer = mapper.writerFor(type); writer.writeValue(generator, object); generator.close(); }
@Then("^I should get all users with the following properties: (.*)$") public void i_should_get_all_users_with_the_following_properties(List<String> properties) throws IOException { ObjectMapper mapper = new ObjectMapper(); JavaType type = mapper.getTypeFactory().constructCollectionType(List.class, User.class); List<User> users = mapper.readValue(httpWorld.loadResponse().getBody(), type); for (String property : properties) { assertThat(users, everyItem(HasProperty.hasProperty(property))); } }
JavaType typeFromId(String id, TypeFactory typeFactory) throws IllegalStateException { String className = basePackage + "." + generateClassName(id); try { return typeFactory.constructType(typeFactory.findClass(className)); } catch (ClassNotFoundException ex) { throw new IllegalStateException("Could not find event class for type " + id, ex); } }
@Override public JsonDeserializer<?> modifyEnumDeserializer(DeserializationConfig config, JavaType type, BeanDescription beanDesc, JsonDeserializer<?> deserializer) { if (Arrays.asList(Quality.class, Format.class).contains(type.getRawClass())) { return new EnumDeserializer((Class<? extends Enum>) type.getRawClass()); } return super.modifyEnumDeserializer(config, type, beanDesc, deserializer); }
@Override public Optional<Object> tryCoerceParam(InvocationContext currentContext, int param, InputEvent input, MethodWrapper method) { Type type = method.getTargetMethod().getGenericParameterTypes()[param]; JavaType javaType = objectMapper(currentContext).constructType(type); return Optional.ofNullable(input.consumeBody(inputStream -> { try { return objectMapper(currentContext).readValue(inputStream, javaType); } catch (IOException e) { throw coercionFailed(type, e); } })); }
@BeforeClass public static void init() throws ParseException, IOException { logger.info(" Initializing RLP tests..."); String json = getJSON("rlptest"); Assume.assumeFalse("Local test is not available", json.equals("")); ObjectMapper mapper = new ObjectMapper(); JavaType type = mapper.getTypeFactory(). constructMapType(HashMap.class, String.class, RLPTestCase.class); TEST_SUITE = mapper.readValue(json, type); }
private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) { try { return this.objectMapper.readValue(inputMessage.getBody(), javaType); } catch (IOException ex) { throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex); } }
@Override public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object property) { ArrayProperty arrayProperty = (ArrayProperty) property; return findJavaType(classLoader, packageName, swagger, arrayProperty.getItems(), arrayProperty.getUniqueItems()); }
private static JavaType getOrCreateEnumByNames(ClassLoader classLoader, String packageName, List<String> enums) { String strEnums = enums.toString(); synchronized (LOCK) { JavaType javaType = enumMap.get(strEnums); if (javaType != null) { return javaType; } String enumClsName = packageName + ".Enum" + enumMap.size(); @SuppressWarnings("rawtypes") Class<? extends Enum> enumCls = JavassistUtils.createEnum(classLoader, enumClsName, enums); javaType = TypeFactory.defaultInstance().constructType(enumCls); enumMap.put(strEnums, javaType); return javaType; } }
public static JavaType findJavaType(ClassLoader classLoader, String packageName, Swagger swagger, String type, String format, List<String> enums) { if (!isEnum(enums)) { return ConverterMgr.findJavaType(type, format); } // enum,且需要动态生成class return getOrCreateEnumByNames(classLoader, packageName, enums); }
@Override public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object property) { StringProperty stringProperty = (StringProperty) property; List<String> enums = stringProperty.getEnum(); return findJavaType(classLoader, packageName, swagger, stringProperty.getType(), stringProperty.getFormat(), enums); }
public static void bulkLinkedRead1Test() throws IOException { SugarRestClient client = new SugarRestClient(TestAccount.Url, TestAccount.Username, TestAccount.Password); // -------------------Read Account Link Contact------------------- int count = 10; SugarRestResponse response = LinkedModules.bulkReadAccountLinkContact(client, count); assertNotNull(response); assertEquals(response.getStatusCode(), HttpStatus.SC_OK); String jsonData = response.getJData(); assertNull(response.getData()); assertNotNull(jsonData); // Deserialize json data to custom object ObjectMapper mapper = JsonObjectMapper.getMapper(); JavaType type = mapper.getTypeFactory().constructCollectionType(ArrayList.class, CustomAcccount1.class) ; List<CustomAcccount1> customAccounts = mapper.readValue(jsonData, type); assertNotNull(customAccounts); assertEquals(customAccounts.size(), count); }
@Override protected MethodSpec implementDeserializeMethod(TypeElement typeElement, Builder deserializeMethodBuilder) { Optional<DeserializationConstructs> constructs = loadConstructs(typeElement); if (!constructs.isPresent()) { return deserializeMethodBuilder.addStatement("return null").build(); } TypeElement enumTypeElement = constructs.get().getEnumTypeElement(); ImmutableList<Element> enumValueElements = constructs.get().getEnumValueElements(); ExecutableElement enumValueAccessorMethod = constructs.get().getEnumValueAccessorMethod(); ExecutableElement enumInstanceAccessorMethod = constructs.get().getEnumInstanceAccessorMethod(); String memberVariableName = this.processorUtil.createMemberVariableName(enumValueAccessorMethod); deserializeMethodBuilder.addStatement("$T codec = $L.getCodec()", ObjectCodec.class, JSON_PARSER_PARAMETER_NAME) .addStatement("$T rootNode = codec.readTree($L)", JsonNode.class, JSON_PARSER_PARAMETER_NAME) .addStatement("$T typeNode = rootNode.get($S)", JsonNode.class, memberVariableName) .beginControlFlow("if (typeNode == null)") .addStatement("$T javaType = $L.constructType($T.class)", JavaType.class, DESERIALIZATION_CONTEXT_PARAMETER_NAME, enumTypeElement) .addStatement("throw new $T($L, \"$L not present\", javaType, null)", InvalidTypeIdException.class, JSON_PARSER_PARAMETER_NAME, memberVariableName) .endControlFlow() .addStatement("$T type = codec.treeToValue(typeNode, $T.$L)", enumTypeElement, enumTypeElement, "class") .beginControlFlow("switch (type)"); enumValueElements.forEach(enumValueElement -> deserializeMethodBuilder .beginControlFlow("case $L:", enumValueElement) .addStatement("return codec.treeToValue(rootNode, $T.$L.$L)", enumTypeElement, enumValueElement, enumInstanceAccessorMethod) .endControlFlow()); return deserializeMethodBuilder.beginControlFlow("default :") .addStatement("return null") .endControlFlow() .endControlFlow() .build(); }
@Override public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectReader reader = mapper.readerFor(javaType); return new JacksonResponseBodyConverter<>(reader, type); }
public static JavaType findJavaType(ClassLoader classLoader, String packageName, Swagger swagger, Object def) { if (def == null) { return VOID_JAVA_TYPE; } Converter converter = converterMap.get(def.getClass()); if (converter == null) { throw new Error("not support def type: " + def.getClass()); } return converter.convert(classLoader, packageName, swagger, def); }
@Override public JavaType typeFromId(DatabindContext context, String id) { JavaType type = nameToType.get(id.toLowerCase()); if (type == null) { throw new NullPointerException( format("no subtype of %s found for enum value %s. existing mappings:\n%s", baseType, id, description)); } return type; }
@Override public JavaType doConvert(ClassLoader classLoader, String packageName, Swagger swagger, Object model) { ArrayModel arrayModel = (ArrayModel) model; if (arrayModel.getItems() != null) { return ArrayPropertyConverter.findJavaType(classLoader, packageName, swagger, arrayModel.getItems(), false); } // don't know when will this happen. throw new Error("not support null array model items."); }
public StateTestSuite(String json) throws IOException { ObjectMapper mapper = new ObjectMapper(); JavaType type = mapper.getTypeFactory(). constructMapType(HashMap.class, String.class, StateTestCase.class); testCases = new ObjectMapper().readValue(json, type); }
public static Class<?> getOrCreateClass(ClassLoader classLoader, String packageName, Swagger swagger, Map<String, Property> properties, String clsName) { Class<?> cls = getClassByName(classLoader, clsName); if (cls != null) { return cls; } ClassConfig classConfig = new ClassConfig(); classConfig.setClassName(clsName); if (null != properties) { for (Entry<String, Property> entry : properties.entrySet()) { JavaType propertyJavaType = ConverterMgr.findJavaType(classLoader, packageName, swagger, entry.getValue()); classConfig.addField(entry.getKey(), propertyJavaType); } } cls = JavassistUtils.createClass(classLoader, classConfig); return cls; }
public static Class<?> getOrCreateBodyClass(OperationGenerator operationGenerator, List<BodyParameter> bodyParameters) { SwaggerGenerator swaggerGenerator = operationGenerator.getSwaggerGenerator(); Method method = operationGenerator.getProviderMethod(); String clsName = swaggerGenerator.ensureGetPackageName() + "." + method.getName() + "Body"; Class<?> cls = getClassByName(swaggerGenerator.getClassLoader(), clsName); if (cls != null) { return cls; } ClassConfig classConfig = new ClassConfig(); classConfig.setClassName(clsName); // 1.全是预备body // 2.预备body与明确body混合 for (BodyParameter bp : bodyParameters) { JavaType javaType = ConverterMgr.findJavaType(swaggerGenerator.getClassLoader(), swaggerGenerator.ensureGetPackageName(), swaggerGenerator.getSwagger(), bp); classConfig.addField(bp.getName(), javaType); } return JavassistUtils.createClass(swaggerGenerator.getClassLoader(), classConfig); }
public DifficultyTestSuite(String json) throws IOException { ObjectMapper mapper = new ObjectMapper(); JavaType type = mapper.getTypeFactory(). constructMapType(HashMap.class, String.class, DifficultyTestCase.class); Map<String, DifficultyTestCase> caseMap = new ObjectMapper().readValue(json, type); for (Map.Entry<String, DifficultyTestCase> e : caseMap.entrySet()) { e.getValue().setName(e.getKey()); testCases.add(e.getValue()); } Collections.sort(testCases, new Comparator<DifficultyTestCase>() { @Override public int compare(DifficultyTestCase t1, DifficultyTestCase t2) { return t1.getName().compareTo(t2.getName()); } }); }
/** * Parses the network response {@link NetworkResponse} and returns the expected Type for the request. * @param response {@link NetworkResponse} The response for the request (Success or error). * @return Response object linked to a specific type */ @Override protected Response<T> parseNetworkResponse(NetworkResponse response) { this.networkResponse = response; JavaType returnType = getReturnType(); T returnData = null; if (returnType != null) { try { if (response.data != null) { returnData = SpitfireManager.getObjectMapper().readValue(response.data, returnType); } } catch (Exception e) { VolleyLog.e(e, "An error occurred while parsing network response:"); returnData = null; } } if (returnData == null && classResponse != Void.class) { ParseError parseError = new ParseError(response); String content = ""; if (response.data != null) { content = new String(response.data); } VolleyLog.e(parseError, "Return data is null. API returned : "+ content); return Response.error(parseError); } return Response.success(returnData, HttpHeaderParser.parseCacheHeaders(response)); }
private void checkType(JavaType type) { // 原子类型/string在java中是abstract的 if (type.getRawClass().isPrimitive() || propertyCreatorMap.containsKey(type.getRawClass()) || String.class.equals(type.getRawClass())) { return; } String msg = "Must be a concrete type."; if (type.isMapLikeType()) { Class<?> keyTypeClass = type.getKeyType().getRawClass(); if (!String.class.equals(keyTypeClass)) { // swagger中map的key只允许为string throw new Error("Type of key in map must be string, but got " + keyTypeClass.getName()); } } if (type.isContainerType()) { checkType(type.getContentType()); return; } if (type.getRawClass().isInterface()) { throw new ServiceCombException(type.getTypeName() + " is interface. " + msg); } if (Modifier.isAbstract(type.getRawClass().getModifiers())) { throw new ServiceCombException(type.getTypeName() + " is abstract class. " + msg); } }
@Override public Model resolve(JavaType type, ModelConverterContext context, Iterator<ModelConverter> next) { // property is not a model if (propertyCreatorMap.containsKey(type.getRawClass())) { return null; } Model model = super.resolve(type, context, next); if (model == null) { return null; } checkType(type); // 只有声明model的地方才需要标注类型 if (ModelImpl.class.isInstance(model) && !StringUtils.isEmpty(((ModelImpl) model).getName())) { setType(type, model.getVendorExtensions()); } return model; }
@Override public void init(JavaType baseType) { this.baseType = baseType; Class<?> baseClass = baseType.getRawClass(); TypesEnum typesEnum = baseClass.getAnnotation(TypesEnum.class); while (baseClass != null && typesEnum == null) { baseClass = baseClass.getSuperclass(); typesEnum = baseClass.getAnnotation(TypesEnum.class); } if (typesEnum == null) { throw new NullPointerException("Missing annotation TypesEnum on " + baseType.getRawClass()); } SubTypeMapping mapping = new SubTypeMapping(typesEnum); TypeFactory defaultInstance = TypeFactory.defaultInstance(); StringBuilder sb = new StringBuilder(); for (Enum<?> e : mapping.getEnumConstants()) { String name = e.name(); String className = mapping.getClassName(e); try { Class<?> c = Class.forName(className, false, this.getClass().getClassLoader()); JavaType type = defaultInstance.uncheckedSimpleType(c); this.nameToType.put(name.toLowerCase(), type); this.typeToName.put(c, name); sb.append(name + " => " + c.getName() + "\n"); } catch (ClassNotFoundException e1) { throw new RuntimeException(String.format( "class not found %s for enum value %s for base type %s", className, name, baseType ) , e1); } } this.description = sb.toString(); }
@Test public void testConverter() { SwaggerGenerator generator = new SwaggerGeneratorForTest(context, null); Swagger swagger = generator.getSwagger(); ParamUtils.addDefinitions(swagger, User.class); Model model = swagger.getDefinitions().get("User"); model.getVendorExtensions().clear(); JavaType javaType = ConverterMgr.findJavaType(generator, model); checkJavaType(swagger, javaType); RefModel refModel = new RefModel(); refModel.setReference("User"); javaType = ConverterMgr.findJavaType(generator, refModel); checkJavaType(swagger, javaType); }
private Map writeAndReadJson(Repository repository) throws Exception { NetworkStateExporter nse = new NetworkStateExporter(repository); Assert.assertTrue(nse.exportStatus(jsonFileName)); InputStream inputStream = new FileInputStream(jsonFileName); String json = new String(ByteStreams.toByteArray(inputStream)); ObjectMapper mapper = new ObjectMapper(); JavaType type = mapper.getTypeFactory().constructType(HashMap.class); Map result = new ObjectMapper().readValue(json, type); return result; }
@Test public void testFetchAndLock() throws CamundaRestException, IOException { FetchExternalTasksDto dto = new FetchExternalTasksDto(); List<LockedExternalTaskDto> externalTasks = service.fetchAndLock(dto); Assert.assertNotNull(externalTasks); Assert.assertEquals(1, externalTasks.size()); Assert.assertNotNull(externalTasks.get(0)); Mockito.verify(objectMapper, Mockito.times(1)).writeValueAsString(Mockito.any()); Mockito.verify(objectMapper, Mockito.times(1)).getTypeFactory(); Mockito.verify(objectMapper, Mockito.times(1)).readValue(Mockito.<InputStream>any(), Mockito.<JavaType>any()); Mockito.verify(httpClient, Mockito.times(1)).execute(Mockito.any()); }
@Override public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectWriter writer = mapper.writerFor(javaType); return new MessagePackRequestBodyConverter<>(writer); }
/** * Returns the type for the response. * @return null, Array, List, Map or Object. */ @Nullable private JavaType getReturnType() { if (classResponse == Void.class) { return null; } else if (classResponse.isArray()) { return TypeFactory.defaultInstance().constructArrayType(classResponse.getComponentType()); } else if (classResponse == List.class) { return TypeFactory.defaultInstance().constructCollectionType(List.class, classResponse.getComponentType()); } else if (classResponse == Map.class) { return TypeFactory.defaultInstance().constructMapType(Map.class, String.class, classResponse.getComponentType()); } return TypeFactory.defaultInstance().constructType(classResponse); }
@Override public ParamValueProcessor create(Parameter parameter, Type genericParamType) { JavaType targetType = TypeFactory.defaultInstance().constructType(genericParamType); if (isPart(parameter)) { return new PartProcessor(parameter.getName(), targetType); } return new FormProcessor(parameter.getName(), targetType); }
default Object decodeResponse(InputStream input, JavaType type) throws Exception { if (input.available() == 0) { return null; } return doDecodeResponse(input, type); }
@SneakyThrows private Map<String, Set<TenantState>> getTenantsList() { Optional<Configuration> maybeConfiguration = configurationService.findConfiguration(CONFIG_LIST_STORAGE); if (!maybeConfiguration.isPresent()) { return new HashMap<>(); } Configuration configuration = maybeConfiguration.get(); JavaType setType = om.getTypeFactory().constructCollectionType(Set.class, TenantState.class); JavaType stringType = om.getTypeFactory().constructType(String.class); JavaType mapType = om.getTypeFactory().constructMapType(Map.class, stringType, setType); return om.readValue(configuration.getContent(), mapType); }
default Object decodeResponse(Buffer buffer, JavaType type) throws Exception { if (buffer.length() == 0) { return null; } try (BufferInputStream input = new BufferInputStream(buffer.getByteBuf())) { return doDecodeResponse(input, type); } }
@Override public Object doDecodeResponse(InputStream input, JavaType type) throws Exception { // plainText类型,肯定是返回string的,想不出有其他类型的场景 return IOUtils.toString(input, StandardCharsets.UTF_8); // TODO: 该方法尚需进一步修改 // Class<?> returnCls = type.getRawClass(); // if (returnCls.isPrimitive()) { // // 处理char类型 // if (returnCls == char.class) { // return ((String)result).charAt(0); // } // // 处理其他如int, long, boolean等类型 // return RestObjectMapper.INSTANCE.readValue((String)result, type); // } // else { // // 处理如String等其他复杂类型 // // 对于更多处理不了的复杂类型建议使用"application/json" // return returnCls.getConstructor(new Class<?>[] {String.class}) // .newInstance((String)result); // } }
@Test public void testdecodeResponseNull() throws Exception { JavaType resultType = TypeFactory.unknownType(); Object result = pp.decodeResponse(Buffer.buffer(), resultType); Assert.assertNull(result); ByteArrayInputStream is = new ByteArrayInputStream(new byte[] {}); result = pp.decodeResponse(is, resultType); Assert.assertNull(result); }
/** * 反序列化复杂Collection如List<Bean>, * contructCollectionType()或contructMapType()构造类型, 然后调用本函数. * * @see #createCollectionType(Class, Class...) */ @SuppressWarnings("unchecked") public <T> T fromJson(@Nullable String jsonString, JavaType javaType) { if (StringUtils.isEmpty(jsonString)) { return null; } try { return (T) mapper.readValue(jsonString, javaType); } catch (IOException e) { logger.warn("parse json string error:" + jsonString, e); return null; } }
@Override public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { JavaType javaType = getJavaType(type, contextClass); return readJavaType(javaType, inputMessage); }
@Override protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { JavaType javaType = getJavaType(clazz, null); return readJavaType(javaType, inputMessage); }