Solução para problema ilegível de jsp
15/07/2009 10:32
1. A razão pela qual a página JSP está distorcida é que a codificação do conjunto de caracteres não está especificada na página. A solução: basta usar o seguinte código no início da página para especificar a codificação do conjunto de caracteres, <%@ page contentType=. "texto /html; conjunto de caracteres = gb2312"?
2. Caracteres ilegíveis do banco de dados. Esse tipo de caracteres ilegíveis fará com que os caracteres chineses inseridos no banco de dados se tornem caracteres ilegíveis, ou os caracteres chineses inseridos no banco de dados também serão caracteres ilegíveis quando lidos e exibidos. :
Adicione o conjunto de caracteres codificados à cadeia de conexão do banco de dados (o mesmo se aplica às conexões da fonte de dados)
String Url="jdbc:mysql://localhost/digitgulf?
usuário=root&password=root&useUnicode=true&characterEncoding=GB2312";
E use o seguinte código na página:
resposta.setContentType("text/html;charset=gb2312");
request.setCharacterEncoding("gb2312");
3. Caracteres ilegíveis ao passar chinês como parâmetro Quando passamos um caractere chinês como parâmetro para outra página, caracteres ilegíveis também aparecerão.
Codifique parâmetros ao passar parâmetros, como RearshRes.jsp?keywords=" + java.net.URLEncoder.encode(keywords)
Em seguida, use a seguinte instrução na página de parâmetros de recebimento para receber keywords=new String(request.getParameter("keywords").getBytes("8859_1"));
O problema central dos caracteres ilegíveis ainda é o problema da codificação do conjunto de caracteres. Contanto que isso seja dominado, problemas gerais de código ilegível podem ser resolvidos.
------------------------------------------
Desde que entrei em contato com Java e JSP, tenho lidado constantemente com o problema dos caracteres chineses distorcidos em Java. Agora, finalmente foi completamente resolvido. Agora compartilharemos nossa experiência de solução com todos.
1. A origem do problema Java Chinês
Os arquivos principais e de classe do Java são baseados em Unicode, o que torna os programas Java uma boa plataforma cruzada, mas também traz alguns problemas com caracteres chineses ilegíveis. Há dois motivos principais: o problema de código distorcido causado pela compilação dos próprios arquivos Java e JSP e o problema de código distorcido causado pela interação de programas Java com outras mídias.
Em primeiro lugar, os arquivos de origem Java (incluindo JSP) provavelmente contêm chinês, e o método de salvamento dos arquivos de origem Java e JSP é baseado em fluxos de bytes. Se Java e JSP forem compilados em arquivos de classe, o método de codificação usado será diferente de. o arquivo de origem Se a codificação for inconsistente, caracteres ilegíveis aparecerão. Com base neste tipo de código distorcido, é recomendado não escrever em chinês em arquivos Java (a parte do comentário não participa da compilação, não importa se você escreve em chinês, tente compilar manualmente com o parâmetro). -ecoding GBK ou -ecoding gb2312 para JSP, no cabeçalho do arquivo Adicionando <%@ page contentType="text/html;charset=GBK"%> ou <%@ page contentType="text/html;charset=gb2312"% > pode basicamente resolver esse tipo de problema de código distorcido.
Este artigo se concentrará no segundo tipo de código distorcido, que é o código distorcido gerado quando programas Java interagem com outras mídias de armazenamento. Muitas mídias de armazenamento, como bancos de dados, arquivos, fluxos, etc., são baseadas em fluxos de bytes. Quando um programa Java interage com essas mídias, a conversão entre caracteres (char) e bytes (byte) ocorrerá, por exemplo, a partir de uma página. Os dados enviados no formulário de envio exibem caracteres ilegíveis no programa Java.
Se o método de codificação usado no processo de conversão acima for inconsistente com a codificação original dos bytes, é provável que apareçam caracteres ilegíveis.
2. Solução
Para o popular Tomcat, existem duas soluções:
1) Altere D:Tomcatconfserver.xml e especifique o formato de codificação do navegador como "Chinês Simplificado":
O método é encontrar o
<Porta do conector="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redireccionamentoPort="8443" aceitaCount="100"
connectionTimeout="20000" desabilitarUploadTimeout="true" URIEncoding='GBK' />
Tags, texto em negrito adicionado por mim.
Você pode verificar se sua alteração foi bem-sucedida assim: Antes de fazer a alteração, em seu navegador IE onde a página ilegível aparece, clique no menu "Exibir | Codificação" e você verá que "Europa Ocidental (ISO)" está selecionado. Após a alteração, clique no menu “Visualizar | Codificação” e você verá que “Chinês Simplificado (GB2312)” está selecionado.
b) Atualize o programa Java. Meu programa é o seguinte:
classe pública ThreeParams estende HttpServlet {
public void doGet (solicitação HttpServletRequest, resposta HttpServletResponse)
lança ServletException, IOException {
resposta.setContentType("text/html; charset=GBK");
...
}
}
Fontes em negrito são necessárias e sua função é permitir que o navegador converta caracteres Unicode em caracteres GBK. Desta forma, o conteúdo da página e o modo de exibição do navegador são definidos como GBK, para que não haja caracteres ilegíveis.
Solução completa para chinês no Tomcat
Estou desenvolvendo um projeto esses dias. O servidor é Tomcat, o sistema operacional é Artigos e opiniões, finalmente consegui. Mas uma memória boa não é tão boa quanto uma caneta ruim, então anotei para não esquecer e também para servir de referência para quem se depara com o mesmo problema:
(1) A página JSP está em chinês, mas quando você olha para ela, ela está distorcida:
A solução é usar <%@ page language="java" contentType="text/html;charset=GBK" %> na codificação da página JSP. Devido ao problema de codificação quando Jsp é convertido em um arquivo Java, por. O padrão de alguns servidores é ISO-8859-1. Se o chinês for inserido diretamente em um JSP, definitivamente haverá um problema com o Jsp tratando-o como ISO8859-1. Podemos confirmar isso observando o arquivo intermediário Java gerado pelo Jasper.
(2) Ao usar o objeto Request para obter o código de caracteres chineses enviado pelo cliente, aparecerão caracteres ilegíveis:
A solução é configurar um filtro, que é um filtro Servelet. O código é o seguinte:
importar java.io.IOException;
importar javax.servlet.Filter;
importar javax.servlet.FilterChain;
importar javax.servlet.FilterConfig;
importar javax.servlet.ServletException;
importar javax.servlet.ServletRequest;
importar javax.servlet.ServletResponse;
classe pública CharacterEncodingFilter implementa Filter {
configuração privada do FilterConfig;
codificação de string privada = "ISO8859_1";
public void destruir() {
System.out.println(config);
configuração = nulo;
}
public void doFilter (solicitação ServletRequest, resposta ServletResponse,
Cadeia FilterChain) lança IOException, ServletException {
request.setCharacterEncoding(codificação);
//chain.doFilter(solicitação, resposta);
chain.doFilter(solicitação,resposta);
}
public void init (configuração FilterConfig) lança ServletException {
isto.config=config;
String s = config.getInitParameter("codificação");
if (s! = nulo) {
codificação = s;
}
}
}
}
Configurar web.xml
<filtro>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.SetCharacterEncodingFilter</filter-class>
</filtro>
<mapeamento de filtro>
<filter-name>CharacterEncodingFilter</filter-name>
<url-padrão>/*</url-padrão>
</filter-mapping>
Se esta situação ainda ocorrer no seu caso, você pode descer e ver se tem a quarta situação. Se os dados enviados pelo seu Formulário são enviados usando get. , dê uma olhada na quarta solução.
Há também o processamento de informações contendo caracteres chineses. O código de processamento é:
pacotedbJavaBean;
classe pública CodingConvert
{
CodingConvert público()
{
//
}
string pública toGb(String uniStr){
String gbStr = "";
if(uniStr == nulo){
uniStr = "";
}
tentar{
byte[] tempByte = uniStr.getBytes("ISO8859_1");
gbStr = new String(tempByte,"GB2312");
}
catch(Exceção ex){
}
retornar gbStr;
}
string pública toUni(String gbStr){
String uniStr = "";
if(gbStr == nulo){
gbStr = "";
}
tentar{
byte[] tempByte = gbStr.getBytes("GB2312");
uniStr = new String(tempByte,"ISO8859_1");
}catch(Exceção ex){
}
retornar uniStr;
}
}
Você também pode realizar a conversão direta. Primeiro, codifique a string obtida com ISO-8859-1, depois armazene a codificação em uma matriz de bytes e, em seguida, converta a matriz em um objeto de string.
String str=request.getParameter("menina");
Byte B[]=str.getBytes("ISO-8859-1");
Str=nova String(B);
Através da conversão acima, qualquer informação enviada pode ser exibida corretamente.
(3) Quando a solicitação Formget usa request.getParameter("name") no servidor, caracteres ilegíveis são retornados; definir o Filtro de acordo com o método do Tomcat não funciona ou usar request.setCharacterEncoding("GBK"); O problema é que em termos do método de processamento de transferência de parâmetros: Se você usar o método doGet(HttpServletRequest request, HttpServletResponse response) no servlet para processá-lo, mesmo que tenha sido escrito antes:
request.setCharacterEncoding("GBK");
resposta.setContentType("text/html;charset=GBK");
Também não funciona, o chinês devolvido ainda está distorcido! ! ! Se você alterar esta função para doPost(solicitação HttpServletRequest, resposta HttpServletResponse) tudo ficará bem.
Da mesma forma, ao usar duas páginas JSP para processar a entrada do formulário, a razão pela qual o chinês pode ser exibido é porque o método post é usado para passá-lo e alterá-lo para o método get ainda não funciona.
Percebe-se que você precisa prestar atenção ao usar o método doGet() no servlet ou o método get no JSP. Afinal, isso envolve passar informações de parâmetros através do navegador, o que provavelmente causará conflitos ou incompatibilidades em conjuntos de caracteres comumente usados.
A solução é:
1) Abra o arquivo server.xml do Tomcat, encontre o bloco e adicione a seguinte linha:
Codificação URI=”GBK”
O completo deverá ser o seguinte:
<Porta do conector = "8080" maxThreads = "150" minSpareThreads = "25" maxSpareThreads = "75" enableLookups = "false" redirecionamentoPort = "8443" aceitaCount = "100" debug = "0" connectionTimeout = "20000" desabilitarUploadTimeout = " verdadeiro" URIEncoding="GBK"/>
2) Reinicie o Tomcat, está tudo bem.
Você pode descobrir o motivo pelo qual precisa ingressar estudando o arquivo em $TOMCAT_HOME/webapps/tomcat-docs/config/http.html. Deve-se observar que se você usar UTF-8 neste local, caracteres ilegíveis aparecerão no Tomcat durante o processo de transmissão. Se isso não funcionar, mude para outro conjunto de caracteres.
(4) Existem caracteres chineses na página JSP e caracteres chineses nos botões, mas ao visualizar a página através do servidor, aparecem caracteres ilegíveis:
A solução é: Primeiro, o texto da mensagem localizada não deve ser incluído diretamente no arquivo JSP, mas o texto deve ser obtido do Pacote de Recursos por meio da tag <bean:message>. Você deve colocar seu texto em chinês no arquivo Application.properties. Este arquivo é colocado em WEB-INF/classes/*. Por exemplo, se eu tiver dois rótulos para nome e idade na página, primeiro preciso criar um Aplicativo. propriedades. O conteúdo interno deve ser name = "name" age = "age", então coloco esse arquivo em WEB-INF/classes/properties/ e codifico-o de acordo com o arquivo Application.properties para criar um arquivo de recurso chinês. , assumindo que o nome seja Application_cn.properties. O comando native2ascii é fornecido no JDK, que pode realizar a conversão de codificação de caracteres. Encontre o diretório onde você colocou o arquivo Application.properties no ambiente DOS Execute o comando no ambiente DOS. O arquivo de recurso chinês Application_cn.properties codificado em GBK será gerado: native2ascii ?encoding gbk Application.properties Application_cn.properties. o comando acima. Futuramente será gerado o arquivo Application_cn.properties com o seguinte conteúdo: name=u59d3u540d age=u5e74u9f84, configurado em Struts-config.xml: <message-resources parâmetro="properties.Application_cn"/>. Neste ponto, mais da metade está basicamente concluída. Então você deve escrever <%@ page language="java" contentType="text/html;charset=GBK" %> na página JSP. é Write <bean:message key=”name”> Quando esta alteração aparecer na página, o mesmo vale para age. Os caracteres chineses no botão também serão processados da mesma maneira.
(5) O código escrito no banco de dados está distorcido:
Solução: Configure um filtro, que é um filtro Servelet. O código é o mesmo da segunda vez.
Se você estiver conectado diretamente ao banco de dados por meio de JDBC, o código de configuração será o seguinte: jdbc:mysql://localhost:3306/workshopdb?useUnicode=true&characterEncoding=GBK Isso garantirá que o código no banco de dados não esteja ilegível.
Se você vincular por meio da fonte de dados, o procedimento acima também será adequado. Se você configurá-lo corretamente, ao inserir chinês, será chinês no banco de dados. página que exibe os dados. language="java" contentType="text/html;charset=GBK" %>Esta linha de código. Deve-se observar que alguns funcionários da recepção usam o Dreamver para escrever o código. Ao escrever um formulário, eles o alteram para um jsp. Há uma coisa a se prestar atenção: o método de envio da ação é. request, e você precisa enviá-lo, porque existem dois métodos de envio JSP: POST e GET, mas o código enviado por esses dois métodos ainda é muito diferente em termos de codificação.
Resumo do artigo:
Aqui falamos principalmente sobre a solução para o problema ilegível do jsp
1. O problema mais básico dos caracteres ilegíveis.
PHPCE.CN, Manual de Design
3. Como lidar com caracteres ilegíveis no método de envio do formulário.
Se você usar o método get para enviar em chinês, a página que aceita parâmetros também aparecerá distorcida. O motivo desse código distorcido também é causado pelo formato de codificação interno do Tomcat iso8859-1. O Tomcat codificará caracteres chineses usando o método de codificação padrão get, iso8859-1, e os anexará ao URL após a codificação, resultando em parâmetros ilegíveis / e recebidos da página.
Solução:
A. Use o primeiro método no exemplo acima para decodificar os caracteres recebidos e depois transcodificá-los.
B. Get usa envio de URL e a codificação iso8859-1 foi executada antes de inserir o URL. Para afetar essa codificação, é necessário adicionar useBodyEncodingForURI="true" ao nó do Conector em server.xml
A configuração do atributo pode controlar o método de codificação de caracteres chineses do Tomcat para o método get. O atributo acima controla o envio get a ser codificado usando o formato de codificação definido por request.setCharacterEncoding("UTF-8"). Portanto, ele é automaticamente codificado como utf-8 e a página de aceitação pode aceitá-lo normalmente. Mas acho que o verdadeiro processo de codificação é que o Tomcat precisa alterar D:Tomcatconfserver.xml e especificar o formato de codificação do navegador como "Chinês Simplificado":
<Porta do conector="8080"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redireccionamentoPort="8443" aceitaCount="100"
debug="0" connectionTimeout="20000" useBodyEncodingForURI="true"
disableUploadTimeout="true" URIEncoding="UTF-8"/> PHPCE.CN, o URIEncoding="UTF-8" definido no manual de design é codificado novamente, mas como foi codificado como utf-8, não será codificado novamente. Algo mudou. Se a codificação for obtida da URL, a página receptora será decodificada de acordo com URIEncoding="UTF-8".
Você pode saber o motivo pelo qual precisa adicioná-lo estudando o arquivo em $TOMCAT_HOME/webapps/tomcat-docs/config/http.html. Você pode verificar se sua alteração foi bem-sucedida assim: antes de fazer a alteração, uma página ilegível. aparecerá na sua página No navegador IE, clique no menu "Exibir | Codificação" e você verá que "Europa Ocidental (ISO)" está selecionado. Após a alteração, clique no menu “Visualizar | Codificação” e você verá que “Chinês Simplificado (GB2312)” está selecionado.
4. Resolva os caracteres ilegíveis ao fazer upload de arquivos Ao fazer upload de arquivos, as configurações do formulário são enctype = "multipart/form-data". Dessa forma, os arquivos são enviados em streaming. Se você usar o componente de upload do Apache, encontrará muitos códigos distorcidos. Isso ocorre porque o commons-fileupload.jar anterior do Apache tem um bug e os caracteres chineses são retirados e decodificados. Como esse método é enviado, a codificação usa automaticamente o formato de codificação padrão do Tomcat iso-8859-1. Mas o problema dos caracteres ilegíveis é: Símbolos especiais como pontos, vírgulas, etc. tornam-se caracteres ilegíveis. Se o número de caracteres chineses for um número ímpar, caracteres ilegíveis aparecerão. Se houver um número par, a análise será normal. .
Solução: Baixe commons-fileupload-1.1.1.jar Esta versão do jar resolveu esses bugs.
No entanto, ao extrair o conteúdo, você ainda precisa transcodificar os caracteres extraídos de iso8859-1 para utf-8. Todos os caracteres e caracteres chineses normais podem ser obtidos.
5. Código Java referente à solicitação de URL, recebendo parâmetros distorcidos
O formato de codificação da url depende do URIEncoding="UTF-8" mencionado acima. Se este formato de codificação for definido, significa que todos os parâmetros de caracteres chineses do URL deverão ser codificados. Caso contrário, os valores dos parâmetros dos caracteres chineses obtidos serão todos distorcidos, como um link Response.sendDerect ("/a.jsp?name=Zhang Dawei");
PHPCE.CN, Manual de Design
String name = request.getParameter("name"); o que você obtém são caracteres ilegíveis. Porque está estipulado que deve ser utf-8, então o redirecionamento deve ser escrito assim:
Response.sendDerect("/a.jsp?name=URLEncode.encode("Zhang Dawei","utf-8"); somente.
O que acontecerá se este parâmetro URIEncoding="UTF-8" não estiver definido? Se não for definido, o formato de codificação padrão iso8859-1 será usado. O problema surge novamente. O primeiro é que se o número de valores dos parâmetros for um número ímpar, ele poderá ser analisado normalmente. Se for um número par, o caractere final ficará distorcido. Além disso, se o último caractere estiver em inglês, ele poderá ser analisado normalmente, mas os sinais de pontuação chineses ainda estarão distorcidos. Como um expediente, se não houver sinais de pontuação chineses em seus parâmetros, você poderá adicionar um símbolo em inglês no final do valor do parâmetro para resolver o problema distorcido e, em seguida, remover o último símbolo após obter os parâmetros. Também pode ser raspado ou usado.
6. Em relação à solicitação de url, o código do script também controlará o redirecionamento da página se os parâmetros recebidos estiverem distorcidos. Ele também envolverá os parâmetros anexados e analisará os parâmetros na página receptora. Se este parâmetro de caracteres chineses não executar o processamento de codificação especificado por URIEncoding="UTF-8", os caracteres chineses recebidos pela página receptora também serão distorcidos. O processamento e a codificação do script são problemáticos. Você deve ter um arquivo correspondente ao script de codificação e, em seguida, chamar o método no script para codificar os caracteres chineses.
7. Em relação ao problema ilegível do jsp aberto no MyEclipse Para um projeto existente, o formato de armazenamento do arquivo Jsp pode ser utf-8. Se o Eclipse for instalado recentemente, o formato de codificação usado por padrão para abrir é iso8859-1. Portanto, os caracteres chineses em jsp estão distorcidos. Este código distorcido é relativamente fácil de resolver. Basta acessar as preferências do Eclipse3.1 e encontrar general->edidor e definir a codificação de abertura do seu arquivo para utf-8. O Eclipse reabrirá automaticamente com o novo formato de codificação. Os caracteres chineses podem ser exibidos normalmente.
8. Sobre o código ilegível ao abrir a página HTML no Eclipse Como a maioria das páginas são produzidas pelo Dreamweaver, seu formato de armazenamento é diferente do reconhecimento do Eclipse.
Geralmente, neste caso, crie um novo jsp no eclipse, copie o conteúdo da página diretamente do dreamweaver e cole-o no jsp.
PHPCE.CN, Manual de Design
Este problema de código distorcido é o problema de código distorcido mais simples. Geralmente novos aparecerão. É o código ilegível causado pela codificação inconsistente da página.
<%@ page idioma="java" pageEncoding="UTF-8"%>
<%@ page contentType="text/html;charset=iso8859-1"%>
<html>
<cabeça>
<title>Problema chinês</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
</head>
<corpo>
eu sou uma boa pessoa
</body>
</html>
Codificação em três lugares.
O formato de codificação em primeiro lugar é o formato de armazenamento do arquivo jsp. O Ecljpse salvará os arquivos de acordo com este formato de codificação. E compile o arquivo jsp, incluindo os caracteres chineses dentro dele.
A segunda codificação é o formato de decodificação. Como os arquivos salvos como UTF-8 são decodificados em iso8859-1, se houver chinês, ele definitivamente ficará distorcido. Isso significa que deve ser consistente. A linha onde está localizado o segundo lugar não precisa estar lá. O formato de codificação padrão também é ISO8859-1. Portanto, sem essa frase, “eu sou uma boa pessoa” também ficaria distorcido. Deve ser consistente.
A terceira codificação serve para controlar o método de decodificação do navegador. Se as decodificações anteriores forem consistentes e corretas, o formato de codificação não importa. Algumas páginas da web aparecem distorcidas porque o navegador não consegue determinar qual formato de codificação usar. Como às vezes as páginas são incorporadas nas páginas, o navegador confunde o formato de codificação. Caracteres distorcidos aparecem. PHPCE.CN, Manual de Design
2. O problema de caracteres ilegíveis recebidos após o envio do formulário usando o método Post também é um problema comum. Esse código ilegível também é causado pelo formato de codificação interno iso8859-1 do Tomcat. Ou seja, quando a postagem for enviada, se o formato de codificação enviado não estiver definido, ele será enviado no método iso8859-1, mas no jsp aceito. será aceito no método utf-8. resultando em caracteres ilegíveis. Por este motivo, aqui estão várias soluções e comparações.
A. Conversão de codificação ao aceitar parâmetros
String str = new String(request.getParameter("something").getBytes("ISO-8859-1"),"utf-8"); Neste caso, cada parâmetro deve ser transcodificado desta forma. Muito problemático. Mas você realmente pode obter caracteres chineses.
B. No início da página de solicitação, execute o código de codificação solicitado, request.setCharacterEncoding("UTF-8"), e defina o conjunto de caracteres do conteúdo enviado como UTF-8. Neste caso, as páginas que aceitam este parâmetro não precisam ser transcodificadas. Usar diretamente
String str = request.getParameter("something"); você pode obter os parâmetros dos caracteres chineses. Mas esta frase precisa ser executada em todas as páginas. Este método só é eficaz para envios de postagens, mas é inválido para enctype="multipart/form-data" ao enviar arquivos e fazer upload de arquivos. Os dois caracteres distorcidos serão explicados separadamente posteriormente.
C. Para evitar escrever request.setCharacterEncoding("UTF-8") em todas as páginas, é recomendado usar filtros para
Execute o processamento de codificação. Existem muitos exemplos disso online. Por favor, verifique você mesmo