如果服务器打开，Java会自动连接到该服务器
我正在尝试创建一个程序，该程序将确定服务器是否已连接、关闭或断开连接。 我需要使客户端在服务器打开时自动连接到服务器 问题:如果服务器打开，Java会自动连接到该服务器,java,sockets,network-programming,Java,Sockets,Network Programming,我正在尝试创建一个程序，该程序将确定服务器是否已连接、关闭或断开连接。 我需要使客户端在服务器打开时自动连接到服务器 问题: 1。如何持续ping服务器以确定服务器是否已启动？ 2。为什么单击按钮时服务器只能接收一次。 3。确定服务器何时断开连接 这是我的密码： 服务器 public Server() { super("Server"); server.setLayout(new BorderLayout()); main.setLa
1。如何持续ping服务器以确定服务器是否已启动？2。为什么单击按钮时服务器只能接收一次。3。确定服务器何时断开连接 public Server()
{
super("Server");
server.setLayout(new BorderLayout());
main.setLayout(new BorderLayout());
top.setLayout(new BorderLayout());
bot.setLayout(new BorderLayout());
console.setEditable(false);
console.setFont(new Font("Courier New",Font.PLAIN,14));
console.setBackground(Color.BLACK);
console.setForeground(Color.WHITE);
bot.add(console);
top.add(btnReply,BorderLayout.EAST);
top.add(queryline,BorderLayout.CENTER);
main.add(top,BorderLayout.NORTH);
main.add(bot,BorderLayout.CENTER);
add(main);
}
private void runServer() throws IOException
{
int port = 25000;
ServerSocket serverSocket = new ServerSocket(port);
console.setText("Server is Up and listening to the port: "+port+"\n");
System.out.println("Server is Up and listening to the port: "+port+"\n");
while(true)
{
Thread thread = new Thread(new Handler(socket));
thread.start();
}
}
public static void main(String args[])
{
Server f=new Server();
f.setVisible(true);
f.setExtendedState(JFrame.MAXIMIZED_BOTH);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try
{
f.runServer();
}catch(IOException ex)
{
//JOptionPane.showMessageDialog(null,ex.getMessage());
}
}
@Override
public void actionPerformed(ActionEvent e)
{
}
}
class Handler implements Runnable
{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run()
{
// You may need to add a repeat and exit clause here...
Server f=new Server();
try
{
InputStreamReader ir = new InputStreamReader(socket.getInputStream());
BufferedReader br = new BufferedReader(ir);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
f.console.append(received[1]+": requesting for "+received[0]+"\n");
System.out.println(received[1]+": requesting for "+received[0]+"\n");
}catch(IOException ex)
{
ex.printStackTrace();
}
}
}
public class Branch extends JFrame
{
private static Socket socket;
JPanel main=new JPanel();
JPanel top=new JPanel();
JPanel bot=new JPanel();
JButton btnItem=new JButton("item");
JButton btnGlstock=new JButton("glstock");
JTextArea console=new JTextArea();
JScrollPane scrollv=new JScrollPane(console);
ActionListener item=new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
String ip="";
String send="";
try
{
ip=InetAddress.getLocalHost().getHostAddress();
send="item~"+ip;
request(send);
}catch(Exception ex)
{
JOptionPane.showMessageDialog(null,ex.getMessage());
}
}
};
ActionListener glstock=new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
String ip="";
String send="";
try
{
ip=InetAddress.getLocalHost().getHostAddress();
send="glstock~"+ip;
request(send);
}catch(Exception ex)
{
JOptionPane.showMessageDialog(null,ex.getMessage());
}
}
};
private void request(String send)
{
try
{
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
bw.write(send+"\n");
bw.flush();
}catch(Exception ex)
{
ex.printStackTrace();
}
}
public Branch()
{
super("Branch");
scrollv.setAutoscrolls(true);
main.setLayout(new BorderLayout());
top.setLayout(new FlowLayout());
top.add(btnItem);
top.add(btnGlstock);
btnItem.addActionListener(item);
btnGlstock.addActionListener(glstock);
bot.setLayout(new BorderLayout());
console.setEditable(false);
console.setForeground(Color.white);
console.setBackground(Color.black);
bot.add(scrollv,BorderLayout.CENTER);
main.add(top,BorderLayout.NORTH);
main.add(bot,BorderLayout.CENTER);
add(main);
}
private void connect2Server() throws IOException
{
Timer timer=new Timer(5000,checkPing);
try
{
socket = new Socket(IP,port);
console.append("You are now Connected to the Server\r\n");
//timer.start();
socket.setSoTimeout(5000);
InputStreamReader isr=new InputStreamReader(socket.getInputStream());
isr.read();
}
catch(SocketTimeoutException ex)
{
ex.printStackTrace();
}
catch(IOException ex)
{
console.append("Server is offline\r\n");
ex.printStackTrace();
}
connect2Server();
}
public static void main(String args[])
{
Branch frame=new Branch();
frame.setVisible(true);
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.connect2Server();
frame.connectDatabase();
}
}
while(true)
{
//^Reading the message from the client
// Wait for a NEW client connection
socket = serverSocket.accept();
// Process request...
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
console.append(received[1]+": requesting for "+received[0]+"\n");
// ... No longer monitoring for new content...
}
serverSocket.accept（）正在等待新的客户端连接，而不是监视现有连接
您应该做的是生成某种类型的线程
，将引用传递给客户机套接字
连接，并在其自己的循环中处理它…提供超时或可能的退出条件，以便套接字和线程可以关闭
确定服务器何时断开连接
基本上，如果您尝试向服务器（或客户机）发送某些内容，它将抛出某种类型的异常
，这很好地表明连接由于某种原因已断开
您还可以使用某种计时器定期向服务器发送“健康”检查消息，但是，您需要确保正在同步通信，这样两个（客户端）线程就不会同时尝试发送消息
旁注
发送消息时，当前代码将阻止事件调度线程。当您在本地进行测试时，这可能不是一件大事，但是，根据连接的速度和服务器及时响应的能力，可能会导致您的UI出现“冻结”一两秒钟（或更长时间）
请查看以了解更多详细信息
用示例更新
为了使您的服务器能够处理多个客户端连接，您需要为每个新连接生成一个新线程，例如
private void runServer() throws IOException
{
int port = 25000;
ServerSocket serverSocket = new ServerSocket(port);
console.setText("Server is Up and listening to the port: "+port+"\n");
System.out.println("Server is Up and listening to the port: "+port+"\n");
while(true)
{
Socket socket = serverSocket.accept();
Thread thread = new Thread(new Handler(socket));
thread.start();
}
}
class Handler implements Runnable
{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run()
{
// You may need to add a repeat and exit clause here...
try
{
boolean keepRunning = true;
while (keepRunning) {
InputStreamReader ir = new InputStreamReader(socket.getInputStream());
BufferedReader br = new BufferedReader(ir);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
System.out.println(received[1]+": requesting for "+received[0]+"\n");
// Check for a valid "exit" state and change keepRunning
// if the client want's to disconnect...
}
}catch(IOException ex)
{
ex.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (Exception exp) {
}
}
}
}
然后在“客户端套接字处理程序”中，您需要设置一个循环，该循环将一直从客户端套接字读取数据，直到出现错误或客户端请求终止通信，例如
private void runServer() throws IOException
{
int port = 25000;
ServerSocket serverSocket = new ServerSocket(port);
console.setText("Server is Up and listening to the port: "+port+"\n");
System.out.println("Server is Up and listening to the port: "+port+"\n");
while(true)
{
Socket socket = serverSocket.accept();
Thread thread = new Thread(new Handler(socket));
thread.start();
}
}
class Handler implements Runnable
{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run()
{
// You may need to add a repeat and exit clause here...
try
{
boolean keepRunning = true;
while (keepRunning) {
InputStreamReader ir = new InputStreamReader(socket.getInputStream());
BufferedReader br = new BufferedReader(ir);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
System.out.println(received[1]+": requesting for "+received[0]+"\n");
// Check for a valid "exit" state and change keepRunning
// if the client want's to disconnect...
}
}catch(IOException ex)
{
ex.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (Exception exp) {
}
}
}
}
另外，请确保正确关闭资源；）
如何持续ping服务器以确定服务器是否已启动
使用某种计时器来安排一次常规回调，并在那里进行测试。ping服务器（在此上下文中）可以简单地尝试与之建立连接
你也可以用
为什么当我点击按钮时服务器只能接收一次
因为服务器不再处理您的连接。看看你的服务器代码
while(true)
{
//^Reading the message from the client
// Wait for a NEW client connection
socket = serverSocket.accept();
// Process request...
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
console.append(received[1]+": requesting for "+received[0]+"\n");
// ... No longer monitoring for new content...
}
serverSocket.accept（）正在等待新的客户端连接，而不是监视现有连接
您应该做的是生成某种类型的线程
，将引用传递给客户机套接字
连接，并在其自己的循环中处理它…提供超时或可能的退出条件，以便套接字和线程可以关闭
确定服务器何时断开连接
基本上，如果您尝试向服务器（或客户机）发送某些内容，它将抛出某种类型的异常
，这很好地表明连接由于某种原因已断开
您还可以使用某种计时器定期向服务器发送“健康”检查消息，但是，您需要确保正在同步通信，这样两个（客户端）线程就不会同时尝试发送消息
旁注
发送消息时，当前代码将阻止事件调度线程。当您在本地进行测试时，这可能不是一件大事，但是，根据连接的速度和服务器及时响应的能力，可能会导致您的UI出现“冻结”一两秒钟（或更长时间）
请查看以了解更多详细信息
用示例更新
为了使您的服务器能够处理多个客户端连接，您需要为每个新连接生成一个新线程，例如
private void runServer() throws IOException
{
int port = 25000;
ServerSocket serverSocket = new ServerSocket(port);
console.setText("Server is Up and listening to the port: "+port+"\n");
System.out.println("Server is Up and listening to the port: "+port+"\n");
while(true)
{
Socket socket = serverSocket.accept();
Thread thread = new Thread(new Handler(socket));
thread.start();
}
}
class Handler implements Runnable
{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run()
{
// You may need to add a repeat and exit clause here...
try
{
boolean keepRunning = true;
while (keepRunning) {
InputStreamReader ir = new InputStreamReader(socket.getInputStream());
BufferedReader br = new BufferedReader(ir);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
System.out.println(received[1]+": requesting for "+received[0]+"\n");
// Check for a valid "exit" state and change keepRunning
// if the client want's to disconnect...
}
}catch(IOException ex)
{
ex.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (Exception exp) {
}
}
}
}
然后在“客户端套接字处理程序”中，您需要设置一个循环，该循环将一直从客户端套接字读取数据，直到出现错误或客户端请求终止通信，例如
private void runServer() throws IOException
{
int port = 25000;
ServerSocket serverSocket = new ServerSocket(port);
console.setText("Server is Up and listening to the port: "+port+"\n");
System.out.println("Server is Up and listening to the port: "+port+"\n");
while(true)
{
Socket socket = serverSocket.accept();
Thread thread = new Thread(new Handler(socket));
thread.start();
}
}
class Handler implements Runnable
{
private Socket socket;
public Handler(Socket socket){
this.socket = socket;
}
public void run()
{
// You may need to add a repeat and exit clause here...
try
{
boolean keepRunning = true;
while (keepRunning) {
InputStreamReader ir = new InputStreamReader(socket.getInputStream());
BufferedReader br = new BufferedReader(ir);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
System.out.println(received[1]+": requesting for "+received[0]+"\n");
// Check for a valid "exit" state and change keepRunning
// if the client want's to disconnect...
}
}catch(IOException ex)
{
ex.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (Exception exp) {
}
}
}
}
另外，请确保正确关闭资源；）
如何持续ping服务器以确定服务器是否已启动
使用某种计时器来安排一次常规回调，并在那里进行测试。ping服务器（在此上下文中）可以简单地尝试与之建立连接
你也可以用
为什么当我点击按钮时服务器只能接收一次
因为服务器不再处理您的连接。看看你的服务器代码
while(true)
{
//^Reading the message from the client
// Wait for a NEW client connection
socket = serverSocket.accept();
// Process request...
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String message = br.readLine();
System.out.println(message);
String[] received=message.split("~");
console.append(received[1]+": requesting for "+received[0]+"\n");
// ... No longer monitoring for new content...
}
serverSocket.accept（）正在等待新的客户端连接，而不是监视现有连接
您应该做的是生成某种类型的线程
，将引用传递给客户机套接字
连接，并在其自己的循环中处理它…提供