JAVA之网络编程

网络编程的实质

就是两个(或多个)设备(例如计算机)之间的数据传输。
一、网络:将不同区域的计算机连接到一起 局域网 城域网 互联网
**二、地址:**IP地址 确定网络上 一个绝对地址 |位置 —>房子的地址
三、端口号: 区分计算机软件的 –>房子的房门 2个字节 0-65535 共65536个
1、在同一个协议下 端口号不能重复 不同协议下可以重复
2、1024以下的不要使用 80–>http 21 –>ftp
四、资源定位: URL 统一资源定位符 URI :统一资源
五、数据的传输
1、协议: Tcp 和UDP协议
1)、TCP(transfer control protocol): 电话 类似于三次握手 面向连接 安全可靠 效率低下
2)、UDP(UserDatagramProtocol ): 短信 非面向连接 效率高
2、传输:
1)、先封装
2)、后拆封

网络编程相关类

1、InetAddress InetSocketAddress
2、URL
3、TCP: ServerSocket Socket
4、UDP: DatagramSocket DatagramPacket

InetAddress

封装计算机的IP地址和DNS。无端口。

方法:
getHostAddress()：返回IP地址
getHostName():返回域名/本机为计算机名
InetAddress.getLocalHost()：返回本机IP，如果IP不存在则返回自身
InetAddress.getByName(“IP地址/域名”)：根据IP地址/域名得到InetAddress对象。

    public static void main(String[] args) throws UnknownHostException{     
        //使用getLocalHost方法创建InetAddress对象
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress());  //返回：192.168.1.100
        System.out.println(addr.getHostName());  //输出计算机名
        //根据域名得到InetAddress对象
        addr = InetAddress.getByName("www.163.com"); 
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出：www.163.com   
        //根据ip得到InetAddress对象
        addr = InetAddress.getByName("61.135.253.15"); 
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射，getHostName方法就直接返回这个IP地址。       

    }

InetSocketAddress

在InetAddress基础上+封装端口。
（1）创建对象
InetSocketAddress(String hostName,int port);
InetSocketAddress(InetAddress addr,int port);
（2）方法
getAddress()：返回一个InetAddress对象
getHostName()：返回地址
getPort()：返回端口

public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress  address = new InetSocketAddress("127.0.0.1",8888);
        address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"),8888);
        System.out.println(address.getHostName());
        System.out.println(address.getPort());
        InetAddress addr =address.getAddress();
        System.out.println(addr.getHostAddress()); 
        System.out.println(addr.getHostName());  
    }

URL

URL：统一资源定位符
URI：统一资源标识符

四部分组成：协议 存放协议的主机域名 端口 资源文件名

1.创建
URL（String spec）:绝对路径创建
URL（URL url,String a）:相对路径创建
2.方法
getProtocol():获取协议
getHost():获取域名
getPort():获取端口
getFile():获取资源
getPath():获取相对路径
getRef():获取锚点（也称为引用）
getQuery():获取参数 在URL路径的?后面
getFile():获取URL文件名部分
getAuthority()：获取此URL的授权部分
getDefaultPort()：获取协议的默认端口号

import java.net.*;
import java.io.*;

public class TestURL
{
   public static void main(String [] args)
   {     
    URL url;
    try {
        url = new URL("http://www.baidu.com:80/index.html?uname=vvvvvv#123");
        System.out.println("协议:"+url.getProtocol());
        System.out.println("授权部分:"+url.getAuthority());
        System.out.println("域名:"+url.getHost());
        System.out.println("默认端口:"+url.getDefaultPort());
        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());
    } catch (MalformedURLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
   }
}

//结果

协议:http
授权部分:www.baidu.com:80
域名:www.baidu.com
默认端口:80
端口:80
主机:www.baidu.com
资源:/index.html?uname=vvvvvv
相对路径:/index.html
锚点:123
参数:uname=vvvvvv

3.流
InputStream openStream():获取资源网络流

//网络爬虫原理

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;

public class TestURLDemo {

    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com"); // 主页 默认资源

        // 获取资源 网络流
/*
        InputStream is = url.openStream();
        byte[] flush = new byte[1024];
        int len = 0;
        while (-1 != (len = is.read(flush))) {
            System.out.println(new String(flush, 0, len));
        }
        is.close();
*/
        BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu2.html"), "utf-8"));

        String msg = null;
        while ((msg = br.readLine()) != null) {
            // System.out.println(msg);
            bw.append(msg);
            bw.newLine();
        }
        bw.flush();

        bw.close();
        br.close();

    }

}

UDP

1.类 DatagramSocket DatagramPacket
①客户端
（1）创建客户端 DatagramSocket类+指定端口
（2）准备数据 字节数组
（3）打包 DatagramPacket + 服务器地址及端口
（4）发送
（5）释放资源
②服务器端
（1）创建服务器端 DatagramSocket类+指定端口
（2）准备接收容器 字符数组封装DatagramPacket类
（3）包 接受数据
（4）分析
（5）释放资源

PS：服务器需要先创建，否则会引发客户端找不到服务器的问题

//服务器端
public class MyServer {

    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket(8888);
        //2、准备接受容器
        byte[] container = new byte[1024];
        //3、封装成 包 DatagramPacket(byte[] buf, int length)        
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据
        server.receive(packet);
        //5、分析数据
        byte[] data =packet.getData();
        int len =packet.getLength();
        System.out.println(new String(data,0,len));
        //6、释放
        server.close();

    }

//客户端
public class MyClient {

    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket(6666);
        //2、准备数据
        String msg ="udp编程";
        byte[] data =msg.getBytes();
        //3、打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();

    }

//传递除了字符数组以外的东西，需要结合IO流

public class Server {

    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket(8888);
        //2、准备接受容器
        byte[] container = new byte[1024];
        //3、封装成 包 DatagramPacket(byte[] buf, int length)        
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据
        server.receive(packet);
        //5、分析数据
        double data =convert(packet.getData());
        System.out.println(data);
        //6、释放
        server.close();

    }
    /**
     * 字节数组 +Data 输入流
     * @param data
     * @return
     * @throws IOException 
     */
    public static double convert(byte[] data) throws IOException{
        DataInputStream dis =new DataInputStream(new ByteArrayInputStream(data));
        double num =dis.readDouble();
        dis.close();
        return num;
    }
}

public class Client {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket(6666);
        //2、准备数据
        double num =89.12;
        byte[] data =convert(num);
        //3、打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();

    }

    /**
     * 字节数组 数据源  +Data 输出流
     * @param num
     * @return
     * @throws IOException 
     */
    public static byte[] convert(double num) throws IOException{
        byte[] data =null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos =new DataOutputStream(bos);
        dos.writeDouble(num);
        dos.flush();

        //获取数据
        data = bos.toByteArray();
        dos.close();        
        return data;

    }
}

TCP

面向连接。
1.Socket编程
①服务器端 ServerSocket
（1）创建服务器端 指定端口 ServerSocket(int port)
（2）接受客户端连接 阻塞式Socketaccept()
（3）发送数据 + 接收数据

②客户端
（1）创建客户端 Socket(String host,int port);必须指定服务器+端口，此时就在进行连接
（2）接收数据 + 发送数据
BufferedReader br = new BufferedReader(
new InputStreamReader(
client.getInputStream()));

public class Server {

    public static void main(String[] args) throws IOException {
        //1、创建服务器  指定端口   ServerSocket(int port) 
        ServerSocket server = new ServerSocket(8888);
        //2、接收客户端连接   阻塞式
        Socket socket =server.accept();
        System.out.println("一个客户端建立连接");
        //3、发送数据
        String msg ="欢迎使用";
        //输出流
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(msg);
        dos.flush();

    }

}

public class Client {

    public static void main(String[] args) throws UnknownHostException, IOException {
        //1、创建客户端   必须指定服务器+端口    此时就在连接
        Socket client = new Socket("localhost",8888);
        //2、接收数据
        DataInputStream dis = new DataInputStream(client.getInputStream());
        String echo = dis.readUTF();
        System.out.println(echo);
    }

}

简易聊天室 存在bug
实现群聊私聊功能。

//client
package com.vvvvvv.chatdemo03;

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

/**
 * 创建客户端：发送数据+接受数据
 * 写出数据：输出流
 * 读取数据：输入流
 * @author Administrator
 *
 */
public class Client  {
    public static void main(String[] args) throws UnknownHostException, IOException {
        Socket client = new Socket("localhost",8888);
        System.out.println("请输入姓名：");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String name = br.readLine();
        if(name.equals(""))
            return;
        //启动线程
        new Thread(new Send(client,name)).start();
        new Thread(new Receive(client)).start();
    }
}

//server
package com.vvvvvv.chatdemo03;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import com.vvvvvv.chatdemo02.CloseUtil;

/**
 * 创建服务器
 * 
 * @author Administrator
 *
 */
public class Server {

    private List<MyChannel> all = new ArrayList<MyChannel>();

    public static void main(String[] args) throws IOException {
        new Server().start();//一个线程代表一个客户端
    }

    //启动线程
    public void start() throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while (true) {
            Socket client = server.accept();
            MyChannel channel = new MyChannel(client);
            all.add(channel);
            new Thread(channel).start();
        }
    }

    class MyChannel implements Runnable {
        private DataInputStream dis;
        private DataOutputStream dos;
        private boolean isRunning = true;
        private String name;

        public MyChannel() {

        }

        public MyChannel(Socket client) {
            try {
                dis = new DataInputStream(client.getInputStream());
                dos = new DataOutputStream(client.getOutputStream());
                this.name = dis.readUTF();
                this.send("欢迎加入聊天室");
                sendOthers(this.name + "进入了聊天室", true);

            } catch (IOException e) {
                // e.printStackTrace();
                isRunning = false;
                CloseUtil.closeAll(dis, dos);
            }
        }
        //发送数据给其他人
        //并且做判断是系统信息还是非系统信息 是私聊还是群聊
        //私聊格式：@name:context

        public void sendOthers(String msg, boolean flag) {
            if (msg.startsWith("@") && msg.indexOf(":") > -1) {
                String name = msg.substring(1, msg.indexOf(":"));
                String context = msg.substring(msg.indexOf(":") + 1);
                for(MyChannel temp:all) {
                    if(temp.name.equals(name)) {
                        temp.send(this.name+"悄悄地对你说:"+context);
                    }
                }

            } else {
                for (MyChannel temp : all) {
                    if (temp == this) {
                        continue;
                    }
                    if(flag)
                        temp.send("系统消息："+ msg);
                    else
                        temp.send(this.name + "对所有人说：" +msg);
                }
            }
        }
        //将msg发送出去 谁调用就发送给谁
        public void send(String msg) {
            if (null != msg && !msg.equals("")) {
                try {
                    dos.writeUTF(msg);
                    dos.flush();
                } catch (IOException e) {
                    // e.printStackTrace();
                    isRunning = false;
                    CloseUtil.closeAll(dos);
                    all.remove(this);
                }
            }
        }
        //接收数据
        public String receive() {
            String msg = "";
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                isRunning = false;
                CloseUtil.closeAll(dis);
                all.remove(this);
            }
            return msg;
        }

        @Override
        public void run() {
            //线程体
            while (isRunning) {
                sendOthers(this.receive(),false);
            }

        }
    }
}

//客户端发送数据线程
package com.vvvvvv.chatdemo03;

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

/**
 * 发送数据线程
 * @author Administrator
 *
 */
public class Send implements Runnable {

    //控制台输入流
    private BufferedReader console;
    //输出流
    private DataOutputStream dos;
    //线程标识
    private boolean isRunning = true;
    //当前线程
    private String name;

    public Send() {
        console = new BufferedReader(new InputStreamReader(System.in));
    }
    public Send(Socket client,String name) {
        this();
        try {
            dos = new DataOutputStream(client.getOutputStream());
            this.name = name;
            send(this.name);
        } catch (IOException e) {
            isRunning = false;
            CloseUtil.closeAll(dos,console);
        }
    }
    private String getMsgFromConsole() {
        try {
            return console.readLine();
        } catch (IOException e) {
        }
        return "";
    }
    /**
     * 从控制台接收数据
     * 发送数据
     */
    public void send (String msg) {
        if(null != msg &&  !msg.equals("")) {
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                isRunning = false;
                CloseUtil.closeAll(dos,console);
            }
        }
    }
    public void run() {
        while(isRunning) 
            send(getMsgFromConsole());
    }

}

//客户端接收数据线程
package com.vvvvvv.chatdemo03;

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

/**
 * 接收数据线程
 * @author Administrator
 *
 */
public class Receive implements Runnable {

    private DataInputStream dis;
    private boolean isRunning = true;
    public Receive() {

    }

    public Receive(Socket client) {
        try {
            dis = new DataInputStream(client.getInputStream());
        } catch (IOException e) {
            isRunning = false;
            CloseUtil.closeAll(dis);
        }
    }

    public String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            isRunning = false;
            CloseUtil.closeAll(dis);
        }
        return msg;
    }
    public void run() {
        while(isRunning)
            System.out.println(receive());
    }

}

//关闭流工具类
package com.vvvvvv.chatdemo03;

import java.io.Closeable;
import java.io.IOException;

/**
 * 关闭流的方法
 * @author Administrator
 *
 */

public class CloseUtil {

    public static void closeAll(Closeable... io) {
        for(Closeable temp: io) {
            if(null != temp) {
                try {
                    temp.close();
                } catch (IOException e) {

                }
            }
        }
    }
}