巧用rpmbuild的expand宏实现模板功能
Posted ddev
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了巧用rpmbuild的expand宏实现模板功能相关的知识，希望对你有一定的参考价值。
需求：构建生成的二进制包的个数不确定，由某些条件决定。
比如，我们想为系统中的所有内核版本构建某个外来模块，如果系统中有2个内核版本，就生成两个2个二进制包，分别对应相应的版本，如果系统中有3个内核版本，就生成3个二进制包。
我们的需求是实现动态个数的%package。
很多人在讨论spec是不是一种脚本，很显然不是，它本身没有变量，也不支持循环。但是是支持条件判断的，也支持自定义宏。
回到正题，如果以其它编程语言的逻辑来看，貌似需要的功能是一个变量和若干次循环。但是在spec文件中，就得想另外的办法了。
expand，展开，其实相当于二次执行，类似于bash的eval。它将展开的内容作为spec文件的一部分。
我们就利用bash的循环功能，构建动态个数的%package。
下面给出一个demo，可以根据构建时传入的宏来生成不同个数的二进制包。
rpmbuild -D "packages a b c" -bb SPECS/test.spec将生成test-a、test-b、test-c三个二进制包。
%!?packages: %define packages a
Name: test
Version: 1.0
Release: 1
Summary: test
License: GPL
%description
test
%install
for sub in %packages; do
touch %buildroot/$sub
done
%expand:%(/bin/bash -c "for sub in %packages; do
cat <<EOF
%package \\$sub
Summary: \\$sub
%description \\$sub
%files \\$sub
/\\$sub
EOF
done")
巧用模板方法模式，实现加载违禁词文件功能
点击关注公众号，实用技术文章及时了解
来源：www.jianshu.com/p/815212eb648a
简介
模板方法模式是最为常见的几个模式之一（也比较简单），是基于继承实现代码复用的基本技术。
模板方法模式（TemplateMethod Pattern）的定义是： 首先定义了一个由若干执行步骤组成的执行过程（形成模板），而将一些步骤延迟在子类中实现，使得子类能够对其中一个或者多个具体步骤进行重新定义，从而改变最终的执行结果。
模板方法模式的UML类图如下：
这里涉及到了两个角色：
抽象模板 AbstractTemplate
定义并实现了一个模板方法。这个模板方法一般是一个具体的方法，它定义了一个顶级逻辑的框架，而逻辑的组成步骤由抽象方法和其他具体方法组成，抽象方法在子类中实现。
定义了一个或者多个抽象方法，这个/些抽象方法是模板方法的一部分，组成模板方法内一个或者多个步骤。
具体模板 ConcreteTemplate
实现抽象父类定义的一个或者多个抽象方法，它们是模板方法的组成步骤。
每一个抽象模板都可以有任意多个具体模板的实现，每一个具体模板都可以给出这些抽象方法的不同实现，从而改变模板方法最后的执行结果。
模板方法模式中的方法
模板方法模式中的方法可以分为两大类：模板方法和基本方法
模板方法
模板方法是定义在抽象类中的，把基本操作组合在一起形成一个总的执行过程。
一个抽象类可以有任意多个模板方法，而不限于一个，每一个模板方法都可以调用任意多个具体方法。
基本方法
基本方法又可以进一步划分成：抽象方法（Abstract Method）、具体方法（Concrete Method）和钩子方法（Hook Method）
抽象方法： 抽象方法由抽象类声明并最终由具体子类实现，从而改变模板方法的最终执行结果
具体方法： 具体方法由抽象类声明并实现，子类不一定需要实现（除非是需要重写改方法）
钩子方法： 钩子方法由抽象类声明并实现，而子类会对其进行拓展，通常抽象类给出的实现是一个空实现，作为方法的默认实现。
使用场景
我之前做过的一个业务场景是：对短信的文本内容进行敏感词过滤，需要将文本内容与敏感词词库做匹配，通过加载敏感词文件即可获取全部的违禁词，敏感词文件可以放在服务器内的某一个具体路径，也可以是放在项目内的Resource目录下，在这两个位置下加载方式是有区别的，但是除此之外违禁词的读取、存放都是相同的。
定义了一个接口SensitiveWordLoader、一个抽象类SensitiveWordAbstractFileLoader以及两个具体实现SensitiveWordExternalFileLoader和SensitiveWordJarFileLoader,UML类图如下：
由于敏感词词库也可以存放在各类数据库中，从文件中加载只是其中的一种方法，因此提供了一个接口SensitiveWordLoader供抽象类SensitiveWordAbstractFileLoader实现，SensitiveWordAbstractFileLoader中的load方法即是模板方法。
其中定义了敏感词文件流的获取以及从文件流中读取敏感词并存放，其中的extractSensitiveWordFromSingleLine是具体方法，用于定义从敏感词文件中逐行提取敏感词的逻辑，initInputStream是抽象类中定义的输入流初始化方法，在不同加载方式下获取输入流的方式均不相同因此需要交由子类进行实现；模板方法load内的主要执行逻辑由具体方法extractSensitiveWordFromSingleLine和抽象方法initInputStream完成。
各类代码如下：
SensitiveWordLoader
package com.cube.dp.tmp;
import org.springframework.lang.NonNull;
import java.util.List;
/**
* @author cube.li
* <p>
* 违禁词加载器
*/
public interface SensitiveWordLoader
/**
* 加载违禁词
*
* @return 违禁词列表
*/
@NonNull
List<String> load();
SensitiveWordAbstractFileLoader
package com.cube.dp.tmp;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.lang.NonNull;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @author cube.li
* <p>
* 抽象违禁词文件加载器
*/
@SuppressWarnings("unused", "WeakerAccess")
public abstract class SensitiveWordAbstractFileLoader implements SensitiveWordLoader
/**
* 违禁词文件路径
*/
protected String filePath;
/**
* 文件字符集
*/
protected Charset charset;
/**
* 关键词分隔符
*/
protected String separator;
protected InputStream inputStream;
/**
* 加载标识
*/
private static final AtomicBoolean LOAD_FLAG = new AtomicBoolean(false);
/**
* 违禁词列表
*/
private static List<String> sensitiveWordList;
public SensitiveWordAbstractFileLoader(String filePath, Charset charset, String separator)
this.filePath = filePath;
this.charset = charset;
this.separator = separator;
sensitiveWordList = new ArrayList<>();
initInputStream();
/**
* 初始化inputStream
*/
public abstract void initInputStream();
@Override
@NonNull
public List<String> load()
if (LOAD_FLAG.getAndSet(true))
return sensitiveWordList;
InputStreamReader reader = null;
BufferedReader bufferedReader = null;
try
reader = new InputStreamReader(inputStream, charset.name());
bufferedReader = new BufferedReader(reader);
String singleLine;
while ((singleLine = bufferedReader.readLine()) != null)
sensitiveWordList.addAll(extractSensitiveWordFromSingleLine(singleLine.trim()));
return sensitiveWordList;
catch (Exception e)
e.printStackTrace();
LOAD_FLAG.set(false);
throw new IllegalStateException("load sensitive word file failed,msg =" + e.getMessage());
finally
IOUtils.closeQuietly(inputStream);
IOUtils.closeQuietly(reader);
IOUtils.closeQuietly(bufferedReader);
/**
* 从文件单行内容中获取违禁词
*
* @param singleLine 单行内容
* @return 提取到的违禁词列表
*/
@NonNull
private List<String> extractSensitiveWordFromSingleLine(String singleLine)
String[] array = singleLine.split(separator);
List<String> list = new ArrayList<>();
for (String str : array)
if (StringUtils.isNotBlank(str))
list.add(str);
return list;
public String getFilePath()
return filePath;
public Charset getCharset()
return charset;
public String getSeparator()
return separator;
public InputStream getInputStream()
return inputStream;
public static List<String> getSensitiveWordList()
return sensitiveWordList;
SensitiveWordJarFileLoader
package com.cube.dp.tmp;
import org.springframework.core.io.ClassPathResource;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* @author cube.li
* <p>
* 加载jar包内的违禁词文件加载器
*/
@SuppressWarnings("unused")
public class SensitiveWordJarFileLoader extends SensitiveWordAbstractFileLoader
public SensitiveWordJarFileLoader(String relativePath, String separator)
super(relativePath, StandardCharsets.UTF_8, separator);
public SensitiveWordJarFileLoader(String relativePath)
super(relativePath, StandardCharsets.UTF_8, ",");
/**
* 构造器
*
* @param relativePath 相对路径,包含文件名(位于resources目录下)
* @param charset 字符集
* @param separator 分隔符
*/
public SensitiveWordJarFileLoader(String relativePath, Charset charset, String separator)
super(relativePath, charset, separator);
@Override
public void initInputStream()
try
ClassPathResource classPathResource = new ClassPathResource(filePath);
inputStream = classPathResource.getInputStream();
catch (IOException e)
throw new IllegalStateException("load sensitive word file in jar failed,message = " + e.getMessage());
SensitiveWordExternalFileLoader
package com.cube.dp.tmp;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* @author cube.li
* <p>
* 违禁词外部文件加载器(加载服务器内部,jar包外部)
*/
@SuppressWarnings("unused")
public class SensitiveWordExternalFileLoader extends SensitiveWordAbstractFileLoader
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath, String separator)
this(externalFileAbsolutePath, StandardCharsets.UTF_8, separator);
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath)
this(externalFileAbsolutePath, ",");
/**
* 构造器
*
* @param externalFileAbsolutePath 违禁词文件的绝对路径
* @param charset 字符集
* @param separator 违禁词分隔符
*/
public SensitiveWordExternalFileLoader(String externalFileAbsolutePath, Charset charset, String separator)
super(externalFileAbsolutePath, charset, separator);
@Override
public void initInputStream()
File file = new File(filePath);
try
inputStream = new FileInputStream(file);
catch (FileNotFoundException e)
throw new IllegalStateException("external sensitive word file not found,filePath = " + filePath);
通过上面的例子可以看出，使用模板方法模式实现后的代码复用率极高，子类只需要专注其中的一个或者多个步骤即可，无须将模板方法内的顶层执行逻辑全部重写，代码的阅读性和可拓展性极高。有
的同学可能会问到，为什么这个例子里没有钩子方法（Hook Method）呢？我这里的业务场景比较简单，因此不需要借助钩子方法实现逻辑。
总结
其实各种设计模板无非是前人在无数的业务开发中总结出来的一套模板，说到底就是合理的封装、继承和解耦，设计模式中的各种概念是高度抽象的结果，我们只需要重点关注每个设计模式的实现思路，不必完全对设计模式进行生搬硬套，所谓尽信书则不如无书，结合实际应用场景灵活运用不拘于形才是最佳。
代码详情请看：
https://gitee.com/li-cube/java-design-mode/tree/master/template-method-pattern/src/main/java/com/cube/dp/telp
推荐
PS：因为公众号平台更改了推送规则，如果不想错过内容，记得读完点一下“在看”，加个“星标”，这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧！
以上是关于巧用rpmbuild的expand宏实现模板功能的主要内容，如果未能解决你的问题，请参考以下文章