网络编程

时间 2019-11-19

标签网络编程栏目系统网络繁體版

原文原文链接

~~Edit~~html

网络编程

网络编程

一.网络编程基础

网络编程的目的：直接或间接地经过网络协议与其余计算机进行通信。java

网络编程中有两个主要的问题：
1.如何准确地定位网络上一台或多台主机。
2.找到主机后如何可靠高效地进行数据传输。web

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