java基础之 网络编程

最新推荐文章于 2021-03-06 14:34:24 发布
最新推荐文章于 2021-03-06 14:34:24 发布
阅读量434 收藏 1
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/icanhaha/article/details/44264893
版权

1. 基本知识

网络通讯三要素：

IP InetAddress

PORT

网络协议 UDP/TCP

网络参考模型：

OSI：七层

TCP/IP： 应用层 HTTP FTP

传输层 TCP UDP

网际层 IP 

主机至网络层


2.IP地址对象InetAddress

<span style="font-size:14px;">	//获取本地IP地址对象
	InetAddress address = InetAddress.getLocalHost();  
	//mlu-PC/172.16.22.55
	System.out.println(address);    
	//172.16.22.55
	System.out.println(address.getHostAddress());    
	//mlu-PC
	System.out.println(address.getHostName());    
	
	//根据域名或IP获取IP地址对象
	InetAddress address = InetAddress.getByName("172.16.22.55");
	InetAddress address = InetAddress.getByName("www.baidu.com");
	//180.97.33.108
	System.out.println(address.getHostAddress());
	//www.baidu.com
	System.out.println(address.getHostName());</span>

3.UDP TCP

UDP:

1）将数据及源和目的封装成数据包，不需要建立连接

2）每个数据包的大小限制在64k内

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

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

5）分为发送端和接收端 DatagramSocket

TCP：

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

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

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

4）必须建立连接，效率会稍低

5）分为客户端和服务端 Socket ServerSocket


4.Socket

1)Socket就是为网络服务提供的一种机制

2）通信的两端都有Socket

3）网络通信其实就是Socket间的通信

4）数据在两个Socket间通过IO传输


5.UDP传输

5.1 UDP发送

	/**
	 * 1.建立UDPSocket服务
	 * 2.提供数据，并将数据封装到数据包中
	 * 3.通过socket的发送功能，将数据包发送出去
	 * 4.关闭资源
	 */
	public class UdpSend {
		public static void main(String[] args) throws Exception {
			//1.创建UDP服务，通过DatagarmSocket对象
			DatagramSocket ds = new DatagramSocket();
			//2.提供数据，并将数据封装到数据包中
			byte[] data = "I am Comming".getBytes();
			DatagramPacket dp = new DatagramPacket(data, data.length, InetAddress.getByName("172.16.22.55"), 10000);
			//3.通过socket的发送功能，将数据包发送出去
			ds.send(dp);
			//4.关闭资源
			ds.close();
		}
	}

5.2 UDP接收 

	/**
	 * 1.建立UDPSocket服务,通常指定监听端口
	 * 2.定义数据包，存储接收到的数据信息
	 * 3.通过socket的接收功能，将数据存入数据包
	 * 4.取出数据
	 * 5.关闭资源
	 */
	public class UdpReceive {
		public static void main(String[] args) throws Exception {
			//1.建立UDPSocket服务
			DatagramSocket ds = new DatagramSocket(10000);
			
			//2.定义数据包，存储接收到的数据信息
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf, buf.length);
			
			//3.通过socket的接收功能，将数据存入数据包
			ds.receive(dp);
			
			//4.取出数据
			String ip = dp.getAddress().getHostAddress();
			int port = dp.getAddress().getPort();
			String data = new String(dp.getData(),0,dp.getLength());
			
			//5.关闭资源
			ds.close();			
		}
	}

5.3 UDP通过键盘输入 

	//接收端
	public class UdpReceive {
		public static void main(String[] args) throws Exception {
			//1.建立UDPSocket服务
			DatagramSocket ds = new DatagramSocket(10000);
			//服务器一直启动
			while(true){
				//2.定义数据包，存储接收到的数据信息
				byte[] buf = new byte[1024];
				DatagramPacket dp = new DatagramPacket(buf, buf.length);
				//3.通过socket的接收功能，将数据存入数据包
				ds.receive(dp);
				//4.取出数据
				String ip = dp.getAddress().getHostAddress();
				int port = dp.getPort();
				String data = new String(dp.getData(),0,dp.getLength());
				System.out.println("ip:"+ip + "; port:" +port +"; data:" +data);
			}
		}
	}
	
	//发送端，输入886结束
	public class UdpSend {
		public static void main(String[] args) throws Exception {
			//1.创建UDP服务，通过DatagarmSocket对象
			DatagramSocket ds = new DatagramSocket(10001);
			//2.从键盘输入数据
			BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			while((line = buffer.readLine()) != null){
				if("886".equals(line)){
					break;
				}
				byte[] data = line.getBytes();
				DatagramPacket dp = new DatagramPacket(data, data.length, InetAddress.getByName("172.16.22.55"), 10000);
				//3.通过socket的发送功能，将数据包发送出去
				ds.send(dp);
			}
			//4.关闭资源
			ds.close();
		}
	}

5.4 UDP聊天 

	public class UdpChat {
		public static void main(String[] args) throws Exception {
			DatagramSocket sendSocket = new DatagramSocket();
			DatagramSocket receSocket = new DatagramSocket(20000);
			
			new Thread(new send(sendSocket, "172.16.22.55", 20001)).start();
			new Thread(new receive(receSocket)).start();
		}
	}
	public class UdpChat2 {
		public static void main(String[] args) throws SocketException {
			DatagramSocket sendSocket = new DatagramSocket();
			DatagramSocket receSocket = new DatagramSocket(20001);
			
			new Thread(new send(sendSocket, "172.16.22.55", 20000)).start();
			new Thread(new receive(receSocket)).start();
		}
	}

	class send implements Runnable{
		private DatagramSocket ds;
		private String ip;
		private int port;
		public send(DatagramSocket ds, String ip, int port){
			this.ds = ds;
			this.ip = ip;
			this.port = port;
		}
		@Override
		public void run(){
			//从键盘接收数据
			BufferedReader buffer = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			try {
				while((line = buffer.readLine()) != null){
					if("886".equals(line)){
						break;
					}
					byte[] buf = line.getBytes();
					//组建包
					DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName(ip), port);
					ds.send(dp);
				}
			} catch (Exception ex) {
			}
		}
	}

	class receive implements Runnable{
		private DatagramSocket ds;
		public receive(DatagramSocket ds){
			this.ds = ds;
		}
		@Override
		public void run(){
			try {
				while(true){
					//创建包接收数据
					byte[] buf = new byte[1024];
					DatagramPacket dp = new DatagramPacket(buf, buf.length);
					ds.receive(dp);
					
					//取出数据
					String ip = dp.getAddress().getHostAddress();
					int port = dp.getPort();
					String data = new String(dp.getData(),0,dp.getLength());
					System.out.println(ip + ":" +data);
				}
			} catch (Exception ex) {
			}
		}
	}

6.1 TCP 传输 

/**
 *
 * 客户端：在建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道内进行数据的传输。
 */
public class Tcp_Client {
    public static void main(String[] args) throws Exception {
        System.out.println("client");
        Socket s = new Socket("172.16.22.55",10010);
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        BufferedReader buffIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        BufferedWriter buffOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        
        //向服务端发送消息
        String line = null;
        while((line = reader.readLine()) != null){
            if("over".equals(line)){
                break;
            }
            buffOut.write(line);
            buffOut.newLine();
            buffOut.flush();
            System.out.println("to server ");

            //读取服务端返回的消息
            String returnStr = null;
            while((returnStr = buffIn.readLine())!=null){
                System.out.println("from server: " + returnStr);
            }
        }
        reader.close();
        s.close();
    }
}
/**
 *
 * 服务端，监听一个端口
 */
public class Tcp_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("server");
        ServerSocket ss = new ServerSocket(10010);
        Socket s = ss.accept();
        //获取客户端的ip地址
        String address = s.getInetAddress().getHostAddress();
        
        //socket输入流
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        
        //socket输出流
        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        
        String sIn = null;
        while((sIn = bufIn.readLine()) != null){
            System.out.println(address + " : " + sIn);
            
            //将字符串改为大写后返回
            bufOut.write(sIn.toUpperCase());
            bufOut.newLine();
            bufOut.flush();
            
            System.out.println("flush over");
        }
        s.close();
        ss.close();
    }
}


6.2 TCP上传文件 
public class TcpFileUpload_Client {
    public static void main(String[] args) throws Exception {
        System.out.println("client");
        Socket s = new Socket("172.16.22.55",10020);
        
        //读取上传的文件
        BufferedReader reader = new BufferedReader(new FileReader("d:\\aa.txt"));
        
        //向服务端传输文件 PrintWriter true代表自动flush
        PrintWriter buffOut = new PrintWriter(s.getOutputStream(), true);
        
        //接收服务端的回复
        BufferedReader buffIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        
        //向服务端发送消息
        String line = null;
        while((line = reader.readLine()) != null){
            buffOut.println(line);
            System.out.println("to server ");
        }

        //读取服务端返回的消息
        String returnStr =  buffIn.readLine();
        System.out.println(returnStr);
        
        reader.close();
        s.close();
    }
}

public class TcpFileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("server");
        ServerSocket ss = new ServerSocket(10020);
        Socket s = ss.accept();
        //获取客户端的ip地址
        String address = s.getInetAddress().getHostAddress();
        System.out.println(address + " connect");
            
        //socket输入流
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
        
        //socket输出流
        PrintWriter bufOut = new PrintWriter(new FileWriter("d:\\newText.txt"), true);
        
        //读取输入流信息
        String sIn = null;
        while((sIn = bufIn.readLine()) != null){
            if("over".equals(sIn)){
                System.out.println("flush over");
                break;
            }
            bufOut.println(sIn);
        }
        
        //返回信息给客户端
        PrintWriter bufWriter = new PrintWriter(s.getOutputStream(), true);
        bufWriter.println("success");
        
        bufOut.close();
        s.close();
        ss.close();
    }
}

6.3 TCP上传图片 

public class TcpPicUpload_Client {
    public static void main(String[] args) throws Exception {
        System.out.println("client");
        Socket s = new Socket("172.16.22.55",10030);
        
        //读取上传的文件
        FileInputStream fis = new FileInputStream("d:\\aa.jpg");
        
        //向服务端传输文件
        OutputStream buffOut = s.getOutputStream();
        
        //向服务端发送消息
        byte[] buf = new byte[1024];
        int len = 0;
        while((len = fis.read(buf)) != -1){
            buffOut.write(buf,0,len);
        }
        //告诉服务器已经读完
        s.shutdownOutput();
        
        //接收服务端的回复
        InputStream sr = s.getInputStream();
        //读取服务端返回的消息
        byte[] bufIn = new byte[1024];
        int num = sr.read(bufIn);
        System.out.println(new String(bufIn,0,num));
        
        fis.close();
        s.close();
    }
}

public class TcpPicUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("server");
        ServerSocket ss = new ServerSocket(10030);
        Socket s = ss.accept();
        //获取客户端的ip地址
        String address = s.getInetAddress().getHostAddress();
        System.out.println(address + " connect");
            
        //socket输入流
        InputStream buffIn = s.getInputStream();
        
        FileOutputStream fos = new FileOutputStream("d:\\newPic.jpg"); 
        
        //socket输出流
        OutputStream buffOut = s.getOutputStream();
        
        //读取输入流信息
        byte[] buff = new byte[1024];
        int len = 0;
        while((len = buffIn.read(buff)) != -1){
            fos.write(buff,0,len);
        }
        
        //返回信息给客户端
        buffOut.write("success".getBytes());
        
        fos.close();
        s.close();
        ss.close();
    }
}

6.4 TCP并发上传图片 

public class TcpPicUpload_Server_multi {
    public static void main(String[] args) throws IOException {
        System.out.println("server");
        ServerSocket ss = new ServerSocket(10040);
        while(true){
            Socket s = ss.accept();
            new Thread(new UploadPicThread(s)).start();
        }
    }
}
class UploadPicThread implements Runnable{
    private Socket s;

    public UploadPicThread(Socket s) {
        this.s = s;
    }
    
    @Override
    public void run() {
        //获取客户端的ip地址
        String address = s.getInetAddress().getHostAddress();
        System.out.println(address + " connect");
        FileOutputStream fos = null; 
        //socket输入流
        InputStream buffIn;
        
        //socket输出流
        OutputStream buffOut = null;
        try {
            buffIn = s.getInputStream();
            long l = System.currentTimeMillis();
            
            fos = new FileOutputStream("d:\\"+ String.valueOf(l) + ".jpg"); 
            buffOut = s.getOutputStream();
        
            //读取输入流信息
            byte[] buff = new byte[1024];
            int len = 0;
            while((len = buffIn.read(buff)) != -1){
                fos.write(buff,0,len);
            }

            //返回信息给客户端
            buffOut.write("success".getBytes());

            fos.close();
            s.close();
        } catch (IOException ex) {
        }
    }
}

6.5 URL && URLConnection 

	public static void main(String[] args) throws MalformedURLException, IOException {
        URL url = new URL("http://localhost:8080/HelloNet/index.jsp?name=haha");
        //获取此url的协议名称 http
        System.out.println("url.getProtocol() : " + url.getProtocol());
        //获取此url的主机名 localhost
        System.out.println("url.getHost() : " + url.getHost());
        //获取此url的端口号 8080
        System.out.println("url.getPort() : " + url.getPort());
        //获取此url的路径部分 /HelloNet/index.jsp
        System.out.println("url.getPath() : " + url.getPath());
        //获取此url的文件名 /HelloNet/index.jsp?name=haha
        System.out.println("url.getFile() : " + url.getFile());
        //获取此url的查询部分 name=haha
        System.out.println("url.getQuery() : " + url.getQuery());
        
        //通过URLConnection向服务器发送请求
        URLConnection urlConn = url.openConnection();
        
        //获取服务器返回的文件内容
        InputStream in = urlConn.getInputStream();
        byte[] buf = new byte[1024];
        int len = -1;
        if((len = in.read(buf)) != -1){
            System.out.println(new String(buf, 0, len));
        }
    }







icanhaha
关注
专栏目录
Tcp编程
m0_66947503的博客
07-17 499
写入网络时，必须调用flush（）方法，如果不调用，客户端和服务器都收不到数据，因为我们是以流的方式写入数据的，并不是一写就发送到网络了。而是先写入内存缓冲区，直到缓冲区满了，才一次发送到网络，这样提高了传输效率，如果缓冲区的数据很少。使用Socket进行网络编程时，本质上就是两个进程之间的网络通信，其中一个充当服务器端，它会主动监听某个指定端口，另一个进程必须充当客户端，它必须主动连接服务器的IP地址和指定端口，如果连接成功，服务器端和客户端就成功建立了一个TCP连接，双方后续就可以随时发送和接收数据。.
Java输入输出流-----字节流（1）
xiaobao19837的专栏
05-22 839
从键盘输入字符。本例用System.in.read(buffer)从键盘输入一行字符，存储在缓冲区buffer中，count保存实际读入的字节个数，再以整数和字符两种方式输出buffer中的值。Read方法在java.io包中，而且要抛出IOException异常。程序如下：import java.io.*;public class ArrayTest { public static void m
java IO流学习总结
热门推荐
coder150806的博客
09-09 5万+
学习了几天的java IO流，下面我来谈谈对java 输入输出流IO的个人见解吧！ 转载自：https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念： 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。它的特性是进行数据传输； 例如从水源地长江把水导入自来水厂，然后又从自...
那些年学过的java网络编程（上）
林子易
09-06 216
1.1 概述 计算机网络：（computer network），简称网络，是利用通信设备和线路将地理位置不同的、功能独立的多个计算机系统连接起来，以功能完善的网络软件实现网络的硬件、软件及资源共享和信息传递的系统，简单的说即连接两台或多台计算机进行通信的系统。 网络编程的目的： 无限电台…传播交流信息，数据交换。通信 想要达到这个效果需要： 1.如何准确的定位网络上的一台主机： （例如）192.168.17.104：（端口）5000，定位到这个计算机上的某个资源 2.找到这个主机，如何传输数据呢
字节流和字符流读取文件 使用read()方法 注意清空自定义char数组或byte数组
qq_37238098的博客
05-09 1385
。。。byte[] buff = new byte[1024]; while(in.read(buff) > 0) {。。。 或 。。。char[] c = new char[100]; while(r.read(c) > 0) {。。。 read(buff)方法仅仅对 buff数组进行赋值，当最后一次读取，剩余的数据和数组长度不一致...
Java基础之网络编程
12-22
Java基础之网络编程一、网络通信协议1.TCP/IP网络模型2.IP地址和端口号3.类InetAddress(存在于Java.net包中)二、UDP与TCP协议1.UDP协议2.TCP协议三、UDP通信1.DatagramPacket（数据报包）（数据封装）2....
java网络编程
03-03
Java网络编程是Java开发中的重要领域，它涵盖了网络通信的所有基本概念和技术...通过阅读《Java网络编程》第三版，开发者可以系统地学习这些知识点，并通过实例加深理解，为构建高效、安全的网络应用程序打下坚实基础。
Java网络通信基础编程(必看篇)
08-30
* 灵活的网络编程：Java 网络通信基础编程提供了灵活的网络编程方式，开发者可以根据实际情况选择不同的网络编程方式。 * 广泛的应用场景：Java 网络通信基础编程可以应用于各种网络应用场景，包括 Web 服务器、...
Java网络编程期末考试复习题库+答案
07-06
1. **Java I/O**: Java I/O系统是Java网络编程的基础，包括InputStream、OutputStream、Reader、Writer等基本流，以及FileInputStream、FileOutputStream等文件流。此外，还有BufferedInputStream、BufferedReader等...
Java基础篇：网络编程.pdf
05-19
首先，Java网络编程的基础是通信要素，这包括IP地址和端口号。IP地址是网络上每台计算机的唯一标识，类似于现实生活中的地址。在Java中，可以通过InetAddress类来操作IP地址。IP地址分为IPv4和IPv6两种类型，分别...
慕课网IO流教程4-2笔记
weixin_43547050的博客
08-25 100
视频里老师演示了in.read(byte[] by,int start,by.length)方法的两种形式。 1、在第一种方法里， int bytes=in.read(buf,0,buf.length);
一个buf.一个read_buf
mrwangwang的专栏
11-13 1500
数据最终会通过tty-> receive_buf()将数据放入read_buf. 在这段代码中，有几个很有意思的处理。在进入工作队列的时候，首先会置TTY_FLUSHING标志.如果有进程在读read_buf的时候，如果此标志被置位，就会设置TTY_FLUSHPENDING标志，并进行睡眠。在数据处理完成之后，判断是否有TTY_FLUSHPENDING标志。如果有，则将读进程唤醒.并清除TTY_
java in read_为什么我的方法在System.in.read()循环后被调用3次 - java
weixin_34697798的博客
03-06 256
我已经开始学习Java，写了一些非常简单的东西，但是有一点我不理解：public static void main(String[] args) throws java.io.IOException{char ch;do{System.out.println("Quess the letter");ch = (char) System.in.read();}while (ch != 'q');}为...
(len = is.read(buffer)) != -1.md
奋斗的IT小民工的博客
09-29 1万+
(len = is.read(buffer)) != -1的原理详解 InputStream.read(buffer) 方法 在java中api文档有read()这几种方法 方法摘要 方法 作用 abstract int read() 从输入流中读取数据的下一个字节 int read(byte[]&amp;nbsp;b) 将输入流中读取一定数量 并将其存储在缓冲区数组 b 中。 ...
System.in.read()的用法
studyvcmfc的专栏
10-30 4万+
System.in.read()的用法   2007-10-25 22:00:24|  分类： 默认分类 |  标签： |字号大中小 订阅  用读取键盘输入必须构建       1。输入流   System.in;       2。字符输入流   InputStreamReader       3。缓存输入流   BufferedReader
java从控制台输入数值之System.in.read()
笑笑咯
04-11 1352
public class xin {   public static void main(String[] args) { int read = '0'; System.out.println("涂涂喊你输入数据："); try{ read = System.in.read(); }catch(Exception e){ e.printStackTrace(); System
Java网络编程基础入门教程
1. **套接字（Socket）编程**：这是Java网络编程的基础，它提供了两台机器间进程通信的能力。Socket类代表了网络上的一个连接点，ServerSocket则用于监听客户端的连接请求。 2. **URL和URLConnection**：Java通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值