`
lzkyo
  • 浏览: 466250 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java socket编程收藏之一

编程SocketJava网络应用应用服务器 
阅读更多

(1)Server端

Java代码 复制代码
  1. import java.io.BufferedInputStream;   
  2. import java.io.DataInputStream;   
  3. import java.io.DataOutputStream;   
  4. import java.io.File;   
  5. import java.io.FileInputStream;   
  6. import java.net.ServerSocket;   
  7. import java.net.Socket;   
  8.   
  9. public class Server{   
  10.        
  11.     //ServerSocket监听的端口,等待客户连接请求，客户连接后，会话产生,在完成会话后，关闭连接。   
  12.     int port = 8821;   
  13.   
  14.     void start() {   
  15.         Socket s = null;   
  16.         try {   
  17.             //在连接成功时，应用程序两端都会产生一个Socket实例   
  18.             ServerSocket ss = new ServerSocket(port);   
  19.             while (true) {   
  20.                    
  21.                 String filePath = "D:/bars.jar";   
  22.                 File fi = new File(filePath);   
  23.   
  24.                 //Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例   
  25.                 System.out.println("Ready to accept task!");   
  26.                 s = ss.accept();   
  27.                    
  28.                 //s.getInputStream()获得网络连接输入，同时返回一个IutputStream对象实例   
  29.                 DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));   
  30.                 dis.readByte();   
  31.   
  32.                 DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));   
  33.                 //s.getOutputStream()网络连接输出   
  34.                 DataOutputStream ps = new DataOutputStream(s.getOutputStream());   
  35.                 //将文件名及长度传给客户端。   
  36.                 ps.writeUTF(fi.getName());   
  37.                 ps.flush();   
  38.                 ps.writeLong((long) fi.length());   
  39.                 ps.flush();   
  40.   
  41.                 int bufferSize = 8192;   
  42.                 byte[] buf = new byte[bufferSize];   
  43.   
  44.                 while (true) {   
  45.                     int read = 0;   
  46.                     if (fis != null) {   
  47.                         read = fis.read(buf);   
  48.                     }   
  49.   
  50.                     if (read == -1) {   
  51.                         break;   
  52.                     }   
  53.                     ps.write(buf, 0, read);   
  54.                 }   
  55.                 ps.flush();   
  56.                 fis.close();   
  57.                 s.close(); //关闭socket                  
  58.                 System.out.println("Task over!");   
  59.             }   
  60.   
  61.         } catch (Exception e) {   
  62.             e.printStackTrace();   
  63.         }   
  64.     }   
  65.   
  66.     public static void main(String arg[]) {   
  67.         new Server().start();   
  68.     }   
  69. }  
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 Server{
	
	//ServerSocket监听的端口,等待客户连接请求，客户连接后，会话产生,在完成会话后，关闭连接。
    int port = 8821;

    void start() {
        Socket s = null;
        try {
        	//在连接成功时，应用程序两端都会产生一个Socket实例
            ServerSocket ss = new ServerSocket(port);
            while (true) {
            	
                String filePath = "D:/bars.jar";
                File fi = new File(filePath);

                //Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例
                System.out.println("Ready to accept task!");
                s = ss.accept();
                
                //s.getInputStream()获得网络连接输入，同时返回一个IutputStream对象实例
                DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
                dis.readByte();

                DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
                //s.getOutputStream()网络连接输出
                DataOutputStream ps = new DataOutputStream(s.getOutputStream());
                //将文件名及长度传给客户端。
                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();
                fis.close();
                s.close(); //关闭socket               
                System.out.println("Task over!");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String arg[]) {
        new Server().start();
    }
}



(2)ClientSocket辅助类

Java代码 复制代码
  1. import java.net.*;   
  2. import java.io.*;   
  3.   
  4. public class ClientSocket {   
  5.     private String ip;   
  6.   
  7.     private int port;   
  8.   
  9.     private Socket socket = null;   
  10.   
  11.     DataOutputStream out = null;   
  12.   
  13.     DataInputStream getMessageStream = null;   
  14.   
  15.     public ClientSocket(String ip, int port) {   
  16.         this.ip = ip;   
  17.         this.port = port;   
  18.     }   
  19.   
  20.     /**  
  21.      * 创建socket连接  
  22.      * @throws Exception  
  23.      */  
  24.     public void CreateConnection() throws Exception {   
  25.         try {   
  26.             socket = new Socket(ip, port);   
  27.         } catch (Exception e) {   
  28.             e.printStackTrace();   
  29.             if (socket != null)   
  30.                 socket.close();   
  31.             throw e;   
  32.         }   
  33.     }   
  34.   
  35.     /**  
  36.      * 往Socket写数据  
  37.      * @param sendMessage  
  38.      * @throws Exception  
  39.      */  
  40.     public void sendMessage(String sendMessage) throws Exception {   
  41.         try {   
  42.             out = new DataOutputStream(socket.getOutputStream());   
  43.             if (sendMessage.equals("Windows")) {   
  44.                 out.writeByte(0x1);   
  45.                 out.flush();   
  46.                 return;   
  47.             }else {   
  48.                 out.writeUTF(sendMessage);   
  49.                 out.flush();   
  50.             }   
  51.         } catch (Exception e) {   
  52.             e.printStackTrace();   
  53.             if (out != null)   
  54.                 out.close();   
  55.             throw e;   
  56.         }    
  57.     }   
  58.   
  59.     /**  
  60.      * 从Socket读数据  
  61.      * @return  
  62.      * @throws Exception  
  63.      */  
  64.     public DataInputStream getMessageStream() throws Exception {   
  65.         try {   
  66.             getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream()));   
  67.             return getMessageStream;   
  68.         } catch (Exception e) {   
  69.             e.printStackTrace();   
  70.             if (getMessageStream != null)   
  71.                 getMessageStream.close();   
  72.             throw e;   
  73.         }   
  74.     }   
  75.   
  76.     public void shutDownConnection() {   
  77.         try {   
  78.             if (out != null)   
  79.                 out.close();   
  80.             if (getMessageStream != null)   
  81.                 getMessageStream.close();   
  82.             if (socket != null)   
  83.                 socket.close();   
  84.         } catch (Exception e) {   
  85.   
  86.         }   
  87.     }   
  88. }  
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
     */
    public void CreateConnection() throws Exception {
        try {
            socket = new Socket(ip, port);
        } catch (Exception e) {
            e.printStackTrace();
            if (socket != null)
                socket.close();
            throw e;
        }
    }

    /**
     * 往Socket写数据
     * @param sendMessage
     * @throws Exception
     */
    public void sendMessage(String sendMessage) throws Exception {
        try {
            out = new DataOutputStream(socket.getOutputStream());
            if (sendMessage.equals("Windows")) {
                out.writeByte(0x1);
                out.flush();
                return;
            }else {
                out.writeUTF(sendMessage);
                out.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (out != null)
                out.close();
            throw e;
        } 
    }

    /**
     * 从Socket读数据
     * @return
     * @throws Exception
     */
    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;
        }
    }

    public void shutDownConnection() {
        try {
            if (out != null)
                out.close();
            if (getMessageStream != null)
                getMessageStream.close();
            if (socket != null)
                socket.close();
        } catch (Exception e) {

        }
    }
}



(3)客户端

Java代码 复制代码
  1. import java.io.BufferedOutputStream;   
  2. import java.io.DataInputStream;   
  3. import java.io.DataOutputStream;   
  4. import java.io.FileOutputStream;   
  5.   
  6. public class ClientTest {   
  7.     //Socket对网络上某一个服务器的某一个端口发出连接请求   
  8.     private ClientSocket cs = null;   
  9.   
  10.     private String ip = "localhost";   
  11.   
  12.     private int port = 8821;   
  13.   
  14.     private String sendMessage = "Windwos";   
  15.   
  16.     public ClientTest() {   
  17.         try {   
  18.             if (createConnection()) {   
  19.                 sendMessage();   
  20.                 getMessage();   
  21.             }   
  22.   
  23.         } catch (Exception ex) {   
  24.             ex.printStackTrace();   
  25.         }   
  26.     }   
  27.   
  28.     private boolean createConnection() {   
  29.         cs = new ClientSocket(ip, port);   
  30.         try {   
  31.             cs.CreateConnection();   
  32.             System.out.print("连接服务器成功!" + "\n");   
  33.             return true;   
  34.         } catch (Exception e) {   
  35.             System.out.print("连接服务器失败!" + "\n");   
  36.             return false;   
  37.         }   
  38.   
  39.     }   
  40.   
  41.     private void sendMessage() {   
  42.         if (cs == null)   
  43.             return;   
  44.         try {   
  45.             cs.sendMessage(sendMessage);   
  46.         } catch (Exception e) {   
  47.             System.out.print("发送消息失败!" + "\n");   
  48.         }   
  49.     }   
  50.   
  51.     private void getMessage() {   
  52.         if (cs == null)   
  53.             return;   
  54.         DataInputStream inputStream = null;   
  55.         try {   
  56.             inputStream = cs.getMessageStream();   
  57.         } catch (Exception e) {   
  58.             System.out.print("接收消息缓存错误\n");   
  59.             return;   
  60.         }   
  61.   
  62.         try {   
  63.             //本地保存路径，文件名会自动从服务器端继承而来。   
  64.             String savePath = "E:\\";   
  65.             int bufferSize = 8192;   
  66.             byte[] buf = new byte[bufferSize];   
  67.             int passedlen = 0;   
  68.             long len=0;   
  69.                
  70.             savePath += inputStream.readUTF();   
  71.             DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(savePath)));   
  72.             len = inputStream.readLong();   
  73.                
  74.             System.out.println("文件的长度为:" + len + "\n");   
  75.             System.out.println("开始接收文件!" + "\n");   
  76.                        
  77.             while (true) {   
  78.                 int read = 0;   
  79.                 if (inputStream != null) {   
  80.                     read = inputStream.read(buf);   
  81.                 }   
  82.                 passedlen += read;   
  83.                 if (read == -1) {   
  84.                     break;   
  85.                 }   
  86.                 fileOut.write(buf, 0, read);   
  87.             }   
  88.             System.out.println("接收完成，文件存为" + savePath + "\n");   
  89.   
  90.             fileOut.close();   
  91.         } catch (Exception e) {   
  92.             System.out.println("接收消息错误" + "\n");   
  93.             return;   
  94.         }   
  95.     }   
  96.   
  97.     public static void main(String arg[]) {   
  98.         new ClientTest();   
  99.     }   
  100. }  
分享到：
| spring 事务管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java Socket网络编程.pdf

    在Java中，Socket编程主要涉及两个关键类：`ServerSocket`和`Socket`。`ServerSocket`类用于服务器端，它监听指定端口的连接请求。创建一个`ServerSocket`实例，例如`ServerSocket server = new ServerSocket(9998);...

    Java socket编程实现两台主机间的通信

    Java Socket 编程实现两台主机间的通信 ...Java Socket 编程是实现两台主机间通信的重要技术之一。通过了解 Java Socket 编程的原理、实现方法和应用场景，可以更好地应用 Java Socket 编程来实现网络通信和数据传输。

    总结java_socket编程.doc

    Socket编程是Java语言中用于网络编程的主要技术之一。Socket是一种编程界面，用于实现客户方和服务方的连接。Socket通常用来实现客户机/服务器结构的通信。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket...

    JAVA Socket编程实现文件上传

    Java Socket编程是网络编程的基础，它提供了在两个应用程序之间建立通信连接的能力。在这个场景中，我们讨论的是如何使用Java的Socket来实现文件上传功能，即从客户端将文件发送到服务器，然后保存到服务器的数据库...

    java socket编程

    Java Socket编程是Java平台中用于实现网络通信的核心API，它基于TCP/IP协议栈，提供了低级别的、面向连接的、可靠的字节流通信。在本文中，我们将深入探讨Java Socket编程的关键概念、工作原理以及如何创建服务端和...

    java socket 编程

    java socket编程 java网络编程 课件 java socket编程 java网络编程 课件

    java socket 编程文档

    Java套接字编程是网络通信的核心技术之一，它允许Java应用程序之间或应用程序与远程服务器之间的双向数据传输。本文将深入探讨Java Socket编程的基础知识、关键概念以及如何在实践中应用。 一、Socket概述 Socket，...

    java socket 编程，Java socket 编程实例

    接下来，我们通过一个简单的Java Socket编程示例来深入了解如何在Java中实现Socket编程。该示例展示了一个简单的Web客户端程序，用于获取一个HTML页面的内容。 ```java import java.io.*; import java.net.*; ...

    Java Socket 编程html教程

    Java Socket编程是Java网络编程的重要组成部分，主要用于实现客户端与服务器之间的通信。在本文中，我们将深入探讨Java Socket编程的基础知识，以及如何结合HTML进行交互。 首先，Java Socket是TCP/IP协议族的一...

    三步学会Java_Socket编程

    在Java中，Socket编程是实现网络通信的基础，它提供了进程间通信的能力，使得两个相隔万里的计算机可以通过互联网进行数据交换。本篇文章将深入讲解如何通过三步学习Java Socket编程。 **第一步：理解Socket** ...

    java的Socket编程

    Java的Socket编程是Java网络编程的核心部分，它提供了在TCP/IP协议栈上进行通信的机制。Socket接口是对TCP/IP协议的抽象，使得开发者能够轻松地创建客户端和服务器应用程序，实现网络上的数据交换。在这个主题中，...

    总结java_socket编程

    Java Socket编程是Java网络编程的核心部分，主要用于实现客户端与服务器之间的通信。在TCP/IP协议族中，IP层主要处理主机的定位和数据路由，而TCP和UDP层则提供了数据传输的机制。Java Socket编程主要涉及TCP和UDP这...

    Java面试之Socket编程

    Java网络编程是开发分布式应用程序的关键技术之一，其中Socket编程扮演着至关重要的角色。在Java面试中，对Socket编程的理解和应用能力通常是评估开发者技能的重要标准。以下是对Socket编程的详细阐述： 1. **Java ...

    java Socket 编程源码

    Java Socket编程是网络编程的基础，它提供了在Java中进行低级网络通信的接口。Socket是TCP/IP协议族的一部分，用于实现客户端与服务器之间的双向通信。在这个"java TCP_IP Socket 编程"源码中，我们可以深入理解...

    JAVA Socket 经典教程

    本教程将深入探讨Java Socket编程的核心概念，以及如何利用它进行网络通信。 1. **Java Socket基础** - **Socket的概念**：Socket是网络通信中的一个端点，可以理解为两台机器间通信的桥梁。在Java中，Socket类...

    JAVA Socket 网络编程教程

    本教程将深入探讨Java Socket编程的基本概念、原理和实践应用。 一、Socket基本概念 Socket，也被称为套接字，是网络通信中的一个重要接口，它为两台计算机提供了一个低级别的、进程到进程的通信机制。在Java中，...

    Java socket网络编程的基础示例

    在Java中，我们可以使用`java.net.Socket`类和`java.net.ServerSocket`类来实现TCP Socket编程。`ServerSocket`用于监听客户端的连接请求，`Socket`则代表一个客户端连接。以下是一个简单的TCP服务器端和客户端示例...

    Java Socket编程.pdf

    输入输出流是用于数据读写的接口，是Socket编程中的核心概念之一。 6. 发送和接收数据 数据在发送和接收前需要进行编码和解码。信息编码包括基本整型、字符串和文本、位操作等。组合输入输出流允许同时读写多个...

    Java源码：Socket编程.rar_java socket _java编程_socket java_socket编程 jav

    本资料包含的"Java源码：Socket编程"是一个示例，旨在帮助开发者理解并掌握Java中的Socket编程技术。 首先，Socket编程涉及的主要类有`ServerSocket`和`Socket`。`ServerSocket`类用于创建服务器端的监听套接字，它...

    Java TCP IP Socket编程(原书第2版).

    《Java TCP/IP Socket编程(原书第2版)》基于TCP/IP Socket相关原理，对如何在Java中进行Socket编程作了深入浅出的介绍。《Java TCP/IP Socket编程(原书第2版)》内容简明扼要，条理清晰，并在讲解相应的概念或编程...

Magicbox
Global site tag (gtag.js) - Google Analytics