Support for extracting method body string expressions (e.g. URLs, concatenated strings) in Spring apps

[gediminasnn]

📌 Goal

I’m working on a Spring Boot microservice project and using jQAssistant (jqassistant-spring-plugin version 2.2.1) to analyze system architecture through static code and metadata.

Currently, I’m trying to analyze microservice uni-interactions by tracing hardcoded or dynamically constructed URLs built within client classes. These are often composed using service discovery and string concatenation inside method bodies.

---

🧪 What I’m trying to extract

Here’s a simplified example:

public class ClientServiceClient {

    private final Registry registry;

    public ClientServiceClient(Registry registry) {
        this.registry = registry;
    }

    public List<ClientDto> getClients(CountryCode cc) {
        String url = this.registry.find("clientservice").toString() +
                     "/clientservice/rest/client?country={cc}";
        ...
    }
...

In Neo4j, I’d like to analyze:

• The value assigned to url
• Literal string fragments like /clientservice/rest/...

---

🧩 What’s currently missing

After scanning:

• The url value does not appear as any accessible node
• There’s no connection between the method and that internal string expression

This makes it difficult to label a class as a client and trace which service it communicates with, which is important for architecture investigation.

---

💬 Questions

1. Is it possible to extract these string expressions from method bodies with the current plugin?
2. Are there alternative strategies or workarounds to detect such method-local string construction patterns?
3. If this isn’t currently supported, I’d really appreciate your help shaping a possible approach.

I’ve just started a new role where I’m actively analyzing microservice architecture, so being able to trace these interactions is quite important. Any guidance you could share — or insight into whether this is already being considered — would mean a lot.

---

Thanks again for building and maintaining jQAssistant — it’s a fantastic tool with so much potential for real-world architecture analysis.

Best regards,
Gediminas

[gediminasnn]

Hey @Bramaten and @morpfl 👋
I noticed your recent contributions to the Spring plugin — really appreciate the work! If you have a moment, I’d really appreciate your thoughts on this. Curious if this aligns with anything you’ve worked on or explored before.

[DirkMahler]

The question is not related to the Spring plugin (it just contains rules) but to the Java plugin and the provided bytecode scanner (https://github.com/jQAssistant/jqassistant/tree/master/plugin/java) which is part of the core distribution.

The answer is that we currently do not support this kind of analysis. The main reason is that assignment of values to variables, method parameters, etc. requires data flow analysis which very likely would make the data model much more complex for the user (as well as the implementation of the Java scanner).

What could be possible is an option to make values (e.g. /clientservice/rest/...) which are used by fields and methods accessible, probably this will increase database size and scan performance. So it definitely should be optional and disabled by default.

[gediminasnn]

👋 Hey @DirkMahler, thanks for the earlier explanation — super helpful!

I recently encountered what seems like a scanning issue where jQAssistant creates duplicate nodes for the same class (one under BOOT-INF/classes/, one under /classes/) when scanning a Spring Boot fat JAR. This fragments the analysis and breaks relationships across the graph.

I opened a new issue with detailed reproduction steps and screenshots:
👉 jQAssistant/jqassistant#866

If you have a moment, I’d really appreciate your feedback on:
• Whether I filed the issue in the right place — I’m not very experienced with contributing to open source projects and wasn’t sure where it best fits.
• And if you’re familiar with this kind of behavior, any help or insight would mean a lot.

Thanks again for maintaining this project — it’s a huge help in understanding and auditing large-scale Java systems!