从零开始训练大模型—以RoBERTa为例

已于 2024-12-08 17:40:31 修改
阅读量3.4k 收藏 13
点赞数 1
分类专栏： 源码解读 文章标签： 深度学习 pytorch 语言模型
于 2023-08-16 21:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62603533/article/details/132292705
版权

文章目录

0 前言

本文讲述了如何从零开始训练一个大模型，这个从零开始值是指从源码层面自己处理数据、搭建模型。

1 数据预处理

  • 加载数据

  • 对过长的文本进行切分，设置max_len=128，也就是先按照标点符号把长句子切分为短句子，然后将短句子进行组合，但是不能超过最大长度，超过的部分组合成新的句子，所有数据处理完得到 Dataset。
    在这里插入图片描述

  • 将Dataset传给DataLoader，在DataLoader里面的collate_fn进行操作，得到模型的输入。
    collate_fn函数：
    1）对输入的文本进行编码：input_ids = tokenizer.encode(list(text))
    2）计算需要掩码的token数量：n_pred = min(max_pred, max(1, int(len(input_ids) * 0.15)))
    3）对input_ids进行处理得到待掩码的token：cand_maked_pos = [i for i, token in enumerate(input_ids) if token != word2idx[‘[CLS]’] and token != word2idx[‘[SEP]’]]
    4）打乱待掩码的token：shuffle(cand_maked_pos)
    5）进行掩码：

    for pos in cand_maked_pos[:n_pred]：
	masked_pos.append(pos) 
	masked_tokens.append(input_ids[pos])
	if random() < 0.8: 
		input_ids[pos] = word2idx['[MASK]']
	elif random() > 0.9:
		index = randint(0, vocab_size - 1) 
		while index == 0 or index == 101 or index == 102 or index == 103: 
			index = randint(0, vocab_size - 1)
	input_ids[pos] = index

    6）对input_ids进行补零操作：
    n_pad = maxlen - len(input_ids)
    input_ids.extend([0] * n_pad)
    7）对掩码的token和对应的位置向量进行补零操作：
    n_pad = max_pred - n_pred
    masked_tokens.extend([0] * n_pad)
    masked_pos.extend([0] * n_pad)
    8）将得到的模型输入input_ids、masked_tokens、 masked_pos转换为torch tensor格式：
    torch.tensor(input_ids, dtype=torch.long)
    torch.tensor(masked_tokens, dtype=torch.long)
    torch.tensor(masked_pos, dtype=torch.long)

2 模型构建

2.1 模型介绍

  1. RoBERTa是基于BERT进行改进得到的， RoBERTa 相较于 BERT 最大的改进有三点：
    1）动态 Masking： BERT的masking是在预处理时进行的，导致这种Masking是静态的，每个epoch的masking结果一致。而RoBERTa中使用Dynamic Masking，只是在序列送入模型中的时候才去进行动态的masking，这样在更大的数据集上或者更多步数的训练上会表现更好
    2）取消 NSP (Next Sentence predict) 任务：为了探索NSP训练策略对模型结果的影响，论文中设置了4种训练方式进行对比，最后发现没有NSP任务模型的训练结果会更好，下游任务的效果也会更好
    3）扩大 batch_size：论文中通过实验，证明了更大的batch_size可以得到更好的结果
  2. RoBERTa的结构为：Embedding层；EncoderLayer层；全连接层
    1）Embedding层
    class Embedding(nn.Module):
	def __init__(self):
		super(Embedding, self).__init__()
		self.tok_embed = nn.Embedding(vocab_size, hidden_size)
		self.pos_embed = nn.Embedding(maxlen, hidden_size)
		self.norm = nn.LayerNorm(hidden_size)
		self.dropout = nn.Dropout(hidden_dropout_prob)
		
	def forward(self, input_ids):
		seq_len = input_ids.size(1)
		pos = torch.arange(seq_len, dtype=torch.long)
		pos = pos.unsqueeze(0).expand_as(input_ids) # [seq_len] -> [batch_size, seq_len] 
		embedding = self.tok_embed(input_ids) + self.pos_embed(pos) # [batch_size, seq_len, hidden_size] 
		embedding = self.norm(embedding)
		embedding = self.dropout(embedding)
		return embedding
    2）EncoderLayer层
    EncoderLayer层的主体其实就是Transformer中的编码层，核心内容为自注意力机制，代码如下图所示。这部分内容较为复杂，如果想进一步了解可以参考笔者之前的一篇文章“基于模型结构与模型源码两个层面理解Transformer”。
    def forward(self, Q, K, V, attn_mask):
	scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k)
	scores.masked_fill_(attn_mask, -1e9)
	attn = nn.Softmax(dim=-1)(scores)
	context = torch.matmul(attn, V)
	return context
    3）全连接层
    self.linear = nn.Linear(hidden_size, hidden_size)
self.activ2 = gelu
embed_weight = self.embedding.tok_embed.weight
self.fc2 = nn.Linear(hidden_size, vocab_size)
self.fc2.weight = embed_weight

masked_pos = masked_pos[:, :, None].expand(-1, -1, d_model) # [batch_size, max_pred, hidden_size]
h_masked = self.activ2(self.linear(h_masked)) # [batch_size, max_pred, hidden_size]
logits_lm = self.fc2(h_masked) # [batch_size, max_pred, vocab_size]
return logits_lm
  3. RoBERTa模型
    class RoBERTa(nn.Module):
	def __init__(self):
		super(RoBERTa, self).__init__()
		self.embedding = Embedding()
		self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)])
		self.linear = nn.Linear(hidden_size, hidden_size)
		self.activ2 = gelu
		embed_weight = self.embedding.tok_embed.weight
		self.fc2 = nn.Linear(hidden_size, vocab_size)
		self.fc2.weight = embed_weight
	def forward(self, input_ids, masked_pos):
		output = self.embedding(input_ids) # [batch_size, seq_len, hidden_size]
        enc_self_attn_mask = get_attn_pad_mask(input_ids, input_ids) # [batch_size, maxlen, maxlen]
        for layer in self.layers:
        	output = layer(output, enc_self_attn_mask) # [batch_size, seq_len, hidden_size]
        masked_pos = masked_pos[:, :, None].expand(-1, -1, hidden_size）  # [batch_size, max_pred, hidden_size]
        h_masked = torch.gather(output, 1, masked_pos) # [batch_size, max_pred, hidden_size]
        h_masked = self.activ2(self.linear(h_masked)) # [batch_size, max_pred, hidden_size]
        logits_lm = self.fc2(h_masked) # [batch_size, max_pred, vocab_size]
        return logits_lm

3 模型训练及保存

model = RoBERTa()
criterion = nn.CrossEntropyLoss(ignore_index=0) 
optimizer = optim.Adam(model.parameters(), lr=0.0001)

for epoch in range(epochs):
	loss = 0
	pbar = tqdm.tqdm(loader, desc='Train', nrows=200, ncols=100)
	for input_ids, masked_tokens, masked_pos in pbar:
		logits_lm = model(input_ids, masked_pos) # [batch_size, max_pred, vocab_size]
		loss_lm = criterion(logits_lm.view(-1, vocab_size), masked_tokens.view(-1)) 
		loss += loss_lm
		optimizer.zero_grad()
		loss_lm.backward()
		optimizer.step()
	print('Epoch:', '%04d' % (epoch + 1), 'loss =', '{:.6f}'.format(loss))
	
    output_path = './outputs/'
    save_path = os.path.join(output_path, 'checkpoint_RoBERTa-' + str(epoch+1))
    torch.save(model, save_path)

4 模型测试

下图为模型测试和测试结果，从预测结果可以看出，预测的两段文本，分别掩码了13和2个token，但是两段文本都只预测对了一个token。这是因为当时只用了少量的训练数据，而且模型未得到充分训练。
模型推理过程：

model=torch.load(save_path) 
input_ids = input_ids.numpy().tolist()
masked_tokens = masked_tokens.numpy().tolist()
masked_pos = masked_pos.numpy().tolist()
print([idx2word[w] for w in input_ids[0] if idx2word[w] != ‘[PAD]’])

logits_lm = model(torch.LongTensor([input_ids[0]]),torch.LongTensor([masked_pos[0]]))# logits_lm ：[batch_size, max_pred, vocab_size]
logits_lm = logits_lm.data.max(2)[1][0].data.numpy()  # 预测出的掩码位置的token，长度为max_pred
print(‘masked tokens list : ’,[pos for pos in masked_tokens[0] if pos != 0]) print('predict masked tokens list : ',[pos for pos in logits_lm if pos != 0])

测试结果1：
在这里插入图片描述
测试结果2：
在这里插入图片描述

5 常见大模型简述

5.1 ALBERT模型简述

ALBERT 的结构和 BERT 基本一样，采用了 Transformer 以及 GELU 激活函数。具体的创新部分有三个：

  • embedding 层参数因式分解
  • 跨层参数共享
  • 将 NSP 任务改为 SOP 任务
  1. embedding 层参数因式分解
    原始的 BERT 模型以及各种依据 Transformer 的预训连语言模型都有一个共同特点，即 E=H，其中 E 指的是 Embedding Dimension，H 指的是 Hidden Dimension。这就会导致一个问题，当提升 Hidden Dimension 时，Embedding Dimension 也需要提升，最终会导致参数量呈平方级的增加。所以 ALBERT 的作者将 E 和 H 进行解绑，具体的操作就是在 Embedding 后面加入一个矩阵进行维度变换。E 的维度是不变的，如果 H 增大了，我们只需要在 E 后面进行一个升维操作即可。
    举个例子：
    V * H = 30000 * 768 = 23 040 000
    V * E + E * H = 30000 * 256 + 256 * 768 = 7 876 608
    当V为30000，H为768，E为256时，参数量从2300万降低到780万
  2. 跨层参数共享
    传统 Transformer 的每一层参数都是独立的，包括各层的 self-attention、全连接。这样就导致层数增加时，参数量也会明显上升。之前有工作试过单独将 self-attention 或者全连接层进行共享，都取得了一些效果。ALBERT 作者尝试将所有层的参数进行共享，相当于只学习第一层的参数，并在剩下的所有层中重用该层的参数，而不是每个层都学习不同的参数。
    作者通过实验发现了使用参数共享可以有效的提升模型稳定性，实验结果如下图：
    在这里插入图片描述
  3. 将NSP 任务改为 SOP 任务
    BERT 引入了一个叫做下一个句子预测的二分类问题。这是专门为提高使用句子对，如 “自然语言推理” 的下游任务的性能而创建的。但是在 RoBERTa 这样的论文中已经阐明了 NSP 的无效性，并且发现它对下游任务的影响是不可靠的。
    因此，ALBERT 提出了另一个任务 —— 句子顺序预测，关键思想是（1）从同一个文档中取两个连续的句子作为一个正样本；（2）交换这两个句子的顺序，并使用它作为一个负样本。SOP 提高了下游多种任务（SQUAD，MNLI，SST-2，RACE）的表现。
    在这里插入图片描述

5.2 ELECTRA模型简述

ELECTRA最主要的贡献是提出了新的预训练任务和框架，把生成式的Masked language model(MLM)预训练任务改成了判别式的Replaced token detection(RTD)任务，判断当前token是否被语言模型替换过。
在这里插入图片描述
具体而言：首先按照一定的比例对于原始输入序列X-ORI进行随机MASK操作得到新序列X-MASK；其次将X-MASK作为生成器模型（Generator）的输入，该生成器模型用于对序列中那些被MASK操作的tokens生成新的token（此时生成器是面向所有词表而言），以此来产生新的序列X-Generator；之后将X-Generator作为判别器模型的输入（Discriminator），该判别器模型用于判别序列中每一个token是否是原始token（和X-ORI进行对比而言）。

ELECTRA和BERT的区别：
在这里插入图片描述

5.3 ERNIE模型简述

ERNIE相比于BERT，做出了如下改进：

  • mask策略。BERT只使用了字级别的随机masking，但是ERNIE使用了字、短语、实体三个级别的masking，旨在使模型学习到更多高级的语义
  • 添加更多优质中文语料。加入了百度百科、百度新闻、百度贴吧等中文语料，使得在中文NLP任务上效果更好
  • 对话语言模型。对Dialog的角色，进行了Dialog embedding，从而加强模型在Dialog上的效果
  1. mask策略，使用了字、短语、实体三个级别的masking，模型可以学习到更大语义单元的知识
    在这里插入图片描述
  2. 添加更多优质中文语料。加入了百度百科、百度新闻、百度贴吧等中文语料，使得在中文NLP任务上效果更好。
  3. 对话语言模型，对Dialog的角色，进行了Dialog embedding，从而加强模型在Dialog上的效果。
    在这里插入图片描述
    DLM任务可帮助ERNIE学习对话中的隐式关系，这也增强了模型学习语义表示的能力。DLM任务的模型体系结构与MLM任务的模型体系结构兼容，因此可以通过MLM任务对其进行预训练。

总结

本文是对过去看过内容的一个复盘，只涉及到训练大模型的主要部分，部分细节无法逐一展现，需要源码的可以私我，如果疑问欢迎评论区交流。

从零开始大模型开发与微调：模型训练部分的编写
AI天才研究院
05-27 280
1. 背景介绍 大型语言模型（LLM）已成为自然语言处理（NLP）的核心技术之一，它们通过训练大量数据集，学习语言模式，从而实现了对语言的深入理解。近年来，随着计算能力的提高和数据集的扩大，LLM的性能不断得到提高。然而，如何高效地训练大型模型仍然是一个挑战。 本文将从零开始，详细介绍如何开发和微调一个大型语言模型，以及模型训练部分的编
从零开始大模型开发与微调：大模型带来的变革
AI天才研究院
07-06 880
从零开始大模型开发与微调：大模型带来的变革 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：大模型开发, 微调策略, 自动化机器学习, 大型神经网络, 技术演进 1. 背景介绍
RoBERTa- 稳健优化的 BERT 预训练模型详解
池央的博客
12-03 4048
自 BERT（Bidirectional Encoder Representations from Transformers）问世，预训练语言模型在自然语言处理（NLP）领域掀起革命浪潮，凭卓越表现大幅刷新诸多任务成绩。RoBERTa 承继 BERT 架构，却凭借一系列精巧优化，在效果上更进一步，成为当下 NLP 研究与应用热门模型，广泛用于文本分类、问答系统、机器翻译等任务。
【LM 00】从零开始认识大模型：一篇非从业者指南
zz12345600354的博客
06-17 658
AI技术第一次这么密集地冲击着非从业者们，身处变革之中的我们或许会迷茫，但这本来就是工业革命之后的常态，我们要做的就是像九十年代学习计算机一样拥抱未来。在ChatGPT刚出的时候，我对未来的知识创作是抱着悲观态度的。我认为个人创作者会被ChatGPT挤兑，或者直接投降借助ChatGPT来创作。久而久之，知识会陷入到封闭的循环当中，知乎也会沦为一个ChatGPT版公众号的聚集地，所以有一段时间我卸载了知乎。
从零开始训练大模型：保姆级教程，跟着老师轻松学会
最新发布
2401_84204413的博客
05-02 709
ChatGPT面世以来，各种大模型相继出现。那么大模型到底是如何训练的呢，在这篇文章中，我们将尽可能详细地梳理一个完整的 LLM 训练流程，包括模型预训练（Pretrain）、Tokenizer 训练、指令微调（Instruction Tuning）等环节。
从零开始训练大模型
太阳当空照，花儿对我笑，微风轻轻拂，心情无限好。
09-21 5204
我们更倾向于 SFT 的目的只是将 Pretrained Model 中的知识给引导出来的一种手段，而在SFT 数据有限的情况下，我们对模型的「引导能力」就是有限的。这将导致预训练模型中原先「错误」或「有害」的知识没能在 SFT 数据中被纠正，从而出现「有害性」或「幻觉」的问题。为此，一些让模型脱离昂贵标注数据，自我进行迭代的方法被提出，比如：[
大模型预训练认知分享
2301_81940605的博客
05-17 1464
根据scaling law，模型越大，高质量数据越多，效果越好。但还有一个很直观的情况，随着预训练样本的质量不断提升，训练手段的优化。新的模型，往往效果能轻松反超参数量两倍于它的模型。例如，最新出的minicpm，微信内部评测效果也是非常棒的。跟规模相对接近的2b、7b模型比，得分比qwen2b高，和qwen7b比有的高有的低。这个是minicpm的详细技术文档：这说明，现有参数量情况下，哪怕是2B尺度，也并没有得到充分训练。
从零开始学习大模型
weixin_41888295的博客
04-16 619
在本文中，我们将深入探讨如何创建一个大模型。我们将从数据收集、预处理、模型设计等方面进行详细解析，帮助读者理解并掌握大模型的创建过程。
通用大模型训练过程必须经历的四个阶段！
2301_78285120的博客
12-15 1万+
以上4个阶段构成了完整的GPT模型训练的pipeline，从中可以看出训练大模型是一个非常艰巨的任务，例如对庞大算力资源的要求、对高质量语料数据的要求。另外，在训练大模型的时候一般需要基于一些优化框架，如DeepSpeed，这些工程化方面的任务也有不少坑。因此，对于一般的企业而言通常不建议自己训练基础大模型，如果必须进行私有化部署，可以根据实际情况选择一款开源大模型，如有必要可基于开源大模型进行微调，通过这个途径可以用比较少的投入来高效地落地大模型应用。
从零开始大模型开发与微调：深度学习与人工智能
AI智能涌现深度研究
08-07 1054
1. 背景介绍 1.1 人工智能的新纪元：大模型的崛起 近年来，随着计算能力的提升和数据量的爆炸式增长，人工智能领域迎来了新的纪元：大模型的崛起。这些模型拥有庞大的参数量，能够在各种任务中展现出惊人的能力，例如自然语言处理、图像识别、语音合成等。大模型的出现，为人工智能的应用打开了新的
【NLP】第4章 从头开始预训练 RoBERTa 模型
热门推荐
sikh_0529的博客
09-25 1万+
将来使用更少的参数或其他类似方法进行蒸馏是一种巧妙的方式，可以充分利用预训练并使其高效地满足许多下游任务的需求。KantaiBERT 是一个类似 DistilBERT 的模型，因为它具有相同的 6 层和 12 个头的架构。您可以加载现有数据集或创建自己的数据集，具体取决于您的目标。您将有足够的变压器知识来面对工业 4.0 的挑战，即使用强大的预训练变压器（例如 GPT-3 引擎），这需要的不仅仅是开发技能来实现它们。中看到的那样，最初的 BERT 模型为最初的 Transformer 模型带来了创新功能。
中文大语言模型，以规模较小、可私有化部署、训练成本较低的模型为主
03-14
二是利用已有的大规模预训练模型进行微调，而不是从零开始训练，这样可以显著降低训练成本。 “底座模型”是指经过大规模无标注文本预训练得到的基础模型，如BERT、RoBERTa或ALBERT等。这些模型在各种自然语言处理...
如何从零开始学习大模型（非常详细）零基础入门到精通，收藏这一篇就够了
Python_0011的博客
06-24 2139
机器学习：简单来说，机器学习是指让计算机通过自动分析数据，从中学习到规律和模式，并利用这些学习到的知识来进行预测或做出决策，而无需明确地为其编写程序规则。机器学习的核心目标是让计算机能够从数据中自动提取有用的信息和知识。它能够处理大量的数据，并发现隐藏在其中的复杂关系。例如，通过分析大量的医疗记录，机器学习可以帮助预测疾病的发生；通过分析用户的购买行为数据，预测用户可能感兴趣的商品。机器学习的方法主要包括监督学习、无监督学习和强化学习等。监督学习是在有标记的数据集上进行学习，以预测未知数据的标记；
如何从零开始训练大模型
xiangxueerfei的博客
05-17 1268
现在大模型预训练，大家其实最关注的就是这个loss的收敛效果。这个时候，LR schedule的出现就是一个比较好的补充，能够补足优化器的一些问题。所以，你可以理解为，现在我们没有一个完美的油门，所以搞了俩油门，互相辅助。优化器是个老司机的油门，好用，但人类的经验是有局限性的，很容易陷入局部最优跑不出来。LR schedule像是一个全局的油门，定期更新，帮助老司机跳出局部最优。
Python从零开始进行AIGC大模型训练与推理
叶子的博客
04-17 7263
本专栏将详细介绍从零开始进行AIGC大模型训练与推理，包括文本生成（GPT系列）和图片生成（Stable Diffusion系列）等，初步计划从以下提纲逐步进行博文分享，欢迎关注。（8）Stable Diffusion原理介绍、训练、推理、部署。（9）ControlNet原理介绍、训练、推理、部署。（6）ChatGPT原理介绍、训练、推理、部署。（7）ChatGLM原理介绍、训练、推理、部署。（4）GPT2原理介绍、训练、推理、部署。（5）GPT3原理介绍、训练、推理、部署。
从零开始，大模型训练教程
xiangxueerfei的博客
10-07 1888
ChatGPT面世以来，各种大模型相继出现。那么大模型到底是如何训练的呢，在这篇文章中，我们将尽可能详细地梳理一个完整的 LLM 训练流程，包括模型预训练（Pretrain）、Tokenizer 训练、指令微调（Instruction Tuning）等环节。
从零开始学习大模型-第一章-大模型是什么
2401_84281729的博客
04-29 922
通过这些步骤，初学者可以逐步建立起对大模型的深入理解，并在实践中不断提升自己的技能。学习大模型的过程中，微调是一个关键环节，它使得预训练模型能够更好地适应特定的应用场景。通过这个过程，你可以使大模型更好地适应特定的任务需求，从而在实际应用中发挥最大的效能。通过仔细考虑这些因素，可以更有效地进行大模型的微调，从而在特定任务上获得更好的性能。
神仙级AI大模型入门教程(非常详细)，从零基础入门到精通，从看这篇开始！
AI大模型的博客
05-10 1万+
坚持到了这儿，恭喜你，表示你有做AI大模型工程师的潜力。其实我想说的上面的内容只是冰山一角，刚开始大家不需要多么精通了解这些内容。主要是不断练习，让自己跳出「舒适区」，进入「学习区」，但是又不进入「恐慌区」，不断给自己「喂招」。记住，学习是一个持续的过程。大模型技术日新月异，每天都有新的研究成果和技术突破。要保持对知识的渴望，不断学习最新的技术和算法。同时，实践是检验学习成果的最佳方式。通过实际项目实践，你将能够将理论知识转化为实际能力，不断提升自己的技术实力。最后，不要忘记与同行交流和学习。
新手必看：从零起步，一步步教你如何训练自己的大型模型——完整教程大揭秘！
2401_85325726的博客
12-29 2867
ChatGPT面世以来，各种大模型相继出现。那么大模型到底是如何训练的呢，在这篇文章中，我们将尽可能详细地梳理一个完整的 LLM 训练流程，包括模型预训练（Pretrain）、Tokenizer 训练、指令微调（Instruction Tuning）等环节。
applicationEventPublisher
03-11
### Spring Framework ApplicationEventPublisher Example and Usage In the context of the Spring framework, `ApplicationEventPublisher` is an interface that allows beans to publish events to the application context. This mechanism facilitates a loosely coupled architecture where components can notify each other about significant occurrences without being directly dependent on one another. The core classes involved in this event-driven model include: - **ApplicationEvent**: A class extending from which all custom events should derive. - **ApplicationListener<E extends ApplicationEvent>**: An interface implemented by any bean wishing to listen for specific types of events. - **ApplicationEventMulticaster**: The component responsible for broadcasting events to registered listeners within the ApplicationContext[^1]. To demonstrate how these pieces work together using `ApplicationEventPublisher`, consider the following code snippets illustrating both publishing and listening capabilities. #### Publishing Events with ApplicationEventPublisher A service or repository layer might want to inform others when certain actions occur. For instance, after saving data into storage, it could broadcast such activity as shown below: ```java @Service public class MyService { private final ApplicationEventPublisher publisher; @Autowired public MyService(ApplicationEventPublisher publisher) { this.publisher = publisher; } void performAction() { // Action logic here... CustomEvent event = new CustomEvent(this); publisher.publishEvent(event); // Publishes the event through the context } } ``` Here, upon executing some action inside `performAction()`, a new `CustomEvent` gets created and published via injection of `ApplicationEventPublisher`. #### Listening for Specific Events Using ApplicationListener On the receiving end, interested parties implement `ApplicationListener<SpecificEventType>` to react accordingly whenever their targeted type occurs: ```java @Component public class EventConsumer implements ApplicationListener<MyCustomEvent> { @Override public void onApplicationEvent(MyCustomEvent event) { System.out.println("Received my custom event : " + event.getMessage()); } } ``` This listener will automatically receive notifications every time a matching event (`MyCustomEvent`) happens anywhere across different parts of your application[^2]. Additionally, annotations like `@EventListener` provide even more concise syntax while offering flexibility regarding method signatures and parameters used during handling processes. By leveraging these constructs effectively, developers gain powerful tools enabling robust communication patterns throughout complex systems built atop Spring's foundation.
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值