Socket通信 :
1.TCP协议是面向对象连接、可靠的、有序的,以字节流的方式发送数据。
2.基于TCP协议实现网络通信的类:
Socket通信模型用下图所示:
1、在服务端建立一个ServerSocket,绑定相应的端口,并且在指定的端口进行侦听,等待客户端的连接。
2、当客户端创建连接Socket并且向服务端发送请求。
3、服务器收到请求,并且接受客户端的请求信息。一旦接收到客户端的连接请求后,会创建一个链接socket,用来与客户端的socket进行通信。 通过相应的输入/输出流进行数据的交换,数据的发送接收以及数据的响应等等。
4、当客户端和服务端通信完毕后,需要分别关闭socket,结束通信。
Socket通信实现步骤:
了解Socket通信模型后,就可以简化出Socket通信的实现步骤:
1.创建ServerSocket和Socket
2.打开链接到Socket的输入/输出流
3.按照协议对Socket进行读/写操作
4.关闭输入输出流、关闭Socket
ServerSocket常用方法:
Socket常用方法:
通过写一个用户登录的小程序,来直观了解Socket通信的工作过程,首先我们得知道在客户端和服务器通信时,两者的运作流程是如何的,先从服务器入手。
服务端:
1、创建ServerSocket对象,绑定监听端口
2、通过accept()方法监听客户端请求
3、连接建立后,通过输入流读取客户端发送的请求信息
4、通过输出流向客户端发送响应信息
5、关闭相关资源
那么用户登录的测试案例的服务器端类可以这样(待完善):
- //1.创建一个服务器端的Socket,即ServerSocket,指定绑定的端口
- ServerSocket ss = new ServerSocket(8888);
- //2.调用accept方法开始监听,等待客户端的连接
- System.out.println("服务器即将启动,等待客户端的连接...");
- Socket so = ss.accept(); //accept方法返回Socket实例
- //3.获取一个输入流,并读取客户端信息
- InputStream is = so.getInputStream(); //字节输入流
- InputStreamReader isr = new InputStreamReader(is); //将字节输入流包装成字符输入流
- BufferedReader br = new BufferedReader(isr); //加上缓冲流,提高效率
- String info = null;
- while ((info = br.readLine()) != null) { //循环读取客户端信息
- System.out.println("我是服务器,客户端说:" + info);
- }
- so.shutdownInput(); //关闭输入流
- //4.关闭资源
- br.close();
- isr.close();
- is.close();
- so.close();
- ss.close();
接着我们看一下客户端的运作过程,其实和服务器端差不多,但是其中的区别还是要清楚的。
客户端:
1、创建Socket对象,指明需要连接的服务器的地址和端口号
2、连接建立后,通过输出流向服务器端发送请求信息
3、通过输入流获取服务器相应的信息
4、关闭相关资源。
那么用户登录的测试案例的客户端类可以这样(待完善):
- //1.创建客户端Socket,指定服务器地址和端口
- Socket so = new Socket("localhost", 8888); //端口号要和服务器端相同
- //2.获取输出流,向服务器端发送登录的信息
- OutputStream os = so.getOutputStream(); //字节输出流
- PrintWriter pw = new PrintWriter(os); //字符输出流
- BufferedWriter bw = new BufferedWriter(pw); //加上缓冲流
- bw.write("用户名:admin;密码:123");
- bw.flush();
- so.shutdownOutput(); //关闭输出流
- //3.关闭资源
- bw.close();
- pw.close();
- os.close();
- so.close();
这样服务端和客户端就能进行最简单的通信了,目前这个还不能实现交互,下面会讲两者的交互。
运行一下,看看服务器端是否能接收到客户端发送的信息了呢...
分别启动服务器和客户端,注意必须先启动服务器再启动客户端,否则客户端找不到资源报错:
完善用户登录之服务器响应客户端
在上述的例子中,服务器和客户端仅仅只是相互可以通信,但服务器对于接收到的客户端信息并没有向客户端响应,客户端没有接收到服务器端的任何信息,这明显是不完善不友好的,在这里将对刚刚的例子进行完善,完成服务器对客户端的响应。
修改后的服务器端:
- //1.创建一个服务器端的Socket,即ServerSocket,指定绑定的端口
- ServerSocket ss = new ServerSocket(8888);
- //2.调用accept方法开始监听,等待客户端的连接
- System.out.println("服务器即将启动,等待客户端的连接...");
- Socket so = ss.accept(); //accept方法返回Socket实例
- //3.获取一个输入流,并读取客户端信息
- InputStream is = so.getInputStream(); //字节输入流
- InputStreamReader isr = new InputStreamReader(is); //将字节输入流包装成字符输入流
- BufferedReader br = new BufferedReader(isr); //加上缓冲流,提高效率
- String info = null;
- while ((info = br.readLine()) != null) { //循环读取客户端信息
- System.out.println("我是服务器,客户端说:" + info);
- }
- so.shutdownInput(); //关闭输入流
- //4.获取一个输出流,向客户端输出信息,响应客户端的请求
- OutputStream os = so.getOutputStream(); //字节输出流
- PrintWriter pw = new PrintWriter(os); //字符输出流
- BufferedWriter bw = new BufferedWriter(pw); //缓冲输出流
- bw.write("欢迎您!");
- bw.newLine();
- bw.flush();
- //5.关闭资源
- os.close();
- pw.close();
- bw.close();
- br.close();
- isr.close();
- is.close();
- so.close();
- ss.close();
修改后的客户端:
- //1.创建客户端Socket,指定服务器地址和端口
- Socket so = new Socket("localhost", 8888); //端口号要和服务器端相同
- //2.获取输出流,向服务器端发送登录的信息
- OutputStream os = so.getOutputStream(); //字节输出流
- PrintWriter pw = new PrintWriter(os); //字符输出流
- BufferedWriter bw = new BufferedWriter(pw); //加上缓冲流
- bw.write("用户名:admin;密码:123");
- bw.flush();
- so.shutdownOutput(); //关闭输出流
- //3.获取输入流,得到服务端的响应信息
- InputStream is = so.getInputStream();
- InputStreamReader isr = new InputStreamReader(is);
- BufferedReader br = new BufferedReader(isr);
- String info = null;
- while ((info = br.readLine()) != null) {
- System.out.println("我是客户端,服务器说:" + info);
- }
- //4.关闭资源
- bw.close();
- pw.close();
- os.close();
- so.close();
运行结果:
应用多线程来实现服务器与多客户端之间的通信。<关于多线程更多的内容以后再总结>
多线程基本步骤:
1.服务器端创建ServerSocket,循环调用accept()等待客户端连接。
2.客户端创建一个socket并请求和服务器端连接。
3.服务器端接收客户端请求,创建socket与该客户建立专线连接。
4.建立连接的两个socket在一个单独的线程上对话。
5.服务器端继续等待新的连接。
------------------------------------------------------------------------------
下面再将上述的例子修改成多线程的通信
新建一个服务器线程处理类ServerThread,该类继承Thread类:
- /*
- * 服务器线程处理类
- */
- public class ServerThread extends Thread {
- // 和本线程相关的Socket
- Socket so = null;
- public ServerThread(Socket socket) {// 初始化与本线程相关的Socket
- so = socket;
- }
- // 线程执行的操作,响应客户端的请求
- public void run() {// 重写父类的run方法
- InputStream is = null;
- InputStreamReader isr = null;
- BufferedReader br = null;
- OutputStream os = null;
- PrintWriter pw = null;
- BufferedWriter bw = null;
- try {
- // 3.获取一个输入流,并读取客户端信息
- is = so.getInputStream();// 字节输入流
- isr = new InputStreamReader(is);// 将字节输入流包装成字符输入流
- br = new BufferedReader(isr);// 加上缓冲流,提高效率
- String info = null;
- while ((info = br.readLine()) != null) {// 循环读取客户端信息
- System.out.println("我是服务器,客户端说:" + info);
- }
- so.shutdownInput();// 关闭输入流
- // 4.获取一个输出流,向客户端输出信息,响应客户端的请求
- os = so.getOutputStream();// 字节输出流
- pw = new PrintWriter(os);// 字符输出流
- bw = new BufferedWriter(pw);// 缓冲输出流
- bw.write("欢迎您!");
- bw.newLine();
- bw.flush();
- } catch (IOException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } finally {
- // 5.关闭资源
- try {
- if (os != null)
- os.close();
- if (pw != null)
- pw.close();
- if (bw != null)
- bw.close();
- if (br != null)
- br.close();
- if (isr != null)
- isr.close();
- if (is != null)
- is.close();
- if (!so.isClosed())
- so.close();
- } catch (IOException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
- }
- }
<解 惑>关闭资源为何要加一个判断条件:不为空 ???
<回 答>这是一种正确、严谨的写法。 验证非NULL是编码中很重要的一环。假如本来就是NULL,这是调用各自的close()方法是会报错的。 如果在实例化这些对象时出错导致这些对象为NULL,或是实例化没问题但中途出了什么异常导致这些对象为NULL,都会在未经验证非NULL前尝试调用close()方法关闭时报错。
<提 示>集中异常处理的快捷键:Alt+shift+z
服务器端:
- try {
- //1.创建一个服务器端的Socket,即ServerSocket,指定绑定的端口
- ServerSocket ss = new ServerSocket(8888);
- System.out.println("服务器即将启动,等待客户端的连接...");
- Socket so = null;
- //记录客户端的数量
- int count = 0;
- //循环侦听等待客户端的连接
- while (true) {
- //2.调用accept方法开始监听,等待客户端的连接
- so = ss.accept(); //accept方法返回Socket实例
- //创建一个新的线程
- ServerThread st = new ServerThread(so);
- //启动线程,执行与客户端的交互
- st.start(); //注意是start不是run
- count++;
- System.out.println("此时客户端数量为:" + count);
- InetAddress add = so.getInetAddress();
- System.out.println("当前客户端的ip地址为" + add.getHostAddress());
- }
- } catch(IOException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
多个客户端的运行结果:
这样一个简单的多线程通信就完成了,这个多线程还不是并行操作的,要实现并行操作可以按照下面的思路:
主线程负责创建socket
* 一个线程用来读取
* 一个线程用来写入,用两个内部类
* 要用多线程实现,send线程和recived线程同时访问buff数据区。
* 发送完成后notify,接收线程。接收线程自身wait
* 接收的说,我先wait一下,可能缓存中还没有数据,我会拿到空值得。
* 发送的说Ok,我先写,写完了我notifyall你。我就一直锁着,这样默契的合作了。
变成并行处理了 每个客户端连接服务端都会产生一个新的socket。
< 具体代码还没写,大家可以自行摸索。。。写完了再更新>
---------------点击查看更多关于Socket信息------------------
来源: http://www.cnblogs.com/hysum/p/7531529.html