Core Java(十一)

 

知识点：网络编程

网络基础知识：

网络，ip，端口，协议

网络就是多台计算机组成的一个能够互相通讯的计算机网

通过ip地址（就跟人的身份正号一样）确定是哪台计算机

通过端口可以知道目标计算机运行的程序

协议实现了计算机如何通讯，如何寻址，如何连接等

如何实现在网络中找到计算机的呢？

Ip----计算机------端口-------程序 端口—依赖于网络协议，协议不一样，端口的意义也不一样，tcp/ip中（1024以下都是系统协议），1024-65536都是可以自己定义的

 

Tcp/ip:

还有个OSI网络协议,OSI协议模式分七层
tcp/ip: 是对等通讯的：意思是各个计算机都采用同样的协议进行通讯

例：有两个电脑A,B A向B发送“你好”这样的数据

A分三步：数据打包，包名前面加包头（“你好”），再加一个包头：包头，包头（数据），包名

B 解包

打包解包都是通过该协议进行的

TCP/IP协议到底是如何实现计算机之间通讯的呢？有个TCP/IP模型，流程

网络接口：底层，link,解决二进制数据传输的问题

网络层：寻址、路由（指如何到达地址的过程）

传输层：端口连接，tcp：传输控制协议 udp协议，tcp作用是保证数据的可靠性，但性能一般，它连上机器后，发个消息，确实连接成功，udp用户数据报协议：不保证可靠传递

应用层：通过以上三层为程序提供应用层对象

TCP模型：应用层/传输层/网络层/网络接口

端口是一种抽象的软件结构，与协议相关：TCP23端口和UDT23端口为两个不同的概念。

端口应该用1024以上的端口，以下的端口都已经设定功能。

                     TCP/IP模型

Application (FTP,HTTP,TELNET,POP3,SMPT)

Transport (TCP,UDP)

Network (IP,ICMP,ARP,RARP)

Link (Device driver,….)

 

注：

IP：寻址和路由

ARP（Address Resolution Protocol）地址解析协议：将IP地址转换成Mac地址

RARP（Reflect Address Resolution Protocol）反相地址解析协议：与上相反

ICMP（Internet Control Message Protocol）检测链路连接状况。利用此协议的工具：ping , traceroute

OSI协议的模型有7层

 

讲述两种方式实现计算机的通讯：

第一种：TCP套接字：

TCP协议：安全的传输控制协议，保证数据的可靠性

什么是套接字？就是网络驱动的一个接口，通过套接字能够实现计算机之间的通讯，可以互相发送接收数据

创建一个TCP服务器端程序的步骤：

   

    1). 创建一个ServerSocket

    2). 从ServerSocket接受客户连接请求

    3). 创建一个服务线程处理新的连接

    4). 在服务线程中，从socket中获得I/O流

    5). 对I/O流进行读写操作，完成与客户的交互

    6). 关闭I/O流

    7). 关闭Socket

ServerSocket server = new ServerSocket(post)

Socket connection = server.accept();

ObjectInputStream put=new ObjectInputStream(connection.getInputStream());

ObjectOutputStreamo put=newObjectOutputStream(connection.getOutputStream());   

处理输入和输出流;

关闭流和socket。

 

创建一个TCP客户端程序的步骤：

1).创建Socket

    2). 获得I/O流

    3). 对I/O流进行读写操作

    4). 关闭I/O流

    5). 关闭Socket

Socket connection = new Socket(127.0.0.1, 7777);

ObjectInputStream input=new ObjectInputStream(connection.getInputStream());

ObjectOutputStream utput=new ObjectOutputStream(connection.getOutputStream());

处理输入和输出流;

关闭流和socket。

/**

 * 知识点：

 * TCP Socket套接字

 * 程序目标：

 * 实现两个程序互相通讯的功能

 */

package MY.module11.TCPsocket;

import java.io.*;

import java.net.*;

public class Server {

       public static void main(String[] args){

              try {

                     ServerSocket ss=new ServerSocket(8000);

                     Socket s=ss.accept();

                     InputStream fis=s.getInputStream();

                     BufferedReader br=new BufferedReader(new InputStreamReader(fis));

                     String str=br.readLine();

                     System.out.println(str);

                     br.close();

                     ss.close();

                     s.close();

                    

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

}

package MY.module11.TCPsocket;

import java.io.*;

import java.net.*;

public class Client {

       public static void main(String[] args){

              try {

                     Socket s=new Socket("127.0.0.1",8000);

                     OutputStream os=s.getOutputStream();

                     BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));

                     String str="hello";

                     bw.write(str);

                     bw.close();

                     s.close();

                            } catch (UnknownHostException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

 

/**

 * 知识点：

 * TCPsocket,线程

 * Java相关文件：

 * Client.java

 * 程序目标：

 * 客户端发送信息，服务器得到信息后，将它转换为大写，然后显示在终端上，

 * 直到客户打出goodbye程序才结束

 */

package MY.module11.TCPsocket.t2;

import java.io.*;

import java.net.*;

public class Server extends Thread{

       private Socket s;

       public Server(Socket s){

              this.s=s;

       }

       public static void main(String[] args){

              try {

                     ServerSocket ss=new ServerSocket(2000);

                     while(true){

                            Socket s=ss.accept();

                            new Server(s).start();

                     }

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       public void run(){

              String name=Thread.currentThread().getName();

              try {

                     InputStream is=s.getInputStream();

                     OutputStream os=s.getOutputStream();

                    

                     BufferedReader br=new BufferedReader(new InputStreamReader(is));

                     BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));

                    

                     while(true){

                            String str=br.readLine();

                            if(str.equals("goodbye"))

                                   break;

                            String str2=str.toUpperCase();

                            bw.write(name+":"+str2+System.getProperty("line.separator"));

                            bw.flush();

                     }

                     br.close();

                     bw.close();

                     s.close();

 

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

package MY.module11.TCPsocket.t2;

import java.io.*;

import java.net.*;

public class Client{

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              try {

                     Socket s=new Socket("127.0.0.1",2000);

                     InputStream is=s.getInputStream();

                     OutputStream os=s.getOutputStream();

                    

                     BufferedReader brKey=new BufferedReader(new InputStreamReader(System.in));

                     BufferedReader br=new BufferedReader(new InputStreamReader(is));

                     BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));

                    

                     while(true){

                            String strKey=brKey.readLine();

                            bw.write(strKey+System.getProperty("line.separator"));

                            bw.flush();

                            if(strKey.equals("goodbye"))

                                   break;

                            String str=br.readLine();

                            System.out.println(str);

                     }

                     brKey.close();

                     br.close();

                     bw.close();

                     s.close();

              } catch (UnknownHostException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

 

}

第二种：UDP套接字：

UDP:按数据报的方式传送数据，数据报包里面的数据都是字节型的数据

/**

 * 知识点：

 * udpSocket

 * Java文件说明：

 * Sender.java：发送方 Receiver.java接收打印方

 * 程序目标：

 * 使用udpSocket方式发送数据

 */

package MY.module11.udpsocket;

import java.net.*;

import java.io.*;

public class Sender {

       public static void main(String[] args){

              try {

                     DatagramSocket ds=new DatagramSocket();

                    

                     String s="hello world";

                     DatagramPacket dp=new DatagramPacket(s.getBytes(),s.getBytes().length,InetAddress.getByName("127.0.0.1"),2000);

                     ds.send(dp);

                     ds.close();

              } catch (SocketException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (UnknownHostException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

package MY.module11.udpsocket;

import java.io.*;

import java.net.*;

public class Receiver {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              try {

                     DatagramSocket ds=new DatagramSocket(2000);

                    

                     byte[] buy=new byte[1024];

                     DatagramPacket dp=new DatagramPacket(buy,1024);

                    

                     ds.receive(dp);

                     byte[] b=dp.getData();

                     String s=new String(b,0,dp.getLength());

                     System.out.println(s);

              } catch (SocketException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

 

}

总结：

第一， 要有socket对象

第二， 将要发送的数据打包成数据报包

第三， 接收方也要用数据报包来接收

第四， 通过数据报包中的getData方法得到数据，这个数据是字节型的数据

第五， 最后进行数据的处理

 

/**

 * 知识点：

 * udpSocket:DatagarmSocket,DatagarmPacket

 * 程序目标：

 * 聊天室，用户输入发送的ip，输入要发送的消息，回车的时候，显示在自己

 * 和对方的屏幕上，利用updSocket原理实现

 */

package MY.module11.udpsocket;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import java.io.IOException;

import java.net.*;

public class MyCharRomm {

       private JFrame jf;

       private JPanel jp;

       private JTextField tf1;

       private JTextField tf2;

       private List list;

       private DatagramSocket ds;

      

       public MyCharRomm(){

              try {

                     ds=new DatagramSocket(8000);

                     new Thread(new Runnable(){

 

                            public void run() {

                                   // TODO Auto-generated method stub

                                  byte[] b=new byte[1024];

                                   DatagramPacket dp=new DatagramPacket(b,1024);

                                   while(true){

                                          try {

                                                 ds.receive(dp);

                                                 String receiveStr=new String(dp.getData(),0,dp.getLength());

                                                 list.add(dp.getAddress().getHostName()+":"+receiveStr, 0);

                                          } catch (IOException e) {

                                                 // TODO Auto-generated catch block

                                                 e.printStackTrace();

                                          }

                                   }

                            }

                           

                     }).start();      

              } catch (SocketException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

      

       public void init(){

              jf=new JFrame("liao tiao shi");

              jf.addWindowListener(new WindowAdapter(){

                     public void windowClosing(WindowEvent arg0) {

                            // TODO Auto-generated method stub

                            ds.close();

                            System.exit(0);

                     }

              });

              Container c=jf.getContentPane();

              c.setLayout(new BorderLayout());

              jp=new JPanel();

              list=new List();

             

              tf1=new JTextField();

              tf2=new JTextField();

              tf2.addActionListener(new action());

              jp.setLayout(new GridLayout(1,2));

              jp.add(tf1);

              jp.add(tf2);

              c.add(list,BorderLayout.CENTER);

              c.add(jp,BorderLayout.SOUTH);

             

              jf.setSize(300,300);

              jf.setVisible(true);

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              MyCharRomm mcr=new MyCharRomm();

              mcr.init();

       }

      

       class action implements ActionListener{

 

              public void actionPerformed(ActionEvent arg0) {

                     // TODO Auto-generated method stub

                     DatagramPacket dp=null;

                     String s=tf2.getText();

                     byte[] buy=s.getBytes();

                     String ip=tf1.getText();

                     try {

                            dp=new DatagramPacket(buy,buy.length,InetAddress.getByName(ip),8000);

                            ds.send(dp);

                            tf2.setText("");

                     } catch (UnknownHostException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     } catch (IOException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                     }

              }

             

       }

 

}

UDP是User Datagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。

 

比较：TCP在网络通信上有极强的生命力，例如远程连接（Telnet）和文件传输（FTP）都需要不定长度的数据被可靠地传输；既然有了保证可靠传输的TCP协议，为什么还要非可靠传输的UDP协议呢？主要的原因有两个。一是可靠的传输是要付出代价的，对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽，因此TCP传输的效率不如UDP高。二是在许多应用中并不需要保证严格的传输可靠性，比如视频会议系统，并不要求音频视频数据绝对的正确，只要保证连贯性就可以了，这种情况下显然使用UDP会更合理一些。

如：

http://www.tarena.com.cn:80/teacher/zhuzh.html

协议名://机器名＋端口号＋文件名

 

URL：

什么是URL？有什么用？

统一资源定位器，网络上资源的存放地址，通过这个地址，我们就可以找到资源

URI:统一资源定位符，它是URL的一部分，可能根本不存在

都是资源的唯一标识

URL类的常见方法

 

一个URL对象生成后，其属性是不能被改变的，但是我们可以通过类URL所提供的方法来获取这些属性：

　　　public String getProtocol() 获取该URL的协议名。

　　　public String getHost() 获取该URL的主机名。

　　　public int getPort() 获取该URL的端口号，如果没有设置端口，返回-1。

　　　public String getFile() 获取该URL的文件名。

　　　public String getRef() 获取该URL在文件中的相对位置。

　　　public String getQuery() 获取该URL的查询信息。

　　　public String getPath() 获取该URL的路径

　　　public String getAuthority() 获取该URL的权限信息

　　　public String getUserInfo() 获得使用者的信息

public String getRef() 获得该URL的锚

 

写配置文件类：Properties类

/**

 * 知识点：

 * 将信息写入配置文件 Properties类

 * 程序目标：

 * 将一些信息写入配置文件，再从配置文件中得到这些信息，使用Properties类

 */

package MY.module11.properties;

import java.util.*;

import java.io.*;

public class ConfigUtil {

       public static void test1(){

              Properties p=new Properties();

              try {

//                 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("h://mytest//config.Properties")));

                     FileOutputStream fos=new FileOutputStream("h://mytest//config.Properties");

                     p.setProperty("ip","192.168.1.1");

                     p.setProperty("sore","80");

                     p.store(fos,"这是配置文件");

                     fos.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

             

       }

       public static void test2(){

              Properties p=new Properties();

              try {

                     FileInputStream fis=new FileInputStream("h://mytest//config.Properties");

                     p.load(fis);

                     String ip=p.getProperty("ip");

                     String sore=p.getProperty("sore");

                     System.out.println(ip+" "+sore);

                     fis.close();

              } catch (FileNotFoundException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IOException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test1();

              test2();

       }

 

}