Qual é a diferença entre Class.getResource () e ClassLoader.getResource ()?

Gostaria de saber qual é a diferença entre Class.getResource()e ClassLoader.getResource()?

editar: Quero saber especialmente se há armazenamento em cache no nível do arquivo / diretório. Como em "as listagens de diretório são armazenadas em cache na versão da classe?"

AFAIK o seguinte deve essencialmente fazer o mesmo, mas não é:

getClass().getResource() 
getClass().getClassLoader().getResource()

Descobri isso ao mexer em algum código de geração de relatório que cria um novo arquivo a WEB-INF/classes/partir de um arquivo existente nesse diretório. Ao usar o método de Class, pude encontrar arquivos que estavam lá na implantação usando getClass().getResource(), mas ao tentar buscar o arquivo recém-criado, recebi um objeto nulo. Navegar no diretório mostra claramente que o novo arquivo está lá. Os nomes dos arquivos foram anexados com uma barra como em "/myFile.txt".

A ClassLoaderversão do, getResource()por outro lado, encontrou o arquivo gerado. A partir dessa experiência, parece que há algum tipo de cache da listagem de diretórios em andamento. Estou certo e, em caso afirmativo, onde isso está documentado?

Nos documentos da API emClass.getResource()

Localiza um recurso com um determinado nome. As regras para pesquisar recursos associados a uma determinada classe são implementadas pelo carregador de classes que define a classe. Este método delega para o carregador de classes deste objeto. Se este objeto foi carregado pelo carregador de classes de autoinicialização, o método delega para ClassLoader.getSystemResource (java.lang.String).

Para mim, diz "Class.getResource está realmente chamando getResource () do seu próprio carregador de classe". O que seria o mesmo que fazer getClass().getClassLoader().getResource(). Mas obviamente não é. Alguém poderia me fornecer alguma iluminação sobre este assunto?

Para responder à pergunta se existe algum cache em andamento.

Investiguei esse ponto ainda mais executando um aplicativo Java independente que carregava continuamente um arquivo do disco usando o método getResourceAsStream ClassLoader. Consegui editar o arquivo e as alterações foram refletidas imediatamente, ou seja, o arquivo foi recarregado do disco sem armazenar em cache.

No entanto: estou trabalhando em um projeto com vários módulos e projetos da Web que dependem um do outro. Estou usando o IntelliJ como meu IDE para compilar e executar os projetos da web.

Percebi que as opções acima pareciam não mais ser verdadeiras, o motivo é que o arquivo que eu estava sendo carregado agora está inserido em uma jarra e implantado no projeto da Web em questão. Eu só notei isso depois de tentar alterar o arquivo na minha pasta de destino, sem sucesso. Isso fez parecer que havia um cache em andamento.

Class.getResourcepode levar um nome de recurso "relativo", que é tratado em relação ao pacote da classe. Como alternativa, você pode especificar um nome de recurso "absoluto" usando uma barra invertida. Os caminhos de recurso do carregador de classes são sempre considerados absolutos.

Portanto, o seguinte é basicamente equivalente:

foo.bar.Baz.class.getResource("xyz.txt");
foo.bar.Baz.class.getClassLoader().getResource("foo/bar/xyz.txt");

E também são esses (mas são diferentes do acima):

foo.bar.Baz.class.getResource("/data/xyz.txt");
foo.bar.Baz.class.getClassLoader().getResource("data/xyz.txt");

A primeira chamada pesquisa em relação ao .classarquivo enquanto a última pesquisa em relação à raiz do caminho de classe.

Para depurar problemas como esse, imprimo o URL:

System.out.println( getClass().getResource(getClass().getSimpleName() + ".class") );

Tinha que procurar nas especificações:

• Class.getResource (recurso String)

• ClassLoader.getResource (Recurso String)

A documentação getResource () da classe indica a diferença:

Este método delega a chamada para o carregador de classes, após fazer essas alterações no nome do recurso: se o nome do recurso começar com "/", ele não será alterado; caso contrário, o nome do pacote será anexado ao nome do recurso após a conversão de "." para "/". Se este objeto foi carregado pelo carregador de autoinicialização, a chamada é delegada para ClassLoader.getSystemResource.

Todas essas respostas por aqui, bem como as respostas desta pergunta , sugerem que o carregamento de URLs absolutos, como "/foo/bar.properties", seja tratado da mesma forma por class.getResourceAsStream(String)e class.getClassLoader().getResourceAsStream(String). Esse não é o caso, pelo menos não na minha configuração / versão do Tomcat (atualmente 7.0.40).

MyClass.class.getResourceAsStream("/foo/bar.properties"); // works!  
MyClass.class.getClassLoader().getResourceAsStream("/foo/bar.properties"); // does NOT work!

Desculpe, não tenho absolutamente nenhuma explicação satisfatória, mas acho que o tomcat faz truques sujos e sua magia negra com os carregadores de classes e causa a diferença. Eu sempre usei class.getResourceAsStream(String)no passado e não tive nenhum problema.

PS: Eu também postei isso aqui

Class.getResourcesrecuperaria o recurso pelo carregador de classes que carrega o objeto. While ClassLoader.getResourcerecuperaria o recurso usando o carregador de classe especificado.

Eu tentei ler a partir do input1.txt que estava dentro de um dos meus pacotes junto com a classe que estava tentando lê-lo.

Os seguintes trabalhos:

String fileName = FileTransferClient.class.getResource("input1.txt").getPath();

System.out.println(fileName);

BufferedReader bufferedTextIn = new BufferedReader(new FileReader(fileName));

A parte mais importante era chamar getPath()se você deseja o nome do caminho correto no formato String. NÃO USE,toString() pois ele adicionará algum texto de formatação extra que TOTALMENTE ENCONTRARÁ com o nome do arquivo (você pode experimentá-lo e ver a impressão).

Passou 2 horas depurando isso ... :(