Java Socket编程简介_动力节点Java学院整理

对于Java Socket编程而言,有两个概念,一个是ServerSocket,一个是Socket。服务端和客户端之间通过Socket建立连接,之后它们就可以进行通信了。首先ServerSocket将在服务端监听某个端口,当发现客户端有Socket来试图连接它时,它会accept该Socket的连接请求,同时在服务端建立一个对应的Socket与之进行通信。这样就有两个Socket了,客户端和服务端各一个。

对于Socket之间的通信其实很简单,服务端往Socket的输出流里面写东西,客户端就可以通过Socket的输入流读取对应的内容。Socket与Socket之间是双向连通的,所以客户端也可以往对应的Socket输出流里面写东西,然后服务端对应的Socket的输入流就可以读出对应的内容。下面来看一些服务端与客户端通信的例子:

1、客户端写服务端读

服务端代码

Java代码

 public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
 Socket socket = server.accept();
 //跟客户端建立好连接之后,我们就可以获取socket的InputStream,并从中读取客户端发过来的信息了。
 Reader reader = new InputStreamReader(socket.getInputStream());
 char chars[] = new char[64];
 int len;
 StringBuilder sb = new StringBuilder();
 while ((len=reader.read(chars)) != -1) {
  sb.append(new String(chars, 0, len));
 }
 System.out.println("from client: " + sb);
 reader.close();
 socket.close();
 server.close();
 }
 } 

服务端从Socket的InputStream中读取数据的操作也是阻塞式的,如果从输入流中没有读取到数据程序会一直在那里不动,直到客户端往Socket的输出流中写入了数据,或关闭了Socket的输出流。当然,对于客户端的Socket也是同样如此。在操作完以后,整个程序结束前记得关闭对应的资源,即关闭对应的IO流和Socket。

客户端代码

Java代码

public class Client {
 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream());
 writer.write("Hello Server.");
 writer.flush();//写完后要记得flush
 writer.close();
 client.close();
 }
 } 

对于客户端往Socket的输出流里面写数据传递给服务端要注意一点,如果写操作之后程序不是对应着输出流的关闭,而是进行其他阻塞式的操作(比如从输入流里面读数据),记住要flush一下,只有这样服务端才能收到客户端发送的数据,否则可能会引起两边无限的互相等待。在稍后讲到客户端和服务端同时读和写的时候会说到这个问题。

2、客户端和服务端同时读和写

前面已经说了Socket之间是双向通信的,它既可以接收数据,同时也可以发送数据。

服务端代码

Java代码

public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
 Socket socket = server.accept();
 //跟客户端建立好连接之后,我们就可以获取socket的InputStream,并从中读取客户端发过来的信息了。
 Reader reader = new InputStreamReader(socket.getInputStream());
 char chars[] = new char[64];
 int len;
 StringBuilder sb = new StringBuilder();
 while ((len=reader.read(chars)) != -1) {
  sb.append(new String(chars, 0, len));
 }
 System.out.println("from client: " + sb);
 //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream());
 writer.write("Hello Client.");
 writer.flush();
 writer.close();
 reader.close();
 socket.close();
 server.close();
 }
 } 

在上述代码中首先我们从输入流中读取客户端发送过来的数据,接下来我们再往输出流里面写入数据给客户端,接下来关闭对应的资源文件。而实际上上述代码可能并不会按照我们预先设想的方式运行,因为从输入流中读取数据是一个阻塞式操作,在上述的while循环中当读到数据的时候就会执行循环体,否则就会阻塞,这样后面的写操作就永远都执行不了了。除非客户端对应的Socket关闭了阻塞才会停止,while循环也会跳出。针对这种可能永远无法执行下去的情况的解决方法是while循环需要在里面有条件的跳出来,纵观上述代码,在不断变化的也只有取到的长度len和读到的数据了,len已经是不能用的了,唯一能用的就是读到的数据了。针对这种情况,通常我们都会约定一个结束标记,当客户端发送过来的数据包含某个结束标记时就说明当前的数据已经发送完毕了,这个时候我们就可以进行循环的跳出了。那么改进后的代码会是这个样子:

Java代码

 public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
 Socket socket = server.accept();
 //跟客户端建立好连接之后,我们就可以获取socket的InputStream,并从中读取客户端发过来的信息了。
 Reader reader = new InputStreamReader(socket.getInputStream());
 char chars[] = new char[64];
 int len;
 StringBuilder sb = new StringBuilder();
 String temp;
 int index;
 while ((len=reader.read(chars)) != -1) {
  temp = new String(chars, 0, len);
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  sb.append(temp.substring(0, index));
  break;
  }
  sb.append(temp);
 }
 System.out.println("from client: " + sb);
 //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream());
 writer.write("Hello Client.");
 writer.flush();
 writer.close();
 reader.close();
 socket.close();
 server.close();
 }
 } 

在上述代码中,当服务端读取到客户端发送的结束标记,即“eof”时就会结束数据的接收,终止循环,这样后续的代码又可以继续进行了。

客户端代码

Java代码

public class Client { 

 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream());
 writer.write("Hello Server.");
 writer.flush();
 //写完以后进行读操作
 Reader reader = new InputStreamReader(client.getInputStream());
 char chars[] = new char[64];
 int len;
 StringBuffer sb = new StringBuffer();
 while ((len=reader.read(chars)) != -1) {
  sb.append(new String(chars, 0, len));
 }
 System.out.println("from server: " + sb);
 writer.close();
 reader.close();
 client.close();
 }
 } 

在上述代码中我们先是给服务端发送了一段数据,之后读取服务端返回来的数据,跟之前的服务端一样在读的过程中有可能导致程序一直挂在那里,永远跳不出while循环。这段代码配合服务端的第一段代码就正好让我们分析服务端永远在那里接收数据,永远跳不出while循环,也就没有之后的服务端返回数据给客户端,客户端也就不可能接收到服务端返回的数据。解决方法如服务端第二段代码所示,在客户端发送数据完毕后,往输出流里面写入结束标记告诉服务端数据已经发送完毕了,同样服务端返回数据完毕后也发一个标记告诉客户端。那么修改后的客户端代码就应该是这个样子:

Java代码

public class Client {
 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream());
 writer.write("Hello Server.");
 writer.write("eof");
 writer.flush();
 //写完以后进行读操作
 Reader reader = new InputStreamReader(client.getInputStream());
 char chars[] = new char[64];
 int len;
 StringBuffer sb = new StringBuffer();
 String temp;
 int index;
 while ((len=reader.read(chars)) != -1) {
  temp = new String(chars, 0, len);
  if ((index = temp.indexOf("eof")) != -1) {
  sb.append(temp.substring(0, index));
  break;
  }
  sb.append(new String(chars, 0, len));
 }
 System.out.println("from server: " + sb);
 writer.close();
 reader.close();
 client.close();
 }
 } 

我们日常使用的比较多的都是这种客户端发送数据给服务端,服务端接收数据后再返回相应的结果给客户端这种形式。只是客户端和服务端之间不再是这种一对一的关系,而是下面要讲到的多个客户端对应同一个服务端的情况。

      3、多个客户端连接同一个服务端

像前面讲的两个例子都是服务端接收一个客户端的请求之后就结束了,不能再接收其他客户端的请求了,这往往是不能满足我们的要求的。通常我们会这样做:

Java代码

public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 while (true) {
  //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
 Socket socket = server.accept();
  //跟客户端建立好连接之后,我们就可以获取socket的InputStream,并从中读取客户端发过来的信息了。
 Reader reader = new InputStreamReader(socket.getInputStream());
  char chars[] = new char[64];
  int len;
  StringBuilder sb = new StringBuilder();
  String temp;
  int index;
  while ((len=reader.read(chars)) != -1) {
  temp = new String(chars, 0, len);
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
   sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
  System.out.println("from client: " + sb);
  //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream());
  writer.write("Hello Client.");
  writer.flush();
  writer.close();
  reader.close();
  socket.close();
 }
 }
 } 

在上面代码中我们用了一个死循环,在循环体里面ServerSocket调用其accept方法试图接收来自客户端的连接请求。当没有接收到请求的时候,程序会在这里阻塞直到接收到来自客户端的连接请求,之后会跟当前建立好连接的客户端进行通信,完了后会接着执行循环体再次尝试接收新的连接请求。这样我们的ServerSocket就能接收来自所有客户端的连接请求了,并且与它们进行通信了。这就实现了一个简单的一个服务端与多个客户端进行通信的模式。

上述例子中虽然实现了一个服务端跟多个客户端进行通信,但是还存在一个问题。在上述例子中,我们的服务端处理客户端的连接请求是同步进行的,每次接收到来自客户端的连接请求后,都要先跟当前的客户端通信完之后才能再处理下一个连接请求。这在并发比较多的情况下会严重影响程序的性能,为此,我们可以把它改为如下这种异步处理与客户端通信的方式:

Java代码

public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 while (true) {
  //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  Socket socket = server.accept();
  //每接收到一个Socket就建立一个新的线程来处理它
  new Thread(new Task(socket)).start();
 }
 }
 /**
 * 用来处理Socket请求的
 */
 static class Task implements Runnable {
 private Socket socket;
 public Task(Socket socket) {
  this.socket = socket;
 }
 public void run() {
  try {
  handleSocket();
  } catch (Exception e) {
  e.printStackTrace();
  }
 }
 /**
 * 跟客户端Socket进行通信
 * @throws Exception
 */
 private void handleSocket() throws Exception {
  Reader reader = new InputStreamReader(socket.getInputStream());
  char chars[] = new char[64];
  int len;
  StringBuilder sb = new StringBuilder();
  String temp;
  int index;
  while ((len=reader.read(chars)) != -1) {
  temp = new String(chars, 0, len);
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
  System.out.println("from client: " + sb);
  //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream());
  writer.write("Hello Client.");
  writer.flush();
  writer.close();
  reader.close();
  socket.close();
 }
 }
 } 

在上面代码中,每次ServerSocket接收到一个新的Socket连接请求后都会新起一个线程来跟当前Socket进行通信,这样就达到了异步处理与客户端Socket进行通信的情况。

在从Socket的InputStream中接收数据时,像上面那样一点点的读就太复杂了,有时候我们就会换成使用BufferedReader来一次读一行,如:

Java代码

 public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 while (true) {
  //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  Socket socket = server.accept();
  //每接收到一个Socket就建立一个新的线程来处理它
  new Thread(new Task(socket)).start();
 }
 }
 /**
 * 用来处理Socket请求的
 */
 static class Task implements Runnable {
 private Socket socket;
 public Task(Socket socket) {
  this.socket = socket;
 }
 public void run() {
  try {
  handleSocket();
  } catch (Exception e) {
  e.printStackTrace();
  }
 }
 /**
 * 跟客户端Socket进行通信
 * @throws Exception
 */
 private void handleSocket() throws Exception {
  BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  StringBuilder sb = new StringBuilder();
  String temp;
  int index;
  while ((temp=br.readLine()) != null) {
  System.out.println(temp);
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
  System.out.println("from client: " + sb);
  //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream());
  writer.write("Hello Client.");
  writer.write("eof\n");
  writer.flush();
  writer.close();
  br.close();
  socket.close();
 }
 }
 } 

这个时候需要注意的是,BufferedReader的readLine方法是一次读一行的,这个方法是阻塞的,直到它读到了一行数据为止程序才会继续往下执行,那么readLine什么时候才会读到一行呢?直到程序遇到了换行符或者是对应流的结束符readLine方法才会认为读到了一行,才会结束其阻塞,让程序继续往下执行。所以我们在使用BufferedReader的readLine读取数据的时候一定要记得在对应的输出流里面一定要写入换行符(流结束之后会自动标记为结束,readLine可以识别),写入换行符之后一定记得如果输出流不是马上关闭的情况下记得flush一下,这样数据才会真正的从缓冲区里面写入。对应上面的代码我们的客户端程序应该这样写:

Java代码

 public class Client {
 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream());
 writer.write("Hello Server.");
 writer.write("eof\n");
 writer.flush();
 //写完以后进行读操作
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
 StringBuffer sb = new StringBuffer();
 String temp;
 int index;
 while ((temp=br.readLine()) != null) {
  if ((index = temp.indexOf("eof")) != -1) {
  sb.append(temp.substring(0, index));
  break;
  }
  sb.append(temp);
 }
 System.out.println("from server: " + sb);
 writer.close();
 br.close();
 client.close();
 }
 } 

  4、设置超时时间

假设有这样一种需求,我们的客户端需要通过Socket从服务端获取到XX信息,然后给用户展示在页面上。我们知道Socket在读数据的时候是阻塞式的,如果没有读到数据程序会一直阻塞在那里。在同步请求的时候我们肯定是不能允许这样的情况发生的,这就需要我们在请求达到一定的时间后控制阻塞的中断,让程序得以继续运行。Socket为我们提供了一个setSoTimeout()方法来设置接收数据的超时时间,单位是毫秒。当设置的超时时间大于0,并且超过了这一时间Socket还没有接收到返回的数据的话,Socket就会抛出一个SocketTimeoutException。

假设我们需要控制我们的客户端在开始读取数据10秒后还没有读到数据就中断阻塞的话我们可以这样做:

Java代码

public class Client {
 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream());
 writer.write("Hello Server.");
 writer.write("eof\n");
 writer.flush();
 //写完以后进行读操作
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
 //设置超时间为10秒
 client.setSoTimeout(10*1000);
 StringBuffer sb = new StringBuffer();
 String temp;
 int index;
 try {
  while ((temp=br.readLine()) != null) {
  if ((index = temp.indexOf("eof")) != -1) {
   sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
 } catch (SocketTimeoutException e) {
  System.out.println("数据读取超时。");
 }
 System.out.println("from server: " + sb);
 writer.close();
 br.close();
 client.close();
 }
 } 

5、接收数据乱码

对于这种服务端或客户端接收中文乱码的情况通常是因为数据发送时使用的编码跟接收时候使用的编码不一致。比如有下面这样一段服务端代码:

Java代码

 public class Server {
 public static void main(String args[]) throws IOException {
 //为了简单起见,所有的异常信息都往外抛
 int port = 8899;
 //定义一个ServerSocket监听在端口8899上
 ServerSocket server = new ServerSocket(port);
 while (true) {
  //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  Socket socket = server.accept();
  //每接收到一个Socket就建立一个新的线程来处理它
  new Thread(new Task(socket)).start();
 }
 }
 /**
 * 用来处理Socket请求的
 */
 static class Task implements Runnable {
 private Socket socket;
 public Task(Socket socket) {
  this.socket = socket;
 }
 public void run() {
  try {
  handleSocket();
  } catch (Exception e) {
  e.printStackTrace();
  }
 }
 /**
 * 跟客户端Socket进行通信
 * @throws Exception
 */
 private void handleSocket() throws Exception {
  BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));
  StringBuilder sb = new StringBuilder();
  String temp;
  int index;
  while ((temp=br.readLine()) != null) {
  System.out.println(temp);
  if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
  System.out.println("客户端: " + sb);
  //读完后写一句
 Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
  writer.write("你好,客户端。");
  writer.write("eof\n");
  writer.flush();
  writer.close();
  br.close();
  socket.close();
 }
 }
 } 

这里用来测试我就弄的混乱了一点。在上面服务端代码中我们在定义输入流的时候明确定义了使用GBK编码来读取数据,而在定义输出流的时候明确指定了将使用UTF-8编码来发送数据。如果客户端上送数据的时候不以GBK编码来发送的话服务端接收的数据就很有可能会乱码;同样如果客户端接收数据的时候不以服务端发送数据的编码,即UTF-8编码来接收数据的话也极有可能会出现数据乱码的情况。所以,对于上述服务端代码,为使我们的程序能够读取对方发送过来的数据,而不出现乱码情况,我们的客户端应该是这样的:

Java代码

public class Client {
 public static void main(String args[]) throws Exception {
 //为了简单起见,所有的异常都直接往外抛
 String host = "127.0.0.1"; //要连接的服务端IP地址
 int port = 8899; //要连接的服务端对应的监听端口
 //与服务端建立连接
 Socket client = new Socket(host, port);
 //建立连接后就可以往服务端写数据了
 Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK");
 writer.write("你好,服务端。");
 writer.write("eof\n");
 writer.flush();
 //写完以后进行读操作
 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8"));
 //设置超时间为10秒
 client.setSoTimeout(10*1000);
 StringBuffer sb = new StringBuffer();
 String temp;
 int index;
 try {
  while ((temp=br.readLine()) != null) {
  if ((index = temp.indexOf("eof")) != -1) {
   sb.append(temp.substring(0, index));
   break;
  }
  sb.append(temp);
  }
 } catch (SocketTimeoutException e) {
  System.out.println("数据读取超时。");
 }
 System.out.println("服务端: " + sb);
 writer.close();
 br.close();
 client.close();
 }
 } 
(0)

相关推荐

  • Java Socket编程详解及示例代码

    Socket,又称为套接字,Socket是计算机网络通信的基本的技术之一.如今大多数基于网络的软件,如浏览器,即时通讯工具甚至是P2P下载都是基于Socket实现的.本文会介绍一下基于TCP/IP的Socket编程,并且如何写一个客户端/服务器程序. 餐前甜点 Unix的输入输出(IO)系统遵循Open-Read-Write-Close这样的操作范本.当一个用户进程进行IO操作之前,它需要调用Open来指定并获取待操作文件或设备读取或写入的权限.一旦IO操作对象被打开,那么这个用户进程可以对这个

  • Java Socket聊天室编程(一)之利用socket实现聊天之消息推送

    相关阅读:Java Socket聊天室编程(二)之利用socket实现单聊聊天室 网上已经有很多利用socket实现聊天的例子了,但是我看过很多,多多少有一些问题存在. 这里我将实现一个比较完整的聊天例子,并解释其中的逻辑. 由于socket这一块比较大,所以我将分出几篇来写一个比较完整的socket例子. 这里我们先来实现一个最简单的,服务器与客户端通讯,实现消息推送的功能. 目的:服务器与客户端建立连接,客户端可以向服务器发送消息,服务器可以向客户端推送消息. 1,使用java建立socke

  • Java套接字(Socket)网络编程入门

    网络应用模式主要有: 主机/终端模式:集中计算,集中管理: 客户机/服务器(Client/Server,简称C/S)模式:分布计算,分布管理: 浏览器/服务器模式:利用Internet跨平台. www(万维网)就是建立在客户机/服务器模式上,以HTML语言和HTTP协议为基础,能够提供各种Internet服务的信息浏览系统.网络信息放在主机的不同位置,www服务器利用超文本链路链接各项信息.www客户机(浏览器Brower)负责与服务器建立联系,向服务器发送请求,处理HTML超媒体,提供图形用户

  • Java Socket编程实例(四)- NIO TCP实践

    一.回传协议接口和TCP方式实现: 1.接口: import java.nio.channels.SelectionKey; import java.io.IOException; public interface EchoProtocol { void handleAccept(SelectionKey key) throws IOException; void handleRead(SelectionKey key) throws IOException; void handleWrite(

  • 简单讲解Java的Socket网络编程的多播与广播实现

    在Java中,我们可以有很多种方法来发送和接收数据.有的方法比较靠近底层,有些问题就需要程序员自己去解决,而有些方法抽象层次比较高,很方便地就可以拿来使用.这些处理数据的方法根据抽象层次由低到高分别有: 1.手动编码:使用位运算逐个自己编码和解析. 2.利用流来自动编码:组合使用OutputStream和ByteArrayOutputStream. 3.序列化:将数据放入一个数据对象中,直接将这个对象序列化后发送. 使用起来很方便,但要注意效率的损失,以及接收方也要使用Java. 4.RMI:将

  • Java Socket聊天室编程(二)之利用socket实现单聊聊天室

    在上篇文章Java Socket聊天室编程(一)之利用socket实现聊天之消息推送中我们讲到如何使用socket让服务器和客户端之间传递消息,达到推送消息的目的,接下来我将写出如何让服务器建立客户端与客户端之间的通讯. 其实就是建立一个一对一的聊天通讯. 与上一篇实现消息推送的代码有些不同,在它上面加以修改的. 如果没有提到的方法或者类则和上一篇一模一样. 1,修改实体类(服务器端和客户端的实体类是一样的) 1,UserInfoBean 用户信息表 public class UserInfoB

  • Java Socket编程简介_动力节点Java学院整理

    对于Java Socket编程而言,有两个概念,一个是ServerSocket,一个是Socket.服务端和客户端之间通过Socket建立连接,之后它们就可以进行通信了.首先ServerSocket将在服务端监听某个端口,当发现客户端有Socket来试图连接它时,它会accept该Socket的连接请求,同时在服务端建立一个对应的Socket与之进行通信.这样就有两个Socket了,客户端和服务端各一个. 对于Socket之间的通信其实很简单,服务端往Socket的输出流里面写东西,客户端就可以

  • Java Socket编程笔记_动力节点Java学院整理

    对于即时类应用或者即时类的游戏,HTTP协议很多时候无法满足于我们的需求.这会,Socket对于我们来说就非常实用了.下面是本次学习的笔记.主要分异常类型.交互原理.Socket.ServerSocket.多线程这几个方面阐述. 异常类型 在了解Socket的内容之前,先要了解一下涉及到的一些异常类型.以下四种类型都是继承于IOException,所以很多之后直接弹出IOException即可. UnkownHostException:    主机名字或IP错误 ConnectException

  • Java字符编码简介_动力节点Java学院整理

    1. 概述 本文主要包括以下几个方面:编码基本知识,Java,系统软件,url,工具软件等. 在下面的描述中,将以"中文"两个字为例,经查表可以知道其GB2312编码是"d6d0 cec4",Unicode编码为"4e2d 6587",UTF编码就是"e4b8ad e69687".注意,这两个字没有iso8859-1编码,但可以用iso8859-1编码来"表示". 2. 编码基本知识 最早的编码是iso88

  • Java中Random简介_动力节点Java学院整理

    Java中存在着两种Random函数: 一.java.lang.Math.Random; 调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布.例子如下: package IO; import java.util.Random; public class TestRandom { public static void main(String[] a

  • Java 异步编程实践_动力节点Java学院整理

    什么是异步?为什么要用它? 异步编程提供了一个非阻塞的,事件驱动的编程模型. 这种编程模型利用系统中多核执行任务来提供并行,因此提供了应用的吞吐率.此处吞吐率是指在单位时间内所做任务的数量. 在这种编程方式下, 一个工作单元将独立于主应用线程而执行, 并且会将它的状态通知调用线程:成功,处理中或者失败. 我们需要异步来消除阻塞模型.其实异步编程模型可以使用同样的线程来处理多个请求, 这些请求不会阻塞这个线程.想象一个应用正在使用的线程正在执行任务, 然后等待任务完成才进行下一步. log框架就是

  • Nginx简介_动力节点Java学院整理

    1.什么是Nginx Nginx来自俄罗斯的Igor Sysoev在为Rambler Media(http://www.rambler.ru/)工作期间,使用C语言开发了Nginx.Nginx作为Web服务器,一直为俄罗斯著名的门户网站Rambler Media提供着出色.稳定的服务. Igor Sysoev将Nginx的代码开源,并且赋予其最自由的2-clause BSD-like license许可证.由于Nginx使用基于事件驱动的架构能够并发处理百万级别的TCP连接,高度模块化的设计和自

  • Java Map简介_动力节点Java学院整理

    Map简介 将键映射到值的对象.一个映射不能包含重复的键:每个键最多只能映射到一个值.此接口取代 Dictionary 类,后者完全是一个抽象类,而不是一个接口. Map 接口提供三种collection 视图,允许以键集.值集或键-值映射关系集的形式查看某个映射的内容.映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序.某些映射实现可明确保证其顺序,如 TreeMap 类:另一些映射实现则不保证顺序,如HashMap 类. 注:将可变对象用作映射键时必须格外小心.当对

  • Java中Object toString方法简介_动力节点Java学院整理

    一.Object类介绍  Object类在Java里面是一个比较特殊的类,JAVA只支持单继承,子类只能从一个父类来继承,如果父类又是从另外一个父类继承过来,那他也只能有一个父类,父类再有父类,那也只能有一个,JAVA为了组织这个类组织得比较方便,它提供了一个最根上的类,相当于所有的类都是从这个类继承,这个类就叫Object.所以Object类是所有JAVA类的根基类,是所有JAVA类的老祖宗.所有的类,不管是谁,都是从它继承下来的. 二.toString方法介绍  一个字符串和另外一种类型连接

  • Java Set简介_动力节点Java学院整理

    1. 概述   Java 中的Set和正好和数学上直观的集(set)的概念是相同的.Set最大的特性就是不允许在其中存放的元素是重复的.根据这个特点,我们就可以使用Set 这个接口来实现前面提到的关于商品种类的存储需求.Set 可以被用来过滤在其他集合中存放的元素,从而得到一个没有包含重复新的集合. 2. 常用方法 按照定义,Set 接口继承 Collection 接口,而且它不允许集合中存在重复项.所有原始方法都是现成的,没有引入新方法.具体的 Set 实现类依赖添加的对象的 equals()

  • RandomAccessFile简介_动力节点Java学院整理

    RandomAccessFile RandomAccessFile 是随机访问文件(包括读/写)的类.它支持对文件随机访问的读取和写入,即我们可以从指定的位置读取/写入文件数据. 需要注意的是,RandomAccessFile 虽然属于java.io包,但它不是InputStream或者OutputStream的子类:它也不同于FileInputStream和FileOutputStream. FileInputStream 只能对文件进行读操作,而FileOutputStream 只能对文件进

随机推荐