深入探讨C++的高级反射机制（2）：写个能用的反射库

news2024/10/6 14:37:34

在现代软件开发中，反射是一种强大的特性，它可以支持程序在运行时查询和调用对象的属性和方法。
但是在C++中，没有内置的反射机制。我们可以通过一些巧妙的技术模拟反射的部分功能。

上一篇文章写了个简单的反射功能，这回完善一下，满足常见场景的使用吧。

我们这个简单反射库就称为refl吧。

refl库是一个用C++编写的轻量级反射框架，它允许在编译时和运行时对对象的属性和方法进行查询和操作。

这个库需要使用C++17编译器编译。其完整源码如下：

#include <iostream>
#include <tuple>
#include <stdexcept>
#include <assert.h>
#include <string_view>
#include <optional>
#include <utility> // For std::forward
#include <unordered_map>
#include <functional>
#include <memory>
#include <any>
#include <type_traits> // For std::is_invocable

namespace refl {

	// 这个宏用于创建字段信息
#define REFLECTABLE_PROPERTIES(TypeName, ...)  using CURRENT_TYPE_NAME = TypeName; \
    static constexpr auto properties() { return std::make_tuple(__VA_ARGS__); }
#define REFLECTABLE_MENBER_FUNCS(TypeName, ...) using CURRENT_TYPE_NAME = TypeName; \
    static constexpr auto member_funcs() { return std::make_tuple(__VA_ARGS__); }

// 这个宏用于创建属性信息，并自动将字段名转换为字符串
#define REFLEC_PROPERTY(Name) refl::Property<decltype(&CURRENT_TYPE_NAME::Name), &CURRENT_TYPE_NAME::Name>(#Name)
#define REFLEC_FUNCTION(Func) refl::Function<decltype(&CURRENT_TYPE_NAME::Func), &CURRENT_TYPE_NAME::Func>(#Func)

// 定义一个属性结构体，存储字段名称和值的指针
	template <typename T, T Value>
	struct Property {
		const char* name;
		constexpr Property(const char* name) : name(name) {}
		constexpr T get_value() const { return Value; }
	};
	template <typename T, T Value>
	struct Function {
		const char* name;
		constexpr Function(const char* name) : name(name) {}
		constexpr T get_func() const { return Value; }
	};

	// 使用 std::any 来处理不同类型的字段值和函数返回值
	template <typename T, typename Tuple, size_t N = 0>
	std::any __get_field_value_impl(T& obj, const char* name, const Tuple& tp) {
		if constexpr (N >= std::tuple_size_v<Tuple>) {
			return std::any();// Not Found!
		}
		else {
			const auto& prop = std::get<N>(tp);
			if (std::string_view(prop.name) == name) {
				return std::any(obj.*(prop.get_value()));
			}
			else {
				return __get_field_value_impl<T, Tuple, N + 1>(obj, name, tp);
			}
		}
	}

	// 使用 std::any 来处理不同类型的字段值和函数返回值
	template <typename T, size_t N = 0>
	std::any get_field_value(T& obj, const char* name) {
		return __get_field_value_impl(obj, name, T::properties());
	}

	// 使用 std::any 来处理不同类型的字段值和函数返回值
	template <typename T, typename Tuple, typename Value, size_t N = 0>
	std::any __assign_field_value_impl(T& obj, const char* name, const Value &value, const Tuple& tp) {
		if constexpr (N >= std::tuple_size_v<Tuple>) {
			return std::any();// Not Found!
		}
		else {
			const auto& prop = std::get<N>(tp);
			if (std::string_view(prop.name) == name) {
				if constexpr (std::is_assignable_v<decltype(obj.*(prop.get_value())), Value>) {
					obj.*(prop.get_value()) = value;
					return std::any(obj.*(prop.get_value()));
				}
				else {
					assert(false);// 无法赋值 类型不匹配!!
					return std::any();
				}
			}
			else {
				return __assign_field_value_impl<T, Tuple, Value, N + 1>(obj, name, value, tp);
			}
		}
	}
	template <typename T, typename Value>
	std::any assign_field_value(T& obj, const char* name, const Value& value) {
		return __assign_field_value_impl(obj, name, value, T::properties());
	}

	// 成员函数调用相关:
	template <bool check_arg_typs = true, typename T, typename FuncTuple, size_t N = 0, typename... Args>
	constexpr std::any __invoke_member_func_impl(T& obj, const char* name, const FuncTuple& tp, Args&&... args) {
		if constexpr (N >= std::tuple_size_v<FuncTuple>) {
			return std::any();// Not Found!
		}
		else {
			const auto& func = std::get<N>(tp);
			if (std::string_view(func.name) == name) {
				if constexpr (std::is_invocable_v<decltype(func.get_func()), T&, Args...>) {
					return std::invoke(func.get_func(), obj, std::forward<Args>(args)...);
				}
				else {
					assert(!check_arg_typs);// 调用参数不匹配
					return std::any();
				}
			}
			else {
				return __invoke_member_func_impl<check_arg_typs, T, FuncTuple, N + 1>(obj, name, tp, std::forward<Args>(args)...);
			}
		}
	}

	template <typename T, typename... Args>
	constexpr std::any invoke_member_func(T& obj, const char* name, Args&&... args) {
		constexpr auto funcs = T::member_funcs();
		return __invoke_member_func_impl(obj, name, funcs, std::forward<Args>(args)...);
	}

	template <typename T, typename... Args>
	constexpr std::any invoke_member_func_type_safe(T& obj, const char* name, Args&&... args) {
		constexpr auto funcs = T::member_funcs();
		return __invoke_member_func_impl<true>(obj, name, funcs, std::forward<Args>(args)...);
	}



	// 定义一个类型特征模板，用于获取属性信息
	template <typename T>
	struct For {
		static_assert(std::is_class_v<T>, "Reflector requires a class type.");

		// 遍历所有字段名称
		template <typename Func>
		static void for_each_propertie_name(Func&& func) {
			constexpr auto props = T::properties();
			std::apply([&](auto... x) {
				((func(x.name)), ...);
				}, props);
		}

		// 遍历所有字段值
		template <typename Func>
		static void for_each_propertie_value(T& obj, Func&& func) {
			constexpr auto props = T::properties();
			std::apply([&](auto... x) {
				((func(x.name, obj.*(x.get_value()))), ...);
				}, props);
		}

		// 遍历所有函数名称
		template <typename Func>
		static void for_each_member_func_name(Func&& func) {
			constexpr auto props = T::member_funcs();
			std::apply([&](auto... x) {
				((func(x.name)), ...);
				}, props);
		}
	};

	// ===============================================================

	// 以下是动态反射机制的支持代码：
	namespace dynamic {
		// 反射基类
		class IReflectable {
		public:
			virtual ~IReflectable() = default;
			virtual std::string_view get_type_name() const = 0;

			virtual std::any get_field_value_by_name(const char* name) const = 0;

			virtual std::any invoke_member_func_by_name(const char* name) = 0;
			virtual std::any invoke_member_func_by_name(const char* name, std::any param1) = 0;
			virtual std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2) = 0;
			virtual std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2, std::any param3) = 0;
			virtual std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2, std::any param3, std::any param4) = 0;
			// 不能无限增加，会增加虚表大小。最多支持4个参数的调用。
		};

		// 类型注册工具
		class TypeRegistry {
		public:
			using CreatorFunc = std::function<std::unique_ptr<IReflectable>()>;

			static TypeRegistry& instance() {
				static TypeRegistry registry;
				return registry;
			}

			void register_type(const std::string_view type_name, CreatorFunc creator) {
				creators[type_name] = std::move(creator);
			}

			std::unique_ptr<IReflectable> create(const std::string_view type_name) {
				if (auto it = creators.find(type_name); it != creators.end()) {
					return it->second();
				}
				return nullptr;
			}

		private:
			std::unordered_map<std::string_view, CreatorFunc> creators;
		};

		// 用于注册类型信息的宏
#define DECL_DYNAMIC_REFLECTABLE(TypeName) \
    friend class refl::dynamic::TypeRegistryEntry<TypeName>; \
    static std::string_view static_type_name() { return #TypeName; } \
    virtual std::string_view get_type_name() const override { return static_type_name(); } \
    static std::unique_ptr<::refl::dynamic::IReflectable> create_instance() { return std::make_unique<TypeName>(); } \
    static const bool is_registered; \
    std::any get_field_value_by_name(const char* name) const override { \
        return refl::get_field_value(*this, name); \
    } \
    std::any invoke_member_func_by_name(const char* name) override { \
        return refl::invoke_member_func(*static_cast<TypeName*>(this), name); \
    }\
	std::any invoke_member_func_by_name(const char* name, std::any param1) override { \
		return refl::invoke_member_func(*static_cast<TypeName*>(this), name, param1); \
	}\
	std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2) override { \
		return refl::invoke_member_func(*static_cast<TypeName*>(this), name, param1, param2); \
	}\
	std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2, std::any param3) override { \
		return refl::invoke_member_func(*static_cast<TypeName*>(this), name, param1, param2, param3); \
	}\
	std::any invoke_member_func_by_name(const char* name, std::any param1, std::any param2, std::any param3, std::any param4) override { \
		return refl::invoke_member_func(*static_cast<TypeName*>(this), name, param1, param2, param3, param4); \
	}\

	// 用于在静态区域注册类型的辅助类
		template <typename T>
		class TypeRegistryEntry {
		public:
			TypeRegistryEntry() {
				::refl::dynamic::TypeRegistry::instance().register_type(T::static_type_name(), &T::create_instance);
			}
		};

		// 为每个类型定义注册变量，这段宏需要出现在cpp中。
#define REGEDIT_DYNAMIC_REFLECTABLE(TypeName) \
    const bool TypeName::is_registered = [] { \
        static ::refl::dynamic::TypeRegistryEntry<TypeName> entry; \
        return true; \
    }();
	}


}// namespace refl

下面是对这个库的功能和使用方式的介绍：

静态反射

静态反射是在编译时进行的，refl库通过宏和模板来实现：

  • REFLECTABLE_PROPERTIES和REFLECTABLE_MENBER_FUNCS宏用于声明类的属性和成员函数列表。这些宏在背后创建了一个包含属性或函数信息的元组。
  • REFLEC_PROPERTY和REFLEC_FUNCTION宏用于将类的属性或函数与其名称关联起来，从而允许通过字符串来访问它们。

例如，我们可以定义一个MyStruct类，并使用refl库为其提供反射能力：


// 用户自定义的结构体
class MyStruct : public refl::dynamic::IReflectable {
	// 如果不需要动态反射，可以不从public refl::dynamic::IReflectable派生
public:
	int x{ 10 };
	double y{ 20.5f };
	int print() const {
		std::cout << "MyStruct::print called! " << "x: " << x << ", y: " << y << std::endl;
		return 666;
	}
	// 如果需要支持动态调用，参数必须是std::any，并且不能超过4个参数。
	int print_with_arg(std::any param) const {
		std::cout << "MyStruct::print called! " << " arg is: " << std::any_cast<int>(param) << std::endl;
		return 888;
	}

	REFLECTABLE_PROPERTIES(MyStruct,
		REFLEC_PROPERTY(x),
		REFLEC_PROPERTY(y)
	);
	REFLECTABLE_MENBER_FUNCS(MyStruct,
		REFLEC_FUNCTION(print),
		REFLEC_FUNCTION(print_with_arg)
	);

	DECL_DYNAMIC_REFLECTABLE(MyStruct)//动态反射的支持，如果不需要动态反射，可以去掉这行代码
};

//动态反射注册类(不使用动态反射可以去除)
REGEDIT_DYNAMIC_REFLECTABLE(MyStruct)

动态反射

动态反射更加强大，无需包含被反射类型的头文件，支持在运行时通过字符串名称来访问和修改对象的属性，以及调用对象的方法。

  • IReflectable是一个抽象基类，定义了一组用于动态反射的接口，比如get_field_by_name和invoke_member_func_by_name。
  • TypeRegistry是一个单例类，用于注册和创建反射类型的实例。

通过使用DECL_DYNAMIC_REFLECTABLE和REGEDIT_DYNAMIC_REFLECTABLE宏，开发者可以在类中声明并注册反射信息。

使用示例

以下是如何使用refl库的示例：


int main() {
	MyStruct obj;

	// # 静态反射部分：
	// 打印所有字段名称
	refl::For<MyStruct>::for_each_propertie_name([](const char* name) {
		std::cout << "Field name: " << name << std::endl;
		});

	// 打印所有字段值
	refl::For<MyStruct>::for_each_propertie_value(obj, [](const char* name, auto&& value) {
		std::cout << "Field " << name << " has value: " << value << std::endl;
		});

	// 打印所有函数名称
	refl::For<MyStruct>::for_each_member_func_name([](const char* name) {
		std::cout << "Member func name: " << name << std::endl;
		});

	// 获取特定成员的值，如果找不到成员，则返回默认值
	auto x_value = refl::get_field_value(obj, "x");
	std::cout << "Field x has value: " << std::any_cast<int>(x_value) << std::endl;

	auto y_value = refl::get_field_value(obj, "y");
	std::cout << "Field y has value: " << std::any_cast<double>(y_value) << std::endl;
	
	//修改值：
	refl::assign_field_value(obj, "y", 33.33f);
	y_value = refl::get_field_value(obj, "y");
	std::cout << "Field y has modifyed,new value is: " << std::any_cast<double>(y_value) << std::endl;

	auto z_value = refl::get_field_value(obj, "z"); // "z" 不存在
	if (z_value.type().name() == std::string_view("int")) {
		std::cout << "Field z has value: " << std::any_cast<int>(z_value) << std::endl;
	}

	// 通过字符串调用成员函数 'print'
	auto print_ret = refl::invoke_member_func_type_safe(obj, "print");
	std::cout << "print member return: " << std::any_cast<int>(print_ret) << std::endl;


	std::cout << "---------------------" << std::endl;
	
	// 动态反射部分(动态反射完全不需要知道类型MyStruct的定义)：
	// 动态创建 MyStruct 实例并调用方法
	auto instance = refl::dynamic::TypeRegistry::instance().create("MyStruct");
	if (instance) {
		std::cout << "Dynamic instance type: " << instance->get_type_name() << std::endl;
		// 这里可以调用 MyStruct 的成员方法
		auto x_value2 = instance->get_field_value_by_name("x");
		std::cout << "Field x has value: " << std::any_cast<int>(x_value2) << std::endl;

		instance->invoke_member_func_by_name("print");
		instance->invoke_member_func_by_name("print_with_arg", 10);
		instance->invoke_member_func_by_name("print_with_arg", 20, 222);//这个调用会失败，命中断言，因为print_with_arg只接受一个函数
	}
	return 0;
}

运行效果：
在这里插入图片描述

结论

尽管C++没有提供内置的反射机制，refl库提供了一种简洁的方法来模拟这一功能。通过使用宏和模板，refl库能够在编译时和运行时对对象的属性和方法进行操作，为C++程序带来了更多的灵活性和动态性。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1865508.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux-笔记 OverlayFS文件系统入门

Linux-笔记 OverlayFS文件系统入门

目录 前言 主要概念 工作原理 特点特性 1、上下合并 2、同名文件覆盖 3、同名目录合并 4、写时拷贝 实操入门 内核配置 挂载文件系统 验证 1、同名文件覆盖 2、同名目录合并 3、写时拷贝 1&#xff09;验证新增文件或目录 2&#xff09;验证修改文件 3&…
阅读更多...
[leetcode]assign-cookies. 分发饼干

[leetcode]assign-cookies. 分发饼干

. - 力扣&#xff08;LeetCode&#xff09; class Solution { public:int findContentChildren(vector<int>& g, vector<int>& s) {sort(g.begin(), g.end());sort(s.begin(), s.end());int m g.size(), n s.size();int count 0;for (int i 0, j 0; i…
阅读更多...
【嵌入式Linux】i.MX6ULL GPIO 中断服务函数注册与编写

【嵌入式Linux】i.MX6ULL GPIO 中断服务函数注册与编写

文章目录 1 外部中断初始化与中断服务函数1.2 外部中断初始化函数 exti_init1.2.1 GPIO引脚配置1.2.2 中断使能与注册1.2.3 GIC_EnableIRQ()函数的分析 1.3 中断服务函数 gpio1_io20_irqhandler1.3.1 消抖处理1.3.2 中断事件处理1.3.3 清除中断标志 2 BUG处理2.1 问题描述2.2 解…
阅读更多...
【开源项目】自然语言处理领域的明星项目推荐：Hugging Face Transformers

【开源项目】自然语言处理领域的明星项目推荐：Hugging Face Transformers

在当今人工智能与大数据飞速发展的时代&#xff0c;自然语言处理&#xff08;NLP&#xff09;已成为推动科技进步的重要力量。而在NLP领域&#xff0c;Hugging Face Transformers无疑是一个备受瞩目的开源项目。本文将从项目介绍、代码解释以及技术特点等角度&#xff0c;为您深…
阅读更多...
泰迪智能科技大数据挖掘企业服务平台典型合作案例介绍

泰迪智能科技大数据挖掘企业服务平台典型合作案例介绍

泰迪大数据挖掘企业服务平台 是一款通用的、企业级、智能化的数据分析模型构建与数据应用场景设计工具&#xff0c;能够一体化地完成数据集成、模型构建、模型发布&#xff0c;为数据分析、探索、服务流程提供支撑&#xff0c;提供完整的数据探索、多数据源接入、特征处理、模型…
阅读更多...
编程设计思想

编程设计思想

健康检查脚本 nmap:扫描端口 while true do healthycurl B:httpPORT/healthy -i | grep HTTP/1.1 | tail -n 1 | awk {print $2} done 批量操作类型脚本&#xff08;记录每一步日志&#xff09; 将100个nginx&#xff1a;vn推送到harbor仓库192.168.0.100 根据镜像对比sha值…
阅读更多...
高效修复机床导轨磨损，保障加工精度！

高效修复机床导轨磨损，保障加工精度！

机床导轨是支承和引导运动构件沿着一定轨迹运动的传动装置&#xff0c;在机器设备中是个十分重要的部件&#xff0c;在机床中是常见的部件。机床的加工精度与导轨精度有直接的联系&#xff0c;且导轨一旦损坏&#xff0c;维修较复杂且困难。我们简单总结了以下几点对于机床导轨…
阅读更多...
rocketMQ消息中间件，onMessage报错，MessageExt of onessage method is not supported

rocketMQ消息中间件，onMessage报错，MessageExt of onessage method is not supported

本地启动不会报错&#xff0c;生产者和消费者都运行的好好的&#xff0c;但是打包之后就不断的报错误&#xff0c; 起初以为是maven出现了问题&#xff0c;但是刷新和重写都不管用&#xff0c;并且打的jar包解压后发现类里 有这个类和方法。最后认为是打包出现问题 解决方式&am…
阅读更多...
SEO之竞争对手研究

SEO之竞争对手研究

初创企业搭建网站的朋友看1号文章&#xff1b;想学习云计算&#xff0c;怎么入门看2号文章谢谢支持&#xff1a; 1、我给不会敲代码又想搭建网站的人建议 2、新手上云 竞争对手研究是市场竞争研究的重要部分&#xff0c;对判断特定关键词竞争程度及了解行业整体情况非常有价值。…
阅读更多...
AutoStudio: 开源 AI 漫画创作神器

AutoStudio: 开源 AI 漫画创作神器

AutoStudio是一个用于生成系列连续且一致的图片系统&#xff0c;可用于漫画创作&#xff0c;其核心由四个 Agent 组成&#xff1a; 主题管理器&#xff1a;理解用户对话&#xff0c;跟踪角色信息。 布局生成器&#xff1a;确定图像中角色的位置。 监督者&#xff1a;给出改进…
阅读更多...
昇思25天学习打卡营第3天|张量Tensor

昇思25天学习打卡营第3天|张量Tensor

张量Tensor 概念创建张量&#xff08;4种方式&#xff09;张量的属性张量索引张量运算Tensor与NumPy转换 概念 张量&#xff08;Tensor&#xff09;是一种特殊的数据结构&#xff0c;与数组和矩阵非常相似。张量是MindSpore网络运算中的基本数据结构。 创建张量&#xff08;4…
阅读更多...
离线安装docker-v26.1.4，compose-v2.27.0

离线安装docker-v26.1.4，compose-v2.27.0

目录 ​编辑 1.我给大家准备好了提取即可 2.安装docker和compose 3.解压 4.切换目录 5.执行脚本 6.卸载docker和compose 7.执行命令 “如果您在解决类似问题时也遇到了困难&#xff0c;希望我的经验分享对您有所帮助。如果您有任何疑问或者想分享您的经历&#xff0c;…
阅读更多...
【Academy】测试WebSockets安全漏洞Testing for WebSockets security vulnerabilities

【Academy】测试WebSockets安全漏洞Testing for WebSockets security vulnerabilities

测试WebSockets安全漏洞Testing for WebSockets security vulnerabilities 概述WebSockets是什么?HTTP和WebSockets有什么区别&#xff1f;如何建立WebSocket连接&#xff1f;WebSocket消息看起来像什么&#xff1f; 操纵WebSocket流量拦截和修改WebSocket消息重放和生成新的W…
阅读更多...
揭示优化Prompt的秘诀：如何让API表现媲美网页版

揭示优化Prompt的秘诀：如何让API表现媲美网页版

为什么用GPT API&#xff08;GPT-3.5-turbo&#xff09;进行程序分析时&#xff0c;效果好像比网页版的GPT-3.5差一点&#xff1f;这可能有几个原因&#xff0c;咱们细说一下。 1. Prompt不同 这是最常见的问题之一。API调用时的指令&#xff08;prompt&#xff09;往往比较简…
阅读更多...
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错

【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错

欢迎来到《小5讲堂》 这是《C#》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解。 温馨提示&#xff1a;博主能力有限&#xff0c;理解水平有限&#xff0c;若有不对之处望指正&#xff01; 背景 找不到属性集方法。get只读属性用了反射设置setValue肯定报错 报错…
阅读更多...
Spring Boot 接口一个 JSON 字符串用两个对象去接收，这能行吗？

Spring Boot 接口一个 JSON 字符串用两个对象去接收，这能行吗？

文章目录 需求场景解决方案Step 1: 创建 Person 和 Address 类Step 2: 创建 PersonWithAddress 类Step 3: 自定义转换器Step 4: 配置转换器Step 5: 使用 RequestBody 接收 JSON 数据 结论 &#x1f389;欢迎来到SpringBoot框架学习专栏~ ☆* o(≧▽≦)o *☆嗨~我是IT陈寒&#…
阅读更多...
若依项目实战------企业人力资源管理平台

若依项目实战------企业人力资源管理平台

一、数据库名称规范化及建表相关 1.术语名称 1.系统名称&#xff1a;企业人力资源管理平台英文翻译&#xff1a;Enterprise Human Resource Management Platform缩写&#xff1a;EHR 2.员工信息管理&#xff08;Employee Information Management 缩写&#xff1a;EIM&#…
阅读更多...
Vue3抽屉（Drawer）

Vue3抽屉（Drawer）

效果如下图&#xff1a;在线预览 APIs 参数说明类型默认值必传width宽度&#xff0c;在 placement 为 right 或 left 时使用string | number378falseheight高度&#xff0c;在 placement 为 top 或 bottom 时使用string | number378falsetitle标题string | slotundefinedfalse…
阅读更多...
Docker(八)-Docker运行mysql8容器实例

Docker(八)-Docker运行mysql8容器实例

1.运行mysql8容器实例并挂载数据卷 -e:配置环境变量 --lower_case_table_names1 设置忽略表名大小写一定要放在镜像之后运行mysql8容器实例之前&#xff0c;先查看是否存在mysql8镜像以及是否存在已运行的mysql实例docker run -d -p 3306:3306 --privilegedtrue -v 【宿主机日…
阅读更多...
Jenkins流水线发布，一篇就解决你的所有疑惑

Jenkins流水线发布，一篇就解决你的所有疑惑

这次搭建的项目比较常规，前端是react写的，后端是springboot，并且由于是全栈开发，所以是在同一个项目中。接下来我演示下怎么用jenkins进行自动化发布。 1.jenkins必装插件 这里用到的是jenkinsFile主要是基于Groovy这个沙盒，有些前置插件。这里使用maven进行打包，所以需…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023