How to pass values from application.properties to a java abstract class?

Question

I'm new to Java class design and need help with the following:

Example scenario: I want to pass the company name and email to the BaseEmailMessage class, and fetch these values from the application.properties file.

I also have static variables SIGN_UP_URL and PASSWORD_RESET_URL in the SignUpEmail and PasswordResetEmail classes, respectively, and I need to fetch these from the same properties file.

abstract public class BaseEmailMessage {
    // Need to fetch these from application properties
    // as they are common for all email types
    private String COMPANY_NAME;
    private String COMPANY_EMAIL;
    
    // constructor, methods, getters, and setters...
}

@Component
public class SignUpEmail extends BaseEmailMessage {

    // Need to fetch this from application properties specific to this class only
    private static final String SIGN_UP_URL;
}

@Component
public class PasswordResetEmail extends BaseEmailMessage {

    // Need to fetch this from application properties specific to this class only
    private static final String PASSWORD_RESET_URL;
}

How can I achieve this in a clean and maintainable way? Any best practices to improve the maintainability of this code?

Thanks!

I tried autowiring the Environment instance to the classes, but not sure should I move with that approach or not?

jialin.zhou · Accepted Answer · 2025-05-08 12:30:13Z

4

You can use @ConfigurationProperties and constructor injection instead of manually fetching values from the environment. I think it is a maintainable way to achieve what you're asking.

Avoid using static fields because they're not easily injected by Spring.

Define your properties clearly in `application.properties` :

email.company-name=Example Company
[email protected]
email.signup.url=https://example.com/signup
email.passwordreset.url=https://example.com/reset-password

Define a class to load common email configuration properties:

@Component
@ConfigurationProperties(prefix = "email")
public class EmailProperties {
    private String companyName;
    private String companyEmail;
    
    private final Signup signup = new Signup();
    private final Passwordreset passwordreset = new Passwordreset();
    
    // getters and setters
    
    public static class Signup {
        private String url;
        // getters and setters
    }
    
    public static class Passwordreset {
        private String url;
        // getters and setters
    }

    // getters and setters for top-level properties
    public String getCompanyName() { return companyName; }
    public void setCompanyName(String companyName) { this.companyName = companyName; }

    public String getCompanyEmail() { return companyEmail; }
    public void setCompanyEmail(String companyEmail) { this.companyEmail = companyEmail; }

    public Signup getSignup() { return signup; }
    public Passwordreset getPasswordreset() { return passwordreset; }
}

Use constructor injection in your abstract class `BaseEmailMessage`:

public abstract class BaseEmailMessage {
    protected final String companyName;
    protected final String companyEmail;

    protected BaseEmailMessage(String companyName, String companyEmail) {
        this.companyName = companyName;
        this.companyEmail = companyEmail;
    }

    // methods, getters, etc.
}

Subclasses inject their specific URLs in constructors, along with the common properties:

@Component
public class SignUpEmail extends BaseEmailMessage {
    private final String signupUrl;

    public SignUpEmail(EmailProperties emailProperties) {
        super(emailProperties.getCompanyName(), emailProperties.getCompanyEmail());
        this.signupUrl = emailProperties.getSignup().getUrl();
    }

    // methods using signupUrl
    public String getSignupUrl() {
        return signupUrl;
    }
}

I think this way is maintainable because it is clear separation, easy management and constructor injection.

answered May 8 at 12:30

jialin.zhou

1045 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Andrew S May 8 at 12:42

Beat me too it - the only suggestion is to make EmailProperties a record.

jialin.zhou May 8 at 12:48

It is a great suggestion.

kdeepak May 8 at 13:04

Why have you kept Signup & Passwordreset static?

jialin.zhou May 8 at 13:41

Why does Spring Boot's @ConfigurationProperties not allow the use of non-static inner classes? 1. When Spring creates a configuration class through reflection, it uses a no-argument constructor by default. 2. If the nested class is non-static, Java requires that it must be created through an outer class instance. 3. However, when Spring loads the configuration class, it does not create an outer class instance first. It directly tries to use new Inner() reflection to construct the nested class. 4. The result fails, an exception is thrown, or the configuration cannot be bound.

jialin.zhou May 9 at 6:09

All 30 classes require the same config values, yes, using a shared EmailProperties bean with constructor injection is a good design. If each subclass only uses a small part of the config or if the hierarchy becomes too rigid, consider using composition instead of inheritance when flexibility is needed.

|

Tania Gupta · Accepted Answer · 2025-05-08 12:16:18Z

2

Use @Value annotation like this:

@Value("${YOUR_KEY_NAME_FROM_PROPERTY_FILE}")
private String PASSWORD_RESET_URL;

answered May 8 at 12:16

Tania Gupta

313 bronze badges

3 Comments

Andrew S May 8 at 12:44

Constructor injection is generally preferred over the use of field injection via @Value.

Tania Gupta May 8 at 13:49

You are right. But for simple configurations field injection also works fine.

Andrew S May 8 at 17:01

That requires the field to be mutable, which probably isn't desired (at least not in this case). And it also makes unit testing harder.

Collectives™ on Stack Overflow

How to pass values from application.properties to a java abstract class?

2 Answers 2

Define your properties clearly in `application.properties` :

Define a class to load common email configuration properties:

Use constructor injection in your abstract class `BaseEmailMessage`:

Subclasses inject their specific URLs in constructors, along with the common properties:

7 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Define your properties clearly in application.properties :

Define a class to load common email configuration properties:

Use constructor injection in your abstract class BaseEmailMessage:

Subclasses inject their specific URLs in constructors, along with the common properties:

7 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related

Define your properties clearly in `application.properties` :

Use constructor injection in your abstract class `BaseEmailMessage`: