1. import java.net.CookiePolicy;
  2. import java.net.http.HttpClient;
  3. import java.net.http.HttpRequest;
  4. import java.net.http.HttpResponse;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7. import java.util.concurrent.ConcurrentHashMap;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.ScheduledExecutorService;
  10. import java.util.concurrent.TimeUnit;
  12. public class CookieSessionParser {
  14. private static final int RETRY_INTERVAL = 5; // Seconds
  15. private static final int MAX_RETRIES = 3;
  17. private final HttpClient client = HttpClient.newHttpClient();
  18. private final ConcurrentHashMap<String, String> sessionCookies = new ConcurrentHashMap<>(); // Store session cookies, key = domain, value = cookie string
  19. private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  21. public static void main(String[] args) throws Exception {
  22. CookieSessionParser parser = new CookieSessionParser();
  23. // Example usage: Replace with your target URL.
  24. String targetUrl = "https://example.com";
  25. parser.parseSessionCookies(targetUrl);
  26. }
  28. public void parseSessionCookies(String targetUrl) {
  29. try {
  30. //Initial Cookie Retrieval
  31. String responseBody = getSessionCookies(targetUrl);
  32. if (responseBody != null) {
  33. parseCookiesFromResponse(responseBody);
  34. }
  35. } catch (Exception e) {
  36. System.err.println("Error during initial cookie retrieval: " + e.getMessage());
  37. }
  38. }
  41. private String getSessionCookies(String url) throws Exception {
  42. // Create an HTTP request
  43. HttpRequest request = HttpRequest.newBuilder()
  44. .uri(java.net.URI.create(url))
  45. .cookiePolicy(CookiePolicy.ACCEPT) // Accept all cookies
  46. .build();
  48. // Send the request and get the response
  49. HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  51. // Check for errors
  52. if (response.statusCode() >= 400) {
  53. System.err.println("Request failed with status code: " + response.statusCode());
  54. return null;
  55. }
  56. return response.body();
  57. }
  59. private void parseCookiesFromResponse(String responseBody) {
  60. // Extract cookies from the response body. This is a placeholder.
  61. // In a real application, you'd use a proper HTML parser (e.g., Jsoup)
  62. // to extract cookies. This is a simplified example.
  63. String[] cookies = responseBody.split("Cookie: ");
  64. if (cookies.length > 1) {
  65. String cookieString = cookies[1];
  66. String domain = extractDomain(cookieString);
  67. if (domain != null) {
  68. sessionCookies.put(domain, cookieString);
  69. System.out.println("Found cookies for domain: " + domain);
  71. }
  72. }
  73. }
  75. private String extractDomain(String cookieString) {
  76. // Simple domain extraction. Improve this for more robust parsing.
  77. int firstEqual = cookieString.indexOf('=');
  78. if (firstEqual != -1) {
  79. return cookieString.substring(0, firstEqual); // Extract domain part
  80. }
  81. return null;
  82. }
  84. public void scheduledCookieUpdate(String targetUrl) {
  85. scheduler.scheduleAtFixedRate(() -> {
  86. try {
  87. String responseBody = getSessionCookies(targetUrl);
  88. if (responseBody != null) {
  89. parseCookiesFromResponse(responseBody);
  90. }
  91. } catch (Exception e) {
  92. System.err.println("Error during cookie update: " + e.getMessage());
  93. }
  94. }, 0, RETRY_INTERVAL, TimeUnit.SECONDS);
  95. }
  98. public static void shutdown() {
  99. scheduler.shutdown();
  100. try {
  101. scheduler.awaitTermination(5, TimeUnit.SECONDS);
  102. } catch (InterruptedException e) {
  103. System.err.println("Interrupted while waiting for scheduler termination.");
  104. }
  105. }
  106. }

Add your comment