跟我猜spring-boot:简单的HttpServer

Posted IT老拐瘦

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了跟我猜spring-boot:简单的HttpServer相关的知识，希望对你有一定的参考价值。

引＆目标

本篇是《跟我猜Spring-boot》系列文章的第三篇,本拐做事向来随机随意,三分热血，有始无终,希望《猜》系列文章可以成为本拐第一个正常完结的系列。

在这个系列里，笔者将会通过简单实现Spring里各种功能和特性，试着拆解这些功能特性背后的实现机理。

我们最终靠“猜"实现的源码，肯定会与真正的工程化的东西差十万八千里。

但是通过这些猜出来的源码，希望各位与笔者一样，对设计模式,语言特性会有一些深层的认知。

废话不多说（明明已经说了那么。。。），在上一篇里，我们已经实现了简单的bean注入。

那么我们这一篇，将去实现一个简单的HttpServer. 这其中，所有的源码的改造都基于： 

https://github.com/yfge/mini-boot/archive/'article-02'.tar.gz

既然要实现HttpServer,对照Spring的一些功能,我们需要标注Controller以达到:

  1. 说明它是一个restController

  3. 标注方法

这样，改造后的 SimpleController如下:

SimpleController.java

 
   
   
 
    
  
    
    
  
  1. package com.github.yfge.miniapp;
    2. 
  
    
    
  
  2. //省去import ..
    3. 
  
    
    
  
  3. @RestController
    4. 
  
    
    
  
  4. @RequestMapping(path="/")
    5. 
  
    
    
  
  5. public class SimpleController {
    6. 
  
    
    
  
  6.  @Autowired
    7. 
  
    
    
  
  7.  private SimpleService simpleService;
    8. 
  
    
    
  

    9. 
  
    
    
  
  9.  public SimpleController(){
    10. 
  
    
    
  
  10.  System.out.println("the controller is created!");
    11. 
  
    
    
  
  11.  }
    12. 
  
    
    
  
  12.  @PostConstruct
    13. 
  
    
    
  
  13.  public void init(){
    14. 
  
    
    
  
  14.  System.out.println("the service Id is :"+this.simpleService.getServiceId());
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  

    17. 
  
    
    
  
  17.  @RequestMapping(path="/hello",method = RequestMethod.GET)
    18. 
  
    
    
  
  18.  public String getHello(){
    19. 
  
    
    
  
  19.  return simpleService.getHelloMessage();
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21. }
    22.

那么对应的，我们需要在 SimpleService上加一个 getHelloMessage()的实现:

 
   
   
 
    
  
    
    
  
  1. package com.github.yfge.miniapp;
    2. 
  
    
    
  
  2. //略去import
    3. 
  
    
    
  
  3. @Service
    4. 
  
    
    
  
  4. public class SimpleService {
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  private String serviceId ;
    7. 
  
    
    
  
  7.  public SimpleService(){
    8. 
  
    
    
  
  8.  serviceId= UUID.randomUUID().toString();
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  
  10.  public String getServiceId(){
    11. 
  
    
    
  
  11.  return this.serviceId;
    12. 
  
    
    
  
  12.  }
    13. 
  
    
    
  
  13.  public String getHelloMessage(){
    14. 
  
    
    
  
  14.  StringBuilder builder = new StringBuilder();
    15. 
  
    
    
  
  15.  builder.append("Hello ,the Service is :")
    16. 
  
    
    
  
  16.  .append(this.serviceId);
    17. 
  
    
    
  
  17.  return builder.toString();
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19. }
    20.

需求分析

由我们的改造目标可以看到，我们需要做到：

  1. 实现一个简单的HttpServer

  2. 定义我们需要实现的注解( RequestMapping, RespnseBody, RestController)并实现挂载逻辑。

实现简单的HttpServer

JDK本身已经有了一个HttpServer，使用起来非常简单粗暴，类似于这个样子:

 
   
   
 
    
  
    
    
  
  1.  try {
    2. 
  
    
    
  
  2.  server = HttpServer.create(new InetSocketAddress(8080),0);
    3. 
  
    
    
  
  3.  server.createContext("/",new ServerHandler());
    4. 
  
    
    
  
  4.  server.start();
    5. 
  
    
    
  
  5.  } catch (IOException e) {
    6. 
  
    
    
  
  6.  e.printStackTrace();
    7. 
  
    
    
  
  7.  }
    8.

为了让这个server与我们的简单框架结合到一起，我们显然要把它加到 Application.loadBeans结尾。

在这段代码里, ServerHandler是一个 HttpHandler简单实现,类似于下面这样:

 
   
   
 
    
  
    
    
  
  1.  public class ServerHandler implements HttpHandler{
    2. 
  
    
    
  
  2.  @Override
    3. 
  
    
    
  
  3.  public void handle(HttpExchange exchange) throws IOException {
    4. 
  
    
    
  
  4.  String response = "hello world";
    5. 
  
    
    
  
  5.  exchange.sendResponseHeaders(200, 0);
    6. 
  
    
    
  
  6.  OutputStream os = exchange.getResponseBody();
    7. 
  
    
    
  
  7.  os.write(response.getBytes());
    8. 
  
    
    
  
  8.  os.close();
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  
  10.  }
    11.

在这个简单实现里，我们已经能看到一个HttpServer的基本的结构了,但有一个问题，就是这个HttpServer其实是单线程的。为了验证个问题，可以加一个sleep来测试,这里就不再缀述了。

为了能让他并发执行，我们简单的加一个并发的机制。即引入一个 ThreadPool来进行执行请求,同时将原有的处理逻辑抽象成 ServiceRunnable的类。ServiceRunnable这个类名字听起来或许有些不那么靠谱,但是我们目前为止似乎只看到了这些,所以,更改后的 ServerHandler变成了下面的样子:

ServerHandler.java

 
   
   
 
    
  
    
    
  
  1. public class ServerHandler implements HttpHandler {
    2. 
  
    
    
  
  2.  private ThreadPoolExecutor poolExecutor ;
    3. 
  
    
    
  
  3.  public ServerHandler(){
    4. 
  
    
    
  
  4.  poolExecutor= (ThreadPoolExecutor) Executors.newCachedThreadPool();
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  
  6.  @Override
    7. 
  
    
    
  
  7.  public void handle(HttpExchange exchange) throws IOException {
    8. 
  
    
    
  
  8.  poolExecutor.execute(new ServiceRunnable(exchange));
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  

    11. 
  
    
    
  
  11. }
    12.

我们这个简单的 ServiceRunnable就成了如下样子:ServiceRunnable.java

 
   
   
 
    
  
    
    
  
  1. public class ServiceRunnable implements Runnable {
    2. 
  
    
    
  
  2.  private final HttpExchange exchange;
    3. 
  
    
    
  
  3.  public ServiceRunnable(HttpExchange exchange) {
    4. 
  
    
    
  
  4.  this.exchange = exchange;
    5. 
  
    
    
  
  5.  }
    6. 
  
    
    
  
  6.  @Override
    7. 
  
    
    
  
  7.  public void run() {
    8. 
  
    
    
  
  8.  try {
    9. 
  
    
    
  
  9.  exchange.sendResponseHeaders(200, 0);
    10. 
  
    
    
  
  10.  exchange.getResponseBody().write("hello".getBytes());
    11. 
  
    
    
  
  11.  exchange.getResponseBody().flush();
    12. 
  
    
    
  
  12.  exchange.getResponseBody().close();
    13. 
  
    
    
  
  13.  } catch (IOException e) {
    14. 
  
    
    
  
  14.  e.printStackTrace();
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17. }
    18.

OK,做了以上的改动，我们已经实现了一个简单的HttpServer,虽然它目前只会输出一个Hello,但是通过我们的一些设计，他实现了:

  1. 端口监听和服务启动

  2. 我们将处理请求的逻辑移到了 ServiceRunnable这个类中,意味着对Http的一些扩展性操作我们只要和 ServiceRunnable打交道就可以了。

定义注解

在实现了HttpServer以后,我们需要照着Spring的方式定义一系列的注解:

RequestMapping.java

 
   
   
 
    
  
    
    
  
  1. @Retention(RetentionPolicy.RUNTIME)
    2. 
  
    
    
  
  2. @Target({ElementType.TYPE,ElementType.METHOD})
    3. 
  
    
    
  
  3. public @interface RequestMapping {
    4. 
  
    
    
  
  4.  String[] path() default {};
    5. 
  
    
    
  
  5.  RequestMethod[] method() default {};
    6. 
  
    
    
  
  6. }
    7.

ResponseBody.java

 
   
   
 
    
  
    
    
  
  1. @Retention(RetentionPolicy.RUNTIME)
    2. 
  
    
    
  
  2. @Target({ElementType.METHOD,ElementType.TYPE})
    3. 
  
    
    
  
  3. public @interface ResponseBody {
    4. 
  
    
    
  
  4. }
    5.

RestController.java

 
   
   
 
    
  
    
    
  
  1. @Target(ElementType.TYPE)
    2. 
  
    
    
  
  2. @Retention(RetentionPolicy.RUNTIME)
    3. 
  
    
    
  
  3. @Service
    4. 
  
    
    
  
  4. public @interface RestController {
    5. 
  
    
    
  
  5. }
    6.

那么像之前一样，我们需要将这些注解解析,并得创建相应的bean. 这里面，重要的一点,我们的 SimpleController已经没有Service的注解,而只有了RestController这个注解。并且为了标明RestController也是一个bean，也要创建，我们在 RestController上加了 @Service这就意味着我们的Bean创建逻辑要更改,即，从创建是否含有 @Service的注解,到循环判断这个类的注解上是否也有@Service注解! 有一些绕是吧，其实我们只是需要对 Application.loadBean方法中下面这段做更改:

 
   
   
 
    
  
    
    
  
  1.  for (String name : classNames) {
    2. 
  
    
    
  
  2.  try {
    3. 
  
    
    
  
  3.  var classInfo = Class.forName(name);
    4. 
  
    
    
  
  4.  /**
    5. 
  
    
    
  
  5.  * 检查是否声明了@Service
    6. 
  
    
    
  
  6.  **/
    7. 
  
    
    
  
  7.  if (classInfo.getDeclaredAnnotation(Service.class) != null) { // 这里变得不适用了。
    8. 
  
    
    
  
  8.  /**
    9. 
  
    
    
  
  9.  * 得到默认构造函数
    10. 
  
    
    
  
  10.  */
    11. 
  
    
    
  
  11.  var constructor = classInfo.getConstructor();
    12. 
  
    
    
  
  12.  if (constructor != null) {
    13. 
  
    
    
  
  13.  /**
    14. 
  
    
    
  
  14.  * 创建实例
    15. 
  
    
    
  
  15.  */
    16. 
  
    
    
  
  16.  var obj = constructor.newInstance();
    17. 
  
    
    
  
  17.  /** 保存bean**/
    18. 
  
    
    
  
  18.  applicationContext.addBean(obj);
    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21.  } catch (Throwable e) {
    22. 
  
    
    
  
  22.  e.printStackTrace();
    23. 
  
    
    
  
  23.  }
    24. 
  
    
    
  
  24.  }
    25.

将其中的判断抽取成一个方法，然后进行调用，如下:

 
   
   
 
    
  
    
    
  
  1. public class Application {
    2. 
  
    
    
  

    3. 
  
    
    
  

    4. 
  
    
    
  
  4.  /**
    5. 
  
    
    
  
  5.  * 检查一个类是否需要创建（是否是bean)
    6. 
  
    
    
  
  6.  * @param beanClass
    7. 
  
    
    
  
  7.  * @return
    8. 
  
    
    
  
  8.  */
    9. 
  
    
    
  
  9.  private static boolean isNeedToCreate(Class beanClass) {
    10. 
  
    
    
  
  10.  var annotations = beanClass.getDeclaredAnnotations();
    11. 
  
    
    
  
  11.  if (annotations != null && annotations.length > 0) {
    12. 
  
    
    
  
  12.  for (var annotation : annotations) {
    13. 
  
    
    
  
  13.  if (annotation.annotationType() == Service.class) {
    14. 
  
    
    
  
  14.  return true;
    15. 
  
    
    
  
  15.  } else {
    16. 
  
    
    
  
  16.  if(annotation.annotationType()!= Target.class && annotation.annotationType()!= Retention.class) {
    17. 
  
    
    
  
  17.  return isNeedToCreate(annotation.annotationType());
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21.  return false;
    22. 
  
    
    
  
  22.  }
    23. 
  
    
    
  
  23.  return false;
    24. 
  
    
    
  
  24.  }
    25. 
  
    
    
  

    26. 
  
    
    
  
  26.  /**
    27. 
  
    
    
  
  27.  * 加载相应的bean(Service)
    28. 
  
    
    
  
  28.  *
    29. 
  
    
    
  
  29.  * @param source
    30. 
  
    
    
  
  30.  */
    31. 
  
    
    
  
  31.  private static void LoadBeans(Class source) {
    32. 
  
    
    
  
  32.  ClassUtils util = new ClassUtils();
    33. 
  
    
    
  
  33.  List<String> classNames = util.loadClass(source);
    34. 
  
    
    
  
  34.  /** 实例化一个context **/
    35. 
  
    
    
  
  35.  ApplicationContext applicationContext = new ApplicationContext();
    36. 
  
    
    
  
  36.  for (String name : classNames) {
    37. 
  
    
    
  
  37.  try {
    38. 
  
    
    
  
  38.  var classInfo = Class.forName(name);
    39. 
  
    
    
  
  39.  /**
    40. 
  
    
    
  
  40.  * 检查是否声明了@Service
    41. 
  
    
    
  
  41.  **/
    42. 
  
    
    
  
  42.  if (classInfo.isAnnotation() == false && isNeedToCreate(classInfo)) {
    43. 
  
    
    
  
  43.  /**
    44. 
  
    
    
  
  44.  * 得到默认构造函数
    45. 
  
    
    
  
  45.  */
    46. 
  
    
    
  
  46.  var constructor = classInfo.getConstructor();
    47. 
  
    
    
  
  47.  if (constructor != null) {
    48. 
  
    
    
  
  48.  /**
    49. 
  
    
    
  
  49.  * 创建实例
    50. 
  
    
    
  
  50.  */
    51. 
  
    
    
  
  51.  var obj = constructor.newInstance();
    52. 
  
    
    
  
  52.  /** 保存bean**/
    53. 
  
    
    
  
  53.  applicationContext.addBean(obj);
    54. 
  
    
    
  
  54.  }
    55. 
  
    
    
  
  55.  }
    56. 
  
    
    
  
  56.  } catch (Throwable e) {
    57. 
  
    
    
  
  57.  e.printStackTrace();
    58. 
  
    
    
  
  58.  }
    59. 
  
    
    
  
  59.  }
    60. 
  
    
    
  
  60.  // other code
    61. 
  
    
    
  
  61.  }
    62. 
  
    
    
  
  62. }
    63.

  1. 将标有 @RestController的Bean取出。

OK 按照我们的思路,第一步很容易，第二步呢，我们需要一个Map来进行存储。这个Map应该是一个K-V结构。即 URL-HTTP方法-类方法这里面,为了方便管理，我们直接将三类信息封装成一个类 UrlMappingInfo,同时,为了保证方法可以正常的调用,我们需要把对应的bean也传入。

UrlMappingInfo.java

 
   
   
 
    
  
    
    
  
  1. public class UrlMappingInfo {
    2. 
  
    
    
  
  2.  private String url;
    3. 
  
    
    
  
  3.  private RequestMethod[] requestMethods;
    4. 
  
    
    
  
  4.  private Method method;
    5. 
  
    
    
  
  5.  private Object bean;
    6. 
  
    
    
  
  6.  public UrlMappingInfo(String url,RequestMethod[] requestMethods ,Method method,Object bean){
    7. 
  
    
    
  
  7.  this.url=url;
    8. 
  
    
    
  
  8.  this.requestMethods = requestMethods;
    9. 
  
    
    
  
  9.  this.method = method;
    10. 
  
    
    
  
  10.  this.bean=bean;
    11. 
  
    
    
  
  11.  }
    12. 
  
    
    
  

    13. 
  
    
    
  
  13.  public RequestMethod[] getRequestMethods() {
    14. 
  
    
    
  
  14.  return requestMethods;
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  
  16.  public Method getMethod(){
    17. 
  
    
    
  
  17.  return method;
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19.  public String getUrl(){
    20. 
  
    
    
  
  20.  return url;
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22.  public Object getBean(){
    23. 
  
    
    
  
  23.  return bean;
    24. 
  
    
    
  
  24.  }
    25. 
  
    
    
  
  25. }
    26. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. public class Application {
    2. 
  
    
    
  
  2.  /**
    3. 
  
    
    
  
  3.  * 加载相应的bean(Service)
    4. 
  
    
    
  
  4.  *
    5. 
  
    
    
  
  5.  * @param source
    6. 
  
    
    
  
  6.  */
    7. 
  
    
    
  
  7.  private static void LoadBeans(Class source) {
    8. 
  
    
    
  
  8.  // other code
    9. 
  
    
    
  
  9.  Map<String ,UrlMappingInfo> urlMappingInfoMap = new LinkedHashMap<>();
    10. 
  
    
    
  
  10.  /** 实例化一个context **/
    11. 
  
    
    
  
  11.  /** 注入bean **/
    12. 
  
    
    
  
  12.  /** 执行初始化方法 **/
    13. 
  
    
    
  
  13. 
  
    
    
  
  14.  for(Object ob :applicationContext.getAllBeans()){
    15. 
  
    
    
  
  15.  var classInfo = ob.getClass();
    16. 
  
    
    
  
  16.  if(classInfo.getDeclaredAnnotation(RestController.class)!=null){
    17. 
  
    
    
  
  17.  var requestMapping = classInfo.getDeclaredAnnotation(RequestMapping.class);
    18. 
  
    
    
  
  18.  String[] baseUrl={};
    19. 
  
    
    
  
  19.  if(requestMapping!=null){
    20. 
  
    
    
  
  20.  baseUrl = requestMapping.path();
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22.  for(var method:classInfo.getDeclaredMethods()){
    23. 
  
    
    
  
  23.  var methodRequestMapping = method.getDeclaredAnnotation(RequestMapping.class);
    24. 
  
    
    
  
  24.  if(methodRequestMapping!=null){
    25. 
  
    
    
  
  25.  String[] subUrl = methodRequestMapping.path();
    26. 
  
    
    
  
  26.  for (var base: baseUrl
    27. 
  
    
    
  
  27.  ) {
    28. 
  
    
    
  
  28.  for(var sub:subUrl){
    29. 
  
    
    
  
  29.  String url = base+sub;
    30. 
  
    
    
  
  30.  urlMappingInfoMap.put(url,new UrlMappingInfo(url,methodRequestMapping.method(), method,ob));
    31. 
  
    
    
  
  31.  }
    32. 
  
    
    
  
  32.  }
    33. 
  
    
    
  
  33.  }
    34. 
  
    
    
  
  34.  }
    35. 
  
    
    
  
  35.  }
    36. 
  
    
    
  
  36.  }
    37. 
  
    
    
  
  37.  //
    38. 
  
    
    
  
  38.  HttpServer server = null;
    39. 
  
    
    
  
  39.  try {
    40. 
  
    
    
  
  40.  server = HttpServer.create(new InetSocketAddress(8080), 0);
    41. 
  
    
    
  
  41.  server.createContext("/", new ServerHandler(urlMappingInfoMap));
    42. 
  
    
    
  
  42.  server.start();
    43. 
  
    
    
  
  43.  } catch (IOException e) {
    44. 
  
    
    
  
  44.  e.printStackTrace();
    45. 
  
    
    
  
  45.  }
    46. 
  
    
    
  

    47. 
  
    
    
  
  47.  }
    48. 
  
    
    
  
  48. }
    49.

ServerHandler.java

 
   
   
 
    
  
    
    
  
  1. public class ServerHandler implements HttpHandler {
    2. 
  
    
    
  
  2.  private final Map<String, UrlMappingInfo> urlMappingInfoMap;
    3. 
  
    
    
  
  3.  private ThreadPoolExecutor poolExecutor ;
    4. 
  
    
    
  
  4.  public ServerHandler(Map<String, UrlMappingInfo> urlMappingInfoMap){
    5. 
  
    
    
  
  5.  this.urlMappingInfoMap = urlMappingInfoMap;
    6. 
  
    
    
  
  6.  poolExecutor= (ThreadPoolExecutor) Executors.newCachedThreadPool();
    7. 
  
    
    
  
  7.  }
    8. 
  
    
    
  
  8.  @Override
    9. 
  
    
    
  
  9.  public void handle(HttpExchange exchange) throws IOException {
    10. 
  
    
    
  
  10.  poolExecutor.execute(new ServerRunnable(exchange,urlMappingInfoMap));
    11. 
  
    
    
  
  11.  }
    12. 
  
    
    
  
  12. }
    13.

可以看到,这里,我们已经同时将urlMappingInfoMap这个结构传到了ServerRunnable中,那么更改ServerRunnable就变得简单起来。ServerRunnable.java

 
   
   
 
    
  
    
    
  
  1. public class ServerRunnable implements Runnable {
    2. 
  
    
    
  

    3. 
  
    
    
  
  3.  private final HttpExchange exchange;
    4. 
  
    
    
  
  4.  private final Map<String, UrlMappingInfo> urlMappingInfoMap;
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  public ServerRunnable(HttpExchange exchange, Map<String, UrlMappingInfo> urlMappingInfoMap) {
    7. 
  
    
    
  
  7.  this.urlMappingInfoMap = urlMappingInfoMap;
    8. 
  
    
    
  
  8.  this.exchange = exchange;
    9. 
  
    
    
  
  9.  }
    10. 
  
    
    
  

    11. 
  
    
    
  
  11.  @Override
    12. 
  
    
    
  
  12.  public void run() {
    13. 
  
    
    
  
  13.  try {
    14. 
  
    
    
  
  14.  String url = this.exchange.getRequestURI().getPath();
    15. 
  
    
    
  
  15.  String method = this.exchange.getRequestMethod();
    16. 
  
    
    
  
  16.  System.out.println(method + " " + url);
    17. 
  
    
    
  

    18. 
  
    
    
  
  18.  try {
    19. 
  
    
    
  
  19.  var mappingInfo = this.urlMappingInfoMap.getOrDefault(url, null);
    20. 
  
    
    
  
  20.  if (mappingInfo == null) {
    21. 
  
    
    
  
  21.  exchange.sendResponseHeaders(404, 0);
    22. 
  
    
    
  
  22.  exchange.getResponseBody().write("Error Not Found.".getBytes());
    23. 
  
    
    
  
  23.  } else {
    24. 
  
    
    
  
  24.  boolean isAllowed = false;
    25. 
  
    
    
  
  25.  for (var allowedMethod : mappingInfo.getRequestMethods()) {
    26. 
  
    
    
  
  26.  if (allowedMethod.toString().equals(method)) {
    27. 
  
    
    
  
  27.  var ob = mappingInfo.getMethod().invoke(mappingInfo.getBean());
    28. 
  
    
    
  
  28.  exchange.sendResponseHeaders(200, 0);
    29. 
  
    
    
  
  29.  exchange.getResponseBody().write(ob.toString().getBytes());
    30. 
  
    
    
  
  30.  isAllowed=true;
    31. 
  
    
    
  
  31.  break;
    32. 
  
    
    
  
  32.  }
    33. 
  
    
    
  
  33.  }
    34. 
  
    
    
  
  34.  if(isAllowed ==false){
    35. 
  
    
    
  
  35.  exchange.sendResponseHeaders(405,0);
    36. 
  
    
    
  
  36.  exchange.getResponseBody().write("not allowed!".getBytes());
    37. 
  
    
    
  
  37.  }
    38. 
  
    
    
  
  38.  }
    39. 
  
    
    
  
  39.  }catch (Throwable e){
    40. 
  
    
    
  
  40.  exchange.sendResponseHeaders(500,0);
    41. 
  
    
    
  
  41.  exchange.getResponseBody().write("internal error".getBytes());
    42. 
  
    
    
  
  42.  }
    43. 
  
    
    
  
  43.  exchange.getResponseBody().flush();
    44. 
  
    
    
  
  44.  exchange.getResponseBody().close();
    45. 
  
    
    
  
  45.  } catch (IOException e) {
    46. 
  
    
    
  
  46.  e.printStackTrace();
    47. 
  
    
    
  
  47.  }
    48. 
  
    
    
  
  48.  }
    49. 
  
    
    
  
  49. }
    50.

现在编译运行整个程序. 你可以看到如下输出:

 
   
   
 
    
  
    
    
  
  1. the controller is created!
    2. 
  
    
    
  
  2. the service :fa68fc94-933b-4ae6-b65b-4f2814dad76a is created!
    3. 
  
    
    
  
  3. /hello is Mapping
    4. 
  
    
    
  
  4. The Mini-Boot Application Is Run! The Name is Hello
    5.

做一些测试

 
   
   
 
    
  
    
    
  
  1. curl localhost:8080/hello
    2. 
  
    
    
  
  2. Hello ,the Service is :fa68fc94-933b-4ae6-b65b-4f2814dad76a
    3. 
  
    
    
  

    4. 
  
    
    
  
  4. curl localhost:8080/hello1
    5. 
  
    
    
  
  5. Error Not Found.
    6. 
  
    
    
  

    7. 
  
    
    
  
  7. curl -X POST localhost:8080/hello
    8. 
  
    
    
  
  8. not allowed!
    9.

到现在为止，我们已经：

  1. 实现了简单的HttpServer

  2. 成功模拟了RestController和RequestMapping的功能

但是,我们代码,总是感觉有一些不对劲？

  1. Application.loadBean太复杂,太长了,重复的代码很多！

  2. 我已经有了ApplicationContext来管理Bean,为什么还要把bean包裹在UrlMap里一层一层传递？

  3. ServerRunnable那个类实现的实在丑了（丑出天际！！）有没有办法优雅一点？

OK，那么针这些问题，我们将在下一篇文章,对代码进行第一次重构和优化，顺带检测我们在设计和思考的过程中遗漏的地方。

其他

不给源码的分享都是耍流氓！

本来计划今天直接把servlet撸定。。但是似乎。。有点深，所以servlet的东西会单独放到一篇去写。

另外，由于面向功能的代码写起来实在是太丑了，所以准备先单独写一篇文档，去重构一些东西，以理清一些思路，算是我自己的一个整理吧。希望对您也是有用的。


参考

  1. 使用Java内置的Http Server构建Web应用 :


关于老拐瘦

  • 散养程序猿，野生架构狮

  • 二流搬砖工，三流摄影师

  • 假正经真逗比，装文艺实二逼

啥也不说，扫码关注吧




以上是关于跟我猜spring-boot:简单的HttpServer的主要内容，如果未能解决你的问题，请参考以下文章

rest-assured : Restful API 测试利器 - 真正的黑盒单元测试（跟Spring-Boot更配哦）

spring-boot之简单定时任务

Spring-boot简单的理解

明哥报错簿之 "javax.servlet.http.HttpServlet" was not found on the Java Build Path || HttpSer

spring-boot框架下的websocket服务

使用 Spring-Boot 创建一个简单的 JAR 而不是可执行的 JAR