js里怎么调用java代码

在JavaScript中调用Java代码，可以使用以下几种方法：通过Java插件、利用WebSocket、通过REST API。 其中，利用REST API 是最常用且最灵活的方法。通过REST API，可以在Java后端创建服务端点，然后在JavaScript中使用AJAX或Fetch API调用这些端点，从而实现JavaScript与Java代码的交互。

利用REST API的详细描述：首先，在Java后端创建一个RESTful服务，通过定义控制器和路由来处理HTTP请求。然后，前端的JavaScript代码可以使用AJAX或Fetch API发送HTTP请求，调用这些服务端点，并处理返回的响应数据。这种方法不仅解耦了前后端，还使得代码更易于维护和扩展。

一、通过REST API调用Java代码

1、创建Java RESTful 服务

在Java后端，使用Spring Boot可以非常方便地创建RESTful服务。以下是一个简单的示例：

import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api")
public class MyController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Java!";
    }
}

在上面的代码中，我们定义了一个名为MyController的控制器，它处理/api/hello路径的GET请求，并返回一个简单的字符串。

2、在前端使用Fetch API调用RESTful 服务

在前端的JavaScript代码中，可以使用Fetch API来调用上述RESTful服务：

fetch('http://localhost:8080/api/hello')
    .then(response => response.text())
    .then(data => {
        console.log(data); // 输出 "Hello from Java!"
    })
    .catch(error => {
        console.error('Error:', error);
    });

通过这种方式，前端JavaScript代码可以轻松地调用Java后端服务，并处理返回的数据。

二、通过WebSocket实现实时通信

1、在Java后端创建WebSocket服务

使用Spring Boot可以很容易地创建一个WebSocket服务：

import org.springframework.web.socket.config.annotation.*;
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/ws");
    }
}

同时定义一个WebSocket处理器：

import org.springframework.web.socket.*;
public class MyWebSocketHandler extends TextWebSocketHandler {
    @Override
    public void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        session.sendMessage(new TextMessage("Hello from WebSocket!"));
    }
}

2、在前端使用WebSocket API

在前端的JavaScript代码中，可以使用WebSocket API来连接并与WebSocket服务进行通信：

const socket = new WebSocket('ws://localhost:8080/ws');
socket.onopen = function(event) {
    console.log('WebSocket is open now.');
    socket.send('Hello Server!');
};
socket.onmessage = function(event) {
    console.log('Message from server ', event.data);
};
socket.onclose = function(event) {
    console.log('WebSocket is closed now.');
};
socket.onerror = function(error) {
    console.error('WebSocket Error: ', error);
};

通过这种方式，前端JavaScript代码可以与Java后端进行实时通信。

三、通过Java插件调用Java代码

1、使用Java Applet

Java Applet是一种嵌入在网页中的Java程序，但由于安全性问题和浏览器支持的逐渐减少，这种方法已不再推荐使用。以下是一个简单的示例：

<applet code="MyApplet.class" width="300" height="300">
    <param name="message" value="Hello from Java Applet!">
</applet>

在Java中定义Applet类：

import java.applet.Applet;
import java.awt.Graphics;
public class MyApplet extends Applet {
    private String message;
    public void init() {
        message = getParameter("message");
    }
    public void paint(Graphics g) {
        g.drawString(message, 20, 20);
    }
}

2、使用Nashorn引擎

Java 8引入了Nashorn引擎，可以在JVM中运行JavaScript代码。以下是一个示例：

import javax.script.*;
public class NashornExample {
    public static void main(String[] args) throws ScriptException {
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
        engine.eval("print('Hello from JavaScript running on JVM!')");
    }
}

以上方法可以在特定场景下使用，但在现代Web开发中，使用REST API和WebSocket是更为推荐的方式。

四、通过RMI调用远程Java对象

1、在Java后端创建RMI服务

首先定义一个远程接口：

import java.rmi.Remote;
import java.rmi.RemoteException;
public interface MyRemoteService extends Remote {
    String sayHello() throws RemoteException;
}

然后实现该接口：

import java.rmi.server.UnicastRemoteObject;
public class MyRemoteServiceImpl extends UnicastRemoteObject implements MyRemoteService {
    protected MyRemoteServiceImpl() throws RemoteException {
        super();
    }
    @Override
    public String sayHello() throws RemoteException {
        return "Hello from RMI!";
    }
}

接着在服务器端注册该服务：

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
    public static void main(String[] args) {
        try {
            MyRemoteService service = new MyRemoteServiceImpl();
            Registry registry = LocateRegistry.createRegistry(1099);
            registry.bind("MyRemoteService", service);
            System.out.println("RMI service started.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2、在JavaScript中调用RMI服务

由于JavaScript本身无法直接调用RMI服务，需要在中间层（例如Node.js）中进行处理，然后再通过REST API或WebSocket与JavaScript交互。以下是一个Node.js示例：

const fetch = require('node-fetch');
fetch('http://localhost:8080/api/hello')
    .then(response => response.text())
    .then(data => {
        console.log(data); // "Hello from Java!"
    })
    .catch(error => {
        console.error('Error:', error);
    });

通过这种方式，可以在JavaScript中间接调用Java RMI服务。

五、通过JMS实现消息传递

1、在Java后端配置JMS

配置一个JMS消息队列，如ActiveMQ，并创建一个消息生产者：

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;
public class JMSProducer {
    public static void main(String[] args) throws JMSException {
        ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = factory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue("testQueue");
        MessageProducer producer = session.createProducer(destination);
        TextMessage message = session.createTextMessage("Hello from JMS!");
        producer.send(message);
        connection.close();
    }
}

2、在前端使用WebSocket与JMS交互

可以通过WebSocket与JMS进行交互，以下是一个Node.js示例：

const WebSocket = require('ws');
const ws = new WebSocket('ws://localhost:8080/ws');
ws.on('open', function open() {
    ws.send('Hello from WebSocket!');
});
ws.on('message', function incoming(data) {
    console.log(data); // "Hello from JMS!"
});

通过上述方法，可以实现JavaScript与Java代码的多种交互方式，选择最适合自己项目的方式进行集成。对于团队项目管理和协作，可以使用研发项目管理系统PingCode和通用项目协作软件Worktile来提升效率和协作体验。