Sonntag, Juli 5, 2020

Rückgabe eines einfachen map-Struktur von spring mvc-controller zu ajax

Bin ich mit spring mvc 4 und zu versuchen, um wieder eine einfache map zu ajax – aus meinem controller jsp-Datei.

Controller:

    @RequestMapping(value = "/ajaxtest", method = RequestMethod.GET)
    public @ResponseBody
    Map<String, String> myTest() {
        System.out.println("------------------------------------test");

        Map<String,String> myMap = new HashMap<String, String>();
        myMap.put("a", "1");
        myMap.put("b", "2");
        return myMap;
    }

Ajax aus der jsp-Datei:

function testAjax() {
        $.ajax({
            url : '../../ajaxtest.html',
            dataType: "json",
            contentType: "application/json;charset=utf-8",
            success : function(data) {
                alert("1");
                alert(data);
            }
        });
    }

Aber ich bekomme keine Warnmeldung, sondern nur die Fehler HTTP/1.1 406 Not Acceptable.

Jedoch, dass sich der code nach return ein string ist, funktioniert einwandfrei.
Controller:

    @RequestMapping(value = "/ajaxtest", method = RequestMethod.GET)
    public @ResponseBody
    String myTest() {
        System.out.println("------------------------------------test");
        return "hello";
}   

Ajax:

function testAjax() {
        $.ajax({
            url : '../../ajaxtest.html',
            success : function(data) {
                alert("1");
                alert(data);
            }
        });
    }

Alarmierung 1 und hello von ajax als erwartet.

Habe ich den jackson jar-Dateien, wie erwartet (von pom.xml):

dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.5.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.5.1</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.5.1</version>
    </dependency>

Bin ich etwas fehlt?
Ich will einfach nur, um wieder eine einfache mapping-Struktur (oder eine andere Klasse Struktur in der Zukunft).

Update:
Vom Frühjahr Konsole (nicht sicher, dass es-bezogen):
Resolving exception from handler [null]: org.springframework.web.HttpMediaTypeNotAcceptableException: Could not find acceptable representation

Vielen Dank im Voraus!
Mike

InformationsquelleAutor Mike | 2015-03-06

6 Kommentare

  1. 8

    Ich weiß nicht, ob es der richtige Weg, aber ich löste es wie folgt.

    In der Steuerung, konvertierte ich die Karte zu json:

        @RequestMapping(value = "/ajaxtest", method = RequestMethod.GET)
        public @ResponseBody
        String myTest() {
            System.out.println("------------------------------------random");
    
            Map<String,String> myMap = new HashMap<String, String>();
            myMap.put("a", "1");
            myMap.put("b", "2");
            ObjectMapper mapper = new ObjectMapper();
            String json = "";
            try {
                json = mapper.writeValueAsString(myMap);
            } catch (JsonProcessingException e) {
                //TODO Auto-generated catch block
                e.printStackTrace();
            }
            return json;
    }

    und in der jsp:

    function testAjax() {
            $.ajax({
                url : '../../ajaxtest.html',
                type:"GET",
                contentType: "application/json;charset=utf-8",
                success : function(data) {
                    alert("1");
                    alert(data);
                    var obj = jQuery.parseJSON( data );
                    alert(obj.a);
                    alert(obj.b);
                }
            });

    Dank Euch allen!!!
    Mike
    }

    • Das ist OK, aber haben Sie versucht, zu konfigurieren, wie ich es vorgeschlagen. Ansonsten müssen Sie dies tun manuelle Arbeit auf jede Anfrage, die erwartet, dass JSON, und Sie verlieren den Punkt der framework-Umgang mit den Dingen für Sie
  2. 2

    Versuchen, hinzufügen consumes="application/json" und produces={ "application/json"} an die @RequestMapping zu lassen, Frühling Prozess Ihrer json –

    UPDATE 406 Fehler Beschreibung

    HTTP-Fehler 406-Nicht akzeptabel

    Einführung

    Einem client (z.B. Ihr Webbrowser oder unser CheckUpDown-Roboter) können zeigen, um den Web-server (auf dem die Website läuft) die Merkmale der Daten, die er akzeptieren wird wieder von den Web-server. Dies geschieht mit ‚accept-Header‘ der folgenden Typen:

    Akzeptieren: Die MIME-Typen von dem Kunden akzeptiert. Zum Beispiel kann ein browser akzeptieren nur zurück Arten von Daten (HTML-Dateien, GIF-Dateien, etc.) Sie weiß, wie Sie zu verarbeiten sind.
    Accept-Charset: Der Charakter sets von dem Kunden akzeptiert.
    Accept-Encoding: – Die Verschlüsselung der Daten von dem Kunden akzeptiert z.B. die Datei-Formate versteht.
    Accept-Language: Die natürlichen Sprachen (Englisch, Deutsch, etc.) von dem Kunden akzeptiert.
    Accept-Ranges: Ob der Kunde akzeptiert, reicht der bytes, die von der Ressource, d.h. ein Teil der Ressource.
    Wenn der Web-server erkennt, dass die Daten, die er zurückkehren möchte nicht annehmbar ist, an den client, es gibt einen header zurück, mit dem 406 Fehlercode.

    Es bedeutet, dass Sie irgendwie verändert, sollten Sie Ihre server-Logik zu akzeptieren MIME/Charset/Encoding etc. der Antrag, den Sie gesendet vom client. Kann nicht genau sagen, was falsch ist, sondern versuchen zu spielen, mit Kopf-und verbraucht der RequestMapping.

    • Hinzugefügt @RequestMapping(value = "/ajaxtest", method = RequestMethod.GET, consumes="application/json", produces={ "application/json"}) aber nicht das problem lösen…
  3. 1

    Dein „problem“ ist aufgrund Ihrer Anfrage endet in .html. Sie müssen fügen Sie die folgende Konfiguration, damit es funktioniert, wie Sie erwarten, dass

    <bean id="contentNegotiationManager"              class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
        <property name="favorPathExtension" value="false" />
        <property name="defaultContentType" value="application/json" />
    </bean>
    
     <mvc:annotation-driven content-negotiation-manager="contentNegotiationManager" />

    und als tun, als @StanislavL vorgeschlagen, fügen Sie die produces={ "application/json"} nicht hinzufügen, die verbraucht verursachen Sie Ihre Buchung nicht alle JSON –

    eine Erklärung

    Wenn der Frühling bestimmt die Darstellung, die es konvertiert, sucht es zuerst in den Pfad-Teil der Anfrage (zB .html -, .json .xml), als es aussieht für einen parameter festlegen explizit die Umwandlung der Repräsentation, schließlich geht für einen Accept-header (die sogenannte PPA-Strategie)

    deshalb ist Ihr Beispiel funktioniert

    function testAjax() {
            $.ajax({
                url : '../../ajaxtest.html',
                success : function(data) {
                    alert("1");
                    alert(data);
                }
            });
        }

    du bist immer HTML zurück. Allerdings mit der bitte

    function testAjax() {
            $.ajax({
                url : '../../ajaxtest.html',
                dataType: "json",
                contentType: "application/json;charset=utf-8",
                success : function(data) {
                    alert("1");
                    alert(data);
                }
            });
        }

    sind Sie ausdrücklich zu sagen, dass Sie erwarten, dass JSON wieder vom server, jedoch .html ist deutete an, dass es sein sollte HTML statt, und Sie am Ende in Probleme

    Lernen, die details der content-negotiation-Strategie, die Sie Lesen sollten, diese blog, seine fast berühmt durch jetzt 🙂 Es wird auch zeigen Ihnen die Reine java-config-version

  4. 1

    Ihre Ajax-Aufruf sollte so Aussehen:

    $("#someId" ).click(function(){
                $.ajax({ 
                    url:"getDetails",    
                    type:"GET", 
                    contentType: "application/json; charset=utf-8",
                    success: function(responseData){
                        console.log(JSON.stringify(responseData));
                        //Success Message Handler
                    },error:function(data,status,er) { 
                        console.log(data)
                     alert("error: "+data+" status: "+status+" er:"+er);
                   }
                });
                });

    Spring-Controller-Code sollte wie folgt :

    @RequestMapping(value="/getDetails",method=RequestMethod.GET)
        public @ResponseBody Map<String,String> showExecutiveSummar(){
            Map<String,String> userDetails = new HashMap<String,String>();
            userDetails .put("ID","a" );
            userDetails .put("FirstName","b" );
            userDetails .put("MiddleName","c" );
            userDetails .put("LastName","d" );
            userDetails .put("Gender","e" );
            userDetails .put("DOB","f" );
        return userDetails 
        }

    Können Sie auch beziehen sich auf diese link für das Verständnis der Bibliothek, die diese Funktion unterstützen.

  5. 0

    Versuchen Sie dies:

     $.ajax({
            type:"GET",
            url: "/ajaxtest",
            dataType: "json",
            contentType: "application/json;charset=utf-8",
            success: function(data){
            alert("1");
            alert(data);
        }
        });
    • Nicht das problem lösen…
  6. -1

    Müssen Sie diese Abhängigkeit :

    <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version></version>
        </dependency>

    Fügen Sie diese wenn schon noch nicht :

    <bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
     <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
      <list>
        <ref bean="jacksonMessageConverter"/>
      </list>
    </property>
    </bean>
    • Hinzugefügt beide jackson-mapper-asl und jackson-core-asl in der version 1.9.2 aber immer noch nicht funktioniert…
    • Sie sind original Abhängigkeiten sind OK, spring mvc 4 verwendet jackson 2.x. Also würde ich dir raten, ganz im Gegenteil, stellen Sie sicher, dass Sie nicht über die jackson Abhängigkeiten, die vor 2.x-version. Außerdem denke ich, dass der einzige jackson-databind-dep. ist genug, wie es sollte transitiv ziehen Sie den Kern und annotation

Kostenlose Online-Tests