文章标题
2015-05-22 14:53
183 查看
网络通讯过程：
1、找到对方的IP
2、数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都进行标识。为了方便
称呼这个数字，叫做端口。逻辑端口
3、定义通信规则。这个通信规则成为协议。国际组织定义了通用协议TCP/IP
对象介绍：
InetAddress：此类表示互联网协议 (IP) 地址。
常用方法：
static InetAddress getByName(String host) 给定主机名的情况下，确定主机的IP地址
static InetAddress getLocalHost() 返回本地主机
String getHostAddress() 返回IP地址字符串
String getHostName() 获取此IP地址的主机名
UDP编程
DatagramSocket与DatagramPacket
建立发送端接收端
建立数据包
调用Socket的发送接收方法
关闭Socket
发送端与接收端是两个独立的运行程序
UDP方法介绍：
构造方法： DatagramSocket() 构造数据报套接字并将其绑定到本地主机上任何可用的端口。
DatagramSocket() 创建数据报套接字并将其绑定到本地主机上的指定端口。
方法：void send(DatagramPacket p ) 从此套接字发送数据报包
void receive(DatagramPacket p) 从此套接字接收数据报包。
DatagramPacket 构造函数：
DatagramPacket(byte[] buf , int length) 构造 DatagramPacket，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length,InetAddress address,int port) 构造数据报包，用来将长度为length 的包发送到
指定主机上的指定端口号。
方法：InetAddress getAddress()返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
byte[] getDate() 返回数据缓冲区。
int getLength() 返回将要发送或接收到的数据的长度。
int getPort() 返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
小练习UDP发送：
1. /*需求：通过UDP传输方式，将一段文字数据发送出去
2. * 思路：
3. * 1，建立udpSocket服务
4. * 2，提供数据，并将数据封装到数据包中
5. * 3，通过Socket服务的发送功能，将数据包发出去
6. * 4，关闭资源*/
7. package Test;
8. import java.net.*;
9. public class UDPSendDemo {
10.
11. public static void main(String[] args)throws Exception {
12. //通过DatagramSocket对象，创建UDP服务
13. DatagramSocket ds = new DatagramSocket();
14. //确定数据，并封装成数据包
15. byte[] buf = “UDP ge men lai le”.getBytes();
16. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName(“127.0.0.1”),10000);
17. //通过Socket服务，将已有的数据包发送出去，通过Send方法
18. ds.send(dp);
19. //关闭资源
20. ds.close();
21.
22. }
23.
24. }
25.
UDP接收：
1. /*需求：定义一个应用程序，用于接受udp协议传输的数据并处理
2. * 思路
3. * 1，定义udpsocket服务，通常会监听一个端口。其实就是给这个接受网络应用程序定义一个数字标识
4. * ，方便于明确哪些数据过来该应用程序可以处理
5. * 2，定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据星系
6. * 3，通过socket服务的receive方法将接受的数据数据存入已定义好的数据包中
7. * 4，通过数据包对象的热油功能，将这些不同的数据取出，打印在控制台上。
8. * 5，关闭资源
9. * */
10. package Test;
11. import java.net.*;
12. public class UDPReceiveDemo {
13.
14. public static void main(String[] args)throws Exception {
15. //创建udpsocket，建立站点
16. DatagramSocket ds = new DatagramSocket(10000);
17. byte[] buf = new byte[1024];
18. //定义数据包 用于存储数据
19. DatagramPacket dp = new DatagramPacket(buf,buf.length);
20. //通过服务的receive方法将受到的数据存入数据包中
21. ds.receive(dp);
22. //通过数据包的方法获取其中的数据
23. String ip = dp.getAddress().getHostAddress();
24. String data = new String(dp.getData(),0,dp.getLength());
25. int port = dp.getPort();
26. System.out.println(ip+”:”+data+”:”+port);
27. //关闭资源
28. ds.close();
29. }
30.
31. }
32.
UDP聊天程序：
1. package Inte;
2. /*
3. * 编写一个聊天程序
4. * 有收数据的部分和发数据的部分
5. * 这两部分都需要执行
6. * 那就需要用到多线程的技术
7. * 一个线程控制收，一个线程控制发。
8. * 因为收和发动作时不一致的，所以要定义两个run方法
9. * 而且这两个方法要封装不同的类中
10. */
11. import java.net.*;
12. import java.io.*;
13.
14. public class ChatDemo {
15.
16. public static void main(String[] args) throws Exception{//多线程 运行发送端 和接收端
17. DatagramSocket sendSocket = new DatagramSocket();
18. DatagramSocket receSocket = new DatagramSocket(10005);
19. new Thread(new Send(sendSocket)).start();
20. new Thread(new Rece(receSocket)).start();
21. }
22.
23. }
24. class Send implements Runnable{
25. //创建udp服务，通过DatagramSocket对象
26. private DatagramSocket ds;
27. public Send(DatagramSocket ds){
28. this.ds = ds;
29. }
30.
31. @Override
32. public void run() {
33. try{//接受键盘数据
34. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
35. String line = null;
36. while((line = bufr.readLine()) != null){//读取键盘数据
37. if(“886”.equals(line))
38. break;
39. byte[] buf = line.getBytes();
40. //确定数据，并封装成数据包
41. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName(“127.0.0.1”),10005);
42. //通过socket服务，将已有的数据包发送出去，通过send方法
43. ds.send(dp);
44. }
45. }catch(Exception e ){
46. throw new RuntimeException(“发送错误”);
47. }
48.
49. }
50.
51. }
52. class Rece implements Runnable{
53. //创建udp socket 建立端点
54. private DatagramSocket ds;
55. public Rece(DatagramSocket ds){
56. this.ds = ds;
57. }
58.
59. @Override
60. public void run() {
61. try{
62. while(true){
63. byte[] buf = new byte[1024];
64. //定义数据包 用来存储数据
65. DatagramPacket dp = new DatagramPacket(buf,buf.length);
66. //通过服务的receive方法将收到的数据存入数据包中
67. ds.receive(dp);
68. //通过数据包的方法获取其中的数据
69. String ip = dp.getAddress().getHostAddress();
70. String data = new String(dp.getData(),0,dp.getLength());
71. System.out.println(ip+”:”+data);
72.
73. }
74.
75. }catch(Exception e){
76. throw new RuntimeException(“接收端错误”);
77. }
78.
79. }
80.
81. }
82.
TCP传输
Socket和ServerSocket
建立客户端和服务器端
建立连接后，通过Socket中的IO流进行数据的传输
关闭Socket
同样，客户端和服务器端是两个独立的应用程序
Socket ：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信端点。
构造函数：Socket(InetAddress address , int port) 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
方法: InputStream getInputStream() 返回此套接字的输入流。
OutputStream getOutputStream() 返回此套接字的输出流
InetAddress getInetAddress() 返回套接字连接的地址
ServerSocket 构造函数：
ServerSocket(int port) 创建绑定到特定端口的服务器套接字
方法;Socket accept() 侦听并接受到此套接字的连接。
TCP客户端：
1. 客户端编程步骤：
2. 1、 建立Socket服务，指定要连接主机和端口
3. 2、 获取Socket流中的输出流，将数据发送到该流中，通过网络发送给服务端
4. 3、 关闭客户端资源
5. package Inte;
6. import java.net.*;
7. import java.io.*;
8. public class TcpClient {
9.
10. public static void main(String[] args) throws Exception, IOException {
11. //创建客户端的socket服务，指定目的的主机和端口
12. Socket s = new Socket(“127.0.0.1”,10000);
13. //为了发送数据，获取socket流中的输出流
14. OutputStream out =s.getOutputStream();
15. //写入
16. out.write(“ge men lai le “.getBytes());
17. //关闭客户端socket
18. s.close();
19.
20. }
21.
22. }
23.
TCP服务端：
1. 服务端步骤
2. 1、 建立服务器Socket服务，并监听一个端口
3. 2、 通过accept方法获取连接过来的客户端对象
4. 3、 获取客户端发送过来的数据，使用客户端对象的读取流来读取数据
5. 4
defe
、 关闭客户端 服务端
6. package Inte;
7. import java.net.*;
8. import java.io.*;
9. public class TcpServer {
10.
11. public static void main(String[] args) throws Exception {
12. //建立服务端socket服务，并监听一个端口
13. ServerSocket ss = new ServerSocket(10000);
14. //通过accept方法获取连接过来的客户端对象
15. Socket s =ss.accept();
16. String ip =s.getInetAddress().getHostAddress();
17. System.out.println(ip+”…..connected”);
18. //获取客户端发送过来的数据，使用客户端对象的读取流来读取数据
19. InputStream in = s.getInputStream();
20. byte [] buf = new byte[1024];
21. int len = in.read(buf);
22. System.out.println(new String(buf,0,len));
23. //关闭客户端
24. s.close();
25. ss.close();
26. }
27. }
28.
TCP复制文件：
1. 客户端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class TestClient {
6. public static void main(String[] args) throws Exception {
7. //建立客户度Socket
8. Socket s = new Socket(“127.0.0.1”,10006);
9. //数据读取流
10. BufferedReader bufr = new BufferedReader(new FileReader(“D:\javasl\Test\src\Inte\ChatDemo.java”));
11. //Socket输出流
12. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
13. String line = null;
14. //输出
15. while((line = bufr.readLine()) != null){
16. out.println(line);
17. }
18. //禁止套接字输出流
19. s.shutdownOutput();
20. //Socket读取流
21. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
22. String str = bufIn.readLine();
23. //打印服务器回送过来的数据
24. System.out.println(str);
25. //关闭流
26. bufr.close();
27. //关闭客户端
28. s.close();
29. }
30.
31. }
32.
1. 服务端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class TestServer {
6.
7. public static void main(String[] args) throws Exception {
8. //建立服务端socket
9. ServerSocket ss = new ServerSocket(10006);
10. //获取客户度Socket
11. Socket s =ss.accept();
12. //打印输出连接的客户端IP地址
13. String ip =s.getInetAddress().getHostAddress();
14. System.out.println(ip+”…..connected”);
15. //读取流
16. BufferedReader buf =
17. new BufferedReader(new InputStreamReader(s.getInputStream()));
18. //文件输入流
19. PrintWriter out = new PrintWriter(new FileWriter(“D:\javasl\Test\src\Inte\server.txt”));
20. String line = null;
21. //写入
22. while((line = buf.readLine()) != null){
23. out.write(line);
24.
25. }
26.
27. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
28. //给客户端回送数据
29. pw.println(“上传成功”);
30. //关闭流和客户端 服务端
31. out.close();
32. s.close();
33. ss.close();
34.
35.
36.
37. }
38.
39. }
40.
TCP上传图片
1. 客户端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class PicClient {
6.
7. public static void main(String[] args)throws Exception {
8. //判读参数长度是否为一
9. if(args.length != 1){
10. System.out.println(“请选择一个jpg格式的文件”);
11. return;
12. }
13. //用此参数创造文件
14. File file = new File(args[0]);
15. //判断问价你是否存在以及是否为文件
16. if(!(file.exists()&&file.isFile())){
17. System.out.println(“文件有问题”);
18. return;
19. }
20. //判断文件是否为jpg文件
21. if(!file.getName().endsWith(“.jpg”)){
22. System.out.println(“图片格式错误”);
23. return;
24. }
25. //判断文件大小是否大于3MB
26. if(file.length() > 1034*1024*3){
27. System.out.println(“文件过大”);
28. return;
29. }
30. //创建客户端Socket
31. Socket s = new Socket(“127.0.0.1”,10003 );
32. //读取客户端要上传的图片文件
33. FileInputStream fis = new FileInputStream(file);
34. //获取Socket输出流，将读到的图片数据发送给服务端
35. OutputStream out = s.getOutputStream();
36. byte[] buf = new byte[1024];
37. int len = 0;
38. while((len = fis.read(buf)) != -1){
39. out.write(buf, 0, len);
40. }
41. //告诉服务端说，这边的数据发送完毕。让服务器停止读取
42. s.shutdownOutput();
43. //InputStream in = s.getInputStream();
44. //byte [] bufIn = new byte[1024];
45. //int num = 0;
46. //num = in.read(bufIn);
47. //读取服务端发回的内容
48. BufferedReader bufn = new BufferedReader(new InputStreamReader(s.getInputStream()));
49. String line = null;
50. line = bufn.readLine();
51. System.out.println(line);
52. //关闭流与客户端
53. fis.close();
54. s.close();
55. }
56. }
57.
58.
1. 服务端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class PicServer {
6. public static void main(String[] args)throws Exception {
7. ServerSocket ss = new ServerSocket(10003);
8. while(true){
9. Socket s = ss.accept();
10. new Thread(new PicThread(s)).start();
11. }
12. }
13. }
14. class PicThread implements Runnable{
15. //创建TCP的Socket服务端
16. private Socket s ;
17. public PicThread(Socket s ){
18. this.s = s;
19. }
20. @Override
21. public void run() {
22. int count = 1;
23. String ip = s.getInetAddress().getHostAddress();
24. try{
25. System.out.println(ip+”….connected”);
26. //读取客户端发来的数据
27. InputStream in = s.getInputStream();
28. //定义文件名
29. File file = new File(“D:\”+ip+”(“+(count)+”)”+”.jpg”);
30. while(file.exists())
31. file = new File(“D:\”+ip+”(“+(count++)+”)”+”.jpg”);
32. //将读取到的数据存储到一个文件中
33. FileOutputStream fos = new FileOutputStream(file);
34.
35. byte[] buf = new byte[1024];
36. int len = 0;
37. while((len = in.read(buf)) != -1){
38. fos.write(buf, 0, len);
39. }
40. //OutputStream out = s.getOutputStream();
41. //out.write(“上传成功”.getBytes());
42. //给客户端回送传送结果数据
43. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
44. pw.println(“上传成功”);
45. //关闭流 关闭客户端
46. fos.close();
47. s.close();
48. }catch(Exception e){
49.
50. }
51.
52. }
53.
54. }
55.
登陆
客户端：
1. package Inte;
2. import java.net.*;
3. import java.io.*;
4. public class LoginClient {
5. public static void main(String[] args) throws Exception {
6. //建立客户端Socket
7. Socket s = new Socket(“127.0.0.1”,10007);
8. //键盘录入
9. BufferedReader bufr =
10. new BufferedReader(new InputStreamReader(System.in));
11. //获取Socket输出流
12. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
13. //获取Socket读取流
14. BufferedReader bufIn =
15. new BufferedReader(new InputStreamReader(s.getInputStream()));
16. for(int x = 0 ; x < 3 ; x++){
17. //读取键盘录入的用户名
18. String line = bufr.readLine();
19. if(line == null)
20. break;
21. //将用户名发送到服务端
22. out.println(line);
23. //读取服务端回送数据
24. String info = bufIn.readLine();
25. System.out.println(info);
26. if(info.contains(“欢迎”))
27. break;
28. }
29. bufr.close();
30. s.close();
31. }
32.
33. }
34.
服务端
1. package Inte;
2. import java.net.*;
3. import java.io.*;
4. public class LoginServer {
5. public static void main(String[] args) throws Exception {
6. //创建服务端Socket 并监听007端口
7. ServerSocket ss = new ServerSocket(10007);
8. while(true){
9. //获取连接的客户端Socket
10. Socket s = ss.accept();
11. new Thread(new UserThread(s)).start();
12. }
13.
14. }
15.
16. }
17. class UserThread implements Runnable {
18. private Socket s ;
19. public UserThread(Socket s){
20. this.s =s ;
21. }
22. @Override
23. public void run() {
24. //获取连接但服务端的ip
25. String ip = s.getInetAddress().getHostAddress();
26. System.out.println(ip+”connected”);
27. try{
28. for(int x = 0; x<3; x++){
29. //获取Socket读取流
30. BufferedReader bufIn =
31. new BufferedReader(new InputStreamReader(s.getInputStream()));
32. String name = bufIn.readLine();
33. //如果读取的数据为空 则程序结束
34. if(name == null)
35. break;
36. //读取存放用户名的文件
37. BufferedReader bufr =new BufferedReader(new FileReader(“D:\a.txt”));
38. //获得客户端Socket输出流
39. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
40. String line = null;
41. boolean flag = false;
42. //将服务端传过来的用户名与文件中的用户名一一对比，想同则将flag置为true
43. while((line = bufr.readLine()) != null){
44. if(line.equals(name)){
45. flag =true;
46. break;
47. }
48. }
49. //如果用户名存在 服务端显示xxx，已登录 并且把xxx。欢迎登陆发送到客户端显示
50. if(flag){
51. System.out.println(name+”已登录”);
52. out.println(name+”,欢迎光临”);
53. break;
54. }
55. //用户名不存在 服务端显示xxx，尝试登陆，把用户名xxx，不存在发送到客户端 显示
56. else{
57. System.out.println(name+”尝试登陆”);
58. out.println(“用户名”+name+”不存在”);
59. }
60. }
61. }catch(Exception e){
62. throw new RuntimeException(ip+”尝试失败”);
63. }
64.
65. }
66.
67. }
68.
69.
自定义浏览器
1. package Test3;
2.
3. import java.io.*;
4. import java.net.*;
5.
6. public class MyIE {
7.
8. public static void main(String[] args) throws Exception{
9. //建立客户端Socket服务
10. Socket s = new Socket(“122.207.132.49”, 8080);
11. //获取Socket输出流
12. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
13. //模拟浏览器给服务器发送相应数据
14. pw.println(“GET /MyWeb/1.html HTTP/1.1”);
15. pw.println(“Accept: text/html, application/xhtml+xml, /“);
16. pw.println(“Accept-Language: zh-CN”);
17. pw.println(“Accept-Encoding: gzip, deflate”);
18. pw.println(“Host: 122.207.132.49:10011”);
19. pw.println(“Connection: closed”);
20. pw.println();
21. pw.println();
22. //Socket读取流
23. InputStream in = s.getInputStream();
24. byte[] buf = new byte[1024];
25. int len = 0;
26. //读服务器发过来的数据
27. len =in.read(buf);
28. //将数据打印到控制台上
29. System.out.println(new String(buf,0,len));
30. }
31. }
32.
URL：类 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对
更为复杂的对象的引用，例如对数据库或搜索引擎的查询。
构造函数：URL(string spec) 根据 String 表示形式创建URL 对象。
方法：String getFile() 获取此 URL 的文件名。
String getHost() 获取此 URL 的主机名（如果适用）。
String getPath() 获取此 URL 的路径部分。
int getPort() 获取此 URL 的端口号。
String getProtocal() 获取此 URL 的协议名称。
String getQuery() 获取此 URL 的查询部分。
URLConnection openConnection() 返回一个URLConnection 对象，它表示到URL 所引用的远程对象的连接。
URLConnection的方法：InputStream getInputStream() 返回从此打开的连接读取的输入流。
练习方法：
1. package Test3;
2. import java.net.*;
3. import java.io.*;
4. public class URlDemo {
5.
6. public static void main(String[] args)throws Exception {
7. //创建URL对象
8. URL url = new URL(“http://122.207.132.49:8080/MyWeb/1.html?name=fdl“);
9. //获取协议
10. String protocal = url.getProtocol();
11. //获取主机
12. String host = url.getHost();
13. //获取端口号
14. int port = url.getPort();
15. //获取路径
16. String path = url.getPath();
17. //获取文件
18. String file = url.getFile();
19. //获取查询
20. String Qu = url.getQuery();
21. System.out.println(“protocal: “+protocal);
22. System.out.println(“host: “+host);
23. System.out.println(“port: “+port);
24. System.out.println(“path: “+path);
25. System.out.println(“file: “+file);
26. System.out.println(“Qu: “+Qu);
27. URL url_1 = new URL(“http://122.207.132.49:8080/MyWeb/1.html“);
28. //得到ＵＲＬ连接对象
29. URLConnection connection= url_1.openConnection();
30. //获取连接对象的输入流
31. InputStream in = connection.getInputStream();
32. //缓冲
33. byte[] buf = new byte[1024];
34. //读
35. int len = in.read(buf);
36. System.out.println(new String(buf,0,len));
37. }
38.
39. }
40.
1、找到对方的IP
2、数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都进行标识。为了方便
称呼这个数字，叫做端口。逻辑端口
3、定义通信规则。这个通信规则成为协议。国际组织定义了通用协议TCP/IP
对象介绍：
InetAddress：此类表示互联网协议 (IP) 地址。
常用方法：
static InetAddress getByName(String host) 给定主机名的情况下，确定主机的IP地址
static InetAddress getLocalHost() 返回本地主机
String getHostAddress() 返回IP地址字符串
String getHostName() 获取此IP地址的主机名
UDP编程
DatagramSocket与DatagramPacket
建立发送端接收端
建立数据包
调用Socket的发送接收方法
关闭Socket
发送端与接收端是两个独立的运行程序
UDP方法介绍：
构造方法： DatagramSocket() 构造数据报套接字并将其绑定到本地主机上任何可用的端口。
DatagramSocket() 创建数据报套接字并将其绑定到本地主机上的指定端口。
方法：void send(DatagramPacket p ) 从此套接字发送数据报包
void receive(DatagramPacket p) 从此套接字接收数据报包。
DatagramPacket 构造函数：
DatagramPacket(byte[] buf , int length) 构造 DatagramPacket，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length,InetAddress address,int port) 构造数据报包，用来将长度为length 的包发送到
指定主机上的指定端口号。
方法：InetAddress getAddress()返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
byte[] getDate() 返回数据缓冲区。
int getLength() 返回将要发送或接收到的数据的长度。
int getPort() 返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
小练习UDP发送：
1. /*需求：通过UDP传输方式，将一段文字数据发送出去
2. * 思路：
3. * 1，建立udpSocket服务
4. * 2，提供数据，并将数据封装到数据包中
5. * 3，通过Socket服务的发送功能，将数据包发出去
6. * 4，关闭资源*/
7. package Test;
8. import java.net.*;
9. public class UDPSendDemo {
10.
11. public static void main(String[] args)throws Exception {
12. //通过DatagramSocket对象，创建UDP服务
13. DatagramSocket ds = new DatagramSocket();
14. //确定数据，并封装成数据包
15. byte[] buf = “UDP ge men lai le”.getBytes();
16. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName(“127.0.0.1”),10000);
17. //通过Socket服务，将已有的数据包发送出去，通过Send方法
18. ds.send(dp);
19. //关闭资源
20. ds.close();
21.
22. }
23.
24. }
25.
UDP接收：
1. /*需求：定义一个应用程序，用于接受udp协议传输的数据并处理
2. * 思路
3. * 1，定义udpsocket服务，通常会监听一个端口。其实就是给这个接受网络应用程序定义一个数字标识
4. * ，方便于明确哪些数据过来该应用程序可以处理
5. * 2，定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据星系
6. * 3，通过socket服务的receive方法将接受的数据数据存入已定义好的数据包中
7. * 4，通过数据包对象的热油功能，将这些不同的数据取出，打印在控制台上。
8. * 5，关闭资源
9. * */
10. package Test;
11. import java.net.*;
12. public class UDPReceiveDemo {
13.
14. public static void main(String[] args)throws Exception {
15. //创建udpsocket，建立站点
16. DatagramSocket ds = new DatagramSocket(10000);
17. byte[] buf = new byte[1024];
18. //定义数据包 用于存储数据
19. DatagramPacket dp = new DatagramPacket(buf,buf.length);
20. //通过服务的receive方法将受到的数据存入数据包中
21. ds.receive(dp);
22. //通过数据包的方法获取其中的数据
23. String ip = dp.getAddress().getHostAddress();
24. String data = new String(dp.getData(),0,dp.getLength());
25. int port = dp.getPort();
26. System.out.println(ip+”:”+data+”:”+port);
27. //关闭资源
28. ds.close();
29. }
30.
31. }
32.
UDP聊天程序：
1. package Inte;
2. /*
3. * 编写一个聊天程序
4. * 有收数据的部分和发数据的部分
5. * 这两部分都需要执行
6. * 那就需要用到多线程的技术
7. * 一个线程控制收，一个线程控制发。
8. * 因为收和发动作时不一致的，所以要定义两个run方法
9. * 而且这两个方法要封装不同的类中
10. */
11. import java.net.*;
12. import java.io.*;
13.
14. public class ChatDemo {
15.
16. public static void main(String[] args) throws Exception{//多线程 运行发送端 和接收端
17. DatagramSocket sendSocket = new DatagramSocket();
18. DatagramSocket receSocket = new DatagramSocket(10005);
19. new Thread(new Send(sendSocket)).start();
20. new Thread(new Rece(receSocket)).start();
21. }
22.
23. }
24. class Send implements Runnable{
25. //创建udp服务，通过DatagramSocket对象
26. private DatagramSocket ds;
27. public Send(DatagramSocket ds){
28. this.ds = ds;
29. }
30.
31. @Override
32. public void run() {
33. try{//接受键盘数据
34. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
35. String line = null;
36. while((line = bufr.readLine()) != null){//读取键盘数据
37. if(“886”.equals(line))
38. break;
39. byte[] buf = line.getBytes();
40. //确定数据，并封装成数据包
41. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName(“127.0.0.1”),10005);
42. //通过socket服务，将已有的数据包发送出去，通过send方法
43. ds.send(dp);
44. }
45. }catch(Exception e ){
46. throw new RuntimeException(“发送错误”);
47. }
48.
49. }
50.
51. }
52. class Rece implements Runnable{
53. //创建udp socket 建立端点
54. private DatagramSocket ds;
55. public Rece(DatagramSocket ds){
56. this.ds = ds;
57. }
58.
59. @Override
60. public void run() {
61. try{
62. while(true){
63. byte[] buf = new byte[1024];
64. //定义数据包 用来存储数据
65. DatagramPacket dp = new DatagramPacket(buf,buf.length);
66. //通过服务的receive方法将收到的数据存入数据包中
67. ds.receive(dp);
68. //通过数据包的方法获取其中的数据
69. String ip = dp.getAddress().getHostAddress();
70. String data = new String(dp.getData(),0,dp.getLength());
71. System.out.println(ip+”:”+data);
72.
73. }
74.
75. }catch(Exception e){
76. throw new RuntimeException(“接收端错误”);
77. }
78.
79. }
80.
81. }
82.
TCP传输
Socket和ServerSocket
建立客户端和服务器端
建立连接后，通过Socket中的IO流进行数据的传输
关闭Socket
同样，客户端和服务器端是两个独立的应用程序
Socket ：此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信端点。
构造函数：Socket(InetAddress address , int port) 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
方法: InputStream getInputStream() 返回此套接字的输入流。
OutputStream getOutputStream() 返回此套接字的输出流
InetAddress getInetAddress() 返回套接字连接的地址
ServerSocket 构造函数：
ServerSocket(int port) 创建绑定到特定端口的服务器套接字
方法;Socket accept() 侦听并接受到此套接字的连接。
TCP客户端：
1. 客户端编程步骤：
2. 1、 建立Socket服务，指定要连接主机和端口
3. 2、 获取Socket流中的输出流，将数据发送到该流中，通过网络发送给服务端
4. 3、 关闭客户端资源
5. package Inte;
6. import java.net.*;
7. import java.io.*;
8. public class TcpClient {
9.
10. public static void main(String[] args) throws Exception, IOException {
11. //创建客户端的socket服务，指定目的的主机和端口
12. Socket s = new Socket(“127.0.0.1”,10000);
13. //为了发送数据，获取socket流中的输出流
14. OutputStream out =s.getOutputStream();
15. //写入
16. out.write(“ge men lai le “.getBytes());
17. //关闭客户端socket
18. s.close();
19.
20. }
21.
22. }
23.
TCP服务端：
1. 服务端步骤
2. 1、 建立服务器Socket服务，并监听一个端口
3. 2、 通过accept方法获取连接过来的客户端对象
4. 3、 获取客户端发送过来的数据，使用客户端对象的读取流来读取数据
5. 4
defe
、 关闭客户端 服务端
6. package Inte;
7. import java.net.*;
8. import java.io.*;
9. public class TcpServer {
10.
11. public static void main(String[] args) throws Exception {
12. //建立服务端socket服务，并监听一个端口
13. ServerSocket ss = new ServerSocket(10000);
14. //通过accept方法获取连接过来的客户端对象
15. Socket s =ss.accept();
16. String ip =s.getInetAddress().getHostAddress();
17. System.out.println(ip+”…..connected”);
18. //获取客户端发送过来的数据，使用客户端对象的读取流来读取数据
19. InputStream in = s.getInputStream();
20. byte [] buf = new byte[1024];
21. int len = in.read(buf);
22. System.out.println(new String(buf,0,len));
23. //关闭客户端
24. s.close();
25. ss.close();
26. }
27. }
28.
TCP复制文件：
1. 客户端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class TestClient {
6. public static void main(String[] args) throws Exception {
7. //建立客户度Socket
8. Socket s = new Socket(“127.0.0.1”,10006);
9. //数据读取流
10. BufferedReader bufr = new BufferedReader(new FileReader(“D:\javasl\Test\src\Inte\ChatDemo.java”));
11. //Socket输出流
12. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
13. String line = null;
14. //输出
15. while((line = bufr.readLine()) != null){
16. out.println(line);
17. }
18. //禁止套接字输出流
19. s.shutdownOutput();
20. //Socket读取流
21. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
22. String str = bufIn.readLine();
23. //打印服务器回送过来的数据
24. System.out.println(str);
25. //关闭流
26. bufr.close();
27. //关闭客户端
28. s.close();
29. }
30.
31. }
32.
1. 服务端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class TestServer {
6.
7. public static void main(String[] args) throws Exception {
8. //建立服务端socket
9. ServerSocket ss = new ServerSocket(10006);
10. //获取客户度Socket
11. Socket s =ss.accept();
12. //打印输出连接的客户端IP地址
13. String ip =s.getInetAddress().getHostAddress();
14. System.out.println(ip+”…..connected”);
15. //读取流
16. BufferedReader buf =
17. new BufferedReader(new InputStreamReader(s.getInputStream()));
18. //文件输入流
19. PrintWriter out = new PrintWriter(new FileWriter(“D:\javasl\Test\src\Inte\server.txt”));
20. String line = null;
21. //写入
22. while((line = buf.readLine()) != null){
23. out.write(line);
24.
25. }
26.
27. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
28. //给客户端回送数据
29. pw.println(“上传成功”);
30. //关闭流和客户端 服务端
31. out.close();
32. s.close();
33. ss.close();
34.
35.
36.
37. }
38.
39. }
40.
TCP上传图片
1. 客户端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class PicClient {
6.
7. public static void main(String[] args)throws Exception {
8. //判读参数长度是否为一
9. if(args.length != 1){
10. System.out.println(“请选择一个jpg格式的文件”);
11. return;
12. }
13. //用此参数创造文件
14. File file = new File(args[0]);
15. //判断问价你是否存在以及是否为文件
16. if(!(file.exists()&&file.isFile())){
17. System.out.println(“文件有问题”);
18. return;
19. }
20. //判断文件是否为jpg文件
21. if(!file.getName().endsWith(“.jpg”)){
22. System.out.println(“图片格式错误”);
23. return;
24. }
25. //判断文件大小是否大于3MB
26. if(file.length() > 1034*1024*3){
27. System.out.println(“文件过大”);
28. return;
29. }
30. //创建客户端Socket
31. Socket s = new Socket(“127.0.0.1”,10003 );
32. //读取客户端要上传的图片文件
33. FileInputStream fis = new FileInputStream(file);
34. //获取Socket输出流，将读到的图片数据发送给服务端
35. OutputStream out = s.getOutputStream();
36. byte[] buf = new byte[1024];
37. int len = 0;
38. while((len = fis.read(buf)) != -1){
39. out.write(buf, 0, len);
40. }
41. //告诉服务端说，这边的数据发送完毕。让服务器停止读取
42. s.shutdownOutput();
43. //InputStream in = s.getInputStream();
44. //byte [] bufIn = new byte[1024];
45. //int num = 0;
46. //num = in.read(bufIn);
47. //读取服务端发回的内容
48. BufferedReader bufn = new BufferedReader(new InputStreamReader(s.getInputStream()));
49. String line = null;
50. line = bufn.readLine();
51. System.out.println(line);
52. //关闭流与客户端
53. fis.close();
54. s.close();
55. }
56. }
57.
58.
1. 服务端
2. package Inte;
3. import java.net.*;
4. import java.io.*;
5. public class PicServer {
6. public static void main(String[] args)throws Exception {
7. ServerSocket ss = new ServerSocket(10003);
8. while(true){
9. Socket s = ss.accept();
10. new Thread(new PicThread(s)).start();
11. }
12. }
13. }
14. class PicThread implements Runnable{
15. //创建TCP的Socket服务端
16. private Socket s ;
17. public PicThread(Socket s ){
18. this.s = s;
19. }
20. @Override
21. public void run() {
22. int count = 1;
23. String ip = s.getInetAddress().getHostAddress();
24. try{
25. System.out.println(ip+”….connected”);
26. //读取客户端发来的数据
27. InputStream in = s.getInputStream();
28. //定义文件名
29. File file = new File(“D:\”+ip+”(“+(count)+”)”+”.jpg”);
30. while(file.exists())
31. file = new File(“D:\”+ip+”(“+(count++)+”)”+”.jpg”);
32. //将读取到的数据存储到一个文件中
33. FileOutputStream fos = new FileOutputStream(file);
34.
35. byte[] buf = new byte[1024];
36. int len = 0;
37. while((len = in.read(buf)) != -1){
38. fos.write(buf, 0, len);
39. }
40. //OutputStream out = s.getOutputStream();
41. //out.write(“上传成功”.getBytes());
42. //给客户端回送传送结果数据
43. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
44. pw.println(“上传成功”);
45. //关闭流 关闭客户端
46. fos.close();
47. s.close();
48. }catch(Exception e){
49.
50. }
51.
52. }
53.
54. }
55.
登陆
客户端：
1. package Inte;
2. import java.net.*;
3. import java.io.*;
4. public class LoginClient {
5. public static void main(String[] args) throws Exception {
6. //建立客户端Socket
7. Socket s = new Socket(“127.0.0.1”,10007);
8. //键盘录入
9. BufferedReader bufr =
10. new BufferedReader(new InputStreamReader(System.in));
11. //获取Socket输出流
12. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
13. //获取Socket读取流
14. BufferedReader bufIn =
15. new BufferedReader(new InputStreamReader(s.getInputStream()));
16. for(int x = 0 ; x < 3 ; x++){
17. //读取键盘录入的用户名
18. String line = bufr.readLine();
19. if(line == null)
20. break;
21. //将用户名发送到服务端
22. out.println(line);
23. //读取服务端回送数据
24. String info = bufIn.readLine();
25. System.out.println(info);
26. if(info.contains(“欢迎”))
27. break;
28. }
29. bufr.close();
30. s.close();
31. }
32.
33. }
34.
服务端
1. package Inte;
2. import java.net.*;
3. import java.io.*;
4. public class LoginServer {
5. public static void main(String[] args) throws Exception {
6. //创建服务端Socket 并监听007端口
7. ServerSocket ss = new ServerSocket(10007);
8. while(true){
9. //获取连接的客户端Socket
10. Socket s = ss.accept();
11. new Thread(new UserThread(s)).start();
12. }
13.
14. }
15.
16. }
17. class UserThread implements Runnable {
18. private Socket s ;
19. public UserThread(Socket s){
20. this.s =s ;
21. }
22. @Override
23. public void run() {
24. //获取连接但服务端的ip
25. String ip = s.getInetAddress().getHostAddress();
26. System.out.println(ip+”connected”);
27. try{
28. for(int x = 0; x<3; x++){
29. //获取Socket读取流
30. BufferedReader bufIn =
31. new BufferedReader(new InputStreamReader(s.getInputStream()));
32. String name = bufIn.readLine();
33. //如果读取的数据为空 则程序结束
34. if(name == null)
35. break;
36. //读取存放用户名的文件
37. BufferedReader bufr =new BufferedReader(new FileReader(“D:\a.txt”));
38. //获得客户端Socket输出流
39. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
40. String line = null;
41. boolean flag = false;
42. //将服务端传过来的用户名与文件中的用户名一一对比，想同则将flag置为true
43. while((line = bufr.readLine()) != null){
44. if(line.equals(name)){
45. flag =true;
46. break;
47. }
48. }
49. //如果用户名存在 服务端显示xxx，已登录 并且把xxx。欢迎登陆发送到客户端显示
50. if(flag){
51. System.out.println(name+”已登录”);
52. out.println(name+”,欢迎光临”);
53. break;
54. }
55. //用户名不存在 服务端显示xxx，尝试登陆，把用户名xxx，不存在发送到客户端 显示
56. else{
57. System.out.println(name+”尝试登陆”);
58. out.println(“用户名”+name+”不存在”);
59. }
60. }
61. }catch(Exception e){
62. throw new RuntimeException(ip+”尝试失败”);
63. }
64.
65. }
66.
67. }
68.
69.
自定义浏览器
1. package Test3;
2.
3. import java.io.*;
4. import java.net.*;
5.
6. public class MyIE {
7.
8. public static void main(String[] args) throws Exception{
9. //建立客户端Socket服务
10. Socket s = new Socket(“122.207.132.49”, 8080);
11. //获取Socket输出流
12. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
13. //模拟浏览器给服务器发送相应数据
14. pw.println(“GET /MyWeb/1.html HTTP/1.1”);
15. pw.println(“Accept: text/html, application/xhtml+xml, /“);
16. pw.println(“Accept-Language: zh-CN”);
17. pw.println(“Accept-Encoding: gzip, deflate”);
18. pw.println(“Host: 122.207.132.49:10011”);
19. pw.println(“Connection: closed”);
20. pw.println();
21. pw.println();
22. //Socket读取流
23. InputStream in = s.getInputStream();
24. byte[] buf = new byte[1024];
25. int len = 0;
26. //读服务器发过来的数据
27. len =in.read(buf);
28. //将数据打印到控制台上
29. System.out.println(new String(buf,0,len));
30. }
31. }
32.
URL：类 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对
更为复杂的对象的引用，例如对数据库或搜索引擎的查询。
构造函数：URL(string spec) 根据 String 表示形式创建URL 对象。
方法：String getFile() 获取此 URL 的文件名。
String getHost() 获取此 URL 的主机名（如果适用）。
String getPath() 获取此 URL 的路径部分。
int getPort() 获取此 URL 的端口号。
String getProtocal() 获取此 URL 的协议名称。
String getQuery() 获取此 URL 的查询部分。
URLConnection openConnection() 返回一个URLConnection 对象，它表示到URL 所引用的远程对象的连接。
URLConnection的方法：InputStream getInputStream() 返回从此打开的连接读取的输入流。
练习方法：
1. package Test3;
2. import java.net.*;
3. import java.io.*;
4. public class URlDemo {
5.
6. public static void main(String[] args)throws Exception {
7. //创建URL对象
8. URL url = new URL(“http://122.207.132.49:8080/MyWeb/1.html?name=fdl“);
9. //获取协议
10. String protocal = url.getProtocol();
11. //获取主机
12. String host = url.getHost();
13. //获取端口号
14. int port = url.getPort();
15. //获取路径
16. String path = url.getPath();
17. //获取文件
18. String file = url.getFile();
19. //获取查询
20. String Qu = url.getQuery();
21. System.out.println(“protocal: “+protocal);
22. System.out.println(“host: “+host);
23. System.out.println(“port: “+port);
24. System.out.println(“path: “+path);
25. System.out.println(“file: “+file);
26. System.out.println(“Qu: “+Qu);
27. URL url_1 = new URL(“http://122.207.132.49:8080/MyWeb/1.html“);
28. //得到ＵＲＬ连接对象
29. URLConnection connection= url_1.openConnection();
30. //获取连接对象的输入流
31. InputStream in = connection.getInputStream();
32. //缓冲
33. byte[] buf = new byte[1024];
34. //读
35. int len = in.read(buf);
36. System.out.println(new String(buf,0,len));
37. }
38.
39. }
40.
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 