一、创建web项目

1、打开idea软件，点击界面上的Create New Project
image.png
2、进入如下界面。选中 java Enterprise，配置jdk，tomcat，勾选Web Application案例，注意勾选生成web.xml文件
image.png
image.png
image.png
image.png
3、指定项目的名称及项目文件的保存地址
image.png
4、创建成功
image.png
5、创建class文件和lib文件夹 点击项目的WEF-INF文件夹 ,右键，New → Directory 创建两个文件夹，classes(用来存放编译后输出的class文件) 和 lib(用于存放第三方jar包)
image.png
6、配置classes文件夹路径    File → 选择 Project Structure → 选择 Module → 选择Paths →
选择 “Use module compile output path” ->
将Output path和Test output path都选择刚刚创建的classes文件夹。
image.png
智能客服自动回复 - 图10
7、配置lib文件夹路径   点击Paths旁边的Dependencies 点击右边的”+”号 → 选择”Jars or Directories” -> 将Output path和Test output path都选择刚刚创建的classes文件夹 → 选择”Jar Directory” 然后一路OK就行了.
image.png
选择刚刚创建的lib文件夹
image.png
image.png

二、tomcat项目部署

1.配置tomcat 点击Run ，选择Edit Configurations.
image.png
智能客服自动回复 - 图15
点击右上角的三角形,运行
智能客服自动回复 - 图16
智能客服自动回复 - 图17

三、创建servlet

src–>New–>Create New Servlet
智能客服自动回复 - 图18
智能客服自动回复 - 图19
servlet中简单代码

  1. /**
  2.  * 通过urlPatterns指定映射地址或者在web.xml文件中配置
  3.  */
  4. @WebServlet(name = "helloServlet",urlPatterns = {"/hello"})
  5. public class HelloServlet extends HttpServlet {
  6.     protected void doPost(HttpServletRequest request, HttpServletResponse response) 
  7.       throws ServletException, IOException {
  9.     }
  10.  protected void doGet(HttpServletRequest request, HttpServletResponse response)
  11.       throws ServletException, IOException {
  12.         System.out.println("hello serlvet");
  13.         request.getRequestDispatcher("/index.jsp").forward(request,response);
  14.     }
  15. }

3.测试 运行tomcat访问测试:http://localhost:8080/hello
智能客服自动回复 - 图20
智能客服自动回复 - 图21

四、页面图片准备

1.同一放在web文件夹下 格式如下
image.png
2.lib的导入
image.png
3.代码实现

  1. public class Robot {
  2.     private String url;
  3.     private String apiKey;
  4.     private String userId;
  7.     public Robot() {
  8.     }
  10.     public Robot(String url, String apiKey) {
  11.         this.url = url;
  12.         this.apiKey = apiKey;
  13.     }
  15.     public String getUrl() {
  16.         return url;
  17.     }
  19.     public void setUrl(String url) {
  20.         this.url = url;
  21.     }
  23.     public String getApiKey() {
  24.         return apiKey;
  25.     }
  27.     public void setApiKey(String apiKey) {
  28.         this.apiKey = apiKey;
  29.     }
  31.     public String getUserId() {
  32.         return userId;
  33.     }
  35.     public void setUserId(String userId) {
  36.         this.userId = userId;
  37.     }
  39.     //处理请求信息
  40.     private String before(String msg) {
  41.         //请求参数格式为 json
  42.         /**
  43.          * reqType;   输入类型:0-文本(默认)、1-图片、2-音频
  44.          * perception 输入信息
  45.          * userInfo  用户参数
  46.          * inputText 文本信息
  47.          * selfInfo  客户端属性
  48.          * location  地理位置信息
  49.          * city      所在城市
  50.          * province  省份
  51.          * street    街道
  52.          * apiKey   机器人标识
  53.          * userId   用户唯一标识
  54.          *
  55.          * */
  56.         return "{'reqType':0,'" +
  57.                 "perception':{'inputText':{'text':" + msg + "}," +
  58.                 "'selfInfo':{'location':{'city':\"北京\",'province':\"北京\",'street':\"信息路\"}}}," +
  59.                 "'userInfo':{'apiKey':" + this.getApiKey() + ",'userId':'" + this.getUserId() + "'}}";
  60.     }
  62.     //聊天
  63.     public String Chat(String msg)   {
  64.         //JSON字符串转JSONObject对象
  65.         JSONObject jsonObject = JSONUtil.parseObj(before(msg));
  66.         //Http请求类用于构建Http请求并同步获取结果，此类通过CookieManager持有域名对应的Cookie值，再次请求时会自动附带Cookie信息
  67.         //Rest模式，此时body需要传入一个JSON或者XML字符串，Hutool会自动绑定其对应的Content-Type
  68.         //传入路径与我们传入的JSONObject对象，获取请求响应的结果
  69.         String result2 = HttpRequest.post(this.getUrl()).body(jsonObject.toString()).timeout(20000).execute().body();
  70.         //JSON字符串转JSONObject对象 然后得到结果 转化成string
  71.         return JSONUtil.parseObj(result2).get("results").toString(); //获取返回的结果信息
  72.     }
  73. }
  1. @WebServlet(name = "sentServlet", urlPatterns = "/sent/chat")
  2. public class SentMassage extends HttpServlet {
  3.     public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  4.         doGet(request, response);
  5.     }
  6.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
  7.         response.setCharacterEncoding("utf-8");
  8.         response.setCharacterEncoding("utf-8");
  9.         response.setContentType("application/json;charset=utf-8");
  10.         String inputText = request.getParameter("inputText");
  11.         System.out.println(inputText);
  12.         Robot robot = new Robot();
  13.         robot.setUrl(Changeless.URL);
  14.         robot.setApiKey(Changeless.API_ID_2);
  15.         robot.setUserId(Changeless.USER_ID);
  16.         JSONArray objects = JSONUtil.parseArray(robot.Chat(inputText));
  17.         ArrayList<JSONObject> jsonObjectArrayLists = new ArrayList<>();
  18.         for (Object jsonObject : objects) {
  19.             jsonObjectArrayLists.add((JSONObject) JSONUtil.parseObj(jsonObject).get("values"));
  20.         }
  21.         System.out.println(jsonObjectArrayLists);
  22.         /*将list集合转成json*/
  23.         String result = JSONUtil.parseArray(JSON.toJSONString(jsonObjectArrayLists)).toString();
  24.         /*返回数据*/
  25.         response.getWriter().write(result);
  26.     }
  27. }

五、Java基础代码实现

  1. public class TestRobot {
  2.     public static void main(String[] args) throws Exception {
  3.         Scanner sc = new Scanner(System.in);
  4.         while (true) {
  5.             String our = sc.nextLine();
  6.             String result = getChat(our);
  7.             System.out.println("机器人：" + result);
  8.         }
  9.     }
  11.     public static String getChat(String result) throws Exception {
  12.         // 请求URL
  13.         //afccb0beff0d4d12a45f3d25ced655db
  14.         //597b34bea4ec4c85a775c469c84b6817
  15.         String url = "http://openapi.tuling123.com/openapi/api/v2";
  16.         // 图灵机器人API接口 每天只能5000次调用，建议自己去申请一个，免费的:)
  17.         String apiKey = "597b34bea4ec4c85a775c469c84b6817";
  18.         // 请求参数
  19.         Map<String, Object> paramMap = new HashMap<>();
  20.         paramMap.put("reqType", "0"); // 输入类型:0-文本(默认)、1-图片、2-音频
  21.         // 输入信息
  22.         Map<String, Object> perception = new HashMap<>();
  23.         Map<String, String> inputText = new HashMap<>();
  24.         inputText.put("text", result);
  25.         Map<String, Object> selfInfo = new HashMap<>();
  26.         Map<String, String> location = new HashMap<>();
  27.         location.put("city", "北京");
  28.         location.put("province", "北京");
  29.         location.put("street", "建材城西路");
  30.         selfInfo.put("location", location);
  31.         perception.put("inputText", inputText);
  32.         perception.put("selfInfo", selfInfo);
  33.         // 用户信息
  34.         Map<String, String> userInfo = new HashMap<>();
  35.         userInfo.put("apiKey", apiKey);
  36.         userInfo.put("userId", "123456");
  37.         paramMap.put("perception", perception);
  38.         paramMap.put("userInfo", userInfo);
  39.         // 把map参数，转成json
  40.         String jsonData = JSONUtil.toJSON(paramMap);
  41.         // System.out.println("jsonData:" + jsonData);
  42.         String r2 = HttpUtil.post(url,null,jsonData);
  43.         return getResult(r2, "results");
  44.     }
  45.     // {"intent":{"actionName":"","code":10020,"intentName":""},"results":[{"groupType":1,"resultType":"text","values":{"text":"你好"}}]}
  46.     private static String getResult(String json, String key) {
  47.         List<String> list = JSONUtil.getList(json, key, String.class);
  48.         String result = list.get(0);
  49.         String values = JSONUtil.getString(result, "values");
  50.         String text = JSONUtil.getString(values, "text");
  51.         return text;
  52.     }
  53. }

五、客户端与服务器

15.6.4 示例一：单个客户端与服务器单次通信

需求：客户端连接服务器，连接成功后给服务发送“lalala”，服务器收到消息后，给客户端返回“欢迎登录”，客户端接收消息后，断开连接

客户端示例代码

  1. import java.io.InputStream;
  2. import java.io.OutputStream;
  3. import java.net.Socket;
  5. public class Client {
  7.     public static void main(String[] args) throws Exception {
  8.         // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
  9.         Socket socket = new Socket("127.0.0.1", 8888);
  11.         // 2、获取输出流，用来发送数据给服务器
  12.         OutputStream out = socket.getOutputStream();
  13.         // 发送数据
  14.         out.write("lalala".getBytes());
  15.         //会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
  16.         socket.shutdownOutput();
  18.         //3、获取输入流，用来接收服务器发送给该客户端的数据
  19.         InputStream input = socket.getInputStream();
  20.         // 接收数据
  21.         byte[] data = new byte[1024];
  22.         StringBuilder s = new StringBuilder();
  23.         int len;
  24.         while ((len = input.read(data)) != -1) {
  25.             s.append(new String(data, 0, len));
  26.         }
  27.         System.out.println("服务器返回的消息是：" + s);
  29.         //4、关闭socket，不再与服务器通信，即断开与服务器的连接
  30.         //socket关闭，意味着InputStream和OutputStream也关闭了
  31.         socket.close();
  32.     }
  33. }

服务器端示例代码

  1. import java.io.InputStream;
  2. import java.io.OutputStream;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  6. public class Server {
  8.     public static void main(String[] args)throws Exception {
  9.         //1、准备一个ServerSocket对象，并绑定8888端口
  10.         ServerSocket server =  new ServerSocket(8888);
  11.         System.out.println("等待连接....");
  13.     //2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
  14.         Socket socket = server.accept();
  15.         System.out.println("一个客户端连接成功！！");
  17.         //3、获取输入流，用来接收该客户端发送给服务器的数据
  18.         InputStream input = socket.getInputStream();
  19.         //接收数据
  20.         byte[] data = new byte[1024];
  21.         StringBuilder s = new StringBuilder();
  22.         int len;
  23.         while ((len = input.read(data)) != -1) {
  24.             s.append(new String(data, 0, len));
  25.         }
  26.         System.out.println("客户端发送的消息是：" + s);
  28.         //4、获取输出流，用来发送数据给该客户端
  29.         OutputStream out = socket.getOutputStream();
  30.         //发送数据
  31.         out.write("欢迎登录".getBytes());
  32.         out.flush();
  34.         //5、关闭socket，不再与该客户端通信
  35.         //socket关闭，意味着InputStream和OutputStream也关闭了
  36.         socket.close();
  38.         //6、如果不再接收任何客户端通信，可以关闭ServerSocket
  39.         server.close();
  40.     }
  41. }

15.6.5 示例二：多个客户端与服务器之间的多次通信

通常情况下，服务器不应该只接受一个客户端请求，而应该不断地接受来自客户端的所有请求，所以Java程序通常会通过循环，不断地调用ServerSocket的accept()方法。

如果服务器端要“同时”处理多个客户端的请求，因此服务器端需要为每一个客户端单独分配一个线程来处理，否则无法实现“同时”。

咱们之前学习IO流的时候，提到过装饰者设计模式，该设计使得不管底层IO流是怎样的节点流：文件流也好，网络Socket产生的流也好，程序都可以将其包装成处理流，甚至可以多层包装，从而提供更多方便的处理。

案例需求：多个客户端连接服务器，并进行多次通信

  • 每一个客户端连接成功后，从键盘输入英文单词或中国成语，并发送给服务器
  • 服务器收到客户端的消息后，把词语“反转”后返回给客户端
  • 客户端接收服务器返回的“词语”，打印显示
  • 当客户端输入“stop”时断开与服务器的连接
  • 多个客户端可以同时给服务器发送“词语”，服务器可以“同时”处理多个客户端的请求

客户端示例代码

  1. import java.io.BufferedReader;
  2. import java.io.InputStream;
  3. import java.io.InputStreamReader;
  4. import java.io.OutputStream;
  5. import java.io.PrintStream;
  6. import java.net.Socket;
  7. import java.util.Scanner;
  9. public class Client2 {
  10.     public static void main(String[] args) throws Exception {
  11.         // 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
  12.         Socket socket = new Socket("127.0.0.1", 8888);
  14.         // 2、获取输出流，用来发送数据给服务器
  15.         OutputStream out = socket.getOutputStream();
  16.         PrintStream ps = new PrintStream(out);
  18.         // 3、获取输入流，用来接收服务器发送给该客户端的数据
  19.         InputStream input = socket.getInputStream();
  20.         BufferedReader br = new BufferedReader(new InputStreamReader(input));
  22.         Scanner scanner = new Scanner(System.in);
  23.         while(true){
  24.             System.out.println("输入发送给服务器的单词或成语：");
  25.             String message = scanner.nextLine();
  26.             if(message.equals("stop")){
  27.                 socket.shutdownOutput();
  28.                 break;
  29.             }
  31.             // 4、 发送数据
  32.             ps.println(message);
  33.             // 接收数据
  34.             String feedback  = br.readLine();
  35.             System.out.println("从服务器收到的反馈是：" + feedback);
  36.         }
  38.         //5、关闭socket，断开与服务器的连接
  39.         scanner.close();
  40.         socket.close();
  41.     }
  42. }

服务器端示例代码

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.io.PrintStream;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  8. public class Server2 {
  9.     public static void main(String[] args) throws IOException {
  10.         // 1、准备一个ServerSocket
  11.         ServerSocket server = new ServerSocket(8888);
  12.         System.out.println("等待连接...");
  14.         int count = 0;
  15.         while(true){
  16.             // 2、监听一个客户端的连接
  17.             Socket socket = server.accept();
  18.             System.out.println("第" + ++count + "个客户端"+socket.getInetAddress().getHostAddress()+"连接成功！！");
  20.             ClientHandlerThread ct = new ClientHandlerThread(socket);
  21.             ct.start();
  22.         }
  24.         //这里没有关闭server，永远监听
  25.     }
  26.     static class ClientHandlerThread extends Thread{
  27.         private Socket socket;
  29.         public ClientHandlerThread(Socket socket) {
  30.             super();
  31.             this.socket = socket;
  32.         }
  34.         public void run(){
  36.             try{
  37.                 //（1）获取输入流，用来接收该客户端发送给服务器的数据
  38.                 BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  39.                 //（2）获取输出流，用来发送数据给该客户端
  40.                 PrintStream ps = new PrintStream(socket.getOutputStream());
  41.                 String str;
  42.                 // （3）接收数据
  43.                 while ((str = br.readLine()) != null) {
  44.                     //（4）反转
  45.                     StringBuilder word = new StringBuilder(str);
  46.                     word.reverse();
  48.                     //（5）返回给客户端
  49.                     ps.println(word);
  50.                 }
  51.                 System.out.println(socket.getInetAddress().getHostAddress()+"正常退出");
  52.             }catch(Exception  e){
  53.                 System.out.println(socket.getInetAddress().getHostAddress()+"意外退出");
  54.             }finally{
  55.                 try {
  56.                     //（6）断开连接
  57.                     socket.close();
  58.                 } catch (IOException e) {
  59.                     e.printStackTrace();
  60.                 }
  61.             }
  62.         }
  63.     }
  64. }