java加强--网络编程总结

 

UDP和TCP之间的区别

UDP
1.将数据及源和目的封装成数据包，不需要建立连接
2.每个数据包的大小限制在64K内
3.因无连接，是不可靠协议
4.不需要建立连接，速度快

TCP
1.建立连接，形成传输数据的通道
2.在连接中进行大量的数据传输
3.通过三次握手完成连接，是可靠协议
4.必须建立连接，效率会稍低

/*
 *需求：通过UDP传输方式，将一段文字数据发送出去
 *思路：
 *1，建立updsocket服务
 *2，提供数据，并将数据封装到数据包中。
 *3，通过socket服务的发送功能，将数据包发出去，
 *4，关闭资源
 */
package day23_1_net;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpSend {
 public static void main(String[] args) throws Exception {
  // 1.创建udp服务，通过DatagramSocket对象。
  DatagramSocket ds = new DatagramSocket();
  // 2.确定数据，并封装成数据包。
  byte buf[] = "UDP 我来了".getBytes();
  DatagramPacket dp = new DatagramPacket(buf, buf.length,
    InetAddress.getByName("127.0.0.1"), 10000);

  // 3.通过socket服务，将已有的数据包发送出去，通过send方法，
  ds.send(dp);
  // 4.关闭资源
  ds.close();
 }
}

/*
 *需求：通过UDP传输方式，将一段文字数据发送出去
 *思路：
 *1，建立updsocket服务
 *2，提供数据，并将数据封装到数据包中。
 *3，通过socket服务的发送功能，将数据包发出去，
 *4，关闭资源
 */
package day23_1_net;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpSend {
 public static void main(String[] args) throws Exception {
  // 1.创建udp服务，通过DatagramSocket对象。
  DatagramSocket ds = new DatagramSocket();
  // 2.确定数据，并封装成数据包。
  byte buf[] = "UDP 我来了".getBytes();
  DatagramPacket dp = new DatagramPacket(buf, buf.length,
    InetAddress.getByName("127.0.0.1"), 10000);

  // 3.通过socket服务，将已有的数据包发送出去，通过send方法，
  ds.send(dp);
  // 4.关闭资源
  ds.close();
 }
}

使用TCP进行网络编程时
在Server端要定义
ServerSocket ss=new ServerSocket(9999);//参数是端口号，
Socket s=ss.accept();//获得到Socket。accept是阻塞方法
在Client端
Socket s=new Socket("127.0.0.1", 9999);//参数1是要连接的主机地址，参数2是端口号

根据需求在Server和Client端都要定义发送和接受消息的属性
从通道中获取到流用s.getInputStream();
向通道中发送流用s.getOutputStream();

/*
客户端向服务端上传图片。将客户端封装成线程。
*/
//服务器端
public class Di17_server {
 public static void main(String[] args) throws Exception {
  receive();
 }

 public static void receive() throws Exception {
  ServerSocket ss = new ServerSocket(9999);
  while (true) {
   Socket s = ss.accept();//是阻塞方法，所以没有客户端连上来，就会一直等待
   Rethread rt = new Rethread(s);//将Socket作为参数传到Rethread中去，每一个不同的客户端都会传人一个不同的Socket
   Thread t = new Thread(rt);
   t.start();
  }
 }
}

class Rethread implements Runnable {
 private Socket s;
 int a = 0;

 public Rethread(Socket s) {
  this.s = s;
 }

 @Override
 public void run() {
  String postname = s.getInetAddress().getHostAddress();//得到地址名
  FileOutputStream fos=null;
  PrintWriter pw=null;
  try {
   InputStream is = s.getInputStream();
   File file = new File("d:\\" + postname + "_" + (++a) + ".jpg");
   while (file.exists())// 要使用while判断，
   {
    file = new File("d:\\" + postname + "_" + (++a) + ".jpg");
    System.out.println(a);
   }
   fos = new FileOutputStream(file);
   byte bytes[] = new byte[1024];
   int len = 0;
   while ((len = is.read(bytes)) != -1) {
    fos.write(bytes, 0, len);
   }
   pw = new PrintWriter(s.getOutputStream(), true);
   pw.println("上传成功");
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   try {
    pw.close();
    fos.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
}
//客户端
public class Di17_client {
 public static void main(String[] args) throws Exception {
  send();
 }
 
 public static void send() throws Exception
 {
  Socket s=new Socket("127.0.0.1", 9999);
  OutputStream os=s.getOutputStream();
  
  FileInputStream fis=new FileInputStream("d:\\111.jpg");
  byte[] b=new byte[1024];
  int len=0;
  while((len=fis.read(b))!=-1)
  {
   os.write(b, 0, len);
  }
  
  s.shutdownOutput();//告诉服务器，客户端已经上传完毕(记着一定要写)
  
  BufferedReader bfr=new BufferedReader(new InputStreamReader(s.getInputStream()));
  System.out.println(bfr.readLine());
  
 }
}

 

//用户登录。登录三次。如果用户名三次错误，就不让登录了，可以多线程
//服务器端
public class Server1 {
 public static void main(String[] args) throws Exception {
  ServerSocket ss = new ServerSocket(9999);
  while (true) {
   Socket s = ss.accept();
   UserThread ut = new UserThread(s);
   Thread t = new Thread(ut);
   t.start();
  }
 }
}

class UserThread implements Runnable {
 private Socket s;

 UserThread(Socket s) {
  this.s = s;
 }
 @Override
 public void run() {
  try {
   String ip = s.getInetAddress().getHostAddress();
   System.out.println(ip + "：1连接上服务器");
   // 接受客户端的信息
   BufferedReader bfr = new BufferedReader(new InputStreamReader(s.getInputStream()));

   // 发送信息给客户端
   PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
   for (int i = 0; i < 3; i++) {
    // 读取文件信息
    BufferedReader bfr2 = new BufferedReader(new FileReader("nameinfo.txt"));

    boolean b = false;
    String nameinfo = null;
    String name = bfr.readLine();
    if (name==null){
     System.out.println("这个家伙关闭了客户端");
     break;
    }
    while ((nameinfo = bfr2.readLine()) != null) {
     if (nameinfo.equals(name)) {
      b = true;
      break;
     }
    }
    if (b) {
     pw.println(name + ",欢迎登录");
     System.out.println(name + "登录成功");
     break;
    } else {
     pw.println("用户名错误");
     System.out.println(name + "尝试登录");
    }
   }

  } catch (Exception e) {
   e.printStackTrace();
  } finally {
   try {
    s.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
}
//客户端
public class Client1 {
 public static void main(String[] args) throws Exception {
  Socket s=new Socket("127.0.0.1",9999);
  
  BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
  //发给服务器
  PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
  //接受服务器
  InputStreamReader isr=new InputStreamReader(s.getInputStream());
  BufferedReader br=new BufferedReader(isr);
  for(int i=0;i<3;i++)
  {
   String name=bfr.readLine();
   if(name==null){//如果客户端关闭，那么将返回一个null
    System.out.println("客户端关闭了 ");
    break;
   }
   pw.println(name);
   String info=br.readLine();
   System.out.println(info);
   if(info.contains("欢迎"))
    break;
  }
  s.close();
 }
}