1. import java.io.IOException;
  2. import java.net.URL;
  3. import java.util.logging.Logger;
  5. public class ResourceLoader {
  7. private static final Logger logger = Logger.getLogger(ResourceLoader.class.getName());
  9. /**
  10. * Loads resources from URLs provided as URL parameters.
  11. *
  12. * @param resourceUrls An array of URLs pointing to resources.
  13. * @return A map where keys are resource names (extracted from URL paths)
  14. * and values are the content of the resources as byte arrays.
  15. * Returns an empty map if no URLs are provided or if an error occurs.
  16. */
  17. public static java.util.Map<String, byte[]> loadResources(String[] resourceUrls) {
  18. java.util.Map<String, byte[]> resources = new java.util.HashMap<>();
  20. if (resourceUrls == null || resourceUrls.length == 0) {
  21. logger.info("No resource URLs provided. Returning empty map.");
  22. return resources;
  23. }
  25. for (String url : resourceUrls) {
  26. if (url == null || url.trim().isEmpty()) {
  27. logger.warning("Skipping null or empty URL.");
  28. continue;
  29. }
  31. try {
  32. URL resourceUrl = new URL(url);
  33. byte[] resourceBytes = fetchResource(resourceUrl);
  34. if (resourceBytes != null) {
  35. // Extract resource name from URL path
  36. String resourceName = extractResourceName(resourceUrl.getPath());
  37. resources.put(resourceName, resourceBytes);
  38. logger.info("Successfully loaded resource: " + resourceName + " from " + url);
  39. } else {
  40. logger.error("Failed to fetch resource from " + url);
  41. }
  42. } catch (IOException e) {
  43. logger.error("Error loading resource from " + url, e);
  44. }
  45. }
  47. return resources;
  48. }
  50. /**
  51. * Fetches the content of a resource from a URL.
  52. *
  53. * @param url The URL of the resource.
  54. * @return The content of the resource as a byte array, or null if an error occurs.
  55. * @throws IOException if an I/O error occurs during the fetch.
  56. */
  57. private static byte[] fetchResource(URL url) throws IOException {
  58. try (java.io.InputStream in = url.openStream();
  59. java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream()) {
  60. byte[] buffer = new byte[4096];
  61. int len;
  62. while ((len = in.read(buffer)) > 0) {
  63. out.write(buffer, 0, len);
  64. }
  65. return out.toByteArray();
  66. }
  67. }
  69. /**
  70. * Extracts the resource name from the URL path.
  71. *
  72. * @param path The URL path.
  73. * @return The extracted resource name.
  74. */
  75. private static String extractResourceName(String path) {
  76. String[] parts = path.split("/");
  77. if (parts.length > 1) {
  78. return parts[parts.length - 1];
  79. } else {
  80. return "unknown"; // Handle cases where the path is just the root
  81. }
  82. }
  84. public static void main(String[] args) {
  85. // Example usage
  86. String[] urls = {
  87. "https://www.example.com/image.jpg",
  88. "https://www.example.com/data.txt",
  89. "https://www.example.com/nonexistent.pdf",
  90. "invalid_url" //Example of an invalid url.
  91. };
  93. java.util.Map<String, byte[]> loadedResources = loadResources(urls);
  95. if (loadedResources != null) {
  96. for (java.util.Map.Entry<String, byte[]> entry : loadedResources.entrySet()) {
  97. System.out.println("Resource: " + entry.getKey() + ", Size: " + entry.getValue().length + " bytes");
  98. }
  99. }
  100. }
  101. }

Add your comment