Question

正如你可能从标题中收集的那样，这是一个有点复杂的问题。

首先，我的目标是：

我正在努力实现我的java类与JSON 之间的转换，而不必向它们添加任何特定于json的注释。
我的java类包含immutables，必须从传递给构造函数的参数初始化它们的成员，所以我必须使用多参数构造函数 @JsonCreator，没有@JsonParameter。
我正在使用jackson ObjectMapper。如果我可以使用的另一个ObjectMapper没有此处描述的问题，我很乐意使用它，但它必须与杰克逊的ObjectMapper一样同样有信誉。（所以，我不愿意从他的GitHub下载Jim的ObjectMapper。）

我理解如何实现这一点，以防我在某处出错：

Java曾经通过反射使方法（和构造函数）参数类型可被发现，但不是参数名称。这就是为什么@JsonCreator和@JsonParameter注释过去是必要的：告诉json ObjectMapper哪个构造函数参数对应哪个属性。使用Java 8，如果提供新的-parameters参数，编译器会将方法（和构造函数）参数名称发送到字节码中，并通过反射使它们可用，并且最新版本的jackson ObjectMapper支持这个，所以它现在应该可以使用json对象映射而不需要任何特定于json的注释。

我有这个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>test</groupId>
    <artifactId>test.json</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>Json Test</name>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <build>
        <sourceDirectory>main</sourceDirectory>
        <testSourceDirectory>test</testSourceDirectory>
        <plugins>
            <plugin>
                <!--<groupId>org.apache.maven.plugins</groupId>-->
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <!--<compilerArgument>-parameters</compilerArgument>-->
                    <!--<fork>true</fork>-->
                    <compilerArgs>
                        <arg>-parameters</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrs</groupId>
            <artifactId>jackson-jaxrs-json-provider</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-parameter-names</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

我用它来编译和运行以下一个小的自包含程序：

package jsontest;

import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;

import java.io.IOException;
import java.lang.reflect.*;

public final class MyMain
{
    public static void main( String[] args ) throws IOException, NoSuchMethodException
    {
        Method m = MyMain.class.getMethod("main", String[].class);
        Parameter mp = m.getParameters()[0];
        if( !mp.isNamePresent() || !mp.getName().equals("args") )
            throw new RuntimeException();
        Constructor<MyMain> c = MyMain.class.getConstructor(String.class,String.class);
        Parameter m2p0 = c.getParameters()[0];
        if( !m2p0.isNamePresent() || !m2p0.getName().equals("s1") )
            throw new RuntimeException();
        Parameter m2p1 = c.getParameters()[1];
        if( !m2p1.isNamePresent() || !m2p1.getName().equals("s2") )
            throw new RuntimeException();

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule( new ParameterNamesModule() ); // "-parameters" option must be passed to the java compiler for this to work.
        mapper.configure( DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true );
        mapper.configure( SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true );
        mapper.setSerializationInclusion( JsonInclude.Include.ALWAYS );
        mapper.setVisibility( PropertyAccessor.ALL, JsonAutoDetect.Visibility.PUBLIC_ONLY );
        mapper.enableDefaultTyping( ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY );

        MyMain t = new MyMain( "1", "2" );
        String json = mapper.writeValueAsString( t );
        /*
         * Exception in thread "main" com.fasterxml.jackson.databind.JsonMappingException: No suitable constructor found for type [simple type, class saganaki.Test]: can not
         * instantiate from JSON object (missing default constructor or creator, or perhaps need to add/enable type information?)
         */
        t = mapper.readValue( json, MyMain.class );
        if( !t.s1.equals( "1" ) || !t.s2.equals( "2" ) )
            throw new RuntimeException();
        System.out.println( "Success!" );
    }

    public final String s1;
    public final String s2;

    public MyMain( String s1, String s2 )
    {
        this.s1 = s1;
        this.s2 = s2;
    }
}

以下是发生的事情：

如果我使用mvn clean compile编译程序，然后在Idea中运行或调试它，它可以正常工作并显示＆＃34;成功！＆＃34;。
如果我做＆＃34;重建项目＆＃34;从Intellij Idea中，然后我运行/调试，它失败了JsonMappingException＆＃34;没有为简单类型找到合适的构造函数jsontest.MyMain＆＃34;。
奇怪的是（对我而言），ObjectMapper实例化之前的代码检查以确保构造函数参数名称存在且有效，从而有效地确保了＆＃34; -parameters＆＃34;参数已成功传递给编译器，并且这些检查总是通过！
如果我编辑我的＆＃34;调试配置＆＃34;在Idea和＃34;发布之前＆＃34;我删除＆＃34;制作＆＃34;我用＃34替换它;运行maven目标＆＃34; compile然后我可以在Idea中成功运行我的程序，但我不想这样做。（而且，它甚至不能很好地工作，我想我必须做错了什么：经常我跑，它失败的原因与上面相同，下次我运行成功。）

所以，这是我的问题：

为什么我的程序在使用maven编译时的行为与使用Idea编译时的行为不同？
- 更具体地说：鉴于我的断言证明了＆＃34; -parameters＆＃34;参数是传递给编译器，参数做有名字吗？
我可以做什么让Idea以与maven相同的方式编译我的程序（至少在手头的问题方面）没有取代Idea＆＃39; s＆＃34;使＆＃34;
为什么当我更换默认值＆＃34; Make＆＃34;用＆＃34;运行maven目标＆＃34;在Idea的调试配置中compile？（我做错了什么？）

修改

我很抱歉，assert离子并不一定证明什么，因为它们不一定是-enableassertions启用的。我用if() throw RuntimeException()替换它们以避免混淆。

Answer 1

据我在IntelliJ Community edition sources中看到，IntelliJ对您指定的compilerArgs没有做任何事情。

在MavenProject.java中，有两个地方正在阅读compilerArgs：

Element compilerArguments = compilerConfiguration.getChild("compilerArgs");
if (compilerArguments != null) {
  for (Element element : compilerArguments.getChildren()) {
    String arg = element.getValue();
    if ("-proc:none".equals(arg)) {
      return ProcMode.NONE;
    }
    if ("-proc:only".equals(arg)) {
      return ProcMode.ONLY;
    }
  }
}

和

Element compilerArgs = compilerConfig.getChild("compilerArgs");
if (compilerArgs != null) {
  for (Element e : compilerArgs.getChildren()) {
    if (!StringUtil.equals(e.getName(), "arg")) continue;
    String arg = e.getTextTrim();
    addAnnotationProcessorOption(arg, res);
  }
}

第一个代码块只查看-proc:参数，因此可以忽略此块。第二个是将arg元素（您指定的）的值传递给addAnnotationProcessorOption方法。

private static void addAnnotationProcessorOption(String compilerArg, Map<String, String> optionsMap) {
  if (compilerArg == null || compilerArg.trim().isEmpty()) return;

  if (compilerArg.startsWith("-A")) {
    int idx = compilerArg.indexOf('=', 3);
    if (idx >= 0) {
      optionsMap.put(compilerArg.substring(2, idx), compilerArg.substring(idx + 1));
    } else {
      optionsMap.put(compilerArg.substring(2), "");
    }
  }
}

此方法仅处理以-A开头的参数，这些参数用于将选项传递给注释处理器。其他参数被忽略。

目前，在IntelliJ中运行源代码的唯一方法是在＆＃34;附加命令行参数中自己启用标记＆＃34;编译器设置的字段（不可移植），或者通过编译maven作为运行配置中的预制步骤。如果您希望自动在IntelliJ中实现这一点，则可能必须向Jetbrains提出问题。

JSON ObjectMapper与javac＆＃34; -parameters＆＃34;通过maven运行时的行为，而不是通过InteliJ IDEA

1 个答案: