spring 如何让JacksonObjectMapper使用xjc生成的包含Jakarta注解的类？

xfb7svmp  于 2024-01-05  发布在  Spring
关注(0)|答案(1)|浏览(148)

这是我的箱子
我已经从一些XSD和WSDL文件中生成了一些源文件。生成的源文件有用Jakarta注解注解的类和属性。我的应用程序中有3层，
1.控制器层- Spring MVC控制器。它们接受一个XJC生成的类对象作为请求体，并给予另一个作为响应体
1.客户端层-使用Jaxb 2 Marshaller创建WebServiceTemplate并将请求作为SOAP请求转发到另一个URL的层

  1. XML元素类层-使用xjc生成的XML类型等效类
    我面临的问题是解析JAXBElement类型类的属性。下面是一个示例类，
  1. @XmlAccessorType(XmlAccessType.FIELD)
  2. @XmlType(name = "", propOrder = {
  3.     "filter",
  4.     "initialTerminationTime",
  5.     "subscriptionPolicy",
  6.     "any"
  7. })
  8. @XmlRootElement(name = "CreatePullPointSubscription")
  9. public class CreatePullPointSubscription {
  10.     @XmlElement(name = "Filter")
  11.     protected FilterType filter;
  13.     @XmlElementRef(name = "InitialTerminationTime", namespace = "http://www.onvif.org/ver10/events/wsdl", type = JAXBElement.class, required = false)
  14.     protected JAXBElement<String> initialTerminationTime;
  16.     ...
  17. }

字符串
默认情况下，将这些类视为POJO，生成的模式显示ObjectMapper期望JSON主体反映JAXElement的定义，而不是实际属性的类型。我不希望用户发送JAXBElement的附加属性。
MyWebMvcConfigurer：

  1. @Override
  2.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  3.         SimpleModule serializerModule = new SimpleModule();
  4.         serializerModule.addSerializer(JAXBElement.class, new JAXBJsonSerializer());
  5.         serializerModule.addDeserializer(Object.class, new JAXBJsonDeserializer<>(Object.class));
  7.         for (HttpMessageConverter o : converters) {
  8.             if (o instanceof AbstractJackson2HttpMessageConverter) {
  9.                 ObjectMapper om = ((AbstractJackson2HttpMessageConverter)o).getObjectMapper();
  10.                 om.addMixIn(JAXBElement.class, JAXBElementMixin.class);
  12.                 // This line tells swagger to show what I expect
  13.                 ModelConverters.getInstance().addConverter(new ModelResolver(om));
  14.                 om.registerModule(serializerModule);
  15.             }
  16.         }
  18.         WebMvcConfigurer.super.configureMessageConverters(converters);
  19.     }

型
ModelResolver似乎只是改变了开放的API模式，而不是实际的序列化。为此，我实现了一个自定义序列化器和一个序列化器，正如你在上面的代码中看到的。
JAXBJ声发射器

  1. package com.ibi.onvif.web;
  3. import com.fasterxml.jackson.core.JsonParser;
  4. import com.fasterxml.jackson.databind.DeserializationContext;
  5. import com.fasterxml.jackson.databind.JavaType;
  6. import com.fasterxml.jackson.databind.JsonDeserializer;
  7. import com.fasterxml.jackson.databind.JsonNode;
  9. import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
  10. import com.fasterxml.jackson.databind.deser.std.StdScalarDeserializer;
  11. import jakarta.xml.bind.JAXBElement;
  12. import jakarta.xml.bind.JAXBException;
  13. import jakarta.xml.bind.annotation.XmlElementDecl;
  15. import java.io.IOException;
  16. import java.lang.reflect.InvocationTargetException;
  17. import java.lang.reflect.Method;
  18. import java.util.Iterator;
  19. import java.util.Map;
  21. public class JAXBJsonDeserializer<T> extends StdDeserializer<T> {
  22.     protected JAXBJsonDeserializer(Class<?> vc) {
  23.         super(vc);
  24.     }
  26.     protected JAXBJsonDeserializer(JavaType valueType) {
  27.         super(valueType);
  28.     }
  30.     protected JAXBJsonDeserializer(StdDeserializer<?> src) {
  31.         super(src);
  32.     }
  34.     @Override
  35.     public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
  36.         try {
  37.             // Get the root element's class
  38.             Class<?> rootType = ctxt.getContextualType().getRawClass();
  40.             // Check if the root element is part of a JAXB-generated package
  41.             if (isJAXBGenerated(rootType)) {
  42.                 Object objectFactory = getObjectFactory(rootType);
  44.                 // Deserialize the JSON into a JsonNode
  45.                 JsonNode node = p.getCodec().readTree(p);
  47.                 // Identify the appropriate factory method by annotations or return type
  48.                 Method factoryMethod = findFactoryMethod(objectFactory, rootType, null);
  50.                 // Use the factory method to generate the object
  51.                 T rootObject = (T) factoryMethod.invoke(objectFactory);
  53.                 // Recursively process attributes
  54.                 processAttributes(objectFactory, rootObject, node, ctxt);
  56.                 return rootObject;
  57.             } else {
  58.                 // If not a JAXB-generated class, use the default deserialization
  59.                 return ctxt.readValue(p, (Class<T>) rootType);
  60.             }
  61.         } catch (Exception e) {
  62.             throw new IOException("JAXB deserialization error", e);
  63.         }
  64.     }
  66.     private boolean isJAXBGenerated(Class<?> type) {
  67.         // Implement logic to check if the class is part of a JAXB-generated package
  68.         // For example, you can check package names or annotations.
  69.         // Replace the following line with your actual logic.
  70.         return type.getPackage().getName().startsWith("org.onvif");
  71.     }
  73.     private Object getObjectFactory(Class<?> type) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  74.         String objectFactoryClassName = type.getPackage().getName() + ".ObjectFactory";
  75.         Class<?> objectFactoryClass = Class.forName(objectFactoryClassName);
  76.         return objectFactoryClass.newInstance();
  77.     }
  79.     private Method findFactoryMethod(Object objectFactory, Class<?> rootType, String attr) throws NoSuchMethodException, NoSuchFieldException {
  80.         // If attr is null, the caller is asking for rootType factory method
  81.         Method[] methods = objectFactory.getClass().getDeclaredMethods();
  82.         if (attr == null) {
  83.             for (Method method : methods) {
  84.                 if (method.getName().equals(String.format("create%s", rootType.getName()))) {
  85.                     return method;
  86.                 }
  87.             }
  88.             throw new NoSuchMethodException("Factory method not found for class: " + rootType);
  89.         }
  91.         assert rootType.getField(attr).getType() == JAXBElement.class;
  93.         for (Field field : rootType.getFields()) {
  94.             if (field.getName().equals(attr)) {
  95.                 XmlElement annotation = field.getAnnotation(XmlElement.class);
  96.                 return objectFactory.getClass().getMethod(String.format("create%s%s", rootType.getName(), annotation.name()));
  97.             }
  98.         }
  99.         
  100.         throw new NoSuchMethodException("Factory method not found for class: " + rootType + " and attr: " + attr);
  101.     }
  103.     private void processAttributes(Object objectFactory, Object parentObject, JsonNode node, DeserializationContext ctxt)
  104.             throws IllegalAccessException, InvocationTargetException, NoSuchMethodException, IOException, JAXBException, NoSuchMethodException, NoSuchFieldException {
  105.         for (Iterator<Map.Entry<String, JsonNode>> it = node.fields(); it.hasNext(); ) {
  106.             Map.Entry<String, JsonNode> field = it.next();
  107.             String fieldName = field.getKey();
  108.             JsonNode fieldValue = field.getValue();
  110.             // Find the corresponding object factory field value generator
  111.             Method setterMethod = findSetterMethod(parentObject.getClass(), fieldName);
  113.             // Get the attribute value
  114.             Object attributeValue;
  115.             Class<?> parameterType = setterMethod.getParameterTypes()[0];
  116.             if (parameterType == JAXBElement.class) {
  117.                 // if it is a JAXBElement-type field, call ObjectFactory to get factory method
  118.                 Method fieldFactoryMethod = findFactoryMethod(objectFactory, parentObject.getClass(), fieldName);
  120.                 // get attribute value from the object factory attribute factory
  121.                 attributeValue = fieldFactoryMethod.invoke(objectFactory, ctxt.readTreeAsValue(fieldValue, fieldFactoryMethod.getParameterTypes()[0]));
  122.             }   else    {
  123.                 attributeValue = ctxt.readTreeAsValue(fieldValue, parameterType);
  124.             }
  126.             // Invoke the setter method to set the attribute value
  127.             setterMethod.invoke(parentObject, attributeValue);
  128.         }
  129.     }
  131.     private Method findSetterMethod(Class<?> parentClass, String fieldName) throws NoSuchMethodException {
  132.         return parentClass.getMethod(String.format("set%s", fieldName));
  133.     }
  134. }

型
JAXBJsonSerializer

  1. package com.ibi.onvif.web;
  3. import com.fasterxml.jackson.core.JsonGenerator;
  4. import com.fasterxml.jackson.databind.JsonSerializer;
  5. import com.fasterxml.jackson.databind.SerializerProvider;
  6. import jakarta.xml.bind.JAXBElement;
  8. import java.io.IOException;
  10. public class JAXBJsonSerializer extends JsonSerializer<Object> {
  11.     @Override
  12.     public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  13.         Object objectValue = ((JAXBElement<?>)value).getValue();
  14.         gen.writeObject(objectValue);
  15.     }
  16. }

型
ObjectMapper似乎从来没有使用过我的验证器。

  1. com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of 
  2. `jakarta.xml.bind.JAXBElement` (no Creators, like default constructor, exist): 
  3. no String-argument constructor/factory method to deserialize from String value ('PT600S')

型
如何让ObjectMapper工作？
任何帮助是赞赏！

spring

1条答案

按热度按时间
j7dteeu8

j7dteeu81#

我通过为JAXBElement创建一个自定义的解析器解决了这个问题。JsonParser类允许我们访问父元素属性，通过它我可以识别当前JSON字段正在为哪个类字段进行解析，从而提取像XmlElementRef和XmlElement这样的注解。
请在下面找到相同的代码。
JAXBElementDeserializer.java:

  1. public class JAXBElementDeserializer extends StdDeserializer<JAXBElement<?>>{
  2.     public JAXBElementDeserializer() {
  3.         super(JAXBElement.class);
  4.     }
  6.     @Override
  7.     public JAXBElement<?> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
  8.         try {
  9.             // Get the root element's class
  10.             Class<?> rootType = p.getParsingContext().getCurrentValue().getClass();
  12.             // Check if the root element is part of a JAXB-generated package
  13.             if (isJAXBGenerated(rootType)) {
  14.                 Object objectFactory = getObjectFactory(rootType);
  16.                 // Deserialize the JSON into a JsonNode
  17.                 JsonNode node = p.getCodec().readTree(p);
  19.                 // Identify the appropriate factory method by annotations or return type
  20.                 Method factoryMethod = findFactoryMethod(objectFactory, rootType, p.getCurrentName());
  22.                 //Get the parameter type
  23.                 Class<?> type = factoryMethod.getParameters()[0].getType();
  25.                 // Use the factory method to generate the object
  26.                 return  (JAXBElement<?>) factoryMethod.invoke(objectFactory, ctxt.readTreeAsValue(node, type));
  27.             } else {
  28.                 // If not a JAXB-generated class, use the default deserialization
  29.                 throw new IOException();
  30.             }
  31.         } catch (Exception e) {
  32.             throw new IOException("JAXB deserialization error", e);
  33.         }
  34.     }
  36.     private boolean isJAXBGenerated(Class<?> type) {
  37.         // Implement logic to check if the class is part of a JAXB-generated package
  38.         // For example, you can check package names or annotations.
  39.         // Replace the following line with your actual logic.
  40.         return type.getPackage().getName().startsWith("org.onvif");
  41.     }
  43.     private Object getObjectFactory(Class<?> type) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  44.         String objectFactoryClassName = type.getPackage().getName() + ".ObjectFactory";
  45.         Class<?> objectFactoryClass = Class.forName(objectFactoryClassName);
  46.         return objectFactoryClass.newInstance();
  47.     }
  49.     private Method findFactoryMethod(Object objectFactory, Class<?> rootType, String attr) throws NoSuchMethodException, NoSuchFieldException {
  50.         String annotatedName;
  51.         assert rootType.getField(attr).getType() == JAXBElement.class;
  53.         for (Field field : rootType.getDeclaredFields()) {
  54.             if (field.getName().equals(attr)) {
  55.                 XmlElement annotation = field.getAnnotation(XmlElement.class);
  56.                 if (annotation != null) {
  57.                     annotatedName = annotation.name();
  58.                 }   else {
  59.                     XmlElementRef ref_annotation = field.getAnnotation(XmlElementRef.class);
  60.                     annotatedName = ref_annotation.name();
  61.                 }
  63.                 // Don't know the type, simple search the method by its name
  64.                 for (Method method : objectFactory.getClass().getMethods()) {
  65.                     if (method.getName().equals(String.format("create%s%s", rootType.getSimpleName(), annotatedName))) {
  66.                         return method;
  67.                     }
  68.                 }
  69.             }
  70.         }
  72.         throw new NoSuchMethodException("Factory method not found for class: " + rootType + " and attr: " + attr);
  73.     }
  74. }

字符串
JAXBElementSerializer：

  1. public class JAXBElementSerializer extends JsonSerializer<JAXBElement> {
  2.     @Override
  3.     public void serialize(JAXBElement value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  4.         Object objectValue = value.getValue();
  5.         gen.writeObject(objectValue);
  6.     }
  7. }

型
WebMvcConfigurer.java:

  1. public class OnvifWebMvcConfigurer implements WebMvcConfigurer {
  2.     // Mixins
  3.     public static interface JAXBElementMixin {
  4.         @JsonValue
  5.         Object getValue();
  6.     }
  8.     public static interface DurationMixin {
  9.         @JsonValue
  10.         String toString();
  11.     }
  13.     final private Class<?>[][] MIXIN_CLASSES = {
  14.             {JAXBElement.class, JAXBElementMixin.class},
  15.             {Duration.class, DurationMixin.class},
  16.     };
  17.     
  18.     private final SimpleModule module = new SimpleModule();
  20.     private void setupModule() {
  21.         module.addSerializer(JAXBElement.class, new JAXBElementSerializer());
  22.         module.addSerializer(Duration.class, new DurationSerializer());
  23.         module.addDeserializer(JAXBElement.class, new JAXBElementDeserializer());
  24.         module.addDeserializer(Duration.class, new DurationDeserializer());
  25.     }
  27.     @Override
  28.     public void addInterceptors(InterceptorRegistry registry) {
  29.         registry.addInterceptor(new OnvifCredentialsExtractionInterceptor());
  30.     }
  32.     private void configureMixins(ObjectMapper om) {
  33.         for (Class<?>[] pair : MIXIN_CLASSES) {
  34.             om.addMixIn(pair[0], pair[1]);
  35.             SpringDocUtils.getConfig().replaceWithClass(pair[0], pair[1]);
  36.         }
  37.     }
  39.     private void configureMessageConverter(HttpMessageConverter<?> httpMessageConverter) {
  40.         if (!(httpMessageConverter instanceof AbstractJackson2HttpMessageConverter)) {
  41.             return;
  42.         }
  43.         ObjectMapper om = ((AbstractJackson2HttpMessageConverter) httpMessageConverter).getObjectMapper();
  44.         configureMixins(om);
  45.         ModelConverters.getInstance().addConverter(new ModelResolver(om));
  46.         om.registerModule(module);
  47.     }
  49.     @Override
  50.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  51.         setupModule();
  53.         for (HttpMessageConverter<?> o : converters) {
  54.             configureMessageConverter(o);
  55.         }
  57.         WebMvcConfigurer.super.configureMessageConverters(converters);
  58.     }
  59. }

型
我希望这对你有帮助！

展开查看全部
赞(0）分享  回复(0）举报  2024-01-05
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com