自定义Java套接字类

这是我第一次乱搞插座，直到现在它还在工作。基本上，我有一个名为

Server

的自定义

ServerSocket

类和一个名为

Client

的自定义

Socket

类

当客户机尝试连接到服务器时，服务器会执行一些检查，以确保它实际上是客户机，而不是其他套接字，因为客户机有我需要的某些方法

但是，此检查始终返回false。这是我的服务器连接代码：

package me.eli.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

import me.eli.client.Client;

public class Server extends ServerSocket {

private final Map<Client, IOPair> clients = new HashMap<Client, IOPair>();

public Server(final int port) throws IOException {
    super(port);
    System.out.println("Server started on " + getLocalPort() + "... Waiting for client!");
}

public Client waitOnClient() throws IOException {
    final Socket generalClient = accept();
    final Client client;
    if(!(generalClient instanceof Client)) {
        client = null;
        PrintWriter out = new PrintWriter(generalClient.getOutputStream(), true);
        out.println("Access denied: " + generalClient.getClass().getSimpleName());
        log("Invalid client: " + generalClient.getClass().getName() + " (" + generalClient.getInetAddress().getHostAddress() + ")");
        out.close();
    } else
        client = (Client) generalClient;
    if(client == null)
        return null;
    client.setServer(this);
    BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
    PrintWriter out = new PrintWriter(client.getOutputStream(), true);
    broadcast(client.getName() + " has joined.");
    clients.put(client, new IOPair(in, out));
    System.out.println("Client (" + client.getName() + ") connected from " + client.getInetAddress().getHostAddress());
    out.println("Connected! Welcome to the server.");
    return client;
}

@Override
public void close() throws IOException {
    for(Client c : getClients())
        kick(c, "Server closed");
    super.close();
}

public void kick(Client c, String reason) {
    try {
        c.message("disconnect", reason);
        c.close();
    } catch(IOException e) {
        log("Failed to kick " + c.getName() + ": " + e.getMessage());
        c.message("error", "Failed to disconnect");
    }
}

public void log(String message) {
    getServerOut().println(message);
}

public void log(String source, String message) {
    log("<" + source + "> " + message);
}

public void broadcast(String message) {
    log("broadcast", message);
    for(Client c : getClients())
        c.message("broadcast", message);
}

public Client[] getClients() {
    return clients.keySet().toArray(new Client[clients.keySet().size()]);
}

public BufferedReader getClientIn(Client c) {
    return clients.get(c).getIn();
}

public PrintWriter getClientOut(Client c) {
    return clients.get(c).getOut();
}


public InputStream getServerIn() {
    return System.in;
}

public PrintStream getServerOut() {
    return System.out;
}

public static boolean isServerRunningOn(final int port) {
    try {
        new ServerSocket(port).close();
        return false;
    } catch(IOException e) {
        return true;
    }
}

}

package me.eli.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.Socket;

import me.eli.server.IOPair;
import me.eli.server.Server;

public class Client extends Socket {

private Server server;
private final IOPair serverio;
private final String name;

public Client(final String host, final int port) throws IOException {
    this(host, port, "Guest-" + (int) (Math.random() * 10000));
}

public Client(final String host, final int port, final String name) throws IOException {
    super(host, port);
    System.out.println("Connected to server on " + host + ":" + port);
    BufferedReader in = new BufferedReader(new InputStreamReader(getInputStream()));
    PrintWriter out = new PrintWriter(getOutputStream(), true);
    this.name = name;
    this.serverio = new IOPair(in, out);
    String input;
    if((input = in.readLine()) != null)
        System.out.println("<Welcome message> " + input);
    out.println("Yay! I'm connected!");
}

@Override
public synchronized void close() throws IOException {
    if(serverio != null) {
        if(server != null)
            server.broadcast(getName() + " has disconnected.");
        message("server", "Disconnected.");
        super.close();
        serverio.getIn().close();
        serverio.getOut().close();
    } else
        super.close();
}

public void message(String source, String message) {
    getClientOut().println("<" + source + "> " + message);
}

public String getName() {
    return name;
}

public void setServer(Server server) {
    this.server = server;
}

public Server getServer() {
    return server;
}

public BufferedReader getServerIn() {
    return serverio.getIn();
}

public PrintWriter getServerOut() {
    return serverio.getOut();
}

public InputStream getClientIn() {
    return System.in;
}

public PrintStream getClientOut() {
    return System.out;
}

}

package me.eli.server；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.PrintStream；
导入java.io.PrintWriter；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.HashMap；
导入java.util.Map；
导入me.eli.client.client；
公共类服务器扩展ServerSocket{
私有最终映射客户端=新HashMap（）；
公共服务器（最终int端口）引发IOException{
超级（港口）；
System.out.println（“服务器在“+getLocalPort（）+”…等待客户端！”）上启动）；
}
公共客户端waitOnClient（）引发IOException{
最终套接字generalClient=accept（）；
最终客户；
if（！（客户端的通用客户端实例））{
client=null；
PrintWriter out=新的PrintWriter（generalClient.getOutputStream（），true）；
println（“拒绝访问：+generalClient.getClass（）.getSimpleName（））；
日志（“无效客户端：“+generalClient.getClass（）.getName（）+”（“+generalClient.getInetAddress（）.getHostAddress（）+”））；
out.close（）；
}否则
客户=（客户）一般客户；
if（客户端==null）
返回null；
client.setServer（this）；
BufferedReader in=新的BufferedReader（新的InputStreamReader（client.getInputStream（））；
PrintWriter out=新的PrintWriter（client.getOutputStream（），true）；
广播（client.getName（）+“已加入。”）；
客户机。输入（客户机、新IOPair（输入、输出））；
System.out.println（“客户端（“+Client.getName（）+”）从“+Client.getInetAddress（）.getHostAddress（））连接）；
println（“已连接！欢迎使用服务器”）；
返回客户；
}
@凌驾
public void close（）引发IOException{
对于（客户端c:GetClient（））
踢（c，“服务器关闭”）；
super.close（）；
}
公共无效提示（客户端c，字符串原因）{
试一试{
c、 信息（“断开”，原因）；
c、 close（）；
}捕获（IOE异常）{
日志（“未能触发”+c.getName（）+“：”+e.getMessage（））；
c、 消息（“错误”，“断开连接失败”）；
}
}
公共作废日志（字符串消息）{
getServerOut（）.println（消息）；
}
公共作废日志（字符串源、字符串消息）{
日志（“+”消息）；
}
公共无效广播（字符串消息）{
日志（“广播”，消息）；
对于（客户端c:GetClient（））
c、 信息（“广播”，信息）；
}
公共客户端[]getClients（）{
返回clients.keySet（）.toArray（新客户端[clients.keySet（）.size（））；
}
公共BufferedReader getClientIn（客户端c）{
返回clients.get（c.getIn（）；
}
公共PrintWriter getClientOut（客户端c）{
返回clients.get（c.getOut（）；
}
公共InputStream getServerIn（）{
返回系统.in；
}
公共PrintStream getServerOut（）{
返回系统输出；
}
公共静态布尔值isServerRunningOn（最终int端口）{
试一试{
新建ServerSocket（端口）.close（）；
返回false；
}捕获（IOE异常）{
返回true；
}
}
}

这是我的客户端连接代码：

package me.eli.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

import me.eli.client.Client;

public class Server extends ServerSocket {

private final Map<Client, IOPair> clients = new HashMap<Client, IOPair>();

public Server(final int port) throws IOException {
    super(port);
    System.out.println("Server started on " + getLocalPort() + "... Waiting for client!");
}

public Client waitOnClient() throws IOException {
    final Socket generalClient = accept();
    final Client client;
    if(!(generalClient instanceof Client)) {
        client = null;
        PrintWriter out = new PrintWriter(generalClient.getOutputStream(), true);
        out.println("Access denied: " + generalClient.getClass().getSimpleName());
        log("Invalid client: " + generalClient.getClass().getName() + " (" + generalClient.getInetAddress().getHostAddress() + ")");
        out.close();
    } else
        client = (Client) generalClient;
    if(client == null)
        return null;
    client.setServer(this);
    BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
    PrintWriter out = new PrintWriter(client.getOutputStream(), true);
    broadcast(client.getName() + " has joined.");
    clients.put(client, new IOPair(in, out));
    System.out.println("Client (" + client.getName() + ") connected from " + client.getInetAddress().getHostAddress());
    out.println("Connected! Welcome to the server.");
    return client;
}

@Override
public void close() throws IOException {
    for(Client c : getClients())
        kick(c, "Server closed");
    super.close();
}

public void kick(Client c, String reason) {
    try {
        c.message("disconnect", reason);
        c.close();
    } catch(IOException e) {
        log("Failed to kick " + c.getName() + ": " + e.getMessage());
        c.message("error", "Failed to disconnect");
    }
}

public void log(String message) {
    getServerOut().println(message);
}

public void log(String source, String message) {
    log("<" + source + "> " + message);
}

public void broadcast(String message) {
    log("broadcast", message);
    for(Client c : getClients())
        c.message("broadcast", message);
}

public Client[] getClients() {
    return clients.keySet().toArray(new Client[clients.keySet().size()]);
}

public BufferedReader getClientIn(Client c) {
    return clients.get(c).getIn();
}

public PrintWriter getClientOut(Client c) {
    return clients.get(c).getOut();
}


public InputStream getServerIn() {
    return System.in;
}

public PrintStream getServerOut() {
    return System.out;
}

public static boolean isServerRunningOn(final int port) {
    try {
        new ServerSocket(port).close();
        return false;
    } catch(IOException e) {
        return true;
    }
}

}

package me.eli.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.Socket;

import me.eli.server.IOPair;
import me.eli.server.Server;

public class Client extends Socket {

private Server server;
private final IOPair serverio;
private final String name;

public Client(final String host, final int port) throws IOException {
    this(host, port, "Guest-" + (int) (Math.random() * 10000));
}

public Client(final String host, final int port, final String name) throws IOException {
    super(host, port);
    System.out.println("Connected to server on " + host + ":" + port);
    BufferedReader in = new BufferedReader(new InputStreamReader(getInputStream()));
    PrintWriter out = new PrintWriter(getOutputStream(), true);
    this.name = name;
    this.serverio = new IOPair(in, out);
    String input;
    if((input = in.readLine()) != null)
        System.out.println("<Welcome message> " + input);
    out.println("Yay! I'm connected!");
}

@Override
public synchronized void close() throws IOException {
    if(serverio != null) {
        if(server != null)
            server.broadcast(getName() + " has disconnected.");
        message("server", "Disconnected.");
        super.close();
        serverio.getIn().close();
        serverio.getOut().close();
    } else
        super.close();
}

public void message(String source, String message) {
    getClientOut().println("<" + source + "> " + message);
}

public String getName() {
    return name;
}

public void setServer(Server server) {
    this.server = server;
}

public Server getServer() {
    return server;
}

public BufferedReader getServerIn() {
    return serverio.getIn();
}

public PrintWriter getServerOut() {
    return serverio.getOut();
}

public InputStream getClientIn() {
    return System.in;
}

public PrintStream getClientOut() {
    return System.out;
}

}

package me.eli.client；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.PrintStream；
导入java.io.PrintWriter；
导入java.net.Socket；
导入me.eli.server.IOPair；
导入me.eli.server.server；
公共类客户端扩展套接字{
专用服务器；
专用最终IOPair服务器；
私有最终字符串名；
公共客户端（最终字符串主机、最终int端口）引发IOException{
这个（主机，端口，“Guest-”+（int）（Math.random（）*10000））；
}
公共客户端（最终字符串主机、最终int端口、最终字符串名称）引发IOException{
超级（主机、端口）；
System.out.println（“连接到“+主机+”：“+端口上的服务器）；
BufferedReader in=新的BufferedReader（新的InputStreamReader（getInputStream（））；
PrintWriter out=新的PrintWriter（getOutputStream（），true）；
this.name=名称；
this.serverio=新IOPair（输入、输出）；
字符串输入；
如果（（input=in.readLine（））！=null）
系统输出打印项次（“+输入）；
out.println（“耶！我接通了！”）；
}
@凌驾
public synchronized void close（）引发IOException{
if（serverio！=null）{
如果（服务器！=null）
广播（getName（）+“已断开连接。”）；
消息（“服务器”，“断开连接”）；
super.close（）；
serverio.getIn（）.close（）；
serverio.getOut（）.close（）；
}否则
super.close（）；
}
公共无效消息（字符串源、字符串消息）{
getClientOut（）.println（“+”消息）；
}
公共字符串getName（）{
返回名称；
}
公共void设置服务器（服务器）{
this.server=server；
}
公共服务器getServer（）{
返回服务器；
}
公共BufferedReader getServerIn（）{
返回serverio.getIn（）；
}
公共PrintWriter getServerOut（）{
返回serverio.getOut（）；
}
公共输入流getClientIn（）{
返回系统.in；
}
公共PrintStream getClientOut（）{
返回系统输出；
}
}

我在网络方面不是最有经验的，但这让我感到困惑，因为我确实与我的客户机类进行了连接。提前谢谢

服务器执行一些检查，以确保它实际上是在尝试建立连接的客户端

不可能的和荒谬的。

客户端

类位于连接的另一端。它不会神奇地传输到您的

accept（）

方法。如果您想验证您的