Java笔记-12 网络编程

InetAddress

• 创建InetAddress对象，从本地，ip，或者域名创建

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

public class TestIP {
    public static void main(String[] args) throws UnknownHostException {
        //创建InetAddress对象
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress());//192.168.243.1
        System.out.println(addr.getHostName());//计算机名

        //根据域名得到对象
        addr = InetAddress.getByName("www.baidu.com");
        System.out.println(addr.getHostAddress()); //ip地址
        System.out.println(addr.getHostName()); //域名

        //根据ip
        addr = InetAddress.getByName("39.156.66.14");        System.out.println(addr.getHostAddress()); //ip地址
        System.out.println(addr.getHostAddress()); //ip地址
        //如果ip不存在或不允许解析，则返回ip地址
        System.out.println(addr.getHostName()); //域名

    }
}

端口

• 两个字节，0-65535，区分一个电脑的不同网络应用程序
• 公认端口0-1023，注册端口1024-49151，私有端口49152-65535
• 8080，Tomcat的端口，1521，Oracle,3306,mysql
• windows下查看端口，netstat -ano命令。
• 过滤端口 netstat -ano | findstr “808”
• 查找应用程序 tasklist | findstr “808”

InetSocketAddress

• new InetSocketAddress(地址|域名,端口);

import java.net.InetSocketAddress;

public class TestSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress address1 = new InetSocketAddress("www.baidu.com",8080);
        System.out.println(address.getHostName()); //127.0.0.1
        System.out.println(address.getAddress());  //127.0.0.1/127.0.0.1
        System.out.println(address.getPort()); ///端口
    }
}

URL

• URI 统一资源标识符
• URL 统一资源定位符
• URN 统一资源名称
• http默认端口是80

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

public class TestURL {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=2&tn=baiduhome_pg&wd=java&rsv_spt=1&oq=%2526lt%253B9.156.66.14&rsv_pq=98b4ebc900033cdd&rsv_t=b50aYzbLYicGgZtJnHCgENvOQx0v6JlZvtmGJ7GOiPllohOtrF0K0Us6S%2BEA6nMWh9xF&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_sug3=6&rsv_sug2=0&prefixsug=java&rsp=3&inputT=1104&rsv_sug4=10013020");
        //获取四个值，协议，域名，端口，请求资源
        System.out.println("协议："+url.getProtocol());
        System.out.println("域名："+url.getHost());
        System.out.println("端口："+url.getPort());
        System.out.println("请求资源："+url.getFile());
        System.out.println("请求资源1："+url.getPath());
        System.out.println("参数："+url.getQuery());
        System.out.println("锚点："+url.getRef());
    }
}

获取网页代码 爬虫

• 获取网页代码，使用HttpURLConnection模拟浏览器登录。谷歌浏览器打开网页，F12,查看请求信息
• 获取信息后还要经过进一步的处理
  

package MyPro12;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class TestSpider {
    public static void main(String[] args) throws Exception {
        //模拟浏览器
        URL url = new URL("https://www.dianping.com");
        //下载资源
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET"); //从浏览器的F12查看原网页获取
        conn.setRequestProperty("User-Agent","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36");
        //InputStream is = url.openStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
        String msg = null;
        while ((msg = br.readLine())!=null){
            System.out.println(msg);
        }
        br.close();

    }
    public void test()throws Exception{
        //直接抓取，可能失败，需要模拟浏览器
        URL url = new URL("https://www.jd.com");
        //下载资源
        InputStream is = url.openStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
        String msg = null;
        while ((msg = br.readLine())!=null){
            System.out.println(msg);
        }
        br.close();
    }
}

传输协议 UDP TCP

• TCP 面向连接，比较可靠的字节流通信，占用资源多，效率低
• UDP 非面向连接不可靠，收到也不确认，非常简单，开销小
• 套接字 socket，socket连接传输层和应用层
• socket编程

UDP

• DatagramSocket，用于接收或发送的套接字
• DatagramPacket数据包
• 仅基于该数据包中包含的信息，每个消息从一台机器路由到另一台机器。 从一台机器发送到另一台机器的多个分组可能会有不同的路由，并且可能以任何顺序到达。
• udp示例，先开启接受端，再开启发送。接收端的端口，与发送端的InetSocketAddress端口一致。
• 发送端，发送数据，字节数组

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/**
 * 发送端
 * UdpClient.java
 */
public class UdpClient {
    public static void main(String[] args) throws Exception {
        System.out.println("发送方启动....");
        //1 使用DatagramSocket创建发送端
        DatagramSocket client = new DatagramSocket(9998);
        //2 准备数据，字节数组
        String data = "武汉加油";
        byte[] datas = data.getBytes();
        //3 封装成包裹指定目的地
        DatagramPacket  packet = new DatagramPacket(datas,0,datas.length,
                new InetSocketAddress("localhost",9999));
        //4 发送包裹
        client.send(packet);
        System.out.println("发送完毕");
        //5 释放资源
        client.close();
    }
}

• 接收端，接受字节数组并还原回去数据

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

/**
 * 接收端
 * 使用DatagramSocket创建
 * 准备容器
 * 接收包裹
 * 分析
 */
public class UdpServer {
    public static void main(String[] args) throws Exception {
        System.out.println("接收端....");
        //1 创建接收端，端口不能重复
        DatagramSocket server = new DatagramSocket(9999);
        //2 准备容器接收
        byte[] container = new byte[1024*60];
        DatagramPacket packet= new DatagramPacket(container,0,container.length);
        //3 阻塞式接收包裹
        server.receive(packet);
        //4 分析数据
        byte[] data = packet.getData();
        int len = packet.getLength();
        System.out.println("收到数据：\n" +  new String(data,0,len));
        //5 释放资源
        server.close();
    }
}

• 利用多线程实现双向发送

聊天室示例

• 某个客户端发送消息，其他所有人都能收到，或者给指定人发送消息
• Chat.java 服务端。核心部分

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 在线聊天室: 服务器
 * 目标: 私聊

 * @author 裴新 QQ:3401997271
 *
 */
public class Chat {
	private static CopyOnWriteArrayList<Channel> all =new CopyOnWriteArrayList<Channel>();
	public static void main(String[] args) throws IOException {
		System.out.println("-----Server-----");
		// 1、指定端口 使用ServerSocket创建服务器
		ServerSocket server =new ServerSocket(8888);
		// 2、阻塞式等待连接 accept
		while(true) {
				Socket  client =server.accept(); 
				System.out.println("一个客户端建立了连接");
				Channel c =new Channel(client);
				all.add(c); //管理所有的成员
				new Thread(c).start();			
			}		
		}
		//一个客户代表一个Channel
		static class Channel implements Runnable{
			private DataInputStream dis;
			private DataOutputStream dos;
			private Socket  client;			
			private boolean isRunning;
			private String name;
			public Channel(Socket  client) {
				this.client = client;
				try {
					dis = new DataInputStream(client.getInputStream());
					dos =new DataOutputStream(client.getOutputStream());
					isRunning =true;
					//获取名称
					this.name =receive();
					//欢迎你的到来
					this.send("欢迎你的到来");
					sendOthers(this.name+"来了shsxt聊天室",true);
				} catch (IOException e) {
					System.out.println("---1------");
					release();					
				}			
			}
			//接收消息
			private String receive() {
				String msg ="";
				try {
					msg =dis.readUTF();
				} catch (IOException e) {
					System.out.println("---2------");
					release();
				}
				return msg;
			}
			//发送消息
			private void send(String msg) {
				try {
					dos.writeUTF(msg);
					dos.flush();
				} catch (IOException e) {
					System.out.println("---3------");
					release();
				}
			}
			/**
			 * 群聊：获取自己的消息，发给其他人
			 * 私聊: 约定数据格式: @xxx:msg
			 * @param msg
			 */
			private void sendOthers(String msg,boolean isSys) {
				boolean isPrivate = msg.startsWith("@");
				if(isPrivate) { //私聊
					int idx =msg.indexOf(":");
					//获取目标和数据
					String targetName = msg.substring(1,idx);
					msg = msg.substring(idx+1);
					for(Channel other: all) {
						if(other.name.equals(targetName)) {//目标
							other.send(this.name +"悄悄地对您说:"+msg);
							break;
						}
					}
				}else {				
					for(Channel other: all) {
						if(other==this) { //自己
							continue;
						}
						if(!isSys) {
							other.send(this.name +"对所有人说:"+msg);//群聊消息
						}else {
							other.send(msg); //系统消息
						}
					}
				}
			}
			//释放资源
			private void release() {
				this.isRunning = false;
				SxtUtils.close(dis,dos,client);
				//退出
				all.remove(this);
				sendOthers(this.name+"离开大家庭...",true);
			}
			@Override
			public void run() {
				while(isRunning) {
					String msg = receive() ;
					if(!msg.equals("")) {
						//send(msg);
						sendOthers(msg,false);
					}
				}
			}
		}
}

• Client.java 客户端，开启多个模拟多个用户。idea需要在Edit Configuration中勾选Allow parallel run

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 在线聊天室: 客户端
 * 目标: 私聊
 * @author 裴新 QQ:3401997271
 *
 */
public class Client {
	public static void main(String[] args) throws UnknownHostException, IOException {
		System.out.println("-----Client-----");
		BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输入用户名:");
		String name =br.readLine();
		//1、建立连接: 使用Socket创建客户端 +服务的地址和端口
		Socket client =new Socket("localhost",8888);
		//2、客户端发送消息
		new Thread(new Send(client,name)).start();  
		new Thread(new Receive(client)).start();
	}
}

• Send.java 发送消息

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

/**
 * 使用多线程封装:发送端
 * 1、发送消息
 * 2、从控制台获取消息
 * 3、释放资源
 * 4、重写run
 * @author 裴新 QQ:3401997271
 *
 */
public class Send implements Runnable {
	private BufferedReader console ;
	private DataOutputStream dos;
	private Socket client;
	private boolean isRunning;
	private String name;
	public Send(Socket client,String name) {
		this.client =client;
		console =new BufferedReader(new InputStreamReader(System.in));
		this.isRunning = true;
		this.name = name;
		try {
			dos =new DataOutputStream(client.getOutputStream());
			//发送名称
			send(name);
		} catch (IOException e) {
			System.out.println("==1==");
			this.release();
		}	
	}
	@Override
	public void run() {
		while(isRunning) {
			String msg = getStrFromConsole();
			if(!msg.equals("")) {
				send(msg);
			}
		}
	}	
	//发送消息
	private void send(String msg) {
		try {
			dos.writeUTF(msg);
			dos.flush();
		} catch (IOException e) {
			System.out.println(e);
			System.out.println("===3==");
			release();
		}
	}
	/**
	 * 从控制台获取消息
	 * @return
	 */
	private String getStrFromConsole() {
		try {
			return  console.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return "";
	}
	//释放资源
	private void release() {
		this.isRunning = false;
		SxtUtils.close(dos,client);
	}

}

• Receive.java 接收消息

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;

/**
 * 使用多线程封装:接收端
*  1、接收消息
 * 2、释放资源
 * 3、重写run
 * @author 裴新 QQ:3401997271
 *
 */
public class Receive implements Runnable {
	private DataInputStream dis ;
	private Socket client;
	private boolean isRunning;
	public Receive(Socket client) {
		this.client = client;
		this.isRunning = true;
		try {
			dis =new DataInputStream(client.getInputStream());
		} catch (IOException e) {
			System.out.println("====2=====");
			release();
		}
	}
	//接收消息
	private String receive() {
		String msg ="";
		try {
			msg =dis.readUTF();
		} catch (IOException e) {
			System.out.println("====4====");
			release();
		}
		return msg;
	}
	
	@Override
	public void run() {		
		while(isRunning) {
			String msg =receive();
			if(!msg.equals("")) {
				System.out.println(msg);
			}
		}
	}
	//释放资源
	private void release() {
		this.isRunning = false;
		SxtUtils.close(dis,client);
	}

}

• SxtUtils.java 工具类

import java.io.Closeable;

/**
 * 工具类
 * 
 * @author 裴新 QQ:3401997271
 *
 */
public class SxtUtils {
	/**
	 * 释放资源
	 */
	public static void close(Closeable... targets ) {
		for(Closeable target:targets) {
			try {
				if(null!=target) {
					target.close();
				}
			}catch(Exception e) {
				
			}
		}
	}
}