1. import java.sql.*;
  2. import java.util.ArrayList;
  3. import java.util.HashMap;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.concurrent.Executors;
  7. import java.util.concurrent.ScheduledExecutorService;
  8. import java.util.concurrent.TimeUnit;
  10. public class RecordWatcher {
  12. private static final String DB_URL = "your_database_url"; // Replace with your database URL
  13. private static final String DB_USER = "your_username"; // Replace with your username
  14. private static final String DB_PASSWORD = "your_password"; // Replace with your password
  15. private static final String TABLE_NAME = "your_table_name"; // Replace with your table name
  16. private static final String PRIMARY_KEY_COLUMN = "id"; // Replace with your primary key column
  18. private static List<Map<String, Object>> lastRecords; // Store the last known records
  19. private static final int CHECK_INTERVAL_SECONDS = 5; // Check every 5 seconds
  20. private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  22. public static void main(String[] args) {
  23. // Initialize the lastRecords list
  24. lastRecords = new ArrayList<>();
  26. // Start the scheduler
  27. scheduler.scheduleAtFixedRate(RecordWatcher::checkForChanges, 0, CHECK_INTERVAL_SECONDS, TimeUnit.SECONDS);
  28. }
  30. private static void checkForChanges() {
  31. try (Connection connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {
  32. // Get all records from the table
  33. String sql = "SELECT * FROM " + TABLE_NAME;
  34. try (ResultSet resultSet = connection.createStatement().executeQuery(sql)) {
  35. List<Map<String, Object>> currentRecords = new ArrayList<>();
  37. // Convert ResultSet to List of Maps
  38. while (resultSet.next()) {
  39. Map<String, Object> record = new HashMap<>();
  40. for (int i = 1; i <= resultSet.getPriorCount(); i++) {
  41. record.put(resultSet.getMetaData().getColumnName(i), resultSet.getObject(i));
  42. }
  43. currentRecords.add(record);
  44. }
  46. // Check for changes
  47. if (!currentRecords.equals(lastRecords)) {
  48. System.out.println("Changes detected!");
  49. // Process the changes here (e.g., log them, send notifications)
  50. processChanges(lastRecords, currentRecords);
  51. lastRecords = currentRecords; // Update lastRecords
  52. }
  53. } catch (SQLException e) {
  54. logError("Error accessing database: " + e.getMessage());
  55. }
  56. } catch (SQLException e) {
  57. logError("Error connecting to database: " + e.getMessage());
  58. }
  59. }
  61. private static void processChanges(List<Map<String, Object>> oldRecords, List<Map<String, Object>> newRecords) {
  62. // Example: Print the changes
  63. System.out.println("Old records size: " + oldRecords.size());
  64. System.out.println("New records size: " + newRecords.size());
  66. //Find added records
  67. List<Map<String, Object>> addedRecords = new ArrayList<>();
  68. for (Map<String, Object> record : newRecords) {
  69. if (!oldRecords.contains(record)) {
  70. addedRecords.add(record);
  71. }
  72. }
  73. if (addedRecords.size() > 0) {
  74. System.out.println("Added records:");
  75. for (Map<String, Object> record : addedRecords) {
  76. System.out.println(record);
  77. }
  78. }
  81. //Find removed records
  82. List<Map<String, Object>> removedRecords = new ArrayList<>();
  83. for (Map<String, Object> record : oldRecords) {
  84. if (!newRecords.contains(record)) {
  85. removedRecords.add(record);
  86. }
  87. }
  88. if (removedRecords.size() > 0) {
  89. System.out.println("Removed records:");
  90. for (Map<String, Object> record : removedRecords) {
  91. System.out.println(record);
  92. }
  93. }
  94. }
  96. private static void logError(String message) {
  97. System.err.println("Error: " + message);
  98. }
  99. }

Add your comment