设置客户端套接字和服务器套接字侦听器（Java）_Java_Sockets_P2p

设置客户端套接字和服务器套接字侦听器（Java）

java sockets

设置客户端套接字和服务器套接字侦听器（Java）,java,sockets,p2p,Java,Sockets,P2p,我正在尝试用java建立点对点连接我试图将我的程序设置为侦听传入的连接，同时外观上能够连接到不同的客户端如何将套接字连接实例化：socketConnection为连接到程序的任何对象。理想的情况是： if(socketConnection.isConnectedToExternalPeer()){ //do stuff } else if (socketConnection.hasAnIncomingConnection()){ //do stuff } 在咨询@L.Spillner的解决

我正在尝试用java建立点对点连接

我试图将我的程序设置为侦听传入的连接，同时外观上能够连接到不同的客户端

如何将套接字连接实例化：

socketConnection

为连接到程序的任何对象。理想的情况是：

if(socketConnection.isConnectedToExternalPeer()){
//do stuff
} else if (socketConnection.hasAnIncomingConnection()){
//do stuff
}

在咨询@L.Spillner的解决方案后，我将以下代码组合在一起，唯一的问题是我无法完全掌握如何接受连接，这一点可以从以下事实中明显看出：当我尝试设置流时，程序会在等待对等方回复时以循环结束：

public class Client implements AutoCloseable {

    // Any other ThreadPool can be used as well
    private ExecutorService cachedExecutor = null;
    private ExecutorService singleThreadExecutor = null;
    // port this client shall listen on
    private int port = 0;

    // Name of the client
    private String name = null;

    // indicates that a connection is ongoing
    private boolean isConnected = false;

    // the socket the Client is currently connected with
    private Socket activeConenctionSocket = null;

    // The ServerSocket which will be listening for any incoming connection
    private ServerSocket listener = null;

    // The socket which has been accepted by the ServerSocket
    private Future<Socket> acceptedSocket;


    private ObjectInputStream inputStream = null;


    private ObjectOutputStream outputStream = null;

    private BloomChain bloomChain = null;


    /**
     * @param port Port number by which this client shall be accessed.
     * @param name The name of this Client.
     */
    public Client( int port, String name )
    {
        this.port = port;
        this.name = name;
        this.bloomChain = new BloomChain();

        this.cachedExecutor = Executors.newCachedThreadPool();
        this.singleThreadExecutor = Executors.newSingleThreadExecutor();

        this.listener = createListeningSocket();
        startListening();
    }

    private ServerSocket createListeningSocket()
    {

        ServerSocket temp = null;
        try
        {
            temp = new ServerSocket( this.port );

        }
        catch ( IOException e )
        {
            e.printStackTrace();
        }

        return temp;
    }

    private void startListening()
    {
        if ( !this.isConnected )
        {
            this.listener = createListeningSocket();
            this.acceptedSocket = this.cachedExecutor.submit( new ServAccept( this.listener ) );

        }
    }



    /**
     * Attempts to connect to any other socket specified by the hostname and the targetport.
     *
     * @param host The hostname of the target to connect.
     * @param targetport The port of the target.
     */
    public void connect( String host, int targetport )
    {

        try
        {   System.out.println(host);
            System.out.println(targetport);
            this.activeConenctionSocket = new Socket( InetAddress.getByName( host ), targetport );

            setUpStreams(this.activeConenctionSocket);

            this.isConnected = true;

            System.out.println(InetAddress.getAllByName(host));
        }
        catch ( IOException e )
        {
            e.printStackTrace();
        }

        try
        {
            this.listener.close();
        }
        catch ( IOException e )
        {
            // this will almost certainly throw an exception but it is intended.
        }
    }

    public void setUpStreams(Socket socket) throws IOException {
        this.outputStream = new ObjectOutputStream(socket.getOutputStream());
        this.outputStream.flush();
        this.inputStream = new ObjectInputStream(socket.getInputStream());
    }

    @Override
    public void close() throws Exception
    {
        // close logic (can be rather nasty)
    }

    public void sendMessage(String message){

        if(bloomChain.size()<1){
            bloomChain.addBlock(new Block(message, "0"));
        } else {
            bloomChain.addBlock(new Block(message, bloomChain.get(bloomChain.size()-1).getPreviousHash()));
        }
        try {

            this.outputStream.writeObject(bloomChain);
            this.outputStream.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public String mineMessage(){
        final String[] receivedMessage = {null};
        final Block tempBlock = this.bloomChain.get(this.bloomChain.size()-1);

        this.singleThreadExecutor.submit(()->{
            tempBlock.mineBlock(bloomChain.getDifficulty());
            receivedMessage[0] = tempBlock.getData();

        });

        return receivedMessage[0];
    }

    public String dataListener(){
        if(isConnected) {
            try {
                BloomChain tempChain = (BloomChain) this.inputStream.readObject();
                if (tempChain.isChainValid()) {
                    this.bloomChain = tempChain;
                    return mineMessage();
                }

            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    public ServerSocket getListener() {
        return this.listener;
    }

    public boolean isConnected(){
        return isConnected;
    }

    public ObjectOutputStream getOutputStream(){
        return this.outputStream;
    }

    public ObjectInputStream getInputStream(){
        return this.inputStream;
    }



}

这将成功等待

acceptedSocket

返回连接的套接字，但是当我尝试连接到另一个本地运行的客户端时，我得到以下错误：

java.net.SocketException:socket closed

好的，经过一些修补，我终于找到了一个简洁的小解决方案：

我们希望能够同时监听和连接，因此我们需要一个

ServerSocket

，并发出一个呼叫以接受传入的连接。
然而，这个方法阻塞了线程，所以为了能够继续我们的程序，我们必须将这个调用外包到另一个线程中，幸运的是，默认的JavaAPI提供了一个简单的方法来完成

以下代码示例未完成，但提供了核心功能：

Client.java:

public class Client
    implements AutoCloseable
{
  // Any other ThreadPool can be used as well
  private ExecutorService es = Executors.newCachedThreadPool();

  // port this client shall listen on
  private int port;

  // Name of the client
  private String name;

  // indicates that a connection is ongoing
  private boolean isConnected = false;

  // the socket the Client is currently connected with
  private Socket activeConenctionSocket;

  // The ServerSocket which will be listening for any incoming connection
  private ServerSocket listener;

  // The socket which has been accepted by the ServerSocket
  private Future<Socket> acceptedSocket;

  /**
   * @param port Port number by which this client shall be accessed.
   * @param name The name of this Client.
   */
  public Client( int port, String name )
  {
    this.port = port;
    this.name = name;
    this.listener = createListeningSocket();
    startListening();
  }

  private ServerSocket createListeningSocket()
  {

    ServerSocket temp = null;
    try
    {
      temp = new ServerSocket( port );
    }
    catch ( IOException e )
    {
      e.printStackTrace();
    }

    return temp;
  }

  private void startListening()
  {
    if ( !isConnected )
    {
      listener = createListeningSocket();
      acceptedSocket = es.submit( new ServAccept( listener ) );
    }
  }

  /**
   * Attempts to connect to any other socket specified by the hostname and the targetport.
   * 
   * @param host The hostname of the target to connect.
   * @param targetport The port of the target.
   */
  public void connect( String host, int targetport )
  {
    isConnected = true;
    try
    {
      activeConenctionSocket = new Socket( InetAddress.getByName( host ), targetport );
    }
    catch ( IOException e )
    {
      e.printStackTrace();
    }

    try
    {
      listener.close();
    }
    catch ( IOException e )
    {
      // this will almost certainly throw an exception but it is intended.
    }
  }

  @Override
  public void close() throws Exception
  {
    // close logic (can be rather nasty)
  }
}

编辑：

public class Client
    implements AutoCloseable
{
  // Any other ThreadPool can be used as well
  private ExecutorService es = Executors.newCachedThreadPool();

  // port this client shall listen on
  private int port;

  // Name of the client
  private String name;

  // indicates that a connection is ongoing
  private boolean isConnected = false;

  // the socket the Client is currently connected with
  private Socket activeConenctionSocket;

  // The ServerSocket which will be listening for any incoming connection
  private ServerSocket listener;

  // The socket which has been accepted by the ServerSocket
  private Future<Socket> acceptedSocket;

  /**
   * @param port Port number by which this client shall be accessed.
   * @param name The name of this Client.
   */
  public Client( int port, String name )
  {
    this.port = port;
    this.name = name;
    this.listener = createListeningSocket();
    startListening();
  }

  private ServerSocket createListeningSocket()
  {

    ServerSocket temp = null;
    try
    {
      temp = new ServerSocket( port );
    }
    catch ( IOException e )
    {
      e.printStackTrace();
    }

    return temp;
  }

  private void startListening()
  {
    if ( !isConnected )
    {
      listener = createListeningSocket();
      acceptedSocket = es.submit( new ServAccept( listener ) );
    }
  }

  /**
   * Attempts to connect to any other socket specified by the hostname and the targetport.
   * 
   * @param host The hostname of the target to connect.
   * @param targetport The port of the target.
   */
  public void connect( String host, int targetport )
  {
    isConnected = true;
    try
    {
      activeConenctionSocket = new Socket( InetAddress.getByName( host ), targetport );
    }
    catch ( IOException e )
    {
      e.printStackTrace();
    }

    try
    {
      listener.close();
    }
    catch ( IOException e )
    {
      // this will almost certainly throw an exception but it is intended.
    }
  }

  @Override
  public void close() throws Exception
  {
    // close logic (can be rather nasty)
  }
}

事实上，我不得不承认，我的方法对于任务来说可能不是一个非常全面的方法，所以我决定改变一些东西。这一次，我决定使用Events/一个自定义EventListener，而不是使用一个Future对象，它只是坐在那里监听要接收的连接。我测试了连接功能，它工作得很好，但我还没有实现一个解决方案来确定客户机是否真的连接到了对等机。我只是确保客户端一次只能保持一个连接

这些变化：

ServerAccept.java

public class ServAccept
    implements Callable<Socket>
{
  ServerSocket serv;

  public ServAccept( ServerSocket sock )
  {
    this.serv = sock;
  }

  @Override
  public Socket call() throws Exception
  {
    return serv.accept();
  }

}

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

public class ServAccept implements Runnable
{
    private ServerSocket serv;
    private ConnectionReceivedListener listener;

    public ServAccept( ServerSocket sock,ConnectionReceivedListener con )
    {
        this.serv = sock;
        this.listener = con;
    }

    @Override
    public void run()
    {
        try
        {
            listener.onConnectionReceived( new ConnectionReceivedEvent( serv.accept() ) );
        } catch (IOException e)
        {
            // planned exception here.
        }
    }
}

import java.util.EventListener;

@FunctionalInterface
public interface ConnectionReceivedListener extends EventListener
{
    public void onConnectionReceived(ConnectionReceivedEvent event);
}

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

public class ConnectionReceivedEvent
{
    private Socket accepted;

    public ConnectionReceivedEvent( Socket sock )
    {
        this.accepted = sock;
    }

    public Socket getSocket()
    {
        return accepted;
    }

    public OutputStream getOutput() throws IOException
    {
        return accepted.getOutputStream();
    }

    public InputStream getInput() throws IOException
    {
        return accepted.getInputStream();
    }

    public int getPort()
    {
        return accepted.getPort();
    }
}

不再实现

Callable

但

Runnable

更改的唯一原因是我们不再等待任何返回，因为我们将使用侦听器和一些有趣的事件。无论如何，为了做到这一点，我们需要创建一个侦听器并将其传递给这个对象。但首先我们应该看看侦听器/事件结构：

ConnectionReceivedListener.java

public class ServAccept
    implements Callable<Socket>
{
  ServerSocket serv;

  public ServAccept( ServerSocket sock )
  {
    this.serv = sock;
  }

  @Override
  public Socket call() throws Exception
  {
    return serv.accept();
  }

}

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

public class ServAccept implements Runnable
{
    private ServerSocket serv;
    private ConnectionReceivedListener listener;

    public ServAccept( ServerSocket sock,ConnectionReceivedListener con )
    {
        this.serv = sock;
        this.listener = con;
    }

    @Override
    public void run()
    {
        try
        {
            listener.onConnectionReceived( new ConnectionReceivedEvent( serv.accept() ) );
        } catch (IOException e)
        {
            // planned exception here.
        }
    }
}

import java.util.EventListener;

@FunctionalInterface
public interface ConnectionReceivedListener extends EventListener
{
    public void onConnectionReceived(ConnectionReceivedEvent event);
}

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

public class ConnectionReceivedEvent
{
    private Socket accepted;

    public ConnectionReceivedEvent( Socket sock )
    {
        this.accepted = sock;
    }

    public Socket getSocket()
    {
        return accepted;
    }

    public OutputStream getOutput() throws IOException
    {
        return accepted.getOutputStream();
    }

    public InputStream getInput() throws IOException
    {
        return accepted.getInputStream();
    }

    public int getPort()
    {
        return accepted.getPort();
    }
}

只是一个简单的接口，从我们建立一些匿名类或lambda表达式。没什么好幻想的。它甚至不需要扩展

EventListener

接口，但我喜欢这样做，以提醒我该类的用途

ConnectionReceivedEvent.java

public class ServAccept
    implements Callable<Socket>
{
  ServerSocket serv;

  public ServAccept( ServerSocket sock )
  {
    this.serv = sock;
  }

  @Override
  public Socket call() throws Exception
  {
    return serv.accept();
  }

}

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

public class ServAccept implements Runnable
{
    private ServerSocket serv;
    private ConnectionReceivedListener listener;

    public ServAccept( ServerSocket sock,ConnectionReceivedListener con )
    {
        this.serv = sock;
        this.listener = con;
    }

    @Override
    public void run()
    {
        try
        {
            listener.onConnectionReceived( new ConnectionReceivedEvent( serv.accept() ) );
        } catch (IOException e)
        {
            // planned exception here.
        }
    }
}

import java.util.EventListener;

@FunctionalInterface
public interface ConnectionReceivedListener extends EventListener
{
    public void onConnectionReceived(ConnectionReceivedEvent event);
}

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

public class ConnectionReceivedEvent
{
    private Socket accepted;

    public ConnectionReceivedEvent( Socket sock )
    {
        this.accepted = sock;
    }

    public Socket getSocket()
    {
        return accepted;
    }

    public OutputStream getOutput() throws IOException
    {
        return accepted.getOutputStream();
    }

    public InputStream getInput() throws IOException
    {
        return accepted.getInputStream();
    }

    public int getPort()
    {
        return accepted.getPort();
    }
}

也没什么好想象的，只是将套接字作为构造函数参数传递，并定义一些getter，在本例中大多数getter都不会使用这些getter

但是我们现在如何使用它呢

private void startListening()
{
    if (!isConnected)
    {
        closeIfNotNull();
        listener = createListeningSocket();
        es.execute( new ServAccept( listener, event -> setAccepted( event.getSocket() ) ) );
    }
}

private void setAccepted( Socket socket )
{
    if (!isConnected)
    {
        this.activeConenctionSocket = socket;
        setUpStreams( socket );
    } else
    {
        sendError( socket );
    }
}

我们仍然使用

ExecutorService

并使用

servaccpt

类创建一个新线程。然而，由于我们不期望任何回报，我将从

ExecutorService#submit

更改为

ExecutorService#execute

（只是意见和品味的问题）。
但是

servaccpt

现在需要两个参数。要使用的服务器套接字和侦听器。幸运的是，我们可以使用annonymous类，而且由于我们的侦听器只具有一个方法，所以我们甚至可以使用lambda表达式<代码>事件->设置已接受（event.getSocket（））

作为对你第二次编辑的回答：我犯了一个逻辑错误。当中断

ServerSocket#accept

调用时，不是

ServerSocket#close

方法引发异常，而是

accept（）

调用本身引发异常。换句话说，你得到的异常是故意的，我错误地抑制了另一个异常。

好的，经过一些修补，我终于想出了一个简洁的小解决方案：