Java >> Java opplæring >  >> Tag >> Spring

Spring Boot og AWS S3:Last opp fil

Spring

Velkommen lesere, i denne opplæringen vil vi vise hvordan du laster opp en fil til en AWS S3-bøtte ved hjelp av springboot-rammeverket.

1. Introduksjon

  • Spring boot er en modul som gir rask applikasjonsutviklingsfunksjon til fjærrammeverket, inkludert autokonfigurasjon , frittstående kode , og produksjonsklar kode
  • Den lager programmer som er pakket som jar og startes direkte ved hjelp av innebygd servletbeholder (som Tomcat, Jetty eller Undertow). Dermed er det ikke nødvendig å distribuere krigen filer
  • Det forenkler maven-konfigurasjonen ved å tilby startmalen og hjelper til med å løse avhengighetskonfliktene. Den identifiserer automatisk de nødvendige avhengighetene og importerer dem i applikasjonen
  • Det hjelper med å fjerne kjelekoden, ekstra merknader og XML-konfigurasjoner
  • Den gir en kraftig batchbehandling og administrerer resten av endepunktene
  • Det gir et effektivt jpa-starter-bibliotek for å effektivt koble applikasjonen med relasjonsdatabasene
  • Den tilbyr en mikrotjenestearkitektur og skykonfigurasjon som administrerer alle applikasjonsrelaterte konfigurasjonsegenskaper på en sentralisert måte

1.1 AWS-lagringstjeneste

AWS Storage Service eller ganske enkelt kjent som AWS S3 er et online lagringsanlegg for brukerne. Det er billig, enkelt å sette opp og brukeren betaler kun for det de bruker. Det tilbyr,

  • For å være vert for statisk nettinnhold og data eller til og med dynamiske sider
  • Datalagring for analyse
  • Sikkerhetskopiering og arkivering av data
  • Løsninger for katastrofegjenoppretting

1.1.1 S3-bøtte

Amazon S3-bøtte har to primære enheter, dvs. objekt og bøtte, der objekter er lagret inne i bøttene. Det gir løsninger med høy tilgjengelighet og holdbarhet ved å replikere dataene fra én bøtte i flere datasentre. Hver AWS-konto tilbyr 100 bøtter som gratis, men dette tallet kan økes ved å sende inn en forespørsel til støttesenteret. Amazon S3 funksjoner –

  • Hvert objekt i en bøtte får en unik ID
  • S3 lar en utvikler laste opp/slette eller lese et objekt via REST API
  • S3 tilbyr to les-etter-skrive- og eventuell konsistensmodeller for å sikre at hver endringskommando som er forpliktet til et system skal være synlig for alle deltakerne
  • Objekter lagret i en bøtte forlater aldri sin plassering med mindre brukeren overfører den
  • Objekter kan gjøres private eller offentlige og rettigheter kan gis til spesifikke brukere

1.1.2 Konfigurere AWS S3-bøtte og IAM-bruker

Hvis noen trenger å gå gjennom prosessen med å lage en S3-bøtte og koble den til en IAM-bruker, vennligst se denne videoen.

For å starte med denne opplæringen, håper vi at brukere for øyeblikket har sin AWS-konto opprettet og vet hvordan de setter opp en S3-bøtte og kobler den til en IAM-bruker etter eget valg.

2. Spring boot og AWS S3:Last opp fil

Her er en systematisk veiledning for implementering av denne opplæringen.

2.1 Søknadskrav

For å laste opp en fil på S3 via spring boot-applikasjonen, må brukerne sørge for at de har opprettet en S3-bøtte og den tilsvarende IAM-brukeren. For denne opplæringen vil vi bruke følgende –

  • S3-bøtte – assignment-s3-bucket
  • IAM-bruker – some_public_user
  • Andre detaljer som AWS Access ID , AWS hemmelig nøkkel , og S3 Bucket Region er skjult av sikkerhetshensyn

2.2 Brukte verktøy

Vi bruker Eclipse, JDK 8.x, Maven og AWS S3.

2.3 Prosjektstruktur

I tilfelle du er forvirret om hvor du bør opprette de tilsvarende filene eller mappen, la oss se gjennom prosjektstrukturen til våroppstartsapplikasjonen.

La oss begynne å bygge applikasjonen!

3. Opprette en Spring Boot-applikasjon

Nedenfor er trinnene involvert i utviklingen av applikasjonen.

3.1 Maven Dependency

Her spesifiserer vi avhengigheten for fjærstøvelen og AWS S3 SDK. Maven vil automatisk løse de andre avhengighetene. Den oppdaterte filen vil ha følgende kode.

pom.xml 

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.jcg.springboot.aws.s3</groupId>
	<artifactId>SpringbootS3tutorial</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<name>Springboot and AWS S3 tutorial</name>
	<description>A tutorial to illustrate the springboot and aws s3 interactions</description>

	<properties>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.source>${maven.compiler.target}</maven.compiler.source>
		<aws-java-sdk.version>1.11.750</aws-java-sdk.version>
	</properties>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.5.RELEASE</version>
	</parent>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Aws dependency. -->
		<dependency>
			<groupId>com.amazonaws</groupId>
			<artifactId>aws-java-sdk</artifactId>
			<version>${aws-java-sdk.version}</version>
		</dependency>
	</dependencies>

	<build>
		<finalName>SpringbootS3tutorial</finalName>
		<!-- To make spring boot as a fat jar so that all required jar files and 
			main file is added for running the code from Docker. -->
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

3.2 Applikasjonsegenskaper

Opprett en ny egenskapsfil på stedet:SpringbootS3tutorial/src/main/resources/ og legg til følgende kode til den.

application.properties 

# Application server port
server.port=9098
# AWS S3 configuration
aws.access_key_id=<aws_access_key_id>
aws.secret_access_key=<aws_secret_access_key>
aws.s3.bucket=<s3_bucket>
aws.s3.region=<s3_region>

3.3 Java-klasser

La oss skrive alle java-klassene som er involvert i denne applikasjonen.

3.3.1 Konfigurasjonsklasse

Opprett en konfigurasjonsklasse i org.jcg.springboot.aws.s3.config pakken og legg til følgende kode til den. Denne klassen er ansvarlig for å kommunisere med AWS S3 og gi en AmazonS3 objekt for videre interaksjoner.

AWSS3Config.java 

package org.jcg.springboot.aws.s3.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;

@Configuration
public class AWSS3Config {

	// Access key id will be read from the application.properties file during the application intialization.
	@Value("${aws.access_key_id}")
	private String accessKeyId;
	// Secret access key will be read from the application.properties file during the application intialization.
	@Value("${aws.secret_access_key}")
	private String secretAccessKey;
	// Region will be read from the application.properties file  during the application intialization.
	@Value("${aws.s3.region}")
	private String region;

	@Bean
	public AmazonS3 getAmazonS3Cient() {
		final BasicAWSCredentials basicAWSCredentials = new BasicAWSCredentials(accessKeyId, secretAccessKey);
		// Get AmazonS3 client and return the s3Client object.
		return AmazonS3ClientBuilder
				.standard()
				.withRegion(Regions.fromName(region))
				.withCredentials(new AWSStaticCredentialsProvider(basicAWSCredentials))
				.build();
	}
}

3.3.2 Tjenesteklasse

Opprett en tjenesteklasse i org.jcg.springboot.aws.s3.serv pakken og legg til følgende kode til den. Denne klassen består av en metode som er ansvarlig for å laste opp filen til S3-bøtten.

AWSS3ServiceImpl.java 

package org.jcg.springboot.aws.s3.serv;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.time.LocalDateTime;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.PutObjectRequest;

@Service
public class AWSS3ServiceImpl implements AWSS3Service {

	private static final Logger LOGGER = LoggerFactory.getLogger(AWSS3ServiceImpl.class);

	@Autowired
	private AmazonS3 amazonS3;
	@Value("${aws.s3.bucket}")
	private String bucketName;

	@Override
	// @Async annotation ensures that the method is executed in a different background thread 
	// but not consume the main thread.
	@Async
	public void uploadFile(final MultipartFile multipartFile) {
		LOGGER.info("File upload in progress.");
		try {
			final File file = convertMultiPartFileToFile(multipartFile);
			uploadFileToS3Bucket(bucketName, file);
			LOGGER.info("File upload is completed.");
			file.delete();	// To remove the file locally created in the project folder.
		} catch (final AmazonServiceException ex) {
			LOGGER.info("File upload is failed.");
			LOGGER.error("Error= {} while uploading file.", ex.getMessage());
		}
	}

	private File convertMultiPartFileToFile(final MultipartFile multipartFile) {
		final File file = new File(multipartFile.getOriginalFilename());
		try (final FileOutputStream outputStream = new FileOutputStream(file)) {
			outputStream.write(multipartFile.getBytes());
		} catch (final IOException ex) {
			LOGGER.error("Error converting the multi-part file to file= ", ex.getMessage());
		}
		return file;
	}

	private void uploadFileToS3Bucket(final String bucketName, final File file) {
		final String uniqueFileName = LocalDateTime.now() + "_" + file.getName();
		LOGGER.info("Uploading file with name= " + uniqueFileName);
		final PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, uniqueFileName, file);
		amazonS3.putObject(putObjectRequest);
	}
}

3.3.3 Kontrollerklasse

Legg til følgende kode til kontrollerklassen opprettet i org.jcg.springboot.aws.s3.ctrl pakke. Denne klassen håndterer innkommende forespørsler og viser uploadFile metode for å håndtere file inndataparameter som kommer i forespørselen.

AWSS3Ctrl.java 

package org.jcg.springboot.aws.s3.ctrl;

import org.jcg.springboot.aws.s3.serv.AWSS3Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
@RequestMapping(value= "/s3")
public class AWSS3Ctrl {

	@Autowired
	private AWSS3Service service;

	@PostMapping(value= "/upload")
	public ResponseEntity<String> uploadFile(@RequestPart(value= "file") final MultipartFile multipartFile) {
		service.uploadFile(multipartFile);
		final String response = "[" + multipartFile.getOriginalFilename() + "] uploaded successfully.";
		return new ResponseEntity<>(response, HttpStatus.OK);
	}
}

3.3.4 Hovedklasse

Legg til følgende kode til hovedklassen for å starte opp programmet fra hovedmetoden. Husk alltid at inngangspunktet for spring boot-applikasjonen er klassen som inneholder @SpringBootApplication annotering og statisk hoved metode.

SpringbootS3tutorial.java 

package org.jcg.springboot.aws.s3;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Main implementation class which serves two purposes in a spring boot application: Configuration and bootstrapping.
 * @author yatin-batra
 */
@SpringBootApplication
public class SpringbootS3tutorial {

	private static final Logger LOGGER = LoggerFactory.getLogger(SpringbootS3tutorial.class);

	public static void main(String[] args) {
		SpringApplication.run(SpringbootS3tutorial.class, args);
		LOGGER.info("SpringbootS3tutorial application started successfully.");
	}
}

4. Kjør programmet

For å kjøre programmet, kompiler prosjektet og høyreklikk på SpringbootS3tutorial.java klasse, Run As -> Java Application .

5. Prosjektdemo

Når programmet er startet, åpner du Postman-verktøyet. Trykk på følgende URL (HTTP POST request) for å laste opp filen til S3-bøtte. Husk å velge riktig alternativ i brødteksten eller se fig. 3 for en prøveforespørsel.

http://localhost:9098//s3/upload

Når filen er lastet opp vellykket til S3-bøtten, vil API-en returnere 200 OK respons som vist i fig. 4.

Og brukerne kan navigere til AWS-konsollen for å bekrefte at den samme filen nå er til stede i S3-bøtten.

Det er alt for denne opplæringen, og jeg håper artikkelen serverte deg det du lette etter. God læring og ikke glem å dele!

6. Konklusjon

I avsnittene ovenfor lærte utviklere hvordan de laster opp filer til en S3-bøtte via en fjæroppstartsapplikasjon. Utviklere kan laste ned eksempelapplikasjonen fra nedlastingsdelen.

7. Last ned prosjektet

Dette var et eksempel på å laste opp en fil til AWS S3-bøtten via en fjæroppstartsapplikasjon.AWS

Java Tag