把你要传输的对象实现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知识，也可以点击本站的其他文章进行学习。