BinCat V4-实现PHP文件解析

Quercus-QuercusServlet

Quercus是一个Resin实现的解析并运行php文件的jar库，其本质是使用QuercusServlet处理所有访问.php的文件请求，Quercus会将php文件翻译成java class文件并在JVM中执行。

添加Quercus依赖：

  1. <dependency>
  2.   <groupId>com.caucho</groupId>
  3.   <artifactId>quercus</artifactId>
  4.   <version>4.0.63</version>
  5. </dependency>

然后创建一个Quercus的Servlet映射，因为BinCat只支持注解，所以无法在QuercusServlet类上添加@WebServlet注解，但是我们可以写一个类去继承QuercusServlet从而间接的完成Servlet声明。

QuercusPHPServlet示例：

  1. package com.anbai.sec.server.test.servlet;
  3. import com.caucho.quercus.servlet.QuercusServlet;
  5. import javax.servlet.annotation.WebServlet;
  7. @WebServlet(name = "QuercusPHPServlet", urlPatterns = ".*\\.php$")
  8. public class QuercusPHPServlet extends QuercusServlet {
  11. }

BinCatConfig示例代码(方便统一的Servlet注册)：

  1. /**
  2.     * 手动注册Servlet并创建BinCatServletContext对象
  3.   *
  4.     * @param appClassLoader 应用的类加载器
  5.     * @return ServletContext Servlet上下文对象
  6.     */
  7. public static BinCatServletContext createServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
  8.     BinCatServletContext servletContext = new BinCatServletContext(appClassLoader);
  10.     // 手动注册Servlet类
  11.     Class<Servlet>[] servletClass = new Class[]{
  12.       TestServlet.class,
  13.       CMDServlet.class,
  14.       QuercusPHPServlet.class
  15.         };
  17.     for (Class<Servlet> clazz : servletClass) {
  18.       Servlet    servlet    = clazz.newInstance();
  19.       WebServlet webServlet = clazz.getAnnotation(WebServlet.class);
  21.       if (webServlet != null) {
  22.         // 获取WebInitParam配置
  23.         WebInitParam[] webInitParam = webServlet.initParams();
  25.         // 动态创建Servlet对象
  26.         ServletRegistration.Dynamic dynamic = servletContext.addServlet(webServlet.name(), servlet);
  28.         // 动态设置Servlet映射地址
  29.         dynamic.addMapping(webServlet.urlPatterns());
  31.         // 设置Servlet启动参数
  32.         for (WebInitParam initParam : webInitParam) {
  33.           dynamic.setInitParameter(initParam.name(), initParam.value());
  34.         }
  35.       }
  36.     }
  38.     // 创建ServletContext
  39.     return servletContext;
  40. }

因为QuercusServlet创建时需要必须有ServletContext对象，所以我们必须实现ServletContext接口。除此之外，Servlet创建时还需要调用Servlet的初始化方法(public void init(ServletConfig config) throws ServletException)。调用init的时候还需要实现ServletConfig接口。

初始化Servlet代码片段：

  1. /**
  2.     * 初始化Servlet
  3.     *
  4.     * @param servletContext Servlet上下文
  5.     * @throws ServletException Servlet处理异常
  6.     */
  7. public static void initServlet(BinCatServletContext servletContext) throws ServletException {
  8.   Set<BinCatServletRegistrationDynamic> dynamics = servletContext.getRegistrationDynamics();
  10.   for (BinCatServletRegistrationDynamic dynamic : dynamics) {
  11.     Servlet             servlet          = dynamic.getServlet();
  12.     String              servletName      = dynamic.getServletName();
  13.     Map<String, String> initParameterMap = dynamic.getInitParameters();
  15.     servlet.init(new BinCatServletConfig(servletContext, servletName, initParameterMap));
  16.   }
  17. }

BinCatServletContext实现

在Servlet容器启动的时候必须创建一个ServletContext(Servlet上下文)，用于管理容器中的所有Servlet对象。在创建BinCatServletContext的时候需要创建并初始化所有的Servlet并存储到servletMap中。

BinCatServletContext代码片段：

  1. package com.anbai.sec.server.servlet;
  3. import javax.servlet.*;
  4. import javax.servlet.annotation.WebServlet;
  5. import javax.servlet.descriptor.JspConfigDescriptor;
  6. import java.io.File;
  7. import java.io.InputStream;
  8. import java.net.MalformedURLException;
  9. import java.net.URL;
  10. import java.util.*;
  11. import java.util.concurrent.ConcurrentHashMap;
  13. public class BinCatServletContext implements ServletContext {
  15.     // 创建一个装动态注册的Servlet的Map
  16.     private final Map<String, Servlet> servletMap = new HashMap<>();
  18.     // 创建一个装ServletContext初始化参数的Map
  19.     private final Map<String, String> initParameterMap = new HashMap<>();
  21.     // 创建一个装ServletContext属性对象的Map
  22.     private final Map<String, Object> attributeMap = new HashMap<>();
  24.     // 创建一个装Servlet动态注册的Set
  25.     private final Set<BinCatServletRegistrationDynamic> registrationDynamics = new LinkedHashSet<>();
  27.     // BinCatWebAppClassLoader，Web应用的类加载器
  28.     private final BinCatWebAppClassLoader appClassLoader;
  30.     public BinCatServletContext(BinCatWebAppClassLoader appClassLoader) throws Exception {
  31.         this.appClassLoader = appClassLoader;
  32.     }
  34.     // 此处省略ServletContext接口中的大部分方法，仅保留几个示例方法...
  36.     @Override
  37.     public Servlet getServlet(String name) throws ServletException {
  38.         return servletMap.get(name);
  39.     }
  41.     @Override
  42.     public Enumeration<Servlet> getServlets() {
  43.         Set<Servlet> servlets = new HashSet<Servlet>();
  44.         servlets.addAll(servletMap.values());
  46.         return Collections.enumeration(servlets);
  47.     }
  49.     @Override
  50.     public Enumeration<String> getServletNames() {
  51.         Set<String> servlets = new HashSet<String>();
  52.         servlets.addAll(servletMap.keySet());
  54.         return Collections.enumeration(servlets);
  55.     }
  57. }

BinCatServletConfig实现

在创建BinCatServletContext时我们指定了一个ServletConfig实现：BinCatServletConfig，ServletConfig用于指定Servlet启动时的配置信息。

BinCatServletConfig实现：

  1. package com.anbai.sec.server.servlet;
  3. import javax.servlet.ServletConfig;
  4. import javax.servlet.ServletContext;
  5. import javax.servlet.annotation.WebInitParam;
  6. import javax.servlet.annotation.WebServlet;
  7. import java.util.Collections;
  8. import java.util.Enumeration;
  9. import java.util.HashSet;
  10. import java.util.Set;
  12. public class BinCatServletConfig implements ServletConfig {
  14.    private final BinCatServletContext servletContext;
  16.    private final WebServlet webServlet;
  18.    private final WebInitParam[] webInitParam;
  20.    public BinCatServletConfig(BinCatServletContext servletContext, WebServlet webServlet) {
  21.       this.servletContext = servletContext;
  22.       this.webServlet = webServlet;
  23.       this.webInitParam = webServlet.initParams();
  24.    }
  26.    @Override
  27.    public String getServletName() {
  28.       return webServlet.name();
  29.    }
  31.    @Override
  32.    public ServletContext getServletContext() {
  33.       return this.servletContext;
  34.    }
  36.    @Override
  37.    public String getInitParameter(String name) {
  38.       for (WebInitParam initParam : webInitParam) {
  39.          String paramName = initParam.name();
  41.          if (paramName.equals(name)) {
  42.             return initParam.value();
  43.          }
  44.       }
  46.       return null;
  47.    }
  49.    @Override
  50.    public Enumeration<String> getInitParameterNames() {
  51.       Set<String> initParamSet = new HashSet<String>();
  53.       for (WebInitParam initParam : webInitParam) {
  54.          initParamSet.add(initParam.name());
  55.       }
  57.       return Collections.enumeration(initParamSet);
  58.    }
  60. }

BinCatDispatcherServlet实现

为了方便后续的BinCat版本处理Http请求和响应处理结果，我们简单的封装了BinCatDispatcherServlet和BinCatResponseHandler对象。BinCatDispatcherServlet会根据浏览器请求的不同URL地址去调用对应的Servlet服务，除此之外还提供了一个简单的静态资源文件处理逻辑和PHP解析功能。

BinCatDispatcherServlet实现代码：

  1. package com.anbai.sec.server.handler;
  3. import com.anbai.sec.server.servlet.BinCatRequest;
  4. import com.anbai.sec.server.servlet.BinCatResponse;
  5. import com.anbai.sec.server.servlet.BinCatServletContext;
  6. import com.anbai.sec.server.servlet.BinCatServletRegistrationDynamic;
  7. import org.javaweb.utils.FileUtils;
  8. import org.javaweb.utils.StringUtils;
  10. import java.io.ByteArrayOutputStream;
  11. import java.io.File;
  12. import java.io.IOException;
  13. import java.nio.file.Files;
  14. import java.util.Collection;
  15. import java.util.Set;
  16. import java.util.regex.Pattern;
  18. public class BinCatDispatcherServlet {
  20.     public void doDispatch(BinCatRequest req, BinCatResponse resp, ByteArrayOutputStream out) throws IOException {
  21.         // 请求URI地址
  22.         String uri = req.getRequestURI();
  24.         // 获取ServletContext
  25.         BinCatServletContext servletContext = (BinCatServletContext) req.getServletContext();
  27.         // 获取Http请求的文件
  28.         File requestFile = new File(req.getRealPath(uri));
  30.         // 处理Http请求的静态文件，如果文件存在(.php后缀除外)就直接返回文件内容，不需要调用Servlet
  31.         if (requestFile.exists() && requestFile.isFile() && !uri.endsWith(".php")) {
  32.             // 修改状态码
  33.             resp.setStatus(200, "OK");
  35.             // 解析文件的MimeType
  36.             String mimeType = Files.probeContentType(requestFile.toPath());
  38.             if (mimeType == null) {
  39.                 String fileSuffix = FileUtils.getFileSuffix(requestFile.getName());
  40.                 resp.setContentType("text/" + fileSuffix);
  41.             } else {
  42.                 resp.setContentType(mimeType);
  43.             }
  45.             out.write(Files.readAllBytes(requestFile.toPath()));
  46.         } else {
  47.             // 遍历所有已注册得Servlet，处理Http请求
  48.             Set<BinCatServletRegistrationDynamic> dynamics = servletContext.getRegistrationDynamics();
  49.             for (BinCatServletRegistrationDynamic dynamic : dynamics) {
  50.                 Collection<String> urlPatterns = dynamic.getMappings();
  52.                 for (String urlPattern : urlPatterns) {
  53.                     try {
  54.                         // 检测请求的URL地址和Servlet的地址是否匹配
  55.                         if (Pattern.compile(urlPattern).matcher(uri).find()) {
  56.                             // 修改状态码
  57.                             resp.setStatus(200, "OK");
  59.                             // 调用Servlet请求处理方法
  60.                             dynamic.getServlet().service(req, resp);
  61.                             return;
  62.                         }
  63.                     } catch (Exception e) {
  64.                         // 修改状态码,输出服务器异常信息到浏览器
  65.                         resp.setStatus(500, "Internal Server Error");
  66.                         e.printStackTrace();
  68.                         out.write(("<pre>" + StringUtils.exceptionToString(e) + "</pre>").getBytes());
  69.                     }
  70.                 }
  71.             }
  72.         }
  73.     }
  75. }

BinCatResponseHandler实现

BinCatResponseHandler只是一个简单封装的用于向浏览器输出Http处理请求结果的对象。

BinCatResponseHandler实现代码：

  1. package com.anbai.sec.server.handler;
  3. import com.anbai.sec.server.servlet.BinCatResponse;
  5. import java.io.ByteArrayOutputStream;
  6. import java.io.IOException;
  7. import java.io.OutputStream;
  8. import java.util.Map;
  10. public class BinCatResponseHandler {
  12.    public void processResult(BinCatResponse response, Map<String, String> responseHeader, String serverName,
  13.                              OutputStream out, ByteArrayOutputStream baos) throws IOException {
  15.       // 处理Http响应内容
  16.       out.write(("HTTP/1.1 " + response.getStatus() + " " + response.getMessage() + "\n").getBytes());
  17.       // 输出Web服务器信息
  18.       out.write(("Server: " + serverName + "\n").getBytes());
  19.       // 输出返回的消息类型
  20.       out.write(("Content-Type: " + response.getContentType() + "\n").getBytes());
  21.       // 输出返回字节数
  22.       out.write(("Content-Length: " + baos.size() + "\n").getBytes());
  24.       // 输出用户自定义的Header
  25.       for (String key : responseHeader.keySet()) {
  26.          out.write((key + ": " + responseHeader.get(key) + "\n").getBytes());
  27.       }
  29.       // 写入换行
  30.       out.write("\n".getBytes());
  31.       // 将读取到的数据写入到客户端Socket
  32.       out.write(baos.toByteArray());
  33.    }
  35. }

BinCat V4实现

V4在V3的基础上实现了ServletConfig、ServletContext接口，从而实现了Servlet的实例化和初始化，BinCatDispatcherServlet实现的Servlet服务调用。

BinCatServerV4实现代码：

  1. package com.anbai.sec.server;
  3. import com.anbai.sec.server.config.BinCatConfig;
  4. import com.anbai.sec.server.handler.BinCatDispatcherServlet;
  5. import com.anbai.sec.server.handler.BinCatResponseHandler;
  6. import com.anbai.sec.server.servlet.BinCatRequest;
  7. import com.anbai.sec.server.servlet.BinCatResponse;
  8. import com.anbai.sec.server.servlet.BinCatServletContext;
  10. import java.io.ByteArrayOutputStream;
  11. import java.io.InputStream;
  12. import java.io.OutputStream;
  13. import java.net.ServerSocket;
  14. import java.net.Socket;
  15. import java.util.Map;
  16. import java.util.concurrent.ConcurrentHashMap;
  17. import java.util.logging.Logger;
  19. /**
  20.  * ServerSocket Http 服务器示例
  21.  */
  22. public class BinCatServerV4 {
  24.     // 设置服务监听端口
  25.     private static final int PORT = 8080;
  27.     // 设置服务名称
  28.     private static final String SERVER_NAME = "BinCat-0.0.4";
  30.     private static final Logger LOG = Logger.getLogger("info");
  32.     public static void main(String[] args) {
  33.         try {
  34.             // 创建ServerSocket，监听本地端口
  35.             ServerSocket ss = new ServerSocket(PORT);
  37.             // 创建BinCatServletContext对象
  38.             BinCatServletContext servletContext = BinCatConfig.createServletContext();
  40.             // 初始化Servlet
  41.             BinCatConfig.initServlet(servletContext);
  43.             LOG.info(SERVER_NAME + " 启动成功，监听端口: " + PORT);
  45.             while (true) {
  46.                 // 等待客户端连接
  47.                 Socket socket = ss.accept();
  49.                 try {
  50.                     // 获取Socket输入流对象
  51.                     InputStream in = socket.getInputStream();
  53.                     // 获取Socket输出流对象
  54.                     OutputStream out = socket.getOutputStream();
  56.                     // 创建BinCat请求处理对象
  57.                     BinCatRequest request = new BinCatRequest(socket, servletContext);
  59.                     // 创建BinCat请求处理结果输出流
  60.                     ByteArrayOutputStream baos = new ByteArrayOutputStream();
  62.                     // 创建BinCat请求处理结果Header对象
  63.                     Map<String, String> responseHeader = new ConcurrentHashMap<String, String>();
  65.                     // 创建BinCat响应处理对象
  66.                     BinCatResponse response = new BinCatResponse(socket, responseHeader, baos);
  68.                     // 创建BinCatDispatcherServlet对象，用于分发Http请求
  69.                     BinCatDispatcherServlet dispatcherServlet = new BinCatDispatcherServlet();
  71.                     // 创建BinCatResponseHandler对象，用于处理Http请求结果
  72.                     BinCatResponseHandler responseHandler = new BinCatResponseHandler();
  74.                     // 使用BinCatDispatcherServlet处理Servlet请求
  75.                     dispatcherServlet.doDispatch(request, response, baos);
  77.                     // 响应服务器处理结果
  78.                     responseHandler.processResult(response, responseHeader, SERVER_NAME, out, baos);
  80.                     in.close();
  81.                     out.close();
  82.                 } catch (Exception e) {
  83.                     LOG.info("处理客户端请求异常:" + e);
  84.                 } finally {
  85.                     socket.close();
  86.                 }
  87.             }
  88.         } catch (Exception e) {
  89.             e.printStackTrace();
  90.         }
  91.     }
  93. }

BinCat PHP解析测试

我们需要在javaweb-sec项目根目录创建一个测试文件，如info.php:

  1. <?php phpinfo();?>

image-20200911163413630

启动BinCat V4后访问http://localhost:8080/info.php:

image-20200911150900145

复制一个最新版本的Discuz到javaweb-sec目录，尝试安装Discuz，访问：http://localhost:8080/discuz/install/index.php

image-20200911150712040

Discuz环境检测正常：

image-20200911150754241

测试BinCat的PHP解析功能正常，只是开始安装Discuz时无法下一步，无异常和错误卡了，无法完成安装。