网络编程

InetAddress

 InetAddress ia = InetAddress.getByName("主机名或IP地址");
 ia.getHostAddress(); 获取ip地址
 ia。getHostName();获取主机名

端口：

1.端口是进程的唯一标识，每个进程都至少有一个端口
2.不同进程的端口不能重复
3.有效端口0-65535 ， 0-1024为系统端口

协议：

UDP:用户数据博爱协议(User Datagram Protocal)

特点：
1.如果想使用该协议传输数据，那么必须将数据进行打数据报包

2. 该协议只能用来传输较小的数据，最大64k，一般使用聊天软件
   3.发送端传输数据的时候，可以没有接收端，所以数据不安全，有可能丢失，发送数据的时候不用建立连接
   4.效率高
   UDP协议也是使用socket来实现
   DatagramSocket可以发送也可以接收
   构造函数：

   1.DatagramSocket();绑定任何端口
   2.DatagramSocket(int port); 绑定到指定端口
   

作为发送端套接字，我们可以使用第一个，也可以使用第二个构造方法，作为接收端，一定要使用第二种，因为发送端要给接收端发送数据，必须知道端口

发送端：

send(DatagramPacket p) 从此套接字发送数据包
DatagramPacket表示把发送的数据进行打包
构造方法： DatagramPacket（byte[] buf,int length,InetAddress address,int port）
buf: 表示把发送的数据放到字节数组中
length：包长度（字节数组长度）
address:目标ip地址就是接收端ip地址
port:目标端口，接收端端口

接收端： 发送端查找接收端端口

receive(DatagramPacket p）从此套接字接收数据包，一直阻塞，等待
DatagramPacket：把接收的数据报包进行解析包
构造函数：DatagramPacket(byte[] buf,int lenght) 创建空的数据报包
buf:表示接收到的数据
length: 接收到的数据长度

getDate(); 接收数据方法
getLength() 获取长度
getAddress() 接收发送者ip
getPort() 接收发送者端口

例子：

     public class SendMessage implements Runnable{
    private DatagramSocket socket ;
    private String ip ;
    private int port ;
    public SendMessage(DatagramSocket socket ,int port,String ip) {
          this.socket = socket ;
          this.port = port ;
          this.ip = ip ;
   }
    public void run() {
                 try {
                        while(true ){
                BufferedReader bf = new BufferedReader(new InputStreamReader(System.in ));
                             String line = null;
                              while((line =bf .readLine())!=null){
                                     byte[] buf = line .getBytes();
                             DatagramPacket p = new DatagramPacket(buf , buf.length , InetAddress.getByName (ip ), port );
                              socket.send( p);
                             }
                       }
                } catch (Exception e ) {
                        e.printStackTrace();
                }
   }
   }
   public class ResiveMessage implements Runnable {
   DatagramSocket socket;
    public ResiveMessage(DatagramSocket socket ) {
          this.socket = socket ;
   }
    public void run() {
          try {
                 while (true ) {
                       DatagramPacket p = new DatagramPacket(new byte[1024], 1024);
                        socket.receive( p);
                       System. out.println(
                                     p.getAddress().getHostAddress() + "-------" + new String(p .getData(), 0, p.getLength()));
                }
         } catch (Exception e ) {
                 e.printStackTrace();
         }
   }
   }

调用：
         Properties p = new Properties();
          p.load( new FileReader("date.ini" ));
         String ip = p.getProperty( "ip");
         String port = p.getProperty( "port");
         
         DatagramSocket socket = new DatagramSocket(Integer.parseInt(port));
         SendMessage send = new SendMessage(socket,Integer.parseInt( port), ip);
         ResiveMessage resive = new ResiveMessage(socket );
          new Thread(send ).start();
          new Thread(resive ).start();
   }  

TCP:传输控制协议(Transmission Control Protocol)

特点：
1.使用该协议必须先建立连接，满足三次握手协议，建立连接通道
2.这个协议传输数据安全，发送数据的时候，一定要有接收端
3.可以传输大的文件，主要使用文件上传下载
4.效率低

1.一个服务端可以被多个客户端访问
2.客户端可以访问服务端，叫做请求，服务端发送给客户端数据，响应，客户端和客户端不能互相访问
Socket：
getOutputStream()
getInputStream()

使用客户端套接字Socket中的方法：获取输入流，获取数据

ServerSocket：
accept() 获取通道的socket对象

readLine() 阻塞

结束标记：
shutdownInput();
shutdownOutput(); 客户端写的结束标记

public class ClientDemo {
    public static void main(String[] args) throws Exception {
         Socket s = new Socket("dubo" ,10010);// 创建客户端套接字对象
         OutputStream stream = s.getOutputStream(); // 获取字节输出流
         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(stream));//将字节输出流转换为字符缓冲输处流
         BufferedReader bf = new BufferedReader(new FileReader("player.txt" ));// 创建字符输入缓冲流
         String line = null;
          while((line = bf .readLine())!=null){
                 bw.write( line);
                 bw.newLine();
                 bw.flush();
         }
          s.shutdownOutput(); // 结束标记
         InputStream input = s.getInputStream(); // 获取字节输入流
          byte[] buf = new byte[1024];
          int len = 0;
          while((len = input .read(buf ))!=-1){
                System. out.println("----------" +new String(buf,0,len));
         }
          // 释放资源
          bf.close();
          s.close();   
   }
}

public class ServiceDemo {
    public static void main(String[] args) throws Exception {
         ServerSocket s = new ServerSocket(10010);
         Socket accept = s.accept();
         InputStream input = accept.getInputStream();
         BufferedReader bf = new BufferedReader(new InputStreamReader(input));
         BufferedWriter fw = new BufferedWriter(new FileWriter("newplayer.txt" ));
         String line = null;
          while((line = bf .readLine())!=null){
                 fw.write( line);
                 fw.newLine();
                 fw.flush();
         }
          // 返回数据
         OutputStream back = accept.getOutputStream();
          back.write( "上传成功" .getBytes());
          bf.close();
          fw.close();
          s.close();
   }
 }