精华内容
下载资源
问答
  • 网络编程 计算机网络: ...如何准确的定位网络上的一台主机192.168.16.124:端口,定位这个计算机的某个资源 找到了这个主机,如何传输数据 javaweb:网页编程 B/S 网络编程:TCP/IP S/C 网络通信的要素

    网络编程

    • 计算机网络:

      • 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。
    • 网络编程的目的

      • 无线电台,传播交流信息
    • 想要达到这个效果需要什么

      • 如何准确的定位网络上的一台主机192.168.16.124:端口,定位到这个计算机的某个资源
      • 找到了这个主机,如何传输数据
      • javaweb:网页编程 B/S
      • 网络编程:TCP/IP S/C

    网络通信的要素

    • 如何实现网络的通信?

    • 通信双方的地址:

      • ip
      • 端口号
      • ip:端口号—>192.168.16.124.5900
    • 规则:网络通信协议

      • TCP/IP参考模型

    IP

    • ip地址:关键字InetAddress

      • 唯一定位一台网络上的计算机

      • 127.0.0.1:本机localhost

      • ip地址的分类

        • ipv4 127.0.0.1,4个字节组成,0~255,42亿;已用尽

        • ipv6:128位。8个无符号的证书

        • 2001:0bb2:aaaa:0015:0000:0000:1aaa:1312
          
      • 公网(互联网)-私网(局域网)

        • ABCD类地址
        • 192.169.xx.xx,专门给组织北部使用的
    • 域名:用来记忆IP(www.vip.com)

    端口

    • 端口便是计算机上一个程序的进程:

    • 不同的进程有不同的端口号,用来区分不同的软件

    • 被规定的端口号TCP,UDP数量为0~65535 *2

    • 单个协议下,端口号不能冲突

    • 端口分类

      • 公有端口0~1023

        • HTTP:80
        • HTTPS:443
        • FTP:21
        • Telent:23
      • 程序注册端口:1024~49151,分配用户或者程序使用

        • Tomcat:8080
        • MySQL:3306
        • Oracle:1521
      • 动态、私有:49152~65535

    • TCP Udp对比

      • TCP:打电话

        • 连接,稳定
        • 三次握手四次挥手
        • 客户端、服务端
        • 传输完成,释放连接,效率低
      • UDP:发信息

        • 不连接,不稳定
        • 客户端、服务端:没有明确的界限
        • 不管有没有准备好,都可以发给你
        • 导弹
        • DDOS:洪水攻击!
    • 简单的服务器客户端模拟

      //服务器
      package Net;
      import java.io.ByteArrayOutputStream;
      import java.io.IOException;
      import java.io.InputStream;
      import java.net.ServerSocket;
      import java.net.Socket;
      
      public class TcpSeriverDemo01 {
          public static void main(String[] args) {
              ServerSocket serverSocket=null;
              Socket socket=null;
              InputStream is =null;
              ByteArrayOutputStream baos =null;
      
              try {
                  serverSocket=new ServerSocket(9999);//创建一个地址
                  socket=serverSocket.accept();//等待客户端连接
                  is = socket.getInputStream();//读取客户端信息
                  baos=new ByteArrayOutputStream();//管道流
                  byte[] buffer=new byte[1024];
                  int len;
                  while ((len=is.read(buffer))!=-1){
                      baos.write(buffer,0,len);
                  }
                  System.out.println(baos.toString());
              } catch (IOException e) {
                  e.printStackTrace();
              }finally {//关闭资源
                  if (baos!=null){
                      try {
                          baos.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  if (is!=null){
                      try {
                          is.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  if (socket!=null){
                      try {
                          socket.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  if (serverSocket!=null){
                      try {
                          serverSocket.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
      
          }
      }
      
      
      //客户端
      package Net;
      import java.io.IOException;
      import java.io.OutputStream;
      import java.net.InetAddress;
      import java.net.Socket;
      import java.net.UnknownHostException;
      public class TcpClientDemo01 {
          //要知道服务器 地址
          public static void main(String[] args) {
              Socket socket = null;
              OutputStream os=null;
              try {
                  InetAddress serverIP = InetAddress.getByName("127.0.0.1");//得到服务器的地址和端口号
                  int port = 9999;
                  socket=new Socket(serverIP,port);//创建一个socket连接
                  os=socket.getOutputStream();//发送信息IO流
                  os.write("北京欢迎你".getBytes());
              } catch (Exception e) {
                  e.printStackTrace();
              }finally {
                  if (os!=null){
                      try {
                          os.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
                  if (socket!=null){
                      try {
                          socket.close();
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  }
              }
      
          }
      }
      

    TCP

    • 客户端:连接服务器Socket–>发送信息
    • 服务器:创建服务端口ServerSocket–>等待用户的连接accept–>接收用户信息

    文件传输 关键字:FileInputStream,FileoutputStream

    • 服务器

      package Net.Demo02;
      import java.io.*;
      import java.net.ServerSocket;
      import java.net.Socket;
      import java.net.SocketAddress;
      public class TcpServerDemo02 {
          public static void main(String[] args) throws Exception {
              ServerSocket serverSocket=new ServerSocket(9000);
              Socket socket = serverSocket.accept();
              InputStream is =socket.getInputStream();
              FileOutputStream fos =new FileOutputStream(new File("receive.jpg"));
              byte[] buffer=new byte[1024];
              int len;
              while ((len=is.read(buffer))!=-1){
                  fos.write(buffer,0,len);
              }
              OutputStream os=socket.getOutputStream();
              os.write("接收完毕".getBytes());
              fos.close();
              is.close();
              socket.close();
              serverSocket.close();
          }
      }
      
    • 客户端

      package Net.Demo02;
      import java.io.*;
      import java.net.InetAddress;
      import java.net.Socket;
      public class TcpClientDemo02 {
          public static void main(String[] args) throws Exception {
              InetAddress address= InetAddress.getByName("127.0.0.1");
              Socket socket=new Socket(address,9000);
              OutputStream os= socket.getOutputStream();
              FileInputStream fis=new FileInputStream(new File("yanzi.jpg"));
              byte[] buffer=new byte[1024];
              int len;
              while ((len=fis.read(buffer))!=-1){
                  os.write(buffer,0,len);
              }
              socket.shutdownOutput();
              InputStream is =socket.getInputStream();
              ByteArrayOutputStream baos=new ByteArrayOutputStream();
              byte[] buffer2=new byte[2014];
              int lens;
              while((len=is.read(buffer2))!=-1){
                  baos.write(buffer2,0,len);
              }
              System.out.println(baos.toString());
              fis.close();
              os.close();
              socket.close();
          }
      }
      

    Tomcat

    • 服务端

      • 自定义s
      • Tomcat服务器S:java后台开发!
    • 客户端

      • 自定义C
      • 浏览器B

    UDP发送信息

    • 不需要连接服务器:关键字:DatagramSocket

      • 服务器

        package Net.Demo03;
        import java.net.DatagramPacket;
        import java.net.DatagramSocket;
        import java.net.SocketException;
        public class UdpServerDemo01 {
            public static void main(String[] args) throws Exception {
                DatagramSocket socket=new DatagramSocket(9090);
                byte[] buffer=new byte[1024];
                DatagramPacket packet=new DatagramPacket(buffer,0,buffer.length);
                socket.receive(packet);
                System.out.println(packet.getAddress().getHostAddress());
                System.out.println(new String(packet.getData(),0,packet.getLength()));
                socket.close();
            }
        }
        
      • 客户端

    package Net.Demo03;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.net.SocketException;
    public class UdpClientDemo01 {
        public static void main(String[] args) throws Exception {
            DatagramSocket socket=new DatagramSocket();
            String msg="你好,服务器!";
            InetAddress localhost=InetAddress.getByName("127.0.0.1");
            int port=9090;
            DatagramPacket packet=new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
            socket.send(packet);
            socket.close();
        }
    }
    
    • 初步聊天实现

      • 客户端
      package Net.Demo04;
      import java.io.BufferedReader;
      import java.io.InputStreamReader;
      import java.net.*;
      public class UdpsenderDemo01 {
          public static void main(String[] args) throws Exception {
              DatagramSocket socket=new DatagramSocket();
              BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
              while (true){
                  String data=reader.readLine();
                  byte[] datas= data.getBytes();
                  DatagramPacket packet =new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));
                  socket.send(packet);
                  if (data.equals("bye")){
                      break;
                  }
              }
              socket.close();
          }
      }
      
      • 接收端
      package Net.Demo04;
      import java.net.DatagramPacket;
      import java.net.DatagramSocket;
      import java.net.SocketException;
      public class UdpReceiveDemo01 {
          public static void main(String[] args) throws Exception {
              DatagramSocket socket=new DatagramSocket(6666);
              while (true){
                  byte[] container=new byte[1024];
                  DatagramPacket packet=new DatagramPacket(container,0,container.length);
                  socket.receive(packet);
                  byte[] data=packet.getData();
                  String receiveData=new String(data,0,data.length);
                  System.out.println(receiveData);
                  if (receiveData.equals("bye")){
                      break;
                  }
              }
              socket.close();
          }
      }
      

    多线程咨询

    • 发送端

      package Net.Demo05;
      import org.jcp.xml.dsig.internal.dom.ApacheOctetStreamData;
      import java.io.BufferedReader;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.net.DatagramPacket;
      import java.net.DatagramSocket;
      import java.net.InetSocketAddress;
      import java.net.SocketException;
      public class TalkSend implements Runnable{
          DatagramSocket socket=null;
          BufferedReader reader=null;
          private int fromPort;
          private String toIP;
          private int toport;
          public TalkSend(int fromPort, String toIP, int toport) {
              this.fromPort = fromPort;
              this.toIP = toIP;
              this.toport = toport;
              try {
                  socket=new DatagramSocket(fromPort);
                  reader=new BufferedReader(new InputStreamReader(System.in));
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void run() {
              while (true){
                  try {
                      String data=reader.readLine();
                      byte[] datas =data.getBytes();
                      DatagramPacket packet=new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toport));
                      socket.send(packet);
                      if (data.equals("bye")){
                          break;
                      }
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              socket.close();
          }
      }
      
    • 接收端

      package Net.Demo05;
      import java.io.IOException;
      import java.net.DatagramPacket;
      import java.net.DatagramSocket;
      import java.net.SocketException;
      public class TalkReceive implements Runnable{
          DatagramSocket socket=null;
          private int port;
          private String msgFrom;
          public TalkReceive(int port,String msgFrom) {
              this.port = port;
              this.msgFrom=msgFrom;
              try {
                  socket=new DatagramSocket(port);
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
          @Override
          public void run() {
              while (true){
                  try {
                      byte[] container=new byte[1024];
                      DatagramPacket packet=new DatagramPacket(container,0,container.length);
                      socket.receive(packet);
                      byte[] data=packet.getData();
                      String receiveData=new String(data,0,data.length);
                      System.out.println(msgFrom+":"+receiveData);
                      if (receiveData.equals("bye")){
                          break;
                      }
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              socket.close();
          }
      }
      
    • A

      package Net.Demo05;
      public class TalkStudent {
          public static void main(String[] args) {
              new Thread(new TalkSend(7777,"localhost",9999)).start();
              new Thread(new TalkReceive(8888,"老师")).start();
          }
      }
      
    • B

      package Net.Demo05;
      public class TalkTeacher {
          public static void main(String[] args) {
              new Thread(new TalkSend(5555,"localhost",8888)).start();
              new Thread(new TalkReceive(9999,"学生")).start();
          }
      }
      

    URL

    • 统一资源定位符:定位资源得,定位互联网上得某一个资源
    • DNS 域名解析 www.baidu.com: xxx.x…x…x
    • 协议://ip地址:端口/项目名/资源
    package Net.PA;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    public class UrlDown {
        public static void main(String[] args) throws Exception {
            URL url=new URL("https://ws.stream.qqmusic.qq.com/C400002zpsxr1TlBvY.m4a?guid=7983659658&vkey=5EF7C88327DF6EDC07FB84C564CB1884F2D0B9AE7AACE0A72C8B387FB122CF1B1586FA8B6DE434A00A74B55AAE314FB2806E0C4C6B4F7DC9&uin=7739&fromtag=66");
            HttpURLConnection urlConnection=(HttpURLConnection) url.openConnection();
            InputStream inputStream=urlConnection.getInputStream();
            FileOutputStream fos =new FileOutputStream("f.m4a");
            byte[] buffer=new byte[1024];
            int len;
            while ((len=inputStream.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
            fos.close();
            inputStream.close();
            urlConnection.disconnect();
        }
    }
    
    展开全文
  • 客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收一个客户端的请求就会建立一个新的线程去处理...
    72e8f433a2b665de163bdad533c17cda.png

    这是一个简单的C/S架构,基本实现思路是将服务器注册至某个空闲端口用来监视并处理每个客户端的传输请求。

    客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收到一个客户端的请求就会建立一个新的线程去处理它,根据接收到的文件名到目标路径中去寻找目标路径中是否已经有该文件名的.temp临时文件(如果没有就创建它),之后服务器会将文件已经传输的大小(临时文件大小)返回给客户端(例如临时文件刚刚建立返回的便是0),客户端会将刚刚建立的RandomAccessFile对象的文件指针指向服务器返回的位置,之后以1kb为一组向服务器传输需传输文件的内容数据,服务器则接收数据并将其写入临时文件中,并根据现有数据画出进度条。在文件传输完毕后客户端会将临时文件重命名为最初接收到的文件名。

    服务器代码:

    import java.awt.Color;import java.awt.Container;import java.awt.Dimension;import java.awt.FlowLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.File;import java.io.IOException;import java.io.RandomAccessFile;import java.net.ServerSocket;import java.net.Socket;import javax.swing.BoxLayout;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JOptionPane;import javax.swing.JPanel;import javax.swing.JProgressBar; public class FileTransferServer extends ServerSocket {  private static final int SERVER_PORT = 8899; // 服务端端口  public FileTransferServer() throws Exception { super(SERVER_PORT); }  public void load() throws Exception { while (true) { // server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的 Socket socket = this.accept();  // 每接收到一个Socket就建立一个新的线程来处理它 new Thread(new Task(socket)).start(); } } //处理客户端传输过来的文件线程类 class Task implements Runnable {  private Socket socket; private DataInputStream dis; private DataOutputStream dos; private RandomAccessFile rad; private JFrame frame; //用来显示进度条 private Container contentPanel; private JProgressBar progressbar; private JLabel label;  public Task(Socket socket) { frame = new JFrame("文件传输"); this.socket = socket; }  @Override public void run() { try { dis = new DataInputStream(socket.getInputStream()); dos = new DataOutputStream(socket.getOutputStream()); String targetPath = dis.readUTF(); //接收目标路径 String fileName = dis.readUTF(); //接收文件名 //System.out.println("服务器:接收文件名"); long fileLength = dis.readLong(); //接收文件长度 //System.out.println("服务器:接收文件长度"); File directory = new File(targetPath); //目标地址 if(!directory.exists()) { //目标地址文件夹不存在则创建该文件夹 directory.mkdir(); } File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp"); //建立临时数据文件.temp //System.out.println("服务器:加载temp文件"); rad = new RandomAccessFile(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp
    展开全文
  •  客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收一个客户端的请求就...

    Java断点续传(基于socket与RandomAccessFile的简单实现)

      这是一个简单的C/S架构,基本实现思路是将服务器注册至某个空闲端口用来监视并处理每个客户端的传输请求。

      客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收到一个客户端的请求就会建立一个新的线程去处理它,根据接收到的文件名到目标路径中去寻找目标路径中是否已经有该文件名的.temp临时文件(如果没有就创建它),之后服务器会将文件已经传输的大小(临时文件大小)返回给客户端(例如临时文件刚刚建立返回的便是0),客户端会将刚刚建立的RandomAccessFile对象的文件指针指向服务器返回的位置,之后以1kb为一组向服务器传输需传输文件的内容数据,服务器则接收数据并将其写入临时文件中,并根据现有数据画出进度条。在文件传输完毕后客户端会将临时文件重命名为最初接收到的文件名。

      服务器代码:

    import java.awt.Color;
    import java.awt.Container;
    import java.awt.Dimension;
    import java.awt.FlowLayout;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.swing.BoxLayout;
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    import javax.swing.JProgressBar;
     
    public class FileTransferServer extends ServerSocket {
     
        private static final int SERVER_PORT = 8899; // 服务端端口
     
        public FileTransferServer() throws Exception {
            super(SERVER_PORT);
        }
     
        public void load() throws Exception {
            while (true) {
                // server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
                Socket socket = this.accept();
               
                // 每接收到一个Socket就建立一个新的线程来处理它
                new Thread(new Task(socket)).start();
            }
        }
         //处理客户端传输过来的文件线程类
        class Task implements Runnable {
     
            private Socket socket;
            private DataInputStream dis;
            private DataOutputStream dos;
            private RandomAccessFile rad;
            private JFrame frame;    //用来显示进度条
            private Container contentPanel;
            private JProgressBar progressbar;
            private JLabel label;
                
            public Task(Socket socket) {
                frame = new JFrame("文件传输");
                this.socket = socket;
            }
     
            @Override
            public void run() {
                try {
                    dis = new DataInputStream(socket.getInputStream());
                    dos = new DataOutputStream(socket.getOutputStream());
                    String targetPath = dis.readUTF();    //接收目标路径
                    String fileName = dis.readUTF();    //接收文件名
                    //System.out.println("服务器:接收文件名");
                    long fileLength = dis.readLong();    //接收文件长度
                    //System.out.println("服务器:接收文件长度");
                    File directory = new File(targetPath);    //目标地址
                    if(!directory.exists()) {    //目标地址文件夹不存在则创建该文件夹
                        directory.mkdir();
                    }
                    File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp");    //建立临时数据文件.temp
                    //System.out.println("服务器:加载temp文件");
                    rad = new RandomAccessFile(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp", "rw");
                    long size = 0;
                    if(file.exists() && file.isFile()){    //如果目标路径存在且是文件,则获取文件大小
                        size = file.length();
                    }
                    //System.out.println("服务器:获的当前已接收长度");
                    dos.writeLong(size);    //向客户端发送当前数据文件大小
                    dos.flush();
                    //System.out.println("服务器:发送当前以接收文件长度");
                    int barSize = (int)(fileLength / 1024);    //进度条当前进度
                    int barOffset = (int)(size / 1024);        //进度条总长
                    frame.setSize(300,120); //传输界面
                    contentPanel = frame.getContentPane();
                    contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
                    progressbar = new JProgressBar();    //进度条
                    label = new JLabel(fileName + " 接收中");
                    contentPanel.add(label);
                    progressbar.setOrientation(JProgressBar.HORIZONTAL);    //进度条为水平
                    progressbar.setMinimum(0);    //进度条最小值
                    progressbar.setMaximum(barSize);    //进度条最大值
                    progressbar.setValue(barOffset);    //进度条当前值
                    progressbar.setStringPainted(true); //显示进度条信息
                    progressbar.setPreferredSize(new Dimension(150, 20));    //进度条大小
                    progressbar.setBorderPainted(true);    //为进度条绘制边框
                    progressbar.setBackground(Color.pink);    //进度条颜色为骚粉
                    JButton cancel = new JButton("取消");    //取消按钮
                    JPanel barPanel = new JPanel();
                    barPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
                    barPanel.add(progressbar);
                    barPanel.add(cancel);
                    contentPanel.add(barPanel);
                    cancel.addActionListener(new cancelActionListener());
                    //为取消按钮注册监听器
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setVisible(true);
                    rad.seek(size);    //移动文件指针
                    //System.out.println("服务器:文件定位完成");
                    int length;
                    byte[] bytes=new byte[1024];
                    while((length = dis.read(bytes, 0, bytes.length)) != -1){
                        rad.write(bytes,0, length);    //写入文件
                        progressbar.setValue(++barOffset);    //更新进度条(由于进度条每个单位代表大小为1kb,所以太小的文件就显示不出啦)
                    }
                    if (barOffset >= barSize) {    //传输完成后的重命名
                        if(rad != null)
                             rad.close();
                        if(!file.renameTo(new File(directory.getAbsolutePath() + File.separatorChar + fileName))) {
                            file.delete();
                            //防御性处理删除临时文件
                        }
                        //System.out.println("服务器:临时文件重命名完成");
                    }        
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {    //关闭资源
                        if(rad != null)
                             rad.close();
                        if(dis != null)
                            dis.close();
                        if(dos != null)
                            dos.close();
                        frame.dispose();
                        socket.close();
                    } catch (Exception e) {}
                }
            }
            class cancelActionListener implements ActionListener{    //取消按钮监听器
                public void actionPerformed(ActionEvent e){
                    try {
                        //System.out.println("服务器:接收取消");
                        if(dis != null)
                            dis.close();
                        if(dos != null)
                            dos.close();
                        if(rad != null)
                            rad.close();
                        frame.dispose();
                        socket.close();
                        JOptionPane.showMessageDialog(frame, "已取消接收,连接关闭!", "提示:", JOptionPane.INFORMATION_MESSAGE);    
                        label.setText(" 取消接收,连接关闭");
                    } catch (IOException e1) {
                        
                    }
                }
            }
        }  
    }

      客户端代码:

    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.Socket; 
    
    public class FileTransferClient extends Socket {
     
        private static final String SERVER_IP = "127.0.0.1"; // 服务端IP
        private static final int SERVER_PORT = 8899; // 服务端端口
        private Socket client;
        private DataOutputStream dos;
        private DataInputStream dis;  
        private RandomAccessFile rad;  
    
        public FileTransferClient() throws Exception {
            super(SERVER_IP, SERVER_PORT);
            this.client = this;
            //System.out.println("客户端:成功连接服务端");
        }
        
        public void sendFile(String filePath, String targetPath) throws Exception {
            try {
                File file = new File(filePath);
                
                if(file.exists()) {
                    dos = new DataOutputStream(client.getOutputStream());     //发送信息 getOutputStream方法会返回一个java.io.OutputStream对象
                    dis = new DataInputStream(client.getInputStream());    //接收远程对象发送来的信息  getInputStream方法会返回一个java.io.InputStream对象
                    dos.writeUTF(targetPath); //发送目标路径
                    dos.writeUTF(file.getName()); //发送文件名
                    //System.out.println("客户端:发送文件名");
                    rad = new RandomAccessFile(file.getPath(), "r");
                    /*
                     * RandomAccessFile是Java输入输出流体系中功能最丰富的文件内容访问类,既可以读取文件内容,也可以向文件输出数据。
                     * 与普通的输入/输出流不同的是,RandomAccessFile支持跳到文件任意位置读写数据,RandomAccessFile对象包含一个记录指针,用以标识当前读写处的位置。
                     * 当程序创建一个新的RandomAccessFile对象时,该对象的文件记录指针对于文件头 r代表读取
                     */
                    dos.flush();    //作用见下方介绍
                    dos.writeLong(file.length()); //发送文件长度
                    //System.out.println("客户端:发送文件长度");
                    dos.flush();
                    long size = dis.readLong();    //读取当前已发送文件长度
                    //System.out.println("客户端:开始传输文件 ");
                    int length = 0;
                    byte[] bytes = new byte[1024];    //每1kb发送一次
                    if (size < rad.length()) {
                        rad.seek(size);
                        //System.out.println("客户端:文件定位完成");
                        //移动文件指针
                        while((length = rad.read(bytes)) > 0){
                            dos.write(bytes, 0, length);                            
                            dos.flush();
                            //每1kb清空一次缓冲区
                            //为了避免每读入一个字节都写一次,java的输流有了缓冲区,读入数据时会首先将数据读入缓冲区,等缓冲区满后或执行flush或close时一次性进行写入操作
                        }
                    }
                    //System.out.println("客户端:文件传输成功 ");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {    //关闭资源
                if(dos != null)
                    dos.close();
                if(dis != null)
                    dis.close();
                if(rad != null)
                    rad.close();
                client.close();
            }
            
        }
     
        class cancelActionListener implements ActionListener{    //关闭按钮监听器
            public void actionPerformed(ActionEvent e3){
                try {
                    //System.out.println("客户端:文件传输取消");
                    if(dis != null)
                        dis.close();
                    if(dos != null)
                        dos.close();
                    if(rad != null)
                        rad.close();
                    client.close();
                } catch (IOException e1) {
                    
                }
            }
        }   
    }

      传输文件是一个耗时操作,若直接实例化客户端对服务器发送数据会造成UI假死的情况,直到文件传输完成后才会恢复,所以建议在实例化客户端时单独建立一个新线程。

      测试代码:

    import javax.swing.JFrame;
    import javax.swing.JButton;
    import javax.swing.JFileChooser;
    import java.awt.event.ActionListener;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.awt.event.ActionEvent;
    
    public class MainFrame extends JFrame{
        public MainFrame() {
            this.setSize(1280, 768);
            getContentPane().setLayout(null);
            
            JButton btnNewButton = new JButton("传输文件");    //点击按钮进行文件传输
            btnNewButton.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    // TODO 自动生成的方法存根
                    super.mouseClicked(e);
                    JFileChooser fileChooser = new JFileChooser();    //fileChooser用来选择要传输的文件
                    fileChooser.setDialogTitle("选择要传输的文件");
                    int stFile = fileChooser.showOpenDialog(null);
                    if(stFile == fileChooser.APPROVE_OPTION){    //选择了文件
                        JFileChooser targetPathChooser = new JFileChooser();    //targetPathChooser用来选择目标路径
                        targetPathChooser.setDialogTitle("选择目标路径");
                        targetPathChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);    //只能选择路径
                        int stPath = targetPathChooser.showOpenDialog(null);
                        if(stPath == targetPathChooser.APPROVE_OPTION) {    //选择了路径
                            //新建一个线程实例化客户端
                            new Thread(new NewClient( fileChooser.getSelectedFile().getPath(), targetPathChooser.getSelectedFile().getPath())).start();
                        }
                    }
                }
            });
            btnNewButton.setBounds(526, 264, 237, 126);
            getContentPane().add(btnNewButton);
        }
        class NewClient implements Runnable {    //用于实例化客户端的线程
            private String fileP;    //需复制文件路径
            private String targetP;    //目标路径
            public NewClient(String fileP, String targetP) {    //构造函数
                this.fileP = fileP;
                this.targetP = targetP;
            }
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                try {
                    @SuppressWarnings("resource")
                    FileTransferClient ftc = new FileTransferClient();
                    //实例化客户端
                    ftc.sendFile(fileP, targetP);
                } catch (Exception e1) {
                    // TODO 自动生成的 catch 块
                    e1.printStackTrace();
                }
            }
        }
        public static void main(String[] args) {
            // TODO 自动生成的方法存根
            MainFrame mainFrame = new MainFrame();
            mainFrame.setVisible(true);
            mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            try {
                 @SuppressWarnings("resource")
                FileTransferServer server = new FileTransferServer(); // 启动服务端
                 server.load();
            } catch (Exception e) {
                  e.printStackTrace();
            }
        }
    }

      演示:

      1运行MainFame

      2点击传输文件

      3选择要传输的文件

      4选择目标路径

      5点击打开

      点击取消

      之后重复2 - 5的操作。

      啊我手速慢,问题不大,你会发现断点续传已经实现了。

    转载于:https://www.cnblogs.com/suvvm/p/10839543.html

    展开全文
  •  客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收一个客户端的请求就会建立一个新的线程去...

    这是一个简单的C/S架构,基本实现思路是将服务器注册至某个空闲端口用来监视并处理每个客户端的传输请求。

      客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收到一个客户端的请求就会建立一个新的线程去处理它,根据接收到的文件名到目标路径中去寻找目标路径中是否已经有该文件名的.temp临时文件(如果没有就创建它),之后服务器会将文件已经传输的大小(临时文件大小)返回给客户端(例如临时文件刚刚建立返回的便是0),客户端会将刚刚建立的RandomAccessFile对象的文件指针指向服务器返回的位置,之后以1kb为一组向服务器传输需传输文件的内容数据,服务器则接收数据并将其写入临时文件中,并根据现有数据画出进度条。在文件传输完毕后客户端会将临时文件重命名为最初接收到的文件名。

      服务器代码:

    import java.awt.Color;
    import java.awt.Container;
    import java.awt.Dimension;
    import java.awt.FlowLayout;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.swing.BoxLayout;
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    import javax.swing.JProgressBar;
    
    public class FileTransferServer extends ServerSocket {
    
        private static final int SERVER_PORT = 8899; // 服务端端口
    
        public FileTransferServer() throws Exception {
            super(SERVER_PORT);
        }
    
        public void load() throws Exception {
            while (true) {
                // server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
                Socket socket = this.accept();
    
                // 每接收到一个Socket就建立一个新的线程来处理它
                new Thread(new Task(socket)).start();
            }
        }
         //处理客户端传输过来的文件线程类
        class Task implements Runnable {
    
            private Socket socket;
            private DataInputStream dis;
            private DataOutputStream dos;
            private RandomAccessFile rad;
            private JFrame frame;    //用来显示进度条
            private Container contentPanel;
            private JProgressBar progressbar;
            private JLabel label;
    
            public Task(Socket socket) {
                frame = new JFrame("文件传输");
                this.socket = socket;
            }
    
            @Override
            public void run() {
                try {
                    dis = new DataInputStream(socket.getInputStream());
                    dos = new DataOutputStream(socket.getOutputStream());
                    String targetPath = dis.readUTF();    //接收目标路径
                    String fileName = dis.readUTF();    //接收文件名
                    //System.out.println("服务器:接收文件名");
                    long fileLength = dis.readLong();    //接收文件长度
                    //System.out.println("服务器:接收文件长度");
                    File directory = new File(targetPath);    //目标地址
                    if(!directory.exists()) {    //目标地址文件夹不存在则创建该文件夹
                        directory.mkdir();
                    }
                    File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp");    //建立临时数据文件.temp
                    //System.out.println("服务器:加载temp文件");
                    rad = new RandomAccessFile(directory.getAbsolutePath() + File.separatorChar + fileName + ".temp", "rw");
                    long size = 0;
                    if(file.exists() && file.isFile()){    //如果目标路径存在且是文件,则获取文件大小
                        size = file.length();
                    }
                    //System.out.println("服务器:获的当前已接收长度");
                    dos.writeLong(size);    //向客户端发送当前数据文件大小
                    dos.flush();
                    //System.out.println("服务器:发送当前以接收文件长度");
                    int barSize = (int)(fileLength / 1024);    //进度条当前进度
                    int barOffset = (int)(size / 1024);        //进度条总长
                    frame.setSize(300,120); //传输界面
                    contentPanel = frame.getContentPane();
                    contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
                    progressbar = new JProgressBar();    //进度条
                    label = new JLabel(fileName + " 接收中");
                    contentPanel.add(label);
                    progressbar.setOrientation(JProgressBar.HORIZONTAL);    //进度条为水平
                    progressbar.setMinimum(0);    //进度条最小值
                    progressbar.setMaximum(barSize);    //进度条最大值
                    progressbar.setValue(barOffset);    //进度条当前值
                    progressbar.setStringPainted(true); //显示进度条信息
                    progressbar.setPreferredSize(new Dimension(150, 20));    //进度条大小
                    progressbar.setBorderPainted(true);    //为进度条绘制边框
                    progressbar.setBackground(Color.pink);    //进度条颜色为骚粉
                    JButton cancel = new JButton("取消");    //取消按钮
                    JPanel barPanel = new JPanel();
                    barPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
                    barPanel.add(progressbar);
                    barPanel.add(cancel);
                    contentPanel.add(barPanel);
                    cancel.addActionListener(new cancelActionListener());
                    //为取消按钮注册监听器
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.setVisible(true);
                    rad.seek(size);    //移动文件指针
                    //System.out.println("服务器:文件定位完成");
                    int length;
                    byte[] bytes=new byte[1024];
                    while((length = dis.read(bytes, 0, bytes.length)) != -1){
                        rad.write(bytes,0, length);    //写入文件
                        progressbar.setValue(++barOffset);    //更新进度条(由于进度条每个单位代表大小为1kb,所以太小的文件就显示不出啦)
                    }
                    if (barOffset >= barSize) {    //传输完成后的重命名
                        if(rad != null)
                             rad.close();
                        if(!file.renameTo(new File(directory.getAbsolutePath() + File.separatorChar + fileName))) {
                            file.delete();
                            //防御性处理删除临时文件
                        }
                        //System.out.println("服务器:临时文件重命名完成");
                    }        
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {    //关闭资源
                        if(rad != null)
                             rad.close();
                        if(dis != null)
                            dis.close();
                        if(dos != null)
                            dos.close();
                        frame.dispose();
                        socket.close();
                    } catch (Exception e) {}
                }
            }
            class cancelActionListener implements ActionListener{    //取消按钮监听器
                public void actionPerformed(ActionEvent e){
                    try {
                        //System.out.println("服务器:接收取消");
                        if(dis != null)
                            dis.close();
                        if(dos != null)
                            dos.close();
                        if(rad != null)
                            rad.close();
                        frame.dispose();
                        socket.close();
                        JOptionPane.showMessageDialog(frame, "已取消接收,连接关闭!", "提示:", JOptionPane.INFORMATION_MESSAGE);    
                        label.setText(" 取消接收,连接关闭");
                    } catch (IOException e1) {
    
                    }
                }
            }
        }  
    }

    客户端代码:

    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.net.Socket; 
    
    public class FileTransferClient extends Socket {
    
        private static final String SERVER_IP = "127.0.0.1"; // 服务端IP
        private static final int SERVER_PORT = 8899; // 服务端端口
        private Socket client;
        private DataOutputStream dos;
        private DataInputStream dis;  
        private RandomAccessFile rad;  
    
        public FileTransferClient() throws Exception {
            super(SERVER_IP, SERVER_PORT);
            this.client = this;
            //System.out.println("客户端:成功连接服务端");
        }
    
        public void sendFile(String filePath, String targetPath) throws Exception {
            try {
                File file = new File(filePath);
    
                if(file.exists()) {
                    dos = new DataOutputStream(client.getOutputStream());     //发送信息 getOutputStream方法会返回一个java.io.OutputStream对象
                    dis = new DataInputStream(client.getInputStream());    //接收远程对象发送来的信息  getInputStream方法会返回一个java.io.InputStream对象
                    dos.writeUTF(targetPath); //发送目标路径
                    dos.writeUTF(file.getName()); //发送文件名
                    //System.out.println("客户端:发送文件名");
                    rad = new RandomAccessFile(file.getPath(), "r");
                    /*
                     * RandomAccessFile是Java输入输出流体系中功能最丰富的文件内容访问类,既可以读取文件内容,也可以向文件输出数据。
                     * 与普通的输入/输出流不同的是,RandomAccessFile支持跳到文件任意位置读写数据,RandomAccessFile对象包含一个记录指针,用以标识当前读写处的位置。
                     * 当程序创建一个新的RandomAccessFile对象时,该对象的文件记录指针对于文件头 r代表读取
                     */
                    dos.flush();    //作用见下方介绍
                    dos.writeLong(file.length()); //发送文件长度
                    //System.out.println("客户端:发送文件长度");
                    dos.flush();
                    long size = dis.readLong();    //读取当前已发送文件长度
                    //System.out.println("客户端:开始传输文件 ");
                    int length = 0;
                    byte[] bytes = new byte[1024];    //每1kb发送一次
                    if (size < rad.length()) {
                        rad.seek(size);
                        //System.out.println("客户端:文件定位完成");
                        //移动文件指针
                        while((length = rad.read(bytes)) > 0){
                            dos.write(bytes, 0, length);                            
                            dos.flush();
                            //每1kb清空一次缓冲区
                            //为了避免每读入一个字节都写一次,java的输流有了缓冲区,读入数据时会首先将数据读入缓冲区,等缓冲区满后或执行flush或close时一次性进行写入操作
                        }
                    }
                    //System.out.println("客户端:文件传输成功 ");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {    //关闭资源
                if(dos != null)
                    dos.close();
                if(dis != null)
                    dis.close();
                if(rad != null)
                    rad.close();
                client.close();
            }
    
        }
    
        class cancelActionListener implements ActionListener{    //关闭按钮监听器
            public void actionPerformed(ActionEvent e3){
                try {
                    //System.out.println("客户端:文件传输取消");
                    if(dis != null)
                        dis.close();
                    if(dos != null)
                        dos.close();
                    if(rad != null)
                        rad.close();
                    client.close();
                } catch (IOException e1) {
    
                }
            }
        }   
    }

    传输文件是一个耗时操作,若直接实例化客户端对服务器发送数据会造成UI假死的情况,直到文件传输完成后才会恢复,所以建议在实例化客户端时单独建立一个新线程。

    测试代码:

    import javax.swing.JFrame;
    import javax.swing.JButton;
    import javax.swing.JFileChooser;
    import java.awt.event.ActionListener;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.awt.event.ActionEvent;
    
    public class MainFrame extends JFrame{
        public MainFrame() {
            this.setSize(1280, 768);
            getContentPane().setLayout(null);
    
            JButton btnNewButton = new JButton("传输文件");    //点击按钮进行文件传输
            btnNewButton.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    // TODO 自动生成的方法存根
                    super.mouseClicked(e);
                    JFileChooser fileChooser = new JFileChooser();    //fileChooser用来选择要传输的文件
                    fileChooser.setDialogTitle("选择要传输的文件");
                    int stFile = fileChooser.showOpenDialog(null);
                    if(stFile == fileChooser.APPROVE_OPTION){    //选择了文件
                        JFileChooser targetPathChooser = new JFileChooser();    //targetPathChooser用来选择目标路径
                        targetPathChooser.setDialogTitle("选择目标路径");
                        targetPathChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);    //只能选择路径
                        int stPath = targetPathChooser.showOpenDialog(null);
                        if(stPath == targetPathChooser.APPROVE_OPTION) {    //选择了路径
                            //新建一个线程实例化客户端
                            new Thread(new NewClient( fileChooser.getSelectedFile().getPath(), targetPathChooser.getSelectedFile().getPath())).start();
                        }
                    }
                }
            });
            btnNewButton.setBounds(526, 264, 237, 126);
            getContentPane().add(btnNewButton);
        }
        class NewClient implements Runnable {    //用于实例化客户端的线程
            private String fileP;    //需复制文件路径
            private String targetP;    //目标路径
            public NewClient(String fileP, String targetP) {    //构造函数
                this.fileP = fileP;
                this.targetP = targetP;
            }
            @Override
            public void run() {
                // TODO 自动生成的方法存根
                try {
                    @SuppressWarnings("resource")
                    FileTransferClient ftc = new FileTransferClient();
                    //实例化客户端
                    ftc.sendFile(fileP, targetP);
                } catch (Exception e1) {
                    // TODO 自动生成的 catch 块
                    e1.printStackTrace();
                }
            }
        }
        public static void main(String[] args) {
            // TODO 自动生成的方法存根
            MainFrame mainFrame = new MainFrame();
            mainFrame.setVisible(true);
            mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            try {
                 @SuppressWarnings("resource")
                FileTransferServer server = new FileTransferServer(); // 启动服务端
                 server.load();
            } catch (Exception e) {
                  e.printStackTrace();
            }
        }
    }

    演示:

    1运行MainFame

    2点击传输文件

    Java断点续传(基于socket与RandomAccessFile的实现)

    3选择要传输的文件

    Java断点续传(基于socket与RandomAccessFile的实现)

    4选择目标路径

    Java断点续传(基于socket与RandomAccessFile的实现)

    5点击打开

    Java断点续传(基于socket与RandomAccessFile的实现)

      点击取消

      之后重复2 - 5的操作。

    Java断点续传(基于socket与RandomAccessFile的实现)

    你会发现断点续传已经实现了


    本文的重点是你有没有收获与成长,其余的都不重要,希望读者们能谨记这一点。同时我经过多年的收藏目前也算收集到了一套完整的学习资料,包括但不限于:分布式架构、高可扩展、高性能、高并发、Jvm性能调优、Spring,MyBatis,Nginx源码分析,Redis,ActiveMQ、、Mycat、Netty、Kafka、Mysql、Zookeeper、Tomcat、Docker、Dubbo、Nginx等多个知识点高级进阶干货,希望对想成为架构师的朋友有一定的参考和帮助
    需要更详细思维导图和以下资料的可以加一下技术交流分享群:“708 701 457”免费获取
    Java断点续传(基于socket与RandomAccessFile的实现)
    Java断点续传(基于socket与RandomAccessFile的实现)
    Java断点续传(基于socket与RandomAccessFile的实现)

    转载于:https://blog.51cto.com/14230003/2407115

    展开全文
  • 客户端先获得用户给予的需传输文件与目标路径,之后根据该文件实例化RandomAccessFile为只读,之后客户端向服务器发送需传输的文件名文件大小与目标路径,服务器没接收一个客户端的请求就会建立一个新的线程去处理...
  • java基础-网络编程

    2021-03-28 14:16:04
    java基础-网络编程C/SIP端口通信协议TCP文件上传UDPUDP消息发送UDP聊天实现多线程 C/S B/S是网页编程,与网络编程不同 定位网络上的一台主机 IP:唯一地址 端口:定位这个计算机上的某个资源 传输数据 规则:...
  • 基本socket编程,介绍socket编程的基本步骤,启动socket服务器后,在打开socket的客户端,在输入框里输入消息发送到服务器,服务器受到消息后返回给客户端; Http服务器,httpsever.java; 一个支持多线程的服务器...
  • java 面试题 总结

    2009-09-16 08:45:34
    但通常情况下,由于Java Bean是被容器所创建(如Tomcat)的,所以Java Bean应具有一个无参的构造器,另外,通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地...
  • bindPort()将远程主机的端口映射本地某个端口 6、com.baijob.commonTools.net.URLUtil 将相对、绝对路径转换为URL对象,用于网络或文件流的读写,Setting的配置依赖此工具包 四、线程相关工具类 1、...
  • 但通常情况下,由于Java Bean是被容器所创建(如Tomcat)的,所以Java Bean应具有一个无参的构造器,另外,通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地...
  • 网络编程学习笔记1.1、概述1.2、网络通信的要素1.3、IP1.4 、端口1.5、通信协议1.6、TCP文件上传1.7、UDP1、发送消息2、咨询1.8、URL 1.1、概述 本博文是学习b站up主狂神的视频,狂神讲Java,所做的学习笔记 狂神:...
  • 而DOClever独创的自动化测试功能,只需要你编写极少量的javascript代码便可以在网页里完成这样一系列操作,同时,DOClever还提供了后台定时批量执行测试用例并把结果发送到团队成员邮箱的功能,你可以及时获取接口的...
  • JIRA 从入门精通.doc

    千次下载 热门讨论 2011-10-20 13:22:17
    一个问题就创建完成,然后邮件就会发送到相关人员邮箱中。 注:上图中的填写,可能每个公司的配置一样,需要根据具体情况进行设置。 3、 浏览项目 在浏览项目的界面可以看到项目的基本信息资料,模块和版本信息及...
  • 而 KCP是为流速设计的(单个数据包从一端发送到一端需要多少时间),以10%-20%带宽浪费的代价换取了比 TCP快30%-40%的传输速度。TCP信道是一条流速很慢,但每秒流量很大的大运河,而KCP是水流湍急的小激流。KCP有...
  • public boolean deleteSendList(String ip,String path) 当发送完成某个文件后,从发送列表中删除以发送文件。 private void showWrong(String msg,Exception e) 用JOptionPane显示错误的原因。 private void ...
  • 山寨QQ源代码

    热门讨论 2012-02-11 08:20:49
    用户登录成功后,将自己所有的好友列表从文件中读取,放在一个向量中发送给服务器,服务器查看哪些人在在线用户列表中,然后返回用户的在线好友,同时通知这些在线好友某人人上线了,还是利用已建立的套接字。...
  • 新版Android开发教程.rar

    千次下载 热门讨论 2010-12-14 15:49:11
    � Google 提供了一套 Java 核心包 (J2SE 5,J2SE 6) 的有限子集,尚不承诺遵守 Java 任何 Java 规范 , 可能会造 成J ava 阵营的进一步分裂。 � 现有应用完善度不太够,需要的开发工作量较大。--------------------...
  • finishToActivity : 结束指定 Activity finishOtherActivities : 结束所有其他类型的 Activity finishAllActivities : 结束所有 Activity finishAllActivitiesExceptNewest: 结束除最新之外的所有 Activity ...
  • 添加Idempotent修饰的方法,可以让ICE更好地实现“自动恢复错误”机制,即在某个Ice Object调用失败的情况下,ICE会再次调用有Idempotent修饰的方法,透明恢复故障,而在客户端看来则调用正常,没有感觉ICE做了...
  • git reset回退到某个历史版本 SVN分支使用使用说明 SVN 版本管理系统的安装 使用nexus3 配置maven的私有仓库 Maven在生成环境的使用及其配置说明 Nexus Repository 3 介绍 Maven 私有库Sonatype Nexus2 ...
  • SSO-WebDemo

    2013-08-12 20:25:57
    其中值得一提的是OpenSSO (https://opensso.dev.java.net),为用Java实现WEB-SSO提供架构指南和服务指南,为用户自己来实现WEB-SSO提供了理论的依据和实现的方法。 为什么说WEB-SSO比较容易实现呢?这是有WEB应用...
  • adb1.0.26包含fastboot.exe

    2019-03-05 15:11:03
    上面是当前最新版 v1.0.36 的 adb 的输出,会显示 push apk 文件到手机的进度百分比。 使用旧版本 adb 的输出则是这样的: 12040 KB/s (22205609 bytes in 1.801s) pkg: /data/local/tmp/SogouInput_android_v8.3...
  • IIS6.0 IIS,互联网信息服务

    热门讨论 2010-08-23 21:20:55
    多个域名对应同个Web站点 你只需先将某个IP地址绑定Web站点上,再在DNS服务器中,将所需域名全部映射向你的这个IP地址上,则你在浏览器中输入任何一个域名,都会直接得到所设置好的那个网站的内容。 搭建IIS服务器...
  • 2.5.6 在NetWare 网络中,客户需要访问某个类型的服务器时,首先要发送一个 ()广播报文来寻找服务器? 2.5.7 IPX地址网络地址有( )个字节? 2.5.8 对于帧中继描述正确的是? 2.5.9 对于INVERSE ARP的描述正确...
  • 当创建任务的时候根据任务类型选择一个组,要执行任务的时候会发送到相应的组的机器上执行任务)。 对于执行work的机器ip调试时可以是master,生产环境建议不要让master执行任务。如果要执行map-reduce或者spark任务...

空空如也

空空如也

1 2
收藏数 38
精华内容 15
关键字:

java实现文件发送到某个端口

java 订阅