If I have the following directory structure,
+src
++com.foo.util
+++FooProperties.java
+foo.properties
How do I reference foo.properties as a resource stream in FooProperties? I've tried adding it to the classpath and referencing it as such,
FooProperties.class.getResourceAsStream("/foo.properties")
but I get a NullPointerException. What am I doing wrong?
If you want to keep the properties file outside the src(same level as src), then you can fetch your properties file this way:-
try {
InputStream fileStream = new FileInputStream(new File(
"test.properties"));
Properties props = new Properties();
props.load(fileStream);
String myPropValue = (String) props.get("test.prop");
System.out.println(myPropValue);
} catch (FileNotFoundException e) {
} catch (IOException e) {
}
Hope it helps. You can even edit the properties file using the above method(no absolute path required).
Related
I dont really understand why but I get file not found when I try to load the properties.
I put a file called c24.properties in the resources folder alongside with application.properties
private static final String PROP = "c24.properties";
private Properties properties;
// Constructor
public KTServices() {
try {
properties = new Properties();
properties.load(new FileInputStream(PROP)); // FILE NOT FOUND??
} catch (IOException e) {
e.printStackTrace();
}
}
Any help? Why it doesn't find? This is a Spring Boot maven project
PS: I just checked the /target and the c24.properties is in the root folder as expected
Properties appProps = new Properties();
try {
appProps.load(Thread.currentThread().getContextClassLoader().getResource("app.properties").openStream());
} catch (IOException var3) {
this.log.error("properties file not found", var3.toString());
}
return appProps;
If the file is in the same directory as the class file, you can use the following:
properties.load(KTServices.class.getResourceAsStream(PROP));
Any property files that are outside the jar requires a full path to locate successfully.
The code sample given below returns null value.
Directory structure for your reference is :
D:\Postcard_workspace_new\Postcard_workspace\ConfigMigrationUtility\ConstantFiles ->contains the constants.properties file
D:\Postcard_workspace_new\Postcard_workspace\ConfigMigrationUtility\src\configmigrator\utility ->contains below given java class
Code :
public class PropertyUtil {
public static Properties prop;
public static Properties constantProp;
constantProp = new Properties();
public static void loadPropertyFile(String inputfilename) {
try {
// Loads the constants.properties file
InputStream constantPropFile = ClassLoader.class
.getResourceAsStream("/ConstantFiles/constants.properties");
System.out.println(constantPropFile);//prints null
constantProp.load(constantPropFile);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
// e.printStackTrace();
log.equals("Constant Property file not found");
} catch (IOException e) {
// TODO Auto-generated catch block
// e.printStackTrace();
log.error("Can't Load constants.properties property
file ");
}
}
}
Place the file constants.properties at the following location:
D:\Postcard_workspace_new\Postcard_workspace\ConfigMigrationUtility\src
And access it using this:
InputStream constantPropFile = ClassLoader.class.getResourceAsStream("/constants.properties");
If you are working in eclipse then include that properties file's folder in src folder. Else just copy that properties file and paste in the src folder. Because At the runtime jvm finds the file in src folder.
if you add "ConstantFiles" folder to your project build path, you can access it using ClassLoader.class
.getResourceAsStream("/constants.properties");
(If you are using eclipse, right click on project > build path > configure build path > add folder on source tab)
I´ve included a jar (I built it: MyJar.jar) that i use to authenticate, in that jar I have to read some properties that I have in a package (e.g com.myproject.properties) inside a property file of my project.
I have a method in MyJar.jar which receive the name of the property and the path for the property file something like this:
public String getValueOfProperty(String property,String pathToPropertyFile){
BasicTextEncryptor encryptor = new BasicTextEncryptor();
Properties props = new EncryptableProperties(encryptor);
props.load(new FileInputStream(pathToPropertyFile));
....
}
I got the following error: System can't find the specified path
The path is: com/myproject/properties/conf.properties
What am I doing wrong?
Solved,
This is what i Used:
The path the method receives is something like this: /sv/com/myproject/configuration/file.properties,
This method will search with relative path
public String decryptVar(String var,String PathPropertyFile) throws Exception{
try {
BasicTextEncryptor encryptor = new BasicTextEncryptor();
Properties props = new EncryptableProperties(encryptor);
InputStream fis = this.getClass().getResourceAsStream(PathPropertyFile);
props.load(fis);
encryptor.setPassword(props.getProperty("PROPERTY_IN_FILE"));
return props.getProperty(var);
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}
Implementing: JASYPTH
I have a cheerapp.mp3 in my /res/raw folder
so my code is
String filepath="/res/raw/cheerapp"; //or cheerapp.mp3
file = new File(filePath);
FileInputStream in = null;
try {
in = new FileInputStream( file );
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
The error I got file not found. why?
Use assets folder and ...
InputStream sound = getAssets().open("filename.mp3");
... or raw folder and ...
InputStream sound = getResources().openRawResource(R.raw.filename);
if it doesn't help you, then check this
Never can you access resource files by path!
Because they are compiled in APK file installed in Android. You can only access resource within application by access its generated resource id, from any activity (context):
InputStream cheerSound = this.getResources().openRawResource(R.raw.cheerapp);
or from view:
InputStream cheerSound = this.getContext().getResources().openRawResource(R.raw.cheerapp);
In your case, you should store sound files in external sd-card, then can access them by path. For e.g, you store your file in sounds folder on your sd-card:
FileInputStream inFile = new FileInputStream("/mnt/sdcard/sounds/cheerapp.mp3");
NOTE: path starts with '/' is absolute path, because '/' represents root in Unix-like OS (Unix, Linux, Android, ...)
Maybe you could use the AssetManager to manage your resources. For example:
AssetManager manager = this.getContext().getAssets();
InputStream open;
try {
open = manager.open(fileName);
BitmapFactory.Options options = new BitmapFactory.Options();
...
} catch (IOException e) {
e.printStackTrace();
}
I need to read a properties files that's buried in my package structure in com.al.common.email.templates.
I've tried everything and I can't figure it out.
In the end, my code will be running in a servlet container, but I don't want to depend on the container for anything. I write JUnit test cases and it needs to work in both.
When loading the Properties from a Class in the package com.al.common.email.templates you can use
Properties prop = new Properties();
InputStream in = getClass().getResourceAsStream("foo.properties");
prop.load(in);
in.close();
(Add all the necessary exception handling).
If your class is not in that package, you need to aquire the InputStream slightly differently:
InputStream in =
getClass().getResourceAsStream("/com/al/common/email/templates/foo.properties");
Relative paths (those without a leading '/') in getResource()/getResourceAsStream() mean that the resource will be searched relative to the directory which represents the package the class is in.
Using java.lang.String.class.getResource("foo.txt") would search for the (inexistent) file /java/lang/String/foo.txt on the classpath.
Using an absolute path (one that starts with '/') means that the current package is ignored.
To add to Joachim Sauer's answer, if you ever need to do this in a static context, you can do something like the following:
static {
Properties prop = new Properties();
InputStream in = CurrentClassName.class.getResourceAsStream("foo.properties");
prop.load(in);
in.close()
}
(Exception handling elided, as before.)
The following two cases relate to loading a properties file from an example class named TestLoadProperties.
Case 1: Loading the properties file using ClassLoader
InputStream inputStream = TestLoadProperties.class.getClassLoader()
.getResourceAsStream("A.config");
properties.load(inputStream);
In this case the properties file must be in the root/src directory for successful loading.
Case 2: Loading the properties file without using ClassLoader
InputStream inputStream = getClass().getResourceAsStream("A.config");
properties.load(inputStream);
In this case the properties file must be in the same directory as the TestLoadProperties.class file for successful loading.
Note: TestLoadProperties.java and TestLoadProperties.class are two different files. The former, .java file, is usually found in a project's src/ directory, while the latter, .class file, is usually found in its bin/ directory.
public class Test{
static {
loadProperties();
}
static Properties prop;
private static void loadProperties() {
prop = new Properties();
InputStream in = Test.class
.getResourceAsStream("test.properties");
try {
prop.load(in);
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public class ReadPropertyDemo {
public static void main(String[] args) {
Properties properties = new Properties();
try {
properties.load(new FileInputStream(
"com/technicalkeeda/demo/application.properties"));
System.out.println("Domain :- " + properties.getProperty("domain"));
System.out.println("Website Age :- "
+ properties.getProperty("website_age"));
System.out.println("Founder :- " + properties.getProperty("founder"));
// Display all the values in the form of key value
for (String key : properties.stringPropertyNames()) {
String value = properties.getProperty(key);
System.out.println("Key:- " + key + "Value:- " + value);
}
} catch (IOException e) {
System.out.println("Exception Occurred" + e.getMessage());
}
}
}
Assuming your using the Properties class, via its load method, and I guess you are using the ClassLoader getResourceAsStream to get the input stream.
How are you passing in the name, it seems it should be in this form: /com/al/common/email/templates/foo.properties
I managed to solve this issue with this call
Properties props = PropertiesUtil.loadProperties("whatever.properties");
Extra, you have to put your whatever.properties file in /src/main/resources
Nobody mentions the similar but even simpler solution than above with no need to deal with the package of the class. Assuming myfile.properties is in the classpath.
Properties properties = new Properties();
InputStream in = ClassLoader.getSystemResourceAsStream("myfile.properties");
properties.load(in);
in.close();
Enjoy
use the below code please :
Properties p = new Properties();
StringBuffer path = new StringBuffer("com/al/common/email/templates/");
path.append("foo.properties");
InputStream fs = getClass().getClassLoader()
.getResourceAsStream(path.toString());
if(fs == null){
System.err.println("Unable to load the properties file");
}
else{
try{
p.load(fs);
}
catch (IOException e) {
e.printStackTrace();
}
}