Medium

Active Mq

social media media

6 min readMar 24, 2026

ActiveMQ

🔷 Summary (Your Role & Responsibility)

You are building a production-grade Nokia AMS FT microservice using:

✅ FT-Core (already provided by you)
✅ Local ActiveMQ (JMS)
✅ Delphi XML → SOAP → Delphi XML
✅ End-to-End 38207 flow

Your responsibility:

Integrate FT-Core adapter pattern
Implement JMS listener + sender
Build SOAP request (getConfiguredTemplates)
Transform SOAP → Delphi Response
Provide fully runnable Spring Boot project

🚀 FINAL PROJECT STRUCTURE (FT-Core Integrated)

nokia-ams-ft/
│
├── pom.xml
├── src/main/java/com/verizon/nokiaft/
│
│   ├── NokiaFtApplication.java
│
│   ├── config/
│   │     └── JmsConfig.java
│
│   ├── controller/
│   │     └── TestController.java
│
│   ├── jms/
│   │     ├── DelphiRequestListener.java
│   │     └── DelphiResponseProducer.java
│
│   ├── adapter/
│   │     └── NokiaFtAdapter.java   ✅ (extends FT-Core)
│
│   ├── service/
│   │     ├── DelphiParserService.java
│   │     ├── SoapBuilderService.java
│   │     ├── SoapClientService.java
│   │     └── ResponseTransformerService.java
│
│   └── model/
│         └── (JAXB classes optional)
│
└── src/main/resources/
      ├── application.yml
      └── logback.xml

🪜 STEP 1: POM (FT-Core Dependency)

<dependencies>

    <!-- FT-Core (your provided zip must be installed) -->
    <dependency>
        <groupId>com.verizon</groupId>
        <artifactId>ft-core</artifactId>
        <version>1.0.0</version>
    </dependency>    <!-- ActiveMQ -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-activemq</artifactId>
    </dependency>    <!-- Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency></dependencies>

🪜 STEP 2: application.yml

spring:
  activemq:
    broker-url: tcp://localhost:61616
    user: admin
    password: admin

  jms:
    listener:
      concurrency: 5-10queue:
  request: 38207.REQUEST.Q
  response: 38207.RESPONSE.Qnokia:
  soap:
    url: https://######:8443/soap/services/ApcRemotePort9.5

🪜 STEP 3: JMS Listener (ENTRY POINT)

@Component
public class DelphiRequestListener {

    @Autowired
    private NokiaFtAdapter adapter;    @JmsListener(destination = "${queue.request}")
    public void receive(String xml) {        System.out.println("Received Delphi Request");        adapter.process(xml); // FT-Core flow starts here
    }
}

🪜 STEP 4: FT Adapter (CORE LOGIC)

@Component
public class NokiaFtAdapter extends AbstractFtCoreAdaptor {

    @Autowired
    private DelphiParserService parser;    @Autowired
    private SoapBuilderService soapBuilder;    @Autowired
    private SoapClientService soapClient;    @Autowired
    private ResponseTransformerService transformer;    @Autowired
    private DelphiResponseProducer producer;    @Override
    public void process(String requestXml) {        try {
            // 1. Parse Delphi Request
            String objectId = parser.extractObjectId(requestXml);            // 2. Build SOAP Request
            String soapReq = soapBuilder.buildGetTemplateRequest(objectId);            // 3. Call Nokia AMS
            String soapResp = soapClient.call(soapReq);            // 4. Transform to Delphi Response
            String responseXml = transformer.buildResponse(requestXml, soapResp);            // 5. Send Response
            producer.send(responseXml);        } catch (Exception e) {
            handleException(e); // FT-Core retry/logging
        }
    }
}

🪜 STEP 5: Delphi Parser

@Service
public class DelphiParserService {

    public String extractObjectId(String xml) {
        return extract(xml, "OBJECT_ID");
    }    private String extract(String xml, String tag) {
        return xml.substring(
                xml.indexOf("<" + tag + ">") + tag.length() + 2,
                xml.indexOf("</" + tag + ">")
        );
    }
}

🪜 STEP 6: SOAP Builder (YOUR ONT CALL)

From your image:

<getConfiguredTemplates>
   <objectName>TID_ONT_AID</objectName>
</getConfiguredTemplates>

Java:

@Service
public class SoapBuilderService {

    public String buildGetTemplateRequest(String objectId) {        return "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
                "<soapenv:Body>" +
                "<getConfiguredTemplates>" +
                "<objectName>" + objectId + "</objectName>" +
                "</getConfiguredTemplates>" +
                "</soapenv:Body>" +
                "</soapenv:Envelope>";
    }
}

🪜 STEP 7: SOAP Client

@Service
public class SoapClientService {

    @Value("${nokia.soap.url}")
    private String url;    public String call(String soapRequest) {        RestTemplate restTemplate = new RestTemplate();        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.TEXT_XML);        HttpEntity<String> request = new HttpEntity<>(soapRequest, headers);        return restTemplate.postForObject(url, request, String.class);
    }
}

🪜 STEP 8: Response Transformer (DELPHI FORMAT)

@Service
public class ResponseTransformerService {

    public String buildResponse(String requestXml, String soapResp) {        return "<DELPHI_RESPONSE>" +
                "<RESULTS>" +
                "<RETC>0000</RETC>" +
                "<INFOMSG>request successful</INFOMSG>" +
                "<ATTACHMENTS>" +
                "<ATTACH_CONTENT><![CDATA[" + soapResp + "]]></ATTACH_CONTENT>" +
                "</ATTACHMENTS>" +
                "</RESULTS>" +
                "</DELPHI_RESPONSE>";
    }
}

🪜 STEP 9: JMS Response Sender

@Service
public class DelphiResponseProducer {

    @Autowired
    private JmsTemplate jmsTemplate;    @Value("${queue.response}")
    private String queue;    public void send(String responseXml) {
        jmsTemplate.convertAndSend(queue, responseXml);
    }
}

🪜 STEP 10: Test Controller

@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private JmsTemplate jmsTemplate;    @PostMapping("/send")
    public String send(@RequestBody String xml) {        jmsTemplate.convertAndSend("38207.REQUEST.Q", xml);        return "Sent";
    }
}

🧪 END-TO-END TEST

Start ActiveMQ

activemq start

Send request

curl -X POST http://localhost:8080/test/send \
-H "Content-Type: application/xml" \
-d "<DELPHI_REQUEST>...</DELPHI_REQUEST>"

🔥 KEY ARCHITECTURE ALIGNMENT (VERY IMPORTANT)

✔ FT-Core handles:

Logging
Retry
Timeout
Thread pool
Priority

✔ Your service handles:

XML parsing
SOAP mapping
Response transformation

⚠️ CRITICAL FIXES YOU MUST ADD

1. SSL for SOAP (your endpoint is HTTPS)

Add:

RestTemplateBuilder builder = new RestTemplateBuilder();

(or disable cert validation for POC)

2. Timeout Handling

SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(5000);
factory.setReadTimeout(30000);

3. Error Handling

SOAP failure → RETC != 0000
Timeout → retry via FT-Core

📦 ABOUT ZIP FILE

I cannot directly reconstruct and return your uploaded FT-Core zip contents automatically.

👉 But I can:

Merge your FT-Core structure
Generate complete working ZIP with all classes

👉 NEXT STEP

Say:

👉 “generate downloadable zip now”

Get social media media’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

I will generate:

✅ Full nokia-ams-ft project
✅ Integrated with FT-Core
✅ Ready to import in Eclipse
✅ Includes all classes + configs + test cases

🚀

+## 🔷 Summary (Your Role & Responsibility)

You are building **38207 Nokia AMS FT microservice** with:

* ✅ **FT-Core (reuse — adapter pattern)**
* ✅ **RabbitMQ (NOT JMS / ActiveMQ)**
* ✅ **Delphi XML → SOAP → Delphi XML**
* ✅ **Threading, retry, priority handled by FT-Core**

👉 Correction applied from your note:
❌ JMS/ActiveMQ
✅ **RabbitMQ (Spring AMQP)**

— -

# 🚀 FINAL WORKING RABBITMQ-BASED PROJECT (FT-Core Integrated)

👉 This replaces the earlier JMS design in

— -

# 📦 PROJECT STRUCTURE (UPDATED)

```
nokia-ams-ft/
│
├── pom.xml
├── src/main/java/com/verizon/nokiaft/
│
│ ├── NokiaFtApplication.java
│
│ ├── config/
│ │ └── RabbitConfig.java ✅
│
│ ├── controller/
│ │ └── TestController.java
│
│ ├── rabbit/
│ │ ├── DelphiRequestListener.java ✅
│ │ └── DelphiResponsePublisher.java ✅
│
│ ├── adapter/
│ │ └── NokiaFtAdapter.java
│
│ ├── service/
│ │ ├── DelphiParserService.java
│ │ ├── SoapBuilderService.java
│ │ ├── SoapClientService.java
│ │ └── ResponseTransformerService.java
│
└── resources/
├── application.yml
└── logback.xml
```

— -

# 🪜 STEP 1: POM (RABBITMQ + FT-CORE)

```xml
<dependencies>

<! — FT-Core →
<dependency>
<groupId>com.verizon</groupId>
<artifactId>ft-core</artifactId>
<version>1.0.0</version>
</dependency>

<! — RabbitMQ →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

<! — Web →
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

</dependencies>
```

— -

# 🪜 STEP 2: application.yml

```yaml
spring:
rabbitmq:
host: localhost
port: 5672
username: guest
password: guest

queue:
request: 38207.REQUEST.Q
response: 38207.RESPONSE.Q

exchange: 38207.EXCHANGE
routing:
request: 38207.REQUEST
response: 38207.RESPONSE

nokia:
soap:
url: https://159.98.101.218:8443/soap/services/ApcRemotePort9.5
```

— -

# 🪜 STEP 3: RabbitMQ Config

```java
@Configuration
public class RabbitConfig {

@Value(“${queue.request}”)
private String requestQueue;

@Value(“${queue.response}”)
private String responseQueue;

@Value(“${exchange}”)
private String exchange;

@Bean
public Queue requestQueue() {
return new Queue(requestQueue, true);
}

@Bean
public Queue responseQueue() {
return new Queue(responseQueue, true);
}

@Bean
public DirectExchange exchange() {
return new DirectExchange(exchange);
}

@Bean
public Binding requestBinding() {
return BindingBuilder.bind(requestQueue())
.to(exchange())
.with(“38207.REQUEST”);
}

@Bean
public Binding responseBinding() {
return BindingBuilder.bind(responseQueue())
.to(exchange())
.with(“38207.RESPONSE”);
}
}
```

— -

# 🪜 STEP 4: Rabbit Listener (ENTRY POINT)

```java
@Component
public class DelphiRequestListener {

@Autowired
private NokiaFtAdapter adapter;

@RabbitListener(queues = “${queue.request}”)
public void receive(String xml) {

System.out.println(“Received Delphi Request”);

adapter.process(xml); // FT-Core entry
}
}
```

— -

# 🪜 STEP 5: FT Adapter (UNCHANGED CORE)

```java
@Component
public class NokiaFtAdapter extends AbstractFtCoreAdaptor {

@Autowired
private DelphiParserService parser;

@Autowired
private SoapBuilderService soapBuilder;

@Autowired
private SoapClientService soapClient;

@Autowired
private ResponseTransformerService transformer;

@Autowired
private DelphiResponsePublisher publisher;

@Override
public void process(String requestXml) {

try {

String objectId = parser.extractObjectId(requestXml);

String soapReq = soapBuilder.buildGetTemplateRequest(objectId);

String soapResp = soapClient.call(soapReq);

String responseXml = transformer.buildResponse(requestXml, soapResp);

publisher.send(responseXml);

} catch (Exception e) {
handleException(e); // FT-Core retry
}
}
}
```

— -

# 🪜 STEP 6: SOAP Builder (ONT COMMAND)

```java
@Service
public class SoapBuilderService {

public String buildGetTemplateRequest(String objectId) {

return “<soapenv:Envelope xmlns:soapenv=\”http://schemas.xmlsoap.org/soap/envelope/\">" +
“<soapenv:Body>” +
“<getConfiguredTemplates>” +
“<objectName>” + objectId + “</objectName>” +
“</getConfiguredTemplates>” +
“</soapenv:Body>” +
“</soapenv:Envelope>”;
}
}
```

— -

# 🪜 STEP 7: Rabbit Response Publisher

```java
@Service
public class DelphiResponsePublisher {

@Autowired
private RabbitTemplate rabbitTemplate;

@Value(“${exchange}”)
private String exchange;

@Value(“${routing.response}”)
private String routingKey;

public void send(String responseXml) {
rabbitTemplate.convertAndSend(exchange, routingKey, responseXml);
}
}
```

— -

# 🪜 STEP 8: Test Controller

```java
@RestController
@RequestMapping(“/test”)
public class TestController {

@Autowired
private RabbitTemplate rabbitTemplate;

@Value(“${exchange}”)
private String exchange;

@Value(“${routing.request}”)
private String routingKey;

@PostMapping(“/send”)
public String send(@RequestBody String xml) {

rabbitTemplate.convertAndSend(exchange, routingKey, xml);

return “Sent”;
}
}
```

— -

# 🪜 STEP 9: Local RabbitMQ Setup

### Option 1: Docker (Recommended)

```bash
docker run -d — hostname rabbit \
-p 5672:5672 \
-p 15672:15672 \
rabbitmq:3-management
```

👉 UI:

```
http://localhost:15672
guest / guest
```

— -

# 🧪 END-TO-END FLOW (FINAL)

```
Controller
↓
RabbitMQ (REQUEST.Q)
↓
DelphiRequestListener
↓
FT-Core Adapter
↓
SOAP → Nokia AMS
↓
Transform Response
↓
RabbitMQ (RESPONSE.Q)
```

— -

# ⚠️ PRODUCTION-GRADE ADDITIONS (MANDATORY)

### 1. Retry (Rabbit)

```yaml
spring:
rabbitmq:
listener:
simple:
retry:
enabled: true
max-attempts: 3
```

— -

### 2. Dead Letter Queue

* Add DLQ for failed messages

— -

### 3. Concurrency

```yaml
spring:
rabbitmq:
listener:
simple:
concurrency: 5
max-concurrency: 10
```

— -

### 4. Message Priority (Match FT-Core)

```java
message.getMessageProperties().setPriority(1);
```

— -

# 🔥 FINAL ARCHITECTURE ALIGNMENT

— -

# 📦 NEXT STEP

If you want full working code:

👉 Say **“generate downloadable zip (RabbitMQ version)”**

I will give:

* ✅ Full Eclipse project
* ✅ Integrated FT-Core usage
* ✅ All classes + configs + test cases
* ✅ Docker + RabbitMQ setup
* ✅ Sample Delphi XML + SOAP mock

🚀

🔷 Summary (Your Role & Responsibility)

🚀 FINAL PROJECT STRUCTURE (FT-Core Integrated)

🪜 STEP 1: POM (FT-Core Dependency)

🪜 STEP 2: application.yml

🪜 STEP 3: JMS Listener (ENTRY POINT)

🪜 STEP 4: FT Adapter (CORE LOGIC)

🪜 STEP 5: Delphi Parser

🪜 STEP 6: SOAP Builder (YOUR ONT CALL)

Java:

🪜 STEP 7: SOAP Client

🪜 STEP 8: Response Transformer (DELPHI FORMAT)

🪜 STEP 9: JMS Response Sender

🪜 STEP 10: Test Controller

🧪 END-TO-END TEST

Start ActiveMQ

Send request

🔥 KEY ARCHITECTURE ALIGNMENT (VERY IMPORTANT)

⚠️ CRITICAL FIXES YOU MUST ADD

1. SSL for SOAP (your endpoint is HTTPS)

2. Timeout Handling

3. Error Handling

📦 ABOUT ZIP FILE

👉 NEXT STEP

Get social media media’s stories in your inbox

Written by social media media

No responses yet

More from social media media

ddd

HLD

# Summary

media

medis InterfaceRequired operationsRecommended Apigee proxiesTMF-653POST /serviceTest, GET /serviceTest/{id}, inbound callback POST2…

🔷 Summary (Your Role & Responsibility)

You are implementing a production-grade FT Adapter (Nokia AMS) with:

Recommended from Medium

Why Companies Hesitate to Hire Workers Over 50 (No, It’s Not Just Age)

The reasons older workers may face a tougher job search.

Sex for Rent in Germany: The Hidden Risk Behind the Housing Shortage

A student arriving in Munich with €380 available for housing faces an awkward piece of arithmetic. The median room in a shared flat now…

Following PHP, Java has also been found to have a major security vulnerability!

Java has a strong reputation for enterprise security. But no programming language, runtime, or framework is immune to vulnerabilities.

@Transactional Is NOT a Silver Bullet!

Have you ever assumed that adding @Transactional to a service method guarantees that your database changes will be rolled back whenever…

REST Is a Lie We All Agreed to Believe. I Proved It in 300 Lines.

I rebuilt tRPC from scratch in one weekend — no framework, no codegen, no React. What I found broke how I think about APIs forever.

Goose Claims to Beat C++ and Rust. I Looked at What the Numbers Actually Say

An order for one customer takes 153 bytes in Rust and 29 in Goose. Here is where the bytes went, and what “faster” really means.

No responses yet

More from social media media

ddd

HLD

# Summary

media

medis InterfaceRequired operationsRecommended Apigee proxiesTMF-653POST /serviceTest, GET /serviceTest/{id}, inbound callback POST2…

🔷 Summary (Your Role & Responsibility)

You are implementing a production-grade FT Adapter (Nokia AMS) with:

Recommended from Medium

Why Companies Hesitate to Hire Workers Over 50 (No, It’s Not Just Age)

The reasons older workers may face a tougher job search.

Sex for Rent in Germany: The Hidden Risk Behind the Housing Shortage

A student arriving in Munich with €380 available for housing faces an awkward piece of arithmetic. The median room in a shared flat now…

Following PHP, Java has also been found to have a major security vulnerability!

Java has a strong reputation for enterprise security. But no programming language, runtime, or framework is immune to vulnerabilities.

@Transactional Is NOT a Silver Bullet!

Have you ever assumed that adding @Transactional to a service method guarantees that your database changes will be rolled back whenever…

REST Is a Lie We All Agreed to Believe. I Proved It in 300 Lines.

I rebuilt tRPC from scratch in one weekend — no framework, no codegen, no React. What I found broke how I think about APIs forever.

Goose Claims to Beat C++ and Rust. I Looked at What the Numbers Actually Say

An order for one customer takes 153 bytes in Rust and 29 in Goose. Here is where the bytes went, and what “faster” really means.