Java网络编程基础知识_java

Java网络编程基础

1，Java网络编程概述
2，通信要素一：IP地址和端口号
- 2.1，IP
- 2.2，端口号
- 2.3，关于InetAddress类的说明：
3，通信要素二：网络协议
- 3.1，TCP网络编程
- 3.2，UDP网络编程
4，URL编程
- 4.1，URL常用方法测试
- 4.2，实现实现下载服务器端资源

1，Java网络编程概述

网络编程的目的：

直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

网络编程中有两个主要的问题：

问题1，如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
问题2，找到主机后如何可靠高效地进行数据传输

网络编程中的两个要素：

对应问题1：通过IP和端口号。
对应问题2：提供网络通信协议。

OSI是理想化的模型，实现较困难；实际应用中多是TCP/IP参考模型（4层）

2，通信要素一：IP地址和端口号

2.1，IP

IP地址实际太难记忆，如果访问网址通过一串数字就会很麻烦。因此就引入了域名(eg：www.baidu.com)。

当我们在浏览器端写出域名，浏览器就将域名发送到DNS（域名解析服务器），DNS再将域名进行解析获得IP地址，然后使用获得的IP地址访问相应的网络服务器，请求到资源。

另外注意：
本地回路地址即代表了本机：127.0.0.1；对应localhost(可看作本机ip域名)

2.2，端口号

2.3，关于InetAddress类的说明：

package com.atguigu.java1;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
 *IP地址唯一的标识 Internet 上的计算机（通信实体）
 *
 * Java中一个InetAddress类可以代表一个IP地址
 *
 * 如何实例化InetAddress：
 *  ①getByName(String host) :参数可以是域名或IP地址
 *  ②getLocalhost()：获取本机的Ip
 *  
 */
public class InetAddressTest {
    public static void main(String[] args) {
        try {
            InetAddress inet1 = InetAddress.getByName("192.168.10.14");//参数可以为IP
            System.out.println(inet1);        //    /192.168.10.14
            InetAddress inet2 = InetAddress.getByName("www.baidu.com");//参数可以为域名
            System.out.println(inet2);        //www.baidu.com/110.242.68.4。能解析出相应的IP
            InetAddress inet3 = InetAddress.getByName("127.0.0.1");//传入本机IP
            System.out.println(inet3);        //   /127.0.0.1

            InetAddress inet4 = InetAddress.getLocalHost(); //获取本机ip的方法
            System.out.println(inet4); //可以获取本机IP
            //两个常用方法：
            System.out.println(inet2.getHostName());   //www.baidu.com。 获取域名
            System.out.println(inet2.getHostAddress()); //110.242.68.4。 获取主机ip地址
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }
}

3，通信要素二：网络协议

TCP类似打电话；UDP类似发送短信，电报（不需要建立连接）。

TCP三次握手（建立连接）四次挥手（释放连接）：

通常是客户端（主动挥手）主动断开连接

3.1，TCP网络编程

例题1：编程实现客户端发送信息给服务端，服务端将数据显示在控制台上。

package com.atguigu.java1;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 实现TCP网络编程
 * 
 * 例：客户端发送信息给服务端，服务端将数据显示在控制台上
 */
public class TCPTest {
    //模拟一个客户端
    @Test
    public void client() {
        Socket socket = null;   
        OutputStream os = null;     
        try {
            //1，创建socket的对象，指明服务器端的IP和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");   //此处使用本机的IP进行演示
            socket = new Socket(inet, 8899);//造一个socket。Socket是端口号与IP地址的组合得出一个网络套接字

            //2，获取一个输出流，用于输出数据
            os = socket.getOutputStream(); //获取流
            //3，写出数据的 *** 作
            os.write("你好，我是客户端用户dddd".getBytes());  //getByte()方法返回一个byte[]。执行完此单元测试，数据就会成功发送到服务器端
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4，资源的关闭
            if (os != null) {
                //资源记得关闭
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //模拟一个服务器端（接收数据）
    @Test
    public void server() {
        ServerSocket ss = null;   
        Socket socket = null;   
        InputStream is = null;  
        try {
            //1，创建服务器端的socket对象（ServerSocket对象），指明自己的端口号
            ss = new ServerSocket(8899); //服务器端造的是ServerSocket，参数只需指明自己的端口号
            //2，调用accept()方法表示接受来自客户端的socket
            socket = ss.accept();
            //3，获取输入流
            is = socket.getInputStream();
            //4，读取输入流中的数据，把流显式输出到控制台
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                String s = new String(buffer, 0, len);
                System.out.println(s);
            }
            System.out.println("收到了来自于："+socket.getInetAddress().getHostAddress()+"的数据");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5，关闭资源
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!= null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

①先启动服务器端的单元测试方法，启动后如下图所示：

②再启动客户端的单元测试方法，启动后如下图所示

③显示结果：

例题2：实现客户端发送文件给服务器端，服务端将文件保存到本地

在当前module下放一张1.jpeg的图片，对此图片进行 *** 作。

package java1;
import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 实现TCP网络编程
 * 实现：客户端发送文件给服务器端，服务端将文件保存到本地
 */
public class TCPTest2 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        try {
            //1，造一个socket
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            //2，获取socket的输出流
            os = socket.getOutputStream();
            //3，获取输入流，从文件里读数据
            fis = new FileInputStream(new File("1.jpeg"));
            //4，具体读写过程
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5，资源关闭
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            //1，创建一个客户端的socket（ServerSocket）
            ss = new ServerSocket(9090);
            //2，接收来自客户端的socket
            socket = ss.accept();
            //3，读入，得到输入流
            is = socket.getInputStream();
            //4，保存
            fos = new FileOutputStream(new File("2.jpeg"));
            //读写过程
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //5，流的关闭
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (ss!=null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

用例题1中的执行方式依次执行两个单元测试方法

3.2，UDP网络编程

代码理解：

package java1;
import org.junit.Test;
import java.io.IOException;
import java.net.*;
/**
 * UDP协议的网络编程测试
 *
 */
public class UDPTest {
    //发送端
    @Test
    public void sender() throws IOException {
        //1,造一个DatagramSocket对象
        DatagramSocket socket = new DatagramSocket();   //UDP数据报通过数据报套接字 DatagramSocket 发送和接收

        //2,封装数据报
        String str="我是UDP方式发送的数据";
        byte[] data = str.getBytes();
        InetAddress inet=InetAddress.getByName("127.0.0.1");       //此处使用本机IP
        //或者使用InetAddress inet =InetAddress.getLocalHost();

        DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);  //DatagramPacket 对象封装了UDP数据报

        //3,通过socket把数据报发送出去
        socket.send(packet);

        //4,关闭socket
        socket.close();
    }

    //接收端
    @Test
    public void receiver() throws IOException {
        //1,接收端也使用DatagramSocket，要指明端口号
        DatagramSocket socket=new DatagramSocket(9090);

        byte[] buffer=new byte[100];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

        //2，接收数据
        socket.receive(packet);
        //3，输出控制台
        System.out.println(new String(packet.getData(),0,packet.getLength()));  //packet.getData()获取packet中的数据，返回一个字节数组
        //4，资源关闭
        socket.close();
    }
}

4，URL编程

种子其实就是一个url地址，只要服务器上的资源在，就能找到。

4.1，URL常用方法测试

package java1;

import java.net.MalformedURLException;
import java.net.URL;

/**
 * URL：统一资源定位符，对应互联网上的某一资源地址
 *
 */
public class URLTest {
    public static void main(String[] args) {
        //实例化
        try {
            URL url=new URL("http://localhost:8080/stuInfoSystem/toInfo?username=tom");
            System.out.println(url.getProtocol());      //http。获取URL的协议名
            System.out.println(url.getHost());      // localhost。获取主机名
            System.out.println(url.getPort());   //8080。获取端口号
            System.out.println(url.getPath());  ///stuInfoSystem/toInfo。获取文件具体路径
            System.out.println(url.getFile());  ///stuInfoSystem/toInfo?username=tom。获取URL的文件名
            System.out.println(url.getQuery());  //username=tom。获取url的查询名
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }

    }

}

4.2，实现实现下载服务器端资源

此处以Tomcat服务器为例

在Tomcat的webapps目录下的exemples目录下放一个名为1.jpeg的图片，思考如何实现下载。

运行Tomcat后在浏览器可以访问到此资源：

实现下载：

package java1;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * URL：统一资源定位符，对应互联网上的某一资源地址
 *
 */
public class URLTest {
    public static void main(String[] args) {
        HttpURLConnection urlConnection = null; //获取连接对象。这里实际获取到的是一个HttpURLConnection类型的对象
        InputStream is = null;  //拿到一个输入流
        FileOutputStream fos= null;  //保存位置
        try {
            //1，先创建一个URL
            URL url=new URL("http://localhost:8080/examples/1.jpeg");
            //2，实现下载图片
            urlConnection = (HttpURLConnection)url.openConnection();
            urlConnection.connect(); //获取连接
            is = urlConnection.getInputStream();
            fos = new FileOutputStream("ddd.jpeg");
            //读取后写入本地文件
            byte[] buffer =new byte[1024];
            int len;
            while ((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
            System.out.println("下载完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //关闭资源
            if (is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (urlConnection!=null){
                urlConnection.disconnect();
            }
        }
    }
}

运行后从Tomcat服务器下载完成ddd.jpeg。

注意：因为此处是main方法测试，所以运行程序后，资源下载到当前项目中目录下；如果是使用单元测试方法，会下载到当前的module目录下。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://www.outofmemory.cn/langs/794876.html

Java网络编程基础知识

发表评论

评论列表（0条）