Classe Java.net.URI em Java

Esta classe fornece métodos para criar instâncias de URI de seus componentes ou analisando a forma de string desses componentes, para acessar e recuperar diferentes componentes de uma instância de URI.
O que é URI?
URI significa Identificador Uniforme de Recursos. Um Identificador Uniforme de Recursos é uma sequência de caracteres usada para a identificação de um recurso específico. Possibilita a interação da representação do recurso na rede por meio de protocolos específicos.

URI, URL e URN: Qual é a diferença?

A pergunta que deve estar vindo à sua mente é que se o URI identifica um recurso, o que o URL faz? As pessoas costumam usar os termos de maneira intercambiável, mas isso não é correto. De acordo com Tim Berners Lee

“Um Uniform Resource Identifier (URI) é uma sequência compacta de caracteres que identifica um recurso abstrato ou físico.”
“Um URI pode ser classificado como um localizador, um nome ou ambos. O termo "Uniform Resource Locator" (URL) se refere ao subconjunto de URI que identifica recursos por meio de uma representação de seu mecanismo de acesso primário (por exemplo, sua "localização" de rede), em vez de identificar o recurso pelo nome ou por algum outro atributo ( s) desse recurso. O termo “Uniform Resource Name” (URN) refere-se ao subconjunto de URI que devem permanecer globalmente únicos e persistentes, mesmo quando o recurso deixa de existir ou se torna indisponível. ”

Por exemplo,

https://www.geeksforgeeks.org/url-class-java-examples/

Representa um URL, pois informa o local exato onde o artigo da classe url pode ser encontrado na rede.

url-class-java-examples

Representa um URN, pois não informa nada sobre o local, mas apenas fornece um nome exclusivo para o recurso.

A diferença entre um objeto da classe URI e uma classe URL reside no fato de que uma string URI é analisada apenas levando em consideração a sintaxe e nenhuma pesquisa de host é realizada na criação. A comparação de dois objetos URI é feita exclusivamente nos caracteres contidos na string. Mas, por outro lado, uma string de URL é analisada com um certo esquema e as comparações de dois objetos de URL são realizadas procurando o recurso real na rede.

Sintaxe URI:

scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]

esquema: O componente do esquema apresenta os protocolos a serem associados ao URI. Em alguns esquemas, o “//” é necessário, enquanto outros não precisam deles.
```
abc: //admin:admin@geeksforgeeks.org:1234/path/data
             ? key = value & key2 = value2 # fragid1
```
autoridade: o componente de autoridade é feito de vários componentes - seção de autenticação, um host e um número de porta opcional precedido por um ':'. A seção de autenticação inclui nome de usuário e senha. O host pode ser qualquer endereço IP.
```
abc: // admin: admin@geeksforgeeks.org: 1234 / path / data
             ? key = value & key2 = value2 # fragid1
```

caminho: o caminho representa uma string contendo o endereço do servidor para o recurso.

abc: // admin: admin@geeksforgeeks.org: 1234 / path / data 
             ? key = value & key2 = value2 # fragid1

consulta: a consulta representa um dado não hierárquico, geralmente a consulta usada para pesquisar um recurso específico. Eles são separados por um '?' da parte anterior.
```
abc: // admin: admin@geeksforgeeks.org: 1234 / path / data
              ? key = value & key2 = value2 # fragid1
```
fragmento: os fragmentos são usados para identificar recursos secundários como títulos ou subtítulos em uma página, etc.
```
abc: // admin: admin@geeksforgeeks.org: 1234 / path / data
             ? key = value & key2 = value2 # fragid1
```

Construtores:

URI (String str) : Constrói um objeto URI analisando a string especificada. A gramática usada durante a análise é aquela especificada no RFC 2396, Apêndice A.

Sintaxe: public URI (String str)
    lança URISyntaxException
Parâmetros: 
str: String a ser analisada em URI
Lança:  
URISyntaxException: se a string violar RFC 2396

URI (esquema de string, string ssp, fragmento de string) : Constrói um URI a partir dos componentes fornecidos. Um componente pode ser deixado indefinido passando nulo. Inicialmente, a string de resultado está vazia. Se o esquema não for nulo, ele será anexado. Da mesma forma, o ssp e a parte do fragmento são anexados, se fornecidos.
```
Sintaxe: public URI (esquema de string, string ssp, fragmento de string)
    lança URISyntaxException
Parâmetros: 
esquema: nome do esquema
ssp: parte específica do esquema
fragmento: parte do fragmento
Lança: 
URISyntaxException: se a string URI construída a partir do
 componentes violam RFC 2396
```
Da mesma forma, outros construtores são fornecidos com base em quais componentes são conhecidos no momento da criação.

URI (esquema de string, string userInfo, host de string, porta int, caminho de
string, consulta de string, fragmento de string)

Sintaxe: public URI (esquema de String, String userInfo, String host, porta interna,
      Caminho da string, consulta da string, fragmento da string)
Parâmetros:
esquema: string representando esquema
userInfo: userinfo de URI
host: componente host do URI
porta: número da porta de escuta
caminho: caminho do URI
consulta: String que representa a parte da consulta
fragmento: fragmento opcional

URI (esquema de string, host de string, caminho de string, fragmento de string)

Sintaxe: public URI (String scheme, String host, String path, String fragment)
 Parâmetros:
esquema: string representando esquema
host: componente host do URI
caminho: caminho do URI
fragmento: fragmento opcional

URI (esquema de string, autoridade de string, caminho de string, consulta de string, fragmento de string)

Sintaxe: public URI (esquema de string, autoridade de string, caminho de string,
 Consulta de string, fragmento de string)
Parâmetros:
esquema: string representando esquema
autoridade: autoridade
caminho: caminho do URI
consulta: String que representa a parte da consulta

Métodos :

create(): cria um novo objeto URI. Esse método pode ser chamado de pseudo construtor. Ele é fornecido para uso nas situações em que se sabe com certeza que determinada string será analisada como o objeto URI e seria considerado um erro do programador se não fosse analisada.
```
Sintaxe: public static URI create (String str)
 Parâmetros: 
str: String a ser analisada como URI
```
parseServerAuthority(): Este método é usado para analisar os componentes de autoridade do URI, se fornecidos nas informações do usuário, host e componentes de porta. Este método retorna um objeto URI cujo campo de autoridade foi analisado como uma autoridade baseada no servidor.
```
Sintaxe: public URI parseServerAuthority()
```
normalize(): normaliza o caminho deste URI. O URI é construído normalizando o caminho do URI, que é consistente com RFC 2396. Retorna um objeto URI normalizado.
```
Sintaxe: public URI normalize()
```
resolve(): Resolve o URI fornecido com este URI. Retorna um novo URI hierárquico de maneira consistente com RFC 2396.
```
Sintaxe: public URI resolve (URI uri)
 Parâmetros:
uri: URI a ser resolvido
```
Outro método sobrecarregado que leva string como argumento e é equivalente a chamar resolve (URI.create (str)).
```
Sintaxe: public URI resolve (String str)
 Parâmetros: 
str: String a ser analisada como URI
```
relativize(): relativiza o URI fornecido em relação a este URI.
```
Sintaxe: public URI relativize (URI uri)
```
Parâmetros:
uri: URI para relativizar

toURL(): Constrói um URL a partir deste URI.

Sintaxe: public URL toURL()
          lança MalformedURLException
Lança: 
MalformedURLException: se ocorrer um erro durante a construção do URL

getScheme(): Retorna o componente de esquema do URI
```
Sintaxe: public String getScheme()
```
getRawSchemeSpecificPart(): Retorna o componente específico do esquema bruto do URI.
```
Sintaxe: public String getRawSchemeSpecificPart()
```
getSchemeSpecificPart(): Retorna o componente específico do esquema decodificado do URI
```
Sintaxe: public String getSchemeSpecificPart()
```
getRawAuthority(): Retorna o componente de autoridade do URI. Se a autoridade for baseada no servidor, serão retornadas informações adicionais do usuário, componentes de host e porta.
```
Sintaxe: public String getRawAuthority()
```
getAuthority(): Retorna resultados exatamente semelhantes aos do método acima, exceto na forma decodificada.
```
Sintaxe: public String getAuthority()
```
getRawUserInfo(): Retorna o componente de informações do usuário do URI, ou nulo se for indefinido.
```
Sintaxe: public String getRawUserInfo()
```

getUserInfo(): Retorna o componente de informações do usuário do URI no formato decodificado ou nulo se for indefinido.

Sintaxe: public String getUserInfo()

Implementação Java:

// Java program to illustrate various

// URI class methods

import java.net.*;

class uridemo1

{

public static void main(String[] args) throws Exception

{

String uribase = "https://www.geeksforgeeks.org/";

String urirelative = "languages/../java";

String str = "https://www.google.co.in/?gws_rd=ssl#"+""

+ "q=networking+in+java+geeksforgeeks"+""

+"&spf=1496918039682";

// Constructor to create a new URI

// by parsing the string

URI uriBase = new URI(uribase);

// create() method

URI uri = URI.create(str);

// toString() method

System.out.println("Base URI = " + uriBase.toString());

URI uriRelative = new URI(urirelative);

System.out.println("Relative URI = " + uriRelative.toString());

// resolve() method

URI uriResolved = uriBase.resolve(uriRelative);

System.out.println("Resolved URI = " + uriResolved.toString());

// relativized() method

URI uriRelativized = uriBase.relativize(uriResolved);

System.out.println("Relativized URI = " + uriRelativized.toString());

// normalize() method

System.out.println(uri.normalize().toString());

// getScheme() method

System.out.println("Scheme = " + uri.getScheme());

// getRawShemeSpecific() method

System.out.println("Raw Scheme = " + uri.getRawSchemeSpecificPart());

// getSchemeSpecificPart() method

System.out.println("Scheme-specific part = " + uri.getSchemeSpecificPart());

// getRawUserInfo() method

System.out.println("Raw User Info = " + uri.getRawUserInfo());

// getUserInfo() method

System.out.println("User Info = " + uri.getUserInfo());

// getAuthority() method

System.out.println("Authority = " + uri.getAuthority());

// getRawAuthority() method

System.out.println("Raw Authority = " + uri.getRawAuthority());

}

Saída :

URI de base = https://www.geeksforgeeks.org/
URI relativo = idiomas /../ java
URI resolvido = https://www.geeksforgeeks.org/java
URI relativizado = java
https://www.google.co.in/?gws_rd=ssl#q=networking+in+
java + geeksforgeeks & spf = 1496918039682
Esquema = https
Esquema bruto = //www.google.co.in/?gws_rd=ssl
Parte específica do esquema = //www.google.co.in/?gws_rd=ssl
Informação bruta do usuário = nulo
Informações do usuário = nulo
Autoridade = www.google.co.in
Raw Authority = www.google.co.in

getHost(): Retorna o componente do host do URI. Como o componente host de um URI não pode conter octetos de escape, portanto, esse método não executa nenhuma decodificação.
```
Sintaxe: public String getHost()
```
getPort(): Retorna o número da porta deste URI.
```
Sintaxe: public int getPort()
```
getRawPath(): Retorna o caminho bruto deste URI, ou nulo se não for definido.
```
Sintaxe: public String getRawPath()
```
getPath(): Retorna o componente do caminho decodificado deste URI.
```
Sintaxe: public String getPath()
```
getRawQuery(): Retorna o componente de consulta do URI ou nulo se indefinido.
```
Sintaxe: public String getRawQuery()
```
getQuery(): Retorna o componente de consulta do URI no formato decodificado ou nulo se indefinido.
```
Sintaxe: public String getQuery()
```
getRawFragment(): Retorna o componente do fragmento do URI, ou nulo se indefinido.
```
Sintaxe: public String getRawFragment()
```
getFragment(): Retorna o componente do fragmento decodificado deste URI, ou nulo se indefinido.
```
Sintaxe: public String getFragment()
```
compareTo(): compara este objeto URI com outro objeto URI. A comparação é realizada de acordo com a ordem natural com os métodos String.compareTo(). Se um componente for indefinido e outro for definido, o primeiro é considerado menor que o segundo. Os componentes a serem analisados são comparados em sua forma bruta, em vez de em sua forma codificada.
```
Sintaxe: public int compareTo (URI uri)
 Parâmetros: 
uri: URI a ser comparado
```
equals(): Testa o objeto fornecido com este URI. Ig o objeto não é um URI, ele retorna falso. Para que dois URIs sejam considerados iguais, é necessário que ambos sejam opacos ou hierárquicos. Ao verificar a igualdade de diferentes componentes, sua forma bruta é considerada, e não a forma codificada.
```
Sintaxe: public boolean equals (Object ob)
 Parâmetros: 
ob: objeto a ser comparado quanto à igualdade
```
isAbsolute(): Retorna verdadeiro se este URI for absoluto; caso contrário, retorna falso. Um URI é absoluto se, e somente se, tiver um componente de esquema.
```
Sintaxe: public boolean isAbsolute()
```
isOpaque(): Retorna verdadeiro se este URI for opaco; caso contrário, retorna falso. Um URI é opaco se, e somente se, for absoluto e sua parte específica do esquema não começar com uma barra ('/')
```
Sintaxe: public boolean isOpaque()
```
hashCode(): Retorna o hashcode para este objeto URI. Todos os componentes são levados em consideração ao criar um hashcode para o objeto URI.
```
Sintaxe: public int hashCode()
```
toString(): Retorna a representação de string deste objeto URI.
```
Sintaxe: public String toString()
```

toASCIIString(): Retorna a representação da string no formato ASCII.

Sintaxe: public String toASCIIString()

Implementação Java :

//Java Program to illustrate various

//URI class methods

import java.net.*;

class uridemo1

{

public static void main(String[] args) throws Exception

{

String str = "https://www.google.co.in/?gws_rd=ssl#"+""

+ "q=networking+in+java+geeksforgeeks"+""

+"&spf=1496918039682";

// Constructor to create a new URI

// by parsing the given string.

URI uri = new URI(str);

// getHost() method

System.out.println("Host = " + uri.getHost());

// getPort() method

System.out.println("Port = " + uri.getPath());

// getRawPath() method

System.out.println("Raw Path = " + uri.getRawPath());

// getPath() method

System.out.println("Path = " + uri.getPath());

// getQuery() method

System.out.println("Query = " + uri.getQuery());

// getRawQuery() method

System.out.println("Raw Query = " + uri.getRawQuery());

// getFragment() method

System.out.println("Fragment = " + uri.getFragment());

// getRawFragment() method

System.out.println("Raw Fragment = " + uri.getRawFragment());

URI uri2 = new URI(str + "fr");

// compareTo() mrthod

System.out.println("CompareTo =" + uri.compareTo(uri2));

// equals() method

System.out.println("Equals = " + uri.equals(uri2));

// hashcode() method

System.out.println("Hashcode : " + uri.hashCode());

// toString() method

System.out.println("toString : " + uri.toString());

// toASCIIString() method

System.out.println("toASCIIString : " + uri.toASCIIString());

}

Saída :

Host = www.google.co.in
Porta = /
Caminho bruto = /
Caminho = /
Query = gws_rd = ssl
Consulta bruta = gws_rd = ssl
Fragment = q = networking + in + java + geeksforgeeks & spf = 1496918039682
Fragmento bruto = q = networking + in + java + geeksforgeeks & spf = 1496918039682
CompareTo = -2
Igual a = falso
Hashcode: 480379574
toString: https://www.google.co.in/?gws_rd=ssl#q=networking+
em + java + geeksforgeeks & spf = 1496918039682
toASCIIString: https://www.google.co.in/?gws_rd=ssl#q=
networking + in + java + geeksforgeeks & spf = 1496918039682

Referências:
Documentação oficial do Java

Este artigo foi contribuído por Rishabh Mahrsee . Se você gosta de GeeksforGeeks e gostaria de contribuir, você também pode escrever um artigo usando contribute.geeksforgeeks.org ou enviar o seu artigo para contribute@geeksforgeeks.org. Veja o seu artigo na página principal do GeeksforGeeks e ajude outros Geeks.

Escreva comentários se encontrar algo incorreto ou se quiser compartilhar mais informações sobre o tópico discutido acima. Se você encontrar algo incorreto, escreva comentários ou se quiser compartilhar mais informações sobre o tópico discutido acima.

Acervo Lima

O maior acervo de tutoriais e referências

Classe Java.net.URI em Java

Latest posts

Latest posts

Most popular posts