Java:基于Linux平台的语音聊天机器人

项目名称: 基于Linux平台的语音聊天机器人
开发环境: Centos7+IDEA+JDK1.8+Maven
项目功能:
1.语音聊天功能:能够实现人机交互,进行语音聊天。
2.命令识别功能:通过语言聊天判别对话内容是否是命令,如果 是命令则执行命令。
3.文字识别功能:通过语言控制进入文字识别系统,将有文字的预设图片传入到指定路 径下。由程序识别后,返回图片中的字。
4.手势识别功能:通过语言控制进入手势识别系统,将带手势的图片传入指定路径。由 系统识别后,返回图片中人的手势。
参考文档:语音合成API 语音识别API 图像识别API
项目准备:
1.首先需要虚拟机以及Centos环境
2.JDK 安装

2.1运行java -version查看当前目录下是否自带JDK
如有java version "1.7.0"OpenJDK Runtime Environment
执行以下命令进行删除所有的包。
2.2rpm -e --nodeps java-1.7.0-openjdk
2.3rpm -e --nodeps java-1.7.0-openjdk-headless
2.4rpm -e --nodeps tzdata-java
上传jdk.rpm包到Centos上
2.5运行rpm -ivh jdk-8u20-linux-x64.rpm进行解压安装
2.6运行vi  ~/.bash_profile打开配置文件,加上JDK环境变量
export JAVA_HOME=/usr/java/jdk1.8.0_171-amd64 export (此路径是你解压的路径)
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar export
PATH=$PATH:$JAVA_HOME/bin
2.7运行source ~/.bash_profile重新加载配置文件
2.8运行java -version查看当前系统下的JDK是否安装完成

3.安装Maven

3.1安装wget命令
yum -y install wget
3.2下载Maven包
wget http://mirror.bit.edu.cn/apache/maven/maven-3/3.5.2/binaries/apache-maven-3.5.2-bin.tar.gz
3.3解压
tar -zxvf apache-maven-3.5.2-bin.tar.gz 
3.4运行vi /etc/profile 配置环境变量,添加以下内容
export MAVEN_HOME=/var/apache-maven-3.5.2(路径是你解压的路径)
export MAVEN_HOME
export PATH=$PATH:$MAVEN_HOME/bin
3.5运行source /etc/profile重新加载配置文件
3.6运行mvn -version查看当前系统下的Maven是否安装完成

4.安装语音播放器

4.1检查系统是否自带录音软件
运行arecord查看系统是否自带录音
4.2安装cvlc播放器
rpm -Uvh http://li.nux.ro/download/nux/dextop/el7/x86_64/nux-dextop-release-0-5.el7.nux.noarch.rpm
yum install vlc -y 
安装完成后
运行cvlc查看系统是否已经有该命令

5.注册图灵机器人和百度智能云

5.1注册图灵机器人后,创建机器人,得到机器人的apikey
5.2语音识别和语言合成用同一个接口,所以创建一个语音识别应用,一个手势识别应用,一个文字识别应用。创建完成后获取到应用的AppID,API Key,Secret Key

项目开发
1.创建一个Maven项目,在pom.xml中导入百度智能云的API SDK。以及JSON的第三方依赖包

 <dependency>
       <groupId>com.baidu.aip</groupId>
       <artifactId>java-sdk</artifactId>
       <version>4.8.0</version>
 </dependency>
 <dependency>
       <groupId>org.kohsuke.stapler</groupId>
       <artifactId>json-lib</artifactId>
       <version>2.1-rev6</version>
 </dependency>

2.编写代码
2.1本次项目是在Linux环境下运行,运行时需要调用Linux命令,所有首先创建执行Linux命令的类

//LinuxExectue.java

package com.github7;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;

public class LinuxExectue {
    //创建执行Linux命令的类,并且打印输出后的结果
    public String  execshell(String str) {
        String cmd = str;
        String strings="";
        try {
            Process ps = Runtime.getRuntime().exec(cmd);
            strings = loadStream(ps.getInputStream());
            System.out.print(strings);
            System.err.print(loadStream(ps.getErrorStream()));
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return strings;
    }
    //判断文件是否存在

    public String  execshelllocation(String str) {
        String cmd = str;
        String strings="";
        try {
            Process ps = Runtime.getRuntime().exec(cmd);
            strings = loadStream(ps.getInputStream());
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        return strings;
    }
    //创建执行Linux命令的类,只执行命令。
    public void execshellnoshow(String str) {
        String cmd = str;
        try {
            Process ps = Runtime.getRuntime().exec(cmd);
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
    }

    //打印结果
    public String loadStream(InputStream in) throws IOException {
        int ptr = 0;
        in = new BufferedInputStream(in);
        StringBuffer buffer = new StringBuffer();
        while ((ptr = in.read()) != -1) {
            buffer.append((char) ptr);
        }
        return buffer.toString();
    }
}

2.2编写语音聊天类

//ChattingWithRobot.java
package com.github7;
import com.baidu.aip.speech.AipSpeech;
import com.baidu.aip.speech.TtsResponse;
import com.baidu.aip.util.Util;
import org.json.JSONArray;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;

public class ChattingWithRobot {
    String APP_ID = "需要注册,自己获取"; //百度智能云API
    String API_KEY = "需要注册,自己获取";
    String SECRET_KEY = "需要注册,自己获取";
    String APIKEY = "需要注册,自己获取"; //图灵机器人API
    //聊天入口
    public  void chatting () throws InterruptedException, IOException {
        while (true) {
            ChattingWithRobot robot=new ChattingWithRobot();
            LinuxExectue exectue = new LinuxExectue();
            System.out.println("-----------------------------------------------------------");
            System.out.print("请讲话(你可以说 :查看内存/查看文件/关闭等)时间为5秒");
            exectue.execshellnoshow("arecord -t wav -c 1 -r 16000 -d 5 -f S16_LE /home/linrui7/tuling/input.wav  ");
            Thread.sleep(1000);
            System.out.print("4 ");
            Thread.sleep(1000);
            System.out.print("3 ");
            Thread.sleep(1000);
            System.out.print("2 ");
            Thread.sleep(1000);
            System.out.print("1 ");
            Thread.sleep(1000);
            System.out.print("0 ");
            System.out.println();
            //将刚才录音文件传入到百度云语言识别,获取语音识别后的JSON对象
            JSONObject jsonObject = robot.voicetostr();
            //判断刚才的录音文件是否有说话内容
            if (jsonObject.getLong("err_no") == 0) {
                //获取JSON对象中的第一个JSON数组对象,取出对象为“result”的值
                JSONArray jsonArray = jsonObject.getJSONArray("result");
                //String myword=jsonArray.getJSONObject(0).getString("result");
                String manstr = jsonArray.toString();
                String myword = manstr.substring(2, manstr.length() - 2);
                System.out.println("你说:" + myword);
                //判断我说的话是不是命令
                //保存如下命令
                HashMap<String, String> hashMap = new HashMap<String, String>();
                hashMap.put("文件", "ls  /home/linrui7/tuling/");
                hashMap.put("查看内存", "free");
                hashMap.put("查看硬盘", "df -h");
                hashMap.put("关闭防火墙", "systemctl stop firewalld");
                hashMap.put("打开防火墙", "systemctl start firewalld");
                hashMap.put("查看进程", "ps aux");
                if (myword.contains("退出")) {
                    System.exit(1);
                }
                boolean bo = false;
                for (String s : hashMap.keySet()) {
                    //如果我说的话中包含有Map中的词汇,则执行命令。
                    if (myword.contains(s)) {
                        String ex = hashMap.get(s);
                        exectue.execshell(ex);
                        bo = true;
                        break;
                    }
                }
                if (bo == false) {
                    //保存你说的话
                    String mansay = manstr.substring(2, manstr.length() - 2);
                    //连接机器人
                    StringBuffer stringBuffer = robot.robotstr(mansay);
                    //返回机器人的对话
                    String[] strings = stringBuffer.toString().split(":");
                    String robotstr = strings[2].replace("\"", "").replace("}", "");
                    System.out.println("说:" + robotstr );
                    //将机器人的文字转换成语音并播放
                    robotstrToWav(robotstr);
                    exectue.execshellnoshow("cvlc --play-and-exit /home/linrui7/tuling/output.wav ");
                    System.out.println("-----------------------------------------------------------\n\n");
                }
                System.out.println("4s后进行下一次对话");
                Thread.sleep(1000);
                System.out.print("3 ");
                Thread.sleep(1000);
                System.out.print("2 ");
                Thread.sleep(1000);
                System.out.print("1 ");
                Thread.sleep(1000);
                System.out.print("0 ");
            } else {
                System.out.println("并没有监测到你说话");
                String string = "并没有监测到你说话,请重新对话";
                robotstrToWav(string);
            }
        }
    }
    //识别本地语音文件,返回JSON对象
    public JSONObject voicetostr() {
        AipSpeech client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);
        JSONObject res = client.asr("/home/linrui7/tuling/input.wav", "wav", 16000, null);
        return res;
    }

    //连接图灵机器人,获取机器人的话
    public StringBuffer robotstr(String js) throws IOException {
        String question = js;
        String INFO = URLEncoder.encode(question, "utf-8");
        String getURL = "http://www.tuling123.com/openapi/api?key=" + APIKEY + "&info=" + INFO;
        URL getUrl = new URL(getURL);
        HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();
        connection.connect();
        // 取得输入流,并使用Reader读取
        BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"));
        StringBuffer stringBuffer = new StringBuffer();
        String line = "";
        while ((line = reader.readLine()) != null) {
            stringBuffer.append(line);
        }
        reader.close();
        // 断开连接
        connection.disconnect();
        return stringBuffer;
    }
    //将机器人返回的话转换成语音
    public void robotstrToWav(String str) {
        AipSpeech client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);
        HashMap<String, Object> options = new HashMap<String, Object>();
        options.put("spd", "5");
        options.put("pit", "5");
        options.put("per", "4");
        TtsResponse res = client.synthesis(str, "zh", 1, options);
        byte[] data = res.getData();
        JSONObject res1 = res.getResult();
        if (data != null) {
            try {
                Util.writeBytesToFileSystem(data, "/home/linrui7/tuling/output.wav");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (res1 != null) {
            System.out.println(res1.toString(2));
        }
    }
}

2.3编写手势识别部分

package com.github7;
import com.baidu.aip.bodyanalysis.AipBodyAnalysis;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.Scanner;

public class GestureRecognition {
    String APP_ID = "需要注册,自己获取";
    String API_KEY = "需要注册,自己获取";
    String SECRET_KEY = "需要注册,自己获取";
    AipBodyAnalysis client = new AipBodyAnalysis(APP_ID, API_KEY, SECRET_KEY);
    HashMap<String, String> options = new HashMap<String, String>();

    public void gesturemeth() {
        while (true) {
            System.out.println("---请选择---");
            System.out.println("输入1手势识别");
            System.out.println("输入0退出程序");
            Scanner scanner1 = new Scanner(System.in);
            String str=scanner1.next();
            if(str.equals("1")||str.equals("0")) {
                int in = Integer.parseInt(str);

                switch (in) {
                    case 1:
                        ges();
                        break;
                    case 0:
                        System.exit(1);
                        break;
                    default:
                        System.out.println("输入错误,重新选择");
                        gesturemeth();
                }
            }else {
                System.out.println("输入错误,重新选择");
                gesturemeth();
            }
        }
    }

    public void ges() {
        System.out.println("请输入照片名称 比如:aaa");
        System.out.print("当前默认识别路径为/home/linrui7/tuling/picture/,有以下图片,请选择\n");
        LinuxExectue linuxExectue = new LinuxExectue();
        linuxExectue.execshell("ls /home/linrui7/tuling/picture/");
        JSONObject jsonObject = photoResult();
        if (jsonObject.isNull("result")) {
            ges();
        } else {
            JSONArray jsonArray = jsonObject.getJSONArray("result");

            String classname = jsonArray.getJSONObject(0).get("classname").toString();
            String name = action(classname);
            if (name.contains("未能匹配")) {
                System.out.println("不能识别的手势哦");
                System.out.println("请作出以下动作:拳头、OK、祈祷、作揖、作别、单手比心、点赞、\n、Diss、我爱你、掌心向上、双手比心(3种)、数字(9种)、Rock、竖中指。");
            } else {
                System.out.println("图片中的手势是:" + name + "\n");
            }
        }
    }

    //返回图像识别结果
    public JSONObject photoResult() {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();
        String location = "/home/linrui7/tuling/picture/" + input + ".png";
        LinuxExectue linuxExectue = new LinuxExectue();
        String locationCheck = linuxExectue.execshelllocation("ls " + location);
        if (locationCheck.equals("") || locationCheck.isEmpty()) {
            System.out.println();
            System.out.println("对不起,图片不存在");
            ges();
        } else {
            JSONObject res = client.gesture(location, options);
            linuxExectue.execshellnoshow("eog " + location);
            return res;
        }
        return new JSONObject();
    }

    public String action(String classname) {
        String gestureName = "";
        if (classname.equals("Thumb_down")) {
            gestureName = "踩|拇指向下";
            return gestureName;
        } else if (classname.equals("Ok")) {
            gestureName = "OK";
            return gestureName;
        } else if (classname.equals("ILY")) {
            gestureName = "Rock";
            return gestureName;
        } else if (classname.equals("Heart_single")) {
            gestureName = "单手比心";
            return gestureName;
        } else if (classname.equals("Thumb_up")) {
            gestureName = "点赞|拇指向上";
            return gestureName;
        } else if (classname.equals("Prayer")) {
            gestureName = "祈祷";
            return gestureName;
        } else if (classname.equals("Fist")) {
            gestureName = "拳头";
            return gestureName;
        } else if (classname.equals("Point")) {
            gestureName = "点|食指";
            return gestureName;
        } else if (classname.equals("Heart_1") || classname.equals("Heart_2") || classname.equals("Heart_3")) {
            gestureName = "双手比心";
            return gestureName;
        } else if (classname.equals("Palm")) {
            gestureName = "掌心向前";
            return gestureName;
        } else if (classname.equals("Palm_up")) {
            gestureName = "掌心向上";
            return gestureName;
        } else if (classname.equals("Honour")) {
            gestureName = "作别|告别";
            return gestureName;
        } else if (classname.equals("Rock")) {
            gestureName = "摇滚";
            return gestureName;
        } else if (classname.equals("Congratulation")) {
            gestureName = "作揖|祝贺";
            return gestureName;
        } else {
            gestureName = "未能匹配的手势:" + classname;
            return gestureName;
        }
    }
}


2.4编写文字识别部分

package com.github7;
import com.baidu.aip.ocr.AipOcr;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.HashMap;
import java.util.Scanner;

public class CharacterRecognition {
    String APP_ID = "需要注册,自己获取";
    String API_KEY = "需要注册,自己获取";
    String SECRET_KEY = "需要注册,自己获取";
    HashMap<String, String> options = new HashMap<String, String>();
    AipOcr client = new AipOcr(APP_ID, API_KEY, SECRET_KEY);

    public void ocr() {
        while (true) {
            System.out.println("---请选择---");
            System.out.println("输入1文字识别");
            System.out.println("输入0退出程序");
            Scanner scanner1 = new Scanner(System.in);
            String str=scanner1.next();
            if(str.equals("1")||str.equals("0")) {
                int in = Integer.parseInt(str);
                switch (in) {
                    case 1:
                        character();
                        break;
                    case 0:
                        System.exit(1);
                        break;
                    default:
                        System.out.println("输入错误,重新选择");
                        ocr();
                }
            }else {
                System.out.println("输入错误,重新选择");
                ocr();
            }
        }
    }

    //运行方法
    public void character() {
        System.out.println("请输入照片名称 比如:aaa");
        System.out.print("当前默认识别路径为/home/linrui7/tuling/picture/,有以下图片,请选择\n");
        LinuxExectue linuxExectue = new LinuxExectue();
        linuxExectue.execshell("ls /home/linrui7/tuling/picture/");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();
        JSONObject jsonObject = getJson(input);
        //判断如果是空路径的情况下,有没有结果
        if (jsonObject.isNull("result")) {
            character();
        } else {
            JSONArray jsonArray = jsonObject.getJSONArray("words_result");
            for (int i = 0; i < jsonObject.getInt("words_result_num"); i++) {
                System.out.println(jsonArray.getJSONObject(i).getString("words").toString());
            }
            System.out.println("");
        }
    }

    //获取图片的JSon串
    public JSONObject getJson(String str) {
        options.put("recognize_granularity", "big");//big - 不定位单字符位置,small - 定位单字符位置
        options.put("language_type", "CHN_ENG");//语言类型
        options.put("detect_direction", "true");//检测图片朝向
        options.put("detect_language", "true");//检测图片语言
        options.put("vertexes_location", "true");//外接多边形顶点位置默认false
        options.put("probability", "false");//是否返回识别结果中每一行的置信度
        LinuxExectue linuxExectue=new LinuxExectue();
        String location = "/home/linrui7/tuling/picture/" + str + ".png";
        String locationCheck=linuxExectue.execshelllocation("ls "+location);
        if(locationCheck.equals("")||locationCheck.isEmpty()){
            System.out.println();
            System.out.println("对不起,图片不存在");
            character();
        }else {
            linuxExectue.execshellnoshow("eog " + location);
            JSONObject res = client.basicGeneral(location, options);
            //System.out.println(res.toString(2));
            return res;
        }
        return new JSONObject();
    }
}


2.5编写程序入口

package com.github7;
import com.baidu.aip.speech.AipSpeech;
import com.baidu.aip.speech.TtsResponse;
import com.baidu.aip.util.Util;
import org.json.JSONArray;
import org.json.JSONObject;
import java.io.IOException;
import java.util.HashMap;

public class Starting {
    String APP_ID = "需要注册,自己获取";
    String API_KEY = "需要注册,自己获取";
    String SECRET_KEY = "需要注册,自己获取";
    String APIKEY = "需要注册,自己获取";
    public static void main(String[] args) throws InterruptedException, IOException {
        System.setProperty("aip.log4j.conf", "/home/linrui7/tuling/tulingdemo/src/main/resources/log4j.properties");
        Starting selectFunction = new Starting();
        LinuxExectue exectue = new LinuxExectue();
        String str = "请选择要执行的功能 比如说:聊天系统";
        selectFunction.robotstrToWav(str);
        exectue.execshellnoshow("cvlc --play-and-exit /home/linrui7/tuling/changeoutput.wav ");
        Thread.sleep(10000);
        System.out.println(str);
        System.out.println("----->功能一:聊天系统");
        System.out.println("----->功能二:文字识别");
        System.out.println("----->功能三:手势识别\n");
        while (true) {
            //录音
            System.out.println("。。。。。Please Speaking。。。。。");
            exectue.execshellnoshow("arecord -t wav -c 1 -r 16000 -d 5 -f S16_LE /home/linrui7/tuling/change.wav  ");
            Thread.sleep(1000);
            System.out.print("4 ");
            Thread.sleep(1000);
            System.out.print("3 ");
            Thread.sleep(1000);
            System.out.print("2 ");
            Thread.sleep(1000);
            System.out.print("1 ");
            Thread.sleep(1000);
            System.out.print("0 ");
            //语音识别
            JSONObject jsonObject = selectFunction.voicetostr();
            if (jsonObject.getLong("err_no") == 0) {
                //获取JSON对象中的第一个JSON数组对象,取出值
                JSONArray jsonArray = jsonObject.getJSONArray("result");
                String manstr = jsonArray.toString();
                String myword = manstr.substring(2, manstr.length() - 2);
                if (myword.contains("聊天系统") || myword.contains("功能一")) {
                    System.out.println("你选择的是:聊天系统");
                    ChattingWithRobot chattingWithRobot = new ChattingWithRobot();
                    chattingWithRobot.chatting();
                } else if (myword.contains("文字识别") || myword.contains("功能二")) {
                    System.out.println("你选择的是:文字识别");
                    CharacterRecognition characterRecognition = new CharacterRecognition();
                    characterRecognition.ocr();
                } else if (myword.contains("手势识别") || myword.contains("功能三")) {
                    System.out.println("你选择的是:手势识别");
                    GestureRecognition gestureRecognition = new GestureRecognition();
                    gestureRecognition.gesturemeth();
                } else if (myword.contains("退出") || myword.contains("不想玩了")) {
                    System.exit(1);
                } else {
                    String string = "你的选择错误,请重新选择以下选项";
                    System.out.println(string);
                    System.out.println("----->功能一:聊天系统");
                    System.out.println("----->功能二:文字识别");
                    System.out.println("----->功能三:手势识别\n");
                    selectFunction.robotstrToWav(string);
                    exectue.execshellnoshow("cvlc --play-and-exit /home/linrui7/tuling/changeoutput.wav ");
                    Thread.sleep(4000);
                }
            } else {
                System.out.println("机器人说:你并没有说话哦\n");
                String string = "你并没有讲话哦";
                selectFunction.robotstrToWav(string);
                exectue.execshellnoshow("cvlc --play-and-exit /home/linrui7/tuling/changeoutput.wav ");
                Thread.sleep(2000);
            }
        }
    }

    //语音转文字
    public JSONObject voicetostr() {
        AipSpeech client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);
        JSONObject res = client.asr("/home/linrui7/tuling/change.wav", "wav", 16000, null);
        return res;
    }

    //文字转语音
    public void robotstrToWav(String str) {
        AipSpeech client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);
        HashMap<String, Object> options = new HashMap<String, Object>();
        /*
        spd	选填	语速,取值0-15,默认为5中语速
        pit	选填	音调,取值0-15,默认为5中语调
        vol	选填	音量,取值0-15,默认为5中音量
        per(基础音库)	选填	度小宇=1,度小美=0,度逍遥=3,度丫丫=4
         */
        options.put("spd", "5");
        options.put("pit", "5");
        options.put("per", "4");
        TtsResponse res = client.synthesis(str, "zh", 1, options);
        byte[] data = res.getData();
        JSONObject res1 = res.getResult();
        if (data != null) {
            try {
                Util.writeBytesToFileSystem(data, "/home/linrui7/tuling/changeoutput.wav");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (res1 != null) {
            System.out.println(res1.toString(2));
        }
    }
}


2.6将产生的日志信息输出到指定文件中,配置log4j.properties

 System.setProperty("aip.log4j.conf", "/home/linrui7/tuling/tulingdemo/src/main/resources/log4j.properties");
#设置日志的级别,定义日志信息的输出目的
log4j.rootLogger=INFO,R
#定义A1的输出目的地为控制台
#log4j.appender.A1=org.apache.log4j.ConsoleAppender
#布局为 PatternLayout 可以灵活地指定布局模式。
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
#设置输出格式
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH\:mm\:ss} [%c]-[%p] %m%n
#定义R的输出目的地为文件,并且文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.R=org.apache.log4j.RollingFileAppender
#设置输出的文件地址
log4j.appender.R.File=/home/linrui7/tuling/log4j/Log4j.log
#设置文件大小伟100 kb 文件到达100时,产生一个新文件,
#MaxBackupIndex 最大记录的文件数为1 查过一个文件删除文件较早的。
log4j.appender.R.MaxFileSize=1048576KB log4j.appender.R.MaxBackupIndex=1
#以下和上面一样
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.github7</groupId>
    <artifactId>tulingdemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <useUniqueVersions>false</useUniqueVersions>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.github7.Starting</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>
    <dependency>
        <groupId>com.baidu.aip</groupId>
        <artifactId>java-sdk</artifactId>
        <version>4.8.0</version>
    </dependency>
    <dependency>
        <groupId>org.kohsuke.stapler</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.1-rev6</version>
    </dependency>

</dependencies>
</project>

代码界面 目录结构
在这里插入图片描述
项目界面:
聊天界面
在这里插入图片描述

文字识别
在这里插入图片描述

手势识别
在这里插入图片描述
测试
1.每个模块编写完成,分别对语音聊天,命令执行,程序入口进行了单元测试。
2.整体代码编写完成,进行冒烟测试,验证语音聊天功能,语音发送命令返回结果的功能可正常使用。
3.进行系统测试,首先编写测试用例运用边界值法测试录音时间,运用等价类法测试指令执行情况,以及 通过改变网络带宽进行性能测试,获取在不同网速下响应时间,在 Centos云服务器以及另外两种版本的 Centos环境下进行兼容性测试,并在执行过程中记录所有的缺陷。
4.测试用例中退出功能的实现没有通过,通过更改部分代码解决问题后,对所有功能进行了回归测试。最后,所有测试用例通过。

  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值