Java笔记-网络编程

Java笔记-网络编程

TCP：打电话

UDP：发短信

网络协议：http、ftp、tcp、udp

OSI七层网络模型	TCP/IP四层概念模型	对应网络协议
应用层	应	HTTP、TFTP、FTP、NFS、SMTP
表示层	用	Telnet、Rlogin、SNMP、Gopher
会话层	层	SMTP、DNS
传输层	传输层	TCP、UDP
网络层	网络层	IP、ICMP、ARP
数据链路层	数据链路层	FDDI、PDN、PPP
物理层	数据链路层	IEEE802.1A

IP：InetAddress

• ipv4/ipv6： ipv4由4个字节组成0~255 ；ipv6 128位，8个无符号整数组成
• 公网/私网

端口：0-65535

• http:8080
• Https: 443
• FTP:21
• Telnet:23
• Tomcat:8080
• Mysql:3306
• Oracle:1521

TCP

打电话

三次握手 四次挥手

传输完成，释放连接

//TCP通话客户端
public class testClientSocket {
    public static void main(String[] args) throws IOException {
        int port = 9999;
        InetAddress address = null;
        Socket socket = null;
        OutputStream out = null;
        ByteArrayOutputStream output = null;
        InputStream in = null;
        try{
            //知道地址，建立通信
            address = InetAddress.getByName("127.0.0.1");
            socket = new Socket(address,port);

            //输出信息
            out = socket.getOutputStream();

            out.write("客户端：你好呀服务器端,我是客户端".getBytes());

 //通知服务器端已经结束嘞
            socket.shutdownOutput();

             in = socket.getInputStream();
             output = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while((len = in.read(buffer)) != -1){
                output.write(buffer,0,len);
            }
            System.out.println(output.toString());

        }finally {

            if(output !=null){
                output.close();
            }
            if(in !=null){
                in.close();
            }
            if(out != null){
                out.close();
            }
            if(socket != null){
                socket.close();
            }



        }


    }
}

//服务器端
public class testServerSocket {
    public static void main(String[] args) throws IOException {

        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream in = null;
        ByteArrayOutputStream byteStream = null;
        OutputStream output = null;
        try{
            //声明自己的端口号
            serverSocket = new ServerSocket(9999);

            //接受客户端端的socket
            socket = serverSocket.accept();

            //获取客户端的数据
            in = socket.getInputStream();

                byteStream = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while((len=in.read(buffer))!=-1){
                    byteStream.write(buffer,0,len);
                }
                System.out.println(byteStream.toString());


                //反馈给客户端
            output = socket.getOutputStream() ;
            output.write("服务器端：亲爱的客户端，服务器端已收到".getBytes());


        }finally {
            output.close();
            byteStream.close();
            in.close();
            socket.close();
            serverSocket.close();
        }


    }
}

UDP

发短信

客户端和服务端没有明确界定

不管有没有准备好，都要发送

//发送端
public class testUDP {
    public static void main(String[] args) throws IOException {
        //建立socket
        DatagramSocket socket = new DatagramSocket();

        String msg = "你好";
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 9090;
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,address,port);

        //发送包
        socket.send(packet);
        socket.close();
    }
}

//接收端

public class testToUDP {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(9090);

        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        socket.receive(packet);


        System.out.println(new String(packet.getData(),0,packet.getLength()));
        socket.close();
    }
}

循环聊天

//UDP协议发送者
public class UDPSend implements  Runnable{
    DatagramSocket socket = null;
    DatagramPacket packet = null;

     BufferedReader reader = null;

    int fromPort ;
    String toIP ;
    int toPort ;

    public UDPSend(String toIP , int fromPort, int toPort)  {
       this.toIP = toIP;
        this.fromPort = fromPort;
        this.toPort = toPort;
        try {
            socket = new DatagramSocket(fromPort);
        } catch (SocketException e) {
            e.printStackTrace();
        }
        reader = new BufferedReader(new InputStreamReader(System.in));

    }


    @Override
    public void run() {
        //发送信息
        try {

            while(true){
                String data = reader.readLine().trim();
                byte[] datas = data.getBytes();

                packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));

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

            }


        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            socket.close();

        }

    }
}

//UDP接收
public class UDPRecieve implements  Runnable{

    DatagramSocket socket ;
    DatagramPacket packet ;
    private int fromPort;
    private int port;
    private String msgFrom;

    public UDPRecieve(int fromPort, int port,String msgFrom) {
        this.msgFrom = msgFrom;
        this.fromPort = fromPort;
        this.port = port;
        try {
            socket = new DatagramSocket(this.port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            while(true){
                byte[] buffer = new byte[20];

                packet = new DatagramPacket(buffer,0,buffer.length);

                socket.receive(packet);

                byte[] data = packet.getData();
                String receiveData = new String(data,0,data.length);

                System.out.println(this.msgFrom  +":"+receiveData);
                if(receiveData.equals("bye")){
                    break;
                }
            }


        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            socket.close();

        }


    }
}

//开启两个线程，一个人可以接收和发送，开两个端口
//另外一个人也接收和发送，也开两个端口
public class testUser1 {
    public static void main(String[] args) {
        new Thread(new UDPSend("127.0.0.1",1111,2222)).start();
        new Thread(new UDPRecieve(3333,4444,"User2")).start();
    }
}

public class testUser2 {
    public static void main(String[] args) {
        new Thread(new UDPSend("127.0.0.1",3333,4444)).start();
        new Thread(new UDPRecieve(1111,2222,"User1")).start();
    }
}