我经常推荐 Groovy 的 @Immutable AST 转换作为使类不可变的简单方法。这与其他 Groovy 类一起工作总是很好，但最近有人问我是否可以将这些类混合到 Java 代码中。我一直认为答案是肯定的，但我遇到了障碍。

假设我有一个不可变的 User 类:

import groovy.transform.Immutable

@Immutable
class User {
    int id
    String name
}

如果我使用用 Groovy 编写的 JUnit 测试来测试它，一切都会按预期进行:

import org.junit.Test

class UserGroovyTest {

    @Test
    void testMapConstructor() {
        assert new User(name: 'name', id: 3)
    }

    @Test
    void testTupleConstructor() {
        assert new User(3, 'name')
    }

    @Test
    void testDefaultConstructor() {
        assert new User()
    }

    @Test(expected = ReadOnlyPropertyException)
    void testImmutableName() {
        User u = new User(id: 3, name: 'name')
        u.name = 'other'
    }
}

我可以对用 Java 编写的 JUnit 测试做同样的事情:

导入静态 org.junit.Assert.*;

import org.junit.Test;

public class UserJavaTest {

    @Test
    public void testDefaultCtor() {
        assertNotNull(new User());
    }

    @Test
    public void testTupleCtor() {
        assertNotNull(new User(3, "name"));
    }

    @Test
    public void testImmutableName() {
        User u = new User(3, "name");
        // u.setName("other") // Method not found; doesn't compile
    }
}

这是有效的，尽管有一些问题即将出现。 IntelliJ 15 不喜欢调用 new User()，声称未找到构造函数。这也意味着 IDE 会用红色下划线显示该类，这意味着它存在编译错误。无论如何测试都通过了，这有点奇怪，但就这样吧。

如果我尝试直接在 Java 代码中使用 User 类，事情就会变得很奇怪。

public class UserDemo {
    public static void main(String[] args) {
        User user = new User();
        System.out.println(user);
    }
}

IntelliJ 再次不高兴，但编译并运行。所有的输出是:

User(0)

这很奇怪，因为尽管 @Immutable 转换确实生成了一个 toString 方法，但我更希望输出显示这两个属性。不过，这可能是因为 name 属性为 null，所以它未包含在输出中。

如果我尝试使用元组构造函数:

public class UserDemo {
    public static void main(String[] args) {
        User user = new User(3, "name");
        System.out.println(user);
    }
}

我明白了

User(0, name)

作为输出，至少这次(有时它根本不起作用)。

然后我添加了一个 Gradle 构建文件。如果我将 Groovy 类放在 src\main\groovy 下，将 Java 类放在 src\main\java 下(测试相同，但使用 test 文件夹)，我立即遇到编译问题:

> gradle test
error: cannot find symbol
User user = new User(...)
^

我通常通过尝试对所有内容使用 Groovy 编译器来解决此类交叉编译问题。如果我将这两个类都放在 src\main\java 下，则没有任何变化，这不足为奇。但是如果我将这两个类都放在 src\main\groovy 下，那么我会在 compileGroovy 阶段得到这个:

> gradle clean test
error: constructor in class User cannot be applied to the given types;
User user = new User(3, "name");

required: no arguments
found: int,String
reason: actual and formal arguments differ in length

嗯。这次它反对元组构造函数，因为它认为它只有一个默认构造函数。我知道转换添加了一个默认的、一个基于映射的和一个元组构造函数，但它们可能没有及时生成，Java 代码无法看到它们。

顺便说一句，如果我再次分离 Java 和 Groovy 类，并将以下内容添加到我的 Gradle 构建中:

sourceSets {
    main {
        java { srcDirs = []}
        groovy { srcDir 'src/main/java' }
    }
}

我得到了同样的错误。如果我不添加 sourceSets block ，我会收到之前的 User class not found 错误。

所以最重要的是，将 @Immutable Groovy 类添加到现有 Java 系统的正确方法是什么？有没有什么方法可以让 Java 及时生成构造函数以查看它们？

多年来，我一直在向 Java 开发人员介绍 Groovy，并说你可以做到这一点，但现在却遇到了问题。请帮我挽回面子。 :)

最佳答案

我也试过你的场景，你有一个带有 src/main/java 的项目和一个 src/main/groovy目录并以类似于您所见的编译错误告终。

当我将 Groovy 不可变对象(immutable对象)与 Java 代码放在一个单独的项目中时，我就能够在 Java 中使用 Groovy 不可变对象(immutable对象)。我创建了一个简单的示例并将其推送到 GitHub (https://github.com/cjstehno/immut)。

基本上它是一个 Gradle 多项目，所有 Groovy 代码(不可变对象(immutable对象))都在 immut-groovy 中immut-java 中的子项目和所有 Java 代码项目。 immut-java项目取决于 immut-groovy项目并使用不可变的 Something对象:

public class SomethingFactory {

    Something createSomething(int id, String label){
        return new Something(id, label);
    }
}

我在 Java 项目中添加了一个单元测试，它创建了一个不可变的 Groovy 类的新实例并验证了它的内容。

public class SomethingFactoryTest {
    @Test
    public void createSomething(){
        Something something = new SomethingFactory().createSomething(42, "wonderful");

        assertEquals(something.getId(), 42);
        assertEquals(something.getLabel(), "wonderful");
    }
}

这不是很理想，但确实有效。

关于java - Java 中的 Groovy @Immutable 类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33767411/