共计 4897 个字符，预计需要花费 13 分钟才能阅读完成。
Web 倒退中通信形式
- 简略通信
- 不同申请
- 简单申请
案例实操
1 简略通信
回顾 Socket 编程给咱们最大的感触，是能够在多台电脑之间进行数据的传输，这就是网络编程的开始和根底，通过客户端申请服务器端通信，直观理解 Web 编程。
Server
/**
* 服务端，接管客户端申请并给出简略的响应
* @author Cushier
*
*/
public class Server {public static void main(String[] args) throws IOException{// 创立服务器，指定端口 ServerSocket(int port)
ServerSocket socket = new ServerSocket(8888);
// 接管客户端连贯
Socket client = socket.accept();
System.out.println("******************");
// 获取数据的输出流
InputStream is = client.getInputStream();
// 应用缓冲字符输出流
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String msg = "";
while ((msg = br.readLine()) != null) {System.out.println(msg);
}
br.close();}
} Client
/**
* 客户端：向服务器发送申请，并发送简略的音讯
* @author Cushier
*
*/
public class Client {public static void main(String[] args) throws UnknownHostException, IOException {
// 创立客户端 必须指定服务器 + 端口
Socket client = new Socket("localhost", 8888);
// 发送音讯 申请资源
// 获取输入流
OutputStream os = client.getOutputStream();
// 应用缓冲字符输入流
BufferedWriter br = new BufferedWriter(new OutputStreamWriter(os));
// 写出音讯，发送内容
String msg = "Hello, I am Client, I need some resources";
br.write(msg);
br.close();}
} 从下面的例子总结通信条件如下：
- 须要有服务器端(server)：期待被申请，须要裸露 ip 和 port
- 须要有客户端(client)：被动发动申请，通晓服务端的 ip 和 port
- 通信规定(协定)：TCP/IP 协定
ip 用于定位计算机；端口号(定位程序)，用于标识过程的逻辑地址，不同过程的标记；无效端口：0~65535，其中 0~1024 由零碎应用或者保留端口，开发中倡议应用 1024 以上的端口。
2 不同申请
Client
/**
* 客户端：向服务器发送申请，发送不同的申请
* @author Cushier
*
*/
public class Client {public static void main(String[] args) throws IOException {
// 通过零碎默认类型的 SocketImpl 创立未连贯套接字
Socket socket = new Socket();
// 此类实现 IP 套接字地址（IP 地址 + 端口号）。它还能够是一个对（主机名 + 端口号），在此状况下，将尝试解析主机名
SocketAddress address = new InetSocketAddress("localhost", 8898);
// 将此套接字连贯到服务器，并指定一个超时值。或者不指定超时工夫
socket.connect(address, 1000);
OutputStream os = socket.getOutputStream();
os.write("time".getBytes());
os.flush();
socket.close();}
} Server
/**
* 服务端
* public class ServerSocketextends Object：此类实现服务器套接字。* 服务器套接字期待申请通过网络传入。* 它基于该申请执行某些操作，而后可能向请求者返回后果。*
* @author Cushier
*
*/
public class Server {public static void main(String[] args) throws IOException {
// 创立绑定到特定端口的服务器套接字。ServerSocket server = new ServerSocket(8898);
// Socket accept() 侦听并承受到此套接字的连贯。Socket client = server.accept();
System.out.println("接管到连贯");
InputStream is = client.getInputStream();
BufferedInputStream bis = new BufferedInputStream(is);
byte[] req = new byte[1024];
// 接管客户端申请
int len = bis.read(req);
String reqStr = new String(req, 0, len);
System.out.println(reqStr);
if (reqStr.equals("money")) {System.out.println("here's the money");
} else if (reqStr.equals("time")) {System.out.println("you have so much time");
}
client.close();
server.close();}
} 3 简单申请
Client
/**
* 客户端
*
* @author Cushier
*
*/
public class Client {public static void main(String[] args) throws IOException {
// 通过零碎默认类型的 SocketImpl 创立未连贯套接字
Socket socket = new Socket();
// 此类实现 IP 套接字地址（IP 地址 + 端口号）。它还能够是一个对（主机名 + 端口号），在此状况下，将尝试解析主机名
SocketAddress address = new InetSocketAddress("localhost", 8898);
// 将此套接字连贯到服务器，并指定一个超时值。或者不指定超时工夫
socket.connect(address, 1000);
OutputStream os = socket.getOutputStream();
os.write("money".getBytes());
os.flush();
// 接管响应，显示后果
InputStream is = socket.getInputStream();
byte[] result = new byte[1024];
int len = is.read(result);
String resultStr = new String(result, 0, len);
System.out.println(resultStr);
socket.close();}
} Server
/**
* 服务端
* @author Cushier
*
*/
public class Server2 {public static void main(String[] args) throws IOException {
// 创立绑定到特定端口的服务器套接字。ServerSocket server = new ServerSocket(8898);
// Socket accept() 侦听并承受到此套接字的连贯。Socket client = server.accept();
System.out.println("接管到连贯");
InputStream is = client.getInputStream();
BufferedInputStream bis = new BufferedInputStream(is);
byte[] req = new byte[1024];
// 接管客户端申请
int len = bis.read(req);
String reqStr = new String(req, 0, len);
System.out.println(reqStr);
// 将接管到的申请封装成对象，传送给申请的类
MyRequest request = new MyRequest();
MyResponse response = new MyResponse();
OutputStream os = client.getOutputStream();
if (reqStr.equals("money")) {
// 依据申请的信息，结构解决的类
MyServlet s1 = new ServletMoney();
s1.service(request, response);
// 通过 client 的响应，将后果响应回客户端
os.write("here's the money".getBytes());
os.flush();} else if (reqStr.equals("time")) {
// 依据申请的信息，结构解决的类
MyServlet s2 = new ServletTime();
s2.service(request, response);
// 通过 client 的响应，将后果响应回客户端
os.write("you have somuch time".getBytes());
os.flush();}
client.close();
server.close();}
}
/*
* 我是一个有要求的人，你申请的这个资源必须是满足我要求格局的类，作用：避免凌乱，不便调用 这是我的规范
*/
interface MyServlet {void service(MyRequest req, MyResponse resp);
}
class ServletMoney implements MyServlet {
@Override
public void service(MyRequest req, MyResponse resp) {// 做出力不从心的解决}
}
class ServletTime implements MyServlet {
@Override
public void service(MyRequest req, MyResponse resp) {// 做出力不从心的解决}
}
/*
* 申请信息都按法则封装在该对象
*/
class MyRequest {
}
class MyResponse {} 随着客户需要越来越简单，须要的性能越来越多，咱们的服务器端须要解决的申请越来越多，须要辨别不同的申请，还须要依照不同申请进行申请数据的提取以及资源的调配和运算还有逻辑的解决，最初还须要响应给客户端，这就使得 服务器端代码越来越简单，实现越来越艰难。
依据以往的教训，单方进行通信只须要遵循肯定的规定就能够很明确地晓得各局部数据的含意，于是呈现了网络更下层的利用协定（前面讲的 HTTP 协定），规定服务器端和客户端通信的规定。
客户端申请服务器端和服务器端响应客户端，都依照固定的规定，那么接管申请和响应数据这部分操作就能够固定下来，交给特定的一段代码来执行，从而缩小服务器端的代码量，于是呈现了接下来说的 服务器。
扩大
服务器的呈现
当客户端申请的资源越来越丰盛，需要越来越简单，程序的外围就应该放在解决业务和计算响应数据上，于是呈现了服务器 对立接管客户端数据进行解决并散发到不同的资源 ，由 各个资源进行解决，最初后果交由服务器响应。
从下面的形容能够发现，当初所说的服务器只是负责接管申请，对申请进行散发，以及最初将获取的数据进行相应的固定框架，至于数据怎么计算得出还得依据具体的业务需要编写（填充）代码。在没有业务需要的状况下就能将服务器筹备进去，当初市面上的服务器有很多，比拟罕用的有：Tomcat、JBOOS、IBM 的 WebSphere、BEA 的 WebLogic 以及 Apache 等。
正文完
