jakarta.servlet.http.HttpSession Maven / Gradle / Ivy
/*
* Copyright (c) 1997, 2024 Oracle and/or its affiliates and others.
* All rights reserved.
* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package jakarta.servlet.http;
import jakarta.servlet.ServletContext;
import java.util.Enumeration;
import java.util.function.Consumer;
/**
*
* Provides a way to identify a user across more than one page request or visit to a Web site and to store information
* about that user.
*
*
* The servlet container uses this interface to create a session between an HTTP client and an HTTP server. The session
* persists for a specified time period, across more than one connection or page request from the user. A session
* usually corresponds to one user, who may visit a site many times. The server can maintain a session in many ways such
* as using cookies or rewriting URLs.
*
*
* This interface allows servlets to
*
* - View and manipulate information about a session, such as the session identifier, creation time, and last accessed
* time
*
- Bind objects to sessions, allowing user information to persist across multiple user connections
*
*
*
* When an application stores an object in or removes an object from a session, the session checks whether the object
* implements {@link HttpSessionBindingListener}. If it does, the servlet notifies the object that it has been bound to
* or unbound from the session. Notifications are sent after the binding methods complete. For session that are
* invalidated or expire, notifications are sent after the session has been invalidated or expired.
*
*
* When container migrates a session between VMs in a distributed container setting, all session attributes implementing
* the {@link HttpSessionActivationListener} interface are notified.
*
*
* A servlet should be able to handle cases in which the client does not choose to join a session, such as when cookies
* are intentionally turned off. Until the client joins the session, isNew returns true. If
* the client chooses not to join the session, getSession will return a different session on each request,
* and isNew will always return true.
*
*
* Session information is scoped only to the current web application (ServletContext), so information
* stored in one context will not be directly visible in another.
*
*
* This object is only valid within the scope of the HTTP request from which it was obtained. Once the processing
* of that request returns to the container, this object must not be used. If there is a requirement to access the
* session outside of the scope of an HTTP request then this must be done via {@code #getAccessor()}.
*
* @author Various
*
* @see HttpSessionBindingListener
*/
public interface HttpSession {
/**
*
* Returns the time when this session was created, measured in milliseconds since midnight January 1, 1970 GMT.
*
* @return a long specifying when this session was created, expressed in milliseconds since 1/1/1970 GMT
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
long getCreationTime();
/**
* Returns a string containing the unique identifier assigned to this session. The identifier is assigned by the servlet
* container and is implementation dependent.
*
* @return a string specifying the identifier assigned to this session
*/
String getId();
/**
*
* Returns the last time the client sent a request associated with this session, as the number of milliseconds since
* midnight January 1, 1970 GMT, and marked by the time the container received the request.
*
*
* Actions that your application takes, such as getting or setting a value associated with the session, do not affect
* the access time.
*
* @return a long representing the last time the client sent a request associated with this session,
* expressed in milliseconds since 1/1/1970 GMT
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
long getLastAccessedTime();
/**
* Returns the ServletContext to which this session belongs.
*
* @return The ServletContext object for the web application
* @since Servlet 2.3
*/
ServletContext getServletContext();
/**
* Specifies the time, in seconds, between client requests before the servlet container will invalidate this session.
*
*
* An interval value of zero or less indicates that the session should never timeout.
*
* @param interval An integer specifying the number of seconds
*/
void setMaxInactiveInterval(int interval);
/**
* Returns the maximum time interval, in seconds, that the servlet container will keep this session open between client
* accesses. After this interval, the servlet container will invalidate the session. The maximum time interval can be
* set with the setMaxInactiveInterval method.
*
*
* A return value of zero or less indicates that the session will never timeout.
*
* @return an integer specifying the number of seconds this session remains open between client requests
*
* @see #setMaxInactiveInterval
*/
int getMaxInactiveInterval();
/**
* Returns the object bound with the specified name in this session, or null if no object is bound under
* the name.
*
* @param name a string specifying the name of the object
*
* @return the object with the specified name
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
Object getAttribute(String name);
/**
* Returns an Enumeration of String objects containing the names of all the objects bound to
* this session.
*
* @return an Enumeration of String objects specifying the names of all the objects bound to
* this session
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
Enumeration getAttributeNames();
/**
* Binds an object to this session, using the name specified. If an object of the same name is already bound to the
* session, the object is replaced.
*
*
* After this method executes, and if the new object implements HttpSessionBindingListener, the container
* calls HttpSessionBindingListener.valueBound. The container then notifies any
* HttpSessionAttributeListeners in the web application.
*
*
* If an object was already bound to this session of this name that implements HttpSessionBindingListener,
* its HttpSessionBindingListener.valueUnbound method is called.
*
*
* If the value passed in is null, this has the same effect as calling removeAttribute().
*
*
* @param name the name to which the object is bound; cannot be null
*
* @param value the object to be bound
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
void setAttribute(String name, Object value);
/**
* Removes the object bound with the specified name from this session. If the session does not have an object bound with
* the specified name, this method does nothing.
*
*
* After this method executes, and if the object implements HttpSessionBindingListener, the container calls
* HttpSessionBindingListener.valueUnbound. The container then notifies any
* HttpSessionAttributeListeners in the web application.
*
* @param name the name of the object to remove from this session
*
* @exception IllegalStateException if this method is called on an invalidated session
*/
void removeAttribute(String name);
/**
* Invalidates this session then unbinds any objects bound to it.
*
* @exception IllegalStateException if this method is called on an already invalidated session
*/
void invalidate();
/**
* Returns true if the client does not yet know about the session or if the client chooses not to join the
* session. For example, if the server used only cookie-based sessions, and the client had disabled the use of cookies,
* then a session would be new on each request.
*
* @return true if the server has created a session, but the client has not yet joined
*
* @exception IllegalStateException if this method is called on an already invalidated session
*/
boolean isNew();
/**
* An accessor for applications to interact with a {@code HttpSession} outside of the scope of an HTTP request.
*/
interface Accessor {
/**
* Call to access the {@code HttpSession} used to obtain this {@code Accessor} from outside the scope of a HTTP request.
*
* When called, the container will call the {@link Consumer#accept(Object)} method of the {@code sessionConsumer} passed
* by the application, with an {@code HttpSession} object that represents the same {@code HttpSession} that this
* {@code Accessor} was obtained from.
*
* The passed {@code HttpSession} may be the same instance as used to obtain this {@code Accessor}, or a new instance
* for the session which has possibly been passivated and activated since the {@code Accessor} was obtained.
*
* The passed {@code HttpSession} may be shared concurrently with other {@code Accessor}s for the same session, other
* calls to this {@code Accessor} and/or {@link jakarta.servlet.Servlet}s and {@link jakarta.servlet.Filter}s.
*
* The passed {@code HttpSession} must not be used or referenced outside the scope of the call to the
* {@link Consumer#accept(Object)} method of {@code sessionConsumer}.
*
* For the purposes of session access, validity, passivation, activation etc. the container behaves as if the call to
* the {@link Consumer#accept(Object)} method of {@code sessionConsumer} occurs during the processing of an HTTP request
* for the same session.
*
* @param sessionConsumer the application provided {@link Consumer} of {@code HttpSession} to access the session.
* @throws IllegalStateException if this method is called on an invalidated session or if the session ID has changed
* since the {@code Accessor} was obtained.
*/
void access(Consumer sessionConsumer);
}
/**
* Provides a mechanism for applications to interact with this session outside the scope of an HTTP request.
*
* @return A container provided {@link Accessor} for this session or {@code null} if access is not supported outside an
* HTTP request.
* @throws IllegalStateException if this method is called on an invalidated session
*/
default Accessor getAccessor() {
return null;
}
}