Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

Do the same thing but now use JakartaEE

  1. User

    Do the same thing but now use JakartaEE

  2. Assistant

    Below is a “same‐as‐Quarkus” skeleton, but built on a vanilla Jakarta EE stack (JDK 17+, Maven, a Jakarta EE 10–compliant app server such as WildFly, Payara or Open Liberty).
    We’ll use:
    • JAX-RS for our REST API
    • Jakarta WebSocket client to ingest live ticks
    • Jakarta JMS + ActiveMQ for decoupled messaging (raw → processed → persistence)
    • JPA (Hibernate) + PostgreSQL for storage
    • JSON-B (Yasson) for JSON binding


    1) Project Structure

    market-data-handler-jee/
    ├── pom.xml
    ├── src/
    │   ├── main/
    │   │   ├── java/com/example/marketdata/
    │   │   │   ├── model/
    │   │   │   │   └── TickData.java
    │   │   │   ├── ws/
    │   │   │   │   └── MarketDataWebSocketClient.java
    │   │   │   ├── jms/
    │   │   │   │   ├── RawTickProducer.java       # sends raw JSON to JMS queue
    │   │   │   │   ├── TickProcessorMDB.java      # MDB: raw → process → processed queue
    │   │   │   │   └── PersistenceMDB.java        # MDB: processed → JPA
    │   │   │   └── rest/
    │   │   │       └── MarketDataResource.java    # JAX-RS endpoints
    │   │   └── resources/
    │   │       └── META-INF/
    │   │           └── persistence.xml
    │   └── docker-compose.yml
    └── README.md
    

    2) Dependencies (pom.xml)

    <project …>
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.example</groupId>
      <artifactId>market-data-handler-jee</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <jakarta.platform.version>10.0.0</jakarta.platform.version>
      </properties>
    
      <dependencyManagement>
        <dependencies>
          <!-- Jakarta EE 10 Platform BOM -->
          <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-platform</artifactId>
            <version>${jakarta.platform.version}</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>
        </dependencies>
      </dependencyManagement>
    
      <dependencies>
        <!-- Jakarta EE APIs (provided by container) -->
        <dependency>
          <groupId>jakarta.platform</groupId>
          <artifactId>jakarta.jakartaee-web-api</artifactId>
          <scope>provided</scope>
        </dependency>
    
        <!-- JSON-B for binding -->
        <dependency>
          <groupId>org.eclipse</groupId>
          <artifactId>yasson</artifactId>
          <version>3.0.2</version>
        </dependency>
    
        <!-- PostgreSQL JDBC driver -->
        <dependency>
          <groupId>org.postgresql</groupId>
          <artifactId>postgresql</artifactId>
          <version>42.5.0</version>
        </dependency>
      </dependencies>
    
      <build>
        <finalName>market-data-handler-jee</finalName>
      </build>
    </project>
    

    3) Docker Compose

    version: "3.8"
    services:
      postgres:
        image: postgres:14-alpine
        environment:
          POSTGRES_DB: marketdb
          POSTGRES_USER: marketuser
          POSTGRES_PASSWORD: marketpass
        ports: ["5432:5432"]
        volumes:
          - pgdata:/var/lib/postgresql/data
    
      activemq:
        image: rmohr/activemq:5.16.3
        environment:
          ACTIVEMQ_USER: admin
          ACTIVEMQ_PASSWORD: admin
        ports:
          - "61616:61616"   # JMS
          - "8161:8161"     # Web console
    
    volumes:
      pgdata:
    

    4) JPA Configuration (persistence.xml)

    <?xml version="1.0" encoding="UTF-8"?>
    <persistence xmlns="https://jakarta.ee/xml/ns/persistence"
                 version="3.1">
      <persistence-unit name="marketPU" transaction-type="JTA">
        <jta-data-source>java:/PostgresDS</jta-data-source>
        <properties>
          <!-- For development only -->
          <property name="jakarta.persistence.schema-generation.database.action"
                    value="drop-and-create"/>
          <property name="hibernate.show_sql" value="true"/>
        </properties>
      </persistence-unit>
    </persistence>
    

    On your app-server (WildFly/Payara), define: • a JDBC datasource java:/PostgresDS pointing at PostgreSQL
    • a JMS connection factory (e.g. jms/RemoteConnectionFactory)
    • two JMS queues: jms/queue/RawTicksQueue & jms/queue/ProcessedTicksQueue


    5) The Code

    5.1 model/TickData.java

    package com.example.marketdata.model;
    
    import jakarta.persistence.*;
    import java.math.BigDecimal;
    import java.time.Instant;
    
    @Entity
    @Table(name = "ticks")
    public class TickData {
      @Id @GeneratedValue
      private Long id;
    
      @Column(nullable = false)
      private String symbol;
    
      @Column(nullable = false, precision = 19, scale = 8)
      private BigDecimal price;
    
      @Column(nullable = false)
      private long volume;
    
      @Column(nullable = false)
      private Instant timestamp;
    
      // getters/setters...
    }
    

    5.2 ws/MarketDataWebSocketClient.java

    package com.example.marketdata.ws;
    
    import com.example.marketdata.jms.RawTickProducer;
    import com.example.marketdata.model.TickData;
    import jakarta.annotation.PostConstruct;
    import jakarta.enterprise.context.ApplicationScoped;
    import jakarta.inject.Inject;
    import jakarta.websocket.*;
    import org.eclipse.microprofile.config.inject.ConfigProperty;
    import java.net.URI;
    
    /**
     * Connects to external WebSocket feed, parses JSON into TickData,
     * then passes to JMS producer.
     */
    @ClientEndpoint
    @ApplicationScoped
    public class MarketDataWebSocketClient {
    
      @Inject
      RawTickProducer rawTickProducer;
    
      @Inject
      @ConfigProperty(name = "market.data.source.websocket.uri")
      String wsUri;
    
      private Session session;
    
      @PostConstruct
      public void init() {
        try {
          WebSocketContainer container = ContainerProvider.getWebSocketContainer();
          session = container.connectToServer(this, new URI(wsUri));
          System.out.println("WS connected to " + wsUri);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    
      @OnMessage
      public void onMessage(String json) {
        try {
          // you could use JSON-B here, but let's delegate
          rawTickProducer.sendRaw(json);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    

    5.3 jms/RawTickProducer.java

    package com.example.marketdata.jms;
    
    import jakarta.annotation.Resource;
    import jakarta.enterprise.context.ApplicationScoped;
    import jakarta.inject.Inject;
    import jakarta.jms.*;
    
    @ApplicationScoped
    public class RawTickProducer {
    
      @Inject
      JMSContext jmsContext;
    
      @Resource(lookup = "jms/queue/RawTicksQueue")
      Queue rawQueue;
    
      public void sendRaw(String json) {
        jmsContext.createProducer()
                  .send(rawQueue, json);
      }
    }
    

    5.4 jms/TickProcessorMDB.java

    package com.example.marketdata.jms;
    
    import jakarta.ejb.ActivationConfigProperty;
    import jakarta.ejb.MessageDriven;
    import jakarta.inject.Inject;
    import jakarta.jms.*;
    import jakarta.json.bind.Jsonb;
    import jakarta.json.bind.JsonbBuilder;
    import java.time.Instant;
    
    /**
     * Consumes raw JSON, transforms into TickData object,
     * does business logic, then re-emits JSON to processed queue.
     */
    @MessageDriven(
      activationConfig = {
        @ActivationConfigProperty(
          propertyName  = "destinationLookup",
          propertyValue = "jms/queue/RawTicksQueue"),
        @ActivationConfigProperty(
          propertyName  = "destinationType",
          propertyValue = "jakarta.jms.Queue")
      }
    )
    public class TickProcessorMDB implements MessageListener {
    
      Jsonb jsonb = JsonbBuilder.create();
    
      @Inject JMSContext jmsContext;
    
      @Resource(lookup = "jms/queue/ProcessedTicksQueue")
      Queue processedQueue;
    
      @Override
      public void onMessage(Message message) {
        try {
          String json = ((TextMessage)message).getText();
    
          // 1) parse
          TickData tick = jsonb.fromJson(json, TickData.class);
    
          // 2) business logic / enrichment goes here
          tick.setTimestamp(Instant.now());
    
          // 3) re-emit
          String out = jsonb.toJson(tick);
          jmsContext.createProducer()
                    .send(processedQueue, out);
    
        } catch (JMSException e) {
          e.printStackTrace();
        }
      }
    }
    

    5.5 jms/PersistenceMDB.java

    package com.example.marketdata.jms;
    
    import com.example.marketdata.model.TickData;
    import jakarta.ejb.ActivationConfigProperty;
    import jakarta.ejb.MessageDriven;
    import jakarta.inject.Inject;
    import jakarta.jms.*;
    import jakarta.json.bind.Jsonb;
    import jakarta.json.bind.JsonbBuilder;
    import jakarta.persistence.EntityManager;
    import jakarta.persistence.PersistenceContext;
    
    /**
     * Consumes processed JSON, persists with JPA
     */
    @MessageDriven(
      activationConfig = {
        @ActivationConfigProperty(
          propertyName  = "destinationLookup",
          propertyValue = "jms/queue/ProcessedTicksQueue"),
        @ActivationConfigProperty(
          propertyName  = "destinationType",
          propertyValue = "jakarta.jms.Queue")
      }
    )
    public class PersistenceMDB implements MessageListener {
    
      Jsonb jsonb = JsonbBuilder.create();
    
      @PersistenceContext(unitName = "marketPU")
      EntityManager em;
    
      @Override
      public void onMessage(Message message) {
        try {
          String json = ((TextMessage)message).getText();
          TickData tick = jsonb.fromJson(json, TickData.class);
          em.persist(tick);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    

    5.6 rest/MarketDataResource.java

    package com.example.marketdata.rest;
    
    import com.example.marketdata.model.TickData;
    import jakarta.inject.Inject;
    import jakarta.persistence.EntityManager;
    import jakarta.persistence.TypedQuery;
    import jakarta.ws.rs.*;
    import jakarta.ws.rs.core.MediaType;
    import java.util.List;
    
    @Path("/api/v1/data")
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    public class MarketDataResource {
    
      @Inject
      EntityManager em;
    
      @GET
      @Path("/ticks/{symbol}")
      public List<TickData> getBySymbol(@PathParam("symbol") String symbol) {
        TypedQuery<TickData> q = em.createQuery(
          "SELECT t FROM TickData t WHERE t.symbol = :sym", TickData.class);
        q.setParameter("sym", symbol.toUpperCase());
        return q.getResultList();
      }
    
      @GET
      @Path("/ticks/latest/{symbol}")
      public TickData getLatest(@PathParam("symbol") String symbol) {
        TypedQuery<TickData> q = em.createQuery(
          "SELECT t FROM TickData t WHERE t.symbol = :sym ORDER BY t.timestamp DESC", 
          TickData.class);
        q.setParameter("sym", symbol.toUpperCase());
        q.setMaxResults(1);
        return q.getSingleResult();
      }
    }
    

    6) How to Run

    1. Start Docker infra:
      docker-compose up -d
      
    2. Configure your Jakarta EE server:
      • JDBC datasource java:/PostgresDS → PostgreSQL
      • JMS connection factory & queues as per JNDI names above
    3. Build & deploy the WAR to your server (WildFly/Payara/OpenLiberty).
    4. Access the WebSocket feed, let it flow → JMS → DB.
    5. Browse your REST API at:
      http://localhost:8080/market-data-handler-jee/api/v1/data/ticks/XYZ

    From here you can enrich the processor, add error/dead-letter handling, security (JWT), etc. 🎉