socket编程传递文件

使用TCP通信传输对象

直接关闭socket，即流也一起关闭。

多线程通信的优先级问题

客户端实现步骤

/*UDP客户端*/
public class UDPClient {
 public static void main(String[] args) {
  try {
   //向服务器端发送数据
   //1.定义服务器的地址、端口号、数据
   InetAddress address = InetAddress.getByName("localhost");
   int port = 8800;
   byte[] data = "用户名：admin;密码：123".getBytes();
   //2.创建数据报，包含发送的数据信息
   DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
   //3.创建DatagramSocket对象
   DatagramSocket socket = new DatagramSocket();
   //4.向服务器端发送数据报
   socket.send(packet);
   
   //接收服务器端响应的数据
   //1.创建数据报，用于接收服务器端响应的数据
   byte[] data2 = new byte[1024];
   DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
   //2.接收服务器响应的数据
   socket.receive(packet2);
   //3.读取数据
   String reply = new String(data2,0,packet2.getLength());
   System.out.println("我是客户端，服务器端说："+reply);
   //4.关闭资源
   socket.close();
  } catch (UnknownHostException e) {
   e.printStackTrace();
  } catch (SocketException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

服务器端实现步骤

/*UDP服务器端，实现基于UDP的用户登陆*/
public class UDPServer {
 public static void main(String[] args) {
  try {
   //接收客户端发送的数据
   //1.创建服务器端DatagramScoket,指定端口
   DatagramSocket socket = new DatagramSocket(8800);
   //2.创建数据报，用于接收客户端发送的数据
   byte[] data = new byte[1024];//创建字节数组，指定接受的数据报的大小
   DatagramPacket packet = new DatagramPacket(data, data.length);
   //3.接受客户端发送的数据
   System.out.println("服务器端已经启动，等待客户端发送数据");
   socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
   //4.读取数据
   String info = new String(data,0,packet.getLength());
   System.out.println("我是服务器，客户端说："+info);
   
   //向客户端响应数据
   //1.定义客户端的地址、端口号、数据
   InetAddress address = packet.getAddress();
   int port = packet.getPort();
   byte[] data2 = "欢迎你！".getBytes();
   //2.创建数据报，包含响应的数据信息
   DatagramPacket packet2 = new DatagramPacket(data2, data2.length,address,port);
   //3.响应客户端
   socket.send(packet2);
   //4.关闭资源
   socket.close();
  } catch (SocketException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

UDP编程
  1、UDP协议(用户数据报协议)是无连接、不可靠、无序的。
  2、UDP协议以数据报作为数据传输的载体。
  3、使用UDP进行数据传输时，首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明所要达到的Socket(主机地址和端口号)，然后在将数据报发生出去。
  4、相关操作类：DatagramPacket：表示数据报包
                 DatagramSocket：进行端到端通信的类

DatagramPacket类构造方法：
  1、DatagramPacket(byte[] buf,int length)//接受长度为length的数据包
  2、DatagramPacket(byte[] buf,int length,InetAddress address,int port)//将指定长度的字节发生到指定主机的指定端口

DatagramSocket类
  1、构造方法：DatagramSocket();
               DatagramSocket(int port,InetAddress laddr);
  2、close();//关闭DatagramSocket
  3、getInetAddress();//获取地址
  4、getPort();//获取端口号
  5、send(DatagramPacket p);//从此套接字发送数据包
     recrive(DatagramPacket p);//从此套接字接收数据包

UDP编程操作

主线程负责创建socket
* 一个线程用来读取
* 一个线程用来写入,用两个内部类
* 要用多线程实现，send线程和recived线程同时访问buff数据区。
* 发送完成后notify，接收线程。接收线程自身wait
* 接收的说，我先wait一下，可能缓存中还没有数据，我会拿到空值的。
* 发送的说Ok，我先写，写完了我notifyall你。我就一直锁着。变成并行处理了。
每个客户端连接服务端都会产生一个新的socket。

socket关闭条件时

一种写法：if(socket!=null)socket.close();

另一种写法：if(!socket.isClosed())socket.close();

多线程服务器操作

服务器向客户端进行响应

//获取输出流，响应客户端的请求
OutputStream os=socket.getOutputStream();
PrintWriter pw=new PrintWriter(os);//包装为打印流
pw.write("欢迎您!");
pw.flush();//调用flush()方法刷新缓冲输出
//关闭资源
pw.close();
os.close();
socket.close();

--------------------------------
客户端接收服务器发送的消息

InputStream is=socket.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(is));
String line;
while((line=br.readerline()!=null)
{
    System.out.println("我是客户端，服务器说："+line);
}
is.close();
br.close();
socket.close();

/*TCP服务器端*/
public class Server { 
    public static void main(String[] args) {  
        try {   
            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口   
            ServerSocket serverSocket = new ServerSocket(8888);   
            //2.调用accept()方法开始监听，等待客户端的连接   
            System.out.println("服务器即将启动，等待客户端的连接");   
            Socket socket = serverSocket.accept();   
            //3.获取输入流，并读取客户端信息   
            InputStream is = socket.getInputStream();//字节输入流   
            InputStreamReader isr = new InputStreamReader(is);//将字节流包装为字符流
            BufferedReader br = new BufferedReader(isr);//为输入流添加缓冲   
            String info = null;   
            while((info=br.readLine())!=null){//循环读取客户端的信息    
                System.out.println("我是服务器，客户端说："+info);   
            }   
            socket.shutdownInput();//关闭输入流      
            //4.关闭资源   
            br.close();   
            isr.close();   
            is.close();   
            socket.close();   
            serverSocket.close();  
        } catch (IOException e) {   
            e.printStackTrace();  
        }   
    }
}

/*TCP客户端*/
public class Client { 
    public static void main(String[] args) {  
        try {   
            //1.创建客户端Socket,指定服务器地址和端口   
            Socket socket = new Socket("localhost",8888);   
            //2.获取输出流，向服务器端发送信息   
            OutputStream os = socket.getOutputStream();//字节输出流   
            PrintWriter pw = new PrintWriter(os);//将输出流包装成打印流   
            pw.write("用户名：admin;密码：123");   
            pw.flush();   
            socket.shutdownOutput();//关闭输出流      
            //3.关闭资源   
            pw.close();   
            os.close();   
            socket.close();  
         } catch (UnknownHostException e) {   
            e.printStackTrace();  
         } catch (IOException e) {   
             e.printStackTrace();  
         } 
    }
}

服务端:
1、创建ServerSocket对象，绑定监听端口
2、通过accept()方法监听客户端请求
3、连接建立后，通过输入流读取客户端发送的请求信息
4、通过输出流向客户端发送响应信息
5、关闭相关资源

客户端：
1、创建Socket对象，指明需要连接的服务器的地址和端口号
2、连接建立后，通过输出流向服务器端发送请求信息
3、通过输入流获取服务器相应的信息
4、关闭相关资源。

客户端的操作

服务器端的操作