Search code examples
javaajaxservlets

How should I use servlets and Ajax?


Whenever I print something inside the servlet and call it by the web browser, it returns a new page containing that text. Is there a way to print the text on the current page using Ajax?

I'm very new to web applications and servlets.


Solution

  • Indeed, the keyword is "Ajax": Asynchronous JavaScript and XML. However, last years it's more than often Asynchronous JavaScript and JSON. Basically, you let JavaScript execute an asynchronous HTTP request and update the HTML DOM tree based on the response data.

    Since it's pretty tedious work to make it to work across all browsers (especially Internet Explorer versus others), there are plenty of JavaScript libraries out which simplifies this in single functions and covers as many as possible browser-specific bugs/quirks under the hoods, such as jQuery, Prototype, Mootools. Since jQuery is most popular these days, I'll use it in the below examples.

    Kickoff example returning String as plain text

    Create a /some.jsp like below:

    <!DOCTYPE html>
    <html lang="en">
        <head>
            <title>SO question 4112686</title>
            <script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
            <script>
                const yourServletURL = "${pageContext.request.contextPath}/yourServlet";
                $(document).on("click", "#somebutton", function() { // When HTML DOM "click" event is invoked on element with ID "somebutton", execute the following function...
                    $.get(yourServletURL, function(responseText) {  // Execute Ajax GET request on your servlet URL and execute the following function with Ajax response text...
                        $("#somediv").text(responseText);           // Locate HTML DOM element with ID "somediv" and set its text content with the response text.
                    });
                });
            </script>
        </head>
        <body>
            <button id="somebutton">press here</button>
            <div id="somediv"></div>
        </body>
    </html>
    

    Create a servlet with a doGet() method which look like this:

    @WebServlet("/yourServlet")
    public class YourServlet extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            String text = "some text";
    
            response.setContentType("text/plain");  // Set content type of the response so that jQuery knows what it can expect.
            response.setCharacterEncoding("UTF-8"); // You want world domination, huh?
            response.getWriter().write(text);       // Write response body.
        }
    }
    

    Obviously, the URL pattern of /yourServlet is free to your choice, but if you change it then you'll need to alter the /yourServlet string in the yourServletURL JS variable accordingly.

    Now open the http://localhost:8080/context/test.jsp in the browser and press the button. You'll see that the content of the div gets updated with the servlet response.

    Returning List<String> as JSON

    With JSON instead of plaintext as response format you can even get some steps further. It allows for more dynamics. First, you'd like to have a tool to convert between Java objects and JSON strings. There are plenty of them as well (see the bottom of this page for an overview). My personal favourite is Google Gson.

    Here's an example which displays List<String> as <ul><li>. The servlet:

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<String> list = new ArrayList<>();
        list.add("item1");
        list.add("item2");
        list.add("item3");
        String json = new Gson().toJson(list);
    
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(json);
    }
    

    The JavaScript code:

    $(document).on("click", "#somebutton", function() {    // When HTML DOM "click" event is invoked on element with ID "somebutton", execute the following function...
        $.get(yourServletURL, function(responseJson) {     // Execute Ajax GET request on your servlet URL and execute the following function with Ajax response JSON...
            const $ul = $("<ul>").appendTo($("#somediv")); // Create HTML <ul> element and append it to HTML DOM element with ID "somediv".
            $.each(responseJson, function(index, item) {   // Iterate over the JSON array.
                $("<li>").text(item).appendTo($ul);        // Create HTML <li> element, set its text content with currently iterated item and append it to the <ul>.
            });
        });
    });
    

    Do note that jQuery automatically parses the response as JSON and gives you directly a JSON object (responseJson) as function argument when you set the response content type to application/json. If you forget to set it or rely on a default of text/plain or text/html, then the responseJson argument wouldn't give you a JSON object, but a plain vanilla string and you'd need to manually fiddle around with JSON.parse() afterwards, which is thus totally unnecessary if you set the content type right in first place.

    Returning Map<String, String> as JSON

    Here's another example which displays Map<String, String> as <option>:

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Map<String, String> options = new LinkedHashMap<>();
        options.put("value1", "label1");
        options.put("value2", "label2");
        options.put("value3", "label3");
        String json = new Gson().toJson(options);
    
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(json);
    }
    

    And the JSP:

    $(document).on("click", "#somebutton", function() {               // When HTML DOM "click" event is invoked on element with ID "somebutton", execute the following function...
        $.get(yourServletURL, function(responseJson) {                // Execute Ajax GET request on your servlet URL and execute the following function with Ajax response JSON...
            const $select = $("#someselect");                         // Locate HTML DOM element with ID "someselect".
            $select.find("option").remove();                          // Find all child elements with tag name "option" and remove them (just to prevent duplicate options when button is pressed again).
            $.each(responseJson, function(key, value) {               // Iterate over the JSON object.
                $("<option>").val(key).text(value).appendTo($select); // Create HTML <option> element, set its value with currently iterated key and its text content with currently iterated item and finally append it to the <select>.
            });
        });
    });
    

    with

    <select id="someselect"></select>
    

    Returning List<Entity> as JSON

    Here's an example which displays List<Product> in a <table> where the Product class has the properties Long id, String name and BigDecimal price. The servlet:

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Product> products = someProductService.list();
        String json = new Gson().toJson(products);
    
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write(json);
    }
    

    The JS code:

    $(document).on("click", "#somebutton", function() {          // When HTML DOM "click" event is invoked on element with ID "somebutton", execute the following function...
        $.get(yourServletURL, function(responseJson) {           // Execute Ajax GET request on your servlet URL and execute the following function with Ajax response JSON...
            const $table = $("<table>").appendTo($("#somediv")); // Create HTML <table> element and append it to HTML DOM element with ID "somediv".
            $.each(responseJson, function(index, product) {      // Iterate over the JSON array.
                $("<tr>").appendTo($table)                       // Create HTML <tr> element, set its text content with currently iterated item and append it to the <table>.
                    .append($("<td>").text(product.id))          // Create HTML <td> element, set its text content with id of currently iterated product and append it to the <tr>.
                    .append($("<td>").text(product.name))        // Create HTML <td> element, set its text content with name of currently iterated product and append it to the <tr>.
                    .append($("<td>").text(product.price));      // Create HTML <td> element, set its text content with price of currently iterated product and append it to the <tr>.
            });
        });
    });
    

    Returning List<Entity> as XML

    Here's an example which does effectively the same as previous example, but then with XML instead of JSON. When using JSP as XML output generator you'll see that it's less tedious to code the table and all. JSTL is this way much more helpful as you can actually use it to iterate over the results and perform server side data formatting. The servlet:

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Product> products = someProductService.list();
    
        request.setAttribute("products", products);
        request.getRequestDispatcher("/WEB-INF/xml/products.jsp").forward(request, response);
    }
    

    The JSP code (note: if you put the <table> in a <jsp:include>, it may be reusable elsewhere in a non-Ajax response):

    <?xml version="1.0" encoding="UTF-8"?>
    <%@page contentType="application/xml" pageEncoding="UTF-8"%>
    <%@taglib prefix="c" uri="jakarta.tags.core" %>
    <%@taglib prefix="fmt" uri="jakarta.tags.fmt" %>
    <data>
        <table>
            <c:forEach items="${products}" var="product">
                <tr>
                    <td>${product.id}</td>
                    <td><c:out value="${product.name}" /></td>
                    <td><fmt:formatNumber value="${product.price}" type="currency" currencyCode="USD" /></td>
                </tr>
            </c:forEach>
        </table>
    </data>
    

    The JavaScript code:

    $(document).on("click", "#somebutton", function() {             // When HTML DOM "click" event is invoked on element with ID "somebutton", execute the following function...
        $.get(yourServletURL, function(responseXml) {               // Execute Ajax GET request on your servlet URL and execute the following function with Ajax response XML...
            $("#somediv").html($(responseXml).find("data").html()); // Parse XML, find <data> element and append its HTML to HTML DOM element with ID "somediv".
        });
    });
    

    You'll by now probably realize why XML is so much more powerful than JSON for the particular purpose of updating a HTML document using Ajax. JSON is funny, but after all generally only useful for so-called "public web services". MVC frameworks like JSF use XML under the covers for their ajax magic.

    Ajaxifying an existing form

    You can use jQuery $.serialize() to easily ajaxify existing POST forms without fiddling around with collecting and passing the individual form input parameters. Assuming an existing form which works perfectly fine without JavaScript/jQuery (and thus degrades gracefully when the end user has JavaScript disabled):

    <form id="someform" action="${pageContext.request.contextPath}/yourServletURL" method="post">
        <input type="text" name="foo" />
        <input type="text" name="bar" />
        <input type="text" name="baz" />
        <input type="submit" name="submit" value="Submit" />
    </form>
    

    You can progressively enhance it with Ajax as below:

    $(document).on("submit", "#someform", function(event) {
        const $form = $(this);
    
        $.post($form.attr("action"), $form.serialize(), function(response) {
            // ...
        });
    
        event.preventDefault(); // Important! Prevents submitting the form.
    });
    

    You can in the servlet distinguish between normal requests and Ajax requests as below:

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String foo = request.getParameter("foo");
        String bar = request.getParameter("bar");
        String baz = request.getParameter("baz");
    
        boolean ajax = "XMLHttpRequest".equals(request.getHeader("X-Requested-With"));
    
        // ...
    
        if (ajax) {
            // Handle Ajax (JSON or XML) response.
        } else {
            // Handle regular (JSP) response.
        }
    }
    

    The jQuery Form plugin does less or more the same as above jQuery example, but it has additional transparent support for multipart/form-data forms as required by file uploads.

    Manually sending request parameters to servlet

    If you don't have a form at all, but just wanted to interact with the servlet "in the background" whereby you'd like to POST some data, then you can use jQuery $.param() to easily convert a JSON object to an URL-encoded query string as per application/x-www-form-urlencoded content type, exactly as used by normal HTML forms, so that you can continue using request.getParameter(name) to extract the data.

    const params = {
        foo: "fooValue",
        bar: "barValue",
        baz: "bazValue"
    };
    
    $.post(yourServletURL, $.param(params), function(response) {
        // ...
    });
    

    The $.post() is essentially a shorthand for the following $.ajax() call.

    $.ajax({
        type: "POST",
        url: yourServletURL,
        data: $.param(params),
        success: function(response) {
            // ...
        }
    });
    

    The same doPost() method as shown in previous section can be reused. Do note that above $.post() syntax also works with $.get() in jQuery and doGet() in servlet.

    Manually sending JSON object to servlet

    If you however intend to send the JSON object as a whole instead of as individual request parameters for some reason, then you'd need to serialize it to a string using JSON.stringify() (not part of jQuery) and instruct jQuery to set request content type to application/json instead of (default) application/x-www-form-urlencoded. This can't be done via $.post() convenience function, but needs to be done via $.ajax() as below.

    const data = {
        foo: "fooValue",
        bar: "barValue",
        baz: "bazValue"
    };
    
    $.ajax({
        type: "POST",
        url: yourServletURL,
        contentType: "application/json", // NOT dataType!
        data: JSON.stringify(data),
        success: function(response) {
            // ...
        }
    });
    

    Do note that a lot of starters mix contentType with dataType. The contentType represents the type of the request body. The dataType represents the (expected) type of the response body, which is usually unnecessary as jQuery already autodetects it based on response's Content-Type header.

    Then, in order to process the JSON object in the servlet which isn't being sent as individual request parameters but as a whole JSON string the above way, you only need to manually parse the request body using a JSON tool instead of using getParameter() the usual way. Namely, servlets don't support application/json formatted requests, but only application/x-www-form-urlencoded or multipart/form-data formatted requests. Gson also supports parsing a JSON string into a JSON object.

    JsonObject data = new Gson().fromJson(request.getReader(), JsonObject.class);
    String foo = data.get("foo").getAsString();
    String bar = data.get("bar").getAsString();
    String baz = data.get("baz").getAsString();
    // ...
    

    Do note that this all is more clumsy than just using $.param(). Normally, you want to use JSON.stringify() only if the target service is e.g. a JAX-RS (RESTful) service which is for some reason only capable of consuming JSON strings and not regular request parameters.

    Sending a redirect from servlet

    Important to realize and understand is that any sendRedirect() and forward() call by the servlet on an ajax request would only forward or redirect the Ajax request itself and not the main document/window where the Ajax request originated. JavaScript/jQuery would in such case only retrieve the redirected/forwarded response as responseText variable in the callback function. If it represents a whole HTML page and not an Ajax-specific XML or JSON response, then all you could do is to replace the current document with it.

    document.open();
    document.write(responseText);
    document.close();
    

    Note that this doesn't change the URL as end user sees in browser's address bar. So there are issues with bookmarkability. Therefore, it's much better to just return an "instruction" for JavaScript/jQuery to perform a redirect instead of returning the whole content of the redirected page. E.g., by returning a boolean, or a URL.

    String redirectURL = "http://example.com";
    
    Map<String, String> data = new HashMap<>();
    data.put("redirect", redirectURL);
    String json = new Gson().toJson(data);
    
    response.setContentType("application/json");
    response.setCharacterEncoding("UTF-8");
    response.getWriter().write(json);
    
    function(responseJson) {
        if (responseJson.redirect) {
            window.location = responseJson.redirect;
            return;
        }
    
        // ...
    }
    

    See also: