基于TCP的Socket编程

>>Socket相关的理解：
1>TCP：拨电话后和对方谈话 对应特点：有连接，安全(对方一定收到了且自己说什么对方听到的就是什么)。
     UDP：写信给对方 对应特点：无连接，但对方不一定收到，收到了数据也不一定完整。
     DNS：域名服务(每个域名对一个一个IP)。
2>比喻和对比
        Socket：电话机         IP：电话号码  端口：分机号。
3>返回本地IP地址的三种方式：
    InetAddress.getByName("localhost")   ; InetAddress.getByName("127.0.0.1") (属于回路地址)  ; InetAddress.getByName(null)   ;
4>服务器端和客户端的功能
    服务器端：开辟端口 提供服务；
   客户端：指定服务器端和端口，获取服务。

>>一个简单的客户端/服务器端(Client/Server)的数据读写
Server服务器端代码：
import java.net.*;
import java.io.*;
class ServerrSocket
{
public static void main(String[] args)
{
  server();
}
public static void server()
{
  try{
   ServerSocket ss = new ServerSocket(6000);//指定6000端口提供服务；
   System.out.println("服务器端启动...");
   Socket s = ss.accept();    //采取侦听的方法，随时接受客户端Client的请求
   OutputStream os = s.getOutputStream(); //根据客户端Client创建输出流对象
   InputStream is = s.getInputStream(); //根据客户端Client创建输入流对象
   os.write("hello ,welcome you!".getBytes()); //向客户端Client写入数据
   byte[] buf = new byte[100]; //声明一个byte数组，用于接收客户端Client的输入数据
   int len = is.read(buf); //读取客户端的输入Client数据并保存到byte数组中，返回数组大小
   System.out.println(new String(buf,0,len)); //服务器端Server输出客户端的输入
   os.close();//关闭输出流
   is.close(); //关闭输入流
   s.close(); //关闭Socket对象
   ss.close(); //关闭服务器Socket对象
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

客户端Client代码：
import java.net.*;
import java.io.*;
class ClientSocket
{
public static void main(String[] args)
{
  client();
}
public static void client()
{
  try{
   Socket s = new Socket(InetAddress.getByName("127.0.0.1"),6000); //创建指定IP的端口号为6000的服务请求
   OutputStream os = s.getOutputStream();  //根据服务器端Server创建输出流对象
   InputStream is = s.getInputStream(); //根据服务器端Server创建输入流对象
   os.write("hello ,i am dajian!".getBytes()); //向服务器度Server写入字节码数据
   byte[] buf = new byte[100]; //声明byte数组，用于接收服务器端的数据
   int len = is.read(buf);  //读入服务器度Server写入的数据到byte数组，返回数组大小
   System.out.println(new String(buf,0,len)); //客户端输出数据
   os.close(); //关闭输出流
   is.close(); //关闭输入流
   s.close();//关闭Socekt对象
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

3>>与Thread结合，实现持续不间断的侦听客户端的请求
import java.net.*;
import java.io.*;
//服务器端继承Thread，变成线程类
class ServerrSocket  extends Thread
{
private Socket s; //套接字属性
//带参构造函数指定哪个为套接字提供服务
ServerrSocket(Socket s)
{
  this.s = s;
}

//重写run方法
public void run()
{  
  try{
   OutputStream os = s.getOutputStream();//输出流
   InputStream is = s.getInputStream(); //输入流
   os.write("hello ,welcome you!".getBytes());
   byte[] buf = new byte[100];
   int len = is.read(buf);
   System.out.println(new String(buf,0,len));
   os.close();
   is.close();
   s.close();
  }catch(Exception e)
  {
   e.printStackTrace();
  }
}
public static void main(String[] args)
{
  server();
}
public static void server()
{
  try{
   ServerSocket ss = new ServerSocket(6000);
   System.out.println("服务器端启动...");
   //while死循环实现始终等待客户端请求，接受请求开启线程，提供服务
   while(true)
   {
    Socket s = ss.accept();
    new ServerrSocket(s).start();//紧接着走run方法,run方法结束，线程结束
   }
   //ss.close(); //持续侦听，所以不对服务器Socekt对象进行关闭  
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

4>>缓冲流读写大量数据的处理和注意事项
import java.net.*;
import java.io.*;
//服务器端继承Thread，变成线程类
class ServerrSocket  extends Thread
{
private Socket s; //套接字属性
//带参构造函数指定哪个为套接字提供服务
ServerrSocket(Socket s)
{
  this.s = s;
}

//重写run方法
public void run()
{  
  try{

   /* //原始的输入流输出流方法
   OutputStream os = s.getOutputStream();//输出流
   InputStream is = s.getInputStream(); //输入流
   os.write("hello ,welcome you!".getBytes());
   byte[] buf = new byte[100];
   int len = is.read(buf);
   System.out.println(new String(buf,0,len));
   os.close();
   is.close();
   s.close();
   */

   /* 使用缓冲流读写数据 关键调用flush方法清空缓冲 或者最后将缓冲流对象关闭调用close方法
   //演示调用flush方法清空缓冲
   OutputStream os = s.getOutputStream();//输出流
   InputStream is = s.getInputStream(); //输入流
   BufferedOutputStream bos = new BufferedOutputStream(os);
   bos.write("hello ,welcome you!".getBytes());
   bos.flush();//必须清空缓冲，通过网络将数据送出去
   byte[] buf = new byte[100];
   int len = is.read(buf);
   System.out.println(new String(buf,0,len));
   */
   //演示调用close方法关闭缓冲
   OutputStream os = s.getOutputStream();//输出流
   InputStream is = s.getInputStream(); //输入流
   BufferedOutputStream bos = new BufferedOutputStream(os);
   bos.write("hello ,welcome you!".getBytes());
   byte[] buf = new byte[100];
   int len = is.read(buf);
   System.out.println(new String(buf,0,len));
   bos.close();
   //os.close();
   is.close();
   s.close();
  }catch(Exception e)
  {
   e.printStackTrace();
  }
}
public static void main(String[] args)
{
  server();
}
public static void server()
{
  try{
   ServerSocket ss = new ServerSocket(6000);
   System.out.println("服务器端启动...");
   //while死循环实现始终等待客户端请求，接受请求开启线程，提供服务
   while(true)
   {
    Socket s = ss.accept();
    new ServerrSocket(s).start();//紧接着走run方法,run方法结束，线程结束
   }
   //ss.close(); //持续侦听，所以不对服务器Socekt对象进行关闭

  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}