java如何获取目标服务器时间

不及物动词 1年前其他 84

共3条回复我来回复

worktile

Worktile官方账号

要获取目标服务器的时间，可以使用Java中的一些内置类和方法。下面是几种获取目标服务器时间的常见方法：

使用Java中的Date类和SimpleDateFormat类：

import java.text.SimpleDateFormat;
import java.util.Date;

public class ServerTime {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        try {
            // 获取目标服务器的时间戳
            long timestamp = System.currentTimeMillis();
            
            // 将时间戳转换为日期格式
            Date serverTime = new Date(timestamp);
            
            // 格式化日期
            String formattedTime = sdf.format(serverTime);
            
            System.out.println("目标服务器时间：" + formattedTime);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

该方法使用System.currentTimeMillis()方法获取当前系统时间戳，然后将时间戳转换为日期格式，并使用SimpleDateFormat将日期格式化为所需的格式。

使用Java中的URLConnection类和HttpURLConnection类发送HTTP请求：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class ServerTime {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://目标服务器地址"); // 替换为目标服务器的URL
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            // 解析服务器返回的时间数据
            // ...

            System.out.println("目标服务器时间：" + serverTime);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

该方法使用URL和HttpURLConnection类发送HTTP请求到目标服务器的URL，获取服务器返回的时间数据，然后解析时间数据以获取目标服务器的时间。

使用第三方库，如Apache HttpClient库：

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

public class ServerTime {
    public static void main(String[] args) {
        try {
            HttpClient httpClient = HttpClientBuilder.create().build();
            HttpGet httpGet = new HttpGet("http://目标服务器地址"); // 替换为目标服务器的URL
            HttpResponse response = httpClient.execute(httpGet);

            // 获取服务器返回的时间数据
            String responseString = EntityUtils.toString(response.getEntity());
            
            // 解析服务器返回的时间数据
            // ...

            System.out.println("目标服务器时间：" + serverTime);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

该方法使用Apache HttpClient库发送HTTP请求以获取服务器返回的时间数据，并解析时间数据以获取目标服务器的时间。

使用NTP协议获取时间：

import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;

import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;

public class ServerTime {
    public static void main(String[] args) {
        final String TIME_SERVER = "ntp3.aliyun.com"; // 替换为目标NTP服务器地址
        
        NTPUDPClient timeClient = new NTPUDPClient();
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getByName(TIME_SERVER);
            TimeInfo timeInfo = timeClient.getTime(inetAddress);
            long returnTime = timeInfo.getMessage().getTransmitTimeStamp().getTime();
            Date serverTime = new Date(returnTime);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String formattedTime = sdf.format(serverTime);
            
            System.out.println("目标服务器时间：" + formattedTime);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

该方法使用Apache Commons Net库中的NTPUDPClient类来获取NTP服务器的时间信息，并将其转换为Java的Date对象，然后格式化为所需的日期格式。

请注意，在使用上述方法之前，需要替换为实际的目标服务器地址或NTP服务器地址。此外，可能还需要处理异常和解析返回的时间数据，以适应不同服务器的返回格式。

1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

在Java中获取目标服务器的时间可以通过以下几种方式实现：

使用Java的内置库，如java.util.Date和java.util.Calendar来获取本地机器的时间，然后通过网络请求获取目标服务器的时间差，并进行相应的计算。这种方法需要注意本地机器和目标服务器的时间同步性。

示例代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ServerTime {
    public static void main(String[] args) {
        // 获取目标服务器时间
        String serverTime = getServerTime("http://example.com");

        // 解析服务器时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = sdf.parse(serverTime);
            System.out.println("Server Time: " + date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    private static String getServerTime(String url) {
        String serverTime = "";
        try {
            // 发送HTTP请求
            URLConnection conn = new URL(url).openConnection();
            conn.connect();

            // 获取服务器时间头字段
            long serverTimestamp = conn.getDate();

            // 转换为字符串格式
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            serverTime = sdf.format(new Date(serverTimestamp));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return serverTime;
    }
}

通过网络请求获取目标服务器的时间戳，然后转换成日期格式。这种方法需要与目标服务器进行通信。

示例代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimeZone;

public class ServerTime {
    public static void main(String[] args) {
        // 获取目标服务器时间戳
        long serverTimestamp = getServerTimestamp("http://example.com");

        // 转换为日期格式
        Date date = new Date(serverTimestamp);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.setTimeZone(TimeZone.getTimeZone("GMT+8")); // 设置时区
        String serverTime = sdf.format(date);

        System.out.println("Server Time: " + serverTime);
    }

    private static long getServerTimestamp(String urlStr) {
        long serverTimestamp = 0;
        try {
            // 发送HTTP请求
            URL url = new URL(urlStr);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("HEAD");
            conn.connect();

            // 获取服务器时间戳
            serverTimestamp = conn.getHeaderFieldDate("Date", 0);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return serverTimestamp;
    }
}

使用第三方时间同步服务，如NTP（网络时间协议）服务器。通过Java的相关库，如org.apache.commons.net.ntp.NTPUDPClient来与NTP服务器进行通信，并获取目标服务器的时间。

示例代码：

import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;

import java.net.InetAddress;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ServerTime {
    public static void main(String[] args) {
        NTPUDPClient client = new NTPUDPClient();
        try {
            // 设置NTP服务器地址
            InetAddress address = InetAddress.getByName("ntp.example.com");

            // 获取时间信息
            TimeInfo timeInfo = client.getTime(address);

            // 获取服务器时间戳
            long serverTimestamp = timeInfo.getReturnTime();

            // 转换为日期格式
            Date date = new Date(serverTimestamp);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String serverTime = sdf.format(date);

            System.out.println("Server Time: " + serverTime);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

以上是三种常用的方法，可以根据具体的需求和场景选择合适的方法来获取目标服务器的时间。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

要获取目标服务器的时间，可以使用以下方法：

使用NTP协议获取时间：NTP（Network Time Protocol）是一种用于同步网络中计算机时间的协议。Java中提供了Joda-Time库和NTP服务器，可以使用下面的代码获取目标服务器的时间：

import org.joda.time.DateTime;
import org.joda.time.DateTimeZone;
import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;

public class NTPTime {
    public static void main(String[] args) {
        String ntpServer = "ntp1.aliyun.com"; // NTP服务器地址
        
        try {
            NTPUDPClient client = new NTPUDPClient();
            client.open();

            TimeInfo timeInfo = client.getTime(InetAddress.getByName(ntpServer));
            DateTime dateTime = new DateTime(timeInfo.getMessage().getTransmitTimeStamp().getTime());

            System.out.println(dateTime);

            client.close();

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

使用HTTP请求获取目标服务器的时间：可以使用Java的网络请求库，如Apache HttpClient或OkHttp，通过向服务器发送HTTP请求，获取响应头中的"Date"字段，即可获取服务器的时间。

Apache HttpClient示例代码：

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import java.text.SimpleDateFormat;
import java.util.Date;

public class HttpTime {
    public static void main(String[] args) {
        String serverUrl = "http://your.server.com"; // 服务器地址

        try {
            HttpClient client = HttpClientBuilder.create().build();
            HttpGet request = new HttpGet(serverUrl);
            HttpResponse response = client.execute(request);

            String dateHeader = response.getFirstHeader("Date").getValue();
            Date date = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss zzz").parse(dateHeader);
            System.out.println(date);

            // 如果服务器使用的是GMT时间，可以设置时区进行转换
            // SimpleDateFormat dateFormat = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss zzz");
            // dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
            // Date date = dateFormat.parse(dateHeader);

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

使用SSH远程命令获取目标服务器的时间：如果你能够通过SSH登录到目标服务器，可以使用Java的SSH库，如JSch，通过执行远程命令获取服务器的时间。

JSch示例代码：

import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

public class SSHTime {
    public static void main(String[] args) {
        String sshHost = "your.ssh.server.com"; // SSH服务器地址
        String sshUser = "your_ssh_username"; // SSH登录用户名
        String sshPassword = "your_ssh_password"; // SSH登录密码

        try {
            JSch jsch = new JSch();
            Session session = jsch.getSession(sshUser, sshHost, 22);
            session.setPassword(sshPassword);
            session.setConfig("StrictHostKeyChecking", "no");
            session.connect();

            ChannelExec channel = (ChannelExec) session.openChannel("exec");
            channel.setCommand("date"); // 获取服务器时间的命令
            channel.connect();

            InputStream inputStream = channel.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            String time = reader.readLine();
            System.out.println(time);

            channel.disconnect();
            session.disconnect();

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

通过以上几种方法，你可以获取目标服务器的时间。你可以根据实际情况选择合适的方法。

1年前 0条评论