tried to load poster imgs via backend server

Author: Aakkiieezz

notes - keywords fetched.txt

@@ -18,14 +18,9 @@ movie 926391
 movie 927208
 movie 939342
 movie 1174218
-tv 135670
 
 SELECT childtype, tmdb_id, title, original_title FROM servie
 WHERE (childtype = 'movie' AND tmdb_id IN (19263,34384,277090,327796,499466,532805,568672,631969,827669,836529,861345,912502,926390,926391,927208,939342,1174218))
-    OR (childtype = 'tv' AND tmdb_id = 135670);
-
-
-to delete dhindora - 135670, 274593
 
 239/2266 -> 0 counts
 

notes - posterImg quck loading.txt

@@ -0,0 +1,25 @@
+Whether serving the images locally from your backend will be faster depends on several factors, including the speed of the external server from which the images are being fetched, the network latency, and the optimization of your backend server. Here's a breakdown to help you decide:
+
+1. External Server Latency:
+If the images are hosted on a third-party server, there's a chance that the latency of fetching the images from that server could be contributing to the delay. The time it takes for your frontend to make a request and receive a response can be significant, especially if the images are large or if the server is geographically distant.
+By downloading the images and serving them from your backend, you bypass this external latency, and the frontend would load the images directly from your server, reducing the round-trip time.
+2. Local Server Performance:
+Your backend server will likely be closer to your React application (especially if both are running in the same data center or cloud region), which can reduce network latency compared to fetching images from an external server.
+However, the backend's ability to serve static files (like images) quickly depends on its hardware and how well your static file serving is configured. If the images are served through an optimized static file server or CDN (Content Delivery Network), it can be faster than downloading them one by one from an external source.
+3. Caching Mechanism:
+One of the most significant advantages of serving images locally is the ability to cache them both on your backend and on the client side. For instance, if you serve the images via a CDN or use proper caching headers, browsers can cache images, reducing the load time on subsequent requests.
+If you download the images once and serve them locally, the first load might take some time (depending on the size and number of images), but subsequent loads of the same images will be much faster due to caching.
+4. Image Optimization:
+Ensure the images are optimized before serving them. For example, you can compress the images, convert them to modern formats like WebP, or resize them to reduce their file size. This can significantly reduce the time it takes to load the images.
+5. Asynchronous Loading:
+Even if serving from the backend is faster, consider implementing asynchronous loading or lazy loading of images on the frontend. This way, images load progressively as the user scrolls down the page, making the experience feel faster.
+Will It Be Faster?
+If the external server has a high latency or is slow to serve the images, serving them from your backend could be significantly faster.
+However, if the external server is already fast and the bottleneck is elsewhere (e.g., image size or frontend rendering), serving the images locally may not result in a dramatic improvement.
+The first load will likely take longer because of the image download process, but once the images are cached locally on your backend and/or on the client, subsequent loads will be faster.
+Recommendation:
+Benchmark: Run some performance tests to compare the time taken to load images from the external source vs. serving them locally.
+Use a CDN: If possible, use a CDN to serve the images. A CDN will cache the images closer to the user's location, drastically reducing load times.
+Optimize Images: Compress and optimize the images to reduce their size, which will improve load times, whether they're served from an external server or your backend.
+Lazy Loading: Implement lazy loading on the frontend to only load images when they enter the viewport.
+By combining these strategies, you should be able to achieve a noticeable improvement in image load times.

src/main/java/servie/track_servie/config/ApiSecurity.java

@@ -32,7 +32,9 @@ public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Excepti
 						"/track-servie/auth/login",
 						"/track-servie/react/**", // temporarily
 						"/track-servie/user/image/**",
-						"/profilePics/**")
+						"/profilePics/**",
+						"/posterImgs/**",
+						"/staticPosterImgs/**")
 						.permitAll()
 						.anyRequest()
 						.authenticated())

src/main/java/servie/track_servie/config/WebConfig.java

@@ -23,5 +23,9 @@ public void addResourceHandlers(ResourceHandlerRegistry registry)
 	{
 		registry.addResourceHandler("/profilePics/**")
 				.addResourceLocations("file:/home/aakkiieezz/Coding/track_servie/profilePics/");
+		// registry.addResourceHandler("/posterImgs/**")
+		// 		.addResourceLocations("file:/home/aakkiieezz/Coding/track_servie/posterImgs/");
+		registry.addResourceHandler("/staticPosterImgs/**")
+				.addResourceLocations("classpath:/static/staticPosterImgs/");
 	}
 }

src/main/java/servie/track_servie/service/ImageService.java

@@ -1,5 +1,7 @@
 package servie.track_servie.service;
 
+import java.io.InputStream;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -8,6 +10,7 @@
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.HttpClientErrorException;
 import org.springframework.web.client.RestTemplate;
@@ -21,6 +24,11 @@
 import servie.track_servie.exceptions.TmdbApiException;
 import servie.track_servie.payload.dtos.TmdbError;
 import servie.track_servie.repository.ServieRepository;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
 
 @Service
 public class ImageService
@@ -31,6 +39,7 @@ public class ImageService
 	private RestTemplate restTemplate;
 	@Value("${tmdb.api.base-url}")
 	private String tmdbApiBaseUrl;
+	private static final String directoryPosterImgs = "/home/aakkiieezz/Coding/track_servie/posterImgs/";
 	// private HttpHeaders headers = new HttpHeaders();
 	// private HttpEntity<?> httpEntity = new HttpEntity<>(headers, (MultiValueMap<String, String>) null);
 
@@ -136,6 +145,47 @@ public TmdbImageDto getImages(Integer tmdbId, String childType) throws JsonProce
 			throw new RuntimeException("Failed to fetch data from TMDB", e);
 		}
 	}
+
+	// @Scheduled(fixedRate = Integer.MAX_VALUE)
+	public void downloadImages()
+	{
+		List<String> imageUrls = servieRepository.findAll().stream()
+				.map(s -> s.getPosterPath())
+				.toList();
+		Path outputDirectory = Path.of(directoryPosterImgs);
+		try
+		{
+			Files.createDirectories(outputDirectory);
+			for(String imageUrl : imageUrls)
+				downloadImage("https://image.tmdb.org/t/p/original"+imageUrl, outputDirectory);
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+
+	private void downloadImage(String imageUrl, Path outputDirectory)
+	{
+		try
+		{
+			ResponseEntity<byte[]> response = restTemplate.getForEntity(imageUrl, byte[].class);
+			if(response.getStatusCode().is2xxSuccessful() && response.getBody()!=null)
+			{
+				String fileName = Path.of(imageUrl).getFileName().toString();
+				Path outputPath = outputDirectory.resolve(fileName);
+				Files.write(outputPath, response.getBody());
+				System.out.println("Downloaded: "+fileName);
+			}
+			else
+				System.err.println("Failed to download: "+imageUrl+" (HTTP "+response.getStatusCode()+")");
+		}
+		catch(Exception e)
+		{
+			System.err.println("Error downloading image: "+imageUrl);
+			e.printStackTrace();
+		}
+	}
 }
 // https://api.themoviedb.org/3/movie/11/images
 // https://api.themoviedb.org/3/movie/{movie_id}/images