网络编程
网络编程
一.网络编程基础
网络编程的目的：直接或间接地通过网络协议与其他计算机进行通讯。
网络编程中有两个主要的问题：
1.如何准确地定位网络上一台或多台主机。
2.找到主机后如何可靠高效地进行数据传输。
1.IP地址
IP地址：为实现网络中不同的计算机之间的通信，在网络中的每台机器都必须有一个与众不同事标识，这就是IP地址（IP Address）。
格式：数字型、32位、由4段8位的二进制数组成。一般表示为十进制形式（4个0~255的十进制整数），中间用圆点隔开。如：166.111.78.98
域名地址：也是分段表示的，便于记忆的、字符串形式。
2.端口
端口：一个16位的整数，用于表示数据交给哪个通信程序处理。因此，端口就是应用程序与外界交流的出入口，它是一种抽象的软件结构，包括一些数据结构和I/O（基本输入/输出）缓冲区。
端口用一个整数型标识符来表示，即端口号。
端口号跟协议相关，TCP/IP传输层的两个协议TCP和UDP是完全独立的两个软件模块，因此各自的端口号也相互独立，端口通常称为协议端口（protocol port），简称端口
不同的应用程序处理不同端口上的数据，同一台机器上不能有两个程序使用同一个端口，端口号可以从0到65535，通常将它分为三类：
-
公认端口（Well Known Ports）：从0到1023，它们紧密绑定（Binding）一些服务。
-
注册端口（Registered Ports）：从1024到49151。它们松散地绑定一些服务。
-
动态和/或私有端口（Dynamic and/or Private Ports）：从49152到65535，这些端口是应用程序使用的动态端口，应用程序一般不会主动使用这些端口。
3.网络体系参考模型
OSI(Open System Interconnection)参考模型将网络的不同功能划分为7层：
应用层：处理网络应用
表示层：数据表示
会话层：主机间通信
传输层：端到端的连接
网络层：寻址和最短路径
数据链路层：介质访问（接入）
物理层：二进制传输
通信实体的对等层之间不允许直接通信，各层之间是严格的单向依赖，上层（Service user）使用下层提供的服务，下层（Service provider）向上层提供服务。
对等层通信的实质：对等层实体之间虚拟通信，下层向上层提供服务，实际通信在最底层完成。
OSI各层所使用的协议：
应用层：Telnet、FTP、HTTP、DNS、SMTP、POP3
传输层：TCP、UDP ( 其中TCP：面向连接的可靠的传输协议。UDP：是无连接的，不可靠的传输协议。)
网络层：IP、ICMP、IGMP
4.数据封装
一台计算机要发送数据到另一台计算机，数据首先必须打包，打包的过程称为封装。
封装就是在数据前面加上特定的协议头部。
OSI参考模型中，对等层协议之间的交换的信息单元称为协议数据单元（PDU, Protocol Data Unit）。
OSI参考模型中的每一层都要依靠下一层提供的服务。
为了提供服务，下层把上层的PDU作为本层的数据封装，然后加入本层的头部（和尾部）。头部中含有完成数据传输所需的控制信息。
这样，数据自上而下递交的过程实际上就是不断封装的过程。到达目的地后自下而上递交的过程就是不断拆封的过程。由此可知，在物理线路上传输的数据，其外面实际上被包封了多层“信封”。
二.InetAddress类
- InetAddress类
InetAddress类用来封装我们前面讨论的数字式的IP地址和该地址的域名。
InetAddress类内部隐藏了地址数字。
- InetAddress类中的工厂方法
InetAddress类没有明显的构造函数。为生成一个InetAddress对象，必须运用一个可用的工厂方法。
工厂方法（factory method）仅是一个类中静态方法返回一个该类实例的约定。
对于InetAddress，三个方法:getLocalHost()、getByName()以及getAllByName()可以用来创建InetAddress的实例。
getLocalHost()仅返回象征本地主机的InetAddress对象。
- 本机地址还为localhost,127.0.0.1，这三个地址都是一回事。
- getByName()方法返回一个传给它的主机名的InetAddress。
- 如果这些方法不能解析主机名，它们引发一个UnknownHostException异常。
- 在Internet上，用一个名称来代表多个机器是常有的事。
- getAllByName()工厂方法返回代表由一个特殊名称分解的所有地址的InetAddresses类数组。
- 在不能把名称分解成至少一个地址时，它将引发一个UnknownHostException异常。
另外,在SocketAddress中的子类InetSocketAddress , 此类实现 IP 套接字地址（IP 地址 + 端口号）。
1.import java.net.*;
2.class InetAddressDemo
3.{
4. public static void main(String[] args) throws Exception
5. {
6. InetAddress ia = InetAddress.getLocalHost();//获取本机IP地址
7. System.out.println(ia.getHostAddress());//
8. System.out.println(ia.getHostName());
9.
10. InetAddress[] ia2 = InetAddress.getAllByName("www.baidu.com");
11. for (int i=0;i<ia2.length ;i++ )
12. {
13. System.out.println(ia2[i].getHostAddress());
14. System.out.println(ia2[i].getHostName());
15. }
16.
17. }
18.}
19.
三.UDP
UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。
1.特点
1， 每个数据报中都给出了完整的地址信息，因此无需要建立发送方和接收方的连接。
2， UDP传输数据时是有大小限制的，每个被传输的数据报必须限定在64KB之内。
3， UDP是一个不可靠的协议，发送方所发送的数据报并不一定以相同的次序到达接收方
4, UDP不需要建立建立连接, 速度快
5, UDP操作简单，而且仅需要较少的监护，因此通常用于局域网高可靠性的分散系统中client/server应用程序, 多用于视频会议,桌面共享之类
2.Java中操作UDP
使用位于JDK中Java.net包下的DatagramSocket和DatagramPacket类，可以非常方便地控制用户数据报文。
DatagramSocket类：创建接收和发送UDP的Socket实例
DatagramSocket()：创建实例。通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。
DatagramSocket(int port)：创建数据报Socket并将其绑定到本地主机上的指定端口。。
DatagramSocket(int port, InetAddress localAddr)：这是个非常有用的构建器，当一台机器拥有多于一个IP地址的时候，由它创建的实例仅仅接收来自LocalAddr的报文。
receive(DatagramPacket d)：接收数据报文到d中。receive方法产生一个“阻塞”。
send(DatagramPacket d)：发送报文d到目的地。
setSoTimeout(int timeout)：设置超时时间，单位为毫秒。
close()：关闭DatagramSocket。在应用程序退出的时候，通常会主动释放资源，关闭Socket，但是由于异常地退出可能造成资源无法回收。所以，应该在程序完成时，主动使用此方法关闭Socket，或在捕获到异常抛出后关闭Socket。
DatagramPacket：用于处理报文，将byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成byte数组。
DatagramPacket(byte[] buf, int length, InetAddress addr, int port)： 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)：从buf数组中，取出offset开始的、length长的数据创建数据包对象，目标是addr地址，port端口。
DatagramPacket(byte[] buf, int offset, int length)：构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。
DatagramPacket(byte[] buf, int length)：构造 DatagramPacket，用来接收长度为 length 的数据包。
getData()：它从实例中取得报文的byte数组编码。
3.UDP实现发送和接收
1.发送端
1./*
2.需求:
3.定义发送端,通过udp传输方式,将键盘录入的一段文字数据发送出去;
4.
5.思路:
6.1.通过DatagramSocket建立udpsocket服务;
7.2.提供数据,并通过DatagramPacket将数据封装到数据包中;
8.3.通过上面建立的socket服务的发送功能将数据发送出去;
9.4.关闭资源;
10.*/
11.import java.net.*;
12.import java.io.*;
13.class UdpSendDemo
14.{
15. public static void main(String[] args) throws Exception
16. {
17. DatagramSocket ds = new DatagramSocket(10004);//将该socket绑定在该主机的10004指定端口,从这个端口发送
18. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
19. String line = null;
20. while ((line=bufr.readLine()) !=null)
21. {
22. if (line.equals("886"))//用一个"886"的标识符来让循环停止
23. {
24. break;
25. }
26. byte[] buf = line.getBytes();
27. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10000);//从指定该主机指定端口10000发送buf字符串中一段数据
28. ds.send(dp);//用该socket发送dp数据包
29. }
30. ds.close();
31. }
32.}
33.
2.接收端
1./*
2.需求:
3.定义接收端,接收udp协议接收的数据并进行处理;
4.
5.思路:
6.1.通过DatagramSocket建立udp socket服务;
7.2.通过DatagramPacket定义数据包,用于存储接收到的数据;
8.3.通过上面建立功能将接收到的数据存入已定义好的数据包中;
9.4.通过数据包特有的方法来操作的socket服务的接收数据;
10.5.关闭资源;
11.*/
12.import java.net.*;
13.class UdpReceDemo
14.{
15. public static void main(String[] args) throws Exception
16. {
17. DatagramSocket ds = new DatagramSocket(10000);//将该socket绑定在该主机的10000指定端口,用于监听该端口的数据
18. while (true)
19. {
20. byte[] buf = new byte[1024];
21. DatagramPacket dp = new DatagramPacket(buf,buf.length);//构造 DatagramPacket，用来接收长度为 length 的数据包。
22. ds.receive(dp);
23. String address = dp.getAddress().getHostAddress();//因为getAddress()返回的是InetAddress类
24. String data = new String(dp.getData(),0,dp.getLength());
25. int port = dp.getPort();
26. System.out.println(address+"::"+data+"::"+port);
27. //ds.close();因为一般接收端会一直开等待接收数据
28. }
29.
30. }
31.}
4.利用多线程在一个程序里面实现发送接收
1./*
2.利用多线程,将发送端和接收端放在一个程序下运行,类似QQ
3.*/
4.import java.io.*;
5.import java.net.*;
6.class ChatDemo
7.{
8. public static void main(String[] args) throws Exception
9. {
10. DatagramSocket sendsocket = new DatagramSocket();
11. DatagramSocket recesocket = new DatagramSocket(10003);
12. new Thread(new Send(sendsocket)).start();
13. new Thread(new Rece(recesocket)).start();
14. }
15.}
16.class Send implements Runnable
17.{
18. private DatagramSocket ds;
19. Send(DatagramSocket ds)
20. {
21. this.ds = ds;
22. }
23. public void run()
24. {
25. try
26. {
27. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
28. String line = null;
29. while ((line=bufr.readLine())!=null)
30. {
31. if (line.equals("886"))
32. {
33. break;
34. }
35. byte[] buf = line.getBytes();
36. DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10003);
37. ds.send(dp);
38. }
39. ds.close();
40. }
41. catch (Exception e)
42. {
43. throw new RuntimeException("发送端出错");
44. }
45. }
46.}
47.class Rece implements Runnable
48.{
49. private DatagramSocket ds;
50. Rece(DatagramSocket ds)
51. {
52. this.ds = ds;
53. }
54. public void run()
55. {
56. try
57. {
58. while (true)
59. {
60. byte[] buf = new byte[1024];
61. DatagramPacket dp = new DatagramPacket(buf,buf.length);
62. ds.receive(dp);
63. String address = dp.getAddress().getHostAddress();
64. String data = new String(dp.getData(),0,dp.getLength());
65. int port = dp.getPort();
66. System.out.println(address+"::"+data+"::"+port);
67. }
68. }
69. catch (Exception e )
70. {
71. throw new RuntimeException("接收端出错");
72. }
73.
74.
75. }
76.}
四.TCP
- TCP是Tranfer Control Protocol的简称，是一种面向连接的保证可靠传输的协议。
- 通过TCP协议传输，得到的是一个顺序的无差错的数据流。
- 发送方和接收方的成对的两个 socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。
1.特点
1， 面向连接的协议，在socket之间进行数据传输之前必然要建立连接(通过三次握手建立连接),所以在TCP中需要连接时间。
2， TCP一旦连接建立起来，双方的socket就可以按统一的格式传输大的数据。
3， TCP是一个可靠的协议，它确保接收方完全正确地获取发送方所发送的全部数据。
4， 因为需要建立连接,效率偏低。
2.TCP实现发送接收
1.客户端
1.TCP分为客户端和服务端,客户端的对象是Socket,服务端的对象是ServerSocket
2.
3.定义客户端步骤:
4.1.创建Socket服务,并连接指定主机和端口;
5.
6.2.为了发送数据,获取Socket流中的输出流;
7.
8.
9.*/
10.import java.io.*;
11.import java.net.*;
12.class TcpClientDemo
13.{
14. public static void main(String[] args) throws Exception
15. {
16. Socket s = new Socket(InetAddress.getLocalHost(),10004);
17. OutputStream ops = s.getOutputStream();
18. byte[] buf = "服务端,你好".getBytes();
19. ops.write(buf);
20.
21. //接收服务端发送过来的数据
22. InputStream ips = s.getInputStream();
23. byte[] buf2 = new byte[1024];
24. int len = ips.read(buf2);
25. System.out.println(new String(buf2,0,len));
26. s.close();
27. }
28.}
29.
2.服务端
1./*
2.定义服务端步骤:
3.1.建立服务端的Socket服务,ServerSocket;
4.2.获取连接过来的客户端对象,通过ServerSocket里的accept()方法,没有连接则会等待,该方法是阻塞式方法;
5.3.通过获取到的客户端的Socket对象的读取流InputStream,来接收信息;
6.4.关闭服务器;
7.
8.ServerSocket里面有构造方法ServerSocket(int port,int backlog),其中backlog代表服务允许的最大连接数
9.
10.*/
11.import java.io.*;
12.import java.net.*;
13.class TcpServerDemo
14.{
15. public static void main(String[] args) throws Exception
16. {
17. ServerSocket ss = new ServerSocket(10004);
18. Socket s = ss.accept();
19. InputStream ips = s.getInputStream();
20. byte[] buf = new byte[1024];
21. int num = ips.read(buf);
22. String data = new String(buf,0,num);
23. String ip = s.getInetAddress().getHostAddress();
24. System.out.println(data+"::"+ip);
25.
26. //给客户端反馈数据
27. OutputStream ops = s.getOutputStream();
28. ops.write("收到消息,你也好啊".getBytes());
29.
30. s.close();
31. ss.close();
32. }
33.}
3.建立一个文本转换服务器
需求:建立一个文本转换服务器.
客户端给服务器发送文本,服务端将文本转成大写返回给客户端, 并且客户端可以不断的进行文本转换,当客户端输入over时结束.
1.客户端
客户端:
用IO的思想来思考,
源:键盘录入.
目的:网络设备,网络输出流.
操作的是文本数据,可以选择字符流.
步骤:
1.建立服务;
2.获取键盘录入;
3.将数据发送给服务端;
4.获取服务端返回的数据;
1./*
2.该例子容易出现的问题:服务端和客户端莫名的都等待;
3.因为客户端和服务端都有阻塞式方法,这些方法没有读到结束标记,要么数据没有从缓冲区刷出或者没有读到换行符\r\n;
4.
5.*/
6.
7.import java.io.*;
8.import java.net.*;
9.class TransClientDemo
10.{
11. public static void main(String[] args) throws Exception
12. {
13. Socket s = new Socket(InetAddress.getLocalHost(),10005);
14. //定义读取键盘数据的流对象
15. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
16. //目的,将数据写入到socket输出流,发给服务端
17. BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
18. //这里用用PrintWriter来代替上面的bufout:PrintWriter out = new PrintWriter(s.getOutputStream(),true)
19. //定义一个socket读取流,读取服务端返回的数据
20. BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
21. String line = null;
22. while ((line=bufr.readLine()) !=null)
23. {
24. if ("over".equals(line))
25. {
26. break;
27. }
28. bufout.write(line);//将数据写入socket输出流
29. bufout.newLine();//因为服务端的readLine()方法以\r\n来判断结束标记,如果没有则会一直阻塞,所以加入换行符
30. bufout.flush();//必须将缓冲区里面数据刷出
31. //如果上面用了PrintWriter的话,这里上面三行可以直接用out.println(line)
32. String str = bufin.readLine();//读取服务端返回的数据
33. System.out.println("Server:"+str);
34. }
35. s.close();
36. bufr.close();
37. }
38.}
39.
服务端
1.import java.io.*;
2.import java.net.*;
3.class TransServerDemo
4.{
5. public static void main(String[] args) throws Exception
6. {
7. ServerSocket ss = new ServerSocket(10005);
8. Socket s = ss.accept();
9. //读取socket读取流中的数据
10. BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
11. //目的,socket输出流,将大写数据写入socket输出流
12. BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
13. //这里用用PrintWriter来代替上面的bufout:PrintWriter out = new PrintWriter(s.getOutputStream(),true)
14. String line = null;
15. while ((line=bufin.readLine()) !=null)
16. {
17. System.out.println(line);
18. bufout.write(line.toUpperCase());
19. bufout.newLine();
20. bufout.flush();
21. //如果上面用了PrintWriter的话,这里上面三行可以直接用out.println(line)
22. }
23. s.close();
24. ss.close();
25. }
26.}
27.
4.客户端向服务器发送文本文件
1.客户端
1./*
2.将文件从客户端上传到服务端
3.*/
4.import java.io.*;
5.import java.net.*;
6.class UploadClientDemo
7.{
8. public static void main(String[] args) throws Exception
9. {
10. Socket s = new Socket(InetAddress.getLocalHost(),10005);
11.
12. BufferedReader bufr = new BufferedReader(new FileReader("CopyDemo.java"));
13.
14. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
15.
16. BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
17. String line = null;
18. while ((line=bufr.readLine())!=null)
19. {
20. out.println(line);
21. }
22. out.println("over");//发送一个结束标记,然后服务端会一直等待
23. //在实际开发中,直接用s.shutdownOutput(),以此来关闭发送流,同时服务端就收到一个结束标记
24. String str = in.readLine();
25. System.out.println(str);
26. s.close();
27. bufr.close();
28. }
29.}
30.
2.服务端
1.import java.io.*;
2.import java.net.*;
3.class UploadServerDemo
4.{
5. public static void main(String[] args) throws Exception
6. {
7. ServerSocket ss = new ServerSocket(10005);
8. Socket s = ss.accept();
9. BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
10. PrintWriter bufw = new PrintWriter(new FileWriter("e:\\haha.txt"),true);
11. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
12.
13. String line = null;
14. while ((line=in.readLine())!=null)
15. {
16. if ("over".equals(line))
17. {
18. break;
19. }
20. bufw.println(line);
21. }
22.
23. out.println("发送成功");
24. s.close();
25. ss.close();
26. bufw.close();
27.
28. }
29.}
5.客户端向服务器发送图片
1.客户端
1./*
2.客户端向服务端上传图片
3.*/
4.import java.io.*;
5.import java.net.*;
6.class PicClientDemo
7.{
8. public static void main(String[] args) throws Exception
9. {
10. Socket s = new Socket(InetAddress.getLocalHost(),10007);
11. FileInputStream fis = new FileInputStream("e:\\1.jpg");
12. OutputStream ops = s.getOutputStream();
13. int len = 0;
14. byte[] buf = new byte[1024];
15. while ((len=fis.read(buf))!=-1)
16. {
17. ops.write(buf,0,len);
18. }
19. s.shutdownOutput();
20. s.close();
21. fis.close();
22. }
23.
24.}
2.服务端
1.import java.io.*;
2.import java.net.*;
3.class PicServerDemo
4.{
5. public static void main(String[] args) throws Exception
6. {
7. ServerSocket ss = new ServerSocket(10007);
8. Socket s = ss.accept();
9. InputStream ips = s.getInputStream();
10. FileOutputStream fos = new FileOutputStream("e:\\2.jpg");
11. byte[] buf = new byte[1024];
12. int len = 0;
13. while ((len=ips.read(buf))!=-1)
14. {
15. fos.write(buf,0,len);
16. }
17. fos.close();
18. s.close();
19. ss.close();
20. }
21.}
22.
23.
6.使用多线程实现多个客户端同时向服务端发送文件
1.客户端
1./*
2.当多个客服端同时向服务端发送文件时,需要采用多线程才行
3.
4.*/
5.import java.io.*;
6.import java.net.*;
7.class UploadPicByThreadClient
8.{
9. public static void main(String[] args) throws Exception
10. {
11. if (!(args.length == 1))
12. {
13. System.out.println("请选择一个图片上传");
14. return;
15. }
16. if (!(args[0].endsWith(".jpg")))
17. {
18. System.out.println("请选择一个.jpg文件");
19. return;
20. }
21. File file = new File(args[0]);
22. if (!(file.exists() && file.isFile()))
23. {
24. System.out.println("文件不存在或者不是文件");
25. return;
26. }
27.
28. Socket s = new Socket("192.168.0.114",10008);
29. FileInputStream fis = new FileInputStream(file);
30. OutputStream ops = s.getOutputStream();
31. int len = 0;
32. byte[] buf = new byte[1024];
33. while ((len=fis.read(buf))!=-1)
34. {
35. ops.write(buf,0,len);
36. }
37. s.shutdownOutput();
38. s.close();
39. fis.close();
40. }
41.}
42.
2.服务端
1.import java.io.*;
2.import java.net.*;
3.class UploadPicByThreadServer
4.{
5. public static void main(String[] args) throws Exception
6. {
7. ServerSocket ss = new ServerSocket(10008);
8. while (true)
9. {
10. Socket s = ss.accept();
11. new Thread(new PicThread(s)).start();
12. }
13. }
14.}
15.class PicThread implements Runnable
16.{
17. Socket s;
18. PicThread(Socket s)
19. {
20. this.s = s;
21. }
22.
23. public void run()
24. {
25. String ip = s.getInetAddress().getHostAddress();
26. System.out.println(ip+":::connect");
27. int num = 1;
28. try
29. {
30. InputStream ips = s.getInputStream();
31.
32. File file = new File("e:\\"+ip+"("+num+")"+".jpg");
33. while (file.exists())
34. {
35. file = new File("e:\\"+ip+"("+(num++)+")"+".jpg");
36. }
37. FileOutputStream fos = new FileOutputStream(file);
38. byte[] buf = new byte[1024];
39. int len = 0;
40. while ((len=ips.read(buf))!=-1)
41. {
42. fos.write(buf,0,len);
43. }
44. fos.close();
45. s.close();
46.
47. }
48. catch (Exception e)
49. {
50. throw new RuntimeException("上传失败");
51. }
52.
53. }
54.}
55.
56.
7.客户端并发登录服务器
客户端通过键盘录入用户名;
服务端对这个用户名进行校验;
如果该用户存在,在服务端显示: “XXX,已登录” , 并在客户端显示: “XXX,欢迎光临”
如果该用户不存在,在服务端显示: “XXX,尝试登录” , 并在客户端显示:”XXX,该用户不存在”
1.客户端
1./*
2.客户端并发登录服务器
3.
4.客户端通过键盘录入用户名;
5.服务端对这个用户名进行校验;
6.如果该用户存在,在服务端显示: "XXX,已登录" , 并在客户端显示: "XXX,欢迎光临"
7.
8.如果该用户不存在,在服务端显示: "XXX,尝试登录" , 并在客户端显示:"XXX,该用户不存在"
9.
10.
11.*/
12.import java.io.*;
13.import java.net.*;
14.class UserLoginClient
15.{
16. public static void main(String[] args) throws Exception
17. {
18. Socket s = new Socket(InetAddress.getLocalHost(),10009);
19. //定义读取流,读取键盘录入
20. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
21. //socket输出流,发送登录的的name
22. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
23. //socket输入流,接收服务端发送的信息
24. BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
25. for (int x=0;x<3;x++ )
26. {
27. //接收键盘录入
28. String name = bufr.readLine();
29. if (name == null)
30. {
31. break;
32. }
33. //发送给服务端
34. out.println(name);
35. //接收服务端信息
36. String info = in.readLine();
37. System.out.println(info);
38. if (info.equals(name+"欢迎登录"))
39. {
40. break;
41. }
42. }
43. s.close();
44. bufr.close();
45. }
46.}
47.
2.服务端
1.import java.io.*;
2.import java.net.*;
3.class UserLoginServer
4.{
5. public static void main(String[] args) throws Exception
6. {
7. ServerSocket ss = new ServerSocket(10009);
8. while (true)
9. {
10. Socket s = ss.accept();
11. new Thread(new UserThread(s)).start();
12. }
13. }
14.}
15.class UserThread implements Runnable
16.{
17. Socket s;
18. UserThread(Socket s)
19. {
20. this.s = s;
21. }
22. public void run()
23. {
24. //获取到登录客户端的ip
25. String ip = s.getInetAddress().getHostAddress();
26. System.out.println(ip+":::connect");
27. try
28. {
29. //获取socket输入流,读取客服端发送过来的信息
30. BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
31. //定于输出流,向客户端发送信息
32. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
33. //定义一个标记,来判断客户端发送过来的信息和数据库中的信息是否相同
34. boolean flag = false;
35. String name = null;//用来接收客户端发送过来的用户登录信息
36. for (int x =0;x<3 ;x++ )//允许用户连续尝试登录三次
37. {
38. //用于读取服务器中存的用户列表
39. BufferedReader bufr = new BufferedReader(new FileReader("e:\\1.txt"));
40. name = in.readLine();//读取一次socket输入流中的用户信息
41. String line = null;
42. while ((line=bufr.readLine())!=null)
43. {
44. if (name.equals(line))
45. {
46. flag = true;
47. break;
48. }
49. }
50. if (flag == true)
51. {
52. System.out.println(ip+"登录成功");
53. out.println(name+"欢迎登录");
54. bufr.close();
55. break;
56. }
57. System.out.println(ip+"尝试登录");
58. out.println(name+"用户不存在");
59. bufr.close();
60. }
61. s.close();
62. }
63. catch (Exception e)
64. {
65. throw new RuntimeException("上传失败");
66. }
67. }
68.}
69.
70.
8.自定义浏览器功能
1./*
2.自定义浏览器功能
3.*/
4.import java.io.*;
5.import java.net.*;
6.class MyIE
7.{
8. public static void main(String[] args) throws Exception
9. {
10. Socket s = new Socket(InetAddress.getLocalHost(),8080);
11. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
12.
13. //模拟浏览器向服务器发送的请求消息头
14. out.println("GET /myweb/web.html HTTP/1.1");
15. out.println("Accept: */*");
16. out.println("Accept-Language: zh-Hans-CN,zh-Hans;q=0.5");
17. out.println("Host: 221.237.64.248:10010");
18. out.println("Connection: closed");
19. out.println();
20. out.println();
21.
22. BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
23. String line = null;
24. while ((line=bufr.readLine())!=null)
25. {
26. System.out.println(line);
27. }
28. s.close();
29. }
30.}
31.//浏览器向TOMCAT服务器发送的请求消息头
32./*
33.GET / HTTP/1.1
34.Accept: text/html, application/xhtml+xml, image/jxr
35.Accept-Language: zh-Hans-CN,zh-Hans;q=0.5
36.User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2
37.704.79 Safari/537.36 Edge/14.14393
38.Accept-Encoding: gzip, deflate
39.Host: 221.237.64.248:10010
40.Connection: Keep-Alive
41.*/
42.
43.//TOMCAT服务器向浏览器返回的应答消息头
44./*
45.HTTP/1.1 200 OK
46.Server: Apache-Coyote/1.1
47.Accept-Ranges: bytes
48.ETag: W/"191-1476517035954"
49.Last-Modified: Sat, 15 Oct 2016 07:37:15 GMT
50.Content-Type: text/html
51.Content-Length: 191
52.Date: Sat, 15 Oct 2016 14:06:12 GMT
53.Connection: close
54.
55.
56.*/
57.
五.URL和URLConnection
1.应用
1./*
2.URL
3.URLConnection
4.*/
5.import java.io.*;
6.import java.net.*;
7.class URLDemo
8.{
9. public static void main(String[] args) throws Exception
10. {
11. URL url = new URL("http://221.237.64.124:8080/myweb/web.html");
12. String protocol = url.getProtocol();//获取协议 得到http
13. String host = url.getHost();//获取主机
14. int port = url.getPort();//获取端口
15. String path = url.getPath();//获取路径
16. String file = url.getFile();//获取文件名
17. String query = url.getQuery();//获取查询部分
18.
19. //URLConnection将数据在应用层封装,所以返回的数据只有网页里面的数据,就如浏览器返回的数据一样,不会将服务器返回的应答消息头显示出来
20. URLConnection conn = url.openConnection();//返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
21. System.out.println(conn);//结果为:sun.net.www.protocol.http.HttpURLConnection:http://221.237.64.124:8080/myweb/web.html?name=zhangsan&color=red
22. InputStream in = conn.getInputStream();//获取URLConnection里的读取流
23. byte[] buf = new byte[1024];
24. int len = in.read(buf);
25. System.out.println(new String(buf,0,len));
26. }
27.}
2.域名解析
域名解析:
域名解析是把域名指向网站空间IP，让人们通过注册的域名可以方便地访问到网站的一种服务。IP地址是网络上标识站点的数字地址，为了方便记忆，采用域名来代替IP地址标识站点地址。域名解析就是域名到IP地址的转换过程。域名的解析工作由DNS服务器完成
当我们在输入网址,系统会先访问本地的hosts文件,位置C:WINDOWS\system32\driver\setc,然后在访问DNS服务器
1.比如避开盗版软件的验证服务器,在本地的host文件将网址改为本地host,127.0.0.1,这样就会验证失败
2.可以避开一些垃圾网站,在本地host中将网址的映射改成127.0.0.1
