com.amazonaws.services.s3.model.ObjectMetadata#addUserMetadata ( )源码实例Demo

public String putObject(String bucketName, String originFileName, MultipartFile multipartFile) {
    String uuid = UUID.randomUUID().toString().replaceAll("-", "");
    String fileName = FILE + "_" + uuid + "_" + originFileName;
    try {
        InputStream inputStream = multipartFile.getInputStream();
        if (isAwsS3) {
            ObjectMetadata objectMetadata = new ObjectMetadata();
            objectMetadata.addUserMetadata("Content-Type", "application/octet-stream");
            amazonS3.putObject(bucketName, fileName, inputStream, objectMetadata);
        } else {
            minioClient.putObject(bucketName, fileName, inputStream, "application/octet-stream");
        }
    } catch (Exception e) {
        throw new FileUploadException("error.file.upload", e);
    }
    return fileName;
}
 

private void upload(@NotNull File src, @NotNull String key, @NotNull CallbackPayload payload) {
    log.info("Uploading {} to {} in {}", src, key, bucketName);
    final PutObjectRequest request = new PutObjectRequest(bucketName, key, src);
    final ObjectMetadata metadata = request.getMetadata();
    final String commitId = payload.getAfter();
    if (commitId != null) {
        metadata.addUserMetadata("commit-id", commitId);
    }
    final DateTime timestamp = payload.getTimestamp();
    if (timestamp != null) {
        metadata.addUserMetadata("hook-timestamp",
                ISODateTimeFormat.basicTime().print(timestamp));
    }

    final TimerContext time = uploadTimer.time();
    try {
        s3Client.putObject(request);
    } catch (Exception e) {
        log.error("Couldn't upload to {} in {}", key, bucketName, e);
        throw e;
    } finally {
        time.stop();
    }
    log.info("Uploaded to {} in {}", key, bucketName);
}
 

protected ObjectMetadata buildMetadata(File file) throws IOException {
    final ObjectMetadata metadata = new ObjectMetadata();
    metadata.setContentType(Mimetypes.getInstance().getMimetype(file.getName()));
    metadata.setContentLength(file.length());
    metadata.setLastModified(new Date(file.lastModified()));

    if (storageClass != null && !storageClass.isEmpty()) {
        metadata.setHeader("x-amz-storage-class", storageClass);
    }
    if (useServerSideEncryption) {
        metadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
    }

    for (Map.Entry<String, String> entry : userMetadata.entrySet()) {
        final String key = entry.getKey().toLowerCase();
        switch (key) {
            case "cache-control":
                metadata.setCacheControl(entry.getValue());
                break;
            case "expires":
                try {
                    final Date expires = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z").parse(entry.getValue());
                    metadata.setHttpExpiresDate(expires);
                } catch (ParseException e) {
                    metadata.addUserMetadata(entry.getKey(), entry.getValue());
                }
                break;
            case "content-encoding":
                metadata.setContentEncoding(entry.getValue());
                break;
            case "content-type":
                metadata.setContentType(entry.getValue());
            default:
                metadata.addUserMetadata(entry.getKey(), entry.getValue());
                break;
        }
    }
    return metadata;
}
 

public void publishSnapshot(Blob blob) {
    String objectName = getS3ObjectName(blobNamespace, "snapshot", blob.getToVersion());

    ObjectMetadata metadata = new ObjectMetadata();
    metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
    metadata.setHeader("Content-Length", blob.getFile().length());
    
    uploadFile(blob.getFile(), objectName, metadata);
    
    /// now we update the snapshot index
    updateSnapshotIndex(blob.getToVersion());
}
 

public void publishDelta(Blob blob) {
    String objectName = getS3ObjectName(blobNamespace, "delta", blob.getFromVersion());
    
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.addUserMetadata("from_state", String.valueOf(blob.getFromVersion()));
    metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
    metadata.setHeader("Content-Length", blob.getFile().length());
    
    uploadFile(blob.getFile(), objectName, metadata);
}
 

public void publishReverseDelta(Blob blob) {
    String objectName = getS3ObjectName(blobNamespace, "reversedelta", blob.getFromVersion());
    
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.addUserMetadata("from_state", String.valueOf(blob.getFromVersion()));
    metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
    metadata.setHeader("Content-Length", blob.getFile().length());
    
    uploadFile(blob.getFile(), objectName, metadata);
}
 

private ObjectMetadata metadata(GoEnvironment env) {
    String tracebackUrl = env.traceBackUrl();
    String user = env.triggeredUser();
    ObjectMetadata objectMetadata = new ObjectMetadata();
    objectMetadata.addUserMetadata(METADATA_USER, user);
    objectMetadata.addUserMetadata(METADATA_TRACEBACK_URL, tracebackUrl);
    objectMetadata.addUserMetadata(COMPLETED, COMPLETED);
    objectMetadata.addUserMetadata(GO_PIPELINE_LABEL, env.get(GO_PIPELINE_LABEL));
    return objectMetadata;
}
 

private void addFile() throws Exception {

    InputStream is = new ByteArrayInputStream(this.outputStream.toByteArray());
    int contentLength = outputStream.size();

    TransferManager transferManager = new TransferManager(amazonS3Client);
    ObjectMetadata metadata = new ObjectMetadata();
    metadata.setExpirationTime(DateTime.now().plusDays(365 * 3).toDate());
    metadata.setContentLength(contentLength);

    metadata.addUserMetadata("writer", "org.apache.streams");

    for (String s : metaData.keySet()) {
      metadata.addUserMetadata(s, metaData.get(s));
    }

    String fileNameToWrite = path + fileName;
    Upload upload = transferManager.upload(bucketName, fileNameToWrite, is, metadata);
    try {
      upload.waitForUploadResult();

      is.close();
      transferManager.shutdownNow(false);
      LOGGER.info("S3 File Close[{} kb] - {}", contentLength / 1024, path + fileName);
    } catch (Exception ignored) {
      LOGGER.trace("Ignoring", ignored);
    }


  }
 

private ObjectMetadata metadata(GoEnvironment env) {
    String tracebackUrl = env.traceBackUrl();
    String user = env.triggeredUser();
    ObjectMetadata objectMetadata = new ObjectMetadata();
    objectMetadata.addUserMetadata(METADATA_USER, user);
    objectMetadata.addUserMetadata(METADATA_TRACEBACK_URL, tracebackUrl);
    objectMetadata.addUserMetadata(COMPLETED, COMPLETED);
    objectMetadata.addUserMetadata(GO_PIPELINE_LABEL, env.get(GO_PIPELINE_LABEL));
    return objectMetadata;
}
 

public S3SinkStreamWriter(S3Folder streamS3Folder) throws IOException {
  this.streamS3Folder = streamS3Folder;
  segmentName = "segment-" + UUID.randomUUID().toString();
  ObjectMetadata metadata = new ObjectMetadata();
  metadata.setContentType("application/binary");
  metadata.addUserMetadata("transaction", "prepare");
  writer = streamS3Folder.createObjectWriter(segmentName, metadata) ;
}
 

@Test
public void testUpdateObjectMetadata() throws IOException, InterruptedException {
  String KEY = "test-update-objec-metadata" ;
  ObjectMetadata metadata = new ObjectMetadata() ;
  metadata.setContentType("text/plain");
  s3Client.createObject(BUCKET_NAME, KEY, new byte[0], metadata);
  metadata = s3Client.getObjectMetadata(BUCKET_NAME, KEY) ;
  metadata.addUserMetadata("transaction", "buffering");
  s3Client.updateObjectMetadata(BUCKET_NAME, KEY, metadata);
  metadata = s3Client.getObjectMetadata(BUCKET_NAME, KEY) ;
  Assert.assertEquals("buffering", metadata.getUserMetaDataOf("transaction"));
}
 

@Override
public void completeCommit() throws Exception {
  ObjectMetadata metadata = writer.getObjectMetadata();
  metadata.addUserMetadata("transaction", "complete");
  streamS3Folder.updateObjectMetadata(segmentName, metadata);
}
 

public void createObject(String bucketName, String key, InputStream is, ObjectMetadata metadata) {
  s3Client.putObject(new PutObjectRequest(bucketName, key, is, metadata));
  metadata.addUserMetadata("transaction", "test");
}