Tratar Caracteres Especiais Em Arquivos XML

17 de outubro de 2012 8 respostas

Thiago_de_Paula_Bese 17 de outubro de 2012

Pessoal, bom dia

Estou com dúvidas em relação ao tratamento de caracteres especiais em Java para arquivos XML

Exemplo, Tenho o seguinte XML:

<?xml version="1.0" encoding="UTF-8"?>
<inutNFe xmlns="http://www.portalfiscal.inf.br/nfe" versao="2.00">
<infInut Id="ID99999999999999999999999999999999999999999">
<tpAmb>2</tpAmb>
<xServ>INUTILIZAR</xServ>
<cUF>42</cUF>
<ano>11</ano>
<CNPJ>99999999999999</CNPJ>
<mod>55</mod>
<serie>1</serie>
<nNFIni>1</nNFIni>
<nNFFin>1</nNFFin>
<xJust>Teste inutilizaçao de numeros da NFe</xJust>
</infInut>
</inutNFe>

Obs: Neste XML quero alterar na tag a palavra inutilização por inutilizacao

Criei uma função para tratar caracteres especiais, baseando neste exemplo:

º “”
“*” “”
‘"’ “”
“’” “”
º “”
& “”
° “”
§ “”
ª “”
à a
ã a
á a
â a
è e
ê e
é e
í i
õ o
ó o
ô o
ú u
ç c
ñ n
À A
Ã A
Á A
Â A
È E
Ê E
É E
Í I
Ô O
Ó O
Ô O
Ú U
Ç C
Ñ N
ø “”
Ø “”

Baseando neste exemplo, fiz esta função:

//Trata caracteres especiais
    public static String trataCaracteres(String xml)
    {
        String[] caractereBranco = {
            "\\º", "\\*", "\\'", "\\º", "\\&", "\\°", "\\§", "\\ª", "\\Ø", "\\ø"};
        
        for (int i = 0; i < caractereBranco.length; i++)
        {
            xml = xml.replaceAll(caractereBranco[i], "");
        }
            xml = xml.replaceAll("à", "a");
            xml = xml.replaceAll("ã", "a");
            xml = xml.replaceAll("á", "a");
            xml = xml.replaceAll("â", "a");
            xml = xml.replaceAll("è", "e");
            xml = xml.replaceAll("ê", "e");
            xml = xml.replaceAll("é", "e");
            xml = xml.replaceAll("í", "i");
            
            xml = xml.replaceAll("õ", "o");
            xml = xml.replaceAll("ó", "o");
            xml = xml.replaceAll("ô", "o");
            xml = xml.replaceAll("ú", "u");
            xml = xml.replaceAll("ç", "c");
            xml = xml.replaceAll("ñ", "n");
            xml = xml.replaceAll("À", "A");
            xml = xml.replaceAll("Ã", "A");
            xml = xml.replaceAll("Á", "A");
            xml = xml.replaceAll("Â", "A");
            xml = xml.replaceAll("È", "E");
            xml = xml.replaceAll("Ê", "E");
            xml = xml.replaceAll("É", "E");
            
            xml = xml.replaceAll("Í", "I");
            xml = xml.replaceAll("Ô", "O");
            xml = xml.replaceAll("Ó", "O");
            xml = xml.replaceAll("Ú", "U");
            xml = xml.replaceAll("Ç", "c");
            xml = xml.replaceAll("Ñ", "n");
           
        return xml;
    }

Entretanto, quando eu realizo a conversão com este código:

XMLEnvio = assinaXML.lerXML(caminhoXML);
XMLEnvio = XMLEnvio.replaceAll("\\n", "");
XMLEnvio = Assinador.trataCaracteres(XMLEnvio);
FileWriter fw = new FileWriter("D:\\teste_crt.xml");
fw.write(XMLEnvio);
fw.close();

O retorno da conversão vem desta forma:

<?xml version="1.0" encoding="UTF-8"?>
<inutNFe xmlns="http://www.portalfiscal.inf.br/nfe" versao="2.00">
<infInut Id="ID99999999999999999999999999999999999999999">
<tpAmb>2</tpAmb>
<xServ>INUTILIZAR</xServ>
<cUF>42</cUF>
<ano>11</ano>
<CNPJ>99999999999999</CNPJ>
<mod>55</mod>
<serie>1</serie>
<nNFIni>1</nNFIni>
<nNFFin>1</nNFFin>
<xJust>Teste inutilizaAao de numeros da NFe</xJust>
</infInut>
</inutNFe>

“inutilizaAao”? Ou seja, invéz de trocar ‘ç’ por ‘c’, é colocado um A

Sinceramente não entendi o que aconteceu

Alguém sabe me informar onde estou errando na função? É assim mesmo que se faz o método que substitui caracteres especiais? Existe algum método diferente ou mais seguro para realizar este tipo de processamento?

Desculpa pela ignorância.

Agradeço desde já…

8 Respostas

Rodrigo_Sasaki 17 de out. de 2012

Mas por que você quer remover os caracteres especiais? o serviço da sefaz envia xmls que contém caracteres especiais, é de se esperar que eles também aceitem.

Rodrigo_Sasaki 17 de out. de 2012

Em todo caso, você pode fazer uso da classe Normalizer

public static void main(String[] args){
		String str = "Teste inutilizaçao de numeros da NFe";
		System.out.println(normalizar(str));
	}

	public static String normalizar(String stringAcentuada){
		return Normalizer.normalize(stringAcentuada, Form.NFD).replaceAll("[^\\p{ASCII}]", "");
	}

Thiago_de_Paula_Bese 17 de out. de 2012

Entendi.

Estou tentando retirar os caracteres por demanda da empresa. Como você disse, creio que a SEFAZ não terá problemas em receber caracteres especiais. Mas o objetivo deste tipo de tratamento é apenas para que o XML fique em condições de aparecer no Browser IE, pois com caracteres especiais isto não é possível. Resumindo, o problema não é crítico…hehe

Vou tentar realizar o procedimento com o exemplo que você me passou, e volto jajá para postar, quem sabe, [RESOLVIDO]…rs

Obrigado

Rodrigo_Sasaki 17 de out. de 2012

Eu já usei essa solução uma vez pra remover acentuação, funcionou muito bem.

Caso você tenha as libs de commons.lang da apache, a classe StringUtils tem soluções muito mais completas para esse problema.

Thiago_de_Paula_Bese 17 de out. de 2012

Rodrigo Sasaki:
Eu já usei essa solução uma vez pra remover acentuação, funcionou muito bem.

Caso você tenha as libs de commons.lang da apache, a classe StringUtils tem soluções muito mais completas para esse problema.

Valeu pela dica, Rodrigo Sasaki.

Vou montar uma função aqui para realizar o procedimento com a classe Normalizer, e volto a postar como fiz. Valeu mesmo brother! =D

Thiago_de_Paula_Bese 17 de out. de 2012

Pessoal, acho que encontrei onde está o problema.

Quando rodo o exemplo atraves da linha de comando(DOS): java -jar CaractereEspecial.jar “D:\XML-ped-inu.xml”

Tenho o seguinte resultado (crio um arquivo .XML para armazenar a resposta)

Texto a ser tratado: Teste inutilizacao de numeros da NFeç&Ø

//Normalização inesperada quando executo a aplicação atraves do JAR
<?xml version="1.0" encoding="UTF-8"?>
<inutNFe xmlns="http://www.portalfiscal.inf.br/nfe" versao="2.00">
<infInut Id="ID99999999999999999999999999999999999999999">
<tpAmb>2</tpAmb>
<xServ>INUTILIZAR</xServ>
<cUF>42</cUF>
<ano>11</ano>
<CNPJ>99999999999999</CNPJ>
<mod>55</mod>
<serie>1</serie>
<nNFIni>1</nNFIni>
<nNFFin>1</nNFFin>
<xJust>Teste inutilizacao de numeros da NFeAA&#1596;/xJust>
</infInut>
</inutNFe>

Agora quando executo a aplicação atraves do netbeans(F6), da certo:

//Resultado esperado, agora sim!
<?xml version="1.0" encoding="UTF-8"?>
<inutNFe xmlns="http://www.portalfiscal.inf.br/nfe" versao="2.00">
<infInut Id="ID99999999999999999999999999999999999999999">
<tpAmb>2</tpAmb>
<xServ>INUTILIZAR</xServ>
<cUF>42</cUF>
<ano>11</ano>
<CNPJ>99999999999999</CNPJ>
<mod>55</mod>
<serie>1</serie>
<nNFIni>1</nNFIni>
<nNFFin>1</nNFFin>
<xJust>Teste inutilizacao de numeros da NFec</xJust>
</infInut>
</inutNFe>

Por que executando através da linha de comando não consigo a conversão esperada (como foi programado na função)?

Infelizmente aqui na empresa eles utilizam o Jar integrado no sistema ERP. Entretanto sou obrigado a executar a aplicação chamando o jar na linha de comando.

Ta faltando só isso pra mim colocar o projeto em produção. Se alguém tiver alguma dica ou solução, agradeço.

Obrigado desde já

Thiago_de_Paula_Bese 17 de out. de 2012

Criando um XML desta forma:

FileWriter fw = new FileWriter("D:\\crt_especial.xml");
fw.write(xmlTratado);
fw.close();

Obtive este resultado
Teste inutilizacao de numeros da NFeAA

Depois troquei a forma de criar o XML:

byte[] bytes = xmlTratado.getBytes("UTF-8");
FileOutputStream out = new FileOutputStream("D:\\crt_especial.xml"); 
out.write(bytes);  
out.close();

Agora tenho este resultado:
Teste inutilizacao de numeros da NFeAA?

Será que é a forma de criação do arquivo que está influenciando no problema?

Att;

Thiago_de_Paula_Bese 17 de out. de 2012

Segue o exemplo que fiz para realizar este teste:

Classe que contem os metodos:

package caractereespecial;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.*;
import java.text.Normalizer.Form;

public class Altera 
{
    public static String lerXML(String fileXML) throws IOException 
    {
        String linha = "";
        StringBuilder xml = new StringBuilder();

        BufferedReader in = new BufferedReader(new InputStreamReader(
                        new FileInputStream(fileXML)));
        while ((linha = in.readLine()) != null) {
                xml.append(linha);
        }
        in.close();

        return xml.toString();
	
    }
    
    public static String normalizar(String stringAcentuada)
    {
        return Normalizer.normalize(stringAcentuada, Form.NFD).replaceAll("[^\\p{ASCII}]", "");  
    }
    
    
    
    //Trata caracteres especiais
    public static String alteraCaractereEspecial(String xml)
    {
        String[] caractereBranco = {"\\º", "\\*", "\\'", "\\º", "\\&", "\\°", "\\§", "\\ª", "\\Ø", "\\ø"};
        
        for (int i = 0; i < caractereBranco.length; i++)
        {
            xml = xml.replaceAll(caractereBranco[i], "");
        }
            xml = xml.replaceAll("à", "a");
            xml = xml.replaceAll("ã", "a");
            xml = xml.replaceAll("á", "a");
            xml = xml.replaceAll("â", "a");
            xml = xml.replaceAll("è", "e");
            xml = xml.replaceAll("ê", "e");
            xml = xml.replaceAll("é", "e");
            xml = xml.replaceAll("í", "i");
            
            xml = xml.replaceAll("õ", "o");
            xml = xml.replaceAll("ó", "o");
            xml = xml.replaceAll("ô", "o");
            xml = xml.replaceAll("ú", "u");
            xml = xml.replaceAll("ç", "c");
            xml = xml.replaceAll("ñ", "n");
            xml = xml.replaceAll("À", "A");
            xml = xml.replaceAll("Ã", "A");
            xml = xml.replaceAll("Á", "A");
            xml = xml.replaceAll("Â", "A");
            xml = xml.replaceAll("È", "E");
            xml = xml.replaceAll("Ê", "E");
            xml = xml.replaceAll("É", "E");
            
            xml = xml.replaceAll("Í", "");
            xml = xml.replaceAll("Ô", "");
            xml = xml.replaceAll("Ó", "");
            xml = xml.replaceAll("Ú", "");
            xml = xml.replaceAll("Ç", "");
            xml = xml.replaceAll("Ñ", "");
           
        return xml;
    }
}

E a classe main (por testes, fiz para rodar na linha de comando ou para executar pelo NetBeans):

package caractereespecial;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;

public class CaractereEspecial {

    public static void main(String[] args) throws IOException 
    {
        
        //String caminhoXML = "D:\\XML-ped-inu.xml";
        String caminhoXML = args[0];
        
        String xmlEnvio = Altera.lerXML(caminhoXML);
        
        String xmlTratado = Altera.alteraCaractereEspecial(xmlEnvio);
        
        
        System.out.println(xmlTratado);
        
        /*
        FileWriter fw = new FileWriter("D:\\crt_especial.xml");
        fw.write(xmlTratado);
        fw.close();
        
        * 
        */
        
        byte[] bytes = xmlTratado.getBytes("UTF-8");
        FileOutputStream out = new FileOutputStream("D:\\crt_especial.xml"); 
        out.write(bytes);  
        out.close();
       
         
    }
}

att;

Criado 17 de outubro de 2012

Ultima resposta 17 de out. de 2012

Respostas 8

Participantes 2

8 Respostas

Topicos relacionados