-
- 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.
-
-
- 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.
-
-
-
Current status
-
- This is simple utility, quickly written. Tested on 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.
-
-
-
Example graphs
-
- Example visualization of
- Sixth
- project:
- architecture
- graphs
-
-
- A very simple example:
-
-
-
- Graph legend:
-
-
-
-
-
Usage example
-
- Following example produces graph for JavaInspect itself:
-
-
-
-// Create graph
-final Graph graph = new Graph();
-
-// Add some object to the graph.
-graph.addObject(graph);
-
-// Add some class to the graph.
-graph.addClass(Utils.class);
-
-// Produce bitmap image titled "JavaInspect.png" to the user Desktop
-// directory.
-graph.generateGraph("JavaInspect", true);
-
-
-
-Result:
- Generated DOT file: JavaInspect.dot
- Generated PNG image: JavaInspect.png
-
-
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 primarily uses Java reflection to
+discover and visualize any part of Java program provided that
+classes to be visualised are available in the classpath.
+
+
+
+JavaInspect currently has no GUI, configuration files, embedded
+scripting support, direct Maven or Ant integration. The only way to
+instuct Javainspect what to do is by using its Java API.
+
+
+
+To get JavaInspect into same classpath with your projecs I so far came
+up with 2 solutions:
+
+
+
+
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.
+
+
+
+
+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 format. By default on your Desktop directory.
+
+
+
+Note: GraphViz is developed and tested so far only on GNU/Linux.
+
+Currently the only way to control JavaInspect is by using Java
+API. 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.
+
+
+
+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.
+
+
and/or: Let GraphViz recursively scan and parse specified
+directories with Java source code files to discover class names.
+
+
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 wildcards patterns based blacklist
+and/or whitelist.
+
+
Optionally we can tune some rendering parameters like:
+
+
Possibility to remove orphaned classes (classes with no
+references) from the graph.
+
+
Specify target directory for generated visualization
+files. (Default is user desktop directory)
+
+
Keep intermediate GraphViz dot file for later inspection.
+
+
+
+
Render graph.
+
+
+
+
+
+
+
3.1 example 1: individually picked objects
+
+
+This example demonstrates generating of class graph from hand picked
+classes and visualizing GraphViz itself.
+
+
+
+
+
// 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);
+
+// Produce bitmap image titled "JavaInspect.png" to the user Desktop
+// directory
+graph.generateGraph("JavaInspect");
+
+
+
+
+Note: if desired, more compact version of the above:
+
// Create graph
+finalClassGraphgraph = newClassGraph();
+
+// Recursively scan current directory for Java source code and attempt
+// to detect class names from there to be added to the graph.
+graph.addProject(".");
+
+// Blacklist example classes from being shown on the graph
+graph.blacklistClassPattern("eu.svjatoslav.inspector.java.structure.example.*");
+
+// do not show single classes with no relationships on the graph
+graph.hideOrphanedClasses();
+
+// Produce bitmap image titled "JavaInspect full project.png" to the
+// user Desktop directory.
+graph.generateGraph("JavaInspect full project");
+
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.
+