C++程序服务化封装

最新推荐文章于 2022-01-13 14:33:10 发布
置顶 最新推荐文章于 2022-01-13 14:33:10 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： C++ 文章标签： C++ 服务化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011261430/article/details/76528993
版权

之前有一篇“C++exe做系统服务，自动加载”是C语言风格的方式，使用是没有问题，但是很杂乱，这里对之封装，简化使用方式。

WindowsService.h

#pragma once
#include <string>
using namespace std;

//注入Windows服务类
class CWindowsService
{
public:
    CWindowsService();//构造函数
    CWindowsService(const string strServiceName);//构造函数
    ~CWindowsService();//析构函数

    void SetServiceName(const string strServiceName);//设置服务名称(所有操作前必须调用)

    void Run();//一键自助安装服务   

private:
    bool Install(int & dwCurrentState);//安装服务
    bool Uninstall();//卸载服务
    bool Start();//启动服务
    bool Stop();//停止服务

    static void ServiceMain(DWORD argc, LPTSTR *argv);//创建服务主要处理逻辑
    static void ServiceCtrlHandler(DWORD nControlCode);//接受servicecontrol 命令
    BOOL UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwServiceSpecificExitCode, DWORD dwCheckPoint, DWORD dwWaitHint);//更新服务状态 更新失败即结束服务
    BOOL StartServiceThread();//创建主窗口线程
    static DWORD ServiceExecutionThread(LPDWORD param);//创建服务主线程
    void KillService();// 停止服务 即结束主窗口线程 设置状态失败或是收到STOP SERVICE 命令调用此函数


private:
    HANDLE m_hServiceThread;
    SERVICE_STATUS_HANDLE m_nServiceStatusHandle;
    HANDLE m_EventkillService;
    HWND m_hMain;
    BOOL m_bServiceRunning;
    DWORD m_dwServiceCurrentStatus;

    string m_ServiceDisplayName;
    string m_ServiceName;
};

extern CWindowsService *g_pWindowsService;

WindowsService.cpp

#include "stdafx.h"
#include "WindowsService.h"
#include "server.h"

CWindowsService *g_pWindowsService = NULL;

//构造函数
CWindowsService::CWindowsService()
{
    m_hServiceThread = 0;
    m_nServiceStatusHandle = 0;
    m_EventkillService = NULL;
    m_hMain = NULL;
    m_bServiceRunning = FALSE;
    m_dwServiceCurrentStatus = 0;
}

CWindowsService::CWindowsService(const string strServiceName)
{
    CWindowsService();
    m_ServiceDisplayName = strServiceName;
    m_ServiceName = strServiceName;
}

//析构函数
CWindowsService::~CWindowsService()
{
}

//设置服务名称
void CWindowsService::SetServiceName(const string strServiceName)
{
    m_ServiceDisplayName = strServiceName;
    m_ServiceName = strServiceName;
}

//一键自助安装服务
void CWindowsService::Run()
{
    BOOL bNT = FALSE;
    BOOL bInstalled = FALSE;
    int dwCurrentState = 0;

    SC_HANDLE hService, hScm;
    hScm = OpenSCManager(0, 0, SC_MANAGER_CONNECT);

    if (hScm)
    {
        bNT = TRUE;
        hService = OpenService(hScm, m_ServiceName.c_str(), GENERIC_READ);
        if (hService)
        {
            bInstalled = TRUE;

            SERVICE_STATUS ServiceStatus;
            if (QueryServiceStatus(hService, &ServiceStatus))
            {
                dwCurrentState = ServiceStatus.dwCurrentState;
                if (dwCurrentState == SERVICE_START_PENDING)
                {
                    CloseServiceHandle(hService);
                    CloseServiceHandle(hScm);

                    char chServiceName[256] = "";
                    strcpy_s(chServiceName, m_ServiceName.c_str());
                    const SERVICE_TABLE_ENTRY servicetable[] =
                    {
                        { chServiceName, (LPSERVICE_MAIN_FUNCTION)ServiceMain },
                        { NULL,NULL }
                    };
                    BOOL success;
                    success = StartServiceCtrlDispatcher(servicetable);
                    if (!success)
                    {
                        int nError = GetLastError();
                        TCHAR buffer[1000];
                        _stprintf_s(buffer, _T("启动服务出错，错误码：%d"), nError);
                        MessageBox(0, buffer, m_ServiceName.c_str(), MB_OK);
                    }
                    return ;
                }
            }
            CloseServiceHandle(hService);
        }
        CloseServiceHandle(hScm);
    }

    if (!bInstalled)
    {
        if (MessageBox(0, _T("是否安装服务?"), m_ServiceName.c_str(), MB_YESNO | MB_ICONQUESTION) == IDYES)
        {
            if (!Install(dwCurrentState))
            {
                MessageBox(0, _T("安装服务失败"), m_ServiceName.c_str(), MB_OK);
                return;
            }
        }
        else
            return ;
    }

    if (dwCurrentState == SERVICE_STOPPED && (MessageBox(0, _T("启动服务?"), m_ServiceName.c_str(), MB_YESNO | MB_ICONQUESTION) == IDYES))
    {
        if (!Start())
        {
            MessageBox(0, _T("启动服务失败"), m_ServiceName.c_str(), MB_OK);
        }

        return;
    }

    if (dwCurrentState == SERVICE_STOPPED && (MessageBox(0, _T("卸载服务?"), m_ServiceName.c_str(), MB_YESNO | MB_ICONQUESTION) == IDYES))
    {
        if (!Uninstall())
        {
            MessageBox(0, _T("卸载服务失败"), m_ServiceName.c_str(), MB_OK);
        }
        return ;
    }

    if (dwCurrentState != SERVICE_STOPPED && (MessageBox(0, _T("停止服务?"), m_ServiceName.c_str(), MB_YESNO | MB_ICONQUESTION) == IDYES))
    {
        if (!Stop())
        {
            MessageBox(0, _T("停止服务失败"), m_ServiceName.c_str(), MB_OK);
        }
        return;
    }

    if (dwCurrentState == SERVICE_STOPPED)
        return ;
}

//安装服务
bool CWindowsService::Install(int & dwCurrentState)
{
    SC_HANDLE hService, hScm;

    hScm = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
    if (!hScm)
    {
        return false;
    }
    int nStartMode = SERVICE_AUTO_START;

    if (MessageBox(0, _T("自动运行服务?"), m_ServiceName.c_str(), MB_YESNO | MB_ICONQUESTION) == IDYES)
    {
        nStartMode = SERVICE_AUTO_START;
    }

    TCHAR buffer[MAX_PATH + 3];
    buffer[0] = '"';
    DWORD written = GetModuleFileName(0, buffer + 1, MAX_PATH);
    if (!written)
    {
        CloseServiceHandle(hScm);
        MessageBox(0, _T("创建服务失败，未能获取应用程序当前的路径"), m_ServiceName.c_str(), MB_ICONSTOP);
        return false;
    }
    buffer[written + 1] = '"';
    buffer[written + 2] = 0;

    hService = CreateService(hScm, m_ServiceName.c_str(),
        m_ServiceDisplayName.c_str(),
        SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS, nStartMode,
        SERVICE_ERROR_NORMAL,
        buffer,
        0, 0, NULL, 0, 0);
    if (!hService)
    {
        CloseServiceHandle(hScm);
        return false;
    }

    SERVICE_DESCRIPTION description;
    memset(&description, 0, sizeof(SERVICE_DESCRIPTION));
    TCHAR szdescription[100];
    memset(szdescription, 0, sizeof(TCHAR) * 100);
    _stprintf_s(szdescription, 100, _T("%s"), m_ServiceName.c_str());//服务名称
    description.lpDescription = szdescription;
    ChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, &description);

    CloseServiceHandle(hService);
    CloseServiceHandle(hScm);
    dwCurrentState = SERVICE_STOPPED;

    return true;
}

//卸载服务
bool CWindowsService::Uninstall()
{
    SC_HANDLE hService, hScm;
    hScm = OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
    if (!hScm)
    {
        return false;
    }
    hService = OpenService(hScm, m_ServiceName.c_str(), SERVICE_ALL_ACCESS);
    if (!hService)
    {
        CloseServiceHandle(hScm);
        return false;
    }
    DeleteService(hService);
    CloseServiceHandle(hService);
    CloseServiceHandle(hScm);

    return true;
}

//启动服务
bool CWindowsService::Start()
{
    SC_HANDLE hService, hScm;
    hScm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
    if (!hScm)
    {
        return false;
    }
    hService = OpenService(hScm, m_ServiceName.c_str(), SERVICE_ALL_ACCESS);
    if (!hService)
    {
        CloseServiceHandle(hScm);
        return false;
    }
    if (StartService(hService, 0, NULL) == 0)
    {
        DWORD dwerr = GetLastError();
        Sleep(1);
    }
    CloseServiceHandle(hService);
    CloseServiceHandle(hScm);

    return true;
}

//停止服务
bool CWindowsService::Stop()
{
    SC_HANDLE hService, hScm;
    hScm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
    if (!hScm)
    {
        return false;
    }
    hService = OpenService(hScm, m_ServiceName.c_str(), SERVICE_ALL_ACCESS);
    if (!hService)
    {
        CloseServiceHandle(hScm);
        return false;
    }
    SERVICE_STATUS status;
    ControlService(hService, SERVICE_CONTROL_STOP, &status);
    CloseServiceHandle(hService);
    CloseServiceHandle(hScm);

    return true;
}

//创建服务主要处理逻辑
void CWindowsService::ServiceMain(DWORD argc, LPTSTR * argv)
{
    BOOL success;
    g_pWindowsService->m_nServiceStatusHandle = RegisterServiceCtrlHandler(g_pWindowsService->m_ServiceName.c_str(), (LPHANDLER_FUNCTION)(ServiceCtrlHandler));
    if (!g_pWindowsService->m_nServiceStatusHandle)
        return;

    success = g_pWindowsService->UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 1, 3000);
    if (!success)
        return;

    g_pWindowsService->m_EventkillService = CreateEvent(0, TRUE, FALSE, 0);//创建时间等待结束
    if (g_pWindowsService->m_EventkillService == NULL)
        return;

    success = g_pWindowsService->UpdateServiceStatus(SERVICE_START_PENDING, NO_ERROR, 0, 2, 1000);
    if (!success)
        return;

    success = g_pWindowsService->StartServiceThread(); //开启主线程
    if (!success)
        return;

    g_pWindowsService->m_dwServiceCurrentStatus = SERVICE_RUNNING;
    success = g_pWindowsService->UpdateServiceStatus(SERVICE_RUNNING, NO_ERROR, 0, 0, 0);
    if (!success)
        return;

    WaitForSingleObject(g_pWindowsService->m_EventkillService, INFINITE); //等待结束
    CloseHandle(g_pWindowsService->m_EventkillService);
    WaitForSingleObject(g_pWindowsService->m_hServiceThread, INFINITE); // 更待结束线程结束
    CloseHandle(g_pWindowsService->m_hServiceThread);
    g_pWindowsService->UpdateServiceStatus(SERVICE_STOPPED, NO_ERROR, 0, 0, 0);
}

//接受servicecontrol 命令
void CWindowsService::ServiceCtrlHandler(DWORD nControlCode)
{
    BOOL success;
    switch (nControlCode)
    {
    case SERVICE_CONTROL_SHUTDOWN:
    case SERVICE_CONTROL_STOP:
        g_pWindowsService->m_dwServiceCurrentStatus = SERVICE_STOP_PENDING;
        success = g_pWindowsService->UpdateServiceStatus(SERVICE_STOP_PENDING, NO_ERROR, 0, 1, 3000);
        g_pWindowsService->KillService();
        return;
    default:
        break;
    }
    g_pWindowsService->UpdateServiceStatus(g_pWindowsService->m_dwServiceCurrentStatus, NO_ERROR, 0, 0, 0);
}

//更新服务状态 更新失败即结束服务
BOOL CWindowsService::UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWin32ExitCode, DWORD dwServiceSpecificExitCode, DWORD dwCheckPoint, DWORD dwWaitHint)
{
    BOOL success;
    SERVICE_STATUS nServiceStatus;
    nServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    nServiceStatus.dwCurrentState = dwCurrentState;
    if (dwCurrentState == SERVICE_START_PENDING)
    {
        nServiceStatus.dwControlsAccepted = 0;
    }
    else
    {
        nServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP
            | SERVICE_ACCEPT_SHUTDOWN;
    }
    if (dwServiceSpecificExitCode == 0)
    {
        nServiceStatus.dwWin32ExitCode = dwWin32ExitCode;
    }
    else
    {
        nServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
    }
    nServiceStatus.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
    nServiceStatus.dwCheckPoint = dwCheckPoint;
    nServiceStatus.dwWaitHint = dwWaitHint;

    success = SetServiceStatus(m_nServiceStatusHandle, &nServiceStatus);
    if (!success)
    {
        KillService();
        return success;
    }
    else
    {
        return success;
    }
}

//创建主窗口线程
BOOL CWindowsService::StartServiceThread()
{
    DWORD id;
    m_hServiceThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ServiceExecutionThread, 0, 0, &id);
    if (m_hServiceThread == 0)
    {
        return FALSE;
    }
    else
    {
        m_bServiceRunning = TRUE;
        return true;
    }
}

//创建服务主线程(应用主要启动)
DWORD CWindowsService::ServiceExecutionThread(LPDWORD param)
{
    BOOL res = TRUE;

    //启动
    CServer *pServer = new CServer;
    g_pWindowsService->m_bServiceRunning = pServer->Create();


    if (!g_pWindowsService->m_bServiceRunning)
    {
        return 0;
    }
    else
    {
        g_pWindowsService->m_hMain = pServer->GetMainHwnd();

    }

    MSG msg;
    while (GetMessage(&msg, 0, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    SetEvent(g_pWindowsService->m_EventkillService);
    return 0;
}

// 停止服务 即结束主窗口线程 设置状态失败或是收到STOP SERVICE 命令调用此函数
void CWindowsService::KillService()
{
    if (m_hMain != NULL)
        PostMessage(m_hMain, WM_CLOSE, 0, 0); //结束窗口
    m_bServiceRunning = FALSE;
}
  • 需要修改地方
    WindowsService.cpp
    //创建服务主线程(应用主要启动)
    DWORD CWindowsService::ServiceExecutionThread(LPDWORD param)
    修改该函数里面的
    //启动
    CServer *pServer = new CServer;
    g_pWindowsService->m_bServiceRunning = pServer->Create();

这里就是服务真正需要运行的代码，对应修改。

  • 调用方式

#include "stdafx.h"
#include "WindowsService.h"

#ifndef _DEBUG
#pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )
#endif

int _tmain(int argc, _TCHAR* argv[])
{
#ifdef _DEBUG//调试
    //调试使用
#else//服务（发布使用）
    //设置服务名称
    string strServiceName = "ServiceName";
    g_pWindowsService = new CWindowsService(strServiceName);
    g_pWindowsService->Run();//注册服务，启动
#endif

    return 0;
}
仅仅学会简单
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
C++把程序转成服务
07-09
C++把应用程序转成服务，里面有demo,把相应h和cpp拷到自己项目就可以使用
用C/C++创建windows服务程序
weixin_30527143的博客
08-29 448
转载：https://blog.csdn.net/chenyujing1234/article/details/8023816 一、演示过程下方代码演示了如何使用vs(C/C++)创建windows服务程序 工程文件下载地址: http://download.csdn.net/download/sooth2008/2759082 使用visual studio创建一个win32...
大规模微服务实战经验
微服务技术与实践专栏
01-29 359
作者 | 李林锋《Netty 进阶之路》、《分布式服务框架原理与实践》作者李林锋分享大规模业务团队实施微服务的经验和教训。引言背景对于一些复杂的业务系统(例如CRM)进...
微服务技术架构剖析及微服务带来的优势
wangpf2011的博客
12-05 4294
框架之初为了快速迭代出产品，而选择简单的技术架构，构建单体应用。这些架构可以适应初期业务的快速发展，但是随着业务变得越来越复杂，就会发现这些架构越来越难支撑业务的发展，各业务模块相互调用，业务边界越来越模糊，同时对系统更正性、完善性、预防性等维护工作越来越难，往往牵一发而动全身，最终可能造成测试工作不足，上线后才发现各种bug。另外会出现在一个类中写好几千行代码，一个方法中到处都是if else语...
C++ 将控制台程序改成服务
weixin_44229493的博客
11-06 1930
C++ 将控制台程序改成服务 C++ 将控制台程序改成服务 给打家介绍一个简单易用的方法将控制台程序改成服务的方法。直接上代码 #include <iostream> #include "Windows.h" #define SERVICE_NAME "atest" SERVICE_STATUS ServiceStatus; SERVICE_STATUS_HANDLE hServiceStatusHandle; void WINAPI ServiceHandler(DWORD fdwContr
C++socket编程学习总结（3）封装TCP服务器的几个常用方法
My Struggle
03-20 503
上一篇：https://blog.csdn.net/qq_41938259/article/details/104916488基本实现了TCP服务器的建立，它支持多个用户的接入。但是一遍遍写创建sock、监听、接收、发送这些语句，令人十分烦躁，还好C++是面向对象编程，拥有继承、封装、多态等特性，我们可以建立一个XTcp.h头文件，用于建立XTcp类，而新建一个XTcp.cpp文件用于实现Xtcp...
C++ Oracle标准数据库封装
11-26
通过以上所述，我们可以看到C++ Oracle标准数据库封装涉及的内容广泛且复杂，但一旦熟悉了这个过程，就可以构建出强大而高效的数据库应用程序。在实践中，不断学习和优化，是提升数据库操作性能的关键。
c++ 服务器开发精髓 pdf
最新发布
08-10
【C++服务器开发精髓】是关于构建Windows服务程序的指南，尤其强调了使用C++进行开发。虽然C++因其面向对象特性而常用于高级服务开发，但对于初学者来说，理解服务的基本工作原理时，C语言可能更为合适。这是因为...
C++编写windows服务程序示例代码
02-04
以下是一个简单的C++服务程序框架： ```cpp #include // 服务控制处理函数 void WINAPI ServiceMain(DWORD argc, LPTSTR* argv) { // 注册服务控制调度器 // ... } // 服务控制处理调度器 DWORD WINAPI ...
redis c++封装.zip
04-28
通过以上知识点的实现，一个完整的Redis C++封装库将能帮助开发者高效地在C++项目中集成和使用Redis服务。同时，为了适应不断变化的Redis版本和特性，封装库也需要定期更新和维护，以保持兼容性和最佳性能。
C++调用WebService封装成DLL，供外部调用
07-11
C++调用WebService封装成DLL，供外部调用
C 语言编写 Windows 服务程序的五个步骤
思则不罔
08-27 1136
当初我写第一个 NT 服务时，我到 MSDN 上找例子。在那里我找到了一篇 Nigel Thompson 写的文章：“Creating a Simple Win32 Service in C++”，这篇文章附带一个 C++ 例子。虽然这篇文章很好地解释了服务的开发过程，但是，我仍然感觉缺少我需要的重要信息。我想理解通过什么框架，调用什么函数，以及何时调用，但 C++ 在这方面没有让我轻松多少。面向
如何把c++程序转成服务_程序员如何打造属于自己的云笔记服务
weixin_39867662的博客
11-30 205
前言在这个互联网知识呈爆炸增长的时代，作为一个程序员要掌握的知识越来越多，然再好的记性也不如烂笔头，有了笔记我们就是可以时常扒拉扒拉以前的知识，顺便可以整理下自己的知识体系。如今市面上云笔记产品，说实在真不少，什么有道，印象，为知等等，本人目前使用的是有道，无它，免费而已其他几个倒没怎么接触过，毕竟重复的产品一个就够了。笔记用了有三年多时间了，基本都是写写工作日志，备忘一下工作中遇到的脚本命令，顺...
C++ 编写WebService服务
热门推荐
lixiang987654321的专栏
03-19 1万+
大家好，很久没有写相关的技术文章了，最近一直考虑一个问题，就是对于一个老C++程序员来说，后续路程如何走下去：该学写什么，了解写什么？想了想，突然注意到最近公司接到的客户需求：将监控行业相关数据以webservice接口形式提供给外部调用。之前在了解onvif协议的时候，顺便了解过gsoap工具和soap协议，但是不深也未曾亲自实现过，想想在北京的时候一个同事在我面前提过webservice，说功
使用c++制作微服务计算服务
qianbo042311的博客
01-13 2252
其他链接 上次使用了go来制作微服务计算服务 go制作微服务计算服务 c++制作标准差服务计算 使用c++的计算服务速度是更快的,一下只是一个计算标准差的函数样例，和go服务之间进行交换可以使用更简单的c，如果使用c++，则可以简化计算过程 #pragma once #include <vector> //标准差 //数据是五分钟的，就是sdann //数据是24小时的，就是sdnn double get_stddev(std::vector<double> &data);
2021-07-16服务封装
weixin_45792025的博客
07-16 117
#ifndef _EasyTcpServer_hpp_ #define _EasyTcpServer_hpp_ #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #define _WINSOCK_DEPRECATED_NO_WARNINGS #include<windows.h> #include<WinSock2.h> #pragma comment(lib,"ws2_32.lib") #else #include<unistd
简述类的封装的定义、具体步骤和好处
qq_36607688的博客
11-24 6764
 定义；隐藏类的一些具体实现，通过提供一些接口来实现一些功能，将类的状态信息隐藏在类的外部，不允许       在类的外部直接访问，而是通过这个类提供的一些方法来对属性进行操作以及访问。 步骤：修改属性的可见性来限制对属性的访问；为每个属性创建一对赋值       (setter)方法和取值(getter)方法，用于对这些属性的存取；在赋值方法中，加入对       属性的存取控
VC Windows系统服务创建代码
weixin_34404393的博客
03-07 135
Windows系统服务创建步骤,常用类封装,废话不多说,直接上代码 1 // ServceDemo.cpp : 定义控制台应用程序的入口点。 2 // 3 4 #include "stdafx.h" 5 #include "WindwosService.h" 6 7 unsigned __stdcall SvcRun (void *Params ) 8 ...
Visual C++ 可视化程序设计教程
此外，还介绍了Visual C++作为可视化集成开发环境(IDE)的特点和优势，如源程序编辑器、调试器、系统函数库、资源管理器、例程库以及在线帮助。" 在可视化程序设计中，Visual C++是一个重要的工具，它允许开发者在...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值