Java编程基础-网络编程下

最新推荐文章于 2022-09-11 09:45:20 发布

persistenthuang

最新推荐文章于 2022-09-11 09:45:20 发布

阅读量86

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_43309907/article/details/104002427

版权

java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

网络编程

协议

TCP

TCP编程

案例一

登录验证
发送端

package javaTCP;
import java.io.*;
import java.net.*;
public class LoginClient {
 public static void main(String[] args) throws UnknownHostException, IOException {
  System.out.println("----client----");
  BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  System.out.println("请输入用户名：");
  String uname=br.readLine();
  System.out.println("请输入密码：");
  String upwd=br.readLine();
  //1.建立连接，使用Socket创建客户端+服务器地址和端口
  Socket client=new Socket("127.0.0.1",8888);
   //2.操作，输入输出流操作
  DataOutputStream dos=new DataOutputStream(client.getOutputStream());
  dos.writeUTF("uname="+uname+"&"+"upwd="+upwd);
  dos.flush();
  DataInputStream dis=new DataInputStream(client.getInputStream());
  String result=dis.readUTF();
  System.out.println(result);
  //4.释放资源
  dos.close();
  client.close();
}
}

接收端

package javaTCP;
import java.io.*;
import java.net.*;
public class LoginServer {
 public static void main(String[] args) throws IOException {
  System.out.println("----server----");
  //1.指定端口，利用ServerSocket创建服务器
  ServerSocket server=new ServerSocket(8888);
  String uname="";
  String upwd="";
  //2.阻塞式等待连接accept
  Socket client=server.accept();
  System.out.println("一个客户端建立了连接");
  //3.操作，输入输出流操作
  DataInputStream dis=new DataInputStream(client.getInputStream());
  String data=dis.readUTF();
  String[] dataArray=data.split("&");
  for(String info:dataArray) {
   String[] userInfo=info.split("=");
   if(userInfo[0].equals("uname")) {    
    System.out.println("你的用户名为："+userInfo[1]);
    uname=userInfo[1];
   }
   else if(userInfo[0].equals("upwd")) {
    System.out.println("你的密码为："+userInfo[1]);
    upwd=userInfo[1];
   }
  }
  //判断
  DataOutputStream dos=new DataOutputStream(client.getOutputStream());
  if(uname.equals("用户名")&&upwd.equals("mima")) {
   dos.writeUTF("登陆成功 欢迎回来");
  }else {
   dos.writeUTF("用户名密码错误");
  }
  dos.flush();
  //4.释放资源
  dos.close();
  dis.close();
  client.close();
  server.close();
 }
}

案例二

文件拷贝
接收端

package javaTCP;
import java.net.*;
import java.io.*;
/**
 * TCP
 * @author HUANGYAOHUI
 */
public class FileServer {
 public static void main(String[] args) throws IOException {
  System.out.println("----server----");
  //1.指定端口，利用ServerSocket创建服务器
  ServerSocket server=new ServerSocket(8888);
  //2.阻塞式等待连接accept
  Socket client=server.accept();
  System.out.println("一个客户端建立了连接");
  //3.操作，输入输出流操作
  InputStream is=new BufferedInputStream(client.getInputStream());
  OutputStream os=new BufferedOutputStream(new FileOutputStream("src/copy003.jpg"));
  byte[] flush=new byte[1024];
  int len=-1;
  while((len=is.read(flush))!=-1) {
   os.write(flush,0,len);
  }
  os.flush();
  //4.释放资源
  os.close();
  is.close();
  client.close();
 }
}

发送端

package javaTCP;
import java.io.*;
import java.net.*;
public class FileClient {
 public static void main(String[] args) throws UnknownHostException, IOException {
    System.out.println("----client----");
    //1.建立连接，使用Socket创建客户端+服务器地址和端口
    Socket client=new Socket("localhost",8888);
     //2.操作，输入输出流操作
    InputStream is=new BufferedInputStream(new FileInputStream("003.jpg"));
    OutputStream os=new BufferedOutputStream(client.getOutputStream());
    byte[] flush=new byte[1024];
    int len=-1;
    while((len=is.read(flush))!=-1) {
     os.write(flush,0,len);
    }
    os.flush();
    //4.释放资源
    os.close();
    is.close();
    client.close();
 }
}

UDP

UTP编程

案例一：

分两个端发送接收数据
接收端

package javaNet;
import java.net.*;
/**
 * 基本操作：接收端
 * Address already in use: Cannot bind
 * 同一个协议下端口不允许冲突
 * 1.使用DatagramSocket指定端口 创建接收端
 * 2.使用容器 封装成DatagramPacket包裹
 * 3.阻塞式接收包裹receive(DatagramPacket p)
 * 4.分析数据
 * byte[] getData();
 *     getlength();
 * 5.释放资源
 * @author HUANGYAOHUI
 */
public class UdpServer {
 public static void main(String[] args) throws Exception{
  System.out.println("接收方启动中。。。。。。");
  //1.使用DatagramSocket指定端口 创建接收端
  DatagramSocket server=new DatagramSocket(9999);
  //2.使用容器 封装成DatagramPacket包裹
  byte[] container=new byte[1024*60];
  DatagramPacket packet=new DatagramPacket(container,0,container.length);
  //3.阻塞式接收包裹receive(DatagramPacket p)
  server.receive(packet);
  //4.分析数据
  //byte[] getData();
  //    getlength();
  byte[] datas=packet.getData();
  System.out.println(new String(datas));
  //5.释放资源
  server.close();
 }
}

发送端：

package javaNet;
import java.net.*;
/**
 * 基本操作： 发送端
 * 1.使用DatagramSocket指定端口 创建发送端
 * 2.准备数据一定转换成字节数组
 * 3.封装成DatagramPacket包裹，需要指定目的地。
 * 4.发送包裹send(DatagramPacket p)
 * 5.释放资源
 * @author HUANGYAOHUI
 */
public class UdpClient{
 public static void main(String[] args) throws Exception{
  System.out.println("发送方启动中。。。。。。");
  //1.使用DatagramSocket指定端口 创建发送端
  DatagramSocket client=new DatagramSocket(6666);
  //2.准备数据一定转换成字节数组
  String data="The word is writting for me to change";
  byte[] datas=data.getBytes();
  //3.封装成DatagramPacket包裹，需要指定目的地。
  DatagramPacket packet=new DatagramPacket(datas,0,datas.length,
    new InetSocketAddress("127.0.0.1",9999));
  //4.发送包裹send(DatagramPacket p)
  client.send(packet);
  //5.释放资源
  client.close();
 }
}

案例二

在线咨询

package javaNet;
import java.net.*;
public class TalkReceive implements Runnable{
 //1.使用DatagramSocket指定端口 创建接收端
 private DatagramSocket server;
 String from;
 public TalkReceive(int port,String from) {
  this.from=from;
  try {
   server=new DatagramSocket(port);
  } catch (SocketException e) {
   e.printStackTrace();
  }
 }
 @Override
 public void run() {
  try {
   while(true) {
    byte[] container=new byte[1024*60];
    DatagramPacket packet=new DatagramPacket(container,0,container.length);
    //3.阻塞式接收包裹receive(DatagramPacket p)
    server.receive(packet);
    //4.分析数据
    byte[] datas=packet.getData();
    String data=new String(datas,0,datas.length);
    System.out.println(from+":"+data);
    if(data.equals("bye"))
     break;
   }
   //5.释放资源
   server.close();
  } catch (Exception e) {
   // TODO: handle exception
  }
 }
}

package javaNet;
import java.io.*;
import java.net.*;
public class TalkSent implements Runnable{
 //1.使用DatagramSocket指定端口 创建发送端
 private DatagramSocket client;
 private BufferedReader reader;
 private String toIP;
 private int toPort;
 public TalkSent(int port,String toIP,int toPort) {
  this.toIP=toIP;
  this.toPort=toPort;
  try {
   client=new DatagramSocket(port);
   reader=new BufferedReader(new InputStreamReader(System.in));
  } catch (SocketException e) {
   e.printStackTrace();
  }
 }
 @Override
 public void run() {
  try {
   while(true) {
    String data=reader.readLine();
    byte[]datas=data.getBytes();
    //3.封装成DatagramPacket包裹，需要指定目的地。
    DatagramPacket packet=new DatagramPacket(datas,0,datas.length,
      new InetSocketAddress(toIP,toPort));
    //4.发送包裹send(DatagramPacket p)
    client.send(packet);
    if(data.equals("bye"))
     break;
   }
   //5.释放资源
   client.close();
   reader.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

package javaNet;
public class TalkStudent {
 public static void main(String[] args) {
  new Thread(new TalkReceive(6666,"老师")).start();
  new Thread(new TalkSent(5555,"127.0.0.1",9999)).start();
 }
}

package javaNet;
public class TalkTeacher {
 public static void main(String[] args) {
  new Thread(new TalkReceive(9999,"学生")).start();
  new Thread(new TalkSent(7777,"127.0.0.1",6666)).start();
 }
}