-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
1、网络模型：OSI参考模型和TCP/IP参考模型
图示：
一般来说开发处于传输层和网际层，应用层为：FTP和HTTP协议等，传输层为：UDP和TCP等，网际层为：IP。
通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包，图示为：
2、网络通信三要素：IP地址，端口号，传输协议
A、IP地址
a、它是网络中的设备标识
b、不易记忆，可用主机名表示，两者存在映射关系
c、本机回环地址：127.0.0.1，主机名为：localhost。
IP地址：java中对应的是InetAddress类，存在于java.net包中。
InetAddress类：
（一）无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回本类对象。
InetAddressi = InetAddress.getLocalHost();
（二）方法：
1）static InetAddress getByName(String host)：获取指定主机的IP和主机名。（最好用ip地址去获取，主机名需要解析）
2）static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时，用此方法。
3）String getHostAddress()：返回IP地址字符串文本形式，以IP地址为主。
4）String getHostName()：返回IP地址主机名。
（三）如何获取任意一台主机的IP地址对象：
1）功能：返回InetAddress对象
2）对于任意主机，需要指定传入主机名的参数
注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。
示例：
1. import java.net.*;
2. class IPDemo
3. {
4. public static void main(String[] args)throws Exception
5. {
6. //获取本类对象
7. InetAddress ia=InetAddress.getLocalHost();
8.
9. //ip
10. String address=ia.getHostAddress();
11. //主机名
12. String name=ia.getHostName();
13. System.out.println("IP="+address+"\tname="+name);
14.
15. //获取指定主机的ip信息
16. InetAddress i=InetAddress.getByName("192.168.1.175");
17.
18. String add=i.getHostAddress();
19. String na=i.getHostName();
20. System.out.println("addIP="+add+"\tiname="+na);
21.
22. //获取指定主机名的ip信息
23. InetAddress[] baidu=InetAddress.getAllByName("www.baidu.com");
24. for (InetAddress b :baidu)
25. {
26. String baddress=b.getHostAddress();
27. String bname=b.getHostName();
28. System.out.println("baiduIP="+baddress+"\tbaiduname="+bname);
29. }
30. }
31. }
B、端口号：
a、用于标识进程的逻辑地址，不用进程的标识。
b、有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。
C、传输协议：
即通信规则，包含TCP和UDP协议
UDP
是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。
协议特点：
a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送
b、每个数据包的大小限制在64K之内
c、因无连接，是不可靠的协议
d、不建立连接，速度快。
TCP
是面向连接的，必须连接成功才能传输数据，应用于下载等程序上
协议特点：
a、面向连接，在建立连接后，形成传输数据的通道
b、在连接中进行大数据量的传输
c、通过三次握手完成连接，是可靠的协议
d、必须建立连接，效率稍慢
三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。
3、通信的步骤：
1）找到IP地址
2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。
3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。
注意：必须要有数字标识才能将数据发送到应用程序上。
传输协议
一、Socket
1、它被称之为插座，相当于港口一样，是网络服务提供的一种机制。
2、通信两端都要有Socket，才能建立服务。
3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。
二、UDP传输
1、通过类DatagramSocket，此类表示用发送和接收数据包的套接字，即Socket。
2、方法：
1）创建 UDPSocket发送服务对象：
DatagramSocket()，不指定端口。DatagramSocket(intport)，指定端口。
2）发送：void send(DatagramPacket p)
3）接收：void receive(DatagramPacket p)
其中DatagramPacket：数据报包用来实现无连接包投递服务的，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址（InetAddress）的都是用于发送包的。
3、步骤
1）发送数据：
a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。如果不指定的话，系统会随机分配一个端口，如第一次运行时端口为1093，那么第二次就会顺延为1094，再运行会一直顺延，因为之前的端口还没有得到释放，所以会顺延端口号值。
b、提供数据，并将数据封装到数据包中
c、通过socket服务的发送功能，将数据包发送出去
d、关闭资源
2）接收数据：
a、定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。
b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中
d、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上
e、关闭资源
在定义接收数据的方法中，仍会在DatagramSocket构造函数中传入DatagramPacket的参数，这是因为收到的数据太多，需要解析，通过将数据封装成对象，易于解析，所以需要传入参数。
注意：
1、发送端与接收端是两个独立的运行程序。
2、在发送端，要在数据包对象中明确目的地IP及端口。
3、在接收端，要指定监听的端口。
示例：
1. /*
2. udp发送端：
3. 需求：通过udp传输方式，将一段文字数据发送出去。
4. */
5.
6. import java.net.*;
7. class UdpSend
8. {
9. public static void main(String[] args)throws Exception
10. {
11. //1、创建udp服务。通过DatagramSocket对象
12. DatagramSocket ds=new DatagramSocket();
13. //2、确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)
14. byte[] buf="udp shi shen ma".getBytes();
15. DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.175"),10000);
16.
17. //3、通过Socket服务，将已有的数据包发送出去。通过send方法。
18. ds.send(dp);
19. //4、关闭资源
20. ds.close();
21. }
22. }
23.
24. /*
25. udp接收端
26. 需求：定义一个应用程序，用于接收udp协议传输的数据并处理。
27. */
28.
29. class UdpReceive
30. {
31. public static void main(String[] args)throws Exception
32. {
33. //1、创建udp Socket服务，建立端点
34. //DatagramSocket ds=new DatagramSocket(10000);
35.
36. //一直处于接收状态
37. while(true)
38. {
39. //1、创建udp Socket服务，建立端点
40. DatagramSocket ds=new DatagramSocket(10000);
41. //2、定义数据包。用于存储数据
42. byte[] buf=new byte[1024];
43. DatagramPacket dp=new DatagramPacket(buf,buf.length);
44. //3、通过Socket服务的receive方法将接收到的数据存入数据包中
45. ds.receive(dp);//阻塞式方法
46. //4、通过数据包的方法获取其中的数据
47. String ip=dp.getAddress().getHostName();
48. String data=new String(dp.getData(),0,dp.getLength());
49. int port=dp.getPort();
50. System.out.println(ip+"::"+data+"::"+port);
51. //5、关闭资源
52. ds.close();
53. }
54. //5、关闭资源
55. //ds.close();
56. }
57. }
练习一
1. /*
2. 用键盘录入的方式，来发送数据
3. */
4.
5. import java.net.*;
6. import java.io.*;
7. //UDP 发送端
8. class UdpSend
9. {
10. public static void main(String[] args)throws Exception
11. {
12. //1、创建udp Socket服务
13. DatagramSocket ds=new DatagramSocket(9999);
14. //2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包
15. DatagramPacket dp=null;
16. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
17. String line=null;
18. while((line=br.readLine())!=null)
19. {
20. byte[] buf=line.getBytes();
21. dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);
22. //3、通过Socket服务，将已有的数据包发送出去
23. ds.send(dp);
24. if ("886".equals(line))
25. {
26. break;
27. }
28. }
29. //4、关闭资源
30. ds.close();
31.
32. }
33. }
34.
35. //UDP 接收端
36. class UdpReceive
37. {
38. public static void main(String[] args)throws Exception
39. {
40. //1、创建udp Socket服务
41. DatagramSocket ds=new DatagramSocket(10000);
42. //一直处于接收状态
43. while (true)
44. {
45. //2、定义数据包，用于存储数据
46. byte[] buf=new byte[1024];
47. DatagramPacket dp=new DatagramPacket(buf,buf.length);
48. //3、通过Socket服务，将数据接收并存储进数据包中
49. ds.receive(dp);
50. //4、通过数据包的方法获取其中的数据
51. String ip=dp.getAddress().getHostAddress();
52. String data=new String(dp.getData(),0,dp.getLength());
53. int port=dp.getPort();
54.
55. System.out.println("IP:"+ip+"=="+data);
56. }
57. //5、关闭资源
58. //ds.close();
59. }
60. }
练习二
1. /*
2. 编写一个聊天程序。
3. 有收数据的部分，和发数据的部分。
4. 这两部分需要同时执行。
5. 那就需要用到多线程技术。
6. 一个线程控制收，一个线程控制发。
7.
8. 因为收和发动作是不一致的，所以要定义两个run方法。
9. 而且这个两个方法要封装到不同的类中。
10.
11. */
12. //Udp发送线程
13.
14. import java.net.*;
15. import java.io.*;
16.
17. class UdpSend implements Runnable
18. {
19. //定义Socket服务引用
20. private DatagramSocket ds;
21. UdpSend(DatagramSocket ds)
22. {
23. this.ds=ds;
24. }
25. //复写run方法
26. public void run()
27. {
28. try
29. {
30. //2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包
31. DatagramPacket dp=null;
32. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
33. String line=null;
34. while((line=br.readLine())!=null)
35. {
36. byte[] buf=line.getBytes();
37. dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);
38. //3、通过Socket服务，将已有的数据包发送出去
39. ds.send(dp);
40. if ("886".equals(line))
41. {
42. break;
43. }
44. }
45. //4、关闭资源
46. ds.close();
47. }
48. catch (Exception e)
49. {
50. throw new RuntimeException("发送数据失败");
51. }
52. }
53. }
54.
55. //Udp接收线程
56. class UdpReceive implements Runnable
57. {
58. //定义Socket服务引用
59. private DatagramSocket ds;
60. UdpReceive(DatagramSocket ds)
61. {
62. this.ds=ds;
63. }
64. //复写run方法
65. public void run()
66. {
67. try
68. {
69. //一直处于接收状态
70. while (true)
71. {
72. //2、定义数据包，用于存储数据
73. byte[] buf=new byte[1024];
74. DatagramPacket dp=new DatagramPacket(buf,buf.length);
75. //3、通过Socket服务，将数据接收并存储进数据包中
76. ds.receive(dp);
77. //4、通过数据包的方法获取其中的数据
78. String ip=dp.getAddress().getHostAddress();
79. String data=new String(dp.getData(),0,dp.getLength());
80. int port=dp.getPort();
81.
82. System.out.println("IP:"+ip+"=="+data);
83. }
84. //5、关闭资源
85. //ds.close();
86. }
87. catch (Exception e)
88. {
89. throw new RuntimeException("接收端接收数据失败");
90. }
91. }
92. }
93.
94. class UdpChatDemo
95. {
96. public static void main(String[] args)throws Exception
97. {
98. new Thread(new UdpSend(new DatagramSocket())).start();
99. new Thread(new UdpReceive(new DatagramSocket(10000))).start();
100. }
101. }
三、TCP传输
1、TCP分客户端和服务端。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。
2、方法：
1）创建客户端对象：
Socket()：创建空参数的客户端对象，一般用于服务端接收数据
Socket(String host,int port)，指定要接收的IP地址和端口号
2）创建服务端对象：ServerSocket(int port)：指定接收的客户端的端口
3）Socket accept()：监听并接受到此套接字的连接
4）void shutdownInput()：此套接字的输入流至于“流的末尾”
5）void shutdownOutput()：禁用此套接字的输出流
6）InputStream getInputStream()：返回此套接字的输入流，Socket对象调用
7）OutputStream getOutputStream()：返回套接字的输出流，Socket对象调用
3、基本思路
客户端：
1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。
3）与服务端通讯结束后，关闭Socket。
服务端：
1）服务端需要明确它要处理的数据是从哪个端口进入的。
2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。
3）当该客户端访问结束，关闭该客户端。
4、步骤
客户端：
通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。
1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取
2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流
3）通过输出流的write()方法将要发送的数据写入到流中
4）关闭Socket流资源
服务端：
服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。
1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数
2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待
3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。
4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。
示例：
1. /*
2. 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
3. */
4. //客户端
5. import java.net.*;
6. import java.io.*;
7. class TcpClient
8. {
9. public static void main(String[] args) throws Exception
10. {
11. //1、创建客户端的Socket服务。指定目的主机和端口
12. Socket s=new Socket("127.0.0.1",10000);
13. //2、获取Socket流中输出流，发送数据
14. OutputStream out=s.getOutputStream();
15. out.write("你好！".getBytes());
16. //3、获取Socket流中的输入流，用来接收服务端的反馈信息并打印
17. InputStream in=s.getInputStream();
18.
19. byte[] buf=new byte[1024];
20. int len=in.read(buf);//读取反馈的数据
21.
22. //输出接收的数据
23. System.out.println(new String(buf,0,len));
24.
25. s.close();//关闭资源
26. }
27. }
28.
29.
30. //服务端
31.
32. class TcpServer
33. {
34. public static void main(String[] args)throws Exception
35. {
36. //1、创建服务端的Socket服务，并监听一个端口
37. ServerSocket ss=new ServerSocket(10000);
38. //2、通过accept方法获取连接过来的客户端对象。
39. Socket s=ss.accept();
40. //获取客户端ip
41. String ip=s.getInetAddress().getHostName();
42. System.out.println(ip+"connected....");
43. //3、获取对应客户端对象的读取流读取发过来的数据，并打印
44. InputStream in=s.getInputStream();
45. byte[] buf=new byte[1024];
46. int len=in.read(buf);
47. System.out.println(new String(buf,0,len));
48.
49. //4、调用对应的客户端的输出流写入返回数据
50. OutputStream out=s.getOutputStream();
51. out.write("哥们，收到！".getBytes());
52.
53. //关闭资源
54. s.close();
55. ss.close();//可选操作
56. }
57. }
练习一
1. /*
2. 练习
3. 需求：建立一个文本转换服务器
4. 客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
5. 而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。
6.
7. 分析：
8. 客户端：
9. 既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
10. 源：键盘录入
11. 目的：网络设备，网络输出流。
12. 而且操作的是文本数据。可以选择字符流。
13.
14. 步骤：
15. 1、建立服务
16. 2、获取键盘录入
17. 3、将数据发给服务端
18. 4、获取服务端返回的大写数据
19. 5、结束，管资源。
20.
21. 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
22.
23.
24. 此练习出现的问题：
25. 现象：客户端和服务端都在莫名的等待。
26. 原因：因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等。而导致两端都在等待。
27. 解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中
28. 方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。
29. 方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。
30.
31. */
32.
33. import java.io.*;
34. import java.net.*;
35. class TcpClient
36. {
37. public static void main(String[] args) throws Exception
38. {
39. //创建Socket服务
40. Socket s=new Socket("127.0.0.1",10000);
41.
42. //定义读取键盘数据的流对象
43. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
44.
45. //定义目的，将数据写入到Socket输出流。发给服务端
46. //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
47. PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
48.
49. //定义一个Socket读取流，读取服务端返回的大写信息。
50. BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
51.
52. String line=null;
53. while ((line=br.readLine())!=null)
54. {
55.
56. if("over".equals(line))
57. break;
58.
59. //bwout.write(line);//写入输出流
60. //bwout.newLine();//换行
61. //bwout.flush();//刷新
62. pw.println(line);//将数据写入流中
63.
64. String data=brin.readLine();//读取返回的信息
65. System.out.println(data);
66.
67. }
68. br.close();//关流
69. s.close();
70. }
71. }
72. /*
73. 服务端：
74. 源：Socket读取流
75. 目的：Socket输出流
76. 都是文本，装饰
77. */
78.
79. class TcpServer
80. {
81. public static void main(String[] args)throws Exception
82. {
83. //创建服务端的ServerSocket服务,并指定监听端口
84. ServerSocket ss =new ServerSocket(10000);
85.
86. //获取客户端连接
87. Socket s=ss.accept();
88.
89. //获取客户端ip
90. System.out.println(s.getInetAddress().getHostName()+" connected.......");
91.
92. //读取Socket读取流中的数据
93. BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
94.
95. //将大写数据写入到Socket输出流，并发送给客户端。
96. //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
97. PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
98.
99. String line=null;
100. while ((line=brin.readLine())!=null)
101. {
102. System.out.println(line);
103.
104. //bwout.write(line.toUpperCase());//将读到数据转换为大写后返回
105. //bwout.newLine();//换行
106. //bwout.flush();//刷新
107.
108. pw.println(line.toUpperCase());//将读到数据转换为大写后返回
109. }
110. s.close();//关流
111. ss.close();关闭资源（可选）
112. }
113. }
练习二
1. /*
2. 需求：向服务器上传一个文件，服务返回一条信息
3. 1、客户端：
4. 源：硬盘上的文件；目的：网络设备，即网络输出流。
5. 若操作的是文本数据，可选字符流，并加入高效缓冲区。若是媒体文件，用字节流。
6.
7. 2、服务端：
8. 源：socket读取流；目的：socket输出流。
9.
10. 3、出现的问题：
11. 现象：
12. a、文件已经上传成功了，但是没有得到服务端的反馈信息。
13. b、即使得到反馈信息，但得到的是null，而不是“上传成功”的信息
14.
15. 原因：
16. a、因为客户端将数据发送完毕后，服务端仍然在等待这读取数据，并没有收到结束标记，就会一直等待读取。
17. b、上个问题解决后，收到的不是指定信息而是null，是因为服务端写入数据后，需要刷新，才能将信息反馈给客服端。
18.
19. 解决：
20. 方法一：定义结束标记，先将结束标记发送给服务端，让服务端接收到结束标记，然后再发送上传的数据。但是这样定义可能会发生定义的标记和文件中的数据重复，而导致提前结束。
21. 方法二：定义时间戳，由于时间是唯一的，在发送数据前，先获取时间，发送完后在结尾处写上相同的时间戳，在服务端，接收数据前先接收一个时间戳，然后在循环中判断时间戳以结束标记。
22. 方法三：通过socket方法中的shutdownOutput()，关闭输入流资源，从而结束传输流，以给定结束标记。通常用这个方法。
23. */
24.
25. import java.io.*;
26. import java.net.*;
27.
28.
29. //客户端
30. class TcpClient
31. {
32. public static void main(String[] args) throws Exception
33. {
34. //创建Socket服务
35. Socket s=new Socket("127.0.0.1",10000);
36.
37. //定义读取流读取文件数据
38. BufferedReader br=new BufferedReader(new FileReader("TcpDemo.java"));
39.
40. //定义目的，将数据写入到Socket输出流。发给服务端
41. //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
42. PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
43.
44. //定义一个Socket读取流，读取服务端返回信息。
45. BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
46.
47. String line=null;
48. while ((line=br.readLine())!=null)
49. {
50. pw.println(line);
51. }
52.
53. s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.
54.
55. System.out.println(brin.readLine());//接收返回信息
56.
57. br.close();
58. s.close();
59. }
60. }
61.
62. //服务端
63. class TcpServer
64. {
65. public static void main(String[] args)throws Exception
66. {
67. //创建服务端的ServerSocket服务,并指定监听端口
68. ServerSocket ss =new ServerSocket(10000);
69.
70. //获取客户端连接
71. Socket s=ss.accept();
72.
73. //获取客户端ip
74. System.out.println(s.getInetAddress().getHostName()+" connected.......");
75.
76. //读取Socket读取流中的数据
77. BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));
78.
79. //将接收到的数据写入文件中
80. PrintWriter out=new PrintWriter(new FileWriter("TcpDemo.txt"),true);
81.
82. //将返回信息写入Socket流的写入流中
83. BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
84.
85. String line=null;
86. while ((line=brin.readLine())!=null)
87. {
88. out.println(line);
89. }
90.
91. //PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
92. //pw.println("上传成功");
93.
94. bwout.write("上传成功!");
95. bwout.newLine();//换行
96. bwout.flush();//刷新
97.
98. out.close();//关流
99. s.close();
100. ss.close();
101. }
102. }
第三讲 应用
一、用TCP客户端并发上传图片
1、一对一（单线程）上传的思路：
客户端
a、服务端点。
b、读取客户端已有的图片数据
c、通过Socket输出流将数据发给服务端
d、读取服务端反馈信息。
e、关闭
服务端
a、服务端服务，并监听窗口
b、获取客户端对象，并获取客户ip
c、读取客户端输入流数据
d、写入文件
e、用客户端输出流反馈信息
f、关流
2、单线程的服务端有个局限性。当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以，暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
如何定义线程呢？
只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。
代码：
1. /*
2. 需求：并发上传图片
3. */
4.
5. import java.io.*;
6. import java.net.*;
7. //客户端
8. class PicClient
9. {
10. public static void main(String[] args) throws Exception
11. {
12. //对传入的值进行判断
13. if (args.length!=1)
14. {
15. System.out.println("请指定一个图片文件！");
16. return;
17. }
18.
19. File file=new File(args[0]);
20.
21. //对文件路径进行判断
22. if (!(file.exists()&&file.isFile()))
23. {
24. System.out.println("你上传的文件有问题，非文件或者不存在！");
25. return;
26. }
27.
28. //判断是否是图片文件
29. if (!file.getName().endsWith(".jpg"))
30. {
31. System.out.println("图片格式错误，请重新选择！");
32. return;
33. }
34.
35. //对文件大小进行判断
36. if (file.length()>1024*1024*5)
37. {
38. System.out.println("你上传的文件过大,居心叵测！");
39. return;
40. }
41.
42. //创建服务
43. Socket s=new Socket("localhost",10000);
44. //读取图片数据
45. FileInputStream fis=new FileInputStream(file);
46.
47. //用Socket服务输出流写入数据
48. OutputStream out =s.getOutputStream();
49.
50. BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
51.
52. byte[] buf=new byte[1024];
53.
54. int len=0;
55.
56. while ((len=fis.read(buf))!=-1)
57. {
58. out.write(buf,0,len);
59. }
60.
61. //结束标记，表示文件数据已经上传完了
62. s.shutdownOutput();
63.
64. String info=in.readLine();//读取返回信息
65. System.out.println(info);
66.
67. fis.close();//关流
68. s.close();
69.
70. }
71. }
72.
73. //服务端
74. class PicServer
75. {
76. public static void main(String[] args)throws Exception
77. {
78. //创建服务，监听端口
79. ServerSocket ss=new ServerSocket(10000);
80.
81. while (true)
82. {
83. //获取客户端对象
84. Socket s=ss.accept();
85. //客户端执行线程
86. new Thread(new PicThread(s)).start();
87. }
88.
89. //ss.close();
90. }
91. }
92.
93. //利用多线程实现并发上传
94. class PicThread implements Runnable
95. {
96. private Socket s;
97. PicThread(Socket s)
98. {
99. this.s=s;
100. }
101. public void run()
102. {
103. int count=1;
104. //获取客户端ip
105. String ip=s.getInetAddress().getHostAddress();
106. try
107. {
108. System.out.println(ip+" connected.....");
109.
110. //通过客户端的读取流读取数据
111. InputStream in=s.getInputStream();
112. //文件保存路径
113. File dir =new File("C:\\Users\\asus\\Desktop");
114. //文件名
115. File file=new File(dir,ip+".jpg");
116. //判断文件是否存在
117. while(file.exists())
118. {
119. file=new File(dir,ip+"("+(count++)+").jpg");
120. }
121.
122. //将数据写入到指定文件中
123. FileOutputStream fos=new FileOutputStream(file);
124.
125. byte[] buf=new byte[1024];
126. int len=0;
127. while ((len=in.read(buf))!=-1)
128. {
129. fos.write(buf,0,len);
130. }
131.
132. //将收到图片数据的信息返回给客户端
133. OutputStream out=s.getOutputStream();
134.
135. out.write("上传成功！".getBytes());
136.
137. fos.close();//关流
138. s.close();
139. }
140. catch (Exception e)
141. {
142. throw new RuntimeException(ip+"图片上传失败");
143. }
144. }
145. }
二、客户端并发登录
客户端通过键盘录入用户名，服务端对这个用户名进行校验。
如果该用户存在，在服务端显示xxx，已登陆；并在客户端显示xxx，欢迎光临。
如果用户不存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，该用户不存在。
最多就登录三次。
代码：
1. import java.io.*;
2. import java.net.*;
3. //客户端
4. class LoginClient
5. {
6. public static void main(String[] args) throws Exception
7. {
8. //创建服务
9. Socket s=new Socket("localhost",10000);
10. //键盘录入
11. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
12.
13.
14. //用Socket服务输出流写入数据
15. PrintWriter out =new PrintWriter(s.getOutputStream(),true );
16.
17. //接收服务器返回的信息
18. BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
19.
20. String line=null;
21.
22. for(int x=0;x<3;x++)
23. {
24. line=br.readLine();//读取键盘录入
25. if (line==null)
26. {
27. break;//如果键盘没有输入，则直接结束
28. }
29.
30. out.println(line);//将数据写入流中
31.
32. String info=in.readLine();//读取返回信息
33.
34. System.out.println(info);
35.
36. if (info.contains("欢迎"))//---------------
37. {
38. break;//如果登录成功，就跳出循环
39. }
40. }
41.
42. br.close();//关流
43. s.close();
44. }
45. }
46.
47. //服务端
48. class LoginServer
49. {
50. public static void main(String [] args)throws Exception
51. {
52. //创建服务，监听端口
53. ServerSocket ss=new ServerSocket(10000);
54.
55. while (true)
56. {
57. //获取客户端对象
58. Socket s=ss.accept();
59.
60. //客户端执行线程
61. new Thread(new LoginThread(s)).start();
62. }
63.
64. //ss.close();
65. }
66. }
67.
68. //利用多线程实现并发登录
69. class LoginThread implements Runnable
70. {
71. private Socket s;
72. LoginThread(Socket s)
73. {
74. this.s=s;
75. }
76. public void run()
77. {
78. //获取客户端ip
79. String ip=s.getInetAddress().getHostAddress();
80. System.out.println(ip+" connected.....");
81. try
82. {
83. for (int x=0;x<3 ;x++ )
84. {
85. //通过客户端的读取流读取数据
86. BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
87.
88. //读取数据库中的数据，这里用文件来表示数据库
89. BufferedReader br=new BufferedReader(new FileReader("users.txt"));
90.
91. String line=in.readLine();//读取客户端数据
92. if (line==null)//--------------
93. {
94. break;//如果客户端没有发送数据，则跳出循环
95. }
96. String data=null;
97. boolean flag=false;//设置标记
98. //读取数据库中的用户数据
99. while ((data=br.readLine())!=null)
100. {
101. if (line.equals(data))
102. {
103. flag=true;//如果用户存在，则将标记设为true
104. break;
105. }
106. }
107.
108. //将数据写入到指定文件中
109. PrintWriter out=new PrintWriter(s.getOutputStream(),true);
110.
111. if (flag)
112. {
113. System.out.println(line+",已登陆！");
114.
115. out.println(line+"，欢迎光临！");
116.
117. break;//-----------
118. }
119. else
120. {
121. System.out.println(line+",尝试登陆！");
122. out.println(line+"，用户名不存在！");
123. }
124. }
125. s.close();//关流
126. }
127. catch (Exception e)
128. {
129. throw new RuntimeException("用户登陆失败");
130. }
131. }
132. }
三、客户端和服务的浏览器演示
浏览器是一个标准的客户端，它可以对服务端传送过来的数据消息进行解析，把符合应用层协议的消息部分解析后，将头信息拆包掉，传送到应用层，只保留了正确的正文主题部分显示在主体部分上。
而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。
示例：
自定义服务器，用浏览器访问：
1. import java.io.*;
2. import java.net.*;
3.
4. //服务器
5. class ServerDemo
6. {
7. public static void main(String[] args)throws Exception
8. {
9. //创建服务，监听端口
10. ServerSocket ss=new ServerSocket(10000);
11. //获取客户端
12. Socket s=ss.accept();
13. //显示ip
14. String ip=s.getInetAddress().getHostAddress();
15.
16. System.out.println(ip);
17. //读取客户端读取流数据
18. InputStream in=s.getInputStream();
19.
20. byte[] buf=new byte[1024];
21. int len=in.read(buf);
22. //显示数据
23. System.out.println(new String(buf,0,len));
24. //返回信息写入客户端输出流
25. PrintWriter out=new PrintWriter(s.getOutputStream(),true);///true一定要记得写
26.
27. out.println("<font color='red' size='7'>客户端你好!</font>");
28.
29. s.close();//关流
30. ss.close();
31. }
32. }
四、URL和URLConnection
1、URL：
URI：范围更大，条形码也包含于此范围
URL：范围较小，即域名
方法：
1）构造函数：URL(String protocol,String host,intport,String file);//根据指定 protocol、host、port号和 file 创建 URL对象。
2）String getProtocol();//获取协议名称
3）String getHost();//获取主机名
4）int getPort();//获取端口号
5）String getFile();//获取URL文件名
6）String getPath();//获取此URL的路径部分
7）String getQuery();//获取此URL的查询部，客户端传输的特定信息
注：一般输入网址，是不带端口号的，此时可进行获取，通过获取网址返回的port，若port为-1，则分配一个默认的80端口，如
int port = getPort();
if(port == -1)
port = 80;
2、URLConnection
方法：
1）URLConnection openConnection();//用URL调用此方法，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
2）InputStream getInputStream();//获取输入流
3）OutputStream getOutputStream();//获取输出流
示例：
1. /*
2. 自定义浏览器，显示网页信息
3. */
4.
5. import java.io.*;
6. import java.awt.*;
7. import java.awt.event.*;
8. import java.net.*;
9.
10. class MyIEGUIDemo
11. {
12. //定义所需组件引用
13. private Frame f;
14. private Button but,bok;
15. private TextField tf;
16. private TextArea ta;
17.
18. //构造函数
19. MyIEGUIDemo()
20. {
21. init();
22. }
23.
24. //窗体基本设置于功能实现
25. public void init()
26. {
27. //组件实例化
28. f=new Frame("我的Window");
29. but=new Button("跳转");
30. tf=new TextField(50);
31. ta=new TextArea(25,60);
32.
33. //基本设置
34. f.setBounds(300,150,500,500);
35. f.setLayout(new FlowLayout());
36.
37. //添加组件
38. f.add(tf);
39. f.add(but);
40. f.add(ta);
41.
42. //窗体事件
43. myEvent();
44.
45. //窗体显示
46. f.setVisible(true);
47. }
48.
49. //注册事件
50. public void myEvent()
51. {
52. //窗体关闭功能
53. f.addWindowListener(new WindowAdapter()
54. {
55. public void windowClosing(WindowEvent e)
56. {
57. System.exit(0);
58. }
59. });
60.
61. //“跳转”按钮事件
62. but.addActionListener(new ActionListener()
63. {
64. public void actionPerformed(ActionEvent e)
65. {
66. showFile();//显示网页内容在文本区中
67. }
68. });
69.
70.
71.
72. //文本框键盘事件
73. tf.addKeyListener(new KeyAdapter()
74. {
75. public void keyPressed(KeyEvent e)
76. {
77. //如果键盘按下Enter键，就将网页内容显示在文本区中
78. if(e.getKeyCode()==KeyEvent.VK_ENTER)
79. showFile();
80. }
81. });
82. }
83.
84. //显示网页内容
85. private void showFile()
86. {
87. ta.setText("");
88. String path=tf.getText();//获取输入的路径
89. try
90. {
91. //封装地址对象
92. URL url =new URL(path);
93. 连接网页服务器
94. URLConnection conn=url.openConnection();
95. //读取流，用于读取服务器返回数据
96. InputStream in=conn.getInputStream();
97.
98. byte[] buf=new byte[1024*1024];
99.
100. int len=in.read(buf);
101. //将数据显示在文本区中
102. ta.append(new String(buf,0,len));
103. }
104. catch (Exception e)
105. {
106. throw new RuntimeException("连接"+path+"网站失败");
107. }
108. }
109.
110. public static void main(String[] args)
111. {
112. //运行窗体
113. new MyIEGUIDemo();
114. }
115. }
小知识点
1、Socket类的构造函数中，有一个空参数的构造函数：
Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象
可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类，它的子类InetSocketAddress实现了IP套接字地址（IP地址+端口号）。所以就可以连接到服务器了。
2、ServerSocket对象中的构造函数：
ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。
3、在浏览器输入网址访问一台主机所做的操作：
如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了神马操作呢？
也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS
在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。
示意图：
host应用：可屏蔽一些恶意网址，即将对应的映射关系写入hosts中，将IP地址改为本机的回环地址，那么会直接找到hosts，就不会将请求发送出去了。
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
扫一扫
4463
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
