首页 > 编程语言> 文章详细

Java网络编程

2020-07-09 13:03:07 阅读：146 来源： 互联网

标签：java socket import 编程网络 System new println Java

概述

信件
计算机网络
计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
网络编程的目的
无线电台，传播交流信息，数据交换、通信

如何准确定位网络上的一台主机 IP地址:端口，定位到这个计算机上的某个资源
找到了这个主机，如何传输数据
javaweb：网页编程 B/S
网络编程：ICP/IP C/S

网络通信的要素

如何实现网络的通信
通信双方地址
ip
端口号
192.168.16.124:5900
规则：网络通信协议

网络编程：重点时传输层，TCP、UDP

小结

网络编程中有两个主要的问题：如何准确的定位到网络上的一台或者多台主机；找到主机之后如何进行通信
网络编程中的要素：IP和端口号；网络通信协议
万物皆对象

IP

ip地址：InetAddress
唯一定位一台网络上计算机
127.0.0.1：本地 localhost
ip的分类

ipv4/ipv6：ipv4：127.0.0.1，4个字节组成，0-255，42亿个，2011年用尽了；
ipv6：fe80::183c:9bcb:1848:a115%14，128位，8个无符号整数，16^32个
公网（互联网）/私网（局域网）

公网：ABCD类
私网：192.168.xx.xx

域名
记忆IP

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本地地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            //查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用方法
            //System.out.println(inetAddress2.getAddress()); //没卵用
            System.out.println(inetAddress2.getCanonicalHostName()); //规范的名字
            System.out.println(inetAddress2.getHostAddress()); //ip
            System.out.println(inetAddress2.getHostName()); //域名，或自己电脑的名字

        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

输出

/127.0.0.1
localhost/127.0.0.1
DESKTOP-OKLJ610/192.168.1.104
www.baidu.com/220.181.38.149
220.181.38.149
220.181.38.149
www.baidu.com

端口

表示计算机上的一个程序的进程

不同的进程有不同的端口号！用来区分软件
被规定0-65535
TCP,UDP：各有65535，两个协议，端口号不冲突
分类：
公有端口 0-1023
HTTP 80
HTTPS 443
FTP 21
Telent 23
程序注册端口 1024-49151，分配用户或者程序
Tomcat 8080
MySQL 3306
Oracle 1521
动态、私有 49152-65535

#cmd命令 
netstat -ano #查看所有端口
netstat -ano|findstr "5900" #查看指定端口
tasklist|findstr "2244" #查看指定端口的进程

import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName()); //地址
        System.out.println(socketAddress.getPort()); //端口
    }
}

输出

/127.0.0.1:8080
localhost/127.0.0.1:8080
/127.0.0.1
127.0.0.1
8080

端口对应
两台电脑应用的通信要找到对应的端口

通信协议

协议：约定，普通话
网络通信协议
速率，传输码率，代码结构，传输控制...
问题：非常的复杂
大事化小：分层！
TCP/IP协议簇：实际上是一组协议
TCP：用户传输协议，打电话
UDP：用户数据报协议，发短信
出名的协议
TCP
IP：网络互连协议
TCP UDP 对比
TCP：打电话；连接，稳定；三次握手，四次挥手；客户端、服务端；传输完成释放连接，效率低
UDP：不连接，不稳定；客户端和服务端没有明确的界限；导弹；DDOS洪水攻击，饱和攻击
三次握手
A：想连接
B：可以，你还在吗
A：在，连吧
四次挥手
A：我要断开了
B：你要走了吗
B：真的要走了吗
A：真的走了

TCP

客户端

连接服务器 Socket
发送消息

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os = null;

        try {
            //1.要知道服务器的 地址 和 端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket连接
            socket = new Socket(serverIP,port);
            //3.发送消息 IO流
            os = socket.getOutputStream();
            os.write("hello".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器

建立服务的端口 ServerSocket
等待用户的链接 accept
接收用的消息

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.我得有一个地址
            serverSocket = new ServerSocket(9999);

            while (true){
                //2.等待客户端连接过来
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();

                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }
                System.out.println(baos.toString());
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if (baos != null) {
                try {
                    baos.close();
                }
                catch(IOException e){
                    e.printStackTrace();
                }
            }
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件上传

传输一个图片

客户端

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception{
        //1.创建一个socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.文件流
        FileInputStream fis = new FileInputStream(new File("jia.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput(); //我已经传输完了

        //确定服务器接收完毕，才能断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[] 管道流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());

        //5.关闭资源  先写的后关
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

服务器

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception{
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept(); //阻塞式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());

        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

Tomcat

服务端
自定义 S
Tomcat服务器 S java开发
客户端
自定义 C
浏览器 B

UDP

发短信：不用连接，

发消息

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1.建立一个socket
        DatagramSocket socket = new DatagramSocket();

        //2.建立包
        String msg = "你好a";

        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);

        //3.发送包
        socket.send(packet);

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

接收端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

//还是等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception{
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

        socket.receive(packet); //阻塞接收

        System.out.println(packet.getAddress().getHostAddress());
        System.out.println(new String(packet.getData(),0,packet.getLength()));

        //关闭连接
        socket.close();
    }
}

实现聊天

发送方

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(8080);

        //准备数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true){ //循环发送
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",666));

            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

接收方

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiverDemo01 {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(666);

        while (true){
            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet); //阻塞式接收

            //显示消息
            byte[] data = packet.getData();
            String receiveData = new String(data,0,data.length);
            System.out.println(receiveData);

            //断开连接
            if (receiveData.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

输出有点问题，1024位都出来了

解决
String receiveData = new String(data,0,data.length);
String去掉空格，改成
String receiveData = new String(data,0,data.length).trim();

多线程在线咨询

两个人都同时是发送方和接收方
写两个类 Send(fromPort,toIP,toPort) Reveice(port)
每个用户都有两个线程，分别用来发送和接收

URL

统一资源定位符
定位互联网上的某一个资源
DNS域名解析 www.baidu.com xx.xx.x.x
协议://ip地址:端口号/项目名

import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws Exception{
        URL url = new URL("http://localhost:8080/hello/index.jsp?username=peng");
        System.out.println(url.getProtocol()); //协议
        System.out.println(url.getHost()); //主机ip
        System.out.println(url.getPort()); //端口
        System.out.println(url.getPath()); //文件
        System.out.println(url.getFile()); //全路径
        System.out.println(url.getQuery()); //参数
    }
}

下载文件

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * Created by peng on 2020/5/7.
 */
public class URLDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("https://www.baidu.com/project/name.txt"); //随便输入的

        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("name.txt");

        byte[] buffer = new byte[1024];
        int len;
        while ((len=inputStream.read())!=-1){
            fos.write(buffer,0,len);
        }

        fos.close();
        inputStream.close();
        urlConnection.disconnect();
    }
}

标签：java,socket,import,编程,网络,System,new,println,Java
来源： https://www.cnblogs.com/peng8098/p/java02.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9