使用网络服务器部署 OSGI 捆绑包时出现无限循环

Question

我正在尝试通过使用网络套接字的网络服务器来实现 OSGI 捆绑。 这是完整的源代码： http://www.2shared.com/file/RMXby331/ CB_27.html

这是激活器：

package org.DX_57.osgi.CB_27.impl;

import java.util.Properties;
import org.DX_57.osgi.CB_27.api.CBridge;
import org.DX_57.osgi.CB_27.impl.EchoServer;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;

public class CBridgeApp implements BundleActivator {

    public void start(BundleContext bc) throws Exception {
        ServiceRegistration registerService = bc.registerService(CBridge.class.getName(), new CBridgeImpl(), new Properties());
        EchoServer();
    }

    public void stop(BundleContext bc) throws Exception {
        boolean ungetService = bc.ungetService(bc.getServiceReference(CBridge.class.getName()));
    }

    private void EchoServer() {
        EchoServer method = new EchoServer();
    }
}

这是 Java 网络服务器的源代码：

package org.DX_57.osgi.CB_27.impl;

import java.net.*;
import java.io.*;

public class EchoServer
{        
    ServerSocket m_ServerSocket;


    public EchoServer() 
    {
        try
        {
            // Create the server socket.
            m_ServerSocket = new ServerSocket(12111);
        }
        catch(IOException ioe)
        {
            System.out.println("Could not create server socket at 12111. Quitting.");
            System.exit(-1);
        }

        System.out.println("Listening for clients on 12111...");

        // Successfully created Server Socket. Now wait for connections.
        int id = 0;
        while(true)
        {                        
            try
            {
                // Accept incoming connections.
                Socket clientSocket = m_ServerSocket.accept();

                // accept() will block until a client connects to the server.
                // If execution reaches this point, then it means that a client
                // socket has been accepted.

                // For each client, we will start a service thread to
                // service the client requests. This is to demonstrate a
                // multithreaded server, although not required for such a
                // trivial application. Starting a thread also lets our
                // EchoServer accept multiple connections simultaneously.

                // Start a service thread

                ClientServiceThread cliThread = new ClientServiceThread(clientSocket, id++);
                cliThread.start();
            }
            catch(IOException ioe)
            {
                System.out.println("Exception encountered on accept. Ignoring. Stack Trace :");
                ioe.printStackTrace();
            }
        }
    }

    public static void main (String[] args)
    {
        new EchoServer();    
    }


    class ClientServiceThread extends Thread
    {
        Socket m_clientSocket;        
        int m_clientID = -1;
        boolean m_bRunThread = true;

        ClientServiceThread(Socket s, int clientID)
        {
            m_clientSocket = s;
            m_clientID = clientID;
        }

        public void run()
        {            
            // Obtain the input stream and the output stream for the socket
            // A good practice is to encapsulate them with a BufferedReader
            // and a PrintWriter as shown below.
            BufferedReader in = null; 
            PrintWriter out = null;

            // Print out details of this connection
            System.out.println("Accepted Client : ID - " + m_clientID + " : Address - " + 
                             m_clientSocket.getInetAddress().getHostName());

            try
            {                                
                in = new BufferedReader(new InputStreamReader(m_clientSocket.getInputStream()));
                out = new PrintWriter(new OutputStreamWriter(m_clientSocket.getOutputStream()));

                // At this point, we can read for input and reply with appropriate output.

                // Run in a loop until m_bRunThread is set to false
                while(m_bRunThread)
                {                    
                    // read incoming stream
                    String clientCommand = in.readLine();

                    System.out.println("Client Says :" + clientCommand);


                    if(clientCommand.equalsIgnoreCase("quit"))
                    {
                        // Special command. Quit this thread
                        m_bRunThread = false;   
                        System.out.print("Stopping client thread for client : " + m_clientID);
                    }
                    else
                    {
                        // Echo it back to the client.
                        out.println(clientCommand);
                        out.flush();
                    }
                }
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
            finally
            {
                // Clean up
                try
                {                    
                    in.close();
                    out.close();
                    m_clientSocket.close();
                    System.out.println("...Stopped");
                }
                catch(IOException ioe)
                {
                    ioe.printStackTrace();
                }
            }
        }
    }
} 

当我尝试在 Glassfish 服务器上部署包时，应用程序服务器挂起，但我可以使用以下命令连接到 java 网络服务器： Java 客户端。似乎存在无限循环。我需要帮助来修复代码。

最好的祝愿

Answer 1

您的捆绑激活器启动方法永远不会返回，因为您正在使用无限循环调用服务的构造函数。一个好的做法是尽快从捆绑激活器返回。

这是如何重写代码的想法：

public class EchoServer {
    private volatile boolean started;
    public void start() {

        new Thread(new Runnable() {
            @Override
            public void run() {
                started = true;

                try {
                    m_ServerSocket = new ServerSocket(12111);
                } catch(IOException ioe) {
                    System.out.println("Could not create server socket at 12111. Quitting.");
                    System.exit(-1);
                }
                System.out.println("Listening for clients on 12111...");

                // Successfully created Server Socket. Now wait for connections.
                int id = 0;

                while (started) {
                    try {

                        Socket clientSocket = m_ServerSocket.accept();
                        ClientServiceThread cliThread = new ClientServiceThread(clientSocket, id++);
                        cliThread.start();    
                    } catch(IOException ioe) {
                        System.out.println("Exception encountered on accept. Ignoring. Stack Trace :");
                        ioe.printStackTrace();
                    }
                }
            }
        }).start();
    }
    public void stop() {
        started = false;
    }
}

Activator

public class CBridgeApp implements BundleActivator {
    private EchoServer method;
    public void start(BundleContext bc) throws Exception {
        ...

        method = new EchoServer();
        method.start();
    }
    public void stop(BundleContext bc) throws Exception {
        ...

        method.stop();
    }
}