recurso aberto com o caminho relativo em java

Question

Na minha Java app que eu necessidade de obter alguns arquivos e diretórios.

Esta é a estrutura do programa:

./main.java
./package1/guiclass.java
./package1/resources/resourcesloader.java
./package1/resources/repository/modules/   -> this is the dir I need to get
./package1/resources/repository/SSL-Key/cert.jks    -> this is the file I need to get

cargas guiclass a classe resourcesloader que irá carregar os meus recursos (arquivos e diretórios).

Como para o arquivo, eu tentei

resourcesloader.class.getClass().getResource("repository/SSL-Key/cert.jks").toString()

, a fim de obter o caminho real, mas desta forma não funciona.

Eu não tenho nenhuma idéia de como fazer o diretório.

Answer 1

Fornecimento o caminho relativo para o carregador de classe, não a classe que você está recebendo o carregador de. Por exemplo:

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();

Answer 2

Eu tive problemas com o uso do método getClass().getResource("filename.txt"). Ao ler as instruções do Java docs, se o recurso não está no mesmo pacote que a classe que você está tentando acessar o recurso de, então você tem que dar caminho relativo começando com '/'. A estratégia recomendada é colocar seus arquivos de recursos em uma pasta "recursos" no diretório raiz. Por exemplo, se você tem a estrutura:

src/main/com/mycompany/myapp

então você pode adicionar recursos pasta como recomendado pelo Maven em:

src/main/resources

Além disso, você pode adicionar subpastas nos recursos pasta

src/main/resources/textfiles

e dizer que o arquivo é chamado myfile.txt para que você tenha

src/main/resources/textfiles/myfile.txt

Agora, aqui é onde o problema do caminho estúpido entra. Digamos que você tenha uma classe em sua com.mycompany.myapp package, e você deseja acessar o arquivo myfile.txt a partir da pasta de recursos. Alguns dizem que você precisa dar o:

"/main/resources/textfiles/myfile.txt" path

ou

"/resources/textfiles/myfile.txt"

ambos estão errados. Depois eu corri mvn clean compile, os arquivos e pastas são copiados no:

myapp/target/classes 

pasta

. Mas os recursos da pasta não está lá, apenas as pastas em recursos pasta. Então você tem:

myapp/target/classes/textfiles/myfile.txt

myapp/target/classes/com/mycompany/myapp/*

para o caminho correto para dar ao método getClass().getResource("") é:

"/textfiles/myfile.txt"

aqui está:

getClass().getResource("/textfiles/myfile.txt")

Este não irá mais retornar nulo, mas vai voltar sua classe. Espero que isso ajude alguém. É estranho para mim, que a pasta "resources" não é copiado, bem como, mas apenas as subpastas e arquivos diretamente na pasta "resources". Parece-me lógico que a pasta "resources" também ser encontrado em "myapp/target/classes"

Answer 3

Na esperança de fornecer informação adicional para aqueles que não pegar isso tão rapidamente quanto os outros, eu gostaria de oferecer meu cenário, pois tem uma configuração um pouco diferente. Meu projeto foi instalado com a seguinte estrutura de diretório (usando Eclipse):

Project/
  src/                // application source code
    org/
      myproject/
        MyClass.java
  test/               // unit tests
  res/                // resources
    images/           // PNG images for icons
      my-image.png
    xml/              // XSD files for validating XML files with JAXB
      my-schema.xsd
    conf/             // default .conf file for Log4j
      log4j.conf
  lib/                // libraries added to build-path via project settings

Eu estava tendo problemas de carregar meus recursos do res diretório. Eu queria que todos os meus recursos separar do meu código-fonte (apenas para fins de gestão / organização). Então, o que eu tinha a fazer era adicionar o res para o build-path e, em seguida, acessar o recurso via:

static final ClassLoader loader = MyClass.class.getClassLoader();

// in some function
loader.getResource("images/my-image.png");
loader.getResource("xml/my-schema.xsd");
loader.getResource("conf/log4j.conf");

NOTA: O / é omitida a partir do início da seqüência de recurso, porque eu estou usando ClassLoader.getResource (string) em vez de Class.getResource (string) .

Answer 4

@GianCarlo: Você pode tentar chamar Sistema user.dir propriedade que lhe dará raiz do seu projeto java e depois fazer acrescentar este caminho para o caminho relativo, por exemplo:

String root = System.getProperty("user.dir");
String filepath = "/path/to/yourfile.txt"; // in case of Windows: "\\path \\to\\yourfile.txt
String abspath = root+filepath;



// using above path read your file into byte []
File file = new File(abspath);
FileInputStream fis = new FileInputStream(file);
byte []filebytes = new byte[(int)file.length()];
fis.read(filebytes);

Answer 5

Quando você usa 'getResource' em uma classe, um caminho relativo é resolvido com base no pacote da classe está dentro. Quando você usa 'getResource' em um ClassLoader, um caminho relativo é resolvido com base na pasta raiz.

Se você usar um caminho absoluto, tanto métodos 'getResource' começará na pasta raiz.

Answer 6

Para aqueles que usam eclipse + Maven. Digamos que você tentar acessar o images/pic.jpg arquivo em src/main/resources. Fazendo dessa forma:

ClassLoader loader = MyClass.class.getClassLoader();
File file = new File(loader.getResource("images/pic.jpg").getFile());

é perfeitamente correto, mas pode resultar em uma exceção de ponteiro nulo. Parece eclipse não reconhece as pastas na estrutura de diretórios maven como pastas de origem imediatamente. Removendo ea pasta src/main/resources da lista pastas de origem do projeto e colocá-lo de volta (project> Propriedades> java caminho de construção> Fonte> Remover / Adicionar pasta), eu era capaz de resolver isso.

Answer 7

resourcesloader.class.getClass()

Pode ser discriminados ao:

Class<resourcesloader> clazz = resourceloader.class;
Class<Class> classClass = clazz.getClass();

O que significa que você está tentando carregar o recurso usando uma classe de bootstrap.

Em vez disso você provavelmente vai querer algo como:

resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

Se apenas javac advertiu sobre a chamada de métodos estáticos em non-static contextos ...

Answer 8

Doe o seguinte trabalho?

resourcesloader.class.getClass().getResource("/package1/resources/repository/SSL-Key/cert.jks")

Existe uma razão que você não pode especificar o caminho completo, incluindo o pacote?

Answer 9

Indo com as duas respostas como mencionado acima. O primeiro

resourcesloader.class.getClassLoader().getResource("package1/resources/repository/SSL-Key/cert.jks").toString();
resourcesloader.class.getResource("repository/SSL-Key/cert.jks").toString()

Deve ser uma e mesma coisa?

Answer 10

Eu fiz uma pequena modificação no @ de jonathan.cone um forro (adicionando .getFile()) a exceção de ponteiro evitar null, e definindo o caminho para o diretório de dados. Aqui está o que funcionou para mim:

String realmID = new java.util.Scanner(new java.io.File(RandomDataGenerator.class.getClassLoader().getResource("data/aa-qa-id.csv").getFile().toString())).next();

Answer 11

Use esta:

resourcesloader.class.getClassLoader().getResource("/path/to/file").**getPath();**

Answer 12

Para obter caminho real para o arquivo que você pode tentar o seguinte:

URL fileUrl = Resourceloader.class.getResource("resources/repository/SSL-Key/cert.jks");
String pathToClass = fileUrl.getPath;    

ResourceLoader é classname aqui. "Recursos / repositório / SSL-chaves / cert.jks" é o caminho relativo para o arquivo. Se você teve seu guiclass em ./package1/java com resto da estrutura da pasta restante, você levaria "../resources/repository/SSL-Key/cert.jks" como caminho relativo por causa das regras que definem caminho relativo.

Desta forma, você pode ler o arquivo com BufferedReader. Não use a string para identificar o caminho para o arquivo, porque se você tiver espaços ou alguns caracteres de não Inglês alfabeto em seu caminho, você vai ter problemas eo arquivo não será encontrado.

BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(fileUrl.openStream()));