1. import java.io.File;
  2. import java.util.HashMap;
  3. import java.util.Map;
  5. public class ResourceLoader {
  7. private final Map<String, String> resources = new HashMap<>();
  9. /**
  10. * Loads resources from directories based on optional flags.
  11. *
  12. * @param baseDir The base directory to start searching from.
  13. * @param flags Optional flags to enable/disable specific resource directories.
  14. */
  15. public void loadResources(String baseDir, String flags) {
  16. File dir = new File(baseDir);
  18. if (!dir.exists() || !dir.isDirectory()) {
  19. System.err.println("Error: Base directory does not exist or is not a directory: " + baseDir);
  20. return; //Or throw exception if appropriate
  21. }
  23. File[] files = dir.listFiles();
  24. if (files != null) {
  25. for (File file : files) {
  26. if (file.isDirectory()) {
  27. String dirName = file.getName();
  28. boolean include = true;
  30. // Check if the flag disables the directory
  31. if (flags != null && flags.contains("-" + dirName)) {
  32. include = false;
  33. }
  35. if (include) {
  36. loadResourcesFromDirectory(file);
  37. }
  38. }
  39. }
  40. }
  41. }
  44. private void loadResourcesFromDirectory(File directory) {
  45. File[] files = directory.listFiles();
  46. if (files != null) {
  47. for (File file : files) {
  48. if (file.isFile() && file.getName().endsWith(".properties")) { //Or other resource types
  49. String resourceName = file.getName().substring(0, file.getName().lastIndexOf(".")); //Remove extension
  50. try {
  51. loadProperties(file, resourceName);
  52. } catch (Exception e) {
  53. System.err.println("Error loading resource: " + resourceName + " - " + e.getMessage());
  54. }
  55. }
  56. }
  57. }
  58. }
  60. private void loadProperties(File file, String resourceName) {
  61. //Load properties from the file
  62. try {
  63. Map<String, String> properties = loadPropertiesFile(file);
  64. resources.put(resourceName, properties.toString());
  65. } catch (Exception e) {
  66. System.err.println("Error loading properties file: " + file.getName() + " - " + e.getMessage());
  67. }
  68. }
  70. private Map<String, String> loadPropertiesFile(File file) throws Exception {
  71. //Placeholder for loading the properties file.
  72. //Replace this with your actual properties loading logic.
  73. //For example using org.apache.commons.lang3.SystemUtils
  74. //This is just a dummy implementation
  75. Map<String, String> properties = new HashMap<>();
  76. properties.put("key1", "value1");
  77. properties.put("key2", "value2");
  78. return properties;
  79. }
  82. /**
  83. * Returns the loaded resources.
  84. *
  85. * @return A map of resource names to their content.
  86. */
  87. public Map<String, String> getResources() {
  88. return resources;
  89. }
  91. public static void main(String[] args) {
  92. ResourceLoader loader = new ResourceLoader();
  94. // Example usage:
  95. // Assuming you have directories 'default', 'optional1', 'optional2'
  96. // and properties files in each directory.
  97. // You can specify flags like "-optional1 -optional2" to enable specific directories.
  99. loader.loadResources("resources", "-optional1"); //Load resources from "resources" directory, excluding "optional1"
  100. Map<String, String> loadedResources = loader.getResources();
  101. System.out.println(loadedResources);
  102. }
  103. }

Add your comment