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

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

1、客户端写服务端读

服务端代码

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

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

客户端代码

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

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

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

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

服务端代码

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

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

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

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

客户端代码

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

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

  1. public class Client {
  2. public static void main(String args[]) throws Exception {
  3. //为了简单起见,所有的异常都直接往外抛
  4. String host = "127.0.0.1";  //要连接的服务端IP地址
  5. int port = 8899;   //要连接的服务端对应的监听端口
  6. //与服务端建立连接
  7. Socket client = new Socket(host, port);
  8. //建立连接后就可以往服务端写数据了
  9. Writer writer = new OutputStreamWriter(client.getOutputStream());
  10. writer.write("Hello Server.");
  11. writer.write("eof");
  12. writer.flush();
  13. //写完以后进行读操作
  14. Reader reader = new InputStreamReader(client.getInputStream());
  15. char chars[] = new char[64];
  16. int len;
  17. StringBuffer sb = new StringBuffer();
  18. String temp;
  19. int index;
  20. while ((len=reader.read(chars)) != -1) {
  21. temp = new String(chars, 0, len);
  22. if ((index = temp.indexOf("eof")) != -1) {
  23. sb.append(temp.substring(0, index));
  24. break;
  25. }
  26. sb.append(new String(chars, 0, len));
  27. }
  28. System.out.println("from server: " + sb);
  29. writer.close();
  30. reader.close();
  31. client.close();
  32. }
  33. }

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

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

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

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

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

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

  1. public class Server {
  2. public static void main(String args[]) throws IOException {
  3. //为了简单起见,所有的异常信息都往外抛
  4. int port = 8899;
  5. //定义一个ServerSocket监听在端口8899上
  6. ServerSocket server = new ServerSocket(port);
  7. while (true) {
  8. //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  9. Socket socket = server.accept();
  10. //每接收到一个Socket就建立一个新的线程来处理它
  11. new Thread(new Task(socket)).start();
  12. }
  13. }
  14. /**
  15. * 用来处理Socket请求的
  16. */
  17. static class Task implements Runnable {
  18. private Socket socket;
  19. public Task(Socket socket) {
  20. this.socket = socket;
  21. }
  22. public void run() {
  23. try {
  24. handleSocket();
  25. } catch (Exception e) {
  26. e.printStackTrace();
  27. }
  28. }
  29. /**
  30. * 跟客户端Socket进行通信
  31. * @throws Exception
  32. */
  33. private void handleSocket() throws Exception {
  34. Reader reader = new InputStreamReader(socket.getInputStream());
  35. char chars[] = new char[64];
  36. int len;
  37. StringBuilder sb = new StringBuilder();
  38. String temp;
  39. int index;
  40. while ((len=reader.read(chars)) != -1) {
  41. temp = new String(chars, 0, len);
  42. if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  43. sb.append(temp.substring(0, index));
  44. break;
  45. }
  46. sb.append(temp);
  47. }
  48. System.out.println("from client: " + sb);
  49. //读完后写一句
  50. Writer writer = new OutputStreamWriter(socket.getOutputStream());
  51. writer.write("Hello Client.");
  52. writer.flush();
  53. writer.close();
  54. reader.close();
  55. socket.close();
  56. }
  57. }
  58. }

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

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

  1. public class Server {
  2. public static void main(String args[]) throws IOException {
  3. //为了简单起见,所有的异常信息都往外抛
  4. int port = 8899;
  5. //定义一个ServerSocket监听在端口8899上
  6. ServerSocket server = new ServerSocket(port);
  7. while (true) {
  8. //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  9. Socket socket = server.accept();
  10. //每接收到一个Socket就建立一个新的线程来处理它
  11. new Thread(new Task(socket)).start();
  12. }
  13. }
  14. /**
  15. * 用来处理Socket请求的
  16. */
  17. static class Task implements Runnable {
  18. private Socket socket;
  19. public Task(Socket socket) {
  20. this.socket = socket;
  21. }
  22. public void run() {
  23. try {
  24. handleSocket();
  25. } catch (Exception e) {
  26. e.printStackTrace();
  27. }
  28. }
  29. /**
  30. * 跟客户端Socket进行通信
  31. * @throws Exception
  32. */
  33. private void handleSocket() throws Exception {
  34. BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  35. StringBuilder sb = new StringBuilder();
  36. String temp;
  37. int index;
  38. while ((temp=br.readLine()) != null) {
  39. System.out.println(temp);
  40. if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  41. sb.append(temp.substring(0, index));
  42. break;
  43. }
  44. sb.append(temp);
  45. }
  46. System.out.println("from client: " + sb);
  47. //读完后写一句
  48. Writer writer = new OutputStreamWriter(socket.getOutputStream());
  49. writer.write("Hello Client.");
  50. writer.write("eof\n");
  51. writer.flush();
  52. writer.close();
  53. br.close();
  54. socket.close();
  55. }
  56. }
  57. }

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

  1. public class Client {
  2. public static void main(String args[]) throws Exception {
  3. //为了简单起见,所有的异常都直接往外抛
  4. String host = "127.0.0.1";  //要连接的服务端IP地址
  5. int port = 8899;   //要连接的服务端对应的监听端口
  6. //与服务端建立连接
  7. Socket client = new Socket(host, port);
  8. //建立连接后就可以往服务端写数据了
  9. Writer writer = new OutputStreamWriter(client.getOutputStream());
  10. writer.write("Hello Server.");
  11. writer.write("eof\n");
  12. writer.flush();
  13. //写完以后进行读操作
  14. BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
  15. StringBuffer sb = new StringBuffer();
  16. String temp;
  17. int index;
  18. while ((temp=br.readLine()) != null) {
  19. if ((index = temp.indexOf("eof")) != -1) {
  20. sb.append(temp.substring(0, index));
  21. break;
  22. }
  23. sb.append(temp);
  24. }
  25. System.out.println("from server: " + sb);
  26. writer.close();
  27. br.close();
  28. client.close();
  29. }
  30. }

4、设置超时时间

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

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

  1. public class Client {
  2. public static void main(String args[]) throws Exception {
  3. //为了简单起见,所有的异常都直接往外抛
  4. String host = "127.0.0.1";  //要连接的服务端IP地址
  5. int port = 8899;   //要连接的服务端对应的监听端口
  6. //与服务端建立连接
  7. Socket client = new Socket(host, port);
  8. //建立连接后就可以往服务端写数据了
  9. Writer writer = new OutputStreamWriter(client.getOutputStream());
  10. writer.write("Hello Server.");
  11. writer.write("eof\n");
  12. writer.flush();
  13. //写完以后进行读操作
  14. BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
  15. //设置超时间为10秒
  16. client.setSoTimeout(10*1000);
  17. StringBuffer sb = new StringBuffer();
  18. String temp;
  19. int index;
  20. try {
  21. while ((temp=br.readLine()) != null) {
  22. if ((index = temp.indexOf("eof")) != -1) {
  23. sb.append(temp.substring(0, index));
  24. break;
  25. }
  26. sb.append(temp);
  27. }
  28. } catch (SocketTimeoutException e) {
  29. System.out.println("数据读取超时。");
  30. }
  31. System.out.println("from server: " + sb);
  32. writer.close();
  33. br.close();
  34. client.close();
  35. }
  36. }

5、接收数据乱码

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

  1. public class Server {
  2. public static void main(String args[]) throws IOException {
  3. //为了简单起见,所有的异常信息都往外抛
  4. int port = 8899;
  5. //定义一个ServerSocket监听在端口8899上
  6. ServerSocket server = new ServerSocket(port);
  7. while (true) {
  8. //server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
  9. Socket socket = server.accept();
  10. //每接收到一个Socket就建立一个新的线程来处理它
  11. new Thread(new Task(socket)).start();
  12. }
  13. }
  14. /**
  15. * 用来处理Socket请求的
  16. */
  17. static class Task implements Runnable {
  18. private Socket socket;
  19. public Task(Socket socket) {
  20. this.socket = socket;
  21. }
  22. public void run() {
  23. try {
  24. handleSocket();
  25. } catch (Exception e) {
  26. e.printStackTrace();
  27. }
  28. }
  29. /**
  30. * 跟客户端Socket进行通信
  31. * @throws Exception
  32. */
  33. private void handleSocket() throws Exception {
  34. BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));
  35. StringBuilder sb = new StringBuilder();
  36. String temp;
  37. int index;
  38. while ((temp=br.readLine()) != null) {
  39. System.out.println(temp);
  40. if ((index = temp.indexOf("eof")) != -1) {//遇到eof时就结束接收
  41. sb.append(temp.substring(0, index));
  42. break;
  43. }
  44. sb.append(temp);
  45. }
  46. System.out.println("客户端: " + sb);
  47. //读完后写一句
  48. Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
  49. writer.write("你好,客户端。");
  50. writer.write("eof\n");
  51. writer.flush();
  52. writer.close();
  53. br.close();
  54. socket.close();
  55. }
  56. }
  57. }

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

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

转自:

http://elim.iteye.com/blog/1979837

转:Java Socket编程的更多相关文章

  1. Java Socket编程题库

    一.    填空题 ___ IP地址____用来标志网络中的一个通信实体的地址.通信实体可以是计算机,路由器等. 统一资源定位符URL是指向互联网"资源"的指针,由4部分组成:协议 ...

  2. Java Socket编程(转)

    Java Socket编程 对于Java Socket编程而言,有两个概念,一个是ServerSocket,一个是Socket.服务端和客户端之间通过Socket建立连接,之后它们就可以进行通信了.首 ...

  3. Java基础:三步学会Java Socket编程

    Java基础:三步学会Java Socket编程 http://tech.163.com 2006-04-10 09:17:18 来源: java-cn 网友评论11 条 论坛        第一步 ...

  4. 如何为可扩展系统进行Java Socket编程

    从简单I/O到异步非阻塞channel的Java Socket模型演变之旅 上世纪九十年代后期,我在一家在线视频游戏工资工作,在哪里我主要的工作就是编写Unix Unix Berkley Socket ...

  5. 多线程Java Socket编程示例

    package org.merit.test.socket; import java.io.BufferedReader; import java.io.IOException; import jav ...

  6. Java Socket编程基础篇

    原文地址:Java Socket编程----通信是这样炼成的 Java最初是作为网络编程语言出现的,其对网络提供了高度的支持,使得客户端和服务器的沟通变成了现实,而在网络编程中,使用最多的就是Sock ...

  7. Java Socket编程详细解说

    Java Socket编程 JavaSocketServerSocket乱码超时 Java Socket编程 对于Java Socket编程而言,有两个概念,一个是ServerSocket,一个是So ...

  8. Java Socket编程如何建立两者关系

    转自:http://developer.51cto.com/art/201003/190582.htm Java Socket编程需要大家详细的学习,有关的技术一直在不断的更新.那么要如何才能掌握好有 ...

  9. 20182332 实验四《Java Socket编程 》实验报告

    20182332 实验肆<数据结构与面向对象程序设计>实验报告 课程:<程序设计与数据结构> 班级: 1823 姓名: 盛国榕 学号:20182332 实验教师:王志强 实验日 ...

随机推荐

  1. 2019.4.25 表格表单与HTML5 && CSS3

    目录 表格 标签 属性 表格间距离 表格的内边距 表格的边框 样式 边框合并 行合并 列合并 display 表单 标签 属性 提交的网址 请求方式 input相关 扩大响应范围 字符 密码 单选框 ...

  2. phpqrcode实现二维码(含图片)

    ---恢复内容开始--- 1,http://phpqrcode.sourceforge.net/ 下载 2,解压以后只需要一个文件 3,原生php测试: <?php include 'phpqr ...

  3. ANR机制

    1.什么是ANR(Application Not Responding) 在Android中,应用程序的响应性是由ActivityManager和WindowManager系统服务监视的.当监测到以下 ...

  4. [问题解决]Fresco设置占位图不显示的问题

    [问题解决]Fresco设置占位图不显示的问题 /** * Created by diql on 2017/02/15. */ 问题说明 本来设置占位图是通过以下方法: public void set ...

  5. OSGi是什么:Java语言的动态模块系统(一)

    OSGi是什么 OSGi亦称做Java语言的动态模块系统,它为模块化应用的开发定义了一个基础架构.OSGi容器已有多家开源实现,比如Knoflerfish.Equinox和Apache的Felix.您 ...

  6. WPF通过<x:Array>直接为ListBox的ItemsSource赋值

    <!--其中sys前缀是在xmlns中引入了System的命名空间--> <ListBox.ItemsSource> <x:Array Type="{x:Typ ...

  7. iview中使用Tag时进行数据的变化和实现将输入内容转化为标签输出数组

    上代码 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title ...

  8. CSS选择器详解(二)通用选择器和高级选择器

    目录 通用选择器 高级选择器 子选择器 相邻兄弟选择器 属性选择器 通用选择器 通用选择器可以选择页面上的所有元素,并对它们应用样式,用 * 来表示. 语法: * { property1: value ...

  9. android drawable size

    ================

  10. 使用PowerShell为SSAS Role添加Membership

    PowerShell, SSAS, Role, Membership 上篇随笔使用PowerShell创建SSAS Role贴出了如何使用PowerShell批量创建Role,由于个人项目需求,创建R ...