socket上传下载
问题1 你好像没有说清楚，不好作答。
问题2 可以在客户端使用前做一个注册，由服务器产生一个身份识别码，此后在客户端每次连接服务器时验证这个注册码。数据一般来说都是要加密的，尤其是服务器和客户端之间的指令信息，如果明文传送会很不安全。
问题3 在C/S架构里，一般都是客户端主动去连接服务器。即使是服务器要向客户端发送指令，也是在客户端来连接时判断是否有对应此客户端的指令要下发。具体实现可以在服务端使用一个socket进行listen，当有客户端来连接时启动线程进行具体业务处理；而客户端则定时向服务器进行一次握手通讯，在握手的同时向服务器询问是否有可能存在的指令，如果有便进行指令下发；由于服务器一直在listen，所以客户端有要上传的指令可以随时连接并上传。
问题4 这个可以在问题2里的注册码里包含，比如可更新的文件有3个，指定客户端只能更新第一和第三个文件，你可以在注册码里一个特定字段写入"101"，此后在客户端连接服务器时便可以知道自己能更新哪几个文件了。
a.大型系统中的服务器当然需要同时具备网络通信和数据库访问的功能。
因为要借助数据库来管理纷繁复杂的各种数据比如用户信息、文件信息、软件版本等，而没有Socket网络通信就算不上是服务器了。如果设计合理的话对速度是没有影响的，这就需要你在架构和数据库查询方面下功夫做一些优化。
b.socket只是网络编程的一种技术，并不是架构，对应你客户端使用C#的话，服务器底层可用C++实现，架构方面可以研究一下完成端口。
❷ 要通过(socket)来传输文件这是什么意思
SOCKET用于在两个基于TCP/IP协议的应用程序之间相互通信。中文有的称为套接字，你可以理解为一个插座和插头，两者匹配才能进行数据通信。 SOCKET最早出现在UNIX系统中，是UNIX系统主要的信息传递方式。在WINDOWS系统中，SOCKET称为WINSOCK。
SOCKET有两个基本概念：客户方和服务方。当两个应用之间需要采用SOCKET通信时，首先需要在两个应用之间（可能位于同一台机器，也可能位于不同的机器）建立SOCKET连接，发起呼叫连接请求的一方为客户方，接受呼叫连接请求的一方成为服务方。客户方和服务方是相对的，同一个应用可以是客户方，也可以是服务方。
在客户方呼叫连接请求之前，它必须知道服务方在哪里。所以需要知道服务方所在机器的IP地址或机器名称，如果客户方和服务方事前有一个约定就好了，这个约定就是PORT（端口号）。也就是说，客户方可以通过服务方所在机器的IP地址或机器名称和端口号唯一的确定方式来呼叫服务方。在客户方呼叫之前，服务方必须处于侦听状态，侦听是否有客户要求建立连接。一旦接到连接请求，服务方可以根据情况建立或拒绝连接。连接方式有两种，同步方式（Blocking）和(noBlocking).
客户方发送的消息可以是文本，也可以是二进制信息流。当客户方的消息到达服务方端口时，会自动触发一个事件（event），服务方只要接管该事件，就可以接受来自客户方的消息了。
❸ 怎样用socket实现点对点的文件传输
在两台计算机传输文件之前，必需得先有一台计算机建立套接字连接并绑定一个固定得端口，并在这个端口侦听另外一台计算机的连接请求。
socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
socket.Blocking = true ;
IPEndPoint computernode1 = new IPEndPoint(serverIpadress, 8080);
socket.Bind(computernode1);
socket.Listen(-1);
当有其他的计算机发出连接请求的时候，被请求的计算机将对每一个连接请求分配一个线程，用于处理文件传输和其他服务。
while ( true )
{
clientsock = socket.Accept();
if ( clientsock.Connected )
{
Thread tc = new Thread(new ThreadStart(listenclient));
tc.Start();
}
}
下面的代码展示了listenclient方法是如何处理另外一台计算机发送过来的请求。首先并对发送过来的请求字符串作出判断，看看是何种请求，然后决定相应的处理方法。
void listenclient()
{
Socket sock = clientsock ;
try
{
while ( sock != null )
{
byte[] recs = new byte[32767];
int rcount = sock.Receive(recs,recs.Length,0) ;
string message = System.Text.Encoding.ASCII.GetString(recs) ;
//对message作出处理，解析处请求字符和参数存储在cmdList 中
execmd＝cmdList[0];
sender = null ;
sender = new Byte[32767];
string parm1 = "";
//目录列举
if ( execmd == "LISTING" )
{
ListFiles(message);
continue ;
}
//文件传输
if ( execmd == "GETOK" )
{
cmd = "BEGINSEND " + filepath + " " + filesize ;
sender = new Byte[1024];
sender = Encoding.ASCII.GetBytes(cmd);
sock.Send(sender, sender.Length , 0 );
//转到文件下载处理
DownloadingFile(sock);
continue ;
}
}
}
catch(Exception Se)
{
string s = Se.Message;
Console.WriteLine(s);
}
}
至此，基本的工作已经完成了，下面我们看看如何处理文件传输的。
while(rdby < total && nfs.CanWrite)
{
//从要传输的文件读取指定长度的数据
len =fin.Read(buffed,0,buffed.Length) ;
//将读取的数据发送到对应的计算机
nfs.Write(buffed, 0,len);
//增加已经发送的长度
rdby=rdby+len ;
}
从上面的代码可以看出是完成文件转换成FileStream 流，然后通过NetworkStream绑定对应的套节子，最后调用他的write方法发送到对应的计算机。
我们再看看接受端是如何接受传输过来的流，并且转换成文件的：
NetworkStream nfs = new NetworkStream(sock) ;
try
{
//一直循环直到指定的文件长度
while(rby < size)
{
byte[] buffer = new byte[1024] ;
//读取发送过来的文件流
int i = nfs.Read(buffer,0,buffer.Length) ;
fout.Write(buffer,0,(int)i) ;
rby=rby+i ;
}
fout.Close() ;
从上面可以看出接受与发送恰好是互为相反的过程，非常简单。
至此，单方向的文件传输就完成了，只需要在每个对等的节点上同时实现上面的发送和接受的处理代码就可以做到互相传输文件了。
❹ socket
首先你得了解一些网络协议，比如TCP/IP和UDP协议，还有要知道计算机都有端口，而网络程序中套接字（Socket）用于将应用程序和端口连接起来。Socket是一个假想的连接装置，就像插插头的设备“插座”。
一般Socket用于网络的通讯，比如你要写一个聊天室的程序，那发送和接受信息就需要用到Socket了。
❺ 关于用java的SOCKET传输文件
点对点传输文件
/*
import java.io.*;
import java.net.*;
import java.util.*;
*/
private HttpURLConnection connection;//存储连接
private int downsize = -1;//下载文件大小,初始值为-1
private int downed = 0;//文加已下载大小,初始值为0
private RandomAccessFile savefile;//记录下载信息存储文件
private URL fileurl;//记录要下载文件的地址
private DataInputStream fileStream;//记录下载的数据流
try{
/*开始创建下载的存储文件,并初始化值*/
File tempfileobject = new File("h:\\webwork-2.1.7.zip");
if(!tempfileobject.exists()){
/*文件不存在则建立*/
tempfileobject.createNewFile();
}
savefile = new RandomAccessFile(tempfileobject,"rw");
/*建立连接*/
fileurl = new URL("https://webwork.dev.java.net/files/documents/693/9723/webwork-2.1.7.zip");
connection = (HttpURLConnection)fileurl.openConnection();
connection.setRequestProperty("Range","byte="+this.downed+"-");
this.downsize = connection.getContentLength();
//System.out.println(connection.getContentLength());
new Thread(this).start();
}
catch(Exception e){
System.out.println(e.toString());
System.out.println("构建器错误");
System.exit(0);
}
public void run(){
/*开始下载文件,以下测试非断点续传,下载的文件存在问题*/
try{
System.out.println("begin!");
Date begintime = new Date();
begintime.setTime(new Date().getTime());
byte[] filebyte;
int onecelen;
//System.out.println(this.connection.getInputStream().getClass().getName());
this.fileStream = new DataInputStream(
new BufferedInputStream(
this.connection.getInputStream()));
System.out.println("size = " + this.downsize);
while(this.downsize != this.downed){
if(this.downsize - this.downed > 262144){//设置为最大256KB的缓存
filebyte = new byte[262144];
onecelen = 262144;
}
else{
filebyte = new byte[this.downsize - this.downed];
onecelen = this.downsize - this.downed;
}
onecelen = this.fileStream.read(filebyte,0,onecelen);
this.savefile.write(filebyte,0,onecelen);
this.downed += onecelen;
System.out.println(this.downed);
}
this.savefile.close();
System.out.println("end!");
System.out.println(begintime.getTime());
System.out.println(new Date().getTime());
System.out.println(begintime.getTime() - new Date().getTime());
}
catch(Exception e){
System.out.println(e.toString());
System.out.println("run()方法有问题!");
}
}
/***
//FileClient.java
import java.io.*;
import java.net.*;
public class FileClient {
public static void main(String[] args) throws Exception {
//使用本地文件系统接受网络数据并存为新文件
File file = new File("d:\\fmd.doc");
file.createNewFile();
RandomAccessFile raf = new RandomAccessFile(file, "rw");
// 通过Socket连接文件服务器
Socket server = new Socket(InetAddress.getLocalHost(), 3318);
//创建网络接受流接受服务器文件数据
InputStream netIn = server.getInputStream();
InputStream in = new DataInputStream(new BufferedInputStream(netIn));
//创建缓冲区缓冲网络数据
byte[] buf = new byte[2048];
int num = in.read(buf);
while (num != (-1)) {//是否读完所有数据
raf.write(buf, 0, num);//将数据写往文件
raf.skipBytes(num);//顺序写文件字节
num = in.read(buf);//继续从网络中读取文件
}
in.close();
raf.close();
}
}
//FileServer.java
import java.io.*;
import java.util.*;
import java.net.*;
public class FileServer {
public static void main(String[] args) throws Exception {
//创建文件流用来读取文件中的数据
File file = new File("d:\\系统特点.doc");
FileInputStream fos = new FileInputStream(file);
//创建网络服务器接受客户请求
ServerSocket ss = new ServerSocket(8801);
Socket client = ss.accept();
//创建网络输出流并提供数据包装器
OutputStream netOut = client.getOutputStream();
OutputStream doc = new DataOutputStream(
new BufferedOutputStream(netOut));
//创建文件读取缓冲区
byte[] buf = new byte[2048];
int num = fos.read(buf);
while (num != (-1)) {//是否读完文件
doc.write(buf, 0, num);//把文件数据写出网络缓冲区
doc.flush();//刷新缓冲区把数据写往客户端
num = fos.read(buf);//继续从文件中读取数据
}
fos.close();
doc.close();
}
}
*/
❻ C# Winform 多线程 SOCKET 文件上传，下载
这可是很麻烦的，自己到网上找吧
❼ c# c/s结构Socket上传文件的代码
发送端(client)
private void button2_Click(object sender, EventArgs e)
{
this.button2.Enabled = false;
Thread TempThread = new Thread(new ThreadStart(this.StartSend));
TempThread.Start();
}private void StartSend()
{
//FileInfo EzoneFile = new FileInfo(this.textBox1.Text);string path = @"E:old F directoryTangWeikangge ew1.jpg";
FileInfo EzoneFile = new FileInfo(path);
FileStream EzoneStream = EzoneFile.OpenRead();
int PacketSize = 100000;
int PacketCount = (int)(EzoneStream.Length / ((long)PacketSize));
// this.textBox8.Text = PacketCount.ToString();
// this.progressBar1.Maximum = PacketCount;
int LastDataPacket = (int)(EzoneStream.Length - ((long)(PacketSize * PacketCount)));
// this.textBox9.Text = LastDataPacket.ToString();
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("163.180.117.229"), 7000);Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.Connect(ipep);
// TransferFiles.SendVarData(client, System.Text.Encoding.Unicode.GetBytes(EzoneFile.Name));
// TransferFiles.SendVarData(client, System.Text.Encoding.Unicode.GetBytes(PacketSize.ToString()));
// TransferFiles.SendVarData(client, System.Text.Encoding.Unicode.GetBytes(PacketCount.ToString()));
// TransferFiles.SendVarData(client, System.Text.Encoding.Unicode.GetBytes(LastDataPacket.ToString()));
byte[] data = new byte[PacketSize];
for(int i=0; i<PacketCount; i++)
{
EzoneStream.Read(data, 0, data.Length);TransferFiles.SendVarData(client, data);
// this.textBox10.Text = ((int)(i + 1)).ToString();
// this.progressBar1.PerformStep();
}if(LastDataPacket != 0)
{
data = new byte[LastDataPacket];EzoneStream.Read(data, 0, data.Length);
TransferFiles.SendVarData(client,data);
// this.progressBar1.Value = this.progressBar1.Maximum;
}
client.Close();EzoneStream.Close();
this.button2.Enabled = true;
}接收端(server)
private void button2_Click(object sender, EventArgs e)
{
//int i = 0;
//FileStream recfs = new FileStream("E:\kangge.jpg", FileMode.OpenOrCreate);
//Byte[] recbyte = new Byte[2000000];
//Socket hostsocket = receive.Accept();
//BinaryWriter newfilestr = new BinaryWriter(recfs);
//hostsocket.Receive(recbyte, recbyte.Length, SocketFlags.None);
//for (i = 0; i < recbyte.Length; i++)
//{
// newfilestr.Write(recbyte, i, 1);
//}
//recfs.Close();//hostsocket.Shutdown(SocketShutdown.Receive);
//hostsocket.Close();this.button2.Enabled = false;
Thread TempThread = new Thread(new ThreadStart(this.StartReceive));
TempThread.Start();
}
private void StartReceive()
{
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("163.180.117.229"), 7000);Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(ipep);
server.Listen(10);
Socket client = server.Accept();
// IPEndPoint clientep = (IPEndPoint)client.RemoteEndPoint;
// string SendFileName = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
// string BagSize = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
// int bagCount = int.Parse(System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client)));
// string bagLast = System.Text.Encoding.Unicode.GetString(TransferFiles.ReceiveVarData(client));
int file_name = 1;string fileaddr = "E:\old F directory\TangWei\Copy of kangge\" + file_name.ToString() + ".jpg";
FileStream MyFileStream = new FileStream(fileaddr, FileMode.Create, FileAccess.Write);// int SendedCount = 0;
while(true)
{
byte[] data = TransferFiles.ReceiveVarData(client);
if(data.Length == 0)
{
break;
}
else
{
// SendedCount++;
MyFileStream.Write(data, 0, data.Length);
}
}MyFileStream.Close();
client.Close();
this.button2.Enabled = true;
}公共类。 TransferFiles
class TransferFiles
{public TransferFiles()
{}
public static int SendVarData(Socket s, byte[] data) // return integer indicate how many data sent.
{
int total = 0;
int size = data.Length;
int dataleft = size;
int sent;
byte[] datasize = new byte[4];
datasize = BitConverter.GetBytes(size);
sent = s.Send(datasize);//send the size of data array.while (total < size)
{
sent = s.Send(data, total, dataleft, SocketFlags.None);
total += sent;
dataleft -= sent;
}return total;
}public static byte[] ReceiveVarData(Socket s) // return array that store the received data.
{
int total = 0;
int recv;
byte[] datasize = new byte[4];
recv = s.Receive(datasize, 0, 4, SocketFlags.None);//receive the size of data array for initialize a array.
int size = BitConverter.ToInt32(datasize, 0);
int dataleft = size;
byte[] data = new byte[size];while (total < size)
{
recv = s.Receive(data, total, dataleft, SocketFlags.None);
if (recv == 0)
{
data = null;
break;
}
total += recv;
dataleft -= recv;
}return data;
}
}
❽ java使用socket文件上传
for(int size=0;size!=-1;size=fis.read(buf)){
output.write(buf,0,size);
output.flush();
}
for(int size=0;size!=-1;size=fis.read(buf))
在buf中读取字节;当buf没有内容了,返回的-1;在这个之前,一直在循环;
output.write(buf,0,size);
output.flush();
把buf中道0开始到size个字节的内容写入输出流缓冲中
并用 flush()确认发送到输出流中了;
我的意见是output.write(buf,0,size);
改为output.write(buf);
你接受数据部分代码怎么写的,是不是size等于一个大于1024的整数了而出错
❾ Socket网络通信怎么往服务器上传数据
//上传文件
Socket socket = new Socket("192.168.0.240", 7878);
OutputStream outputStream = socket.getOutputStream();
String head = "Content-Length=" + audioFile.length()
+ ";filename=" + audioFile.getName()
+ ";sourceid=\r\n";
outputStream.write(head.getBytes());
PushbackInputStream inStream = new PushbackInputStream(
socket.getInputStream());
String response = StreaTool.readLine(inStream);
String[] items = response.split(";");
String position = items[1]
.substring(items[1].indexOf("=") + 1);
RandomAccessFile fileOutStream = new RandomAccessFile(
audioFile, "r");
fileOutStream.seek(Integer.valueOf(position));
byte[] buffer = new byte[1024];
int len = -1;
while ((len = fileOutStream.read(buffer)) != -1)
{
outputStream.write(buffer, 0, len);
}
fileOutStream.close();
outputStream.close();
socket.close();
audioFile.delete();
} catch (UnknownHostException e)
{
e.printStackTrace();
} catch (IOException e)
{
e.printStackTrace();
}
❿ 利用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();
}
}