Jakarta EE 11 from Newbie to Pro with Open Liberty

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Product {
    @Id
    private Long id;
    private String name;
    private String description;
    private double price;
    private int stockQuantity;

    // Constructors, getters, and setters
    public Product() {}

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    // Getters and setters omitted for brevity
}

import jakarta.data.repository.Repository;
import jakarta.data.repository.Find;
import jakarta.data.repository.Query;
import jakarta.data.repository.Save;
import jakarta.data.repository.Delete;
import jakarta.data.repository.OrderBy;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import java.util.List;
import java.util.Optional;

@Repository
public interface ProductRepository {

    // Basic CRUD operations
    @Save
    Product save(Product product);

    @Find
    Optional<Product> findById(Long id);

    @Delete
    void delete(Product product);

    // Query by method name - automatically generates query
    List<Product> findByName(String name);

    List<Product> findByPriceLessThan(double price);

    List<Product> findByPriceBetween(double minPrice, double maxPrice);

    List<Product> findByNameContains(String keyword);

    // Sorting and pagination - requires @OrderBy for pagination
    @OrderBy("price")
    Page<Product> findByPriceGreaterThan(double price, PageRequest pageRequest);

    // Custom queries using @Query annotation
    @Query("SELECT p FROM Product p WHERE p.stockQuantity < 10")
    List<Product> findLowStockProducts();

    @Query("SELECT p FROM Product p WHERE p.price > ?1 ORDER BY p.price DESC")
    List<Product> findExpensiveProducts(double minPrice);
}

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.inject.Inject;
import jakarta.data.page.Page;
import jakarta.data.page.PageRequest;
import java.util.List;

@Path("/products")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ProductResource {

    @Inject
    private ProductRepository productRepository;

    @POST
    public Response createProduct(Product product) {
        Product created = productRepository.save(product);
        return Response.status(Response.Status.CREATED).entity(created).build();
    }

    @GET
    @Path("/search")
    public List<Product> searchProducts(@QueryParam("keyword") String keyword) {
        return productRepository.findByNameContains(keyword);
    }

    @GET
    @Path("/expensive")
    public Page<Product> getExpensiveProducts(
            @QueryParam("minPrice") @DefaultValue("100.0") double minPrice,
            @QueryParam("page") @DefaultValue("1") int page,
            @QueryParam("size") @DefaultValue("20") int size) {
        PageRequest pageRequest = PageRequest.ofPage(page).size(size);
        return productRepository.findByPriceGreaterThan(minPrice, pageRequest);
    }

    @GET
    @Path("/low-stock")
    public List<Product> getLowStockProducts() {
        return productRepository.findLowStockProducts();
    }
}

import jakarta.security.auth.message.AuthException;
import jakarta.security.auth.message.AuthStatus;
import jakarta.security.auth.message.MessageInfo;
import jakarta.security.auth.message.MessagePolicy;
import jakarta.security.auth.message.module.ServerAuthModule;
import jakarta.security.auth.message.callback.CallerPrincipalCallback;
import jakarta.security.auth.message.callback.GroupPrincipalCallback;
import jakarta.security.auth.message.callback.Callback;
import jakarta.security.auth.message.callback.CallbackHandler;
import jakarta.security.auth.message.callback.UnsupportedCallbackException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.Principal;
import java.util.Map;
import java.util.Set;

public class CustomServerAuthModule implements ServerAuthModule {

    private CallbackHandler handler;

    @Override
    @SuppressWarnings("rawtypes")
    public void initialize(MessagePolicy requestPolicy, MessagePolicy responsePolicy,
                          CallbackHandler handler, Map options) throws AuthException {
        this.handler = handler;
    }

    @Override
    public AuthStatus validateRequest(MessageInfo messageInfo,
                                      jakarta.security.auth.message.callback.Subject clientSubject,
                                      jakarta.security.auth.message.callback.Subject serviceSubject)
                                      throws AuthException {
        // Extract credentials from request
        String username = extractUsername(messageInfo);
        String password = extractPassword(messageInfo);

        if (validateCredentials(username, password)) {
            // Set the caller principal
            CallerPrincipalCallback principalCallback =
                new CallerPrincipalCallback(clientSubject, username);

            // Set the groups
            GroupPrincipalCallback groupCallback =
                new GroupPrincipalCallback(clientSubject, new String[]{"users"});

            try {
                handler.handle(new Callback[]{principalCallback, groupCallback});
            } catch (IOException | UnsupportedCallbackException e) {
                throw new AuthException(e.getMessage());
            }

            return AuthStatus.SUCCESS;
        }

        return AuthStatus.FAILURE;
    }

    @Override
    public AuthStatus secureResponse(MessageInfo messageInfo,
                                     jakarta.security.auth.message.callback.Subject serviceSubject)
            throws AuthException {
        return AuthStatus.SEND_SUCCESS;
    }

    @Override
    public void cleanSubject(MessageInfo messageInfo,
                            jakarta.security.auth.message.callback.Subject subject)
                            throws AuthException {
        if (subject != null) {
            Set<Principal> principals = subject.getPrincipals();
            if (principals != null) {
                principals.clear();
            }
        }
    }

    @Override
    public Class<?>[] getSupportedMessageTypes() {
        return new Class<?>[]{HttpServletRequest.class, HttpServletResponse.class};
    }

    private String extractUsername(MessageInfo messageInfo) {
        // Extract username from request
        return "user";
    }

    private String extractPassword(MessageInfo messageInfo) {
        // Extract password from request
        return "password";
    }

    private boolean validateCredentials(String username, String password) {
        // Validate credentials
        return username != null && password != null;
    }
}

import jakarta.enterprise.util.Nonbinding;
import jakarta.interceptor.InterceptorBinding;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@InterceptorBinding
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Logged {
    @Nonbinding
    String value();
}

@Logged("myName")
public void myMethod() {
    // ....
}

@Interceptor
@Logged("")
public class LoggedInterceptor {

    @AroundInvoke
    public Object logInvocation(InvocationContext context) throws Exception {
        // NEW in CDI 4.1: Find the @Logged annotation and extract its value
        String logName = context.getInterceptorBinding(Logged.class).value();

        System.out.println("Invoking method with log name: " + logName);

        try {
            Object result = context.proceed();
            System.out.println("Method completed successfully");
            return result;
        } catch (Exception e) {
            System.out.println("Method failed with exception: " + e.getMessage());
            throw e;
        }
    }
}

@ApplicationScoped
public class MyBean {

    @Alert
    public void myAlert1(int id) {
        // Do something
    }

    @Alert
    public void myAlert2(int id, MyOtherBean otherBean) {
        // Do something with otherBean
    }
}

public class InvokerExtension implements Extension {

    public static record AlertMethod(Invoker<?,?> invoker, int parameterCount) { }
    List<AlertMethod> alertMethods = new ArrayList<>();

    public <T> void createInvokers(@Observes @WithAnnotations(Alert.class) ProcessManagedBean<T> pmb) {
        for (AnnotatedMethod<? super T> m : pmb.getAnnotatedBeanClass().getMethods()) {
            if (m.isAnnotationPresent(Alert.class)) {
                validate(m);

                InvokerBuilder<Invoker<T, ?>> builder = pmb.createInvoker(m);

                // Look up the bean instance when invoking
                builder.withInstanceLookup();

                // Look up all arguments except the first
                int parameterCount = m.getParameters().size();
                for (int i = 1; i < parameterCount; i++) {
                    builder.withArgumentLookup(i);
                }

                alertMethods.add(new AlertMethod(builder.build(), parameterCount));
            }
        }
    }
}

public void invokeAlerts(int i) throws Exception {
    for (AlertMethod method : alertMethods) {
        // Construct an array of arguments
        Object[] args = new Object[method.parameterCount];
        // First argument is the alert id
        args[0] = i;
        // All other arguments are looked up from CDI, so we pass in null

        // Call the method
        method.invoker.invoke(null, args);
    }
}

@ApplicationScoped
@Priority(10)
public class ProducerClass {

    @Produces
    @Alternative
    public String produceString() {
        return "OK";
    }
}

@ApplicationScoped
public class ProducerClass {

    @Produces
    @Alternative
    @Priority(10)
    public String produceString() {
        return "OK";
    }
}

// Check if a bean matches an injection point
boolean isMatchingBean(Set<Type> beanTypes,
                      Set<Annotation> beanQualifiers,
                      Type requiredType,
                      Set<Annotation> requiredQualifiers);

// Check if an event matches an observer
boolean isMatchingEvent(Type specifiedType,
                       Set<Annotation> specifiedQualifiers,
                       Type observedEventType,
                       Set<Annotation> observedEventQualifiers);

import jakarta.el.*;
import java.util.Arrays;

public class ArrayLengthExample {

    public static void main(String[] args) {
        // Create EL context
        ExpressionFactory factory = ExpressionFactory.newInstance();
        StandardELContext context = new StandardELContext(factory);

        // Create an array and add it to the context
        String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};
        context.getELResolver().setValue(context, null, "fruits", fruits);

        // NEW in EL 6.0: Use the 'length' property to get array size
        ValueExpression lengthExpr = factory.createValueExpression(
            context, "${fruits.length}", Integer.class);
        Integer length = (Integer) lengthExpr.getValue(context);

        System.out.println("Array length: " + length); // Output: 5

        // You can also use it in conditional expressions
        ValueExpression hasItemsExpr = factory.createValueExpression(
            context, "${fruits.length > 0}", Boolean.class);
        Boolean hasItems = (Boolean) hasItemsExpr.getValue(context);

        System.out.println("Has items: " + hasItems); // Output: true
    }
}

import jakarta.el.*;

// Define a Java Record
public record Product(String name, double price, int quantity) {
    public double totalValue() {
        return price * quantity;
    }
}

public class RecordELResolverExample {

    public static void main(String[] args) {
        // Create EL context
        ExpressionFactory factory = ExpressionFactory.newInstance();
        StandardELContext context = new StandardELContext(factory);

        // Create a Record instance
        Product product = new Product("Laptop", 999.99, 5);
        context.getELResolver().setValue(context, null, "product", product);

        // NEW in EL 6.0: Access Record components directly
        ValueExpression nameExpr = factory.createValueExpression(
            context, "${product.name}", String.class);
        String name = (String) nameExpr.getValue(context);
        System.out.println("Product name: " + name); // Output: Laptop

        ValueExpression priceExpr = factory.createValueExpression(
            context, "${product.price}", Double.class);
        Double price = (Double) priceExpr.getValue(context);
        System.out.println("Product price: " + price); // Output: 999.99

        // Access Record methods
        ValueExpression totalExpr = factory.createValueExpression(
            context, "${product.totalValue()}", Double.class);
        Double total = (Double) totalExpr.getValue(context);
        System.out.println("Total value: " + total); // Output: 4999.95
    }
}

import jakarta.el.*;
import java.util.Optional;

public class OptionalELResolverExample {

    public static void main(String[] args) {
        // Create EL context
        ExpressionFactory factory = ExpressionFactory.newInstance();
        StandardELContext context = new StandardELContext(factory);

        context.addELResolver(new OptionalELResolver());

        // Create Optional values
        Optional<String> presentValue = Optional.of("Hello, EL 6.0!");
        Optional<String> emptyValue = Optional.empty();

        context.getELResolver().setValue(context, null, "message", presentValue);
        context.getELResolver().setValue(context, null, "emptyValue", emptyValue);

        // Access Optional values - automatically unwrapped if present
        ValueExpression messageExpr = factory.createValueExpression(
            context, "${message}", String.class);
        String message = (String) messageExpr.getValue(context);
        System.out.println("Message: " + message); // Output: Hello, EL 6.0!

        // Empty Optional returns null
        ValueExpression emptyExpr = factory.createValueExpression(
            context, "${emptyValue}", String.class);
        String emptyResult = (String) emptyExpr.getValue(context);
        System.out.println("emptyValue: " + emptyResult); // Output: null

        // Use with conditional expressions
        ValueExpression hasMsgExpr = factory.createValueExpression(
            context, "${message != null}", Boolean.class);
        Boolean hasMessage = (Boolean) hasMsgExpr.getValue(context);
        System.out.println("Has message: " + hasMessage); // Output: true
    }
}

<!-- Using the new length property for arrays -->
<h:outputText value="Total items: #{products.length}" />

<h:panelGroup rendered="#{products.length > 0}">
    <ui:repeat value="#{products}" var="product">
        <h:outputText value="#{product.name}: $#{product.price}" />
    </ui:repeat>
</h:panelGroup>

<!-- Using Records in EL expressions -->
<h:outputText value="#{productRecord.name}" />
<h:outputText value="#{productRecord.price}" />
<h:outputText value="Total: $#{productRecord.totalValue()}" />

<!-- Conditional rendering based on array length -->
<h:outputText value="No products available"
              rendered="#{products.length == 0}" />

import jakarta.faces.view.ViewScoped;
import jakarta.inject.Named;
import jakarta.faces.convert.UUIDConverter;
import java.io.Serializable;
import java.util.UUID;

@Named
@ViewScoped
public class EntityBean implements Serializable {

    private UUID entityId;
    private String entityName;

    public void init() {
        // NEW in Faces 4.1: UUIDConverter automatically handles UUID conversion
        // Generate a new UUID for the entity
        entityId = UUID.randomUUID();
    }

    public void saveEntity() {
        System.out.println("Saving entity with ID: " + entityId);
        // The UUID is automatically converted to/from String in the view
    }

    // Getters and setters
    public UUID getEntityId() { return entityId; }
    public void setEntityId(UUID entityId) { this.entityId = entityId; }
    public String getEntityName() { return entityName; }
    public void setEntityName(String entityName) { this.entityName = entityName; }
}

<!-- The UUID is automatically converted using the new UUIDConverter -->
<h:form>
    <h:outputLabel value="Entity ID:" />
    <h:inputText value="#{entityBean.entityId}" />

    <h:outputLabel value="Entity Name:" />
    <h:inputText value="#{entityBean.entityName}" />

    <h:commandButton value="Save" action="#{entityBean.saveEntity}" />
</h:form>

<!-- Display UUID -->
<h:outputText value="Current ID: #{entityBean.entityId}" />

import jakarta.faces.flow.Flow;
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.io.Serializable;

@Named
@ViewScoped
public class FlowAwareBean implements Serializable {

    // NEW in Faces 4.1: Direct injection of current Flow
    @Inject
    private Flow currentFlow;

    public String getFlowInfo() {
        if (currentFlow != null) {
            return "Current flow: " + currentFlow.getId();
        }
        return "Not in a flow";
    }

    public boolean isInFlow() {
        return currentFlow != null;
    }

    public String getFlowId() {
        return currentFlow != null ? currentFlow.getId() : null;
    }
}

<!-- NEW in Faces 4.1: rowStatePreserved property for UIRepeat -->
<!-- This preserves the state of each row, similar to UIData -->
<ui:repeat value="#{productBean.products}" var="product"
           rowStatePreserved="true">
    <h:panelGroup>
        <h:outputText value="#{product.name}: " />
        <h:inputText value="#{product.quantity}" />
        <h:commandButton value="Update"
                        action="#{productBean.updateProduct(product)}" />
    </h:panelGroup>
</ui:repeat>

import jakarta.faces.context.ExternalContext;
import jakarta.faces.context.FacesContext;
import jakarta.inject.Named;
import jakarta.enterprise.context.RequestScoped;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

@Named
@RequestScoped
public class FileDownloadBean {

    public void downloadLargeFile() throws IOException {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        ExternalContext externalContext = facesContext.getExternalContext();

        // Simulate a large file (> 2GB)
        long fileSize = 3_000_000_000L; // 3GB

        externalContext.responseReset();
        externalContext.setResponseContentType("application/octet-stream");
        externalContext.setResponseHeader("Content-Disposition",
            "attachment; filename=\"largefile.bin\"");

        // NEW in Faces 4.1: setResponseContentLengthLong for files > 2GB
        externalContext.setResponseContentLengthLong(fileSize);

        try (OutputStream output = externalContext.getResponseOutputStream()) {
            // Write file content
            // ... (implementation details)
        }

        facesContext.responseComplete();
    }
}

import jakarta.faces.application.FacesMessage;
import jakarta.faces.context.FacesContext;
import jakarta.inject.Named;
import jakarta.enterprise.context.RequestScoped;

@Named
@RequestScoped
public class MessageBean {

    public void demonstrateGenericMessages() {
        FacesContext context = FacesContext.getCurrentInstance();

        // NEW in Faces 4.1: FacesMessage.VALUES and VALUES_MAP are now generic
        // This provides better type safety when working with message severities

        FacesMessage infoMsg = new FacesMessage(
            FacesMessage.SEVERITY_INFO,
            "Information",
            "This is an info message"
        );

        FacesMessage warnMsg = new FacesMessage(
            FacesMessage.SEVERITY_WARN,
            "Warning",
            "This is a warning message"
        );

        FacesMessage errorMsg = new FacesMessage(
            FacesMessage.SEVERITY_ERROR,
            "Error",
            "This is an error message"
        );

        // NEW in Faces 4.1: FacesMessage now implements equals(), hashCode(), toString()
        System.out.println(infoMsg.toString());

        // Compare messages
        FacesMessage anotherInfoMsg = new FacesMessage(
            FacesMessage.SEVERITY_INFO,
            "Information",
            "This is an info message"
        );

        if (infoMsg.equals(anotherInfoMsg)) {
            System.out.println("Messages are equal");
        }

        context.addMessage(null, infoMsg);
        context.addMessage(null, warnMsg);
        context.addMessage(null, errorMsg);
    }
}

@InMemoryIdentityStoreDefinition (
    priority = 10,
    priorityExpression = "${80/20}",
    useFor = {VALIDATE, PROVIDE_GROUPS},
    useForExpression = "#{'VALIDATE'}",
    value = {
        @Credentials(callerName = "jasmine", password = "secret1", groups = { "caller", "user" } )
    }
)

@InMemoryIdentityStoreDefinition (
    value = {
        @Credentials(callerName = "jasmine",  password = "{xor}LDo8LTorbg==", groups = { "caller", "user" } ),
        @Credentials(callerName = "frank", groups = { "user" }, password = "{hash}ARAAA <sequence shortened> Fyyw=="),
        @Credentials(callerName = "sally", groups = { "user" }, password = "{aes}ARAFIYJ <sequence shortened> WRQNA==")
    }
)

wlp/bin/securityUtility encode --encoding=xor
Enter text: <enter text to encode>
Re-enter text:
{xor}PTA9Lyg

<server>
    ...
    <featureManager>
        <feature>appSecurity-4.0</feature>
    </featureManager>
    <appSecurity allowInMemoryIdentityStores="true" />
    ...
</server>

@BasicAuthenticationMechanismDefinition(realmName="basicAuth")

@FormAuthenticationMechanismDefinition(
                loginToContinue = @LoginToContinue(errorPage = "/form-login-error.html",
                loginPage = "/form-login.html"))

@CustomFormAuthenticationMechanismDefinition(
                loginToContinue = @LoginToContinue(errorPage = "/custom-login-error.html",
                loginPage = "/custom-login.html"))

@ApplicationScoped
// @Priority is optional and used to control selection priority if multiple custom definitions exist
@Priority(100)
public class CustomHAM implements HttpAuthenticationMechanism {

    @Override
    public AuthenticationStatus validateRequest(
        HttpServletRequest request,
        HttpServletResponse response,
        HttpMessageContext httpMessageContext) throws AuthenticationException {

            // implement custom logic here, and return an AuthenticationStatus
            return AuthenticationStatus.NOT_DONE;
    }
}

    @Inject
    private SecurityContext securityContext;

    Set<String> allDeclaredCallerRoles = securityContext.getAllDeclaredCallerRoles();

    System.out.println("All declared caller roles for caller ["
        + securityContext.getCallerPrincipal().getName()
        + "] are "
        + allDeclaredCallerRoles.toString());

    @GET
    @Path("/info")
    @Produces(MediaType.APPLICATION_JSON)
    public String getSecureInfo() {
        String username = securityContext.getUserPrincipal().getName();
        boolean isAdmin = securityContext.isUserInRole("ADMIN");

        return String.format(
            "{\"user\": \"%s\", \"isAdmin\": %b}",
            username,
            isAdmin
        );
    }

    @GET
    @Path("/admin")
    @Produces(MediaType.TEXT_PLAIN)
    public String adminOnly() {
        if (!securityContext.isUserInRole("ADMIN")) {
            throw new SecurityException("Admin access required");
        }
        return "Welcome, administrator!";
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/redirect-example")
public class RedirectServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        String action = request.getParameter("action");

        if ("permanent".equals(action)) {
            // Send a 301 Moved Permanently redirect
            response.sendRedirect("/new-location", HttpServletResponse.SC_MOVED_PERMANENTLY);
        } else if ("temporary".equals(action)) {
            // Send a 307 Temporary Redirect (preserves request method)
            response.sendRedirect("/temp-location", HttpServletResponse.SC_TEMPORARY_REDIRECT);
        } else {
            // Default 302 Found redirect
            response.sendRedirect("/default-location");
        }
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;

@WebServlet("/charset-example")
public class CharsetServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // Use Charset instead of String for character encoding
        response.setCharacterEncoding(StandardCharsets.UTF_8);
        response.setContentType("text/html");

        PrintWriter writer = response.getWriter();
        writer.println("<html><body>");
        writer.println("<h1>UTF-8 Encoded Response</h1>");
        writer.println("<p>Special characters: é, ñ, ü, 中文</p>");
        writer.println("</body></html>");
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.ServletOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

@WebServlet("/bytebuffer-example")
public class ByteBufferServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        response.setContentType("application/octet-stream");

        // Create a ByteBuffer with data
        String data = "Binary data using ByteBuffer";
        ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));

        // Write ByteBuffer directly to ServletOutputStream
        ServletOutputStream outputStream = response.getOutputStream();
        outputStream.write(buffer);
        outputStream.flush();
    }
}

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.RequestDispatcher;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/error-handler")
public class ErrorHandlerServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        response.setContentType("text/html");
        PrintWriter writer = response.getWriter();

        // Access error attributes including the new query string attribute
        Integer statusCode = (Integer) request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        String message = (String) request.getAttribute(RequestDispatcher.ERROR_MESSAGE);
        String requestUri = (String) request.getAttribute(RequestDispatcher.ERROR_REQUEST_URI);
        String queryString = (String) request.getAttribute(RequestDispatcher.ERROR_QUERY_STRING);

        writer.println("<html><body>");
        writer.println("<h1>Error Handler</h1>");
        writer.println("<p>Status Code: " + statusCode + "</p>");
        writer.println("<p>Message: " + message + "</p>");
        writer.println("<p>Request URI: " + requestUri + "</p>");

        // New in Servlet 6.1: Query string is now available in error dispatches
        if (queryString != null) {
            writer.println("<p>Query String: " + queryString + "</p>");
        }

        writer.println("</body></html>");
    }
}

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.*;
import java.util.List;
import java.util.ArrayList;

@Path("/products")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ProductResource {

    private static List<Product> products = new ArrayList<>();

    @GET
    public Response getAllProducts() {
        return Response.ok(products).build();
    }

    @GET
    @Path("/{id}")
    public Response getProduct(@PathParam("id") Long id) {
        Product product = products.stream()
            .filter(p -> p.getId().equals(id))
            .findFirst()
            .orElse(null);

        if (product == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }

        return Response.ok(product).build();
    }

    @POST
    public Response createProduct(Product product) {
        products.add(product);
        return Response.status(Response.Status.CREATED)
            .entity(product)
            .build();
    }

    @PUT
    @Path("/{id}")
    public Response updateProduct(@PathParam("id") Long id, Product updatedProduct) {
        Product product = products.stream()
            .filter(p -> p.getId().equals(id))
            .findFirst()
            .orElse(null);

        if (product == null) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }

        products.remove(product);
        products.add(updatedProduct);

        return Response.ok(updatedProduct).build();
    }

    @DELETE
    @Path("/{id}")
    public Response deleteProduct(@PathParam("id") Long id) {
        boolean removed = products.removeIf(p -> p.getId().equals(id));

        if (!removed) {
            return Response.status(Response.Status.NOT_FOUND).build();
        }

        return Response.noContent().build();
    }
}

class Product {
    private Long id;
    private String name;
    private Double price;

    // Constructors, getters, setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Double getPrice() { return price; }
    public void setPrice(Double price) { this.price = price; }
}

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.*;

@Path("/api/users")
public class UserResource {

    @Context
    private UriInfo uriInfo;

    @GET
    @Path("/{userId}/orders/{orderId}")
    @Produces(MediaType.APPLICATION_JSON)
    public Response getUserOrder(
            @PathParam("userId") Long userId,
            @PathParam("orderId") Long orderId) {

        // NEW in REST 4.0: getMatchedResourceTemplate method
        String template = uriInfo.getMatchedResourceTemplate();
        System.out.println("Matched template: " + template);
        // Output: /api/users/{userId}/orders/{orderId}

        // Use the template for logging, metrics, or routing decisions
        return Response.ok()
            .entity(new Order(orderId, userId))
            .header("X-Resource-Template", template)
            .build();
    }
}

class Order {
    private Long orderId;
    private Long userId;

    public Order(Long orderId, Long userId) {
        this.orderId = orderId;
        this.userId = userId;
    }

    public Long getOrderId() { return orderId; }
    public Long getUserId() { return userId; }
}

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.*;
import jakarta.json.Json;
import jakarta.json.JsonMergePatch;
import jakarta.json.JsonValue;
import jakarta.json.bind.Jsonb;
import jakarta.json.bind.JsonbBuilder;

@Path("/customers")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class CustomerResource {

    private static Customer customer = new Customer(1L, "John Doe", "[email protected]");

    @GET
    @Path("/{id}")
    public Response getCustomer(@PathParam("id") Long id) {
        return Response.ok(customer).build();
    }

    // NEW in REST 4.0: JSON Merge Patch support (RFC 7396)
    @PATCH
    @Path("/{id}")
    @Consumes(MediaType.APPLICATION_MERGE_PATCH_JSON)
    public Response patchCustomer(
            @PathParam("id") Long id,
            JsonValue patchJson) {

        try (Jsonb jsonb = JsonbBuilder.create()) {
            // Convert customer to JsonValue
            JsonValue customerJson = jsonb.fromJson(
                jsonb.toJson(customer), JsonValue.class);

            // Create merge patch manually from the incoming JSON
            JsonMergePatch mergePatch = Json.createMergePatch(patchJson);
            // Apply the merge patch
            JsonValue patchedJson = mergePatch.apply(customerJson);

            // Convert back to Customer object
            Customer patchedCustomer = jsonb.fromJson(
                patchedJson.toString(), Customer.class);

            customer = patchedCustomer;

            return Response.ok(customer).build();
        } catch (Exception e) {
            return Response.status(Response.Status.BAD_REQUEST)
                .entity("Invalid patch: " + e.getMessage())
                .build();
        }
    }
}

class Customer {
    private Long id;
    private String name;
    private String email;

    public Customer() {}

    public Customer(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

import jakarta.ws.rs.*;
import jakarta.ws.rs.core.*;
import java.io.InputStream;
import java.io.IOException;
/**
 * Demonstrates multipart/form-data handling in Jakarta REST 4.0
 * using the standard EntityPart API (new in REST 4.0)
 */
@Path("/upload")
public class FileUploadResource {
    @POST
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @Produces(MediaType.APPLICATION_JSON)
    public Response uploadFile(
            @FormParam("file") EntityPart filePart,
            @FormParam("description") String description) {
        if (filePart == null) {
            return Response.status(Response.Status.BAD_REQUEST)
                .entity(new UploadResponse(null, 0, "No file provided"))
                .build();
        }
        try {
            String fileName = filePart.getFileName().orElse("unknown");
            // Read the file content to get size
            long fileSize = 0;
            try (InputStream is = filePart.getContent()) {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = is.read(buffer)) != -1) {
                    fileSize += bytesRead;
                }
            }
            // Process the file
            System.out.println("Uploading file: " + fileName);
            System.out.println("File size: " + fileSize);
            System.out.println("Description: " + description);
            System.out.println("Content-Type: " + filePart.getMediaType());
            return Response.ok()
                .entity(new UploadResponse(fileName, fileSize, "Upload successful"))
                .build();
        } catch (IOException e) {
            return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
                .entity(new UploadResponse(null, 0, "Error processing file: " + e.getMessage()))
                .build();
        }
    }
}

class UploadResponse {
    private String fileName;
    private long fileSize;
    private String message;

    public UploadResponse(String fileName, long fileSize, String message) {
        this.fileName = fileName;
        this.fileSize = fileSize;
        this.message = message;
    }

    // Getters
    public String getFileName() { return fileName; }
    public long getFileSize() { return fileSize; }
    public String getMessage() { return message; }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<!DOCTYPE html>
<html>
<head>
    <title>Error Page - Jakarta Pages 4.0</title>
</head>
<body>
    <h1>An Error Occurred</h1>

    <!-- Standard error attributes -->
    <p><strong>Status Code:</strong> ${pageContext.errorData.statusCode}</p>
    <p><strong>Request URI:</strong> ${pageContext.errorData.requestURI}</p>
    <p><strong>Servlet Name:</strong> ${pageContext.errorData.servletName}</p>

    <!-- NEW in Pages 4.0: Access HTTP method that caused the error -->
    <p><strong>HTTP Method:</strong> ${pageContext.request.getAttribute('jakarta.servlet.error.method')}</p>

    <!-- NEW in Pages 4.0: Access query string from the error request -->
    <p><strong>Query String:</strong> ${pageContext.request.getAttribute('jakarta.servlet.error.query_string')}</p>

    <!-- Exception details if available -->
    <c:if test="${not empty pageContext.errorData.throwable}">
        <h2>Exception Details</h2>
        <p><strong>Type:</strong> ${pageContext.errorData.throwable.class.name}</p>
        <p><strong>Message:</strong> ${pageContext.errorData.throwable.message}</p>
    </c:if>
</body>
</html>

import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;
import jakarta.websocket.server.PathParam;
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.Future;

@ServerEndpoint("/notifications/{userId}")
public class NotificationWebSocket {

    private static final Set<Session> sessions = new CopyOnWriteArraySet<>();

    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        sessions.add(session);
        session.getUserProperties().put("userId", userId);
        System.out.println("User " + userId + " connected");
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        String userId = (String) session.getUserProperties().get("userId");
        System.out.println("Received message from " + userId + ": " + message);

        // Echo the message back
        sendAsyncMessage(session, "Echo: " + message);
    }

    @OnClose
    public void onClose(Session session, @PathParam("userId") String userId) {
        sessions.remove(session);
        System.out.println("User " + userId + " disconnected");
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        System.err.println("WebSocket error: " + throwable.getMessage());
        throwable.printStackTrace();
    }

    // Demonstrates the new getSession() method in SendResult
    private void sendAsyncMessage(Session session, String message) {
        try {
            RemoteEndpoint.Async asyncRemote = session.getAsyncRemote();
            Future<Void> future = asyncRemote.sendText(message);

            // Add a callback to handle the send result
            future.get(); // Wait for completion

            // In a real application, you might use a SendHandler instead
            asyncRemote.sendText(message, new SendHandler() {
                @Override
                public void onResult(SendResult result) {
                    // NEW in WebSocket 2.2: getSession() method
                    Session resultSession = result.getSession();

                    if (result.isOK()) {
                        String userId = (String) resultSession.getUserProperties().get("userId");
                        System.out.println("Message sent successfully to user: " + userId);
                    } else {
                        System.err.println("Failed to send message to session: " +
                            resultSession.getId());
                        System.err.println("Error: " + result.getException().getMessage());
                    }
                }
            });
        } catch (Exception e) {
            System.err.println("Error sending async message: " + e.getMessage());
        }
    }

    // Broadcast message to all connected sessions
    public void broadcastToAll(String message) {
        sessions.forEach(session -> {
            if (session.isOpen()) {
                session.getAsyncRemote().sendText(message, new SendHandler() {
                    @Override
                    public void onResult(SendResult result) {
                        // Use the new getSession() method to identify which session
                        Session resultSession = result.getSession();
                        if (!result.isOK()) {
                            System.err.println("Failed to broadcast to session: " +
                                resultSession.getId());
                        }
                    }
                });
            }
        });
    }
}

import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.nio.ByteBuffer;

@ServerEndpoint("/ping-pong")
public class PingPongWebSocket {

    @OnOpen
    public void onOpen(Session session) {
        System.out.println("WebSocket opened: " + session.getId());

        // Send a ping message to the client
        try {
            session.getBasicRemote().sendPing(ByteBuffer.wrap("ping".getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @OnMessage
    public void onPongMessage(PongMessage pong, Session session) {
        // Handle pong messages received from the client
        ByteBuffer data = pong.getApplicationData();
        byte[] bytes = new byte[data.remaining()];
        data.get(bytes);
        String pongData = new String(bytes);

        System.out.println("Received pong from " + session.getId() + ": " + pongData);
    }

    @OnMessage
    public void onTextMessage(String message, Session session) {
        System.out.println("Received text message: " + message);

        // Send a pong message in response
        try {
            session.getBasicRemote().sendPong(ByteBuffer.wrap("pong".getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @OnClose
    public void onClose(Session session) {
        System.out.println("WebSocket closed: " + session.getId());
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        System.err.println("WebSocket error: " + throwable.getMessage());
    }
}