加载中，请稍候...
加载中，请稍候...
商品编号：
京 东 价：
[定价：￥]
在线客服：
服务支持：
Java TCP/IP Socket编程（原书第2版）
加载中，请稍候...
商品介绍加载中...
扫一扫，精彩好书免费看
　　我觉得本书做了很好的工作，包括简明扼要地抓住关键问题，提供了非常好的实例，因此可以作为重要主题的参考资料。我认为本书适合希望快速地掌握Java网络编程的开发者，也可以作为学生的补充读物。　　——Robere&Brunner，美国国家超级计算应用中心（NCSA）
京东商城向您保证所售商品均为正品行货，京东自营商品开具机打发票或电子发票。
凭质保证书及京东商城发票，可享受全国联保服务（奢侈品、钟表除外；奢侈品、钟表由京东联系保修，享受法定三包售后服务），与您亲临商场选购的商品享受相同的质量保证。京东商城还为您提供具有竞争力的商品价格和，请您放心购买！
注：因厂家会在没有任何提前通知的情况下更改产品包装、产地或者一些附件，本司不能确保客户收到的货物与商城图片、产地、附件说明完全一致。只能确保为原厂正货！并且保证与当时市场上同样主流新品一致。若本商城没有及时更新，请大家谅解！
权利声明：京东上的所有商品信息、客户评价、商品咨询、网友讨论等内容，是京东重要的经营资源，未经许可，禁止非法转载使用。
注：本站商品信息均来自于合作方，其真实性、准确性和合法性由信息拥有者（合作方）负责。本站不提供任何保证，并不承担任何法律责任。
加载中，请稍候...
mandy_xiaomai(上海)
qg_xiaoguang(广东)
llwwei168(甘肃)
妍妍星(北京)
水成(广东)
iq527(浙江)
皮紫皮(北京)
cgeorgel(北京)
sunny_(北京)
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
浏览了该商品的用户还浏览了
加载中，请稍候...
七日畅销榜
新书热卖榜
iframe(src='///ns.html?id=GTM-T947SH', height='0', width='0', style='display: visibility:')java网络编程，通过TCP,Socket实现多对一的局域网聊天室
可以实现多个客户端连接服务器，服务器接收到信息就会把信息广播到所有的客户端
这是服务器端的代码
import java.awt.BorderL
import java.awt.FlowL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.awt.event.WindowA
import java.awt.event.WindowE
import java.net.S
import java.util.L
import javax.swing.JB
import javax.swing.JF
import javax.swing.JOptionP
import javax.swing.JP
import javax.swing.JScrollP
import javax.swing.JTextA
import javax.swing.JTextF
/*这个类是服务器端的UI*/
public class ServerUI extends JFrame {
public static void main(String[] args) {
ServerUI serverUI = new ServerUI();
public JButton btS//启动服务器
public JButton btS//发送信息按钮
public JTextField tfS//需要发送的文本信息
public JTextArea taS//信息展示
public S//用来监听客户端连接
static List&Socket&//保存连接到服务器的客户端
public ServerUI() {
super("服务器端");
btStart = new JButton("启动服务");
btSend = new JButton("发送信息");
tfSend = new JTextField(10);
taShow = new JTextArea();
btStart.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
server = new Server(ServerUI.this);
btSend.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
server.sendMsg(tfSend.getText());
tfSend.setText("");
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
int a = JOptionPane.showConfirmDialog(null, "确定关闭吗？", "温馨提示",
JOptionPane.YES_NO_OPTION);
if (a == 1) {
server.closeServer();
System.exit(0); // 关闭
JPanel top = new JPanel(new FlowLayout());
top.add(tfSend);
top.add(btSend);
top.add(btStart);
this.add(top, BorderLayout.SOUTH);
final JScrollPane sp = new JScrollPane();
sp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
sp.setViewportView(this.taShow);
this.taShow.setEditable(false);
this.add(sp, BorderLayout.CENTER);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(400, 300);
this.setLocation(100, 200);
this.setVisible(true);
import java.io.BufferedR
import java.io.IOE
import java.io.PrintW
import java.net.ServerS
import java.net.S
import java.util.ArrayL
/*这个类是服务器端的等待客户端连接*/
public class Server extends Thread {
public Server(ServerUI ui) {
this.start();
public void run() {
ss = new ServerSocket(1228);
ui.clients=new ArrayList&Socket&();
println("启动服务器成功：端口1228");
while (true) {
println("等待客户端");
Socket client = ss.accept();
ui.clients.add(client);
println("连接成功" + client.toString());
new ListenerClient(ui, client);
} catch (IOException e) {
println("启动服务器失败：端口1228");
println(e.toString());
e.printStackTrace();
public synchronized void sendMsg(String msg) {
for (int i = 0; i & ui.clients.size(); i++) {
Socket client = ui.clients.get(i);
writer = new PrintWriter(client.getOutputStream(), true);
writer.println(msg);
} catch (Exception e) {
println(e.toString());
public void println(String s) {
if (s != null) {
this.ui.taShow.setText(this.ui.taShow.getText() + s + "\n");
System.out.println(s + "\n");
public void closeServer() {
if (ss != null)
ss.close();
if (reader != null)
reader.close();
if (writer != null)
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
import java.io.BufferedR
import java.io.IOE
import java.io.InputStreamR
import java.io.PrintW
import java.net.S
/*这个类是服务器端的等待客户端发送信息*/
public class ListenerClient extends Thread {
public ListenerClient(ServerUI ui, Socket client) {
this.client=
this.start();
//为每一个客户端创建线程等待接收信息，然后把信息广播出去
public void run() {
String msg = "";
while (true) {
reader = new BufferedReader(new InputStreamReader(
client.getInputStream()));
writer = new PrintWriter(client.getOutputStream(), true);
msg = reader.readLine();
sendMsg(msg);
} catch (IOException e) {
println(e.toString());
// e.printStackTrace();
if (msg != null && msg.trim() != "") {
println("&&" + msg);
//把信息广播到所有用户
public synchronized void sendMsg(String msg) {
for (int i = 0; i & ui.clients.size(); i++) {
Socket client = ui.clients.get(i);
writer = new PrintWriter(client.getOutputStream(), true);
writer.println(msg);
} catch (Exception e) {
println(e.toString());
public void println(String s) {
if (s != null) {
this.ui.taShow.setText(this.ui.taShow.getText() + s + "\n");
System.out.println(s + "\n");
客户端代码
import java.awt.BorderL
import java.awt.FlowL
import java.awt.event.ActionE
import java.awt.event.ActionL
import java.awt.event.WindowA
import java.awt.event.WindowE
import javax.swing.JB
import javax.swing.JF
import javax.swing.JOptionP
import javax.swing.JP
import javax.swing.JScrollP
import javax.swing.JTextA
import javax.swing.JTextF
public class ClientUI extends JFrame {
public static void main(String[] args) {
ClientUI client = new ClientUI();
public ClientUI() {
super("客户端");
btStart = new JButton("启动连接");
btSend = new JButton("发送信息");
tfSend = new JTextField(10);
tfIP = new JTextField(10);
tfPost = new JTextField(5);
taShow = new JTextArea();
btStart.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
server = new ClientThread(ClientUI.this);
btSend.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
server.sendMsg(tfSend.getText());
tfSend.setText("");
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
int a = JOptionPane.showConfirmDialog(null, "确定关闭吗？", "温馨提示",
JOptionPane.YES_NO_OPTION);
if (a == 1) {
System.exit(0); // 关闭
JPanel top = new JPanel(new FlowLayout());
top.add(tfSend);
top.add(btSend);
top.add(btStart);
this.add(top, BorderLayout.SOUTH);
final JScrollPane sp = new JScrollPane();
sp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
sp.setViewportView(this.taShow);
this.taShow.setEditable(false);
this.add(sp, BorderLayout.CENTER);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(400, 300);
this.setLocation(600, 200);
this.setVisible(true);
JButton btS
JButton btS
JTextField tfS
JTextField tfIP;
JTextField tfP
JTextArea taS
import java.io.BufferedR
import java.io.IOE
import java.io.InputStreamR
import java.io.PrintW
import java.net.S
public class ClientThread extends Thread {
public ClientThread(ClientUI ui) {
client = new Socket("127.0.0.1", 1228);//这里设置连接服务器端的IP的端口
println("连接服务器成功：端口1228");
reader = new BufferedReader(new InputStreamReader(
client.getInputStream()));
writer = new PrintWriter(client.getOutputStream(), true);
// 如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区
} catch (IOException e) {
println("连接服务器失败：端口1228");
println(e.toString());
e.printStackTrace();
this.start();
public void run() {
String msg = "";
while (true) {
msg = reader.readLine();
} catch (IOException e) {
println("服务器断开连接");
if (msg != null && msg.trim() != "") {
println("&&" + msg);
public void sendMsg(String msg) {
writer.println(msg);
} catch (Exception e) {
println(e.toString());
public void println(String s) {
if (s != null) {
this.ui.taShow.setText(this.ui.taShow.getText() + s + "\n");
System.out.println(s + "\n");
阅读(...) 评论()java之 23天
TCP 网络编程 (二) - 慢慢睁开你的眼睛 - ITeye技术网站
博客分类：
TCP一次传输
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.net.ServerS
import java.net.S
* Socket 和ServerSocket
* 建立客户端和服务器端
* 建立连接后,通过Socket中的IO流进行数据的传递
* 关闭Socket
* 同样,客户端与服务器端是两个独立的应用程序.
通过查阅socke对象,发现在该对象建立的时候,就可以去连接指定的主机.
因为tcp是面向连接的,所以在建立socket的服务时,就要有服务端存在,并连接成功.形成通路后,在该通道进行数据的传输.
1.创建Socket服务,并指定要连接的主机和端口,必须要启动服务器端监听
2.然后创建 客户端,然后开始交流
* 需求:给服务端发送一个文本数据
class TcpClient{
public static void main(String[] args) throws IOException{
Socket s=new Socket("192.168.1.121",10000);
OutputStream out=s.getOutputStream();
out.write("tcp 哥们来了".getBytes());
s.close();
* 需求:定义端点接受数据并打印在控制台上
1.建立服务器端的socket服务, ServerSocket()
并监听一个端口.
2. 获取连接过来的客户端对象.
通过ServerScoket的accept方法,所以这个方法是阻塞式的
3.客户端如果发来数据,那么服务端要使用对应的客户对象,并获取到该客户端对象的读取流读取发过来的数据
并打印在控制台.
4.关闭服务器
class TcpServer{
public static void main(String[] args) throws IOException{
//建立服务端socket服务,并监听一个端口
ServerSocket ss=new ServerSocket(10000);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//获取客户端发送过来的额数据,那么要使用客户端对象的读取流来读取数据
InputStream in=s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.println(new String(buf,0,len));//关闭客户端
s.close();
ss.close();
TCP的传输的客户端和服务端的互访
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.net.ServerS
import java.net.S
* 演示 tcp的传输的客户端和服务端的互访
* 需求:客户端给服务端发送数据,服务端接手后,给客户端反馈系信息
1.建立Socket服务,指定要连接主机和端口
2.获取socket流中的输出流,将数据写到该流中,通过网络发送给服务端
3.获取socket流中的输入流,将服务端反馈的数据获取到,并打印
4.关闭资源
class TcpClient2{
public static void main(String[] args) throws IOException{
Socket s=new Socket("192.168.1.121",10000);
OutputStream out=s.getOutputStream();
out.write("服务端,你好吗?".getBytes());
InputStream in=s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.println(new String(buf,0,len));
s.close();
class TcpServer2{
public static void main(String[] args) throws IOException{
ServerSocket ss=new ServerSocket(10000);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected");
InputStream in=s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.println(new String(buf,0,len));
OutputStream out=s.getOutputStream();
out.write("我很好,thankyou!".getBytes());
s.close();
ss.close();
TCP服务端转换客户端文本
import java.io.BufferedR
import java.io.BufferedW
import java.io.IOE
import java.io.InputStreamR
import java.io.OutputStreamW
import java.io.PrintW
import java.net.ServerS
import java.net.S
* 需求:建立一个文本转换服务器
* 客户端给服务端发送一个,服务端会将文本转成大写再返回给客户端.
* 而且客户端可以不端的进行文本转换.当客户端输入over时,转换结束.
既然是操作设备上的数据,就可以使用io技术,并按照io的操作规律来思考
源:键盘录入
目的:网络设备,网络输出流.
可以操作的是文本数据,可以选择字符流
* 1.建立服务
* 2.获取键盘录入
* 3.将数据发送给服务端
* 4.获取服务端的的反馈数据
* 5.结束,关资源
* 都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲.
* 该例子出现的问题:
* 现象:客户端和服务端都在莫名的等待.
* 为什么呢?
* 因为客户端和服务端都有阻塞式方式,这些方法么有读取到结束标记,
* 那么就一直等.而导致两端都在等待.
class TransClient{
public static void main(String[] args) throws IOException{
Socket s=new Socket("192.168.1.121",10000);
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
//BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
BufferedReader bufrs=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=
while((line=bufr.readLine())!=null){
if("over".equals(line))
out.println(line);
bufw.write(line);
bufw.newLine(); //缓冲区的 读取结束标记
bufw.flush();*/
String str=bufrs.readLine();
System.out.println("Server:"+str);
bufr.close();
s.close();
class TransServer{
public static void main(String[] args) throws IOException{
ServerSocket ss=new ServerSocket(10000);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//读取socket流中的数据
BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的Socket输入流,将大写的写入到socket输出流,并发给客户端
//BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=
while((line=bufr.readLine())!=null){
System.out.println(line);
out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine(); //缓冲区的 读取结束标记
bufw.flush();*/
s.close();
ss.close();
浏览: 393525 次
来自: 上海
你好，我采用方法二，ConfigInfo.java 打出的结果 ...
&filter- ...
说了半天，没看到楼主用的啥软件，还分绿色版和安装版。。。
ningv 写道ningv 写道lz你的逻辑有误。例如昨天凌晨 ...
ningv 写道lz你的逻辑有误。例如昨天凌晨1:00跟今天1 ...您的位置： &
本文从两个内容浅析了Java web程序的客户端和服务器端交互原理，第一，协议；第二，HTTP保温接口及客户端和服务器端的交互原理。详细请看下文
　　1. 协议
　　a. TCP/IP整体构架概述
　　TCP/IP协议并不完全符合OSI的七层参考模型。传统的开放式系统互连参考模型，是一种通信协议的7层抽象的参考模型,其中每一层执行某一特定任务。该模型的目的是使各种硬件在相同的层次上相互通信。这7层是:物理层、数据链路层、网路层、传输层、话路层、表示层和应用层。而TCP/IP通讯协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。这4层分别为：
　　i. 应用层：应用程序间沟通的层，如超文本传送协议（HTTP）、简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。
　　ii. 传输层：在此层中，它提供了节点间的数据传送服务，如传输控制协议（TCP）、用户数据报协议（UDP）等，TCP和UDP给数据包加入传输数据并把它传输到下一层中，这一层负责传送数据，并且确定数据已被送达并接收。
　　iii. 互连网络层：负责提供基本的数据封包传送功能，让每一块数据包都能够到达目的主机（但不检查是否被正确接收），如网际协议（IP）。
　　iv. 网络接口层：对实际的网络媒体的管理，定义如何使用实际网络（如Ethernet、Serial Line等）来传送数据。
　　b. HTTP协议介绍：
　　i. HTTP是一种超文本传送协议（HyperText Transfer Protocol）,是一套计算机在网络中通信的一种规则。在TCP/IP体系结构中，HTTP属于应用层协议，位于TCP/IP协议的顶层
　　ii. HTTP是一种无状态的的协议，意思是指 在Web 浏览器（客户端）和 Web 服务器之间不需要建立持久的连接。整个过程就是当一个客户端向服务器端发送一个请求(request)，然后Web服务器返回一个响应 (response),之后连接就关闭了，在服务端此时是没有保留连接的信息。
　　iii. HTTP 遵循 请求/响应(request/response) 模型的，所有的通信交互都被构造在一套请求和响应模型中。
　　iv. 浏览WEB时，浏览器通过HTTP协议与WEB服务器交换信息，Web服务器向Web浏览器返回的文件都有与之相关的类型,这些信息类型的格式由MIME定义。
　　c. 协议的java实现方式
　　不论是TCP/IP协议也好，还是HTTP协议也好，java都是通过套接字（java.net.Socket）来实现的，可以参考我的另一篇技术博客：一个项目看java TCP/IP Socket编程(1.3版)
　　2. HTTP报文接口及客户端和服务器端交互原理
　　a. HTTP定义的事务处理由以下四步组成：
　　i. 建立连接：
　　例如我在浏览器里输入 ，客户端请求这个地址时即打开了web服务器HTTP端口的一个套接字。因为在网络中间作为传递数据的实体介质就是网线，数据实质上是通过IO流进行输出和输入，这就不难理解我们为什么在写一个Servlet的时候要引用 import java.io.*; 的原因 ，包括我们在向客户端回发结果的时候要用到PrintWriter对象的println()方法。其实请求的这个地址还要加上端口号80，80可以不写，是因为浏览器默认的端口号是80。
　　在Java底层代码中是这样实现的，只不过它们已经帮我们做了。
Socket socket = new Socket("",80);
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
　　ii. 客户端发送HTTP请求报文（request）
　　一旦建立了TCP连接，Web浏览器就会向Web服务器发送请求命令,是一个ASCII文本请求行，后跟0个或多个HTTP头标，一个空行和实现请求的任意数据。
　　即报文分四个部分：请求行，请求头标，空行和请求数据
　　1）请求行
　　请求行由三个标记组成：请求方法、请求URL和HTTP版本，中间用空格分开
　　例如： GET /blog/242842 HTTP/1.1
　　HTTP规范定义了8种可能的请求方法：(最常见的就是 GET 和 POST 两种方法)
GET -- 检索URI中标识资源的一个简单请求
HEAD -- 与GET方法相同，服务器只返回状态行和头标，并不返回请求文档
POST -- 服务器接受被写入客户端输出流中的数据的请求
PUT -- 服务器保存请求数据作为指定URI新内容的请求
DELETE -- 服务器删除URI中命名的资源的请求
OPTIONS -- 关于服务器支持的请求方法信息的请求
TRACE -- Web服务器反馈Http请求和其头标的请求
CONNECT -- 已文档化但当前未实现的一个方法，预留做隧道处理
　　2）请求头标
　　请求头标：由key ：value 健值组成，每行一对。请求头标用来通知服务器有关客户端的功能和标识。
　　HOST -- 请求的哪一个服务器端地址，主地址，比如：我的技术blog：　　User-Agent -- 用户即客户端可以使用的浏览器 ，如： Mozilla/4.0　　Accept -- 即客户端可以接受的MIME 类型列表，如image/gif、text/html、application/msword　　Content-Length -- 只适用于POST请求，以字节给出POST数据的尺寸
　　3）空行
　　发送回车符和退行，通知服务器以下不再有头标。
　　4）请求数据
　　使用POST传送数据，最常使用的是Content-Type和Content-Length头标。
　　请求报文总结：
　　我们可以这样写出一个标准的 HTTP请求：
POST /blog/242842 HTTP1.1
User-Agent: Mozilla/4.0
Accpt: image/gif,text/html,application/pdf,image/png...
key=value&key=value&key=value...... (POST()请求的数据)
　　这上面的一个例子意思是：
我要去访问的服务器端的地址是/ 它下面的资源 /blog/242842
连起来就是： /blog/242842
这个页面用的是 HTTP1.1 规范，我的浏览器版本是Mozilla/4.0
可以支持的MIME格式为 image/gif,text/html,application/pdf,image/png...等等
　　GET 和 POST 最直观的区别就是：GET方法将数据的请求跟在了所请求的URL后面，也就是在请求行里面我们是这么样来做的：
GET /blog/242842?key=value&key=value&key=value......HTTP1.1
　　实际上用 GET 是这样传递数据的：
http:///?page=2......
　　iii.服务器端响应请求生成结果并回发（response）
　　Web 服务器解析请求，定位指定的资源 /blog/242842
　　1）根据请求时的 GET/POST 对应的用servlet里的 doGet() / doPost()方法来处理（有可能是一些业务逻辑，也有可能是一些验证等等，也有可能是一些数据查询，提交等等）其有效的数据就来源于key=value&key=value&key=value......，以及其它的一些封装在 request 对象中的数据资源。
　　2）处理请求之后，由 response 对象得到 java.io.PrintWriter 输出流对象out，通过 out.println(); 将数据以指定的格式，如按照response.setcontentType("text/charset=gb2312");的格式输出到输出流。
　　它的响应报文与请求报文非常类似，其区别就在于：我们在请求阶段的请求行被状态行给替换了，再来看响应报文：
　　3）一个响应报文由四个部分组成：状态行、响应头标、空行、响应数据：
　　(a).状态行：
　　状态行由三个标记组成：HTTP版本、响应代码和响应描述。
　　HTTP响应码：
　　(b).响应头标：像请求头标一样，它们指出服务器的功能，标识出响应数据的细节。
　　(c).空行：最后一个响应头标之后是一个空行，发送回车符和退行，表明服务器以下不再有头标。
&title&Welcome to cuishen's IT blog&/title&
&!-- 这里是具体的内容，看到了这里
相信大家对 HTTP 工作原理及客户端与服务器交互过程已经很清楚了吧
　　iv. 服务器端关闭连接，客户端解析回发响应报文，恢复页面
　　1）浏览器先解析状态行，查看请求是否成功的状态代码--HTTP响应码：404 400 200 ....
　　2）解析每一个响应头标，如：
　　3）读取响应数据HTML，根据标签&html&&/html&中的内容恢复标准的HTML格式页面或者其它。
　　4）一个HTML 文档可能包含其它的需要被载入的资源，浏览器会识别，并对这些资源再进行额外的请求，这个过程可以是循环的方式一直到所有的数据都按照响应头标中规定的格式恢复到页面中。
　　5）数据传送完毕，服务器端关闭连接，即无状态协议。
　　3. 总结
　　不要被高深的名词和理论吓到，其实HTTP客户端和服务器端的交互原理很简单：即先是浏览器和服务器端建立Socket无状态连接，也就是短连接，然后通过IO流进行报文信息（这个报文是严格遵循HTTP报文接口的）的交互，最后会话结束后就关闭连接。对于这些底层的协议和报文的打包解包交互的实现，其实java和浏览器早都已经封装好了，程序员只要专注于业务逻辑的实现就行啦，这些都不必关心！！
上一篇：下一篇：