Dépendances et configuration

Pour intégrer Alibaba Cloud Object Storage Service (OSS) dans une appplication Java, commencez par ajouter les dépendances Maven nécessaires :

<dependencies>
    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
        <version>3.17.4</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.11.0</version>
    </dependency>
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.4</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
<repositories>
    <repository>
        <id>aliyun</id>
        <name>Aliyun Maven Repository</name>
        <url>https://maven.aliyun.com/repository/public</url>
    </repository>
</repositories>

Créez un fichier de configuration sous resources/config.properties avec les paramètres suivants :

oss.endpoint = https://oss-eu-central-1.aliyuncs.com
oss.bucket = mon-bucket-stockage
oss.key.id = votre-id-cle-acces
oss.key.secret = votre-secret-cle-acces
oss.prefix = donnees/

Gestion de la configuration

Chargez la configuration à l'aide d'une classe utilitaire :

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ConfigPropertiesLoader {
    private static final String FICHIER_CONFIG = "config.properties";
    private static final Properties proprietes = new Properties();

    static {
        try (InputStream flux = Thread.currentThread().getContextClassLoader().getResourceAsStream(FICHIER_CONFIG)) {
            if (flux != null) {
                proprietes.load(flux);
            }
        } catch (IOException e) {
            throw new RuntimeException("Erreur lors du chargement de la configuration", e);
        }
    }

    public static String obtenir(String cle) {
        return proprietes.getProperty(cle);
    }
}

Classe utilitaier pour les opérations OSS

Voici une classe réorganisée pour gérer les téléchargements et suppressions de fichiers :

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.model.DeleteObjectsRequest;
import com.aliyun.oss.model.ObjectMetadata;
import com.aliyun.oss.model.PutObjectRequest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class GestionnaireStockageOSS {
    private final String pointAcces;
    private final String cleId;
    private final String cleSecrete;
    private final String nomBucket;
    private final String prefixeFichier;

    public GestionnaireStockageOSS() {
        this.pointAcces = ConfigPropertiesLoader.obtenir("oss.endpoint");
        this.cleId = ConfigPropertiesLoader.obtenir("oss.key.id");
        this.cleSecrete = ConfigPropertiesLoader.obtenir("oss.key.secret");
        this.nomBucket = ConfigPropertiesLoader.obtenir("oss.bucket");
        this.prefixeFichier = ConfigPropertiesLoader.obtenir("oss.prefix");
    }

    public String uploaderFichier(File fichier, String typeContenu) {
        String cleObjet = prefixeFichier + UUID.randomUUID().toString() + "." + typeContenu;
        try (OSS clientOSS = new OSSClientBuilder().build(pointAcces, cleId, cleSecrete)) {
            ObjectMetadata metadonnees = new ObjectMetadata();
            metadonnees.setContentType(determinerTypeContenu(typeContenu));
            try (FileInputStream fluxEntree = new FileInputStream(fichier)) {
                PutObjectRequest requete = new PutObjectRequest(nomBucket, cleObjet, fluxEntree, metadonnees);
                clientOSS.putObject(requete);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException("Fichier non trouvé", e);
        } catch (Exception e) {
            throw new RuntimeException("Échec de l'upload", e);
        }
        return construireUrl(cleObjet);
    }

    public boolean supprimerFichier(String urlFichier) {
        String cleObjet = extraireCleDepuisUrl(urlFichier);
        try (OSS clientOSS = new OSSClientBuilder().build(pointAcces, cleId, cleSecrete)) {
            clientOSS.deleteObject(nomBucket, cleObjet);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public int supprimerMultiplesFichiers(List<String> urlsFichiers) {
        List<String> clesObjets = new ArrayList<>();
        for (String url : urlsFichiers) {
            clesObjets.add(extraireCleDepuisUrl(url));
        }
        try (OSS clientOSS = new OSSClientBuilder().build(pointAcces, cleId, cleSecrete)) {
            DeleteObjectsRequest requete = new DeleteObjectsRequest(nomBucket).withKeys(clesObjets);
            clientOSS.deleteObjects(requete);
            return clesObjets.size();
        } catch (Exception e) {
            throw new RuntimeException("Erreur lors de la suppression multiple", e);
        }
    }

    private String construireUrl(String cleObjet) {
        String domaineBase = pointAcces.replaceFirst("https://", "");
        return "https://" + nomBucket + "." + domaineBase + "/" + cleObjet;
    }

    private String extraireCleDepuisUrl(String url) {
        String prefixe = "https://" + nomBucket + "." + pointAcces.replaceFirst("https://", "") + "/";
        if (url.startsWith(prefixe)) {
            return url.substring(prefixe.length());
        }
        throw new IllegalArgumentException("URL non conforme");
    }

    private String determinerTypeContenu(String extension) {
        switch (extension.toLowerCase()) {
            case "jpeg":
            case "jpg":
                return "image/jpeg";
            case "png":
                return "image/png";
            case "gif":
                return "image/gif";
            case "mp4":
                return "video/mp4";
            case "pdf":
                return "application/pdf";
            default:
                return "application/octet-stream";
        }
    }
}

Exemple d'utilisation

Instanciez la classe et effectuez des opérations :

public class ApplicationStockage {
    public static void main(String[] args) {
        GestionnaireStockageOSS gestionnaire = new GestionnaireStockageOSS();
        File fichier = new File("chemin/image.png");
        String lien = gestionnaire.uploaderFichier(fichier, "png");
        System.out.println("Lien généré : " + lien);

        // Suppression simple
        boolean resultat = gestionnaire.supprimerFichier(lien);
        System.out.println("Suppression effectuée : " + resultat);
    }
}