L'encodage UTF-8 dans la page JSP

J'ai un JSP page dont le codage de la page est ISO-8859-1. Cette page JSP il y a à répondre à la question d'un blog. Je veux inclure des caractères spéciaux lors de Q/détachement.

Le problème est JSP n'est pas en faveur UTF-8 codage de même que j'ai changé de ISO-8859-1 à UTF-8. Ces caractères (~,%,&,+) font problème. Quand je suis à l'affichage de ces caractères, soit individuellement, soit avec la combinaison de n'importe quel caractère il est storinh null dans la base de données et quand je supprimer ces caractères, tandis que l'affichage de l'application, il fonctionne bien.

Quelqu'un peut-il suggérer une solution?

montrer le code que vous recevez les données, comment les stocker dans la base de données, la façon de vous afficher qu'il pd à jsp
C'est un code très long, je ne peux pas coller ici, mais je peux dire u le flux. L'utilisateur affiche la réponse à une question à partir d'une page jsp(un.jsp). Je suis prise toute la valeur d'un tester.js fichier (sur submit (soumettre), alors ces valeurs vont caché page jsp puis je suis l'appel de la méthode java pour afficher les données. Si un utilisateur affiche (&&&&&&&), la valeur est à venir jusqu'à tester.js fichier mais après l'envoi de la valeur de caché page jsp toutes les valeurs null.(seulement dans le cas ci-dessus décrivent caractère spécial reste fonctionne bien).
merci de poster le tester.js s'méthode qui gère la présentation

InformationsquelleAutor Shailendra | 2012-10-04

60

Vous devez utiliser le même encodage sur toutes les couches de votre application afin d'éviter ce problème. Il est utile d'ajouter un filtre pour définir l'encodage:
```
public void doFilter(ServletRequest request,
                     ServletResponse response,
                     FilterChain chain) throws ServletException {
   request.setCharacterEncoding("UTF-8");
   chain.doFilter(request, response);
}
```
De définir l'encodage des pages JSP, ajoutez cette ligne à eux:
```
<%@ page contentType="text/html; charset=UTF-8" %>
```
Configurer votre base de données à utiliser le même encodage que bien.

Si vous avez besoin de convertir l'encodage d'une chaîne de caractères, voir:
- De conversion en java
Je recommande de ne pas stocker le HTML du texte encodé dans votre base de données. Par exemple, si vous avez besoin de générer un fichier PDF (ou autre chose que de l'HTML) vous avez besoin de convertir l'encodage HTML en premier.
- Pouvez-vous expliquer un peu plus comme je suis nouveau sur ce problème. comme pour ajouter un filtre.
- Pour plus de détails et un exemple, voir le stackoverflow.com/tags/servlet-filters/info
InformationsquelleAutor Jasper de Vries
29

Le plein de balises JSP doit être quelque chose comme cela, l'esprit de la pageEncoding trop:
```
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
```
Certains vieux navigateurs gâcher avec de l'encodage trop. vous pouvez utiliser la balise HTML
```
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
```
Également le fichier doit être enregistré au format UTF-8, si vous utilisez Eclipse gauche-cliquez sur le fichier->Propriétés->découvrez ->Texte d'encodage de fichier.
- "<meta charset=UTF-8>" est suffisante.
- Que pageEncoding a fait pour moi. La balise meta seul n'a pas.
- Selon les JSP 2.1 spécification de la page 1 à 50, si aucune pageEncoding est présent, le conteneur JSP utilisera aucune valeur présente dans contentType. Je interpréter cela signifie que contentType="text/html; charset-UTF-8 est suffisante et pageEncoding="UTF-8" isallowed (mais pas nécessaire. Et notez que de toute façon ce définit simplement le retour des en-têtes HTTP; la <meta> balise est pour les anciens navigateurs qui ne respectent pas les en-têtes HTTP. (La distinction n'était pas clair dans la réponse originale à cette question.)
InformationsquelleAutor PbxMan
12

J'ai également eu un problème d'affichage des charectors comme "Ṁ Ö".J'ai ajouté ce qui suit à mon web.xml.
```
<jsp-config>
    <jsp-property-group>
        <url-pattern>*.jsp</url-pattern>
        <page-encoding>UTF-8</page-encoding>
    </jsp-property-group>
</jsp-config>
```
Cela a résolu le problème dans les pages à l'exception de l'en-tête. Essayé de nombreuses méthodes pour résoudre ce problème et rien n'a fonctionné dans mon cas. Le problème avec la tête en-tête de page jsp est inclus à partir d'un autre jsp. Donc a donné l'encodage à l'importation et qui a résolu mon problème.
```
<c:import url="/Header1.jsp" charEncoding="UTF-8"/>
```
Grâce
- Merci pour cette astuce. C'était aussi nécessaire et semble éviter d'écrire le <%@ page pageEncoding="UTF-8"%> dans chaque fichier jsp (seul problème c'est que dans mon cas, ce changement a pris effet qu'après redémarrage de Tomcat et Navigateur-Cache, et non pas directement...)
- Trouver la solution sans <jsp-config> avec Java Config seulement. Veuillez voir ma réponse ici
InformationsquelleAutor Minu George
5

Vous devez vous assurer que le fichier est enregistré avec l'encodage UTF-8.
Vous pouvez le faire avec plusieurs éditeurs de texte ordinaires. Avec Notepad++, c'est à dire, vous pouvez choisir dans le menu Encoding-->Encode in UTF-8. Vous pouvez également faire de même avec Windows bloc-notes (Save As --> Encodage UTF-8).
Si vous utilisez Eclipse, vous pouvez le configurer dans les Propriétés du fichier.

Aussi, vérifiez si le problème est que vous avez à échapper ces personnages. Il ne serait pas étrange qu'était votre problème, comme l'un des personnages est &.

InformationsquelleAutor J.A.I.L.
5

Ce fil peut vous aider à:
En passant les paramètres de la demande comme de l'UTF-8 chaînes codées

En gros:
```
request.setCharacterEncoding("UTF-8");
String login = request.getParameter("login");
String password = request.getParameter("password");
```
Ou l'utilisation de javascript sur le fichier jsp:
```
var userInput = $("#myInput").val();            
var encodedUserInput = encodeURIComponent(userInput);
$("#hiddenImput").val(encodedUserInput);
```
et après le rétablissement de la classe:
```
String parameter = URLDecoder.decode(request.getParameter("hiddenImput"), "UTF-8");
```
- En outre, j'ai ajouté le paramètre URIEncoding="UTF-8" dans la balise <Connecteur> de server.xml (dans mon cas, j'utilise Apache Tomcat)
- Cette solution est très bien, mais vous pourriez ajouter une configuration globale dans web.xml par l'ajout d'un CharacterEncodingFilter, il suffit de suivre ce lien https://stackoverflow.com/a/30276333
InformationsquelleAutor Kleber Bernardo

J'ai utilisé le filtre de codage qui a résolu mon problème d'encodage...

 package com.dina.filter;

    import java.io.IOException;
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;

    /**
     *
     * @author DINANATH
     */
    public class EncodingFilter implements Filter {

        private String encoding = "utf-8";

        public void doFilter(ServletRequest request,ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
            request.setCharacterEncoding(encoding);
    //               response.setContentType("text/html;charset=UTF-8");
                    response.setCharacterEncoding(encoding);
            filterChain.doFilter(request, response);

        }

        public void init(FilterConfig filterConfig) throws ServletException {
            String encodingParam = filterConfig.getInitParameter("encoding");
            if (encodingParam != null) {
                encoding = encodingParam;
            }
        }

        public void destroy() {
            //nothing todo
        }

    }

dans web.xml

    <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>
        com.dina.filter.EncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
    </filter>
    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

InformationsquelleAutor Dinanath Parit

4

C'est une problématique commune.

l'un de la meilleure façon de le résoudre est de vérifier si le caractère spécial est d'atteindre l'intérieur de l'action de la couche, puis en modifiant le caractère spécial dans le code java.

Si vous êtes en mesure de voir ce personnage dans l'Action ou de toute autre java couche de votre choix (couche métier), il suffit de remplacer le caractère correspondant au code HTML des caractères à l'aide de la StringEscapeUtils.html#escapeHtml

Après l'évasion. l'utilisation de la nouvelle chaîne à enregistrer dans la bd.
- eh bien, j'ai reçu votre soloution mais je ne suis pas en mesure d'obtenir le caractère spécial dans la couche de gestion lui-même. Il se perd dans la page jsp avant de venir en classe java.
- hmmm la date aurait dû être en forme et atteint l'action de la couche peut vous vérifiez sur que. si elle n'est pas à venir, vous pouvez mettre certains détails du code ou un exemple de code (sans y inclure l'ensemble de la JSP).
InformationsquelleAutor Naveen Babu
3

Ce sont des caractères spéciaux en html. Pourquoi ne pas vous l'encoder?
Check it out: http://www.degraeve.com/reference/specialcharacters.php

InformationsquelleAutor Lo Juego

Cela va vous aider.

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

InformationsquelleAutor Hasitha M Jayawardana

1

J'ai eu le même problème en utilisant des caractères spéciaux comme des séparateurs sur JSP. Lorsque les caractères spéciaux ai posté à la servlet, ils se sont foiré. J'ai résolu le problème en utilisant la conversion suivante:
```
String str = new String (request.getParameter("string").getBytes ("iso-8859-1"), "UTF-8");
```
InformationsquelleAutor Vivek Saxena

je ajouter ce script shell pour convertir des fichiers jsp EST

#!/bin/sh

###############################################
## this script file must be placed in the parent  
## folder of the to folders "in" and "out"
## in contain the input jsp files
## out will containt the generated jsp files
## 
###############################################

find in/ -name *.jsp | 
    while read line; do 
        outpath=`echo $line | sed -e 's/in/out/'` ;
        parentdir=`echo $outpath | sed -e 's/[^\/]*\.jsp$//'` ;
        mkdir -p $parentdir
        echo $outpath ;
        iconv -t UTF-8 -f ISO-8859-1 -o $outpath $line ;
    done

InformationsquelleAutor Othmen Tiliouine

0

Merci pour tous les Conseils. À l'aide de Tomcat8 j'ai aussi ajouté un filtre comme @Jasper de Vries a écrit. Mais dans la nouvelle Matous aujourd'hui, il existe un filtre déjà mis en œuvre qui peut être utilisé resp juste décommenté dans le Tomcat web.xml:
```
<filter>
    <filter-name>setCharacterEncodingFilter</filter-name>
    <filter-class>org.apache.catalina.filters.SetCharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <async-supported>true</async-supported>
</filter>
...
<filter-mapping>
    <filter-name>setCharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
```
Et comme tous les autres publiés; j'ai ajouté le URIEncoding="UTF-8" pour le Connecteur Tomcat Apache. Qui a également contribué à.

D'Important à dire, qu'Eclipse (si vous utilisez cette) a une copie de son web.xml et remplace le Tomcat-Paramètres comme il a été expliqué ici: Cassé UTF-8 URI de l'Encodage en Jsp

InformationsquelleAutor leole

Le codage de la Page ou quoi que ce soit d'autre, n'importe pas beaucoup. ISO-8859-1 est un sous-ensemble de l'UTF-8, donc vous n'aurez jamais à convertir ISO-8859-1 à UTF-8, ISO-8859-1 est déjà en UTF-8,un sous-ensemble de l'UTF-8, mais toujours en UTF-8.
De Plus, tout ce qui ne veux pas dire une chose si Vous avez un double codage quelque part.
C'est ma "guérison à tous" recette pour toutes les choses de l'encodage et le jeu de caractères liés:

        String myString = "heartbroken ð";

//La chaîne est double codé, fixer que le premier.

                myString = new String(myString.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
                String cleanedText = StringEscapeUtils.unescapeJava(myString);
                byte[] bytes = cleanedText.getBytes(StandardCharsets.UTF_8);
                String text = new String(bytes, StandardCharsets.UTF_8);
                Charset charset = Charset.forName("UTF-8");
                CharsetDecoder decoder = charset.newDecoder();
                decoder.onMalformedInput(CodingErrorAction.IGNORE);
                decoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
                CharsetEncoder encoder = charset.newEncoder();
                encoder.onMalformedInput(CodingErrorAction.IGNORE);
                encoder.onUnmappableCharacter(CodingErrorAction.IGNORE);
                try {
                    //The new ByteBuffer is ready to be read.
                    ByteBuffer bbuf = encoder.encode(CharBuffer.wrap(text));
                    //The new ByteBuffer is ready to be read.
                    CharBuffer cbuf = decoder.decode(bbuf);
                    String str = cbuf.toString();
                } catch (CharacterCodingException e) {
                    logger.error("Error Message if you want to");

                }

InformationsquelleAutor mike oganyan

Vous devez vous connecter pour publier un commentaire.