當前位置:首頁 » 雲伺服器 » 伺服器和客戶端怎麼實現通訊

伺服器和客戶端怎麼實現通訊

發布時間: 2022-06-24 14:33:09

『壹』 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)//這句話可以讓客戶端不停的說話
{
String s2=scanner.nextLine();
ps.println(s2);

String s=bf.readLine();
System.out.println(s); }

client.close();

}
catch (UnknownHostException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
} }}

『貳』 客戶端與伺服器端的通訊,C++書寫步驟。

C++通過socket編程實現服務端與客戶端的通訊,代碼如下(個人環境下測試正常,如果遇到運行send發送報錯,請檢查伺服器埠是否被佔用,調試的時候請先運行服務端程序在運行客服端,一定要載入庫函數ws2_32.lib,發送字元時應該多加一個空字元作為結束字元):

伺服器端程序:

//Server.cpp:.
#include"winsock2.h"
#pragmacomment(lib,"ws2_32.lib")
#include<iostream>
usingnamespacestd;
intmain(intargc,char*argv[])
{
constintBUF_SIZE=64;
WSADATAwsd;//WSADATA變數
SOCKETsServer;//伺服器套接字
SOCKETsClient;//客戶端套接字
SOCKADDR_INaddrServ;;//伺服器地址
charbuf[BUF_SIZE];//接收數據緩沖區
charsendBuf[BUF_SIZE];//返回給客戶端得數據
intretVal;//返回值
//初始化套結字動態庫
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
cout<<"WSAStartupfailed!"<<endl;
return1;
}

//創建套接字
sServer=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sServer)
{
cout<<"socketfailed!"<<endl;
WSACleanup();//釋放套接字資源;
return-1;
}

//伺服器套接字地址
addrServ.sin_family=AF_INET;
addrServ.sin_port=htons(4999);
addrServ.sin_addr.s_addr=INADDR_ANY;
//綁定套接字
retVal=bind(sServer,(LPSOCKADDR)&addrServ,sizeof(SOCKADDR_IN));
if(SOCKET_ERROR==retVal)
{
cout<<"bindfailed!"<<endl;
closesocket(sServer);//關閉套接字
WSACleanup();//釋放套接字資源;
return-1;
}

//開始監聽
retVal=listen(sServer,1);
if(SOCKET_ERROR==retVal)
{
cout<<"listenfailed!"<<endl;
closesocket(sServer);//關閉套接字
WSACleanup();//釋放套接字資源;
return-1;
}

//接受客戶端請求
sockaddr_inaddrClient;
intaddrClientlen=sizeof(addrClient);
sClient=accept(sServer,(sockaddrFAR*)&addrClient,&addrClientlen);
if(INVALID_SOCKET==sClient)
{
cout<<"acceptfailed!"<<endl;
closesocket(sServer);//關閉套接字
WSACleanup();//釋放套接字資源;
return-1;
}

while(true)
{
//接收客戶端數據
ZeroMemory(buf,BUF_SIZE);
retVal=recv(sClient,buf,BUF_SIZE,0);
if(SOCKET_ERROR==retVal)
{
cout<<"recvfailed!"<<endl;
closesocket(sServer);//關閉套接字
closesocket(sClient);//關閉套接字
WSACleanup();//釋放套接字資源;
return-1;
}
if(buf[0]=='0')
break;
cout<<"客戶端發送的數據:"<<buf<<endl;

cout<<"向客戶端發送數據:";
cin>>sendBuf;

send(sClient,sendBuf,strlen(sendBuf),0);
}

//退出
closesocket(sServer);//關閉套接字
closesocket(sClient);//關閉套接字
WSACleanup();//釋放套接字資源;

return0;
}

客戶端程序:

#include"winsock2.h"
#include<iostream>
#pragmacomment(lib,"ws2_32.lib")

usingnamespacestd;
BOOLRecvLine(SOCKETs,char*buf);//讀取一行數據

intmain(intargc,char*argv[])
{
constintBUF_SIZE=64;

WSADATAwsd;//WSADATA變數
SOCKETsHost;//伺服器套接字
SOCKADDR_INservAddr;//伺服器地址
charbuf[BUF_SIZE];//接收數據緩沖區
charbufRecv[BUF_SIZE];
intretVal;//返回值
//初始化套結字動態庫
if(WSAStartup(MAKEWORD(2,2),&wsd)!=0)
{
cout<<"WSAStartupfailed!"<<endl;
return-1;
}
//創建套接字
sHost=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==sHost)
{
cout<<"socketfailed!"<<endl;
WSACleanup();//釋放套接字資源
return-1;
}

//設置伺服器地址和埠
servAddr.sin_family=AF_INET;
servAddr.sin_addr.s_addr=inet_addr("127.0.0.1");
servAddr.sin_port=htons((short)4999);
intnServAddlen=sizeof(servAddr);

//連接伺服器
retVal=connect(sHost,(LPSOCKADDR)&servAddr,sizeof(servAddr));
if(SOCKET_ERROR==retVal)
{
cout<<"connectfailed!"<<endl;
closesocket(sHost);//關閉套接字
WSACleanup();//釋放套接字資源
return-1;
}
while(true)
{
//向伺服器發送數據
ZeroMemory(buf,BUF_SIZE);
cout<<"向伺服器發送數據:";
cin>>buf;
retVal=send(sHost,buf,strlen(buf),0);
if(SOCKET_ERROR==retVal)
{
cout<<"sendfailed!"<<endl;
closesocket(sHost);//關閉套接字
WSACleanup();//釋放套接字資源
return-1;
}
//RecvLine(sHost,bufRecv);
ZeroMemory(bufRecv,BUF_SIZE);
recv(sHost,bufRecv,BUF_SIZE,0);//接收伺服器端的數據,只接收5個字元
cout<<endl<<"從伺服器接收數據:"<<bufRecv;
cout<<" ";
}
//退出
closesocket(sHost);//關閉套接字
WSACleanup();//釋放套接字資源
return0;
}

『叄』 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中利用輸入流與輸出流實現伺服器與客戶端通信有哪些方法

可以用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

}

『伍』 進程之間的客戶端與服務端是如何實現通訊的

首先,為了便於理解,我們一般把網路分為多個層次,這個層次的概念是很重要的基礎概念,你可以參考閱讀經典的謝希仁老師翻譯的《計算機網路》。 在進程之間的網路通信一般都是在「網路層」即IP層,我們編寫程序一般也都是基於這個層次或者這個層次之上的傳輸層或者應用層。語言(實際上是操作系統和庫函數)提供了封裝好的函數,讓我們可以不用關心鏈路層以及物理層的細節。 下面逐一回答你的問題: 1)初始化網路環境是什麼意思,有什麼作用? 為了建立通信連接,我們需要明確當前的網路環境是怎樣的,因為和單機系統的進程通信不同,網路進程間通信比較復雜,而且操作系統支持的網路協議也會很多,不同協議的工作方式不同,地址格式也不同。為了解決多重協議的識別問題,我們必須引入一些用於區分的概念並對其初始化。 2)套接字的意思和作用是什麼? 套接字提供了對網路連接的一系列封裝——雖然你可以自己寫,但完全沒有必要不是么?它根據指定的地址族、數據類型和協議來分配一個套介面的描述字及其所用的資源。例如TCP/IP的socket提供三種類型套接字(流式、數據報、原始),分別對應面向連接的服務(例如FTP)、無連接服務(例如NFS)和較底層的連接服務(例如IP或者自定義協議),你可以基於套接字提供的封裝比較方便的實現網路連接服務。 在IP層次以上網路通信的基本原理和電話或者電報的基本原理是非常相近的。TCP連接類似電話,UDP連接類似電報。 下面我以一些代碼片段(注意是幫助理解的片段,不能編譯執行)簡單地對其進行類比: fd = socket(AF_INET, SOCK_STREAM, 0); address.sin_family = AF_INET; address.sin_addr.s_addr = htonl(INADDR_ANY); address.sin_port = htons(1234); address_len = sizeof(address); //這就是在初始化網路環境,類似於你朋友買了一個電話,同時到電信公司申請了號碼,然後登記的分機是1234 bind(fd, (struct sockaddr *)&address, address_len); //好了,這是做了一個bind(綁定),類似於電信公司把電話號碼和你朋友家的哪個埠線連上了。 listenfd = listen(fd, 64) while(1){ ....一系列等待客戶端的操作,從略 } //這里在伺服器端一般會有一個無限循環,伺服器會一直等待來自客戶端的消息,類似於你朋友一直在等待你的電話。客戶端,類似的也有買電話(socket創建)和初始化,我就不寫了,預先設定好你要撥打的分機號碼是1234 rtval = connect(fd, (struct sockaddr *)&address, address_len); //上面的語句表示開始撥打電話了: //如果你的朋友接了電話,通話建立了(上面語句的返回值rtval不為-1),你就可以講話: writen(fd, (void *)data, strlen(data)); //對方講話,你聽: len = readline(fd, (void *)data2, 100); //講完了,掛電話,類似於下面的語句: close(fd); 整體情況大概就是這樣,所以可以看到計算機的實現和日常生活是很接近的!希望這可以幫助你理解網路通信。 最後建議閱讀TCP/IP詳解之卷2(實現),裡面很多例子不長但很經典,對於打好基礎很有幫助。

『陸』 java中,怎樣實現cs模式的伺服器與客戶端的通信

Socket通信:
作為伺服器端:
//生成伺服器端,監聽伺服器設定的埠
ServerSocket
socketServer
=
new
ServerSocket(埠號);
//建立客戶端和伺服器端的鏈接,這時再看客戶端
Socket
socket
=
socketServer.accept();
作為客戶端:
//新建一個Socket,包含伺服器端的IP和埠號,這樣在伺服器啟動情況下可以建立和伺服器的鏈接.
Socket
socket
=
new
Socket("IP地址","埠號");
這時,伺服器端和客戶端的連接已經建立,如果需要通信和傳輸數據的話分別在伺服器端、客戶端新建流對象,可以通過流對象實現雙方之間的互通.
有關流的內容自己看書體會下就能寫出B/S結構的通信了。

『柒』 伺服器計算機埠和客戶端計算機埠,如何實現相互通信的呢希望懂網路專業知識的大師指點!

伺服器和客戶端在通信之前會先建立TCP連接,就是常說的三次握手過程。
TCP連接建立之後,伺服器和客戶端就可以互通數據了,可以通過HTTP、FTP、SMTP等等的協議進行各種應用,伺服器有通用的服務埠,例如80是HTTP服務,21是FTP服務,25是SMTP服務,這些埠號是通用的。而用戶的埠號則是不確定的。所以,客戶端需要某種服務時會先訪問伺服器的某個埠,並且通過TCP建立過程,告知伺服器自己的埠號。

正如你所說的,黑客可以對客戶端偽裝成伺服器、對伺服器偽裝成客戶端,分別建立TCP連接,然後獲取用戶和伺服器的信息。現在很多釣魚陷阱就是這樣盜取用戶帳號、密碼的。
木馬攻擊又是另外一回事了,木馬主要是把木馬程序載入用戶電腦,然後盜取用戶信息,當然通過中間人攻擊來注入木馬是常用的手段。

『捌』 如何使用socket進行客戶端和伺服器端的通信

下載完成後,軟體是一個單獨的運行程序,可以直接打開軟體。

3
軟體的界面很簡單,在左側有tcp和udp的客戶端或服務端的快捷按鈕,上方有【創建】【刪除】【退出】等選項按鈕。

4
我們先來建立TCP的測試服務端。點擊【TCP Server】再點擊【創建】。

選擇一個監聽埠,這里我們使用6001作為服務端的監聽埠。

建立完成後,服務端會自動啟動,軟體會顯示【啟動監聽】的狀態。

我們可以檢測一下本機的6001埠是否已經打開。在DOS窗口中輸入命令【netstat -a】,可以在列表中看到本機的6001埠的狀態為listening的狀態,表示本機的6001埠正處於監聽的狀態。

在DOS窗口中輸入命令【telnet 192.168.0.140 6001】來登錄本地的6001埠。

點擊回車鍵,就可以成功登錄6001埠。在測試軟體中就可以看到狀態是已連接的狀態,同時也可以看到對方的ip就是本地ip。

再來測試通信情況,在DOS窗口中輸入a、b、c,在軟體的接收窗口就可以看到收到的數據了。

在軟體的發送窗口中輸入1234567890,點擊發送後,在DOS窗口中就可以看到軟體發送過來的數據了。

測試完成後,在軟體中點擊【停止監聽】,同時在DOS窗口中可以看到【失去了跟主機的連接】,表示測試連接已經斷開。

再來創建TCP的客戶端,點擊【TCP Client】再點擊【創建】。會彈出【創建socket客戶端】窗口,輸入對方的ip和對方的埠,點擊確認。

tcp的客戶端已經建立好,如果對方的埠監聽正常的話,點擊【連接】就可以連接到對方的埠和對方進行測試通信了。

『玖』 在java網路編程中,客戶端/伺服器怎麼實現不同電腦之間的通信

1、首先兩台電腦和伺服器都在同一個網路中
2、相互之間可以用sokect<--->server
相互進行通信

『拾』 c#如何實現多個客戶端的通信(同一個伺服器)

客戶端之間的通訊有兩個辦法。
1.
伺服器中轉
2.
伺服器上注冊後,客戶端之間直接通信。
對於第一種方法,大多比較簡單。查一下socket的文章,還有大把現成的代碼給你看。
第二個方法就稍微復雜一些。
但原理都一樣。客戶端A,鏈接伺服器後,地址信息就保存到了伺服器上。除了保持與伺服器的通信外。另外開啟一個
Socket,綁定到另一個埠,並且一直監聽此埠。
客戶端B連接伺服器,從伺服器上獲取客戶端A的地址信息。把客戶端A當成伺服器,連接A。

熱點內容
加拿大28單雙通用演算法 發布:2022-07-05 14:28:51 瀏覽:515
c語言標識符與關鍵字 發布:2022-07-05 14:21:46 瀏覽:118
沒有解壓密碼如何破解 發布:2022-07-05 14:21:40 瀏覽:854
androidcpuabi 發布:2022-07-05 14:21:36 瀏覽:54
中信銀行的密碼忘了怎麼辦 發布:2022-07-05 14:21:31 瀏覽:791
通用配置文件怎麼刪除 發布:2022-07-05 14:20:00 瀏覽:94
計算機存儲器分類方法 發布:2022-07-05 14:18:08 瀏覽:678
怎樣搭建文檔伺服器 發布:2022-07-05 14:18:07 瀏覽:650
手機如何查看已連接wifi密碼 發布:2022-07-05 14:16:46 瀏覽:886
銳刻綠豆冰沙怎麼配置 發布:2022-07-05 14:15:42 瀏覽:453