C++反射机制：可变参数模板实现C++反射

Wesley13
• 阅读 756

1. 概要

  本文描述一个通过C++可变参数模板实现C++反射机制的方法。该方法非常实用，在Nebula高性能网络框架中大量应用，实现了非常强大的动态加载动态创建功能。Nebula框架在码云的仓库地址。

  C++11的新特性--可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。关于可变参数模板的原理和应用不是本文重点，不过通过本文中的例子也可充分了解可变参数模板是如何应用的。

  熟悉Java或C#的同学应该都知道反射机制，很多有名的框架都用到了反射这种特性，简单的理解就是只根据类的名字（字符串）创建类的实例。 C++并没有直接从语言上提供反射机制给我们用，不过无所不能的C++可以通过一些trick来实现反射。Bwar也是在开发Nebula框架的时候需要用到反射机制，在网上参考了一些资料结合自己对C++11可变参数模板的理解实现了C++反射。


2. C++11之前的模拟反射机制实现

  Nebula框架是一个高性能事件驱动通用网络框架，框架本身无任何业务逻辑实现，却为快速实现业务提供了强大的功能、统一的接口。业务逻辑通过从Nebula的Actor类接口编译成so动态库，Nebula加载业务逻辑动态库实现各种功能Server，开发人员只需专注于业务逻辑代码编写，网络通信、定时器、数据序列化反序列化、采用何种通信协议等全部交由框架完成。

  开发人员编写的业务逻辑类从Nebula的基类派生，但各业务逻辑派生类对Nebula来说是完全未知的，Nebula需要加载这些动态库并创建动态库中的类实例就需要用到反射机制。第一版的Nebula及其前身Starship框架以C++03标准开发，未知类名、未知参数个数、未知参数类型、更未知实参的情况下，Bwar没想到一个有效的加载动态库并创建类实例的方式。为此，将所有业务逻辑入口类的构造函数都设计成无参构造函数。

  Bwar在2015年未找到比较好的实现，自己想了一种较为取巧的加载动态库并创建类实例的方法（这还不是反射机制，只是实现了可以或需要反射机制来实现的功能）。这个方法在Nebula的C++03版本中应用并实测通过，同时也是在一个稳定运行两年多的IM底层框架Starship中应用。下面给出这种实现方法的代码：

CmdHello.hpp:

#ifdef __cplusplus
extern "C" {
#endif
// @brief 创建函数声明
// @note 插件代码编译成so后存放到plugin目录，框架加载动态库后调用create()创建插件类实例。
neb::Cmd* create();
#ifdef __cplusplus
}
#endif

namespace im
{

class CmdHello: public neb::Cmd
{
public:
    CmdHello();
    virtual ~CmdHello();
    virtual bool AnyMessage();
};

} /* namespace im */

CmdHello.cpp:

#include "CmdHello.hpp"

#ifdef __cplusplus
extern "C" {
#endif
neb::Cmd* create()
{
    neb::Cmd* pCmd = new im::CmdHello();
    return(pCmd);
}
#ifdef __cplusplus
}
#endif

namespace im
{

CmdHello::CmdHello()
{
}

CmdHello::~CmdHello()
{
}

bool CmdHello::AnyMessage()
{
    std::cout << "CmdHello" << std::endl;
    return(true);
}

}

  实现的关键在于create()函数，虽然每个动态库都写了create()函数，但动态库加载时每个create()函数的地址是不一样的，通过不同地址调用到的函数也就是不一样的，所以可以创建不同的实例。下面给出动态库加载和调用create()函数，创建类实例的代码片段：

void* pHandle = NULL;
    pHandle = dlopen(strSoPath.c_str(), RTLD_NOW);
    char* dlsym_error = dlerror();
    if (dlsym_error)
    {
        LOG4_FATAL("cannot load dynamic lib %s!" , dlsym_error);
        if (pHandle != NULL)
        {
            dlclose(pHandle);
        }
        return(pSo);
    }
    CreateCmd* pCreateCmd = (CreateCmd*)dlsym(pHandle, strSymbol.c_str());
    dlsym_error = dlerror();
    if (dlsym_error)
    {
        LOG4_FATAL("dlsym error %s!" , dlsym_error);
        dlclose(pHandle);
        return(pSo);
    }
    Cmd* pCmd = pCreateCmd();

  对应这动态库加载代码片段的配置文件如下：

{"cmd":10001, "so_path":"plugins/CmdHello.so", "entrance_symbol":"create", "load":false, "version":1}

  这些代码实现达到了加载动态库并创建框架未知类实例的目的。不过没有反射机制那么灵活，用起来也稍显麻烦，开发人员写好业务逻辑类之后还需要实现一个对应的全局create()函数。

3. C++反射机制实现思考

  Bwar曾经用C++模板封装过一个基于pthread的通用线程类。下面是这个线程模板类具有代表性的一个函数实现，对设计C++反射机制实现有一定的启发：

template <typename T>
void CThread<T>::StartRoutine(void* para)
{
    T* pT;
    pT = (T*) para;
    pT->Run();
}

  与之相似，创建一个未知的类实例可以通过new T()的方式来实现，如果是带参数的构造函数，则可以new T(T1, T2)来实现。那么，通过类名创建类实例，建立"ClassName"与T的对应关系，或者建立"ClassName"与包含了new T()语句的函数的对应关系即可实现无参构造类的反射机制。考虑到new T(T1, T2)的参数个数和参数类型都未知，应用C++11的可变参数模板解决参数问题，即完成带参构造类的反射机制。

4. Nebula网络框架中的C++反射机制实现

  研究C++反射机制实现最重要是Nebula网络框架中有极其重要的应用，而Nebula框架在实现并应用了反射机制之后代码量精简了10%左右，同时易用性也有了很大的提高，再考虑到应用反射机制后给基于Nebula的业务逻辑开发带来的好处，可以说反射机制是Nebula框架仅次于以C++14标准重写的重大提升。

  Nebula的Actor为事件（消息）处理者，所有业务逻辑均抽象成事件和事件处理，反射机制正是应用在Actor的动态创建上。Actor分为Cmd、Module、Step、Session四种不同类型。业务逻辑代码均通过从这四种不同类型时间处理者派生子类来实现，专注于业务逻辑实现，而无须关注业务逻辑之外的内容。Cmd和Module都是消息处理入库，业务开发人员定义了什么样的Cmd和Module对框架而言是未知的，因此这些Cmd和Module都配置在配置文件里，Nebula通过配置文件中的Cmd和Module的名称（字符串）完成它们的实例创建。通过反射机制动态创建Actor的关键代码如下：

Actor的类声明：

class Actor: public std::enable_shared_from_this<Actor>

Actor创建工厂：

template<typename ...Targs>
class ActorFactory
{
public:
    static ActorFactory* Instance()
    {
        if (nullptr == m_pActorFactory)
        {
            m_pActorFactory = new ActorFactory();
        }
        return(m_pActorFactory);
    }

    virtual ~ActorFactory(){};

    // 将“实例创建方法（DynamicCreator的CreateObject方法）”注册到ActorFactory，注册的同时赋予这个方法一个名字“类名”，后续可以通过“类名”获得该类的“实例创建方法”。这个实例创建方法实质上是个函数指针，在C++11里std::function的可读性比函数指针更好，所以用了std::function。
    bool Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc);

    // 传入“类名”和参数创建类实例，方法内部通过“类名”从m_mapCreateFunction获得了对应的“实例创建方法（DynamicCreator的CreateObject方法）”完成实例创建操作。
    Actor* Create(const std::string& strTypeName, Targs&&... args);

private:
    ActorFactory(){};
    static ActorFactory<Targs...>* m_pActorFactory;
    std::unordered_map<std::string, std::function<Actor*(Targs&&...)> > m_mapCreateFunction;
};

template<typename ...Targs>
ActorFactory<Targs...>* ActorFactory<Targs...>::m_pActorFactory = nullptr;

template<typename ...Targs>
bool ActorFactory<Targs...>::Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc)
{
    if (nullptr == pFunc)
    {
        return (false);
    }
    bool bReg = m_mapCreateFunction.insert(
                    std::make_pair(strTypeName, pFunc)).second;
    return (bReg);
}

template<typename ...Targs>
Actor* ActorFactory<Targs...>::Create(const std::string& strTypeName, Targs&&... args)
{
    auto iter = m_mapCreateFunction.find(strTypeName);
    if (iter == m_mapCreateFunction.end())
    {
        return (nullptr);
    }
    else
    {
        return (iter->second(std::forward<Targs>(args)...));
    }
}

动态创建类：

template<typename T, typename...Targs>
class DynamicCreator
{
public:
    struct Register
    {
        Register()
        {
            char* szDemangleName = nullptr;
            std::string strTypeName;
#ifdef __GNUC__
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#else
            // 注意：这里不同编译器typeid(T).name()返回的字符串不一样，需要针对编译器写对应的实现
            //in this format?:     szDemangleName =  typeid(T).name();
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#endif
            if (nullptr != szDemangleName)
            {
                strTypeName = szDemangleName;
                free(szDemangleName);
            }
            ActorFactory<Targs...>::Instance()->Regist(strTypeName, CreateObject);
        }
        inline void do_nothing()const { };
    };

    DynamicCreator()
    {
        m_oRegister.do_nothing();   // 这里的函数调用虽无实际内容，却是在调用动态创建函数前完成m_oRegister实例创建的关键
    }
    virtual ~DynamicCreator(){};

    // 动态创建实例的方法，所有Actor实例均通过此方法创建。这是个模板方法，实际上每个Actor的派生类都对应了自己的CreateObject方法。
    static T* CreateObject(Targs&&... args)
    {
        T* pT = nullptr;
        try
        {
            pT = new T(std::forward<Targs>(args)...);
        }
        catch(std::bad_alloc& e)
        {
            return(nullptr);
        }
        return(pT);
    }

private:
    static Register m_oRegister;
};

template<typename T, typename ...Targs>
typename DynamicCreator<T, Targs...>::Register DynamicCreator<T, Targs...>::m_oRegister;

  上面ActorFactory和DynamicCreator就是C++反射机制的全部实现。要完成实例的动态创建还需要类定义必须满足（模板）要求。下面看一个可以动态创建实例的CmdHello类定义：

// 类定义需要使用多重继承。
// 第一重继承neb::Cmd是CmdHello的实际基类（neb::Cmd为Actor的派生类，Actor是什么在本节开始的描述中有说明）；
// 第二重继承为通过类名动态创建实例的需要，与template<typename T, typename...Targs> class DynamicCreator定义对应着看就很容易明白第一个模板参数（CmdHello）为待动态创建的类名，其他参数为该类的构造函数参数。
// 如果参数为某个类型的引用，作为模板参数时应指定到类型。比如： 参数类型const std::string&只需在neb::DynamicCreator的模板参数里填std::string
// 如果参数为某个类型的指针，作为模板参数时需指定为类型的指针。比如：参数类型const std::string*则需在neb::DynamicCreator的模板参数里填std::string*
class CmdHello: public neb::Cmd, public neb::DynamicCreator<CmdHello, int32>
{
public:
    CmdHello(int32 iCmd);
    virtual ~CmdHello();

    virtual bool Init();
    virtual bool AnyMessage(
                    std::shared_ptr<neb::SocketChannel> pChannel,
                    const MsgHead& oMsgHead,
                    const MsgBody& oMsgBody);
};

  再看看上面的反射机制是怎么调用的：

template <typename ...Targs>
std::shared_ptr<Cmd> WorkerImpl::MakeSharedCmd(Actor* pCreator, const std::string& strCmdName, Targs... args)
{
    LOG4_TRACE("%s(CmdName \"%s\")", __FUNCTION__, strCmdName.c_str());
    Cmd* pCmd = dynamic_cast<Cmd*>(ActorFactory<Targs...>::Instance()->Create(strCmdName, std::forward<Targs>(args)...));
    if (nullptr == pCmd)
    {
        LOG4_ERROR("failed to make shared cmd \"%s\"", strCmdName.c_str());
        return(nullptr);
    }
    ...
}

  MakeSharedCmd()方法的调用：

MakeSharedCmd(nullptr, oCmdConf["cmd"][i]("class"), iCmd);

  至此通过C++可变参数模板实现C++反射机制实现已全部讲完，相信读到这里已经有了一定的理解，这是Nebula框架的核心功能之一，已有不少基于Nebula的应用实践，是可用于生产的C++反射实现。

  这个C++反射机制的应用容易出错的地方是

  • 类定义class CmdHello: public neb::Cmd, public neb::DynamicCreator<CmdHello, int32>中的模板参数一定要与构造函数中的参数类型严格匹配（不明白的请再阅读一遍CmdHello类定义）。
  • 调用创建方法的地方传入的实参类型必须与形参类型严格匹配。不能有隐式的类型转换，比如类构造函数的形参类型为unsigned int，调用ActorFactory<Targs...>::Instance()->Create()时传入的实参为int或short或unsigned short或enum都会导致ActorFactory无法找到对应的“实例创建方法”，从而导致不能通过类名正常创建实例。

  注意以上两点，基本就不会有什么问题了。

5. 一个可执行的例子

  上面为了说明C++反射机制给出的代码全都来自Nebula框架。最后再提供一个可执行的例子加深理解。

DynamicCreate.cpp:

#include <string>
#include <iostream>
#include <typeinfo>
#include <memory>
#include <unordered_map>
#include <cxxabi.h>

namespace neb
{

class Actor
{
public:
    Actor(){std::cout << "Actor construct" << std::endl;}
    virtual ~Actor(){};
    virtual void Say()
    {
        std::cout << "Actor" << std::endl;
    }
};

template<typename ...Targs>
class ActorFactory
{
public:
    //typedef Actor* (*ActorCreateFunction)();
    //std::function< Actor*(Targs...args) > pp;

    static ActorFactory* Instance()
    {
        std::cout << "static ActorFactory* Instance()" << std::endl;
        if (nullptr == m_pActorFactory)
        {
            m_pActorFactory = new ActorFactory();
        }
        return(m_pActorFactory);
    }

    virtual ~ActorFactory(){};

    //Lambda: static std::string ReadTypeName(const char * name)

    //bool Regist(const std::string& strTypeName, ActorCreateFunction pFunc)
    //bool Regist(const std::string& strTypeName, std::function<Actor*()> pFunc)
    bool Regist(const std::string& strTypeName, std::function<Actor*(Targs&&... args)> pFunc)
    {
        std::cout << "bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)" << std::endl;
        if (nullptr == pFunc)
        {
            return(false);
        }
        std::string strRealTypeName = strTypeName;
        //[&strTypeName, &strRealTypeName]{int iPos = strTypeName.rfind(' '); strRealTypeName = std::move(strTypeName.substr(iPos+1, strTypeName.length() - (iPos + 1)));};
/*
        auto ClassNameLambda = [&strRealTypeName](const std::string& strTypeName)
        {

        }
        ClassNameLambda(strTypeName);
*/
        bool bReg = m_mapCreateFunction.insert(std::make_pair(strRealTypeName, pFunc)).second;
        std::cout << "m_mapCreateFunction.size() =" << m_mapCreateFunction.size() << std::endl;
        return(bReg);
    }

    //Actor* Create(const std::string& strTypeName)
    Actor* Create(const std::string& strTypeName, Targs&&... args)
    {
        std::cout << "Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)" << std::endl;
        auto iter = m_mapCreateFunction.find(strTypeName);
        if (iter == m_mapCreateFunction.end())
        {
            return(nullptr);
        }
        else
        {
            //return(iter->second());
            return(iter->second(std::forward<Targs>(args)...));
        }
    }

/*
    T* Create(const std::string& strTypeName)
    {
        Actor* pObj = Create(strTypeName);
        if (!pObj)
        {
            return(nullptr);
        }
        T* pRealObj = dynamic_cast<T*>(pObj);
        if (!pRealObj)
        {
            delete pObj;
            return(nullptr);
        }
        return(pRealObj);
    }
*/

private:
    ActorFactory(){std::cout << "ActorFactory construct" << std::endl;};
    static ActorFactory<Targs...>* m_pActorFactory;
    //std::unordered_map<std::string, ActorCreateFunction> m_mapCreateFunction;
    //std::unordered_map<std::string, std::function<Actor*()> > m_mapCreateFunction;
    std::unordered_map<std::string, std::function<Actor*(Targs&&...)> > m_mapCreateFunction;
};

template<typename ...Targs>
ActorFactory<Targs...>* ActorFactory<Targs...>::m_pActorFactory = nullptr;

//template<typename T>
template<typename T, typename ...Targs>
class DynamicCreator
{
public:
    struct Register
    {
        Register()
        {
            std::cout << "DynamicCreator.Register construct" << std::endl;
            char* szDemangleName = nullptr;
            std::string strTypeName;
#ifdef __GNUC__
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#else
            //in this format?:     szDemangleName =  typeid(T).name();
            szDemangleName = abi::__cxa_demangle(typeid(T).name(), nullptr, nullptr, nullptr);
#endif
            if (nullptr != szDemangleName)
            {
                strTypeName = szDemangleName;
                free(szDemangleName);
            }
//std::cout << typeid(T).name() << "\t" << strTypeName << std::endl;
            ActorFactory<Targs...>::Instance()->Regist(strTypeName, CreateObject);
        }
        inline void do_nothing()const { };
    };
    DynamicCreator()
    {
        std::cout << "DynamicCreator construct" << std::endl;
        m_oRegister.do_nothing();
    }
    virtual ~DynamicCreator(){m_oRegister.do_nothing();};

    static T* CreateObject(Targs&&... args)
    {
        std::cout << "static Actor* DynamicCreator::CreateObject(Targs... args)" << std::endl;
        return new T(std::forward<Targs>(args)...);
    }

    virtual void Say()
    {
        std::cout << "DynamicCreator say" << std::endl;
    }
    static Register m_oRegister;
};

template<typename T, typename ...Targs>
typename DynamicCreator<T, Targs...>::Register DynamicCreator<T, Targs...>::m_oRegister;

class Cmd: public Actor, public DynamicCreator<Cmd>
{
public:
    Cmd(){std::cout << "Create Cmd " << std::endl;}
    virtual void Say()
    {
        std::cout << "I am Cmd" << std::endl;
    }
};

class Step: public Actor, DynamicCreator<Step, std::string, int>
{
public:
    Step(const std::string& strType, int iSeq){std::cout << "Create Step " << strType << " with seq " << iSeq << std::endl;}
    virtual void Say()
    {
        std::cout << "I am Step" << std::endl;
    }
};

class Worker
{
public:
    template<typename ...Targs>
    Actor* CreateActor(const std::string& strTypeName, Targs&&... args)
    {
        Actor* p = ActorFactory<Targs...>::Instance()->Create(strTypeName, std::forward<Targs>(args)...);
        return(p);
    }
};

}

int main()
{
    //Actor* p1 = ActorFactory<std::string, int>::Instance()->Create(std::string("Cmd"), std::string("neb::Cmd"), 1001);
    //Actor* p3 = ActorFactory<>::Instance()->Create(std::string("Cmd"));
    neb::Worker W;
    neb::Actor* p1 = W.CreateActor(std::string("neb::Cmd"));
    p1->Say();
    //std::cout << abi::__cxa_demangle(typeid(Worker).name(), nullptr, nullptr, nullptr) << std::endl;
    std::cout << "----------------------------------------------------------------------" << std::endl;
    neb::Actor* p2 = W.CreateActor(std::string("neb::Step"), std::string("neb::Step"), 1002);
    p2->Say();
    return(0);
}

  Nebula框架是用C++14标准写的，在Makefile中有预编译选项，可以用C++11标准编译，但未完全支持C++11全部标准的编译器可能无法编译成功。实测g++ 4.8.5不支持可变参数模板，建议采用gcc 5.0以后的编译器，最好用gcc 6，Nebula用的是gcc6.4。

  这里给出的例子DynamicCreate.cpp可以这样编译：

 g++ -std=c++11 DynamicCreate.cpp -o DynamicCreate

  程序执行结果如下：

DynamicCreator.Register construct
static ActorFactory* Instance()
ActorFactory construct
bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)
m_mapCreateFunction.size() =1
DynamicCreator.Register construct
static ActorFactory* Instance()
ActorFactory construct
bool ActorFactory::Regist(const std::string& strTypeName, std::function<Actor*(Targs... args)> pFunc)
m_mapCreateFunction.size() =1
static ActorFactory* Instance()
Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)
static Actor* DynamicCreator::CreateObject(Targs... args)
Actor construct
DynamicCreator construct
Create Cmd
I am Cmd
----------------------------------------------------------------------
static ActorFactory* Instance()
Actor* ActorFactory::Create(const std::string& strTypeName, Targs... args)
static Actor* DynamicCreator::CreateObject(Targs... args)
Actor construct
DynamicCreator construct
Create Step neb::Step with seq 1002
I am Step

  完毕，周末花了6个小时才写完，找了个合适的时间发布出来。

  Nebula框架系列技术分享 之 《C++反射机制：可变参数模板实现C++反射》。 如果觉得这篇文章对你有用，如果觉得Nebula框架还可以，帮忙到Nebula的Github或码云给个star，谢谢。Nebula不仅是一个框架，还提供了一系列基于这个框架的应用，目标是打造一个高性能分布式服务集群解决方案。


参考资料：

反射机制动态库逻辑框架关系逻辑stringactorconstC/C++C/C++
点赞
收藏
评论区
推荐文章
blmius blmius
•
3年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时，报错：原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等，这样可以更容易地在不同的环境中使用MySQL。全局s
4247
0
0
helloworld_34035044 helloworld_34035044
•
2年前
皕杰报表之UUID
​在我们用皕杰报表工具设计填报报表时，如何在新增行里自动增加id呢？能新增整数排序id吗？目前可以在新增行里自动增加id，但只能用uuid函数增加UUID编码，不能新增整数排序id。uuid函数说明：获取一个UUID，可以在填报表中用来创建数据ID语法：uuid()或uuid(sep)参数说明：sep布尔值，生成的uuid中是否包含分隔符''，缺省为
1210
0
0
待兔 待兔
•
5个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
1137
0
0
Jacquelyn38 Jacquelyn38
•
3年前
2020年前端实用代码段，为你的工作保驾护航
有空的时候，自己总结了几个代码段，在开发中也经常使用，谢谢。1、使用解构获取json数据let jsonData  id: 1,status: "OK",data: 'a', 'b';let  id, status, data: number   jsonData;console.log(id, status, number )
2446
0
0
Stella981 Stella981
•
3年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签，将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
1377
0
0
Wesley13 Wesley13
•
3年前
mysql设置时区
mysql设置时区mysql\_query("SETtime\_zone'8:00'")ordie('时区设置失败，请联系管理员！');中国在东8区所以加8方法二：selectcount(user\_id)asdevice,CONVERT\_TZ(FROM\_UNIXTIME(reg\_time),'08:00','0
1382
0
0
Wesley13 Wesley13
•
3年前
00：Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork)，斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。Java是简单易学，完全面向对象，安全可靠，与平台无关的编程语言。
1314
0
0
Stella981 Stella981
•
3年前
Django中Admin中的一些参数配置
设置在列表中显示的字段，id为django模型默认的主键list_display('id','name','sex','profession','email','qq','phone','status','create_time')设置在列表可编辑字段list_editable
1235
0
0
Wesley13 Wesley13
•
3年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
1586
0
0
Python进阶者 Python进阶者
•
11个月前
Excel中这日期老是出来00：00：00，怎么用Pandas把这个去除
大家好，我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下：这日期老是出来00：00：00，怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下：pd.toexcel之前把这
559
0
0
Wesley13
Wesley13
Lv1
最大的安心是自律温柔和爱自己。
文章
1.2w
粉丝
22
获赞
1.7k
热门文章
JavPlayer：AI破坏马赛克，大量马赛克破坏版影片流出
2020年最新可用的磁力搜索引擎&种子搜索网站，持续整理分享
8个在线接收手机短信验证码的免费网络服务整理
IDM 激活破解工具
java.net.ConnectException：Connection timed out：connect 出现连接超时的问题？