Introduction
I’d like to preface this post with, really, all properties files should be inside your application archive. However, there are occasions, where you do need properties files more easily accessible — where a modification doesn’t require breaking open the EAR/WAR, making the modification, then rebuilding or repackaging the EAR/WAR.
With previous versions of EAP and AS, the conf directory was on the class path and you could drop your properties files in conf/props and be happy. EAP6 and AS7 (now WildFly) do not have the configuration directory on the classpath however, and it really should not be added. So what is the solution? Modules!
These newer versions (at the time or writing this) of JBoss take an OSGi approach to class loading where everything is considered a module. A module can import (require the dependency) or export (allow other to depend) resources.
You can write a simple module to make resources (such as properties files) available to an application that declares it as a dependency. This is the approach that we will take
Writing the Module
Writing the module is pretty simple. The first thing we will do is create our module directory structure in the modules directory. The module name should follow the standard Java style package naming. Each name in the package (separated by full-stops ‘.’) should have its own directory. See below for a module that will be named com.jyore.examples.settings:
|
1
2
3
|
EAP_HOME/modules/com/jyore/examples/settings
|
Now, there will be subdirectories under the settings directory, if you want to use different slots, but to keep it simple, we will use the default main slot. So create a single subdirectory called main inside the settings directory.
|
1
2
3
|
EAP_HOME/modules/com/jyore/examples/settings/main
|
The module descriptor will be placed inside the main directory. Add the following:
|
1
2
3
4
5
6
7
8
|
<?xml version="1.0" encoding="UTF-8"?>
<module xmlns="urn:jboss:module:1.1" name="com.jyore.examples.settings">
<resources>
<resource-root path="."/>
</resources>
</module>
|
This descriptor will put all of the resources under the main directory at the root of the class path for us when we declare the dependency. This can be done one of two ways:
a) MANIFEST.MF Dependencies: entry
|
1
2
3
|
Dependencies: com.jyore.examples.settings
|
b) jboss-deployment-structure.xml entry
|
1
2
3
4
5
6
7
8
9
10
|
<?xml version="1.0" encoding="UTF-8"?>
<jboss-deployment-structure>
<deployment>
<dependencies>
<module name="com.jyore.examples.settings"/>
</dependencies>
</deployments>
</jboss-deployment-structure>
|
If using the jboss-deployment-structure.xml method, this file is placed in the WEB-INF directory of a WAR or the META-INF directory of an EAR.
Testing the Module
No ‘How To’ is complete without a test case. So, let’s see how a simple web app can use this module to get properties.
This example will build a simple web app that will dump the contents of the properties files to a table in a web page.
Java Code – ModuleReader.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
package com.jyore.examples.settings;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class ModuleReader {
private static final String PROPERTIES_FILENAME = "application_settings.properties"
private static Properties settings = null;
public static void loadSettings() {
settings = new Properties();
try {
settings.load(Thread.currentThread().getContextClassLoader().getResourceAsStream(PROPERTIES_FILENAME);
} catch (IOException e) {
e.printStackTrace();
}
}
public static String getProperty(String key) {
if(settings == null) {
return null;
} else {
return settings.getProperty(key);
}
}
public static Set<Object> getKeys() {
if(settings == null) {
return null;
} else {
return settings.keySet();
}
}
}
|
Now for the jsp’s
index.jsp
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
<%@page import="com.jyore.examples.settings.ModuleReader,java.util.set"%>
<html>
<head>
<title>Module Settings Reader</title>
<style>
table, th, td {
border : solid 1px black;
}
</style>
</head>
<body>
<h1>Module Settings Reader</h1>
<button onclick="loadProps();">Click to load properties</button>
<%
Set<Object> keys = ModuleReader.getKeys();
if(keys == null) {
out.print("<span style="color:red">properties file not loaded</span><br/>");
} else {
out.print("<span style="color:green">properties loaded</span><br/><table><tr><td><b>Key</b></td><td><b>Value</b></td></tr>");
String value;
for(Object str : value) {
String key = (String) str;
value = ModuleReader.getProperty(key);
out.print("<tr><td>"+key+"</td><td>"+value+"</td></tr>");
}
out.print("</table>);
}
%>
<script type="text/javascript">
function loadProps() {
window.location.href = "loadProps.jsp";
}
</script>
</body>
</html>
|
loadProps.jsp
|
1
2
3
4
5
6
7
|
<%@page import="com.jyore.examples.settings.ModuleReader"%>
<%
ModuleReader.loadSettings();
response.sendRedirect("index.jsp");
%>
|
My WAR Structure (propertyReader.war)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
propertyReader.war
|-- WEB-INF
| |-- classes
| | `-- com
| | `-- jyore
| | `-- examples
| | `-- settings
| | `-- ModuleReader.class
| |-- web.xml
| `-- jboss-deployment-structure.xml
|-- index.jsp
`-- loadProps.jsp
|
and the module
|
1
2
3
4
5
6
7
8
9
10
|
modules
`-- com
`-- jyore
`-- examples
`-- settings
`-- main
|-- module.xml
`-- application_settings.properties
|
Now we deploy the application and go to http://localhost:8080/propertyReader/
You will see in red text that the properties are not yet loaded, so click the button. This will go to the loadProps page, load the properties file, and redirect back. This time, the properties within application_settings.xml will be displayed within a table on the page.
Open that properties file and edit it by adding another value. Click the button on the web page again and see that the table updates with your addition.
原文地址：http://blog.jyore.com/?p=58