If you're using Spring you can use the getSize() method.

Here is the definition.

https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/multipart/MultipartFile.html

And here some examples

http://www.mkyong.com/spring-mvc/spring-mvc-file-upload-example/

The last modified date value is part of the filesystem (Operating System), so you can not transfer this metadata with the file.

If you send the value in other field, this is not safe because any user could send whatever value they want. Another thing to notice is that the last modified date depends on the operatingsystem date. Ss if the user change its computer date the date that you recieve it's not real.

You can use @HeaderParam to get the value of a named header.

@POST
@Consumes(MediaType.MULTIPART_FORM_DATA)
public Response uploadFile(
    @FormDataParam("file") InputStream uploadedInputStream,
    @FormDataParam("file") FormDataContentDisposition fileDetail,
    @HeaderParam("Content-Disposition") String contentDisposition
) throws IOException { 

Note that you still need to add the file size to the header in the client side, assuming you're using something like the DOM File API and fetch.

You are using method getSize() of MultipartFile, which I think returns size in bytes in binary.
So convert that to in MB you have to multiply file.getSize() with 0.00000095367432. This will give you size in MB. You can verify here.

I am using the same. I can see size of a file in windows is 18.9 KB which is actual size not the size on disk. In my case I need information in KB so I multiplied it by 0.0009765625 and it returned 18.9462890625 KB which is close to the size of file an may be windows is rounding it up.

I believe multiplying file.getSize() with 0.00000095367432 will work.

1. You cannot expect that the Content-Length header is set for the multipart message (some multipart request types even forbid a content length header). It's only required that either a Content-Length header or a Transfer-Encoding header is present.

2. There must be no Content-Length header in a part of a multipart message.

However, your sender may set an additional parameter in the disposition header. You could leverage this to set the file size as follows:

Content-Disposition: form-data; name="file"; filename="3byte.txt"; size=123

But this would be purely optional, the parameters's name would be arbitrary, and no sender is required to include this parameter. That means, a HTTP server engine can never rely on it.

Here's what you need to do:

1. Use custom annotation validation for all your input with different sizes.
2. Set a default maximum size that Spring Boot can accept in your application.properties

To achieve step 1, lets say you have an Entity: Post

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import jakarta.persistence.*;

@Entity
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String image;

    @Transient
    private MultipartFile imageContent;

    // Getters and setters, constructors, etc.
}

With an interface, PostImageSize

import jakarta.validation.Constraint;
import jakarta.validation.Payload;

import java.lang.annotation.*;

@Documented
@Constraint(validatedBy = ImageSizeValidation.class)
@Target({ ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface PostImageSize {

    String message() default "Invalid image size";

    long maxSize() default 5 * 1024 * 1024; // Default size is 5MB

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

and the class ImageSizeValidation mentioned in PostImageSize interface

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import org.springframework.web.multipart.MultipartFile;

public class ImageSizeValidation implements 
ConstraintValidator<PostImageSize, MultipartFile> {

    private long maxSize;

    @Override
    public void initialize(PostImageSize constraintAnnotation) {
        this.maxSize = constraintAnnotation.maxSize();
    }

    @Override
    public boolean isValid(MultipartFile multipartFile, 
    ConstraintValidatorContext cxt) {
        return multipartFile == null || multipartFile.getSize() <= 
        maxSize;
    }
}

Once you have set this up, using the annotation @PostImageSize in your entity will enable custom validation.

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String image;

    @PostImageSize(message = "This image must not be more than 5MB")
    private MultipartFile imageContent;

    // Getters and setters, constructors, etc.
}

After this, you can customize the size according to the annotations you have and include in your entity which will enable it.

// Customizing to 1MB
@PostImageSize(message = "This image must not be more than 1MB", maxSize = 1024 * 1024)
private MultipartFile imageContent;

For step 2 in your application.properties

# Multipart settings
spring.servlet.multipart.max-file-size=256MB
spring.servlet.multipart.max-request-size=256MB
spring.servlet.multipart.enabled=true

Goodluck !!!

I think you have to implement the progress bar in javascript on the client side.

Anyway, this link gives an explanation of how to do it using JQuery.

The server can obtain the size of the multipart being uploaded from the HTTP request header; see @ilya's answer. However, getting that information and the count(s) of bytes read so far into a stream of HTTP responses that display or update a progress bar would be rather complicated ...

Tomcat 7 and and above has a configuration called maxSwallowSize that specify number of bytes for an upload with a default value of 2MB. If your application is configured to accept bigger file, for example with a MultipartResolver in Spring, Tomcat will reject the request.

Because you can configure file size in your application, my advice is to disable maxShallowSize in {TOMCAT_HOME}/conf/server.xml using value -1 and then work only with size configured in your application

as follows:

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
            maxSwallowSize="-1"/>

You can find a detailed description here (with spring framerwork)

The second API saves the file to a temp file on the file system. (which I believe is being automatically deleted when the call completes and the File is closed)

The first API saves the file to a byte stream (array) in memory - that's why you're getting an OOM error.