黑马程序员——【Java基础】——网络编程

---------- android培训、java培训、期待与您交流！ ---------- 

一、网络模型概述

　　网络模型示意图：

　　说明：

　　（1）数据的传输：在用户端，应用层的数据，经过层层封包，最后到物理层，通过网络发送到网络的另一端，再从物理层到应用层进行层层解包。

　　（2）常用层的协议，包括：应用层的FTP和HTTP协议等；传输层的UDP和TCP等；网际层的IP等。

　　（3）对于开发者来讲，一般处于传输层和网际层。对于用户，通常停留在应用层。

二、网络通讯要素

　　网络通讯要素，包括：IP地址、端口号 以及 传输协议。

　　（一）IP地址

　　1、IP地址概述

　　（1）它是网络设备标识；

　　（2）可用主机名表示；

　　（3）localhost：回路网络接口的标准主机名；

　　（4）本机回环地址：127.0.0.1。

　　2、IP地址对象——InetAddress类

　　（1）IP地址：在java中对应的是InetAddress类，存在于java.net包中。

　　（2）InetAddress类：无构造函数。

　　（3）可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回本类对象。InetAddress ip = InetAddress.getLocalHost();

　　（4）InetAddress常用方法：

　　　① static InetAddress getByName(String host)：获取指定主机的IP和主机名。

　　　② String getHostAddress()：返回IP地址字符串文本形式，以IP地址为主。

　　　③ String getHostName()：返回IP地址主机名。

　　　④ static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP地址所组成的数组，返回ip地址不唯一。

　　（5）如何获取其他主机的IP地址对象：

　　　① 功能：返回InetAddress对象

　　　② 对于任意主机，需要指定传入主机名的参数

　　注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。

　　（6）示例代码：

　　//     1、获取本地主机地址对象

　　InetAddress ip = InetAddress.getLocalHost();

　　System.out.println(ip.getHostAddress() + ip.getHostName());

　　//     2、获取其他主机的ip地址对象

　　ip = InetAddress.getByName(“ip地址或者DNS”);

　　System.out.println(ip.getHostAddress);

　　//     3、获取百度域名的ip地址群

　　InetAddress[] ips = InetAddress.getAllByName(“www.baidu.com”);

　　for( InetAddress ip : ips ){

       　　System.out.println(ip.getHostAddress())

　　}

　　（二）端口号

　　1、用于标识进程的逻辑地址，不用进程的标识。

　　2、有效端口：0 ~65535，其中0~ 1024是系统使用或保留的端口。

　　（三）传输协议

　　传输协议：即通信规则，常见的有UDP协议、TCP协议。

　　1、UDP协议：是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。其特点有：

　　（1）将数据和源、目的封装成包，不需要建立链接；

　　（2）每个数据包的大小限制在64K之内；

　　（3）因无连接，是不可靠的协议；

　　（4）不需建立连接，速度快；

　　2、TCP协议：是面向连接的，必须连接成功才能传输数据，应用于下载等程序上。其特点是：

　　（1）建立连接，形成传输数据通道；

　　（2）在连接中进行大数据量传输；

　　（3）通过三次握手完成连接，是可靠的协议；

　　（4）必须建立连接，效率会低一些；

三、网络传输协议

　　（一）Socket：Socket是为网络服务提供的一种机制。

　　1、通信两端都要有Socket；

　　2、网络通信，其实就是Socket间的通信；

　　3、数据在两个Socket间通过IO传输；

　　（二）UDP传输

　　1、概述

　　UDP传输是通过DatagramSocket类来实现的，此类表示用来发送和接收数据包的套接字，存在java.net包中。

　　2、常用方法：

　　① DatagramSocket()：创建 UDPSocket发送服务对象，不指定端口号。

　　② DatagramSocket(int port)：创建 UDPSocket发送服务对象，指定端口号。

　　③ void send(DatagramPacket p)：发送数据报包。

　　④ void receive(DatagramPacket p)：接收数据报包。

　　3、创建UDP发送端、UDP接收端步骤：

　　（1）UDP发送端

　　　① 建立UDP的Socket服务。

　　　② 将要发送的数据封装到数据包中。

　　　③ 用UDP的socket服务将数据包发送出去。

　　　④ 关闭Socket服务。

　　（2）UDP接收端

　　　① 建立UDP Socket服务，因为要接收数据，必须要明确一个端口号。

　　　② 定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

　　　③ 通过socket服务的receive方法，将接收到的数据存入已定义好的数据包中。

　　　④ 通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上。

　　　⑤ 关闭Socket服务。

　　（3）注意事项：

　　（1）发送端与接收端是两个独立的运行程序。

　　（2）在发送端，要在数据包对象中明确目的地IP及端口。

　　（3）在接收端，要指定监听的端口。

　　4、UDP发送端、UDP接收端代码示例

//（1）UDP发送端代码：
import java.net.*;
class UDPSend{
    public static void main(String[] args)throws Exception{
        //1、创建UDP服务，使用DatagramSocket对象。
        DatagramSocket ds = new DatagramSocket(8888);
        //2、将要发送的数据封装到数据包中，用到DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        byte[] buf = "udp shi shen ma".getBytes();
        DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);  
        //3、通过Socket服务，将已有的数据包发送出去。通过send方法
        ds.send(dp);
        //4、关闭资源
        ds.close();
    }
}
//（2）UDP接收端代码：
class UDPReceive{
    public static void main(String[] args)throws Exception{
        //一直处于接收状态
        while(true)
        {
            //    1. 创建udp Socket服务，建立端点
            DatagramSocket ds = new DatagramSocket(10000);
            //    2. 定义数据包。用于存储数据
            byte[] buf = new byte[1024];
            DatagramPacket dp = new DatagramPacket(buf,buf.length);
            //    3. 通过Socket服务的receive方法将接收到的数据存入数据包中
            ds.receive(dp);//阻塞式方法
            //    4. 通过数据包的方法获取其中的数据
            String ip = dp.getAddress().getHostName();
            String text = new String(dp.getData(),0,dp.getLength());
            int port = dp.getPort();
            System.out.println(ip+"::"+text+"::"+port);
            //    5. 关闭资源
            ds.close();
        }
    }
}

　　5、练习题：

　　（1）用键盘录入的方式，来发送数据。

　　（2）编写一个聊天程序，有收数据的部分和发数据的部分。

　　（三）TCP传输

　　1、概述

　　TCP传输分为“客户端”和“服务端”。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。

　　2、常用方法：

　　（1）客户端Socket

　　构造函数：

　　① Socket()：创建未连接套接字。

　　② Socket(InetAddress address , tin port)：创建连接到IP指定端口的套接字。

　　③ Socket( String host , int port )：创建流套接字并将其连接到指定主机上的指定端口号。

　　特有方法：

　　① getInputStream()：返回此套接字的输入流。

　　② getOutputStream()：返回此套接字的输出流。

　　③ void shutdownInput()：此套接字的输入流至于“流的末尾”。

　　④ void shutdownOutput()：禁用此套接字的输出流。

　　（2）服务端ServerSocket

　　① 构造函数：ServerSocket(int port)：创建绑定到特定端口的服务器套接字。

　　② 特有方法：Socket accept()：监听并接受到此套接字的连接，是阻塞式方法。

　　3、创建TCP客户端、TCP服务端步骤：

　　TCP是面向连接的，在建立Socket服务时，需要有服务端存在并连接成功，形成通路，再通过连接好的通路进行数据传输。

　　（1）TCP客户端创建步骤

　　　① 创建Socket服务，明确要连接的主机端口。

　　　② 为了发送数据，应获取Socket中的输出流。如果要接收服务端的反馈信息，还需要获取Socket的输入流。

　　　③ 通过输出流的write()方法，将要发送的数据写入到流中。

　　　④ 关闭Socket流资源。

　　（2）TCP服务端创建步骤

　　　① 建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数完成。

　　　② 获取连接过来的客户端对象，通过ServerSocket的阻塞式方法accept()接收客户端对象。

　　　③ 客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。

　　　④ 关闭资源。（关闭客户端，一般不关服务端）

　　4、TCP客户端和服务端代码示例

/* 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。 */
import java.net.*;
import java.io.*;
//（1）客户端代码示例
class  TcpClient{
    public static void main(String[] args) throws Exception{
        //1、创建客户端的Socket服务。指定目的主机和端口
        Socket s = new Socket("127.0.0.1",10000);
        //2、获取Socket流中输出流，发送数据
        OutputStream out = s.getOutputStream();
        out.write("你好！".getBytes());
        //3、获取Socket流中的输入流，用来接收服务端的反馈信息并打印
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);//读取反馈的数据
        //输出接收的数据
        System.out.println(new String(buf,0,len));
        s.close();//关闭资源
    }
}
//（2）服务端代码示例
class TcpServer{
    public static void main(String[] args)throws Exception{
        //1、创建服务端的Socket服务，并监听一个端口
        ServerSocket ss = new ServerSocket(10000);
        //2、通过accept方法获取连接过来的客户端对象。
        Socket s = ss.accept();
        //获取客户端ip
        String ip = s.getInetAddress().getHostName();
        System.out.println(ip+"connected....");
        //3、获取对应客户端对象的读取流读取发过来的数据，并打印
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        System.out.println(new String(buf,0,len));  
        //4、调用对应的客户端的输出流写入返回数据
        OutputStream out = s.getOutputStream();
        out.write("哥们，收到！".getBytes());  
        //关闭资源
        s.close();
        ss.close();//可选操作
    }
}

　　5、练习题：

　　（1）需求：建立一个文本转换服务器 ，客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端，而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。

　　（2）需求：向服务器上传一个文件，服务返回一条“上传成功”的信息。

　　（四）应用示例

　　需求：通过利用TCP传输，实现并发上传图片

import java.io.*;
import java.net.*; 
//客户端
class  PicClient {
    public static void main(String[] args) throws Exception{
        //对传入的值进行判断
        if (args.length!=1) {
            System.out.println("请指定一个图片文件！");
            return; 
        }
        File file = new File(args[0]);
        //对文件路径进行判断
        if (!(file.exists()&&file.isFile())){
            System.out.println("你上传的文件有问题，非文件或者不存在！");
            return;
        }
        //判断是否是图片文件
        if (!file.getName().endsWith(".jpg")){
            System.out.println("图片格式错误，请重新选择！");
            return;
        }  
        //对文件大小进行判断
        if (file.length()>1024*1024*5){
            System.out.println("你上传的文件过大,居心叵测！");
            return;
        }
        //创建服务
        Socket s = new Socket("localhost",10000);
        //读取图片数据
        FileInputStream fis = new FileInputStream(file);
        //用Socket服务输出流写入数据
        OutputStream out = s.getOutputStream();
        BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = fis.read(buf))! = -1){
            out.write(buf,0,len);
        }
        //结束标记，表示文件数据已经上传完了
        s.shutdownOutput();
        String info=in.readLine();//读取返回信息
        System.out.println(info);
        fis.close();//关流
        s.close();
    }
}

//服务端
class PicServer{
    public static void main(String[] args)throws Exception{
        //创建服务，监听端口
        ServerSocket ss = new ServerSocket(10000);
        while (true){
            //获取客户端对象
            Socket s = ss.accept();
            //客户端执行线程
            new Thread(new PicThread(s)).start();
        }
        //ss.close();
    }
}

//利用多线程实现并发上传
class PicThread implements Runnable{
    private Socket s;
    PicThread(Socket s){
        this.s = s;
    }
    public void run(){
        int count = 1;
        //获取客户端ip
        String ip = s.getInetAddress().getHostAddress();
        try{
            System.out.println(ip+"  connected.....");
            //通过客户端的读取流读取数据
            InputStream in = s.getInputStream();
            //文件保存路径
            File dir = new File("C:\Users\asus\Desktop");
            //文件名
            File file = new File(dir,ip+".jpg");
            //判断文件是否存在
            while(file.exists()){
                file = new File(dir,ip+"("+(count++)+").jpg");
            }
            //将数据写入到指定文件中
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = in.read(buf))! = -1){
                fos.write(buf,0,len);
            }
            //将收到图片数据的信息返回给客户端
            OutputStream out = s.getOutputStream();
            out.write("上传成功！".getBytes());
            fos.close();//关流
            s.close();
        }catch (Exception e){
            throw new RuntimeException(ip+"图片上传失败");
        }
    }
}

四、URL&URLConnection

　　（一）概述

　　1、URI：表示一个统一资源标识符 (URI) 引用。

　　2、URL：代表一个统一资源定位符，它是指向互联网“资源”的指针。

　　3、URN：统一资源名称。

　　（二）常用方法

　　（1）构造函数：

　　URL(String protocol,String host,int port,String file)：根据指定 protocol、host、port号和 file 创建 URL对象。

　　（2）InputStream openStream() ：打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream。

　　（3）String getProtocol()：获取协议名称。

　　（4）String getHost()：获取主机名。

　　（5）int getPort()：获取端口号。

　　（6）String getFile()：获取URL文件名。

　　（7）String getPath()：获取此URL的路径部分。

　　（8）String getQuery()：获取此URL的查询部，客户端传输的特定信息。

　　（三）URLConnection

　　（1）URLConnection openConnection()：用URL调用此方法，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。

　　（2）InputStream getInputStream()：获取输入流

　　（3）OutputStream getOutputStream()：获取输出流

　　注：openStream的底层是通过openConnection()实现的。url.openStream()的可以用以下代码来代替实现：

URL url = new URL(“str_rul”);//str_url是表示“ip地址+端口+路径文件+参数”的字符串。
URLConcetion conn = url.openConnection();
InputStream in = conn.getInputStream();

　　（四）URL应用示例

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
public class URLDemo {
    public static void main(String[] args) throws IOException {
        String str_url = "http://127.0.0.1:8080/myweb/1.html";    
        URL url = new URL(str_url);    
         System.out.println("getProtocol:"+url.getProtocol());
         System.out.println("getHost:"+url.getHost());
         System.out.println("getPort:"+url.getPort());
         System.out.println("getFile:"+url.getFile());
         System.out.println("getPath:"+url.getPath());
         System.out.println("getQuery:"+url.getQuery());
         InputStream in = url.openStream();
        //获取url对象的Url连接器对象。将连接封装成了对象:java中内置的可以解析的具体协议的对象+socket.
        URLConnection conn = url.openConnection();
         String value = conn.getHeaderField("Content-Type");
          System.out.println(value);
         System.out.println(conn);
        InputStream in = conn.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(text);
        in.close();
    }
}

五、常见网路结构

　　（一）C/S结构（client/server）

　　1、特点：

　　　　该结构的软件，客户端和服务端都需要编写。

　　　　可发成本较高，维护较为麻烦。

　　2、好处：

　　　　客户端在本地可以分担一部分运算。

　　（二）B/S结构（browser/server）

　　1、特点：

　　　　该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代。

　　　　开发成本相对低，维护更为简单。

　　2、缺点：

　　　　所有运算都要在服务端完成。 

---------- android培训、java培训、期待与您交流！ ----------