Last Updated: 

Java: Convert HttpCookie to Cookie

In Java, working with cookies is a common task, especially when dealing with web applications. There are two main types of cookie classes that you'll often encounter: javax.servlet.http.Cookie and java.net.HttpCookie. The javax.servlet.http.Cookie class is part of the Java Servlet API and is mainly used in the context of web servers. On the other hand, the java.net.HttpCookie class is a standard implementation in Java SE used for client-side cookie handling in network operations. Converting a javax.servlet.http.Cookie to a java.net.HttpCookie can be necessary when you need to pass cookies between different parts of your application, such as from a servlet to a client-side HTTP request library.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Code Examples
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

This class is used in the Java Servlet environment. It represents an HTTP cookie, which is a small piece of data sent from a website and stored in the user's web browser while the user is browsing that website. It has methods to set and get various cookie attributes like name, value, domain, path, max-age, etc.

java.net.HttpCookie#

This class is part of the Java SE network package. It provides a standard way to handle cookies in client-side network operations. It also has methods to manage cookie attributes similar to javax.servlet.http.Cookie.

The main difference between the two is the context in which they are used. javax.servlet.http.Cookie is server-side, while java.net.HttpCookie is more for client-side operations.

Typical Usage Scenarios#

Passing Cookies from Servlet to HttpClient#

When you have a web application using servlets, you might want to forward cookies received in a servlet request to an external API call using HttpClient. You'll need to convert the javax.servlet.http.Cookie objects from the servlet request to java.net.HttpCookie objects that can be used with HttpClient.

Testing Web Applications#

In unit or integration testing of web applications, you may need to simulate cookie handling. Converting between the two cookie types allows you to use the appropriate cookie object in different parts of your test code.

Code Examples#

import javax.servlet.http.Cookie;
import java.net.HttpCookie;
import java.util.ArrayList;
import java.util.List;
 
public class CookieConverter {
 
    /**
     * Convert a single javax.servlet.http.Cookie to java.net.HttpCookie
     * @param servletCookie The javax.servlet.http.Cookie to convert
     * @return A converted java.net.HttpCookie
     */
    public static HttpCookie convertToNetCookie(Cookie servletCookie) {
        // Create a new java.net.HttpCookie with the same name and value
        HttpCookie netCookie = new HttpCookie(servletCookie.getName(), servletCookie.getValue());
 
        // Set the domain
        if (servletCookie.getDomain() != null) {
            netCookie.setDomain(servletCookie.getDomain());
        }
 
        // Set the path
        if (servletCookie.getPath() != null) {
            netCookie.setPath(servletCookie.getPath());
        }
 
        // Set the max - age
        netCookie.setMaxAge(servletCookie.getMaxAge());
 
        // Set the secure flag
        netCookie.setSecure(servletCookie.getSecure());
 
        // Set the HTTP - only flag
        netCookie.setHttpOnly(servletCookie.isHttpOnly());
 
        return netCookie;
    }
 
    /**
     * Convert a list of javax.servlet.http.Cookie to a list of java.net.HttpCookie
     * @param servletCookies The list of javax.servlet.http.Cookie to convert
     * @return A list of converted java.net.HttpCookie
     */
    public static List<HttpCookie> convertToNetCookies(Cookie[] servletCookies) {
        List<HttpCookie> netCookies = new ArrayList<>();
        if (servletCookies != null) {
            for (Cookie servletCookie : servletCookies) {
                netCookies.add(convertToNetCookie(servletCookie));
            }
        }
        return netCookies;
    }
}

You can use the following code to test the conversion:

import javax.servlet.http.Cookie;
import java.net.HttpCookie;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        // Create a javax.servlet.http.Cookie
        Cookie servletCookie = new Cookie("testCookie", "testValue");
        servletCookie.setDomain(".example.com");
        servletCookie.setPath("/");
        servletCookie.setMaxAge(3600);
        servletCookie.setSecure(true);
        servletCookie.setHttpOnly(true);
 
        // Convert the single cookie
        HttpCookie netCookie = CookieConverter.convertToNetCookie(servletCookie);
        System.out.println("Converted single cookie: " + netCookie);
 
        // Create an array of javax.servlet.http.Cookie
        Cookie[] servletCookies = new Cookie[]{servletCookie};
 
        // Convert the list of cookies
        List<HttpCookie> netCookies = CookieConverter.convertToNetCookies(servletCookies);
        System.out.println("Converted list of cookies: " + netCookies);
    }
}

Common Pitfalls#

Null Pointer Exceptions#

If you try to access a method on a javax.servlet.http.Cookie object without checking if it is null, you'll get a NullPointerException. For example, if the getPath() method returns null and you try to set it on the java.net.HttpCookie without a null check, it can cause issues.

Attribute Mismatch#

Some attributes may have different semantics or behavior in the two cookie classes. For example, the handling of the max - age attribute might vary slightly, so you need to ensure that the values are correctly mapped.

Best Practices#

Null Checks#

Always perform null checks before accessing methods on HttpCookie objects. This helps prevent NullPointerException.

Error Handling#

In a real-world scenario, you should add appropriate error handling in case the conversion fails. For example, you can log the error or throw a custom exception.

Keep the Code Modular#

As shown in the code examples, create separate methods for converting a single cookie and a list of cookies. This makes the code more modular and easier to maintain.

Conclusion#

Converting javax.servlet.http.Cookie to java.net.HttpCookie is a useful technique when working with Java web applications. It allows you to bridge the gap between server-side and client-side cookie handling. By understanding the core concepts, typical usage scenarios, and avoiding common pitfalls, you can effectively use this conversion in your projects.

FAQ#

A: Yes, you can. The process is similar to the conversion shown in this post. You need to map the attributes from java.net.HttpCookie to javax.servlet.http.Cookie.

A: The basic conversion code only handles the standard attributes. If you have custom attributes, you'll need to add additional logic to map those attributes between the two cookie classes.

References#

2025-10