【java】字符串插值（类似于模板引擎)练习

刺骨的言语ヽ痛彻心扉 2023-10-08 23:43 4阅读 0赞

## 背景 ##

在web开发中，字符串插值是最常用的字符串操作之一。

虽然许多编程语言都提供内置的字符串插值支持，但在这个挑战中，您需要自己实现它。不允许在您选择的编程语言中使用内置的字符串插值机制。

在这个挑战中，变量名用双花括号表示:\{ \{和\}\}。例如，给定字符串"Your name is \{ \{name\}\}“和键值对对象\{“name”: “Johnny”\}，它应该返回"Your name is Johnny”。

双花括号和变量名之间的空格/制表符将被忽略。例如，“My name is \{ \{name\}\}”、“My name is \{ \{name\}\}”和“My name is \{ \{name\}\}”是等价的。

## 目标 ##

实现一个带有两个参数的函数/方法:

*  插值的字符串。必选参数。
 *  具有字符串键和任何类型值的键-值对对象(选择所选语言支持的键-值对类型)。必选参数。

函数/方法应该:

*  返回插值后的字符串
 *  忽略字符串中的变量中不存在的键-值对对象键
 *  如果键值对对象中缺少字符串中的一个变量，则抛出异常/错误

## 思路 ##

实现该字符串插值需求需要注意两方面

*  解析字符串中的 `{ {` 、`}}` 对
 *  根据 `{ {` 、`}}` 对 内部的 key 替换字符串中 `{ {` 、`}}` 及其内部的字符

## 实现 ##

主类 **`Interpolation`**

package com.xzbd.test.interpolation;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Set;
    import java.util.stream.Collectors;
    
    import com.xzbd.test.exception.InterpolationException;
    import com.xzbd.test.util.StringUtil;
    
    public class Interpolation {
        
    
        private String content;
    
        private Map<String, Object> values;
    
        private Set<String> keys;
    
        public Interpolation(String content, Map<String, Object> values) {
        
            this.content = content;
            this.values = values;
        }
    
        /**
         * 解析所有的 key
         */
        private void parseKeys(List<InterpolationExp> objs) {
        
            if (Objects.isNull(objs) || objs.isEmpty()) {
        
                return;
            }
            keys = objs.stream().map(o -> o.getKey()).collect(Collectors.toSet());
        }
    
        /**
         * 校验 values 中是否包含所有 key
         * 
         * @return
         */
        private boolean validate() {
        
            if (keys == null || keys.isEmpty()) {
        
                return true;
            }
            for (String key : keys) {
        
                if (values.containsKey(key)) {
        
                    continue;
                }
                throw new InterpolationException("key 校验失败，values 中未定义 key \"" + key + "\"");
            }
            return true;
        }
    
        /**
         * 织入，将 value 植入 content
         * 
         * @return
         */
        private String weaving(List<InterpolationExp> objs) {
        
            if (objs == null || objs.isEmpty()) {
        
                return content;
            }
            int offset = 0;
            for (InterpolationExp obj : objs) {
        
                String key = obj.getKey();
                String val = Objects.isNull(values.get(key)) ? "" : values.get(key).toString();
                int begin = obj.getBeginPoint() - offset;
                int end = obj.getEndPoint() - offset;
                content = StringUtil.replaceFromTo(content, begin, end, val);
                offset = offset + (obj.getEndPoint() - obj.getBeginPoint() + 1) - val.length();
            }
    
            return content;
        }
    
    	// 使用 StringBuilder 对象简单处理 字符串替换
        // private String weaving(List<InterpolationExp> objs) {
        
        // if (objs == null || objs.isEmpty()) {
        
        // return content;
        // }
        // int offset = 0;
        // StringBuilder sb = new StringBuilder(content);
        // for(InterpolationExp obj : objs){
        
        // String key = obj.getKey();
        // String value = values.get(key).toString();
        // sb.replace(obj.getBeginPoint() - offset, obj.getEndPoint() + 1 - offset ,
        // value);
        // offset = offset + (obj.getEndPoint() - obj.getBeginPoint() + 1) -
        // value.length();
        // }
    
        // return sb.toString();
        // }
    
        public String process() {
        
            InterpolationParser parser = new InterpolationParser(content);
            if (!parser.isSuccess()) {
        
                throw new InterpolationException("表达式解析失败，请检查 {
        { 与 }} 是否匹配");
            }
            List<InterpolationExp> objs = parser.getInterpolations();
            // 解析 Keys
            parseKeys(objs);
            // 校验 values 中是否包含所有的 key
            validate();
            // 织入
            return weaving(objs);
        }
    
    }

插值表达式类 **`InterpolationExp`**，该类主要定义了插值表达式实体，用于描述字符串中所有匹配到的插值表达式。根据软件设计，目前设计了 `beginPoint`、`endPoint`、`key` 三个字段。

package com.xzbd.test.interpolation;
    
    /**
     * 插值表达式
     */
    public class InterpolationExp {
        
        private int beginPoint = -1;
        private int endPoint = -1;
        private String key;
    
        public InterpolationExp(int beginPoint ,int endPoint ,String key){
        
            this.beginPoint = beginPoint;
            this.endPoint = endPoint;
            this.key = key;
        }
        
        public int getBeginPoint(){
        
            return  beginPoint;
        }
    
        public int getEndPoint(){
        
            return  endPoint;
        }
    
        public String getKey(){
        
            return key;
        }
    }

解析类 **`InterpolationParser`**

该类主要用于解析字符串模板，其中 `{ {` 和 `}}` 使用到了栈技术`Stack`。解析在该类实例化时进行，`InterpolationParser` 会记录解析结果`private boolean success = false`和解析到的插值表达式列表`List<InterpolationExp> interpolations`。

详细代码如下：

package com.xzbd.test.interpolation;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Stack;
    import java.util.stream.Collectors;
    
    import com.xzbd.test.exception.InterpolationException;
    
    public class InterpolationParser {
        
    
        private Map<Character, Character> brackets;
        private Stack<Character> stack;
        private List<InterpolationExp> interpolations;
        private boolean success = false;
    
        public InterpolationParser(String content) {
        
            if (content == null) {
        
                throw new InterpolationException("content 不能为空");
            }
            // 定义左右括号关系
            brackets = new HashMap<>();
            brackets.put('}', '{');
    
            stack = new Stack<>();
            interpolations = new ArrayList<>();
    
            // 解析
            parse(content);
    
        }
    
        private void parse(String s) {
        
    
            int begin = -1;
            int end = -1;
            List<Character> charts = null;
    
            for (int i = 0; i < s.length(); i++) {
        
                Character temp = s.charAt(i);// 先转换成字符
    
                // 是否为左括号
                if (brackets.containsValue(temp)) {
        
                    begin = i;
                    i = i + 1;
                    if (i > s.length() - 1) {
        
                        return;
                    }
    
                    Character temp2 = s.charAt(i);
                    if (!Objects.equals(temp, temp2)) {
        
                        return;
                    }
                    stack.push(temp);
                    stack.push(temp2);
                    if (stack.size() > 2) {
        
                        return;
                    }
                    charts = new ArrayList<>();
                }
                // 是否为右括号
                else if (brackets.containsKey(temp)) {
        
                    if (stack.isEmpty() || stack.size() != 2) {
        
                        return;
                    }
                    i = i + 1;
                    if (i > s.length() - 1) {
        
                        return;
                    }
                    Character temp2 = s.charAt(i);
                    if (!Objects.equals(temp, temp2)) {
        
                        return;
                    }
    
                    // 若左右括号匹配
                    if (stack.peek() == brackets.get(temp)) {
        
                        stack.pop();
                        stack.pop();
                        end = i;
                        String key = charts.stream().map(c -> c.toString()).collect(Collectors.joining());
                        key = key == null ? "" : key.trim();
                        InterpolationExp obj = new InterpolationExp(begin, end, key);
                        interpolations.add(obj);
                    } else {
        
                        return;
                    }
                } 
                // 其他字符
                else {
        
                    if(charts == null){
        
                        continue;
                    }
                    charts.add(s.charAt(i));
                }
    
            }
            success = stack.isEmpty() ? true : false;
        }
    
        /**
         * 解析是否成功
         * 
         * @return
         */
        public boolean isSuccess() {
        
            return this.success;
        }
    
        /**
         * 返回匹配到的插值对
         * 
         * @return
         */
        public List<InterpolationExp> getInterpolations() {
        
            return interpolations;
        }
    }

**工具类`StringUtil`**

package com.xzbd.test.util;
    
    import java.util.Arrays;
    
    public class StringUtil {
        
        /**
         * 替换指定位置的字符串
         * 
         * <div>将字符串 origin 的 begin 到 end 之间的值替换为 val</div>
         * @param origin 原字符串
         * @param begin 开始位置
         * @param end 结束位置
         * @param val 替换结果字符转
         * @return
         */
        public static String replaceFromTo(String origin, int begin, int end, String val) {
        
            if(origin == null || origin.isEmpty()){
        
                return origin;
            }
    
            char[] chars = origin.toCharArray();
    
            char[] prefixChars = Arrays.copyOf(chars, begin);
            String prefixStr = String.valueOf(prefixChars);
    
            char[] suffixChars = Arrays.copyOfRange(chars, end + 1, chars.length);
            String suffixStr = String.valueOf(suffixChars);
    
            return prefixStr + val + suffixStr;
        }
    }

**异常`InterpolationException`**

package com.xzbd.test.exception;
    
    public class InterpolationException extends RuntimeException{
        
    
        public InterpolationException(String msg){
        
            super(msg);
        }
        
    }

## 测试 ##

测试类 `TestApplication`

package com.xzbd.test.example;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import com.xzbd.test.interpolation.Interpolation;
    
    public class TestApplication {
        
    
    	public static void main(String[] args) {
        
    		testCase1();
    		testCase2();
    		testCase3();
    	}
    
    	public static boolean testCase1() {
        
    		Map<String, Object> map = new HashMap<>();
    		map.put("name", "Bill");
    		map.put("age", 21);
    
    		String content = "My name is {
        { name }} and I am forever {
        { age }}.";
    
    		Interpolation interpolation = new Interpolation(content, map);
    		String res = interpolation.process();
    		System.out.println(res);
    		return true;
    	}
    
    	public static boolean testCase2() {
        
    		Map<String, Object> map = new HashMap<>();
    		map.put("name", "Bill");
    		map.put("age", 21);
    		map.put("male", true);
    
    		String content = "Say hello to {
        { name }}. He is {
        { age }}.";
    
    		Interpolation interpolation = new Interpolation(content, map);
    		String res = interpolation.process();
    		System.out.println(res);
    		return true;
    	}
    
    	public static boolean testCase3() {
        
    		Map<String, Object> map = new HashMap<>();
    		map.put("name", "Bill");
    		
    		String content = "Tommy is a good friend of {
        { name }}. He lives in {
        { city }}.";
    
    		Interpolation interpolation = new Interpolation(content, map);
    		String res = interpolation.process();
    		System.out.println(res);
    		return true;
    	}
    
    }

测试用例执行结果：

![在这里插入图片描述][3cadb86c2eb34bf185ea09bfb1f8d3b7.png]

## 总结 ##

该文根据模板引擎的使用经验，模拟了一个 字符串插值程序。软件中使用到了栈（Stack） 查找 “\{ \{” 和 “\}\}” 对，并使用 char 数组的放大替换字符串中相应的表达式。软件设计有表达式解析、k-v 值校验和织入三个阶段，支持异常抛出。

[源码包地址][Link 1]： https://download.csdn.net/download/m0\_47406832/87650092

源码中未使用一些现有的API处理，因此存在很多优化的地方。**欢迎大家留言给出更好的实现方案**

[3cadb86c2eb34bf185ea09bfb1f8d3b7.png]: https://img-blog.csdnimg.cn/3cadb86c2eb34bf185ea09bfb1f8d3b7.png
[Link 1]: https://download.csdn.net/download/m0_47406832/87650092