【sylar】框架篇-Chapter18-HttpServlet 模块

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量182 收藏
点赞数
分类专栏： 【C++】服务器编程-实战 文章标签： linux 服务器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_38647413/article/details/125965094
版权

站在巨人的肩膀上

C++高性能分布式服务器框架

从零开始重写sylar C++高性能分布式服务器框架

概述

  • HTTPServlet 模块。
  • 提供 HTTP 请求路径到处理类的映射，用于规范化的 HTTP 消息处理流程。
  • HTTP Servlet 包括两部分，第一部分是 Servlet 对象，每个 Servlet 对象表示一种处理 HTTP 消息的方法；第二部分是 ServletDispatch，它包含一个请求路径到 Servlet 对象的映射，用于指定一个请求路径该用哪个 Servlet 来处理。

Servlet

  • 纯虚基类，子类必须重写其虚方法 handleClient。

FunctionServlet

  • 函数式 Servlet。
  • 继承自 Servlet。
  • 内含回调函数，其 handleClient 方法其实是直接调用回调函数。

NotFoundServlet

  • ServletDispatch 默认的 Servlet，404 那种。
  • 继承自 Servlet。

IServletCreator

  • 纯虚基类，子类必须重写其 get() 和 getName() 方法。

HoldServletCreator

  • 继承自 IServletCreator。

ServletCreator

  • 继承自 IServletCreator。
  • 模板类，根据类型创建 Servlet。

ServletDispatch

  • Servlet 分发器。
  • 继承自 Servlet。
  • 内含精准匹配的 Servlet map 和 模糊匹配的 Servlet vector，并提供增、删、查方法。

部分相关代码

/**
 * @filename    servlet.h
 * @brief   Servlet 模块
 * @author  L-ge
 * @version 0.1
 * @modify  2022-07-16
 */
#ifndef __SYLAR_HTTP_SERVLET_H__
#define __SYLAR_HTTP_SERVLET_H__

#include <memory>
#include <functional>
#include <string>
#include <vector>
#include <unordered_map>
#include "http.h"
#include "http_session.h"
#include "sylar/mutex.h"
#include "sylar/util.h"

namespace sylar
{

namespace http
{

/**
 * @brief   Servlet封装
 */
class Servlet
{
public:
    typedef std::shared_ptr<Servlet> ptr;

    Servlet(const std::string& name)
        : m_name(name)
    {}
    virtual ~Servlet() {}

    /**
     * @brief   处理请求
     *
     * @param   request http请求
     * @param   rsponse http响应
     * @param   session http连接
     *
     * @return  是否处理成功
     */
    virtual int32_t handle(sylar::http::HttpRequest::ptr request
                         , sylar::http::HttpResponse::ptr response
                         , sylar::http::HttpSession::ptr session) = 0;

    const std::string& getName() const { return m_name; }

protected:
    /// 名称(一般用于打印日志区分不同的Servlet)
    std::string m_name;
};

/**
 * @brief   函数式Servlet
 */
class FunctionServlet : public Servlet
{
public:
    typedef std::shared_ptr<FunctionServlet> ptr;

    /// 函数回调类型的定义
    typedef std::function< int32_t (sylar::http::HttpRequest::ptr request
                         , sylar::http::HttpResponse::ptr response
                         , sylar::http::HttpSession::ptr session)> callback;

    /**
     * @brief   构造函数
     *
     * @param   cb  回调函数
     */
    FunctionServlet(callback cb);

    virtual int32_t handle(sylar::http::HttpRequest::ptr request
                         , sylar::http::HttpResponse::ptr response
                         , sylar::http::HttpSession::ptr session) override;

private:
    /// 回调函数
    callback m_cb;
};

class IServletCreator
{
public:
    typedef std::shared_ptr<IServletCreator> ptr;
    virtual ~IServletCreator() {}
    virtual Servlet::ptr get() const = 0;
    virtual std::string getName() const = 0;
};

class HoldServletCreator : public IServletCreator 
{
public:
    typedef std::shared_ptr<HoldServletCreator> ptr;
    
    HoldServletCreator(Servlet::ptr slt)
        : m_servlet(slt) 
    {}

    Servlet::ptr get() const override { return m_servlet; }
    std::string getName() const override { return m_servlet->getName(); }

private:
    Servlet::ptr m_servlet;
};

template<class T>
class ServletCreator : public IServletCreator
{
public:
    typedef std::shared_ptr<ServletCreator> ptr;

    ServletCreator() {}

    Servlet::ptr get() const override { return Servlet::ptr(new T); }
    std::string getName() const override { return TypeToName<T>(); }
};

/**
 * @brief   Servlet分发器
 */
class ServletDispatch : public Servlet
{
public:
    typedef std::shared_ptr<ServletDispatch> ptr;
    typedef RWMutex RWMutexType;

    ServletDispatch();

    virtual int32_t handle(sylar::http::HttpRequest::ptr request
                         , sylar::http::HttpResponse::ptr response
                         , sylar::http::HttpSession::ptr session) override;

    void addServlet(const std::string& uri, Servlet::ptr slt);
    void addServlet(const std::string& uri, FunctionServlet::callback cb);

    /**
     * @brief   添加模糊匹配Servlet
     *
     * @param   uri 模糊匹配 /sylar_*
     * @param   slt Servlet
     */
    void addGlobServlet(const std::string& uri, Servlet::ptr slt);
    
    /**
     * @brief   添加模糊匹配Servlet
     *
     * @param   uri 模糊匹配 /sylar_*
     * @param   cb  FunctionServlet回调函数
     */
    void addGlobServlet(const std::string& uri, FunctionServlet::callback cb);
    void addServletCreatot(const std::string& uri, IServletCreator::ptr creator);
    void addGlobServletCreatot(const std::string& uri, IServletCreator::ptr creator);

    template<class T>
    void addServletCreator(const std::string& uri)
    {
        addServletCreator(uri, std::make_shared<ServletCreator<T> >());
    }

    template<class T>
    void addGlobServletCreator(const std::string& uri)
    {
        addGlobServletCreator(uri, std::make_shared<ServletCreator<T> >());
    }

    void delServlet(const std::string& uri);
    void delGlobServlet(const std::string& uri);

    Servlet::ptr getDefault() const { return m_default; }
    void setDefault(Servlet::ptr v) { m_default = v; }

    Servlet::ptr getServlet(const std::string& uri);
    Servlet::ptr getGlobServlet(const std::string& uri);

    /**
     * @brief   通过uri获取Servlet
     *
     * @param   uri uri
     *
     * @return  优先精准匹配，其次模糊匹配，最后返回默认
     */
    Servlet::ptr getMatchedServlet(const std::string& uri);

    void listAllServletCreator(std::map<std::string, IServletCreator::ptr>& infos);
    void listAllGlobServletCreator(std::map<std::string, IServletCreator::ptr>& infos);

private:
    /// 读写互斥量
    RWMutexType m_mutex;
    /// 精准匹配Servlet map
    /// uri(/sylar/xxx) -> servlet
    std::unordered_map<std::string, IServletCreator::ptr> m_datas;
    /// 模糊匹配Servlet 数组
    /// uri(/sylar/*) -> servlet
    std::vector<std::pair<std::string, IServletCreator::ptr> > m_globs;
    /// 默认servlet，所有路径都没匹配到时使用 
    Servlet::ptr m_default;
};

/**
 * @brief   NotFoundServlet(默认返回404)
 */
class NotFoundServlet : public Servlet
{
public:
    typedef std::shared_ptr<NotFoundServlet> ptr;

    NotFoundServlet(const std::string& name);

    virtual int32_t handle(sylar::http::HttpRequest::ptr request
                         , sylar::http::HttpResponse::ptr response
                         , sylar::http::HttpSession::ptr session) override;

private:
    std::string m_name;
    std::string m_content;
};

}

}

#endif


#include "servlet.h"
#include <fnmatch.h>

namespace sylar
{

namespace http
{

FunctionServlet::FunctionServlet(callback cb)
    : Servlet("FunctionServlet")
    , m_cb(cb)
{
}

int32_t FunctionServlet::handle(sylar::http::HttpRequest::ptr request
                     , sylar::http::HttpResponse::ptr response
                     , sylar::http::HttpSession::ptr session)
{
    return m_cb(request, response, session);
}

ServletDispatch::ServletDispatch()
    : Servlet("ServletDispatch")
{
    m_default.reset(new NotFoundServlet("sylar/1.0"));
}

int32_t ServletDispatch::handle(sylar::http::HttpRequest::ptr request
                     , sylar::http::HttpResponse::ptr response
                     , sylar::http::HttpSession::ptr session)
{
    // 通过请求的路径拿到Servlet进行处理
    auto slt = getMatchedServlet(request->getPath());
    if(slt)
    {
        slt->handle(request, response, session);
    }
    return 0;
}

void ServletDispatch::addServlet(const std::string& uri, Servlet::ptr slt)
{
    RWMutexType::WriteLock lk(m_mutex);
    m_datas[uri] = std::make_shared<HoldServletCreator>(slt);
}

void ServletDispatch::addServlet(const std::string& uri, FunctionServlet::callback cb)
{
    RWMutexType::WriteLock lk(m_mutex);
    m_datas[uri] = std::make_shared<HoldServletCreator>(std::make_shared<FunctionServlet>(cb));
}

void ServletDispatch::addGlobServlet(const std::string& uri, Servlet::ptr slt)
{
    RWMutexType::WriteLock lk(m_mutex);
    for(auto it = m_globs.begin(); it != m_globs.end(); ++it) 
    {
        // 把原来的删掉再把新的加进去
        if(it->first == uri) 
        {
            m_globs.erase(it);
            break;
        }
    }
    m_globs.push_back(std::make_pair(uri, std::make_shared<HoldServletCreator>(slt)));
}

void ServletDispatch::addGlobServlet(const std::string& uri, FunctionServlet::callback cb)
{
    return addGlobServlet(uri, std::make_shared<FunctionServlet>(cb));
}

void ServletDispatch::addServletCreatot(const std::string& uri, IServletCreator::ptr creator)
{
    RWMutexType::WriteLock lk(m_mutex);
    m_datas[uri] = creator;
}

void ServletDispatch::addGlobServletCreatot(const std::string& uri, IServletCreator::ptr creator)
{
    RWMutexType::WriteLock lk(m_mutex);
    for(auto it = m_globs.begin(); it != m_globs.end(); ++it)
    {
        if(it->first == uri) 
        {
            m_globs.erase(it);
            break;
        }
    }
    m_globs.push_back(std::make_pair(uri, creator));
}

void ServletDispatch::delServlet(const std::string& uri)
{
    RWMutexType::WriteLock lk(m_mutex);
    m_datas.erase(uri);
}

void ServletDispatch::delGlobServlet(const std::string& uri)
{
    RWMutexType::WriteLock lk(m_mutex);
    for(auto it = m_globs.begin(); it != m_globs.end(); ++it)
    {
        if(it->first == uri)
        {
            m_globs.erase(it);
            break;
        }
    }
}

Servlet::ptr ServletDispatch::getServlet(const std::string& uri)
{
    RWMutexType::ReadLock lk(m_mutex);
    auto it = m_datas.find(uri);
    return it == m_datas.end() ? nullptr : it->second->get();
}

Servlet::ptr ServletDispatch::getGlobServlet(const std::string& uri)
{
    RWMutexType::ReadLock lk(m_mutex);
    for(auto it = m_globs.begin(); it != m_globs.end(); ++it) 
    {
        if(it->first == uri)
        {
            return it->second->get();
        }
    }
    return nullptr;
}

Servlet::ptr ServletDispatch::getMatchedServlet(const std::string& uri)
{
    RWMutexType::ReadLock lk(m_mutex);
    auto mit = m_datas.find(uri);
    if(mit != m_datas.end())                // 先精准
    {
        return mit->second->get();
    }

    for(auto it = m_globs.begin(); it != m_globs.end(); ++it)   // 再模糊
    {
        // fnmatch(pattern, string, flags);
        // pattern: 要检索的模式；string: 要检查的字符串或文件；flags: 可选
        if(!fnmatch(it->first.c_str(), uri.c_str(), 0)) 
        {
            return it->second->get();
        }
    }
    return m_default;       // 最后默认
}

void ServletDispatch::listAllServletCreator(std::map<std::string, IServletCreator::ptr>& infos)
{
    RWMutexType::ReadLock lk(m_mutex);
    for(auto& i : m_datas) 
    {
        infos[i.first] = i.second;
    }
}

void ServletDispatch::listAllGlobServletCreator(std::map<std::string, IServletCreator::ptr>& infos)
{
    RWMutexType::ReadLock lk(m_mutex);
    for(auto& i : m_globs) 
    {
        infos[i.first] = i.second;
    }
}

NotFoundServlet::NotFoundServlet(const std::string& name)
    : Servlet("NotFoundServlet")
    , m_name(name)
{
    m_content = "<html><head><title>404 Not Found"
                "</title></head><body><center><h1>404 Not Found</h1></center>"
                "<hr><center>" + name + "</center></body></html>";
}

int32_t NotFoundServlet::handle(sylar::http::HttpRequest::ptr request
                     , sylar::http::HttpResponse::ptr response
                     , sylar::http::HttpSession::ptr session)
{
    response->setStatus(sylar::http::HttpStatus::NOT_FOUND);
    response->setHeader("Server", "sylar/1.0.0");
    response->setHeader("Content-Type", "text/html");
    response->setBody(m_content);
    return 0;
}

}

}

广告时间：基于sylar框架实现的小demo(希望给个star)

基于redis的参数查询服务

江湖人称菠萝包
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【sylar】框架篇-Chapter17-HttpServer 模块
江湖人称菠萝包
07-25 263
【sylar】框架篇-Chapter17-HttpServer 模块
C++高性能服务器框架 – SYLAR - 线程模块
sylar的专栏
05-22 3068
这里写自定义目录标题线程库选择线程类信号量(Semaphore)互斥量(Mutex)其他 线程库选择 C++11中提供了std::thread, std::mutex, std::condition_variable等线程相关的类。但是还是不够完善，比如没有提供读写锁。没有提供spinlock，虽然c++11里面的atomic可以用来实现CAS锁。 对于高并发服务器来说，很多数据，大多数时候，都...
C++高性能服务器框架 – SYLAR – 01环境配置
sylar的专栏
06-11 1731
环境配置 Linux系统 VIM7.4+ GCC 4.8+ GDB 8.3 CMAKE 2.8+ ragel Linux系统安装 从centos官网下载ios文件，虚拟机加载ios文件，进行最小化安装即可 视频中采用的是centos7.6，链接地址 http://isoredirect.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-Minima...
C++高性能服务器（sylar）日志系统
qq_48185092的博客
10-23 502
最近学完了C++的基础部分，找了个服务器的项目，跟着sylar大佬搭建服务器，这个项目有点难，单是一个日志系统，视频总共才4个小时，我花了一周多的时间才完成，不过在这一周里学到的东西确实很多，一方面是将前面学的基础知识应用到项目中，这段过程个人感觉很重要，这就像是学英语，虽然单词全背会了，但真正在阅读理解中遇到的时候，还是记不到单词的意思。另一方面，跟着大佬敲代码，也渐渐养成了一种良好的编码习惯，以及学到了很多没学过的知识。
【sylar】框架篇-Chapter23-模块篇总结
江湖人称菠萝包
07-26 494
【sylar】框架篇-Chapter23-模块篇总结
【sylar】框架篇-Chapter1-搭建开发环境
江湖人称菠萝包
07-24 1112
【sylar】框架篇-Chapter1-搭建开发环境。
【sylar】框架篇-Chapter13-http 模块
江湖人称菠萝包
07-25 445
【sylar】框架篇-Chapter13-http 模块
【sylar】框架篇-Chapter5-协程模块
江湖人称菠萝包
07-24 846
【sylar】框架篇-Chapter5-协程模块
sylar-env-1.1.0-1.el7.x86_64.rpm
04-20
sylar-env-1.1.0-1.el7.x86_64.rpm
Sylar:学习开发Sylar服务器框架
03-29
Sylar-master文件夹很可能是项目源码的根目录，包含项目的头文件、源文件、构建脚本等。通过阅读源码，我们可以更深入地了解Sylar的内部机制和设计思想。 总之，Sylar服务器框架是一个结合了C++强大特性和高效网络...
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http模块，TcpServer模块，Websocket模块，Https模块等，Smtp邮件模块，MySQL，SQLite3，ORM，Redis，Zookeeper）
01-30
`sylar-master`这个文件名可能指的是项目的源码主分支，包含了所有上述特性的实现代码。对于C++开发者来说，这个框架提供了全面的工具集，可以帮助他们快速开发出高性能的网络应用。无论是构建大型Web服务，还是设计...
C++聊天室服务器，基于sylar框架开发，使用http服务器做资源服务，
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。...
CPU-Z，参数解读
03-10
CPU-Z--参数解读文档，
【Linux】进程间通信——匿名管道
最新发布
2201_76024104的博客
07-08 709
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 307
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux存储管理I
m0_54563444的博客
07-03 904
主要知识点: 基本分区、逻辑卷LVM、EXT3/4/XFS文件系统、RAID。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 732
主要介绍Cmake的安装方法，及自己安装的过程
nginx安装（win和linux）
f552126506的博客
07-07 529
nginx安装（win和linux）
shell scp -r命令
03-15
shell中的scp命令用于在本地主机和远程主机之间复制文件或目录。使用scp命令可以通过网络安全地传输文件。下面是使用scp命令复制文件或目录的示例[^2]： ```shell scp -r source_directory username@destination_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值