精华内容
下载资源
问答
  • 一般情况同一时刻服务器都不止和一个客户端进行通信,如果服务器只有一个线程,那么在多任务操作时任务之间就需要等待,因此需要为服务器创建多条线程提供给不同的同时客户端使用。 为服务器创建多线程,就类似于...

    1.多线程服务器端原理分析

    1. 一般情况下同一时刻服务器都不止和一个客户端进行通信,如果服务器只有一个线程,那么在多任务操作时任务之间就需要等待,因此需要为服务器创建多条线程提供给不同的同时客户端使用。
    2. 为服务器创建多线程,就类似于为服务器创建"影分身",让每一条线程都能享有一个独立的"影分身"服务器。
    3. 为了满足上述要求,每一条线程都必须传入一个新创建的Runnable接口实现类,实现类中的run()方法运行服务器的主程序。

    2.客户端代码

    客户端主要功能:

    1. 客户端向服务器发送信息。
    2. 客户端接收服务器的反馈信息。
    代码如下
    /*实现TCP通信的客户端程序
      实现步骤:
            1.创建Socket对象 (主动连接服务器)
                Socket(String host, int port)  host为服务器的地址(此处服务器也在本机所以使用环回地址),port为服务器中应用的端口
                
            2.OutputStream getOutputStream()
                返回套接字中的字节输出流,此时就可以使用write()方法写入数据,写入服务器
                
            3.InputStream getInputStream()
                返回套接字中的字节输入流对象,调用read()方法可以读取服务器发来的数据
                
            4.释放资源 close()
     */
     public class TCPClient {
    
        public static void main(String[] args) throws IOException {
    
            Socket client = new Socket("127.0.0.1",9000);
    
            OutputStream out = client.getOutputStream();
    
            byte[] bytes = new byte[1024];
            out.write("请求连接服务器".getBytes());  //没有写在文件中,写入了服务器(发送给了服务器)
    
    
    
            InputStream in = client.getInputStream();
    
            byte[] inBytes = new byte[1024];
            int inLen = in.read(inBytes);
    
            String s = new String(inBytes, 0, inLen);
            System.out.println(s);
    
            client.close();
        }
    
    }
    

    3.服务器代码

    服务器主要功能

    1. 服务器需要接收客户端发来的消息。
    2. 接收到消息后,服务器需要向客户端发送反馈信息。
      由于需要为服务器创建多线程,因此服务器实现的程序需要放在Runnable实现类的run()方法中
    代码如下
    /*实现TCP通信中的服务器程序
      实现TCP服务器步骤:
          1.创建ServerSocket对象
            ServerSocket(in port) 端口号
    
          2.等待客户端的连接,如果没有客户端连接,永远等待
            ServerSocket类方法 accept()  (等待客户端的连接)
            accept() 方法的返回值为Socket对象(客户端套接字,包含客户端的IP地址,用于回复信息)
    
          3.Socket对象中获取字节输入流
            InputStream getInputStream()
            对象调用read()方法,读取客户端发来的数据
    
          4.Socket对象中获取字节输出流
          OutputStream getOutputStream()
            对象调用write()方法,向客户端写入(回复)数据
    
          5.释放资源  close()
    
     */
    
    public class TCPThreadServerDemo {
    
        public static void main(String[] args) throws IOException {
    
            ServerSocket server = new ServerSocket(9000);
            
    		//循环放在此处是为了,当每次客户端与服务器通信完成时,服务器不停止运行,而是又再一次进入侦听状态,侦听是否还有服务器向自己发送信息;
            while (true) {
                Socket accept = server.accept();
    
                Thread thread = new Thread(new ThreadServer(accept));
    
                thread.start();
    
            }
        }
    }
    
    
    public class ThreadServer implements Runnable{
    
        private Socket accept;
    	//测试类中传入服务器的侦听accept()侦听到的客户端对象
        public ThreadServer(Socket accept){
            this.accept = accept;
        }
    
        @Override
        public void run() {
    
                try {
                    Server.ServerMethod(accept);
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    
    
    public class Server {
    
        public static void ServerMethod(Socket accept) throws IOException {
    
            InputStream in = accept.getInputStream();
    
            byte[] bytes = new byte[1024];
            int len = in.read(bytes);
            String s = new String(bytes, 0, len);
            System.out.println(s + Thread.currentThread().getName());
    
    
            OutputStream out = accept.getOutputStream();
            out.write("连接成功!".getBytes());
    
            accept.close();
    
        }
    }
    

    测试使用了6个客户端与服务器进行通信,使用这种方式模拟多线程服务器的通信,服务器端结果如下:

    请求连接服务器Thread-0
    请求连接服务器Thread-1
    请求连接服务器Thread-2
    请求连接服务器Thread-3
    请求连接服务器Thread-4
    请求连接服务器Thread-5
    

    4.分析结果

    对上述结果进行分析,发现被使用过的线程任务执行完毕后就死亡了,不能被再次使用,下一个客户端对服务器发起连接时将使用新new出来的Thread,旧的线程资源其实已经使用完了但是无法再次调用start()使用,这要会导致资源浪费;因此我对代码进行了一些修改,同时开启多路线程,使得每个线程内部的run()方法套上while(true)循环使得线程永不终止,将服务器的侦听器放到线程的内部,测试类只需向线程代码传递服务器的连接(套接字)对象即可;当客户端向服务器发送数据时选择进入一个线程,完成线程任务即可。

    5.修改版本

    代码如下

    代码只修改服务器端多线程入口部分,客户端和服务器端主题代码与上述一致,此处不重复书写

    public class TCPThreadServerDemo {
    
        public static void main(String[] args) throws IOException {
    
            ServerSocket server = new ServerSocket(9000);
    
    		//创建多条线程,每条线程都会独立的侦听客户端发送来的消息;
            Thread thread0 = new Thread(new ThreadServer(server));
    
            Thread thread1 = new Thread(new ThreadServer(server));
    
            Thread thread2 = new Thread(new ThreadServer(server));
    
            thread0.start();
            thread1.start();
            thread2.start();
    
        }
    }
    
    public class ThreadServer implements Runnable{
    
        private ServerSocket server;
    
        public ThreadServer(ServerSocket server){
            this.server = server;
        }
    
    
        @Override
        public void run() {
    
            while (true){
    
                try {
                //将侦听方法写在了run()方法内,这样每条线程都可以侦听+执行服务器命令,并且都可以反复侦听,而不是像上面的方法,侦听到客户端消息后再创建新线程;
                    Socket accept = server.accept();
                    Server.ServerMethod(accept);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    这样线程可以被复用,不像上面的方法每条线程只能执行一次通信任务;但是与此同时也出现了问题,如果现在没有客户端向服务器发送请求,但是三个线程还是同时开启着并且不断侦听,十分浪费,如何做到多线程时线程可以复用,同时又能做到无任务时线程可以关闭,侦听到任务时线程才开启。此时就需要使用线程池,当需要使用线程时,向线程池获取线程,此线程就被激活,试用结束后归还线程(线程不会死亡),线程进入空闲状态;这样使用后的线程可以被复用,同时又不会在无任务状态下使多个线程持续运行,解决了上述两种服务器端多线程通信的两个矛盾点;

    6.采用线程池的多线程服务器端

    代码如下

    省略上面已有的客户端和服务器端主程序
    这展示被修改部分的代码

    public class TCPThreadServerDemo {
    
        public static void main(String[] args) throws IOException {
    
            //创建线程池对象,线程池线程容量为3
            ExecutorService service = Executors.newFixedThreadPool(3);
    
            ServerSocket server = new ServerSocket(9000);
    
    
            while (true) {
                Socket accept = server.accept();
    
    //            Thread thread = new Thread(new ThreadServer(accept));
    			//提交线程任务,从线程池中获取线程
                service.submit(new ThreadServer(accept));
                //System.out.println(service);
    
            }
        }
    }
    
    public class ThreadServer implements Runnable{
    
        private Socket accept;
    
        public ThreadServer(Socket accept){
            this.accept = accept;
        }
    
        @Override
        public void run() {
    
                try {
                    Server.ServerMethod(accept);
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    

    测试使用了7个客户端与服务器进行通信,服务器端结果如下:

    请求连接服务器pool-1-thread-1
    请求连接服务器pool-1-thread-2
    请求连接服务器pool-1-thread-3
    请求连接服务器pool-1-thread-1
    请求连接服务器pool-1-thread-2
    请求连接服务器pool-1-thread-3
    请求连接服务器pool-1-thread-1
    

    上述是初学者的个人想法,如果有任何问题或不同观点,或者我写的有错,都可以提出,大家一起讨论,不过请轻点喷 ^ - ^ !

    展开全文
  • 总结:将不同地理位置,功能独立多个计算机通过通信设备连接起来,实现数据共享 网络编程: 指是在已有网络环境前提,进行数据传输,对于发送端就是数据按照规定协议进行打包,对于接收端根据规定一些...

    网络编程基本概念:
    计算机网络:

    在这里插入图片描述总结:将不同地理位置,功能独立的多个计算机通过通信设备连接起来,实现数据共享
    网络编程:
    指的是在已有网络环境的前提下,进行数据的传输,对于发送端就是数据按照规定的协议进行打包,对于接收端根据规定的一些进行数据解析。
    网络通信的三要素:
    1.IP地址 2端口号 3协议

    IP地址:
    java.net包 网络包
    InetAddress用于描述IP地址这类事物的,用于表示网络计算机的唯一标识。
    Inet4Address:使用32位来表示,4个字节来表示,0~255
    Inet6Address:使用128位来表示,16个字节,分成8组,使用十六进制数…

    在这里插入图片描述
    在这里插入图片描述
    本地回还地址:
    127.0.0.1

    端口号:
    不同计算机间数据通信,实际是软件在进行通信。计算机中软件的标识—端口号。
    端口号就是一个两个字节的整数,无符号表示,0~65535范围。
    其中0~1023被占用的,因此我们写的程序需要指定端口号,大于1023以上去指定。

    协议:
    通信双方想要通信。按照指定的规则进行通信,规则即协议。
    UDP:数据报包协议(发送端和接受端)
    特点:面向无连接、速度快、不可靠协议
    应用:视频会议等软件,实例:发快递相似
    TCP:传输控制协议(客户端和服务端)
    特点:面向有连接(三次握手)、速度慢、可靠协议
    三次握手:
    1.客户端发送数据到服务端
    2.服务端接收到数据。并且给客户端返回信息
    3.客户端接收服务端返回的信息
    应用:文件的长传、下载等实例:打电话

    在这里插入图片描述

    在这里插入图片描述

    UDP协议进行数据传输:
    通信需要双方:
    接收端和发送端
    由于UDP协议是面向无连接的,因此通信双方使用的是同一个对象(套接字)。
    DatagramSocket:套接字对象
    DatagramPacket:打包、接包
    发送端:
    1.创建套接字对象
    2.打包数据
    3.发包
    4.关闭

    在这里插入图片描述

    接收端:
    1.创建套接字对象,绑定端口号
    2.接包
    3,拆包
    4.关闭

    在这里插入图片描述

    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    import java.util.Scanner;
    
    public class UDPSendDemo1 {
    	public static void main(String[] args) throws IOException{
    		//模拟实现聊天室---发送端
    		Scanner in = new Scanner(System.in);
    		//创建套接字对象
    		DatagramSocket ds = new DatagramSocket();
    		while(true) {
    			System.out.println("发送内容:");
    			String content = in.next();
    			//封包
    			DatagramPacket dp = new DatagramPacket(content.getBytes(), content.getBytes().length,
    					InetAddress.getByName("10.10.117.85"), 9999);
    			
    			//发送
    			ds.send(dp);
    			
    			//退出程序
    			if("exit".equals(content))
    				return;
    			
    			
    			System.out.println("----------------------------------------");
    			DatagramPacket dp1 = new DatagramPacket(new byte[1024], 1024);
    			ds.receive(dp1);
    			System.out.println("朋友说:"+new String(dp1.getData(),0,dp1.getLength()));
    		}
    		
    	}
    }
    
    ```java
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.util.Scanner;
    
    public class UDPReceDemo1 {
    	public static void main(String[] args) throws IOException{
    		//模拟聊天室--接收端
    		Scanner in = new Scanner(System.in);
    		DatagramSocket ds = new DatagramSocket(9999);
    		while(true) {
    			//接包
    			DatagramPacket dp = new DatagramPacket(new byte[1024], 1024);
    			ds.receive(dp);
    			//拆包
    			System.out.println("朋友说:"+new String(dp.getData(),0,dp.getLength()));
    			
    			//退出
    			if("exit".equals(new String(dp.getData(),0,dp.getLength())))
    				return;
    			
    			System.out.println("---------------------------------------------");
    			String msg = in.next();
    			byte[] buf = msg.getBytes();
    			DatagramPacket dp1 = new DatagramPacket(buf, buf.length, dp.getAddress(), dp.getPort());
    			ds.send(dp1);
    		}
    //		ds.close();
    	}
    }
    
    
    
    
    最终实现数据发送与接收,可与其他人一起实验,需要更改,知晓对方ip地址
    
    展开全文
  • 计算机网络是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 1 网络编程...

    一 、什么是计算机网络
    计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。

    1 网络编程的目的
    实现传播交流信息,数据交换、通信

    2 如何确定网络上的一台主机
    IP地址 + port 定位到这台计算机的某个资源
    eg:192.168.16.124:8080

    二 、网络通信要素
    1 、 通信双方地址 : IP + port
    2 、 网络通信的协议
    TCP/IP参考模型
    在这里插入图片描述

    我们这篇博客主要是针对传输层

    三 、IP
    IP地址 :InetAddress

    唯一定位一台计算机

    127.0.0.1 /localhost 本机地址

    ip地址分类
    1 、 ipv4 : 四个字节组成(1byte = 8bit),每个字节的范围是0 - 255 (1X27+1X26+1X25+1X24+1X23+lX22+1 X21+1X20=255);ipv4一共有42亿,但是30亿都在北美,亚洲4亿,2011年就用完了,所以有了IPV6
    2、IPV6 : 128位,8位无符号整数
    eg ; 2001 :obba :1284:0000:0000:1aaa:2aaa:1524

    公网 (互联网)、私网(局域网)

    *  ABCD 类地址 
    * 192.168.XX.xx 专门给组织内部使用
    

    1
    2
    域名:解决IP记忆问题

    与IP相关的类 InetAddress

    package intentp;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class testInternrt {
        public static void main(String[] args) {
            try {
                //查询ip地址
                InetAddress address = InetAddress.getByName("127.0.0.1");
                InetAddress address1 = InetAddress.getByName("www.baidu.com");
                InetAddress localHost = InetAddress.getLocalHost();
                System.out.println(address1);
                System.out.println(address);
                System.out.println(localHost);
                System.out.println(InetAddress.getAllByName("127.0.0.1"));
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
    }
    

    一个程序进程

    四 端口port
    我们可以将端口理解为表示计算机上的一个进程

         * 不同的进程有不同的端口号!
         * 被规定:0 ——65535
         * TCP/ UDP :65535 * 2 单个协议下端口号不能相同
         * 端口分类
                **  共有端口0-1023
                **  HTTP :80(默认端口)
                ** HTTPS :443 (默认端口)
                ** FTP:  21 
                ** Telent : 23
        * 程序注册端口:1024-49151
            * Tomcat 8080
            * Mysql 3306
            * Oracle : 1521
        * 动态私有 : 49152 - 65535
        *关于端口常见的dos命令
               * netstat -ano 查看所有的端口
               * netstat -ano |findstr  "port"  查找指定的端口
               * tasklist|findstr "port“”   查看指定端口的进程
               * taskkill -pid  进程号 -f 杀死端进程
               * ctr + shift +esc   打开任务管理器
    
    package intentp;
    
    import java.net.InetSocketAddress;
    
    /**
     *C:\Windows\System32\drivers\etc 里面的host文件可以配置本机的映射地址
     * 127.0.0.1  www.sso.com
     */
    public class InetSocketAddressTest {
        public static void main(String[] args) {
            InetSocketAddress socketAddress = new InetSocketAddress("localhost", 8080);
            InetSocketAddress socketAddress2 = new InetSocketAddress("127.0.0.1", 8080);
            System.out.println(socketAddress);
            System.out.println(socketAddress2);
            System.out.println(socketAddress.getAddress());
            System.out.println(socketAddress.getHostName());
            System.out.println(socketAddress.getPort());
        }
    
    }
    

    这里给大家说一下如何配置本机地址的映射
    打开我的电脑——》C盘——》System32——》drivers——》etc 找到host文件,在里面添加映射就可以了
    在这里插入图片描述

    五 、通信协议
    协议:可以理解为一中约定,约定以双方能懂的方式进行交流
    TCP/IP协议簇

    TCP : 用户传输协议
    UDP : 用户数据协议报
    TCP/UDP对比
    TCP :
    连接、稳定
    三次握手
    四次挥手
    客户端 、服务端
    传输完成、释放连接、效率低
    UDP:

    不连接、不稳定
    客户端、服务端 没有明确的界限
    不管有没有准备好都可以发送给你
    比如:DDOS 洪水攻击
    TCP实现聊天
    TCP实现客户端和服务端之间的通信

    package intentp;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * TCP: 实现聊天
     * client:
     * server:
     *
     */
    //客户端
    public class TcpClientDemo {
        public static void main(String[] args) {
            //要知道服务器的地址
            Socket socket = null;
            OutputStream os = null;
            try {
                InetAddress   serverip = InetAddress.getByName("127.0.0.1");
                int port = 9999;
                //传建一个scoket连接
                 socket = new Socket(serverip,port);
                //发消息
                  os = socket.getOutputStream();
                  os.write("你好服务器".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();
                    }
                }
    
    
            }
        }
    }
    
    package intentp;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    //服务端
    public class TcpServerDemo {
        public static void main(String[] args) {
            ServerSocket serverSocket = null;
            Socket accept = null;
            InputStream inputStream = null;
            ByteArrayOutputStream baos = null;
            // 有一个地址
            try {
                 serverSocket = new ServerSocket(9999);
                //等待客户端连接
                 accept = serverSocket.accept();
                //接收消息
                 inputStream = accept.getInputStream();
                /*
                //这样写 万一内容超过1024就容易断开
                byte[] bytes = new byte[1024];
                int len ;
                while((len = inputStream.read(bytes)) != -1){
                    String s = new String(bytes, 0, len);
                    System.out.println(s);
                }*/
                 baos = new ByteArrayOutputStream();
                byte[] bytes = new byte[1024];
                int len;
                while ((len = inputStream.read(bytes)) != -1){
                    baos.write(bytes,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 (inputStream != null){
                   try {
                       inputStream.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
                if (accept != null){
                    try {
                        accept.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (serverSocket != null){
                    try {
                        serverSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
    
        }
    }
    

    TCP实现文件传输

    package intentp;
    
    import java.io.*;
    import java.net.InetAddress;
    import java.net.Socket;
    
    /**
     * TCP文件上传
     *
     */
    public class TcpFileClientDemo {
        public static void main(String[] args) throws Exception{
            //创建一个socket连接
            Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
            //创建一个输出流
            OutputStream os = socket.getOutputStream();
    
            //文件流
            FileInputStream fileInputStream = new FileInputStream(new File("class2.png"));
            byte[] bytes = new byte[1024];
            int len = 0;
            while((len=fileInputStream.read(bytes)) != -1){
                os.write(bytes,0,len);
            }
            //通知服务器我已经结束了
            socket.shutdownOutput();//我已经传输完了
            //确定服务器接收完毕
            InputStream iss = socket.getInputStream();
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            while ((len = iss.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }
            System.out.println(bos.toString());
            //关闭资源
            bos.close();
            iss.close();
            fileInputStream.close();
            os.close();
            socket.close();
    
        }
    
    }
    
    package intentp;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * TCP 传输文件服务器端
     */
    public class TcpFileServerDemo {
        public static void main(String[] args) throws  Exception{
            //建立一个地址--->创建服务
            ServerSocket socket = new ServerSocket(9000);
            //等待连接------》监听服务(阻塞监听)
            Socket accept = socket.accept();
            //接收消息
            InputStream is = accept.getInputStream();
            FileOutputStream fos = new FileOutputStream(new File("receive.png"));
            byte[] bytes = new byte[1024];
            int len;
            while((len = is.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
    
            //通知客户端我接受完了
            OutputStream oss = accept.getOutputStream();
            oss.write("我接收完了,你可以断开了".getBytes());
            oss.close();
            fos.close();
            is.close();
            accept.close();
            socket.close();
    
    
    
        }
    }
    

    UDP消息发送

    package intentp;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    /**
     * Tomcat 完全由java写的
     * UDP 不用连接 服务器
     * 建立socket
     * 建立一个包
     * 发送包
     * 主要方法 data报包
     *
     */
    public class UdpClientDemo {
        public static void main(String[] args) throws  Exception {
            //建立socket
            DatagramSocket socket = new DatagramSocket(9090);
            //建立一个包 //发送给谁 //发送什么
            String mssage = "我是UDP不建立连接";
            InetAddress localhost = InetAddress.getByName("localhost");
            int port = 9090;
            DatagramPacket packet = new DatagramPacket(mssage.getBytes(),0,mssage.getBytes().length,localhost,port);
            //发送包
            socket.send(packet);
            //关闭资源
            socket.close();
    
        }
    
    }
    

    UDP中客户端和服务端没有明确的界限

    package intentp;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    /**
     * UDP 没有真正的client 和server 概念
     * 还是要等待客户端的连接
     */
    public class UdpServerDemo {
        public static void main(String[] args) throws  Exception{
            //开放端口
            DatagramSocket socket = new DatagramSocket(9090);
            //接收数据
            byte[] bytes = new byte[1024];
            //接到哪里
            DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length);
            socket.receive(packet);
            System.out.println(packet.getAddress().getHostAddress());
            System.out.println(new String(packet.getData(),0,packet.getLength()));
            socket.close();
    
    
        }
    }
    

    UDP实现聊天

    package chat;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    import java.net.InetSocketAddress;
    
    public class UdpSendDemo {
        public static void main(String[] args) throws Exception {
            DatagramSocket socket = new DatagramSocket(8888);
    
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            while (true){
                String s = reader.readLine();
                byte[] bytes = s.getBytes();
                //建立一个包 //发送给谁 //发送什么
                DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length,new InetSocketAddress("localhost",6666));
                socket.send(packet);
                if (bytes.equals("bye")){
                    break;
                }
            }
            socket.close();
    
        }
    }
    
    package chat;
    
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    public class UdpResceiveDemo {
        public static void main(String[] args) throws  Exception{
            DatagramSocket socket = new DatagramSocket(6666);
            while (true){
                byte[] bytes = new byte[1024];
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
                socket.receive(datagramPacket);
                byte[] data = datagramPacket.getData();
                String s = new String(data, 0, data.length);
                System.out.println(s);
                if (s.equals("bye")){
                    break;
                }
    
            }
            socket.close();
    
        }
    }
    

    UDP多线程在线咨询
    TALKSEND

    package chat;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetSocketAddress;
    import java.net.SocketException;
    
    public class TalkSened implements Runnable {
        DatagramSocket socket = null;
        BufferedReader reader = null;
    
        private  String toIp;
        private  int toProt;
        private  int fromProt;
    
        public TalkSened(String toIp, int toProt, int fromProt) {
            this.toIp = toIp;
            this.toProt = toProt;
            this.fromProt = fromProt;
            try {
                socket = new DatagramSocket(this.fromProt);
                reader = new BufferedReader(new InputStreamReader(System.in));
            } catch (SocketException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void run() {
            while (true){
                String s = null;
                try {
                    s = reader.readLine();
                    byte[] bytes = s.getBytes();
                    DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length,new InetSocketAddress(this.toIp,this.toProt));
                    socket.send(packet);
                    if (bytes.equals("bye")){
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
            socket.close();
    
        }
    }
    

    TALKRECEVIE

    package chat;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class TalkReceive implements Runnable {
        DatagramSocket socket = null;
        private int fromProt;
        private  String  fromMessge;
    
        public TalkReceive(int fromProt,String fromMessge) {
            this.fromProt = fromProt;
            this.fromMessge = fromMessge;
            try {
                socket = new DatagramSocket(this.fromProt);
            } catch (SocketException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void run() {
    
            while (true){
                try {
                    byte[] bytes = new byte[1024];
                    DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
                    socket.receive(datagramPacket);
                    byte[] data = datagramPacket.getData();
                    String s = new String(data, 0, data.length);
                    System.out.println(fromMessge+":"+ s);
                    if (s.equals("bye")){
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
    
            }
            socket.close();
        }
    }
    

    学生

    package chat;
    
    public class TalkStudent {
        public static void main(String[] args) {
            TalkSened talkSened = new TalkSened("localhost", 9999, 7777);
            TalkReceive talkReceive = new TalkReceive(8888, "老师");
            new Thread(talkSened).start();
            new Thread(talkReceive).start();
    
        }
    }
    

    老师

    package chat;
    
    public class TalkTeacher {
    public static void main(String[] args) {
    TalkSened talkSened = new TalkSened(“localhost”, 8888, 5555);
    TalkReceive talkReceive = new TalkReceive(9999, “学生”);
    new Thread(talkSened).start();
    new Thread(talkReceive).start();
    
    }
    }
    

    在这里插入图片描述

    在这里插入图片描述

    URL下载网络资源

    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.net.URLConnection;
    
    public class Url {
        public static void main(String[] args) throws  Exception {
            URL url = new URL("https://www.baidu/XXXX);//这里写下载资源的网络地址
            //连接到这个资源
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            InputStream inputStream = urlConnection.getInputStream();
            FileOutputStream fos = new FileOutputStream("f.m4a");
            byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }
                fos.close();
                inputStream.close();
                urlConnection.disconnect();
        }
    }
    
    展开全文
  • Java网络通信

    2018-03-12 21:35:49
    一 ip地址和端口号 IP地址:确定网络上一个绝对地址(类似于一个房子地址)端口号:区分计算机软件(类似于房子房门) 2个字节 0--65535在同一协议,端口号不能重复,不同协议可以重复,1024一下端口号...

    一 ip地址和端口号 

    IP地址:确定网络上一个绝对地址(类似于一个房子的地址)

    端口号:区分计算机软件(类似于房子的房门) 2个字节  0--65535

    在同一协议下,端口号不能重复,不同协议下可以重复,1024一下的端口号一般分配给了系统用。

    主机名到 IP 地址的解析通过使用本地机器配置信息和DNS来实现。要使用的特定命名服务默认情况下是本地机器配置的那个。对于任何主机名称,都返回其相应的 IP 地址。

    InetAddress 类具有一个缓存,用于存储成功及不成功的主机名解析。

    测试代码:

    1.通过类InetAddress 获得(无构造器)

    static InetAddress getLocalHost()返回本地主机

    static InetAddress getByName(String host)在给定主机名的情况下确定主机的 IP 地址。主机名可以是机器名(如"java.sun.com"),也可以是其 IP 地址的文本表示形式。

    package com.sunlei.net.ip;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class InetDemo02 {
    	public static void main(String[] args) throws UnknownHostException {
    		//使用getLocalHost方法创建InetAddress对象
    		InetAddress addr = InetAddress.getLocalHost();
    		System.out.println(addr.getHostName());//返回计算机名
    		System.out.println(addr.getHostAddress());//返回ip
    		
    		//根据域名得到InetAddress对象
    		addr = InetAddress.getByName("www.163.com");
    		System.out.println(addr.getHostAddress());//返回ip
    		System.out.println(addr.getHostName());
    		
    		//根据IP得到InetAddress对象
    		addr = InetAddress.getByName("222.211.64.51");
    		System.out.println(addr.getHostAddress());
    		System.out.println(addr.getHostName());//返回域名
    	}
    }
    

    2.通过类InetSocketAddress获得(有构造器)

        根据主机名和端口号创建套接字地址。尝试将主机名解析为 InetAddress。如果尝试失败,则将地址标记为未解析

    package com.sunlei.net.ip;
    
    import java.net.InetAddress;
    import java.net.InetSocketAddress;
    
    /*
     * 封装端口,在InetAddress基础上+端口*/
    
    public class InetSocketDemo01 {
    
    	public static void main(String[] args) {
    		InetSocketAddress address = new InetSocketAddress("127.0.0.1",9999);
    		System.out.println(address.getHostName());
    		System.out.println(address.getPort());
    		
    		InetAddress add = address.getAddress();
    		System.out.println(add.getHostName());//返回计算机名
    		System.out.println(add.getHostAddress());//返回ip
    	}
    }

    二 URL资源定位

        代表一个统一资源定位符,它是指向互联网“资源”的指针。

        由四部分:协议,存放资源的主机域名,端口号,资源文件名(/之后)

        URL(String spee):绝对路径

        URL(URL context,String spee):相对路径构建

    package com.sunlei.net.url;
    
    import java.net.MalformedURLException;
    import java.net.URL;
    
    public class URLDemo01 {
    	public static void main(String[] args) throws MalformedURLException{
    		//绝对路径构建
    		URL url = new URL("http://www.baidu.com:80/index.html#aa?uname=sunlei");		
    		System.out.println("协议:"+url.getProtocol());
    		System.out.println("域名:"+url.getHost());
    		System.out.println("端口:"+url.getPort());
    		System.out.println("资源:"+url.getFile());
    		System.out.println("相对路径:"+url.getPath());
    		System.out.println("锚点"+url.getRef());
    		System.out.println("参数"+url.getQuery());//存在锚点返回null
    		
    		//相对路径创建
    		url = new URL("http://www.baidu.com:80/a/");
    		url = new URL(url,"b.txt");
    		System.out.println(url.toString());
    	}
    }

        html->格式化数据

        CSS->美化数据

        JS->交互数据


    三 UDP通信(以数据为中心,非面向连接, 不安全,数据可能丢失,效率高,类似发短信)

    1.客户端

    (1)创建DatagramSocket类+指定端口

    (2)准备数据(字节数组)

    (3)打包(DatagramPacket+服务器地址及端口)

    (4)发送

    (5)释放资源

    2.服务端

    (1)创建服务端DatagramSocket类+指定端口

    (2)准备接受容器(字节数组)

    (3)包(接受数据)

    (4)分析

    (5)释放资源 

    package com.sunlei.net.udp;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetSocketAddress;
    
    /*
     * 客户端
     * */
    
    public class MyClient {
    
    	public static void main(String[] args) throws IOException {
    		//创建客户端+端口
    		DatagramSocket client = new DatagramSocket(6666);
    		//准备数据
    		String msg = "udp编程";
    		byte[] data = msg.getBytes();
    		//打包DatagramPacket(byte[] buf, int length, SocketAddress address)
    		DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
    		//发送
    		client.send(packet);
    		//释放
    		client.close();
    	}
    }
    
    package com.sunlei.net.udp;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    /*
     * 服务端
     * */
    
    public class MyServer {
    
    	public static void main(String[] args) throws IOException {
    		//创建服务端+端口
    		DatagramSocket server = new DatagramSocket(8888);
    		//准备接收容器
    		byte[] container = new byte[1024];
    		//封装成DatagramPacket(byte[] buf, int length) 
    		DatagramPacket packet = new DatagramPacket(container,container.length);
    		//接收数据(阻塞式接收)
    		server.receive(packet);
    		//分析数据
    		byte[] data = packet.getData();
    		int len = packet.getLength();
    		System.out.println(new String(data,0,len));
    		//释放资源
    		server.close();
    	}
    
    }
    

    四 TCP通信(面向连接 安全 可靠 效率高低 类似打电话)

    package com.sunlei.net.tcp.socket;
    
    import java.io.BufferedReader;
    import java.io.DataInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.Socket;
    import java.net.UnknownHostException;
    
    public class Client {
    	public static void main(String[] args) throws UnknownHostException, IOException {
    		//创建客户端+指定端口   Socket(String host, int port) 
    		Socket client = new Socket("localhost",8888);
    		//接收数据
    		/*
    		BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
    		String echo = br.readLine();
    		System.out.println(echo);
    		*/
    		DataInputStream dis = new DataInputStream(client.getInputStream());
    		String echo = dis.readUTF();
    		System.out.println(echo);
    	}
    }

    package com.sunlei.net.tcp.socket;
    
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.OutputStreamWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server {
    	public static void main(String[] args) throws IOException {
    		//创建客户端+指定端口
    		ServerSocket server = new ServerSocket(8888);
    		//接收客户端的连接 阻塞式
    		Socket socket = server.accept();
    		System.out.println("一个客户端连接");
    		//发送数据
    		String msg = "欢迎使用";
    		//输出流
    		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    		bw.write(msg);
    		bw.newLine();//行结束
    		bw.flush();
    	}
    }
    

    展开全文
  •  * 是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 * B:网络编程  * 就是...
  • 计算机网络是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程目的...
  • // 让该类实现Runnable接口,该类实例可作为线程target public class MulticastSocketTest implements Runnable { // 使用常量作为本程序多点广播IP地址 private static final String BROADCAST_IP = "230...
  • 本文对网络应用中阻塞通信与非阻塞通信工作机制及实现等问题进行了研究和探讨提出了系统地实现阻塞与非阻塞通信的方法和步骤文中对比了两种不同的网络通信方式分别给出了基于阻塞与非阻塞IO开发高性能网络应用程序...
  • 一、JAVA网络编程概述网络应用程序,就是在已实现网络互联的不同计算机上运行应用程序,这些程序之间可以相互交换数据。JAVA是优秀的网络编程语言,Java网络编程类库位于java.net包中。Java支持TCP/UDP及其上层...
  • 可以将套接字看作不同主机间进程进行双间通信的端点,它构成了单个主机内及整个网络编程界面。套接字存在于通信域中,通信域是为了处理一般线程通过套接字通信而引进一种抽象概念。套接字通常和同一个域中...
  • Java实现 蓝桥杯 历届试题 网络寻路

    万次阅读 多人点赞 2019-07-26 22:04:57
    节点间的通信是双向的。某重要数据包,为了安全起见,必须恰好被转发两次到达目的地。该包可能在任意一个节点产生,我们需要知道该网络中一共有多少种不同的转发路径。 源地址和目标地址可以相同,但中间节点必须...
  • 是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程 就是用来实现网络...
  • 是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程 就是用来实现网络...
  • 网络编程:就是在一定的协议实现两台计算机的通信的程序 网络通信协议: 通过计算机网络可以使多台计算机实现连接,位于同一网络的计算机在进行连接和通信时需要遵守一定的规则,在计算机网络中,这些连接和...
  • 一、概念 ...在因特网协议族(Internet protocol suite)中,TCP层是位于IP层之上,应用层之下的中间层。不同主机的应用层之间经常需要可靠的、像管道一样的连接,但是IP层不提供这样的流机制,而是提
  • 今天我们来聊聊网络编程这部分内容网络编程1)计算机网络是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源...
  • 网络通信协议实现网络互联的不同计算机上运行程序间可以进行数据交换 网络编程三要素: IP地址(找到网络计算机) 端口(识别程序) 协议(数据传输需要遵循连接和通信的规则,常见UDP、TCP协议) ...
  • 节点间的通信是双向的。某重要数据包,为了安全起见,必须恰好被转发两次到达目的地。该包可能在任意一个节点产生,我们需要知道该网络中一共有多少种不同的转发路径。 源地址和目标地址可以相同,但中间节点必须...
  • Java的网络编程

    2020-05-30 15:04:52
    网络编程,就是在一定的协议实现两台计算机的通信程序。 网络通信协议:在计算机网络中,连接和通信的规则被称为网络通信协议。它对数据的传输格式,传输速率,传输步骤都做了同意规定,通信双方必须同时遵守...
  • Java网络编程

    2018-06-26 17:35:08
    是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程 就是用来实现...
  • Java网络的编程

    2020-08-06 20:58:47
    通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程目的: 无限电台、传播交流信息、数据交换、通信… 想要达到这个效果需要什么...
  • 计算机网络,就是把分布在不同地理区域计算机与专门外部设备用通信线路互连成一个规模大、功能强的网络系统,从而使众多计算机可以方便地互相传递信息,共享硬件、软件、数据信息等资源。 计算机网络实现...
  • 网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统。 网络编程 就是用来实现网络互连的不同计算机上运行程序间可以进行数据交换。 TCP/IP协议栈 应用层 ...
  • 是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统 网络编程 在网络通信协议...
  • 计算机网络是指将地理位置不同的具有独立功能多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议管理和协调实现资源共享和信息传递计算机系统 网络编程目的: ...
  • 网络协议:计算机网络可以使多台计算机实现连接,位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则,...TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层,每层分别负责不同的通信功能,接...
  • 计算机网络:将地理位置不同的多台计算机通过线路连接起来,在网络系统,管理软件,以及网络协议协调实现资源共享和信息传递 网络编程中通过 ip 地址和 Mac 地址定位到一台或者多台计算机,然后进行 TCP /UDP ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 459
精华内容 183
关键字:

java实现不同网络下的通信

java 订阅