⑴ 用java如何实现终端机和服务器通讯
通讯简单的http请求就可以呀
要是说获取重量
类型那些东西，就需要对应传感器了，是硬件工程师做的，你和他们订好传输协议，按协议接收就好了。
再看看别人怎么说的。
⑵ 在java网络编程中，客户端/服务器怎么实现不同电脑之间的通信
1、首先两台电脑和服务器都在同一个网络中
2、相互之间可以用sokect<--->server
相互进行通信
⑶ java中，怎样实现cs模式的服务器与客户端的通信
Socket通信：
作为服务器端:
//生成服务器端,监听服务器设定的端口
ServerSocket
socketServer
=
new
ServerSocket(端口号);
//建立客户端和服务器端的链接，这时再看客户端
Socket
socket
=
socketServer.accept();
作为客户端:
//新建一个Socket，包含服务器端的IP和端口号，这样在服务器启动情况下可以建立和服务器的链接.
Socket
socket
=
new
Socket（"IP地址","端口号"）;
这时,服务器端和客户端的连接已经建立,如果需要通信和传输数据的话分别在服务器端、客户端新建流对象，可以通过流对象实现双方之间的互通.
有关流的内容自己看书体会下就能写出B/S结构的通信了。
⑷ java网络编程应该怎样在客户端和服务器间实现通信
以前写的，照贴了。。。服务器端：import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.*;
import java.net.*;/*6、 采用UDP协议，编写一个Java网络应用程序，该应用分服务器端程序和客户端程序两部分。
* 客户端指定一个服务器上的文件名，让服务器发回该文件的内容，或者提示文件不存在。
* （20分）（服务端程序和客户端程序分别命名为Server.java和Client.java）*/
public class N4BT6 extends Frame
{
DatagramSocket socket ;
DatagramPacket packet ;byte[] buf ;
File file ;
FileInputStream input;
String message = "该文件不存在";
TextArea text;
public N4BT6(String title)
{
super(title);
text = new TextArea(6,4);
add(text);
setSize(400, 300);
setVisible(true);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
}
});
buf = new byte[1024];
try
{
socket = new DatagramSocket(1230);
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
file = new File(new String(packet.getData()));
socket = new DatagramSocket();
}
catch (Exception e)
{e.printStackTrace();
}
if(file.exists())
{
try
{
buf = new byte[(int)file.length()];
packet = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),1234);
input = new FileInputStream(file);
input.read(buf);
socket.send(packet);
}
catch (IOException e)
{
e.printStackTrace();
}
}
else
{
try
{
packet = new DatagramPacket(message.getBytes(),message.getBytes().length,
InetAddress.getLocalHost(),1234);
socket.send(packet);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public static void main(String[] args)
{
new N4BT6("Server");
}
}
客户端：import java.awt.*;
import java.awt.event.*;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;public class N4BT6_2 extends Frame
{
TextArea text;
String message = "Q.txt";
DatagramSocket socket ;
DatagramPacket packet;
byte[] buf;
public N4BT6_2(String title)
{
super(title);
text = new TextArea(6,4);
add(text);
setSize(400, 300);
setVisible(true);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
}
});
try
{
socket = new DatagramSocket();
packet = new DatagramPacket(message.getBytes(),message.getBytes().length,
InetAddress.getLocalHost(),1230);
socket.send(packet);
}
catch (Exception e)
{
e.printStackTrace();
}
try
{
buf = new byte[1024];
socket = new DatagramSocket(1234);
packet = new DatagramPacket(buf,buf.length);
socket.receive(packet);
text.append(new String(buf));
}
catch (Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new N4BT6_2("Client");
}
}
⑸ java 服务器怎样给客户端传输数据
java需要利用scoket实现网络通信，在通信时可以利用是从客厅、获取输入输出流达到传输数据效果
⑹ JAVA服务端android客户端如何通信
从服务器写一个字符串过去可以这样：String p = "-1,2,5";
发过去以后，将字符串分隔开，String[] ss = p.split(",");
数组里面的元素就是位置的三个坐标了。
但鉴于你可能发送多种类型的数据，你可以写一个协议，举例说就是，String p ="P,-1,2,5";
分隔出来以后，可以根据数组里面的第一个值判断是什么类型的数据，在执行相关的操作。
⑺ java写的客户端怎么和服务器端通信
写个简单点的服务器跟客服端就行了我写了个很简单的，只能在一个客户端跟一个服务器通信，在控制台输入下面这个是服务器import java.io.*;
import java.net.*;
import java.util.Scanner;public class Server
{
public static void main(String[] args)
{
try {
ServerSocket server=new ServerSocket(8888);//定义客户端的端口号
Socket client=server.accept();//定义一个Socket对象
InputStream is=client.getInputStream();//服务器接受信息输入流，也就是接受从服务器段发送过来的消息
BufferedReader br=new BufferedReader(new InputStreamReader(is));//用bufferedreader包装下输入流
OutputStream os=client.getOutputStream();//这是用来给服务器发送消息的输出流
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);//从键盘输入字符串
boolean flag=true;//定义一个死循环，让服务器不停的接受从客户端发送来的字符串
while(flag)
{
String s=br.readLine();//s是从客户端接受到得字符串
System.out.println(s);
String s2=scanner.nextLine();//s2是写给客户端的字符串
ps.println(s2); //给客户端发送你写的东西
}
client.close();
} catch (IOException e) {//try 跟catch你不用管，这是用来处理异常的，就是固定格式
e.printStackTrace();
}
}
} 下面是客户端import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client
{ public static void main(String[] args)
{
try
{
Socket client=new Socket("192.168.--.--",8888);//IP地址是个字符串，端口号是个整数，这个端口号要跟前面你写的那个一样，还有IP地址，写你的机器的IP地址
InputStream is=client.getInputStream();//这边的两个流跟上面服务器的差不多的作用
BufferedReader bf=new BufferedReader(new InputStreamReader(is));
OutputStream os=client.getOutputStream();
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);
boolean flag=true;
while(flag)//这句话可以让客户端不停的说话
⑻ 两java服务端之间通信方式有哪些
JAVA进程间通信的方法主要有以下几种： （1）管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 （2）命名管道（named pipe）：命名管道克服了管道没有名字的限制
⑼ java socket服务器怎么给客户端发信息
服务器端和客户端都是通过SOCKET来进行通信的,首先产生一个
socket实例,通过这个实例,服务器端调用accept这个方法接收来自客户端发送的信息.但是在产生socket实例的时候必须初始化一个端口.用来负责接受客户端的请求！
客户端要给服务器发送消息也必须产生一个socket实例，初始化的时候必须指定服务器的IP地址，并且指定服务接收的端口号,这样客户端才能找到服务器要接收的地方，找到地方就可以发送过去了。和你写信一样。找到地址
BufferedReader
in
=
new
BufferedReader(new
InputStreamReader(socket.getInputStream()));
PrintWriter
out
=
new
PrintWriter(socket.getOutputStream());
BufferedReader
wt
=
new
BufferedReader(new
InputStreamReader(System.in));
这个只是用来获取一个从键盘的一个流.传送给服务器端的数据都是通过流来表示的。意思是是键盘输入的一个字节转化成字符流.并输出或者写入！
⑽ java中利用输入流与输出流实现服务器与客户端通信有哪些方法
可以用TCP或UDP协议。两者不同之处在于，TCP要建立服务器客户端必须和服务器连接，才能和其他客户进行联系。
但UDF不需要，只要知道对方的IP和端口，就可以连接任何一台客户端。
想这样类似QQ的代码很多，晚上搜一下就有。这里给一个客户端和服务器。
-------------------
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
class myframe extends Frame implements ActionListener,WindowListener,Runnable,KeyListener
{
Thread mythread = new Thread(this);
Socket mysocket;
DataInputStream in;
DataOutputStream out;
Label label_ip = new Label("IP");
Label label_port = new Label("Port");
TextField text_ip = new TextField("127.1.1.0",15);
TextField text_port = new TextField("8888",15);
Button button_connect = new Button("连接");
TextArea text_area_show = new TextArea();
TextField text_send = new TextField(45);
Button button_send = new Button("发送");
myframe()
{
Panel panel1 = new Panel();
Panel panel2 = new Panel();
panel1.setLayout(new FlowLayout());
panel1.add(label_ip);
panel1.add(text_ip);
panel1.add(label_port);
panel1.add(text_port);
panel1.add(button_connect);
panel2.setLayout(new FlowLayout());
panel2.add(text_send);
panel2.add(button_send);
add(panel1,BorderLayout.NORTH);
add(text_area_show,BorderLayout.CENTER);
add(panel2,BorderLayout.SOUTH);
text_send.addKeyListener(this);
button_connect.addActionListener(this);
button_send.addActionListener(this);
addWindowListener(this);
this.setTitle("客户端");
setBounds(200,200,400,350);
setVisible(true);
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == button_connect)
{
try
{
String ip = null,port = null;
ip = text_ip.getText();
port = text_port.getText();
mysocket = new Socket(ip, Integer.parseInt(port));
in = new DataInputStream(mysocket.getInputStream());
out = new DataOutputStream(mysocket.getOutputStream());
}
catch (UnknownHostException ex)
{
Logger.getLogger(myframe.class.getName()).log(Level.SEVERE, null, ex);
}
catch (IOException ex)
{
Logger.getLogger(myframe.class.getName()).log(Level.SEVERE, null, ex);
}
mythread.start();
}
if(e.getSource() == button_send)
{
if(mysocket.isConnected() == true)
{
String temp = null;
temp = text_send.getText();
try
{
out.writeUTF(temp);
text_send.setText(null);
}
catch (IOException ex)
{
Logger.getLogger(myframe.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
public void run()
{
while(true)
{
String temp = null;
try
{
temp = in.readUTF();
}
catch (IOException ex)
{
text_area_show.append("服务器退出\n");
return;
}
temp += "\n";
text_area_show.append(temp);
}
}
public void keyPressed(KeyEvent e)
{
if(e.getKeyCode() == KeyEvent.VK_ENTER)
{
String temp = null;
temp = text_send.getText();
try
{
out.writeUTF(temp);
}
catch (IOException ex)
{
Logger.getLogger(myframe.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
public void windowOpened(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
public void keyTyped(KeyEvent e) {}
public void keyReleased(KeyEvent e) {}
}
public class mywindow
{
public static void main(String argv[])
{
myframe f = new myframe();
}
}
--------------------------------
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JTextArea;
class RecvMegSock extends Thread
{
LinkedList SocketList = null;
Socket ClientSock = null;
JTextArea jTextArea1;
RecvMegSock(LinkedList list,Socket s,JTextArea t)
{
SocketList = list;
jTextArea1 = t;
ClientSock = s;
start();
}
public void run()
{
while(true)
{
try
{
DataInputStream in = new DataInputStream(ClientSock.getInputStream());
String word = in.readUTF();
jTextArea1.setText(jTextArea1.getText() + word + "\n");
for(int i = 0;i < SocketList.size();i++)
{
Socket s = (Socket)SocketList.get(i);
DataOutputStream out = new DataOutputStream(s.getOutputStream());
out.writeUTF(word);
}
}
catch (IOException ex)
{
for(int i = 0;i < SocketList.size();i++)
{
Socket s = (Socket)SocketList.get(i);
if(s == ClientSock)
SocketList.remove(s);
}
for(int i = 0;i < SocketList.size();i++)
{
Socket s = (Socket)SocketList.get(i);
try
{
DataOutputStream out = new DataOutputStream(s.getOutputStream());
out.writeUTF(ClientSock.getInetAddress() + "已经退出!!\n");
}
catch (IOException ex1)
{
Logger.getLogger(RecvMegSock.class.getName()).log(Level.SEVERE, null, ex1);
}
}
jTextArea1.setText(jTextArea1.getText() + ClientSock.getInetAddress() + "已经退出!!" + "\n");
return;
}
}
}
}
class AcceptSockThread extends Thread
{
ServerSocket ServerSock = null;
LinkedList SocketList = null;
JTextArea TextArea;
AcceptSockThread(ServerSocket s,LinkedList list,JTextArea t)
{
ServerSock = s;
SocketList = list;
TextArea = t;
start();
}
public void run()
{
while(true)
{
Socket ClientSock = null;
try
{
boolean same = false;
ClientSock = ServerSock.accept(); /*
for(int i = 0;i < SocketList.size();i++)
{
Socket s = (Socket)SocketList.get(i);
if(s.getInetAddress().equals(ClientSock.getInetAddress()) && s.getPort() == ClientSock.getPort())
{
DataOutputStream out = new DataOutputStream(s.getOutputStream());
out.writeUTF(ClientSock.getInetAddress() + "你已经连接了服务器！！\n");
same = true;
}
}
if(same == true)
continue;
*/
new RecvMegSock(SocketList,ClientSock,TextArea);
SocketList.add(ClientSock);
for(int i = 0;i < SocketList.size();i++)
{
Socket s = (Socket)SocketList.get(i);
DataOutputStream out = new DataOutputStream(s.getOutputStream());
out.writeUTF(ClientSock.getInetAddress() + "成功连接服务器\n");
}
TextArea.setText(TextArea.getText() + ClientSock.getInetAddress() + "连接到服务器\n");
}
catch (IOException ex)
{
Logger.getLogger(AcceptSockThread.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
public class ServerDialog extends javax.swing.JDialog
{
ServerSocket Server = null;
LinkedList SocketList = null;
public ServerDialog(java.awt.Frame parent, boolean modal)
{
super(parent, modal);
initComponents();
try
{
Server = new ServerSocket(8888);
SocketList = new LinkedList();
new AcceptSockThread(Server,SocketList,jTextArea1);
}
catch (IOException ex)
{
Logger.getLogger(ServerDialog.class.getName()).log(Level.SEVERE, null, ex);
}
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
jTextField1 = new javax.swing.JTextField();
jButton1 = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
getContentPane().setLayout(null);
jTextArea1.setColumns(20);
jTextArea1.setEditable(false);
jTextArea1.setRows(5);
jScrollPane1.setViewportView(jTextArea1);
getContentPane().add(jScrollPane1);
jScrollPane1.setBounds(10, 10, 380, 250);
getContentPane().add(jTextField1);
jTextField1.setBounds(10, 270, 290, 21);
jButton1.setText("发送");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
getContentPane().add(jButton1);
jButton1.setBounds(310, 270, 80, 25);
pack();
}// </editor-fold>//GEN-END:initComponents
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
if(SocketList.size() == 0)
{
jTextArea1.setText(jTextArea1.getText() + "没有人连接!!" + "\n");
return;
}
for(int i = 0;i < SocketList.size();i++)
{
DataOutputStream out;
try
{
out = new DataOutputStream(((Socket) SocketList.get(i)).getOutputStream());
if(jTextField1.getText() != null)
out.writeUTF(jTextField1.getText());
}
catch (IOException ex)
{
Logger.getLogger(ServerDialog.class.getName()).log(Level.SEVERE, null, ex);
}
}
jTextArea1.setText(jTextArea1.getText() + jTextField1.getText() + "\n");
}//GEN-LAST:event_jButton1ActionPerformed
public static void main(String args[])
{
ServerDialog dlg = new ServerDialog(null,true);
dlg.setBounds(300, 200, 400, 325);
dlg.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
dlg.setVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton jButton1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
private javax.swing.JTextField jTextField1;
// End of variables declaration//GEN-END:variables
}