网络编程系列教材（二）- Java Socket 收发消息入门例子

网络编程系列教材（一）- IP地址与端口概念

网络编程系列教材（三）- 使用 Java Socket 开发多线程聊天程序

工具版本兼容问题

使用 Socket(套接字)进行不同的程序之间的通信

纠

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

10分39秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

步骤 1 : 建立连接
步骤 2 : 收发数字
步骤 3 : 收发字符串
步骤 4 : 使用Scanner
步骤 5 : 练习-服务端和客户端互聊
步骤 6 : 答案-服务端和客户端互聊
步骤 7 : 练习-聊天机器人数据库
步骤 8 : 答案-聊天机器人数据库

步骤 1 :

建立连接

edit 顶折

纠问

1. 服务端开启8888端口，并监听着，时刻等待着客户端的连接请求
2. 客户端知道服务端的ip地址和监听端口号，发出请求到服务端
客户端的端口地址是系统分配的，通常都会大于1024
一旦建立了连接，服务端会得到一个新的Socket对象，该对象负责与客户端进行通信。
注意：在开发调试的过程中，如果修改过了服务器Server代码，要关闭启动的Server,否则新的Server不能启动，因为8888端口被占用了

Server.java
Client.java

代码行数较多，请点击查看

package socket;
 
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
  
public class Server {
  
    public static void main(String[] args)  {
        try {
			//服务端打开端口8888
			ServerSocket ss = new ServerSocket(8888);
			  
			//在8888端口上监听，看是否有连接请求过来
			System.out.println("监听在端口号:8888");
			Socket s =  ss.accept();
			  
			System.out.println("有连接过来" + s);
			
			s.close();
			ss.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
          
    }
}

代码行数较多，请点击查看

package socket;
 
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
  
public class Client {
  
    public static void main(String[] args)  {
          
        try {
			//连接到本机的8888端口
			Socket s = new Socket("127.0.0.1",8888);
			System.out.println(s);
			s.close();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}

步骤 2 :

收发数字

edit 顶折

纠问

一旦建立了连接，服务端和客户端就可以通过Socket进行通信了
1. 客户端打开输出流，并发送数字 110
2. 服务端打开输入流，接受数字 110，并打印

Server.java
Client.java

代码行数较多，请点击查看

package socket;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) {
		try {

			ServerSocket ss = new ServerSocket(8888);

			System.out.println("监听在端口号:8888");
			Socket s = ss.accept();

			//打开输入流
			InputStream is = s.getInputStream();

			//读取客户端发送的数据
			int msg = is.read();
			//打印出来
			System.out.println(msg);
			is.close();

			s.close();
			ss.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

代码行数较多，请点击查看

package socket;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

	public static void main(String[] args) {

		try {
			Socket s = new Socket("127.0.0.1", 8888);

			// 打开输出流
			OutputStream os = s.getOutputStream();

			// 发送数字110到服务端
			os.write(110);
			os.close();

			s.close();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

步骤 3 :

收发字符串

edit 顶折

纠问

直接使用字节流收发字符串比较麻烦，使用数据流对字节流进行封装，这样收发字符串就容易了
1. 把输出流封装在DataOutputStream中
使用writeUTF发送字符串 "Legendary!"
2. 把输入流封装在DataInputStream
使用readUTF读取字符串,并打印

Server.java
Client.java

代码行数较多，请点击查看

package socket;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	public static void main(String[] args) {
		try {

			ServerSocket ss = new ServerSocket(8888);

			System.out.println("监听在端口号:8888");
			Socket s = ss.accept();

			InputStream is = s.getInputStream();

			//把输入流封装在DataInputStream
			DataInputStream dis = new DataInputStream(is);
			//使用readUTF读取字符串
			String msg = dis.readUTF();
			System.out.println(msg);
			dis.close();
			s.close();
			ss.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

代码行数较多，请点击查看

package socket;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client {

	public static void main(String[] args) {

		try {
			Socket s = new Socket("127.0.0.1", 8888);

			OutputStream os = s.getOutputStream();

			//把输出流封装在DataOutputStream中
			DataOutputStream dos = new DataOutputStream(os);
			//使用writeUTF发送字符串
			dos.writeUTF("Legendary!");
			dos.close();
			s.close();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

步骤 4 :

使用Scanner

edit 顶折

纠问

在上个步骤中，每次要发不同的数据都需要修改代码
可以使用Scanner读取控制台的输入，并发送到服务端，这样每次都可以发送不同的数据了。

代码行数较多，请点击查看

package socket;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client {

	public static void main(String[] args) {

		try {
			Socket s = new Socket("127.0.0.1", 8888);

			OutputStream os = s.getOutputStream();
	        DataOutputStream dos = new DataOutputStream(os);
	        
	        //使用Scanner读取控制台的输入，并发送到服务端
	        Scanner sc = new Scanner(System.in);
	        
	        String str = sc.next();
	        dos.writeUTF(str);
	        
			dos.close();
			s.close();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

步骤 5 :

练习-服务端和客户端互聊

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

前面部分的学习效果是服务端接受数据，客户端发送数据。

做相应的改动，使得服务端也能发送数据，客户端也能接受数据，并且可以一直持续下去

步骤 6 :

答案-服务端和客户端互聊

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费3个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

3分53秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

Server.java
Client.java

代码行数较多，请点击查看

package socket;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class Server {

	public static void main(String[] args) {
		try {

			ServerSocket ss = new ServerSocket(8888);

			System.out.println("监听在端口号:8888");
			Socket s = ss.accept();

			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);

			while (true) {
				String msg = dis.readUTF();
				System.out.println("收到客户端信息"+msg);
				Scanner sc = new Scanner(System.in);
				String str = sc.next();
				dos.writeUTF(str);
			}

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

代码行数较多，请点击查看

package socket;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
 
public class Client {
 
    public static void main(String[] args) {
 
        try {
            Socket s = new Socket("127.0.0.1", 8888);
 
            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);
            InputStream is = s.getInputStream();
            DataInputStream dis = new DataInputStream(is);
             
            while(true){
	            Scanner sc = new Scanner(System.in);
	            String str = sc.next();
	            dos.writeUTF(str);
	            String msg = dis.readUTF();
	            System.out.println("收到服务端信息"+msg);
            }
             
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

步骤 7 :

练习-聊天机器人数据库

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

首先创建一个数据库android(android现在是手机操作系统，其本意是机器人的意思)

然后创建一个表dictionary，字段：
id int
receive varchar(100)
response varchar(100)

receive 表示受到的信息
response 表示回应的信息

在这个表里准备一些数据：
你好 -> 好你妹！
你叫什么 -> 你想泡我啊？
打你哦 -> 来啊，来打我啊，不打有点挫
等等
等等

开发一个程序，当从scanner读取到消息，发给Server服务端，服务端用这个消息到表dictionary中找到对应的相应，返回出去。看上去就像在自动回应一样。
如果一个recieve有多条response，则随机返回一条

步骤 8 :

答案-聊天机器人数据库

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

6分25秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

create database android;

use android;

create table dictionary(
   id int AUTO_INCREMENT,
   receive varchar(100),
   response varchar(100),
   PRIMARY KEY (id)
)  DEFAULT CHARSET=utf8;

insert into dictionary values(null,'你好','好你妹！');
insert into dictionary values(null,'你叫什么','你想泡我啊？');
insert into dictionary values(null,'你叫什么','同志，不约');
insert into dictionary values(null,'打你哦','来啊，来打我啊，不打有点挫');

代码行数较多，请点击查看

package socket;

public class Dictionary {
	int id;
	String receive ;
	String response;
}

代码行数较多，请点击查看


package socket;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import charactor.Hero;

public class DictionaryDAO {

public DictionaryDAO() {
	try {
		Class.forName("com.mysql.jdbc.Driver");
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
}

	public Connection getConnection() throws SQLException {
		return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/android?characterEncoding=UTF-8", "root",
				"admin");
	}

	public List<Dictionary> query(String recieve) {
		List<Dictionary> ds = new ArrayList<Dictionary>();

		String sql = "select * from dictionary where receive = ? ";

		try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
			ps.setString(1, recieve);
			ResultSet rs = ps.executeQuery();
			while (rs.next()) {
				Dictionary d = new Dictionary();
				int id = rs.getInt(1);
				String receive = rs.getString("receive");
				String response = rs.getString("response");
				d.id=id;
				d.receive=receive;
				d.response=response;
				ds.add(d);
			}
		} catch (SQLException e) {

			e.printStackTrace();
		}
		return ds;
	}

}

代码行数较多，请点击查看


package socket;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Server {

	private static List<String> cannotUnderstand= new ArrayList<>();
	static{
		cannotUnderstand.add("听求不懂啊");
		cannotUnderstand.add("说人话");
		cannotUnderstand.add("再说一遍？");
		cannotUnderstand.add("大声点");
		cannotUnderstand.add("老子在忙，一边玩儿去");
	}
	public static void main(String[] args) {
		try {

			ServerSocket ss = new ServerSocket(8888);

			System.out.println("监听在端口号:8888");
			Socket s = ss.accept();

			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);

			while (true) {
				String msg = dis.readUTF();
				System.out.println(msg);
				
				List<Dictionary> ds= new DictionaryDAO().query(msg);
				String response = null;
				if(ds.isEmpty()){
					Collections.shuffle(cannotUnderstand);
					response = cannotUnderstand.get(0);
				}
				else{
					Collections.shuffle(ds);
					response = ds.get(0).response;
				}
				dos.writeUTF(response);
			}

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

代码行数较多，请点击查看

package socket;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
 
public class Client {
 
    public static void main(String[] args) {
 
        try {
            Socket s = new Socket("127.0.0.1", 8888);
 
            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);
            InputStream is = s.getInputStream();
            DataInputStream dis = new DataInputStream(is);
             
            while(true){
	            Scanner sc = new Scanner(System.in);
	            String str = sc.nextLine();
	            dos.writeUTF(str);
	            String msg = dis.readUTF();
	            System.out.println(msg);
	            System.out.println();

            }
             
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

网络编程系列教材（一）- IP地址与端口概念

网络编程系列教材（三）- 使用 Java Socket 开发多线程聊天程序

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-17 结合网络和 Mysql 实现简易聊天机器人

虚心求学

关于 JAVA 中级-网络编程-Socket 的提问

发送消息：用户端：你好服务端: 你好，很高兴认识你用户端：你是谁服务端: 我是机器人用户端： hello 服务端: Hello!nice to meet you 用户端：

----------------------客户端-----------------------------
package testNet;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class Client {
	public static void main(String[] args) {
		try {
			Socket s = new Socket("127.0.0.1",8888);
			System.out.println(s);
			System.out.println("发送消息：");
			Scanner scanner = new Scanner(System.in);
			String msg = "";
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);
			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			while(!msg.equals("end"))
			{
				System.out.println("用户端：");
				msg = scanner.nextLine();
				dos.writeUTF(msg);
				System.out.println("\t\t服务端:");
				String str = dis.readUTF();
				System.out.println("\t\t "+str);
			}
			scanner.close();
			is.close();
			dis.close();
			os.close();
			dos.close();
			s.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

--------------------服务端----------------------

package testNet;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

import com.mysql.cj.protocol.Resultset;

public class Server {
	public static void main(String[] args) {
		try {
			Scanner scanner = new Scanner(System.in);
			ServerSocket ss = new ServerSocket(8888);
			System.out.println("开始监听，端口号：8888");
			Socket s = ss.accept();
			System.out.println("监听到连接" + s);
			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);
			String msg = "";
			while (!msg.equals("end")) {
				System.out.println("\t\t用户端：");
				String receive = dis.readUTF();
				System.out.println("\t\t " + receive);
				String reply = selectFromDB(receive);
				if (reply == null)
					reply = "我不清楚哦，还需要再学习";
				System.out.println("服务端：");
				dos.writeUTF(reply);
				System.out.println(reply);
			}
			scanner.close();
			os.close();
			dos.close();
			is.close();
			s.close();
			ss.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static String selectFromDB(String receive) {
		try {
			Class.forName("com.mysql.cj.jdbc.Driver");
		} catch (Exception e) {
			e.printStackTrace();
		}
		String sql = "select * from conservation where receive = ?";
		try (Connection c = DriverManager
				.getConnection("jdbc:mysql://127.0.0.1:3306" + "/robot?characterEncoding = UTF-8", "root", "admin");
				PreparedStatement ps = c.prepareStatement(sql)) {
			ps.setString(1, receive);
			ps.execute();
			ResultSet set = ps.getResultSet();
			List<String> strs = new ArrayList<String>();
			while (set.next()) {
				strs.add(set.getString("reply"));
			}
			Random r = new Random();
			if (!strs.isEmpty())
				return strs.get(r.nextInt(strs.size()>0?strs.size():1 - 1));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-09-02 练习-聊天机器人数据库

旧时亭台阁

关于 JAVA 中级-网络编程-Socket 的提问

使用多线程简单实现，没有处理连接关闭

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.*;
import java.util.Scanner;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务器监听端口：" + serverSocket.getLocalPort());

            // 数据库连接
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/android",
                    "root", "admin"
            );
            PreparedStatement ps = connection.prepareStatement("select * from dictionary where receive = ?");

            // 等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("收到一个客户端的连接请求：" + socket.getRemoteSocketAddress());

            DataInputStream dis = new DataInputStream(socket.getInputStream());
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);

            // 抛出一个接受消息的线程
            new Thread(() -> {
                try {
                    while (true) {
                        String msg = dis.readUTF();
                        System.out.println("收到客户端消息：" + msg);

                        // 从数据库查询响应消息
                        ps.setString(1, msg);
                        ps.execute();
                        ResultSet resultSet = ps.getResultSet();

                        // 获取总的行数
                        resultSet.last();
                        int total = resultSet.getRow();
                        // 随机选取一行
                        int rowId = (int) (Math.random() * total) + 1;
                        if (resultSet.absolute(rowId)) {
                            msg = resultSet.getString("response");
                            System.out.println("从数据库查到对应的回应信息：" + msg);
                        } else {
                            msg = "我不知道你在说什么呢";
                            System.out.println("未从数据库查到对应的回应消息，使用默认回应：" + msg);
                        }
                        // 发送给客户端
                        System.out.println("回应客户端：" + msg);
                        dos.writeUTF(msg);
                    }
                } catch (IOException | SQLException e) {
                    throw new RuntimeException(e);
                }
            }).start();

            // 抛出一个发送消息的线程
            new Thread(() -> {
                try {
                    while (true) {
                        // 从控制条等待输入
                        String line = scanner.nextLine();
                        System.out.println("给客户端发送消息：" + line);
                        dos.writeUTF(line);
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }).start();


        } catch (IOException | ClassNotFoundException | SQLException e) {
            throw new RuntimeException(e);
        }
    }
}









import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 8888);
            System.out.println("与服务器建立连接成功！");

            DataInputStream dis = new DataInputStream(socket.getInputStream());
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);

            // 抛出一个接受消息的线程
            new Thread(() -> {
                try {
                    while (true) {
                        String msg = dis.readUTF();
                        System.out.println("收到服务端消息：" + msg);
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }).start();

            // 抛出一个发送消息的线程
            new Thread(() -> {
                try {
                    while (true) {
                        String line = scanner.nextLine();
                        System.out.println("给服务端发送消息：" + line);
                        dos.writeUTF(line);
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }).start();

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1 个答案

CharlieLong
答案时间：2023-10-17

机器人程序（稍作了修改，用输入->查询Hero表->返回）实现

代码超过 5行，点击查看

package Socket.practice;
/**
 * 服务端
 * 首先创建一个数据库android(android现在是手机操作系统，其本意是机器人的意思)
 *
 * 然后创建一个表dictionary，字段：
 * id int
 * receive varchar(100)
 * response varchar(100)
 * receive 表示受到的信息
 * response 表示回应的信息
 * 在这个表里准备一些数据：
 * 你好 -> 好你妹！
 * 你叫什么 -> 你想泡我啊？
 * 打你哦 -> 来啊，来打我啊，不打有点挫
 * 开发一个程序，当从scanner读取到消息，发给Server服务端，服务端用这个消息到表dictionary中找到对应的相应，返回出去。 看上去就像在自动回应一样。
 * 如果一个recieve有多条response，则随机返回一条
 */

import JDBC.study.HeroDAO;
import charactor.Hero;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class pracBOTServer {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(8888);
        System.out.println("监听在端口号:8888");
        Socket s = ss.accept();
        Thread threadReceiveAndSend = new Thread() {
            public void run() {

                InputStream is = null;
                try {
                    is = s.getInputStream();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                //把输入流封装在DataInputStream
                DataInputStream dis = new DataInputStream(is);
                //使用readUTF读取字符串
                while (true) {
                    String msg = null;
                    try {
                        msg = dis.readUTF();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
//                    回复信息
                    OutputStream os = null;
                    try {
                        os = s.getOutputStream();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("接收到了信息："+msg);
                    //把输出流封装在DataOutputStream中
                    DataOutputStream dos = new DataOutputStream(os);
                    try {
                        String reply=autoReply(msg);
                        dos.writeUTF(reply);
                        System.out.println("回复信息："+reply);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        threadReceiveAndSend.start();
    }
    public static String autoReply(String sReceive){
        //初始化回复的文本内容
        String reply="";
        int total;
        HeroDAO dao=new HeroDAO();
        total=dao.getTotal();
        Hero h=dao.getbyname(sReceive);
        if(h!=null){
            reply=h.toString();
        }else{
            int id= (int) (Math.random() * total);
            h=dao.getRandomly(id-1);
            reply=h.toString();
        }
        return reply;
    }
}
package Socket.practice;
/**
 * 客户端
 * 首先创建一个数据库android(android现在是手机操作系统，其本意是机器人的意思)
 *
 * 然后创建一个表dictionary，字段：
 * id int
 * receive varchar(100)
 * response varchar(100)
 * receive 表示受到的信息
 * response 表示回应的信息
 * 在这个表里准备一些数据：
 * 你好 -> 好你妹！
 * 你叫什么 -> 你想泡我啊？
 * 打你哦 -> 来啊，来打我啊，不打有点挫
 * 开发一个程序，当从scanner读取到消息，发给Server服务端，服务端用这个消息到表dictionary中找到对应的相应，返回出去。 看上去就像在自动回应一样。
 * 如果一个recieve有多条response，则随机返回一条
 */
import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class pracBOTClient {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("127.0.0.1", 8888);
        Thread threadSend= new Thread(){
            public void run(){
                try {
                    OutputStream os = s.getOutputStream();
                    //把输出流封装在DataOutputStream中
                    DataOutputStream dos = new DataOutputStream(os);
                    //使用Scanner读取控制台的输入，并发送到服务端
                    Scanner sc = new Scanner(System.in);
                    while (true) {
                        String str = sc.next();
                        dos.writeUTF(str);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        threadSend.start();

        Thread threadReceive= new Thread(){
            public void run(){
                InputStream is = null;
                try {
                    is = s.getInputStream();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                //把输入流封装在DataInputStream
                DataInputStream dis = new DataInputStream(is);
                //使用readUTF读取字符串
                while (true){
                    String msg = null;
                    try {
                        msg = dis.readUTF();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(msg);
                }
//            dis.close();
//            s.close();
//            ss.close();

            }
        };
        threadReceive.start();
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-05-08 连接被拒绝异常java.net.ConnectException: Connection refused: connect

Javeson

关于 JAVA 中级-网络编程-Socket 的提问

连接被拒绝异常java.net.ConnectException: Connection refused: connect Server.java Client.java 2端都一样的异常

package socket;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
public class Server {
 
    public static void main(String[] args) {
    	try {
            // 连接到本机的8888端口
            Socket s = new Socket("127.0.0.1", 8888);
            System.out.println("客户端上线: ");
            InputStream is = s.getInputStream();
            DataInputStream dis = new DataInputStream(is);
             
            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);
 
            Scanner sc = new Scanner(System.in);
            Thread t1 = new Thread() {
                public void run() {
                    while (true) {
                        try {
                            String msg = dis.readUTF();
                            if (msg != null) {
                                System.out.println("收到服务端的消息:" + msg);
                            }   
                        } catch (IOException e) {
                            // TODO 自动生成的 catch 块
                            e.printStackTrace();
                        }
                    }
                }
            };
            Thread t2 = new Thread() {
                public void run() {
                    while (true) {
                        try {
                            String str = sc.next(); 
                            // 使用writeUTF发送字符串
                            dos.writeUTF(str);
                        } catch (IOException e) {
                            // TODO 自动生成的 catch 块
                            e.printStackTrace();
                        }   
                    }
                }
            };
            t1.start();
            t2.start();
            t1.join();
            System.out.println("关闭客户端");
            dis.close();        
            dos.close();
            s.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
 
    }
}

1 个答案

M_GX
答案时间：2022-06-05

你一个服务端不用ServerSocket，用什么socket

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-01-12 练习 - 聊天机器人数据库

起个名

关于 JAVA 中级-网络编程-Socket 的提问

首先创建一个数据库android(android现在是手机操作系统，其本意是机器人的意思) 然后创建一个表dictionary，字段： id int receive varchar(100) response varchar(100) receive 表示受到的信息 response 表示回应的信息在这个表里准备一些数据：你好 -> 好你妹！你叫什么 -> 你想泡我啊？打你哦 -> 来啊，来打我啊，不打有点挫等等等等开发一个程序，当从scanner读取到消息，发给Server服务端，服务端用这个消息到表dictionary中找到对应的相应，返回出去。看上去就像在自动回应一样。如果一个recieve有多条response，则随机返回一条

创建Chatdic类(雷同于Hero)
创建接口DAO1(雷同于DAO)
创建类ChatdicDAO1(雷同于HeroDAO)
创建类ChatdicTableModel(雷同于HeroTableModel)

server.java
static String recmsg = null;
	
	public static void main(String[] args) {
		// 聊天机器人数据库
		try { 
			ServerSocket ss = new ServerSocket(8888);
			System.out.println("服务端监听: ");
			Socket s = ss.accept();
			// 把输入流封装在DataInputStream
			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);	
			
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);
			
			ChatdicTableModel ctm = new ChatdicTableModel();
			
			
			Thread t1 = new Thread() {
				public void run() {
					while (true) {
						try {
							String msg = dis.readUTF();
							recmsg = msg;	
							Thread t2 = new Thread() {
								public void run() {
									try {
										if (recmsg != null) {
											String str = null;
											int tn = 0;
											List<String> resp = new ArrayList<>();
											for (int i = 0; i < ctm.getRowCount(); i++) {
												if (recmsg.equalsIgnoreCase(ctm.chatdic.get(i).receive)) {
													str = ctm.chatdic.get(i).response;
													tn++;
													if (tn >= 1)
														resp.add(str);
												}
											}	
											if (tn == 0) {
												str = "抱歉，我的词典里没有您所要的回复！";
											}
											if (tn > 1)
												str = getResp(resp);
											dos.writeUTF(str);	
										}
									} catch (IOException e) {
										// TODO 自动生成的 catch 块
										e.printStackTrace();
									}
								}
							};	
							t2.start();
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
					}
				}
			};	
			
			t1.start();
			t1.join();
			System.out.println("关闭服务端");
			dis.close();
			dos.close();
			s.close();
			ss.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}	

// 随机取值
	public static String getResp(List<String> resp) {
		int len = resp.size();
		String response = resp.get((int)(Math.random()*(len -1)));
		return response;
	}  

Client.java
// 聊天机器人数据库
		try {
			// 连接到本机的8888端口
			Socket s = new Socket("127.0.0.1", 8888);
			System.out.println("客户端上线: ");

			// 把输入流封装在DataOutputStream
			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			
			// 把输出流封装在DataOutputStream
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);
			// 使用Scanner读取控制台的输入，并发送到服务端
			Scanner sc = new Scanner(System.in);

			Thread t1 = new Thread() {
				public void run() {
					while (true) {
						try {
							String str = sc.next();	
							// 使用writeUTF发送字符串
							dos.writeUTF(str);
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}	
					}
				}
			};
			Thread t2 = new Thread() {
				public void run() {
					while (true) {
						try {
							String msg = dis.readUTF();
							if (msg != null) 
								System.out.println(msg);
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
					}
				}
			};
			t1.start();
			t2.start();
			t1.join();
			System.out.println("关闭客户端");
			dis.close();		
			dos.close();
			s.close();

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-01-11 练习 - 客户端与服务端互聊

起个名

关于 JAVA 中级-网络编程-Socket 的提问

前面部分的学习效果是服务端接受数据，客户端发送数据。做相应的改动，使得服务端也能发送数据，客户端也能接受数据，并且可以一直持续下去

server.java

    try {
			// 连接到本机的8888端口
			Socket s = new Socket("127.0.0.1", 8888);
			System.out.println("客户端上线: ");
			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);

			Scanner sc = new Scanner(System.in);
			Thread t1 = new Thread() {
				public void run() {
					while (true) {
						try {
							String msg = dis.readUTF();
							if (msg != null) {
								System.out.println("收到服务端的消息:" + msg);
							} 	
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
					}
				}
			};
			Thread t2 = new Thread() {
				public void run() {
					while (true) {
						try {
							String str = sc.next();	
							// 使用writeUTF发送字符串
							dos.writeUTF(str);
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}	
					}
				}
			};
			t1.start();
			t2.start();
			t1.join();
			System.out.println("关闭客户端");
			dis.close();		
			dos.close();
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		} 

client.java

    try {
			// 连接到本机的8888端口
			Socket s = new Socket("127.0.0.1", 8888);
			System.out.println("客户端上线: ");

			InputStream is = s.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			
			OutputStream os = s.getOutputStream();
			DataOutputStream dos = new DataOutputStream(os);

			Scanner sc = new Scanner(System.in);
			Thread t1 = new Thread() {
				public void run() {
					while (true) {
						try {
							String msg = dis.readUTF();
							if (msg != null) {
								System.out.println("收到服务端的消息:" + msg);
							} 	
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
					}
				}
			};
			Thread t2 = new Thread() {
				public void run() {
					while (true) {
						try {
							String str = sc.next();	
							// 使用writeUTF发送字符串
							dos.writeUTF(str);
						} catch (IOException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}	
					}
				}
			};
			t1.start();
			t2.start();
			t1.join();
			System.out.println("关闭客户端");
			dis.close();		
			dos.close();
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}

3 个答案

CharlieLong
答案时间：2023-10-17

* 前面部分的学习效果是服务端接受数据，客户端发送数据。 * 做相应的改动，使得服务端也能发送数据，客户端也能接受数据，并且可以一直持续下去

代码超过 5行，点击查看

package Socket.practice;
/**
 * 前面部分的学习效果是服务端接受数据，客户端发送数据。
 * 做相应的改动，使得服务端也能发送数据，客户端也能接受数据，并且可以一直持续下去
 * 当前为服务端
 */

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class pracSocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(8888);
        System.out.println("监听在端口号:8888");
        Socket s = ss.accept();

        Thread threadReceive= new Thread(){
            public void run(){

                InputStream is = null;
                try {
                    is = s.getInputStream();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                //把输入流封装在DataInputStream
                DataInputStream dis = new DataInputStream(is);
                //使用readUTF读取字符串
                while (true){
                    String msg = null;
                    try {
                        msg = dis.readUTF();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(msg);
                }

//            dis.close();
//            s.close();
//            ss.close();

            }
        };
        threadReceive.start();

        Thread threadSend= new Thread(){
            public void run(){
                try {
                    OutputStream os = s.getOutputStream();
                    //把输出流封装在DataOutputStream中
                    DataOutputStream dos = new DataOutputStream(os);
                    //使用Scanner读取控制台的输入，并发送到服务端
                    Scanner sc = new Scanner(System.in);
                    while (true) {
                        String str = sc.next();
                        dos.writeUTF(str);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        threadSend.start();
    }
}
package Socket.practice;
/**
 * 前面部分的学习效果是服务端接受数据，客户端发送数据。
 * 做相应的改动，使得服务端也能发送数据，客户端也能接受数据，并且可以一直持续下去
 * 当前为客户端
 */
import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class pracSocketClient {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("127.0.0.1", 8888);
        Thread threadSend= new Thread(){
            public void run(){
                try {
                    OutputStream os = s.getOutputStream();
                    //把输出流封装在DataOutputStream中
                    DataOutputStream dos = new DataOutputStream(os);
                    //使用Scanner读取控制台的输入，并发送到服务端
                    Scanner sc = new Scanner(System.in);
                    while (true) {
                        String str = sc.next();
                        dos.writeUTF(str);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        threadSend.start();

        Thread threadReceive= new Thread(){
            public void run(){
                InputStream is = null;
                try {
                    is = s.getInputStream();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

                //把输入流封装在DataInputStream
                DataInputStream dis = new DataInputStream(is);
                //使用readUTF读取字符串
                while (true){
                    String msg = null;
                    try {
                        msg = dis.readUTF();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(msg);
                }
//            dis.close();
//            s.close();
//            ss.close();

            }
        };
        threadReceive.start();

    }
}

G1g4lo
答案时间：2022-01-24

代码超过 5行，点击查看

起个名
答案时间：2022-01-12

多实践，就可以做出来

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 47 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于 JAVA 中级-网络编程-Socket 的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 578362961

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： https://how2j.cn/k/helloworld/helloworld-version/1718.html

上传截图