This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
-
This program is free software; you can redistribute it and/or modify
-it under the terms of version 3 of the GNU Lesser General Public
-License or later as published by the Free Software Foundation.
+
Goal: simplify/speed up understanding the computer program code by
automatically visualizing its structure.
-JavaInspect is a Java library that you can embed into your Java
-project with a few lines of Maven configuration and then visualize any
-part of your Java program structure with few simple JavaInspect API
-calls at application runtime.
+See example produced graphs for Sixth 3D - 3D engine project.
-JavaInspect uses Java reflection to discover class relations and
-structure and produces GraphViz dot file that describes your
-application. Then launches GraphViz to generate bitmap graph in PNG
-format on your Desktop directory.
+JavaInspect can be used as a standalone commandline utility as well as
+java library. JavaInspect uses primarily Java built-in reflection to
+discover and visualize any part of Java program.
-
-
-
-
2 Current status
-
-This is simple utility, quickly written. Tested on GNU Linux (can be
-relatively simply ported to other operating systems too). So far I
-used it for my own needs. There might be bugs and missing
-features. Feedback and code contributions are welcome.
+JavaInspect currently has no GUI, configuration files, embedded
+scripting support, direct Maven or Ant integration. See usage to learn
+how to instuct Javainspect what to do.
-
-
-
-
3 Example graphs
-
-Example visualization of Sixth project: architecture graphs.
+After discovering application structure and optionally filtering out
+unimportant parts, JavaInspect produces GraphViz dot file that
+describes data to be visualized. Then launches GraphViz to generate
+bitmap graph in PNG or SVG format.
-A very simple example:
+Notes:
+
+
JavaInspect is developed and tested so far only on GNU/Linux.
+
-// While classes and objects can be immediately passed to ClassGraph
-// constructor as arguments, it is also possible to add them one by
-// one as in the following example.
+
+Warning: It was tested only on Debian Stretch linux.
+
-// Add some object to the graph.
-graph.addObject(graph);
+
+Available commandline arguments:
+
+
+-j (existing files)…
+ JAR file(s) to render.
+
+-n (mandatory, string)
+ Graph name.
+
+–debug
+ Show debug info.
+
+-k
+ Keep dot file.
+
+-h
+ Hide orphaned classes.
+
+-w (one to many strings)…
+ Whitelist glob(s).
+
+-b (one to many strings)…
+ Blacklist glob(s).
+
+-d (existingdirectory)
+ Target directory. Default is current directory.
+
+-t (options: png, svg)
+ Target image type. Default is: svg.
+
+
+
+
+
4.2 usage via Java API
+
+
+Requires that classes to be visualised are available in the classpath.
+
-// Add some class to the graph.
-graph.addClass(Utils.class);
+
+To get JavaInspect into same classpath with your projecs I so far came
+up with 2 solutions:
+
-// Produce bitmap image titled "JavaInspect.png" to the user Desktop
-// directory and keep intermediary GraphViz DOT file for reference.
-graph.generateGraph("JavaInspect", true);
-
-
+
+
Add JavaInspect library in your project as a dependency.
+
+
Create new Java project for the purpose visualizing your other
+projects and include JavaInspect and your projecs binary artifacts
+(Jar's) into new project classpath. Built binary Jar's (with no
+source code) are sufficient because JavaInspect operates via
+reflection.
+
+
+
+Simple Java based control/configuration code needs to be written for
+each project. I usually put such code into directories devoted for
+JUnit tests. Because it needs not to be compiled/embedded into final
+product or project artifact I'm just willing to visualize.
+
-Result:
+Control code in general does the following:
+
+
Create graph object.
+
+
Java reflection/classloaders does not provide mechanism for
+discovering all classes under given package. Therefore you need to
+declare at least some classes to be added to the graph by manually
+adding individual classes to the graph. For every class added to
+the graph, GraphViz will recursively inspect it and add all
+referecned classes to the graph as well.
+
+
Graphs easilly get very big and complex so optionally we filter
+important code using classname glob patterns based blacklist and/or
+whitelist.
+
+
Optionally we can tune some rendering parameters like:
Specify target directory for generated visualization
+files. (Default is current directory)
+
+
Keep intermediate GraphViz dot file for later inspection.
-
+
+
Render graph.
+
+
-
-
5 Usage example 2
-
+
+
+
4.2.1 example 1: individually picked objects
+
-Recursively scan current directory for Java source code and attempt to
-detect class names from there to be added to the graph.
+This example demonstrates generating of class graph from hand picked
+classes and visualizing GraphViz itself.
-
graph.addProject(".");
+
// Create graph
+finalClassGraphgraph = newClassGraph();
+
+// Add some random object to the graph. GraphViz will detect Class from
+// the object.
+graph.add(graph);
+
+// Also add some random class to the graph.
+graph.add(Utils.class);
+
+// Keep intermediary GraphViz DOT file for reference.
+graph.setKeepDotFile(true);
-// Blacklist example classes from being shown on the graph
-graph.getFilter().blacklistClassPattern(
- "eu.svjatoslav.inspector.java.structure.example.*");
+// Produce bitmap image titled "JavaInspect.png" to the user Desktop
+// directory
+graph.generateGraph("JavaInspect");
+
+
+
-// do not show single classes with no relationships on the graph
-graph.hideOrphanedClasses();
+
+Note: if desired, more compact version of the above:
+
+
-// Produce bitmap image titled "JavaInspect full project.png" to the
-// user Desktop directory.
-graph.generateGraph("JavaInspect full project");
+
+Note: Because this is side project (and I have many of them) I can
+only contribute few hours per year at average. Any help is welcome. A
+LOT of cool ideas could be implemented. For intstance:
+
+
BUG: Should not hide references if there are too many of them to
classes if referring classes are not visible anyway because of
blacklist/whitelist rules. Basically reference counting should
exclude not visible classes.
-
BUG: Current code is quite messy (because of lack of time) things
-were implemented ad-hoc. Needs cleanup/refactoring for better
-readability.
+
+
BUG: Orphaned class removal does not work always. There are many
+bugs and corner cases to find and fix still.
+
+
+
BUG: Code is not very readable. Document and refactor for better
+maintainability.
+
+
+
FEATURE: Create installable DEB package.
+
+
Submit it to some Debian developer for integration or become
+Debian package maintainer.
+
+
+
+
+
FEATURE: Make it modular. That is: central part, an application
+model could be standalone and serializable.
+
+
+
There could be multiple ways to acquire model:
+
+
By introspecting application via Java reflections (current mode
+of operation).
+
+
By parsing java source. (unfinished)
+
+
+
+
+
There could be ways to manipulate model:
+
+
Store/load/compare.
+
+
Trim uninteresting parts.
+
+
Highlight important parts.
-
FEATURE: add dark theme
+
+
+
+
There could be multiple ways to render model:
+
+
PNG/SVG (currently implemented)
+
+
PlantUML (TODO)
+
+
Interactive 3D visualization (TODO)
+
+
-
FEATURE: sort Class fields by alphabet
+
-
FEATURE: visualize also concrete field values so it could be used as
-ultra cool runtime logging framework
+
+
FEATURE: Implement (or integrate existing java parser
+https://javaparser.org/) to be able to produce code visualizations
+based on source code (in addition to current reflection based
+approach).
-
FEATURE: possibility to visualize structure and data from JVM
-snapshot
+
+
FEATURE: possibility to attach to remote process to visualize
+
+
FEATURE: Add dark theme for generated graphs.
+
+
+
FEATURE: Sort Class fields by alphabet.
+
+
+
FEATURE: Visualize also concrete field values so it could be used as
+ultra cool runtime logging/debugging framework.
+
+
+
FEATURE: Possibility to visualize structure and data from JVM
+snapshot.
+
+
+
FEATURE: Possibility to attach to remote process to visualize
data/structure using JVM debug port and mechanism.
-
FEATURE: possibility to attach to JVM using JVM agent
+
+
FEATURE: Possibility to attach to JVM using JVM agent.
+
+
+
FEATURE: Possibility to inspect graphs in 3D using Sixth 3D engine.
-
FEATURE: possibility to script javainspect behavior
+
+
FEATURE: Possibility to select classes/fields/values to be
+visualized in some graph query language. For greater flexibility in
+comparison to currently supported glob syntax.
-
FEATURE: possibility to select classes/fields/values to be
-visualized in SQL like syntax
+
+
FEATURE: Add option to control JavaInspect via JSON or XML config
+file. For example different graphs for given project could be
+defined once in plain text config, possibly with the aid of some
+interactive utility. Then defined graphs could be updated as part of
+project build or release process.
-
FEATURE: configurable maven plugin to generate graphs as part of the
-project build/release process
+
+
FEATURE: Configurable maven plugin to generate graphs as part of the
+project build/release process.
+
+
