把你要傳輸的對象實現Serializable介面，即進行序列化
然後用ObjectOutputStream 和ObjectInputStream就可以讀寫對象了··
Ⅱ java中怎樣進行網路傳輸文本域內容
是要網路傳輸部分的代碼嗎？教師端做個伺服器開個埠然後文件流傳輸就行了
下面的代碼是我做過的一個簡單聊天軟體，裡面有網路傳輸你看下。
//testChatServer.java
importjava.util.*;
importjava.io.*;
importjava.net.*;
publicclasstestChatServer
{
privateArrayList<Socket>clients=newArrayList<Socket>();
privateArrayList<HandleClient>threads=newArrayList<HandleClient>();
publictestChatServer()
{
try
{
ServerSocketserverSocket=newServerSocket(8888);
while(true)
{
Socketsocket=serverSocket.accept();
cnelients.add(socket);
HandleClienttask=newHandleClient(socket);
threads.add(task);
newThread(task).start();
}
}catch(IOExceptione)
{
System.err.println(e);
}
}
publicstaticvoidmain(String[]args)throwsIOException
{
newtestChatServer();
}
{
privateSocketsocket;
privateInputStreaminput;
privateOutputStreamoutput;
publicHandleClient(Socketsocket)
{
this.socket=socket;
}
publicvoidsendMessage(byte[]message)
{
try
{
output.write(message);
output.flush();
}catch(IOExceptione)
{
System.err.println(e);
}
}
publicvoidrun()
{
try
{
input=socket.getInputStream();
output=socket.getOutputStream();
while(true)
{
byte[]tempBytes=newbyte[1000];
input.read(tempBytes);
intcommand=tempBytes[0]-0x30;
switch(command)
{
case1:
{
if(clients.size()==0)
return;
Stringtemp=clients.get(0).getInetAddress()
.getHostAddress();
for(inti=1;i<clients.size();i++)
temp+=(";"+clients.get(i).getInetAddress()
.getHostAddress());
byte[]tempByte2=newbyte[2+temp.getBytes().length];
tempByte2[0]=0x31;
tempByte2[1]=(byte)temp.getBytes().length;
for(inti=0;i<temp.getBytes().length;i++)
{
tempByte2[i+2]=temp.getBytes()[i];
}
output.write(tempByte2);
output.flush();
break;
}
case2:
{
intreadLength=tempBytes[1];
Stringdestination=newString(tempBytes,2,
readLength,"UTF-8");
intreadLength2=tempBytes[2+readLength];
for(inti=0;i<clients.size();i++)
{
if(clients.get(i).getInetAddress()
.getHostAddress().equals(destination))
{
byte[]sourceIP=socket.getInetAddress().getHostAddress().getBytes();
byte[]tempByte2=newbyte[sourceIP.length+readLength2+3];
tempByte2[0]=0x32;
tempByte2[1]=(byte)sourceIP.length;
intj;
for(j=2;j<sourceIP.length+2;j++)
tempByte2[j]=sourceIP[j-2];
tempByte2[j++]=(byte)readLength2;
for(intk=0;k<readLength2;k++,j++)
tempByte2[j]=tempBytes[3+readLength+k];
threads.get(i).sendMessage(tempByte2);
}
}
break;
}
case-48:
{
for(inti=0;i<clients.size();i++)
{
if(clients.get(i).equals(this.socket))
{
clients.remove(i);
threads.remove(i);
}
}
return;
}
}
}
}catch(IOExceptione)
{
for(inti=0;i<clients.size();i++)
{
if(clients.get(i).equals(this.socket))
{
clients.remove(i);
threads.remove(i);
}
}
}
}
}
}
//testChatClient.java
importjava.util.*;
importjava.io.*;
importjava.net.*;
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;
{
privateJTextAreajta=newJTextArea();
privateJTextFieldjtf=newJTextField();
privateJComboBox<String>jcb=newJComboBox<String>();
privateJButtonjbsend=newJButton("send");
privateJButtonjbrefresh=newJButton("refresh");
privateInputStreaminput;
privateOutputStreamoutput;
private Socketsocket;
publicstaticStringSERVER_IP="192.168.1.101";
publicstaticintSERVER_PORT=8888;
//Message1->refreshmessage
//Message2->sendmessage
publictestChatClient()
{
initComponents();
try
{
socket=newSocket(SERVER_IP,SERVER_PORT);
input=socket.getInputStream();
output=socket.getOutputStream();
}
catch(IOExceptione)
{
System.err.println(e);
}
jbrefresh.addActionListener(newActionListener()
{
publicvoidactionPerformed(ActionEvente)
{
jta.setText("");
try
{
if(socket==null)
socket=newSocket(SERVER_IP,SERVER_PORT);
output.write(0x31);
}
catch(IOExceptionex)
{
JOptionPane.showConfirmDialog(null,ex);
}
}
});
jbsend.addActionListener(newActionListener()
{
publicvoidactionPerformed(ActionEvente)
{
if(jtf.getText()==null||jtf.getText().equals(""))
return;
if(jtf.getText().length()>=400)
{
JOptionPane.showConfirmDialog(null,"最大字數不能超過400");
return;
}
try
{
Stringdestination=jcb.getSelectedItem().toString();
Stringmessage=jtf.getText();
if(socket==null)
socket=newSocket(SERVER_IP,SERVER_PORT);
byte[]temp=newbyte[3+destination.getBytes().length+message.getBytes().length];
temp[0]=0x32;
temp[1]=(byte)destination.getBytes().length;
inti=2;
for(intj=0;j<destination.getBytes().length;i++,j++)
temp[i]=destination.getBytes()[j];
temp[i++]=(byte)message.getBytes().length;
for(intj=0;j<message.getBytes().length;i++,j++)
{
temp[i]=message.getBytes()[j];
System.out.println();
}
output.write(temp);
jta.append("me: ");
jta.append(jtf.getText());
jta.append(" ");
jtf.setText("");
}
catch(IOExceptionex)
{
System.err.println(ex);
}
}
});
try
{
jbrefresh.doClick();
while(true)
{
byte[]tempBytes=newbyte[1000];
input.read(tempBytes);
intcommand=tempBytes[0]-0x30;
//intreadLength=input.read();
switch(command)
{
case1:
{
intreadLength=tempBytes[1];
String[]temp=newString(tempBytes,2,readLength,"UTF-8").split(";");
jcb.removeAllItems();
if(temp.length==0&&temp[0].equals(""))
return;
for(inti=0;i<temp.length;i++)
{
jcb.addItem(temp[i]);
}
jcb.setSelectedIndex(0);
break;
}
case2:
{
intreadLength1=tempBytes[1];
jta.append(newString(tempBytes,2,readLength1,"UTF-8")+" ");
intreadLength2=tempBytes[2+readLength1];
jta.append(newString(tempBytes,3+readLength1,readLength2,"UTF-8")+" ");
break;
}
}
}
}
catch(IOExceptione)
{
System.err.println(e);
}
}
publicstaticvoidmain(String[]args){
testChatClientframe=newtestChatClient();
}
publicvoidinitComponents()
{
setLayout(newBorderLayout());
JPaneljpNorth=newJPanel();
jpNorth.setLayout(newBorderLayout());
jpNorth.add(jcb,BorderLayout.CENTER);
jpNorth.add(jbrefresh,BorderLayout.EAST);
JPaneljpSouth=newJPanel();
jpSouth.setLayout(newBorderLayout());
jpSouth.add(jtf,BorderLayout.CENTER);
jpSouth.add(jbsend,BorderLayout.EAST);
add(jpNorth,BorderLayout.NORTH);
add(jpSouth,BorderLayout.SOUTH);
add(newjscrollPane(jta),BorderLayout.CENTER);
this.getRootPane().setDefaultButton(jbsend);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(300,600);
setVisible(true);
}
}
Ⅲ java如何獲得當前的網路傳輸速度
1. JAVA還沒有API可以做到。
2. 可以通過腳本等到主機的網路流量：windown使用wmi，linux使用命令（watch -n 1 "/sbin/ifconfig eth0 | grep bytes"）。
3. 另外就是SNMP協議，通過對於的MID獲得主機或者網路設備的流量。
java有個開源的實現叫做SNMP4J，你可以google 「SNMP4J 網路流量」搜索到大量信息。（
使用SNMP輪詢做實事流量監控的頻率不要太高，否則會有負載問題。）
Ⅳ 利用java socket實現文件傳輸
1.伺服器端
package sterning;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
int port = 8821;
void start() {
Socket s = null;
try {
ServerSocket ss = new ServerSocket(port);
while (true) {
// 選擇進行傳輸的文件
String filePath = "D:\\lib.rar";
File fi = new File(filePath);
System.out.println("文件長度:" + (int) fi.length());
// public Socket accept() throws
// IOException偵聽並接受到此套接字的連接。此方法在進行連接之前一直阻塞。
s = ss.accept();
System.out.println("建立socket鏈接");
DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
dis.readByte();
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream ps = new DataOutputStream(s.getOutputStream());
//將文件名及長度傳給客戶端。這里要真正適用所有平台，例如中文名的處理，還需要加工，具體可以參見Think In Java 4th里有現成的代碼。
ps.writeUTF(fi.getName());
ps.flush();
ps.writeLong((long) fi.length());
ps.flush();
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
while (true) {
int read = 0;
if (fis != null) {
read = fis.read(buf);
}
if (read == -1) {
break;
}
ps.write(buf, 0, read);
}
ps.flush();
// 注意關閉socket鏈接哦，不然客戶端會等待server的數據過來，
// 直到socket超時，導致數據不完整。
fis.close();
s.close();
System.out.println("文件傳輸完成");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String arg[]) {
new ServerTest().start();
}
}
2.socket的Util輔助類
package sterning;
import java.net.*;
import java.io.*;
public class ClientSocket {
private String ip;
private int port;
private Socket socket = null;
DataOutputStream out = null;
DataInputStream getMessageStream = null;
public ClientSocket(String ip, int port) {
this.ip = ip;
this.port = port;
}
/** *//**
* 創建socket連接
*
* @throws Exception
* exception
*/
public void CreateConnection() throws Exception {
try {
socket = new Socket(ip, port);
} catch (Exception e) {
e.printStackTrace();
if (socket != null)
socket.close();
throw e;
} finally {
}
}
public void sendMessage(String sendMessage) throws Exception {
try {
out = new DataOutputStream(socket.getOutputStream());
if (sendMessage.equals("Windows")) {
out.writeByte(0x1);
out.flush();
return;
}
if (sendMessage.equals("Unix")) {
out.writeByte(0x2);
out.flush();
return;
}
if (sendMessage.equals("Linux")) {
out.writeByte(0x3);
out.flush();
} else {
out.writeUTF(sendMessage);
out.flush();
}
} catch (Exception e) {
e.printStackTrace();
if (out != null)
out.close();
throw e;
} finally {
}
}
public DataInputStream getMessageStream() throws Exception {
try {
getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
return getMessageStream;
} catch (Exception e) {
e.printStackTrace();
if (getMessageStream != null)
getMessageStream.close();
throw e;
} finally {
}
}
public void shutDownConnection() {
try {
if (out != null)
out.close();
if (getMessageStream != null)
getMessageStream.close();
if (socket != null)
socket.close();
} catch (Exception e) {
}
}
}
3.客戶端
package sterning;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class ClientTest {
private ClientSocket cs = null;
private String ip = "localhost";// 設置成伺服器IP
private int port = 8821;
private String sendMessage = "Windwos";
public ClientTest() {
try {
if (createConnection()) {
sendMessage();
getMessage();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
private boolean createConnection() {
cs = new ClientSocket(ip, port);
try {
cs.CreateConnection();
System.out.print("連接伺服器成功!" + "\n");
return true;
} catch (Exception e) {
System.out.print("連接伺服器失敗!" + "\n");
return false;
}
}
private void sendMessage() {
if (cs == null)
return;
try {
cs.sendMessage(sendMessage);
} catch (Exception e) {
System.out.print("發送消息失敗!" + "\n");
}
}
private void getMessage() {
if (cs == null)
return;
DataInputStream inputStream = null;
try {
inputStream = cs.getMessageStream();
} catch (Exception e) {
System.out.print("接收消息緩存錯誤\n");
return;
}
try {
//本地保存路徑，文件名會自動從伺服器端繼承而來。
String savePath = "E:\\";
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
int passedlen = 0;
long len=0;
savePath += inputStream.readUTF();
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(savePath))));
len = inputStream.readLong();
System.out.println("文件的長度為:" + len + "\n");
System.out.println("開始接收文件!" + "\n");
while (true) {
int read = 0;
if (inputStream != null) {
read = inputStream.read(buf);
}
passedlen += read;
if (read == -1) {
break;
}
//下面進度條本為圖形界面的prograssBar做的，這里如果是打文件，可能會重復列印出一些相同的百分比
System.out.println("文件接收了" + (passedlen * 100/ len) + "%\n");
fileOut.write(buf, 0, read);
}
System.out.println("接收完成，文件存為" + savePath + "\n");
fileOut.close();
} catch (Exception e) {
System.out.println("接收消息錯誤" + "\n");
return;
}
}
public static void main(String arg[]) {
new ClientTest();
}
}
Ⅳ java 網路編程傳輸對象問題 求大神指導 謝謝
傳數據一般建議用json，像你這種之間吧對象傳過去的話不用再客戶端建user，你服務端需要用ObjectOutputStream對象去把你有數據的user序列話成流傳輸過去，客戶端直接用ObjectInputStream讀取這個流，對象就是Object，但是這個object就是你user的數據了，如果非要弄成user需要用反射把裡面的數據set到你客戶端的user中，這個沒法直接轉過去，不是一種class，所以只能反射再set
Ⅵ java中網路變成傳遞數據的問題
莫名奇妙的問題
沒有看懂
Ⅶ java為什麼在網路傳輸中socket.read()返回1代表讀取完，以前都是返回-1代表讀取完的
socket.read()的結果是讀取的byte長度，1的話表示讀了一個byte，不是結束。-1才表示結束
Ⅷ 普通的+java+對象,在網路上都可以傳輸,對嗎
要想讓java對象在網路中傳輸，需要讓對象序列化
Ⅸ 怎麼用java實現區域網文件傳輸
只要能建立連接就可以，一個做伺服器用ServerSocket，另一個用Socket連接，然後用流傳輸文件就可以了。
Ⅹ Java網路編程基本概念是什麼
1、Java網路編程基本概念——主機的網路層
主機網路層定義特定網路介面(如乙太網或WiFi天線)如何通過物理連接將IP數據報發送到本地網路或世界其他地方。在主機網路層中，連接不同計算機的硬體部分(電纜、光纖、無線電波或煙霧信號)有時被稱為網路的物理層。Java程序員不需要擔心這一層，除非出現錯誤，例如計算機後面的插頭脫落或有人切斷了您與外部世界之間的T-1線。換句話說，Java將永遠看不到物理層。
2、Java網路編程基本概念——網路層
Internet層的下一層是主機網路層，這是Java程序員需要考慮的第一層。網際網路層協議定義了數據位和位元組如何組織成更大的組，稱為包，也定義了不同計算機互相查找的定址機制。Internet Protocol (IP)是世界上使用最廣泛的Internet層協議，也是Java唯一了解的Internet層協議。
網際網路協議基本上是兩種協議:IPV4使用32位地址，IPV6使用128位地址，並增加了技術特性來幫助路由。這是兩種完全不同的網路協議，如果沒有特殊的網關/隧道協議，它們甚至不能在同一網路上互操作，但是Java向您隱藏了幾乎所有這些差異。
除了路由和定址之外，網際網路層的第二個作用是使不同類型的主機網路層能夠彼此對話。網際網路路由器在WiFi和乙太網、乙太網和DSL、DSL和光纖往返協議之間進行交換。沒有網際網路層或類似的分層，每台計算機只能與同一類型網路上的其他計算機通信。網際網路層負責使用適當的協議將異類網路彼此連接起來。
3、Java網路編程基本概念——傳輸層
原始數據報有一些缺點。最明顯的缺點是無法保證可靠的傳輸，即使可以保證，也可能在傳輸過程中被損壞。頭檢查只能檢測頭中的損壞，而不能檢測數據報的數據部分。最後，即使數據報沒有損壞地到達了它的目的地，它也可能不能按照發送的順序到達。
傳輸層負責確保按發送的順序接收數據包，確保沒有數據丟失或銷毀。如果數據包丟失，傳輸層要求發送方重新傳輸該數據包。為此，IP網路向每個數據報添加了一個額外的頭，其中包含更多信息。
這個級別有兩個主要協議。第一個是傳輸控制協議(TCP)，這是一個昂貴的協議，允許丟失或損壞的數據按照發送順序重新傳輸。第二個協議是用戶數據報協議(User Datagram Protocol, UDP)，它允許接收方檢測損壞的數據包，而不保證它們按照正確的順序發送(或者根本不發送)。然而，UDP通常比TCP快。TCP被稱為可靠協議。UDP是不可靠的。
4、Java網路編程基本概念——應用程序層
向用戶交付數據的層稱為應用層。以下三個層定義如何將數據從一台計算機傳輸到另一台計算機。應用層決定數據傳輸後的操作。有HTTP為用戶Web, SMTP, POP, IMAP為用戶電子郵件;FSP, TFTP用於文件傳輸，NFS用於文件訪問;文件共享使用Gnutella和BitTorrent;會話發起協議(SIP)和Skype用於語音通信。此外，您的程序可以在必要時定義自己的應用程序級協議。(頁面)
5、Java網路編程基本概念——IP、TCP、UDP
IP被設計成允許任意兩點之間有多條路由，繞過損壞的路由器來路由數據包。由於兩點之間有多條路由，而且由於網路流量或其他因素，它們之間的最短路徑可能會隨著時間而變化，因此構成特定數據流的數據包可能不會走同一條路由。即使它們全部到達，也可能不是按照它們被發送的順序到達的。為了改進這一基本機制，TCP被放置在IP上，以便連接的兩端可以確認收到的IP數據包，並請求重傳丟失或損壞的數據包。此外，TCP允許接收端上的數據包按照發送的順序重新分組。
然而，TCP有很多開銷。因此，如果單個數據包的丟失不會完全破壞數據，那麼可以使用UDP發送數據包，而不需要TCP提供的保證。UDP是一種不可靠的協議。它不能保證信息包將到達它們的目的地，或者它們將以它們被發送的相同順序到達。
6、Java網路編程基本概念——IP地址和域名
IPv4網路上的每台計算機都有一個4位元組的數字ID。通常在一個點上以四段格式寫，比如192.1.32.90，每個數字是一個無符號位元組，范圍從0到255。IPv4網路上的每台計算機都有一個唯一的四段地址。當數據通過網路傳輸時，包的報頭包括要發送到的機器的地址(目的地址)和要發送到的機器的地址(源地址)。路由上的路由器通過檢查目的地址來選擇發送包的最佳路徑。包含源地址是為了讓收件人知道該對誰進行回復。
雖然計算機可以很容易地處理數字，但人類並不擅長記住它們。因此，域名系統(DNS)被開發出來，用來將容易記住的主機名(如www.12345.com)轉換成數字互聯網地址(如208.201.243.99)。當Java程序訪問網路時，它們需要同時處理數字地址和相應的主機名。這些方法由java.net.InetAddress類提供。
7、Java網路編程基本概念——港口
如果每台計算機一次只做一件事，地址就足夠了。但是現代計算機同時做許多不同的事情。電子郵件需要與FTP請求分開，而FTP請求也需要與Web通信分開。這是通過埠完成的。具有IP地址的每台計算機有數千個邏輯埠(確切地說，每個傳輸層協議有65,535個埠)。這些只是計算機內存中的抽象，不代表任何物理對象，不像USB埠。每個埠在1到65535之間進行數字標識。每個埠可以分配給一個特定的服務。
8、Java網路編程基本概念——一個防火牆
在互聯網上有一些頑皮的人。要排除它們，通常需要在本地網路上設置一個接入點，並檢查進出該接入點的所有流量。位於網際網路和本地網路之間的一些硬體和軟體會檢查所有輸入和輸出的數據，以確保它是防火牆。防火牆通常是路由器的一部分，它將本地網路連接到更大的網際網路，並可以執行其他任務，如網路地址轉換。另外，防火牆可以是單獨的機器。防火牆仍然主要負責檢查進出其網路介面的數據包，根據一組規則接收或拒絕數據包。
本篇《什麼是Java網路編程基本概念?看完這篇文章你一定可以明白》到這里就已經結束了，小編一直認為，某一個編程軟體受歡迎是有一定原因的，首先吸引人的一定是其功能，環球網校的小編祝您java學習之路順利，如果你還想知道更多java知識，也可以點擊本站的其他文章進行學習。