Graphtia documentation · reference
Java framework analysis: Spring, JAX-RS, JPA and gRPC
See how Explorer recognizes Spring / Spring Boot, JAX-RS / Jakarta REST, JPA / Hibernate, gRPC Java, which source relationships it exposes, and what remains outside static coverage.
These adapters add framework structure to the language index. The sections below separate detection, supported relationships, required source context and limits.
Explore an example: Spring / Spring Boot · JAX-RS / Jakarta REST · JPA / Hibernate · gRPC for Java
Spring / Spring Boot
Explore declared components, bean factories, injection sites and MVC routes alongside schedules, transaction annotations and other supported metadata.
Which source mapping declares this endpoint?
Evidence to inspect- Controller root /orders to GET /orders/{id}static root
- Method mapping /{id} to GET /orders/{id}static method mapping
- GET /orders/{id} to findOrder methodhandler binding
Combine a literal controller root and method mapping to inspect the declared endpoint and its accepted Java handler.
DI, security and transaction annotations are source metadata; runtime bean selection, proxies and effective authorization are not proved. Source mappings support an endpoint-to-handler relationship without starting a Spring context.
How it is recognized
Exact org.springframework imports or recognized Spring dependency markers in checked-in Maven/Gradle sources.
Relationships you can inspect
Stereotype components, bean methods and structurally proven constructor/injection dependencies.
Literal MVC method/path/parameter declarations bound to accepted Java methods.
Supported source metadata for security, filters/interceptors, events, schedules, transactions, profiles and conditions.
Required source context
Accepted Java facts, source annotations and visible dependency/project context; literal paths for HTTP providers.
Coverage limits
Field/setter injection, qualifiers, conditions, profiles, events and security enrichment are partial.
Runtime bean selection, proxies, component scans, effective authorization, scheduling and transaction behavior are not executed.
JAX-RS / Jakarta REST
Inspect source-declared resource routes, media types and parameter roles using the shared Jakarta/javax REST model.
Is there enough source evidence to establish the resource root?
Evidence to inspect- @Path /orders on resource to GET /orders/{id}class root
- @GET @Path /{id} to GET /orders/{id}method declaration
- GET /orders/{id} to Resource find methodhandler binding
Inspect the literal class-level root, method path and accepted handler that establish a supported REST provider.
Subresource dispatch, inherited or programmatic roots, negotiation and server behavior remain outside the model. The class-level root matters; a method annotation alone does not invent an application endpoint.
How it is recognized
Exact jakarta.ws.rs or javax.ws.rs imports, or recognized API/dependency markers.
Relationships you can inspect
Literal class/method paths, HTTP methods, media types and parameter roles.
HTTP providers only when the owning resource has a proven static class-level root @Path.
Required source context
Accepted Java methods and literal resource root/path evidence; relevant imports/dependencies in the indexed snapshot.
Coverage limits
Method-only paths do not invent a root provider.
Runtime/subresource dispatch, inherited/programmatic roots, provider order, negotiation, filters and server state remain outside the static model.
JPA / Hibernate
Inspect declared entities, fields, associations and repository/query metadata as source mappings.
Which entity relationship and table-name mapping are declared?
Evidence to inspect- Order entity to customer associationdeclares association
- customer association to Customer entityunique model target
- Order entity to Declared table-name mapping: ordersmapping metadata
Inspect explicit entity annotations and uniquely identified association targets before changing a model.
No live schema, SQL execution, lazy-loading behavior or general ORM-to-DDL reconciliation is proved. Entity and mapping relationships describe source declarations; the table-name box is not a linked SQL DDL table.
How it is recognized
Recognized Jakarta/javax persistence, Hibernate or Spring Data JPA imports/dependency markers.
Relationships you can inspect
Entities, embeddables/mapped superclasses, identifiers/columns, joins and mappedBy relationships.
Supported inheritance metadata, Spring Data repository bases, bounded derived-query names and literal @Query declarations.
Required source context
Accepted Java facts, explicit annotations and uniquely identifiable relationship targets.
Coverage limits
Inheritance and derived-query semantics are partial; ambiguous external targets are not confirmed.
These facts do not prove SQL validity, live schema/constraints, rows, lazy loading, cascades, transactions or query plans; this adapter does not supply general ORM-to-SQL-table reconciliation.
gRPC Java
Trace generated-style Java service implementations and supported registrations/client uses through exact service and RPC identities.
Which generated service base does this registered implementation extend?
Evidence to inspect- OrdersGrpc.OrdersImplBase to OrdersService implementationgenerated base
- OrdersService implementation to GetOrder overrideaccepted override
- ServerBuilder.addService to OrdersService implementationregistration evidence
Inspect generated-style inheritance, RPC overrides and supported server registration around a service change.
No protoc execution, channel behavior, retry policy or observed RPC is inferred. Generated bindings and source registration identify the static service structure.
How it is recognized
Recognized io.grpc imports/dependencies and generated-style service/stub forms.
Relationships you can inspect
*Grpc.*ImplBase inheritance and overridden RPC methods.
Supported ServerBuilder/addService registration and tracked generated-stub consumers.
Required source context
Generated bindings and implementation facts must exist in the indexed source; package/service/RPC/scope must match.
Coverage limits
Registration, clients and streaming are partial; standalone Protobuf schema analysis is unavailable.
No protoc, server, channel, interceptor, retry, deadline or message execution is inferred.
How to interpret a result
Inspect the source location, revision and relationship kind. A recognized registration is static evidence; it does not establish runtime behavior or compatibility with every framework release. Unresolved or ambiguous targets should remain part of your review.