标签: objectmapper

我正在使用 Alamofire、Objectmapper、Realm，除了一件事之外，一切都在工作：我无法映射嵌套对象。

class Voting: Object, Mappable {

    dynamic var votingID: String = ""
    dynamic var question: String = ""
    var votingOptions = List<VotingOption>()

    required convenience init?(_ map: Map) {
        self.init()
    }

    func mapping(map: Map) {
        votingID <- map["id"]
        question <- map["question"]
        votingOptions <- map["votingOptions"]
    }

    override class func primaryKey() -> String {
        return "votingID"
    }   
}

class VotingOption: Object, Mappable{

    dynamic var optionID: String = ""
    dynamic var text: String = ""


    required convenience init?(_ map: Map) {
        self.init()
    } …

我想基于端点配置自定义消息转换器。例如，我在Spring启动控制器中有以下两个端点：

@RequestMapping(value = "/all", method = RequestMethod.GET)
    public ResponseEntity<Object> findAll{@PageableDefault(size = 10, page = 0) final Pageable pageable){
//code
}

@RequestMapping(value = "/object/{id}", method = RequestMethod.GET)
    public ResponseEntity<Object> byId{@RequestParam("id" String id){
//code
}

对于这两种情况，我想使用不同的HttpMessageConverter（以及对象映射器）实例。例如，我想CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES为/all端点设置策略，因为它是页面响应，而不是/object。

该应用程序已经configureMessageConverters覆盖了方法，所有Objects都使用了Objectmapper bean。如果对此做出任何更改，它将适用于所有端点，这是我不希望的。

还有其他方法吗？（有点像在findAll方法本身中创建和使用自定义消息转换器）

目前我正在使用Alamofire + ObjectMapper.我想改用AlamofireObjectMapper.但我有一个问题:如何处理api内容级错误？

例如,当我尝试保存新用户时:如果我发送到服务器的所有详细信息都有效,那么我的服务器将新用户详细信息返回为json.但如果我发送错误的细节(在应用程序逻辑级别),api将返回一个json,只显示一条错误消息,如"此用户名已被占用"

目前我正在使用Alamofire返回json:

Alamofire.request(myURL, method: .post, parameters: dic, encoding: JSONEncoding.default).validate().responseString { response in
                switch response.result {
                case .success:

                    if let JSON = response.result.value {

                            callback(JSON)

                    } else {
                        print("error with response.result.value")}

                case .failure:

                    debugPrint(request)
                    //alert to user 

                }

            }

然后,在回调中,我检查json以查看它是否看起来像用户结构或错误结构(如果它是用户结构,我使用ObjectMapper使其成为User对象):

MyAPI.saveUser(user){
                    (response) in

                    // response to json (to check error)
                    if (MyAPI.JSONToDictionary(response)!)["error"] != nil{

                        // Application level error (logic)
                        print((MyAPI.JSONToDictionary(response)!)["error"])

                    }
                    else{

                        //Using ObjectMapper - response to User object 
                        let responsedUser = MyAPI.jsonToUser(response) …

在Java8之前，我们使用ObjectMapper来设置DateFormat如下

DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
ObjectMapper mapper = <SomeInstantiation>
mapper.setDateFormat(df);
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

现在我们有了 java.time.format.DateTimeFormatter，它与 SimpleDateFormat 不同，它是线程安全的并且更健壮。我想替换 ObjectMapper 上的上述设置。

如何使用 ObjectMapper 设置 DateTimeFormatter

我正在尝试使用下面提到的代码将 ProtoBuf 转换为 Map。

Map map = objectMapper.convertValue(obj, Map.class);

导致此问题的示例 PB 数据：id：“1”元数据 { type：“UNIT” isValidated：false status { status：ACTIVE } }

我收到错误 java.lang.IllegalArgumentException：直接自引用导致循环（通过引用链：com.sample.samplePB["unknownFields"]->com.google.protobuf.UnknownFieldSet["defaultInstanceForType"]）

我在 Spring Boot 项目中使用 Jackson 进行序列化/反序列化。

我有一个具有以下结构的 DTO 对象，

public class TestDTO implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;

    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
    private UUID certificateId;

    @NotNull
    private Long orgId;

    @NotNull
    private CertificateType certificateType;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Valid
    @NotNull
    private PublicCertificateDTO publicCertificate;

    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
    @Valid
    private PrivateCertificateDTO privateCertificate;

    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
    private ZonedDateTime expiryDate;

    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
    private ZonedDateTime createdDate;

    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
    private ZonedDateTime updatedDate;
}

使用以下方法在我的单元测试中序列化此对象，

public static byte[] convertObjectToJsonBytes(TestDTO object)
        throws …

我在使用 Alamofire 对象映射器点击 Alamofire 获取请求时出错

这就是我如何使用 API-

APIService.shared.getSlots{ (success,weekSlots, error) in
    if success {
    self.weekSlots = weekSlots!
    print("success!!")
  } else {
    print(error?.errorMessage ?? "NOPE")
  }
}

而 APIService 类中的 getSlot 函数是-

open func getSlots(completion: @escaping (Bool, [WeekSlot]?, APIError?) -> ()) {
sessionManager.request(APIRouter.getSlots())
  .validate(statusCode: 200..<300)
  .responseArray(queue: nil,
                  keyPath: "week_slots",
                  context: nil) { (response: DataResponse<[WeekSlot]>) in
                    switch response.result {
                    case .success(let value):
                      self.saveArraysToRealm(value: value)
                      completion(true,value, nil)
                    case .failure:
                      let error = self.processFailure(json: JSON(response.data as Any))
                      completion(false, nil, error)
                      print(error)
                    }
  }
} …

使用ObjectMapper( com.fasterxml.jackson.databind) 可以指定它应该忽略未知属性。这可以通过添加@JsonIgnoreProperties(ignoreUnknown = true)类级别或通过将其设置为映射器中的默认行为来完成。但是，在它的initialize()方法中执行此操作时Application<MyConfiguration>似乎没有效果。

ObjectMapper mapper = bootstrap.getObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

对于配置文件中的未知属性，它仍然失败。如何配置 Dropwizard 以忽略未知属性？

我正在尝试创建一个 JSON 文件，但在尝试使用 ObjectMapper 类时遇到了问题。继承人我的班级代码：

import java.math.BigDecimal;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import desafiodimensiva.entities.Desafio2;

@RestController
public class Desafio2Controller {

    @RequestMapping(value = "/teste")
    public String index() {
        return "Greetings from Spring Boot!";
    }
    @RequestMapping("/desafio2")
    public Desafio2 novoDesafio2() {
        ObjectMapper mapper = new ObjectMapper();

        Desafio2 pessoa = new Desafio2();
        BigDecimal valorFinanceiroPessoa = new BigDecimal("0.00");
        pessoa.setNomePessoa("-----------                            ");
        pessoa.setIdPessoa("0000");
        pessoa.setValorFinanceiro(valorFinanceiroPessoa);

        return pessoa;
    }
}

还有我的 pom.xml ：

`<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.desafio.dimensiva</groupId>
    <artifactId>desafiodimensiva</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>Desafio Dimensiva</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.BUILD-SNAPSHOT</version>
    </parent>

    <properties> …

我在 Java 应用程序中使用Jackson JSON 库及其树模型系统 ( JsonNode)。在此，我需要检查一个是否ArrayNode包含给定的JsonNode. 我一直在寻找通过JavaDoc中，我没有看到任何形式的.contains()对方法ArrayNode。我最终自己编写了一个包含方法：

   public static boolean arrayNodeContains(ArrayNode arrayNode, JsonNode node) {
      Stream<JsonNode> nodeStream = StreamSupport.stream(arrayNode.spliterator(), false);
      return nodeStream.anyMatch(j -> j.equals(node));
   }

单元测试：

   @Test
   public void testArrayNodeContains()
         throws IOException
   {
      ObjectMapper mapper = new ObjectMapper;

      String arrayJsonString = "[{\"foo\":\"bar\"},{\"foo\":\"baz\"},{\"baz\":\"bar\"}]";
      String nodeTrueJsonString = "{\"foo\":\"bar\"}";
      String nodeFalseJsonString = "{\"foo\":\"brains\"}";
      List<Object> list = mapper.readValue(arrayJsonString, List.class);
      ArrayNode arrayNode = mapper.valueToTree(list);

      Map<String, Object> nodeTrueMap = mapper.readValue(nodeTrueJsonString, Map.class);
      JsonNode nodeTrue …