7.网络编程

1.网络模型：
OSI（Open System Interconnection）（开放系统）参考模型
TCP/IP参考模型

封包拆包：

2.网络通讯要素L：
IP地址
端口号
传输协议

3.IP地址：
网络中设备的标识
不易记忆，可用主机名
本地回环地址：127.0.0.1，用来访问本机测试网卡。
主机默认名：localhost

4.端口：
用于有效标识进程的逻辑地址，不同进程的标识不同。
有效端口：0~65535，其中0~1024系统使用或保留端口。

5.传输协议：
通讯的规则
常见协议：
TCP(传输控制协议)：打电话，下载文件，QQ文件在线发送
UDP(数据报文协议)：对讲机，QQ文件离线发送

6.IP对象：InetAddress

public class IPDemo {    public static void main(String[] args) throws UnknownHostException {        //获取本地主机ip的地址对象        InetAddress ip = InetAddress.getLocalHost();        //获取其他主机的ip地址对象//      ip = InetAddress.getByName("coy");//      ip = InetAddress.getByName("100.64.172.141");        ip = InetAddress.getByName("www.baidu.com");        //获取本地主机的ip地址和主机名        System.out.println(ip.getHostAddress());        System.out.println(ip.getHostName());    }/*180.97.33.107www.baidu.com*/

7.域名解析：
DNS：域名解析器（互联网公共主机服务器）

配置本地域名解析列表：
C:\Windows\System32\drivers\etc

系统域名解析 先找的是 本地域名解析文件。
（可以把一些游戏广告网站域名在本地解析成本机回环地址127.0.0.1，不进行访问，过滤垃圾网站）

8.Socket :

1.Socket就通讯的两端，为网络服务提供的一种机制（两个港口）2.通信的两端都有Socket3.网络编程就是Socket编程4.网络通信其实就是Socket间的通信5.数据在两个Socket间通过IO传输

9.UDP协议

1.DatagramSocket,DatagramPacket2.建立发送端，接收端3.建立数据包4.调用Socket的发生接收方法5.关闭Socket发送端和接收端是两个独立的运行程序。

发送端：

public class UDPSendDemo {    public static void main(String[] args) throws IOException {        /*                创建UDP传输的发送端。                思路：                1.建立UDP的socket服务                2.将要发送的数据封装到数据包中。                3.通过UDP的socket服务将数据包发送出去。                4.关闭socket服务。         */        System.out.println("发送端启动...");        //1.UDPsocket服务。使用DatagramSocket对象        DatagramSocket ds = new DatagramSocket();        //2.将要发送的数据封装到数据包中。        String str = "udp传输演示：哈哈";        byte[] buf = str.getBytes();        DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("coy"),10000);        //3.通过UDP的socket服务将数据包发送出去。使用send方法。        ds.send(dp);        //4.关闭资源。        ds.close();    }}

接收端：

public class UDPReceDemo {    public static void main(String[] args) throws IOException {        /*                建立UDP接收端的思路                1.建立UDP的socket服务                2.创建数据包。用于存储接收到的数据。方便用数据包对象的方法解析这些数据。                3.使用Socket服务的receive方法将接收的数据存储到数据包中。                4.通过数据包的方法解析数据包中的数据。                5.关闭资源。         */        System.out.println("接收端启动...");        //1.建立UDP的socket服务        DatagramSocket ds = new DatagramSocket(10000);        //2.创建数据包        byte[] buf  = new byte[1024];        DatagramPacket dp = new DatagramPacket(buf,buf.length);        //3.使用接收方法将数据存储到数据包中。        ds.receive(dp);    //阻塞式的        //4.通过数据包对象的方法，解析其中的数据，比如，地址，端口，数据内容。        String ip = dp.getAddress().getHostAddress();        int port = dp.getPort();        String text = new String(dp.getData(),0,dp.getLength());        System.out.println(ip+ ":" + port + ":" + text);        //5.关闭资源        ds.close();    }}

10.TCP传输：

1.Socket,ServerSocket2.建立客户端和服务端3.建立连接后，通过Socket中的IO流进行数据的传输。4.关闭socket同样，客户端和服务端是两个独立的应用程序。

客户端：

public class TCPClientDemo {    public static void main(String[] args) throws UnknownHostException, IOException {        //客户端发数据到服务端        /*                TCP传输：客户端建立的过程                1.创建tcp客户端socket服务。使用的是Socket对象。                    建议该对象一创建就明确目的地。要连接的主机。                2.  如果连接建立成功，说明数据传输通道已建立。                    该通道就是socket流，是底层建立好的。既然是流，说明这里既有输入，也有输出。                    通过Socket来获取输入或输出流对象。                    可以通过getOutputStream(),和getInputStream()来获取两个字节流。                3.使用输出流，将数据写出。                4.关闭资源。         */        //创建客户端socket服务        Socket socket = new Socket("coy",10002);        //获取socket流中的输出流        OutputStream out = socket.getOutputStream();        //使用输出流将指定的数据写出去        out.write("哈哈".getBytes());        //读取服务端返回的数据，使用socket读取流。        InputStream in = socket.getInputStream();        byte[] buf = new byte[1024];        int len = in.read(buf);        String text = new String(buf,0,len);        System.out.println(text);        //关闭资源        socket.close();    }}

服务端：

public class TCPServerDemo {    public static void main(String[] args) throws IOException {        //服务端接收客户端发送过来的数据，并打印在控制台上。        /*                    建立TCP服务端的思路：                1.创建服务端的socket服务。通过ServerSocket对象。                    服务端必须对外提供一个端口，否者客户端无法连接。                2.获取连接过来的客户端对象                3.通过客户端对象获取socket流读取客户端发来的数据                并打印在控制台上。                4.关闭资源。关客户端，服务端。         */        //1.创建服务器对象        ServerSocket ss = new ServerSocket(10002);        //2.获取连接过来的客户端对象。        Socket s = ss.accept();//阻塞式        String ip = s.getInetAddress().getHostAddress();        //3.通过socket对象获取输入流，要读取客户端发来的数据            InputStream in = s.getInputStream();            byte[] buf = new byte[1024];            int len = in.read(buf);            String text = new String(buf,0,len);            System.out.println(ip+": "+ text);                //使用客户端的socket对象的输出流给给客户端返回数据。            OutputStream out = s.getOutputStream();            out.write("收到".getBytes());            s.close();            ss.close();   //服务端一般不关    }}

示例：大写转换服务器：

public class TransClient {    public static void main(String[] args) throws UnknownHostException, IOException {        /*                思路：                客户端：                1.现有socket端点                2.客户端的数据源：键盘                3.客户端的目的：socket                4.接收服务端的数据，源：socket                5.将数据打印出来：目的：控制台                6.在这些流中操作的数据都是文本数据。                转换客户端：                1.创建socket客户端对象                2.获取键盘录入                3.将录入的信息发送给socket输出流                4.socket输入流读取服务端返回的大写数据                5.将接收到的服务端数据打印到控制台         */        //1.创建socket客户端对象        Socket s = new Socket("100.64.190.224",10001);        //2.获取键盘录入        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));        //3.socket输出流//      BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  //自动刷新        //4.socket输入流：读取服务端返回的大写数据        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));        String line = null;        while((line = bufr.readLine())!=null){            if("over".equals(line))                break;            out.println(line);            //4.读取服务端返回的一行大写数据            String upperStr = bufIn.readLine();                  System.out.println(upperStr);               }         s.close();    }}public class TransServer {    public static void main(String[] args) throws IOException {        /*                转换服务端：                分析：                1.serversocket服务                2.获取socket对象                3.读取客户端发过来的需要转换的数据，源：socket                4.目的：显示在控制台上                5.将数据转成大写发给客户端。目的：socket         */        //1.        ServerSocket ss = new ServerSocket(10001);              //2.        Socket s = ss.accept();  //阻塞        //3.获取socket读取流，并装饰        BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));        //获取ip:            String ip = s.getInetAddress().getHostAddress();            System.out.println(ip+".......connected");        //4.获取socket输出流，并装饰。将大写数据返回给客户端        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  //自动刷新        String line = null;        while((line = bufr.readLine())!= null)        {            System.out.println("收到信息：" + line);             //将大写数据返回给客户端            out.println(line.toUpperCase());        }        s.close();        ss.close();    }}

示例：上传文本文件。

//客户端public class TransClient {    public static void main(String[] args) throws UnknownHostException, IOException {        //1.创建socket客户端对象        Socket s = new Socket("100.64.190.224",10001);        System.out.println("成功连接服务器: 100.64.190.224    端口号：10001");        //2.获取文件读取流。并装饰        File file = new File("上传文件.txt");        if(!file.exists()){            System.out.println("文件不存在，无法上传！");            s.close();            System.exit(0);        }        BufferedReader bufr = new BufferedReader(new FileReader(file));        System.out.println("正在上传文本文件"+file.getName());        //3.socket输出流//      BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  //自动刷新        //4.socket输入流：读取服务端返回的上传标志        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));        String line = null;        while((line = bufr.readLine())!=null){                      out.println(line);        }        //告诉服务端：客户端写完了            s.shutdownOutput();        //4.读取服务端返回的上传成功标志        System.out.println(bufIn.readLine());               bufr.close();         s.close();    }}//服务端public class TransServer {    public static void main(String[] args) throws IOException {        //1.        ServerSocket ss = new ServerSocket(10001);              //2.        Socket s = ss.accept();  //阻塞        //3.获取socket读取流，并装饰        BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));        //获取ip:        String ip = s.getInetAddress().getHostAddress();        System.out.println(ip+".......connected");        //获取文件输入流，并装饰        File file = new File("服务端接收文件.txt");        BufferedWriter bufw = new BufferedWriter(new FileWriter(file));            System.out.println("正在接收 "+ip+"发来的文本文件...");        //4.获取socket输出流，并装饰。将上传标志返回给客户端        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  //自动刷新        String line = null;        while((line = bufr.readLine())!= null)        {                       bufw.write(line);            bufw.newLine();            bufw.flush();        }        //将上传标志返回给客户端        System.out.println("接收成功！保存至"+file.getAbsolutePath());        out.println("上传成功！");        bufw.close();        s.close();        ss.close();    }}

示例：上传图片

public class TransClient {    public static void main(String[] args) throws UnknownHostException, IOException {//客户端        //1.创建socket客户端对象        Socket s = new Socket("100.64.190.224",10001);        System.out.println("成功连接服务器: 100.64.190.224    端口号：10001");        //2.读取客户端要上传的图片。        File file = new File("动画短片《某人的目光》新海诚.flv");             FileInputStream fis =  new FileInputStream(file);        System.out.println("正在上传图片"+file.getName());        //3.获取socket输出流，将读到的图片数据发送给服务端              OutputStream out = s.getOutputStream();          int len = 0;        byte[] buf = new byte[1024];        while((len = fis.read(buf))!=-1){                                   out.write(buf,0,len);                   }        //告诉服务端：这边的数据发送完毕。让服务端停止读取            s.shutdownOutput();    //4.socket输入流：读取服务端返回的上传标志        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));                   System.out.println(bufIn.readLine());               fis.close();         s.close();    }}public class TransServer {    public static void main(String[] args) throws IOException {//服务端        //1.创建tcp的socket服务端        ServerSocket ss = new ServerSocket(10001);              //2.获取客户端        Socket s = ss.accept();  //阻塞        //3.读取客户端发来的数据        InputStream ins = s.getInputStream();            //获取ip:        String ip = s.getInetAddress().getHostAddress();        System.out.println(ip+".......connected");        System.out.println("正在接收 "+ip+"发来的文本文件...");        //4.将读取到的数据存储到一个文件中        File file = new File("服务端接收动画短片《某人的目光》新海诚.flv");        FileOutputStream fos =new FileOutputStream(file);        int len = 0;        byte[] buf =new byte[1024];        while((len = ins.read(buf))!= -1)        {                       fos.write(buf, 0, len);                 }        System.out.println("接收成功！保存至"+file.getAbsolutePath());        //5.获取socket输出流。将上传标志返回给客户端        PrintWriter out = new PrintWriter(s.getOutputStream(),true);          out.println("上传成功！");        fos.close();        s.close();        ss.close();    }}

11.服务端多线程：

public class TransClient {    public static void main(String[] args) throws UnknownHostException, IOException {//客户端            //1.创建socket客户端对象            Socket s = new Socket("100.64.190.224",10001);            System.out.println("成功连接服务器: 100.64.190.224    端口号：10001");        //2.读取客户端要上传的图片。        File file = new File("秒速五厘米(Av4433361,P1).flv");                FileInputStream fis =  new FileInputStream(file);        System.out.println("正在上传："+file.getName());        //3.获取socket输出流，将读到的图片数据发送给服务端              OutputStream out = s.getOutputStream();          int len = 0;        byte[] buf = new byte[1024];        while((len = fis.read(buf))!=-1){                                   out.write(buf,0,len);                   }        //告诉服务端：这边的数据发送完毕。让服务端停止读取            s.shutdownOutput();    //4.socket输入流：读取服务端返回的上传标志        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));                   System.out.println(bufIn.readLine());               fis.close();        s.close();    }}public class TransServer {    public static void main(String[] args) throws IOException {//服务端多线程        //1.创建tcp的socket服务端        ServerSocket ss = new ServerSocket(10001);              while(true){        //2.获取客户端        Socket s = ss.accept();  //阻塞           new Thread(new Task(s)).start();            }    }}public class Task implements Runnable {    private Socket s;    public Task(Socket s){        this.s = s;    }    @Override    public void run() {        int count = 0;        try{                //3.读取客户端发来的数据                InputStream ins = s.getInputStream();                    //获取ip:                String ip = s.getInetAddress().getHostAddress();                System.out.println(ip+".......connected");                //4.将读取到的数据存储到一个文件中                File file = new File(ip+".jpg");                while(file.exists()){                    file = new File(ip+"("+(++count)+")"+".jpg");                }                FileOutputStream fos =new FileOutputStream(file);                int len = 0;                byte[] buf =new byte[1024];                while((len = ins.read(buf))!= -1)                {                               fos.write(buf, 0, len);                         }                System.out.println(file.getName()+"接收成功！");                //5.获取socket输出流。将上传标志返回给客户端                PrintWriter out = new PrintWriter(s.getOutputStream(),true);                  out.println(file.getName()+"上传成功！");                fos.close();                s.close();        }catch(IOException e){        }    }}

12.常见客户端和服务端

最常见的客户端：    浏览器：IE最常见的服务端：    web服务器：Tomcat

ip 网际层规则
TCP/UDP 传输层规则
http:// 应用层规则

13.客户端和服务端（浏览器）原理：

1.自定义服务端
使用已有的客户端IE，了解一下客户端给服务端发了说明请求。

public class IEServer {    public static void main(String[] args) throws IOException {        ServerSocket ss = new ServerSocket(9090);        Socket s = ss.accept();        System.out.println(s.getInetAddress().getHostAddress()+"......connected");        InputStream in = s.getInputStream();   //接收客户端的请求        byte[] buf = new byte[1024];        int len = in.read(buf);        String text = new String(buf,0,len);                System.out.println(text);        //客户端一个返回信息        PrintWriter out = new PrintWriter(s.getOutputStream(),true);        out.println("<font color='red' size='7'>欢迎光临</font>");        s.close();        ss.close();    }}服务端接收到 客户端的请求显示：请求行（请求方式（GET,POST）/请求的资源路径（这里没有请求资源）   http协议版本/1.0，1.1）GET / HTTP/1.1 请求消息头：属性名：属性值 （就是一些规则，告诉服务端，客户端能处理解析的内容，语言，）Accept: text/html, application/xhtml+xml, image/jxr, */*   //支持的解析内容  Accept-Language: zh-CN   //支持的语言Accept-Encoding: gzip, deflate  //支持的解压缩方式（服务端将数据压缩发送过来）User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko//浏览器版本信息（QQ空间ie版本过低提示）Host: 100.64.190.224:9090//客户端的主机（因为ip是不变的，但是主机名是可修改的，为了确定哪一个主机）//Host: www.houyouni.com:9090  Connection: Keep-Alive  //保持存活，close保持关闭请求头和请求体之间必须有个空行//请求体：自定义的信息。

客户端发出请求后得到的反馈：

2.模拟一个浏览器获取信息：
浏览器请求过程：

public class IEClient {    public static void main(String[] args) throws UnknownHostException, IOException {        Socket s = new Socket("100.64.190.224",8080);        //模拟浏览器，给tomcat服务端发送符合http协议的请求消息。        PrintWriter out  = new PrintWriter(s.getOutputStream(),true);        out.println("GET /myweb/1.html HTTP/1.1");        out.println("Accept: */*");        out.println("Host: 100.64.190.224:8080");        out.println("Connection:close");        out.println();        InputStream in = s.getInputStream();        byte[] buf = new byte[1024];        int len = in.read(buf);        String str = new String(buf,0,len);        System.out.println(str);        s.close();    }}显示：//服务器发回的应答消息。应答行：http的协议版本 应答状态码 应答状态描述信息   200：成功  404：找不到页面HTTP/1.1 200 OK   //应答消息头（属性信息）： 属性名：属性值（因为自定义的浏览器没有http解析器，所以应答行和消息头也打印出来了。可以用URL类的openStream()方法直接获得该URL连接的读入流InputStream。然后直接读入消息体。）Accept-Ranges: bytes    ETag: W/"42-1509883856548"Last-Modified: Sun, 05 Nov 2017 12:10:56 GMT  //最后一次修改的事件Content-Type: text/html  //数据类型Content-Length: 42  //字节数Date: Sun, 05 Nov 2017 12:14:16 GMTConnection: close   //连接关闭//空行//应答消息体<font color='red' size='7'>欢迎光临</font>

14.URL解析

1.获取url的信息。String str_url = "http://100.64.190.224:8080/myweb/1.html?name=lisi";URL url = new URL(str_url);syso("Protocol:"url.getProtocol()); //协议syso("getHost:"url.getHost());  //主机ipsyso("getPort:"url.getPort());  //端口syso("getFile:"url.getFile());  //文件信息（路径+参数信息）syso("getPath:"url.getPath());  //路经syso("getQuery:"url.getQuery());  //参数信息2.InputStream openStream()           打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream。     此方法是下面方法的缩写：        openConnection().getInputStream()//只打印消息体：InputStream in = url.openStream();//原理：//URLConnection conn = url.openConnection();//InputStream in = conn.getInputStream();    获得url连接器对象，解析具体的协议，可获取连接器对象的socket输入输出流：    //获取url对象的url连接器对象。将连接封装成了对象:java中内置的可以解析的具体协议的对象+socket    //URLConnection conn = url.openConnection();    //syso(conn);    //sun.net.www.protocol.http.HttpURLConnection:http://100.64.190.224:8080/myweb/1.html?name=lisi    //conn.getHeaderField("Content-Type");  // text/htmlbyte[] buf = new byte[1024];int len = in.read(buf);String text = new String(buf,0,len);syso(text);in.close();

URL解析代替Socket连接服务端：

public class IEClient {    public static void main(String[] args) throws UnknownHostException, IOException {        String str_url = "http://100.64.190.224:8080/myweb/1.html";        URL url = new URL(str_url);        URLConnection conn = url.openConnection();        //模拟浏览器，给tomcat服务端发送符合http协议的请求消息。        PrintWriter out  = new PrintWriter(conn.getOutputStream(),true);        out.println("GET /myweb/1.html HTTP/1.1");        out.println("Accept: */*");        out.println("Host: 100.64.190.224:8080");        out.println("Connection:close");        out.println();        InputStream in = conn.getInputStream();        byte[] buf = new byte[1024];        int len = in.read(buf);        String str = new String(buf,0,len);        System.out.println(str);        in.close();    }}

15.常见网络结构：

1.C/S: client/server    优点：        该结构的软件，客户端和服务端都需要编写。        开发成本较高，维护较为麻烦。    好处：        客户端在本地可以分担一部分运算。    2.B/S: browser/server（javaweb）    优点：        该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代。        开发成本相对低，维护更为简单。    缺点：所有运算都在服务器端完成。