Java 带OSGi的套接字：捆绑已停止，套接字仍处于打开状态
在我的一个bundle中使用ServerSocket时，我面临着这个问题，我们把它称为：FooBundle 这个FooBundle还有一个SocketListener.java类。这个类是一个线程，为了对它做一点概述，我将粘贴一些伪代码：Java 带OSGi的套接字：捆绑已停止，套接字仍处于打开状态,java,sockets,osgi,Java,Sockets,Osgi,在我的一个bundle中使用ServerSocket时，我面临着这个问题，我们把它称为：FooBundle 这个FooBundle还有一个SocketListener.java类。这个类是一个线程，为了对它做一点概述，我将粘贴一些伪代码： public class SocketListener implements Runnable{ ServerSocket providerSocket; Socket connection = null; private boolean closeIt =
public class SocketListener implements Runnable{
ServerSocket providerSocket;
Socket connection = null;
private boolean closeIt = false;
public void run() {
try {
//Create the server socket
providerSocket = new ServerSocket(41000, 10);
} catch (IOException e1) {
//catching the exception....
}
while(!closeIt){
try{
connection = providerSocket.accept();
in = new Scanner(new InputStreamReader(onnection.getInputStream()));
while(in.hasNext() !=false)
message = message + " "+in.next();
// bla bla bla...
} catch (IOException e) {
//bla bla...
}
finally{
try{
if (message.equalsIgnoreCase("bye"))
providerSocket.close();
closeIt = true;
}
catch(IOException ioException){
//........
}
}
**FooBundle**
|__FooBundleActivator
|__FooImpl
|__SocketListener (thread)
提前感谢。在退出线程功能之前，无论消息如何，您都需要关闭侦听套接字。那么，对您来说真正有区别的是，在旧连接处于超时状态时，调用该套接字以允许绑定端口
并且，请在代码中使用更好的缩进技术…在退出线程函数之前，无论消息如何，您都需要关闭侦听套接字。那么，对您来说真正有区别的是，在旧连接处于超时状态时，调用该套接字以允许绑定端口
另外，请在代码中使用更好的缩进技术…在Activator外部实例化ServerSocket，并通过构造函数将其传递给SocketListener。您可以在激活器的stop函数中调用serverSocket.stop
如果调用ServerSocket.stop，将抛出SocketException，它是IOException的子类。请考虑在while迭代中处理IOException，这样它肯定会停止执行迭代。在激活器外部实例化ServerSocket，并通过构造函数将其传递给SocketListener。您可以在激活器的stop函数中调用serverSocket.stop
如果调用ServerSocket.stop，将抛出SocketException，它是IOException的子类。请考虑在while迭代中处理IOException，以确保它将停止执行迭代。如果您的包被告知停止，那么假设停止的人知道他在做什么。是的，你的协议期待着“再见”，但是狗屎发生了，任何与这些东西有问题的协议对于现实世界来说都太脆弱了。通常，OSGi中的所有任务都应该有一个生命周期。这就是我使用DS而不是激活器的代码
@Component
public class ProtocolServer extends Thread {
volatile ServerSocket server;
volatile Socket connection;
public ProtocolServer() {
super("Protocol Server on 4100"); // to identify the thread
}
@Activate void activate() {
setDaemon(true);
start();
}
@Deactivate void deactivate() {
interrupt();
// best effort close (even if null)
try { server.close(); } catch(Exception e) {}
try { connection.close(); } catch(Exception e) {}
join(10000); // waits 10 secs until thread exits
}
public void run() {
// loop for active component
while( !isInterrupted() )
try {
doServer();
} catch( Exception e) {
log(e);
// bad error, accept failed or bind failed
// or server socket was closed. If we should remain
// active, sleep to prevent overloading the
// system by trying too often, so sleep
if ( !isInterrupted() )
try { Thread.sleep(5000); } catch(Exception e) {}
}
}
private void doServer() throws Exception {
server = new ServerSocket(4100)
try {
while( !isInterrupted() )
doConnection(server);
} finally {
server.close();
}
}
private void doConnection(ServerSocket server) throws Exception {
connection = server.accept();
try {
doMessages(connection);
// the pseudo code exits here, but that seems
// kind of weird? If desired, interrupt
// this object, this will exit the thread
} catch( Exception e) {
log(e); // the connection failed, is not uncommon
} finally {
connection.close();
connection = null;
}
}
private void doMessages(Socket connection) {
MyScanner s = new MyScanner(socket);
String msg;
while( !isInterrupted() && !"bye".equals( msg=s.getMessage()))
process(msg);
}
}
还有一件事让我感到惊讶，那就是您一次只支持一个连接。一般来说，最好不要对此进行限制，而是在自己的线程中处理消息。在这种情况下，您必须确保为连接创建的每个处理程序也被适当地关闭。如果您的包被告知停止，那么假设停止的人知道他在做什么。是的，你的协议期待着“再见”，但是狗屎发生了，任何与这些东西有问题的协议对于现实世界来说都太脆弱了。通常，OSGi中的所有任务都应该有一个生命周期。这就是我使用DS而不是激活器的代码
@Component
public class ProtocolServer extends Thread {
volatile ServerSocket server;
volatile Socket connection;
public ProtocolServer() {
super("Protocol Server on 4100"); // to identify the thread
}
@Activate void activate() {
setDaemon(true);
start();
}
@Deactivate void deactivate() {
interrupt();
// best effort close (even if null)
try { server.close(); } catch(Exception e) {}
try { connection.close(); } catch(Exception e) {}
join(10000); // waits 10 secs until thread exits
}
public void run() {
// loop for active component
while( !isInterrupted() )
try {
doServer();
} catch( Exception e) {
log(e);
// bad error, accept failed or bind failed
// or server socket was closed. If we should remain
// active, sleep to prevent overloading the
// system by trying too often, so sleep
if ( !isInterrupted() )
try { Thread.sleep(5000); } catch(Exception e) {}
}
}
private void doServer() throws Exception {
server = new ServerSocket(4100)
try {
while( !isInterrupted() )
doConnection(server);
} finally {
server.close();
}
}
private void doConnection(ServerSocket server) throws Exception {
connection = server.accept();
try {
doMessages(connection);
// the pseudo code exits here, but that seems
// kind of weird? If desired, interrupt
// this object, this will exit the thread
} catch( Exception e) {
log(e); // the connection failed, is not uncommon
} finally {
connection.close();
connection = null;
}
}
private void doMessages(Socket connection) {
MyScanner s = new MyScanner(socket);
String msg;
while( !isInterrupted() && !"bye".equals( msg=s.getMessage()))
process(msg);
}
}