如何编写Iveely搜索引擎插件

如果一个搜索引擎仅仅是网页搜索，那么将会是非常枯燥的，也不能根据业务需求扩展，还好Iveely在设计之初，就考虑了扩展性，预留插件功能，在不关闭服务或者停用服务的情况下，可以随时启用新插件或者禁用。

首先先介绍下Iveely加载插件的流程，再举例一步一步写插件。

原理：

在Iveely.Service下面，存在一个plugin.json文件，Iveely.Service将会每六个小时，更新配置信息，如果plugin.json有更新，将会更新到系统中。Iveey.Service只是一个服务中转站，它将用户的请求，根据请求的命令或者匹配的规则，将请求数据转发给对应插件进行处理，最终将插件处理后的结果返回给用户。plugin.json详细信息介绍如下:

plugin.json文件示例

{
    "emailServer":"smtp.126.com",
    "emailPort":"25",
    "emailName":"Iveely后台服务",
    "email": "2@126.com",
    "password": "2",
    "notify": "liufanping@iveely.com,founder@iveely.com",
    "plugins": [
        {
            "name": "天气预报",
            "enable": "1",
            "pattern": ".*天气.*",
            "command": "weather",
            "executeType":"1",
            "owner": "1@qq.com",
            "ip": "1.iveely.com,5001",
            "backup": "1.iveely.com,5001"
        },
        {
            "name": "计算器",
            "enable": "1",
            "pattern": ".*等于.*",
            "command": "calculate",
            "executeType":"2",
            "owner": "2@qq.com",
            "ip": "2.iveely.com,5002",
            "backup": "2.iveely.com,5002"
        }]
}

下面将以搜索引擎的计算功能为例，为Iveely新增计算插件，首先效果图如下：

     示例：

第一步：新建纯Java应用程序工程。

第二步：添加相应的库。

由于插件是以网络方式存在的，因此添加必要的网络库是必然的，其次是基于Iveely.Framework存在。

这些jar文件，均可以在Iveely.Framework工程中找到。

第三步：编写计算器计算类：Calculate类。

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.iveely.plugins.calculator;

import java.util.Collections;
import java.util.Stack;

/**
 *
 * @author X1 Carbon
 */
public class Calculate {

    /**
     * Algorithm helper.
     *
     * @author liufanping@iveely.com
     * @date 2014-11-16 10:38:07
     */
    public static class ArithHelper {

        /**
         * The default precision division.
         */
        private static final int DEF_DIV_SCALE = 16;

        private ArithHelper() {
        }

        /**
         * Provide accurate addition.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double add(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.add(b2).doubleValue();
        }

        /**
         * Provide accurate addition.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double add(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.add(b2).doubleValue();
        }

        /**
         * Provide accurate subtraction.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double sub(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.subtract(b2).doubleValue();
        }

        /**
         * Provide accurate subtraction.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double sub(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.subtract(b2).doubleValue();
        }

        /**
         * Provides accurate multiplication.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double mul(double v1, double v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.multiply(b2).doubleValue();
        }

        /**
         * Provides accurate multiplication.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double mul(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.multiply(b2).doubleValue();
        }

        /**
         * Provide (relatively) precise division, except when the situation
         * occurs when the endless, accurate to 10 decimal point, after the
         * figures are rounded.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double div(double v1, double v2) {
            return div(v1, v2, DEF_DIV_SCALE);
        }

        /**
         * Provide (relatively) precise division, except when the situation
         * occurs when the endless, accurate to 10 decimal point, after the
         * figures are rounded.
         *
         * @param v1
         * @param v2
         * @return
         */
        public static double div(String v1, String v2) {
            java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
            java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
            return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        /**
         * Providing (relatively) accurate division. When occurrence except
         * endless, specify the scale parameter accuracy, after rounding
         * numbers.
         *
         * @param v1
         * @param v2
         * @param scale。
         * @return
         */
        public static double div(double v1, double v2, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
            java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
            return b1.divide(b2, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        /**
         * Provides precise decimals rounded handle.
         *
         * @param v
         * @param scale
         * @return
         */
        public static double round(double v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
            java.math.BigDecimal one = new java.math.BigDecimal("1");
            return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }

        /**
         * Provides precise decimals rounded handle.
         *
         * @param v
         * @param scale
         * @return
         */
        public static double round(String v, int scale) {
            if (scale < 0) {
                throw new IllegalArgumentException("The   scale   must   be   a   positive   integer   or   zero");
            }
            java.math.BigDecimal b = new java.math.BigDecimal(v);
            java.math.BigDecimal one = new java.math.BigDecimal("1");
            return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
        }
    }

    /**
     * Postfix stack.
     */
    private final Stack<String> postfixStack;

    /**
     * Operator Stack.
     */
    private final Stack<Character> opStack;

    /**
     * Operators use the ASCII -40 indexing of operator precedence.
     */
    private final int[] operatPriority;

    public Calculate() {
        postfixStack = new Stack<>();
        opStack = new Stack<>();
        operatPriority = new int[]{0, 3, 2, 1, -1, 1, 0, 2};
    }

    /**
     * According to the given expression evaluates.
     *
     * @param expression
     * @return
     */
    public String calculate(String expression) {
        try {
            Stack<String> resultStack = new Stack<>();
            prepare(expression);
            Collections.reverse(postfixStack);
            String firstValue, secondValue, currentValue;
            while (!postfixStack.isEmpty()) {
                currentValue = postfixStack.pop();
                if (!isOperator(currentValue.charAt(0))) {
                    resultStack.push(currentValue);
                } else {
                    secondValue = resultStack.pop();
                    firstValue = resultStack.pop();
                    String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
                    resultStack.push(tempResult);
                }
            }
            return expression + "=" + Double.valueOf(resultStack.pop());
        } catch (NumberFormatException e) {
        }
        return "";
    }

    /**
     * Be converted into postfix expression stack.
     *
     * @param expression
     */
    private void prepare(String expression) {
        opStack.push(',');
        char[] arr = expression.toCharArray();
        int currentIndex = 0;
        int count = 0;
        char currentOp, peekOp;
        for (int i = 0; i < arr.length; i++) {
            currentOp = arr[i];
            if (isOperator(currentOp)) {
                if (count > 0) {
                    postfixStack.push(new String(arr, currentIndex, count));
                }
                peekOp = opStack.peek();
                if (currentOp == ')') {
                    while (opStack.peek() != '(') {
                        postfixStack.push(String.valueOf(opStack.pop()));
                    }
                    opStack.pop();
                } else {
                    while (currentOp != '(' && peekOp != ',' && compare(currentOp, peekOp)) {
                        postfixStack.push(String.valueOf(opStack.pop()));
                        peekOp = opStack.peek();
                    }
                    opStack.push(currentOp);
                }
                count = 0;
                currentIndex = i + 1;
            } else {
                count++;
            }
        }
        if (count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {
            postfixStack.push(new String(arr, currentIndex, count));
        }
        while (opStack.peek() != ',') {
            postfixStack.push(String.valueOf(opStack.pop()));
        }
    }

    /**
     * Determine whether the arithmetic sign.
     *
     * @param c
     * @return
     */
    private boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
    }

    /**
     * Use ASCII code -40 subscript to do arithmetic signs priority.
     *
     * @param cur
     * @param peek
     * @return
     */
    public boolean compare(char cur, char peek) {
        boolean result = false;
        if (operatPriority[(peek) - 40] >= operatPriority[(cur) - 40]) {
            result = true;
        }
        return result;
    }

    /**
     * According to the given arithmetic operators to do the calculation.
     *
     * @param firstValue
     * @param secondValue
     * @param currentOp
     * @return
     */
    private String calculate(String firstValue, String secondValue, char currentOp) {
        String result = "";
        switch (currentOp) {
            case '+':
                result = String.valueOf(ArithHelper.add(firstValue, secondValue));
                break;
            case '-':
                result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
                break;
            case '*':
                result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
                break;
            case '/':
                result = String.valueOf(ArithHelper.div(firstValue, secondValue));
                break;
            default:
                result = "error format.";
        }
        return result;
    }
}

Calculate类是用于服务的，那么它是怎么提供对外服务呢？

第四步：新建EventHandler类：用于消息处理。

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.iveely.plugins.calculator;

import com.iveely.framework.net.ICallback;
import com.iveely.framework.net.InternetPacket;
import java.io.UnsupportedEncodingException;

/**
 *
 * @author 凡平
 */
public class EventHandler implements ICallback {

    /**
     * Weather forecast.
     */
    private Calculate calculate;

    public EventHandler() {
        this.calculate = new Calculate();
    }

    @Override
    public InternetPacket invoke(InternetPacket packet) {
        InternetPacket respPacket = new InternetPacket();
        respPacket.setMimeType(0);
        respPacket.setExecutType(packet.getExecutType() * -1);
        if (packet.getExecutType() == 2) {
            try {
                String query = getString(packet.getData());
                System.out.println("计算表达式：" + query);
                String result =  this.calculate.calculate(query);
                if (result.isEmpty()) {
                    respPacket.setExecutType(Integer.MIN_VALUE);
                    respPacket.setData(getBytes("Expression error."));
                }else{
                    respPacket.setData(getBytes(result));
                }

            } catch (Exception e) {
                respPacket.setExecutType(Integer.MIN_VALUE);
                respPacket.setData(getBytes(e.getMessage()));
            }
            return respPacket;
        } else {
            return InternetPacket.getUnknowPacket();
        }
    }

    /**
     * Convert string to byte[].
     *
     * @param content
     * @return
     */
    private byte[] getBytes(String content) {
        byte[] bytes;
        try {
            bytes = content.getBytes("UTF-8");
        } catch (UnsupportedEncodingException ex) {
            bytes = content.getBytes();
        }
        return bytes;
    }

    /**
     * Convert byte[] to string.
     *
     * @param bytes
     * @return
     */
    private String getString(byte[] bytes) {
        try {
            return new String(bytes, "UTF-8").trim();
        } catch (UnsupportedEncodingException ex) {
            return new String(bytes).trim();
        }
    }
}

这里面有几个注意的事项：

1. 一定要继承 ICallback。

2. packet.getExecutType() == 2 表示它的执行类型，需要在plugin.json 中配置。

第五步：启动插件服务。

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.iveely.plugins.calculator;

import com.iveely.framework.net.Server;

/**
 *
 * @author 凡平
 */
public class Program {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int port = 5002;
        System.out.println("Server started, port = " + port);
        EventHandler handler = new EventHandler();
        Server server = new Server(handler, port);
        server.start();
    }

}

按照上面，五个步骤，你就完成了一个最基本的插件编写，生成jar包，找一台机器，将它运行起来，要让搜索引擎能够正常使用，还需要让搜索引擎知道这个插件，那么需要配置plugin.json文件。