AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java网络编程--套接字Socket

2013-08-22 630
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、套接字Socket IP地址标志Internet上的计算机，端口号标志正在计算机上运行的进程（程序）。 端口号被规定为一个16位的0--65535之间的整数，其中，0--1023被预先定义的服务通信占用。

一、套接字Socket

IP地址标志Internet上的计算机，端口号标志正在计算机上运行的进程（程序）。

端口号被规定为一个16位的0--65535之间的整数，其中，0--1023被预先定义的服务通信占用。

当两个程序需要通信时，可以通过Socket类建立套接字对象并连接在一起。（端口号与IP地址的组合得出的一个网络套接字）

 

二、示例

（1）客户端服务器端一对一；聊天

 1 package mychat;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.net.Socket;
 9 import java.net.UnknownHostException;
10 
11 public class Client {
12 
13     /**
14      * @param args
15      */
16     public static void main(String[] args) {
17         // TODO Auto-generated method stub
18         Socket client = null;
19         //读服务器说的话
20         BufferedReader br = null;
21         //写个服务器
22         BufferedWriter bw = null;
23         //读键盘
24         BufferedReader input = null;
25         try {
26             client = new Socket("127.0.0.1",6666);
27             while(true)
28             {
29             //从键盘写
30                 System.out.println("客户端说:");
31                 input = new BufferedReader(new InputStreamReader(System.in));
32                 String str = input.readLine();
33                 //写给服务器
34                 bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
35                 bw.write(str);
36                 bw.newLine();
37                 bw.flush();
38                 //接受服务器信息
39                 br = new BufferedReader(new InputStreamReader(client.getInputStream()));
40                 String line =null;
41                 line = br.readLine();
42                 System.out.println("服务器说"+line);
43             }
44             
45         
46         } catch (UnknownHostException e) {
47             // TODO Auto-generated catch block
48             e.printStackTrace();
49         } catch (IOException e) {
50             // TODO Auto-generated catch block
51             e.printStackTrace();
52         }
53         
54     }
55 
56 }
Client.java客户端 
 1 package mychat;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.IOException;
 6 import java.io.InputStreamReader;
 7 import java.io.OutputStreamWriter;
 8 import java.net.ServerSocket;
 9 import java.net.Socket;
10 
11 public class Server {
12 
13     public static void main(String[] args) {
14         // TODO Auto-generated method stub
15         BufferedReader input = null;
16         BufferedWriter bw =null;
17         BufferedReader br = null;
18         Socket socket = null;
19         try {
20             ServerSocket server = new ServerSocket(6666);
21             
22             System.out.println("等待客户端响应");
23             socket = server.accept();
24             System.out.println("与客户端建立连接");
25             //读
26             br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
27             //写
28             bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
29             input = new BufferedReader(new InputStreamReader(System.in));
30             
31             
32             while(true)
33             {
34                 String line = br.readLine();
35                     System.out.println("客户端说:"+line);
36                 //写
37                     
38                 System.out.println("请输入服务器说的话");
39                 String str = input.readLine();
40                 bw.write(str);
41                 bw.newLine();
42                 bw.flush();
43                 System.out.println("服务器说："+str);
44             }
45             
46         } catch (IOException e) {
47             // TODO Auto-generated catch block
48             e.printStackTrace();
49         }
50         finally{
51             try {
52                 br.close();
53             } catch (IOException e) {
54                 // TODO Auto-generated catch block
55                 e.printStackTrace();
56             }
57             try {
58                 bw.close();
59             } catch (IOException e) {
60                 // TODO Auto-generated catch block
61                 e.printStackTrace();
62             }
63             try {
64                 input.close();
65             } catch (IOException e) {
66                 // TODO Auto-generated catch block
67                 e.printStackTrace();
68             }
69             try {
70                 socket.close();
71             } catch (IOException e) {
72                 // TODO Auto-generated catch block
73                 e.printStackTrace();
74             }
75             
76         }
77     }
78 
79 }
Server.java服务器端

（2）客户端上传文件（字符）

 1 package loadzifu;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.File;
 6 import java.io.FileReader;
 7 import java.io.IOException;
 8 import java.io.InputStreamReader;
 9 import java.io.OutputStreamWriter;
10 import java.net.Socket;
11 import java.net.UnknownHostException;
12 
13 public class Client {
14 
15     /**
16      * @param args
17      */
18     public static void main(String[] args) {
19         // TODO Auto-generated method stub
20         Socket client = null;
21         //读文件名
22         BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
23         //读本地文件
24         File f=null;
25         BufferedReader brFile = null;
26         BufferedWriter bw = null;
27         try {
28             client = new Socket("127.0.0.1",6666);
29             bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
30             System.out.println("请输入要上传的文件");
31             String fileName = input.readLine();
32             brFile = new BufferedReader(new FileReader(("src/chat/"+fileName)));
33             String line =null;
34             while((line= brFile.readLine())!=null)
35             {
36                 //写个客户端
37                 bw.write(line);
38                 bw.newLine();
39                 bw.flush();
40                 
41             }
42             
43         } catch (UnknownHostException e) {
44             // TODO Auto-generated catch block
45             e.printStackTrace();
46         } catch (IOException e) {
47             // TODO Auto-generated catch block
48             e.printStackTrace();
49         }
50         finally{
51             try {
52                 bw.close();
53             } catch (IOException e) {
54                 // TODO Auto-generated catch block
55                 e.printStackTrace();
56             }
57             try {
58                 brFile.close();
59             } catch (IOException e) {
60                 // TODO Auto-generated catch block
61                 e.printStackTrace();
62             }
63             try {
64                 input.close();
65             } catch (IOException e) {
66                 // TODO Auto-generated catch block
67                 e.printStackTrace();
68             }
69         }
70         
71         
72     }
73 
74 }
Client.java客户端 
 1 package loadzifu;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.File;
 6 import java.io.FileOutputStream;
 7 import java.io.FileWriter;
 8 import java.io.IOException;
 9 import java.io.InputStreamReader;
10 import java.io.OutputStreamWriter;
11 import java.net.ServerSocket;
12 import java.net.Socket;
13 
14 public class Server {
15 
16     /**
17      * @param args
18      */
19     public static void main(String[] args) {
20         // TODO Auto-generated method stub
21         ServerSocket server = null;
22         Socket socket = null;
23         BufferedReader br =null;
24         BufferedWriter bwFile = null;
25         try {
26             server = new ServerSocket(6666);
27             System.out.println("等待客户端连接");
28             socket = server.accept();
29             System.out.println("与客户端建立连接");
30             File f = new File("src/loadzifu/a.txt");
31             bwFile = new BufferedWriter(new FileWriter(f));
32             br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
33             String str = null;
34             while((str=br.readLine())!=null)
35             {
36                 bwFile.write(str);
37                 bwFile.newLine();
38                 bwFile.flush();
39             }
40             
41         } catch (IOException e) {
42             // TODO Auto-generated catch block
43             e.printStackTrace();
44         }
45         finally{
46             try {
47                 br.close();
48             } catch (IOException e) {
49                 // TODO Auto-generated catch block
50                 e.printStackTrace();
51             }
52             try {
53                 bwFile.close();
54             } catch (IOException e) {
55                 // TODO Auto-generated catch block
56                 e.printStackTrace();
57             }
58             try {
59                 socket.close();
60             } catch (IOException e) {
61                 // TODO Auto-generated catch block
62                 e.printStackTrace();
63             }
64         }
65         
66     }
67 
68 }
Server.java服务器端

（3）客户端上传文件（字节）

 1 package loadzijie;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.BufferedReader;
 6 import java.io.File;
 7 import java.io.FileInputStream;
 8 import java.io.IOException;
 9 import java.io.InputStream;
10 import java.io.InputStreamReader;
11 import java.net.Socket;
12 import java.net.UnknownHostException;
13 
14 public class Client {
15 
16     public static void main(String[] args) {
17         // TODO Auto-generated method stub
18         Socket client = null;
19         //读文件
20         BufferedInputStream bisFile = null;
21         //源文件
22         File f = null;
23         //读键盘
24         BufferedReader input = null;
25         //写个服务器
26         BufferedOutputStream bos = null;
27         try {
28             client = new Socket("127.0.0.1",7777);
29             
30             System.out.println("请输入要复制的文件");
31             input = new BufferedReader(new InputStreamReader(System.in));
32             String fileName = input.readLine();
33             f = new File("src/chat/"+fileName);
34             //读文件
35             bisFile = new BufferedInputStream(new FileInputStream(f));
36             bos = new BufferedOutputStream(client.getOutputStream());
37             int len=0;
38             byte bytes[] = new byte[1024];
39             while((len=bisFile.read(bytes))!=-1)
40             {
41                 bos.write(bytes,0,len);
42                 bos.flush();
43             }
44             
45             
46             
47             
48         } catch (UnknownHostException e) {
49             // TODO Auto-generated catch block
50             e.printStackTrace();
51         } catch (IOException e) {
52             // TODO Auto-generated catch block
53             e.printStackTrace();
54         }finally{
55             try {
56                 bos.close();
57             } catch (IOException e) {
58                 // TODO Auto-generated catch block
59                 e.printStackTrace();
60             }
61             try {
62                 client.close();
63             } catch (IOException e) {
64                 // TODO Auto-generated catch block
65                 e.printStackTrace();
66             }
67             try {
68                 bisFile.close();
69             } catch (IOException e) {
70                 // TODO Auto-generated catch block
71                 e.printStackTrace();
72             }
73         }
74         
75     }
76 
77 }
Client.java客户端 
 1 package loadzijie;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.BufferedWriter;
 6 import java.io.File;
 7 import java.io.FileInputStream;
 8 import java.io.FileOutputStream;
 9 import java.io.IOException;
10 import java.net.ServerSocket;
11 import java.net.Socket;
12 
13 public class Server {
14 
15     public static void main(String[] args) {
16         // TODO Auto-generated method stub
17             ServerSocket server = null;
18             Socket socket = null;
19             File f = null;
20             BufferedInputStream bis = null;
21             BufferedOutputStream bosFile = null;
22             
23             try {
24                 server = new ServerSocket(7777);
25                 System.out.println("等待客户端连接");
26                 socket = server.accept();
27                 System.out.println("与客户端建立连接");
28                 f = new File("src/loadzijie/dd.bmp");
29                 bis = new BufferedInputStream(socket.getInputStream());
30                 bosFile = new BufferedOutputStream(new FileOutputStream(f));
31                 int len =0;
32                 byte bytes[] = new byte[1024];
33                 while((len = bis.read(bytes))!=-1)
34                 {
35                     //写文件
36                     bosFile.write(bytes,0,len);
37                     bosFile.flush();
38                     
39                 }
40                 System.out.println("上传成功");
41                 
42                 
43             } catch (IOException e) {
44                 // TODO Auto-generated catch block
45                 e.printStackTrace();
46             }
47             finally{
48                 try {
49                     bis.close();
50                 } catch (IOException e) {
51                     // TODO Auto-generated catch block
52                     e.printStackTrace();
53                 }
54                 try {
55                     bosFile.close();
56                 } catch (IOException e) {
57                     // TODO Auto-generated catch block
58                     e.printStackTrace();
59                 }
60                 try {
61                     socket.close();
62                 } catch (IOException e) {
63                     // TODO Auto-generated catch block
64                     e.printStackTrace();
65                 }
66             }
67     }
68 
69 }
Server.java服务器端

（4）服务器端多线程接受客户端文件

 1 package loadget;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.BufferedReader;
 6 import java.io.File;
 7 import java.io.FileInputStream;
 8 import java.io.IOException;
 9 import java.io.InputStreamReader;
10 import java.net.Socket;
11 import java.net.UnknownHostException;
12 
13 public class Client {
14 
15     /**
16      * @param args
17      */
18     public static void main(String[] args) {
19         // TODO Auto-generated method stub
20         Socket client = null;
21         File f = null;
22         //读键盘
23         BufferedReader input = null;
24         //读文件
25         BufferedInputStream brFile = null;
26         //上传服务器
27         BufferedOutputStream bos = null;
28         try {
29             client = new Socket("127.0.0.1",7777);
30             System.out.println("请输入要上传的文件");
31             input = new BufferedReader(new InputStreamReader(System.in));
32             String fileName = input.readLine();
33             bos = new BufferedOutputStream(client.getOutputStream());
34             f = new File(("src/chat/"+fileName));
35             //读文件
36             brFile = new BufferedInputStream(new FileInputStream(f));
37             int len =0;
38             byte bytes[]= new byte[1024];
39             while((len=brFile.read(bytes))!=-1)
40             {
41                 bos.write(bytes,0,len);
42                 bos.flush();
43             }
44         
45         } catch (UnknownHostException e) {
46             // TODO Auto-generated catch block
47             e.printStackTrace();
48         } catch (IOException e) {
49             // TODO Auto-generated catch block
50             e.printStackTrace();
51         }
52         finally{
53             try {
54                 bos.close();
55             } catch (IOException e1) {
56                 // TODO Auto-generated catch block
57                 e1.printStackTrace();
58             }
59             try {
60                 brFile.close();
61             } catch (IOException e1) {
62                 // TODO Auto-generated catch block
63                 e1.printStackTrace();
64             }
65             try {
66                 client.close();
67             } catch (IOException e) {
68                 // TODO Auto-generated catch block
69                 e.printStackTrace();
70             }
71         }
72         
73     }
74 
75 }
Client.java客户端 
 1 package loadget;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.BufferedOutputStream;
 5 import java.io.File;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 import java.net.ServerSocket;
 9 import java.net.Socket;
10 
11 public class Server {
12 
13     /**
14      * @param args
15      */
16     public static void main(String[] args) {
17         // TODO Auto-generated method stub
18         ServerSocket server = null;
19         //接受文件
20         
21         
22         try {
23             server = new ServerSocket(7777);
24             
25             while(true)
26             {
27                 
28                 System.out.println("等待与客户端连接");
29                 final Socket sock = server.accept();
30                 System.out.println("与客户端建立连接");
31                 new Thread(new Runnable() {
32                     BufferedInputStream bis = null;
33                             //写文件
34                             BufferedOutputStream bos =null;
35                     @Override
36                     public void run() {
37                         // TODO Auto-generated method stub
38                         try {
39                             
40                             bis = new BufferedInputStream(sock.getInputStream());
41                             int a = (int)(Math.random()*10000+2);
42                             System.out.println("a:"+a);
43                             File fileName = new File("src/loadget/a.txt");
44                             bos = new BufferedOutputStream(new FileOutputStream(fileName));
45                             int len =0;
46                             byte bytes[] = new byte[1024];
47                             while((len=bis.read(bytes))!=-1)
48                             {
49                                 bos.write(bytes,0,len);
50                                 bos.flush();
51                             }
52                             
53                         } catch (IOException e) {
54                             // TODO Auto-generated catch block
55                             e.printStackTrace();
56                         }
57                         finally{
58                             try {
59                                 bos.close();
60                             } catch (IOException e) {
61                                 // TODO Auto-generated catch block
62                                 e.printStackTrace();
63                             }
64                             try {
65                                 bis.close();
66                             } catch (IOException e) {
67                                 // TODO Auto-generated catch block
68                                 e.printStackTrace();
69                             }
70                             try {
71                                 sock.close();
72                             } catch (IOException e) {
73                                 // TODO Auto-generated catch block
74                                 e.printStackTrace();
75                             }
76                         }
77                         
78                     }
79                 }).start();
80             }
81             
82             
83         } catch (IOException e) {
84             // TODO Auto-generated catch block
85             e.printStackTrace();
86         }    
87     }
88 }
Server.java服务器端

 

文章标签：
Java
关键词：
Java网络
Java网络编程
网络编程socket
网络socket
socket网络编程
听着music睡
目录
相关文章
东方睿赢
|
1月前
|
人工智能 Java 物联网
JAVA网络编程的未来：URL与URLConnection的无限可能，你准备好了吗？
随着技术的发展和互联网的普及，JAVA网络编程迎来新的机遇。本文通过案例分析，探讨URL与URLConnection在智能API调用和实时数据流处理中的关键作用，展望其未来趋势和潜力。
东方睿赢
46 7
兴化
|
1月前
|
网络协议 Java 物联网
Java网络编程知识点
Java网络编程知识点
兴化
43 13
喵帕斯先生
|
1月前
|
安全 Java API
深入探索Java网络编程中的HttpURLConnection：从基础到进阶
本文介绍了Java网络编程中HttpURLConnection的高级特性，包括灵活使用不同HTTP方法、处理重定向、管理Cookie、优化安全性以及处理大文件上传和下载。通过解答五个常见问题，帮助开发者提升网络编程的效率和安全性。
喵帕斯先生
107 9
东方睿赢
|
1月前
|
JSON 安全 算法
JAVA网络编程中的URL与URLConnection：那些你不知道的秘密！
在Java网络编程中，URL与URLConnection是连接网络资源的两大基石。本文通过问题解答形式，揭示了它们的深层秘密，包括特殊字符处理、请求头设置、响应体读取、支持的HTTP方法及性能优化技巧，帮助你掌握高效、安全的网络编程技能。
东方睿赢
66 9
龙大吉
|
1月前
|
JSON Java API
JAVA网络编程新纪元：URL与URLConnection的神级运用，你真的会了吗？
本文深入探讨了Java网络编程中URL和URLConnection的高级应用，通过示例代码展示了如何解析URL、发送GET请求并读取响应内容。文章挑战了传统认知，帮助读者更好地理解和运用这两个基础组件，提升网络编程能力。
龙大吉
55 5
众所周知
|
1月前
|
Kubernetes 网络协议 Python
Python网络编程：从Socket到Web应用
在信息时代，网络编程是软件开发的重要组成部分。Python作为多用途编程语言，提供了从Socket编程到Web应用开发的强大支持。本文将从基础的Socket编程入手，逐步深入到复杂的Web应用开发，涵盖Flask、Django等框架的应用，以及异步Web编程和微服务架构。通过本文，读者将全面了解Python在网络编程领域的应用。
众所周知
35 1
进步`于辰
|
2月前
|
Java
[Java]Socket套接字（网络编程入门）
本文介绍了基于Java Socket实现的一对一和多对多聊天模式。一对一模式通过Server和Client类实现简单的消息收发；多对多模式则通过Server类维护客户端集合，并使用多线程实现实时消息广播。文章旨在帮助读者理解Socket的基本原理和应用。
进步`于辰
31 1
bruce_xiaowei
|
2月前
|
网络协议 测试技术 网络安全
Python编程-Socket网络编程
Python编程-Socket网络编程
bruce_xiaowei
29 0
东方睿赢
|
5月前
|
网络协议 开发者 Python
深度探索Python Socket编程：从理论到实践，进阶篇带你领略网络编程的魅力！
【7月更文挑战第25天】在网络编程中, Python Socket编程因灵活性强而广受青睐。本文采用问答形式深入探讨其进阶技巧。**问题一**: Socket编程基于TCP/IP,通过创建Socket对象实现通信,支持客户端和服务器间的数据交换。**问题二**: 提升并发处理能力的方法包括多线程(适用于I/O密集型任务)、多进程(绕过GIL限制)和异步IO(asyncio)。**问题三**: 提供了一个使用asyncio库实现的异步Socket服务器示例,展示如何接收及响应客户端消息。通过这些内容,希望能激发读者对网络编程的兴趣并引导进一步探索。
东方睿赢
60 4
龙大吉
|
5月前
|
开发者 Python
Python Socket编程：不只是基础，更有进阶秘籍，让你的网络应用飞起来！
【7月更文挑战第25天】在网络应用蓬勃发展的数字时代，Python凭借其简洁的语法和强大的库支持成为开发高效应用的首选。本文通过实时聊天室案例，介绍了Python Socket编程的基础与进阶技巧，包括服务器与客户端的建立、数据交换等基础篇内容，以及使用多线程和异步IO提升性能的进阶篇。基础示例展示了服务器端监听连接请求、接收转发消息，客户端连接服务器并收发消息的过程。进阶部分讨论了如何利用Python的`threading`模块和`asyncio`库来处理多客户端连接，提高应用的并发处理能力和响应速度。掌握这些技能，能使开发者在网络编程领域更加游刃有余，构建出高性能的应用程序。
龙大吉
37 3

热门文章

最新文章

  • 1
    Java网络编程总结 --URLConnection
  • 2
    Linux网络编程之原始套接字-ping协议实现
  • 3
    【网络编程】网络包捕获技术WinDivert介绍
  • 4
    GO语言练习：网络编程 TCP 示例
  • 5
    linux网络编程----->线程同步-->信号量
  • 6
    Python网络编程 - 一个简单的客户端Get请求程序
  • 7
    IOS网络编程之请求内容
  • 8
    Java：网络编程之UDP的使用
  • 9
    Unix网络编程 3rd vol1 读书笔记
  • 10
    Java---网络编程(1)
  • 1
    Kubernetes学习-集群搭建篇(二) 部署Node服务，启动JNI网络插件
    328
  • 2
    什么是网络安全等级保护测评（等保测评）？
    276
  • 3
    网络安全与信息安全：保护你的数据，保护你的世界
    50
  • 4
    网络防御前线：洞悉漏洞、加密之盾与安全意识觉醒
    40
  • 5
    探索现代网络安全的多层次防御机制
    204
  • 6
    网络安全与信息安全：防御前线的关键技术与意识觉醒
    44
  • 7
    数字堡垒的构建者：网络安全与信息安全的深层剖析
    60
  • 8
    Linux网络编程 网络基础知识
    73
  • 9
    开发板配置网络ssh登入
    75
  • 10
    网络编程知识点总结（7）
    50

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 容器的网络入门
  • 容器的自定义网络
  • 容器的共享网络模型
    • 下一篇
    DataWorks