Java中的常量与属性

Question

What should be best approach to declare constant value in my java program?

Is it the best approach to declare constant value in .properties file or declare that value as static final in nature in a different class?

Answer 1

The answer to the question depends on what you want to accomplish. But there is also a misunderstanding in it.

Property files

Property files are not meant to be a substitute or an alternative to constants. They are used to store configurable values such as an ip, languages, etc. Loading constants from a file defeats the purpose of a constant.

Constants

The other point is that public static final variables are not a good approach in java, the preferred way is to use an enumerator.(From Effective Java, Item 30: Use enums instead of int constatns ). An enum will force you to group the constants in a meaningful way, while a class full of random public constants is difficult to manage. An Enum enables you to provide functionalities, for example checks, validation, associate the constant with multiples objects and it can be used in switch statements. Enums are also compiled which makes them more efficient and typesafe. The book explains the benefits of enums in much greater detail.

I think the best approach is to consider whether the value will change depending on some external factor or if it will always remain the same.

Property files and global access to the configuration

Imagine you have an ip in your property file and you want to be able to access this value from anywhere in your code. You could just read the value and load it in a public static final variable.

If you do this how are you going to control that the value is initialized, or the configured value is correct? Well in this cases you can use the singleton class pattern (Only one instance of the class can exist), that loads the file and checks that the values are correct.

It can store the value in a private static final variable and enable a getter that can perform the needed checks to ensure that the value is correct. This gives you global access to the variables and groups the logic in a single place.

Next time you add a value to the file you just need to update this class, and don't need to search in the code where it was and if the checks were correct.

Note

Many people are saying that there is not really a "best way" of doing something. I think it's true, but it's also true that if you have access to books like Effetive Java from Joshua Bloch , you should read them and learn from people that have been coding for a really long time.

Answer 2

Declare them as static final in your code if these values are not environment ie dev,qa,stage specific and doesn't change throughout the lifecycle of your code.

Downside of constants are that you need to recompile them, if you make some change to them, which will not be the case in property but if its a constant it shouldn't change at all.

For example :- you might have different credentials for user name "admin" in your dev/qa/stage/prod environment.

Then you can define the admin user like public static final String userId="admin" but password you want to supply from the property file and change it according to the environment in which you running your code.

like

dev.properties admin.password = 123456.

qa.properties admin.password = abcdef.

And then read it these password from the properties file based on your environment.

Answer 3

The real answer depends on your requirements. There is no "A is better than B" in the real world. Only: "A is more helpful given requirements x,y,z than B".

Therefore you simply have to consider the pros/cons of both approaches in order to decide what is "better" for you.

Advantages of using a constant:

• compile time safety
• compiler support in the first place
• simplicity: there is just a constant. Properties need to come from files, they are all flat strings, they can even be missing .

Disadvantages of constants:

• a bugfix requires you to provide re-compiled classfiles to your customers
• in order to apply the bugfix, either the JVM running your code needs to be stopped; or at least your container (like a WAR in Tomcat) needs to be re-deployed.

Properties are just "the other way round".

In other words: if you want to, you can write a lot of complicated code that allows you to "patch" a running application by enabling it to re-read property information. By doing so, you enable your customer to patch a running application by providing a new property file and triggering some "re-read properties" hook inside the application. But make no mistake: implementing a correct, reliable way of doing that is hard .

But unless the above feature is of real value to you, you are most likely better of using plain compile-time constants. You see, "deploying an update" is about giving files to the customer. It doesn't really matter that much of those files are class files or property files (when we are not talking about "hotfix" requirements).

Answer 4

I have tried both the ways - File and a public static final class and both work. Some points to note though:

• Declaring in a file would be specifically advantageous if your program needs to be tested/run by various parties who would like to change these constants. In this case, these would be called properties of App/program. Spring follows this approach for config.
• Declaring them in a class would warrant re-building the App again and again but if these constant don't change or are not required to be accessed by multiple parties, you can very easily pick the static final class approach. Android declares constants dynamically generated in R.java file as an example. This approach retains control in your hand by the way. 3rs parties using your code would not be able to change these constants. The file approach passes control into others' hands for varying them.

Object Mappers would also prefer you to have Bean properties in config files but in Java Annotation sort of lies in between the two and solves it elegantly.

Answer 5

There is a third option: system properties. They can be defined in the command line you use to launch you program, and you can also use a constant to ease access them and provide a default value.

Example:

public static final String HOSTNAME = System.getProperty("my.host-name", "localhost");

It is not always a good idea to provide a default value though.

That been said, the method you choose will depend on the answer to the question: is the value part of the program, or is it part of the context in which the program is installed.