⑴ 用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
}