SpringBoot应用中调用NodeJS脚本并传递、修改Java对象后返回的方法

核心思路 #

Java和NodeJS属于不同运行时，无法直接传递内存对象，需通过JSON序列化/反序列化实现对象的传递与修改：

• Java端将Address对象序列化为JSON字符串传给NodeJS脚本
• NodeJS脚本解析JSON、修改数据后，再序列化为JSON返回给Java
• Java端将返回的JSON反序列化为Address对象

具体实现步骤 #

1. 准备Address实体类 #

确保实体类支持JSON序列化（SpringBoot默认自带Jackson）：

import com.fasterxml.jackson.annotation.JsonProperty;

public class Address {
    @JsonProperty("street")
    private String street;
    @JsonProperty("city")
    private String city;

    // 无参构造器，Jackson反序列化必需
    public Address() {}

    public Address(String street, String city) {
        this.street = street;
        this.city = city;
    }

    // getter、setter方法
    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }

    @Override
    public String toString() {
        return "Address{street='" + street + "', city='" + city + "'}";
    }
}

2. 编写NodeJS脚本（示例：modify-address.js） #

脚本从标准输入读取JSON，修改后输出到标准输出：

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false
});

rl.on('line', (line) => {
    try {
        const address = JSON.parse(line);
        // 修改Address属性
        address.street = "Updated " + address.street;
        address.city = "Updated " + address.city;
        // 输出修改后的JSON
        console.log(JSON.stringify(address));
    } catch (err) {
        console.error(JSON.stringify({error: err.message}));
        process.exit(1);
    }
});

3. SpringBoot中实现调用工具类 #

用ProcessBuilder启动Node进程，处理输入输出：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

@Component
public class NodeScriptInvoker {
    private final ObjectMapper objectMapper = new ObjectMapper();

    public <T> T invokeJS(String scriptPath, T inputObject, Class<T> outputClass) throws IOException {
        // 构建Node进程命令
        ProcessBuilder pb = new ProcessBuilder("node", scriptPath);
        Process process = pb.start();

        // 写入序列化后的JSON
        try (OutputStreamWriter writer = new OutputStreamWriter(process.getOutputStream())) {
            objectMapper.writeValue(writer, inputObject);
            writer.flush();
            process.getOutputStream().close(); // 告知Node输入结束
        }

        // 读取脚本输出
        StringBuilder output = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                output.append(line);
            }
        }

        // 检查进程退出状态
        try {
            int exitCode = process.waitFor();
            if (exitCode != 0) {
                StringBuilder errorOutput = new StringBuilder();
                try (BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()))) {
                    String line;
                    while ((line = errorReader.readLine()) != null) {
                        errorOutput.append(line);
                    }
                }
                throw new IOException("Node脚本执行失败，退出码：" + exitCode + "，错误信息：" + errorOutput);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IOException("进程被中断", e);
        }

        // 反序列化输出为Java对象
        return objectMapper.readValue(output.toString(), outputClass);
    }
}

4. 在Services类中调用 #

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;

@Service
public class Services {
    @Autowired
    private NodeScriptInvoker scriptInvoker;

    public void modifyAddress() throws IOException {
        Address address = new Address("Main Street", "New York");
        // 调用Node脚本并获取修改后的对象
        address = scriptInvoker.invokeJS("/path/to/modify-address.js", address, Address.class);
        System.out.println("modified address: " + address.toString());
    }
}

注意事项 #

• 确保服务器已安装NodeJS，且node命令在系统PATH中可访问
• 处理大对象时需关注性能与内存占用，必要时分块处理
• 完善异常捕获，覆盖脚本执行失败、JSON序列化/反序列化错误等场景
• 复杂交互场景可考虑IPC框架，简单场景用标准输入输出+JSON即可满足需求

内容的提问来源于stack exchange，提问作者Fossil