MaintainJ reduces the time needed to understand complex enterprise Java
applications from days to minutes. It also helps to document Java applications
using sequence and class diagrams.
MaintainJ generates runtime sequence diagrams using the call
trace captured for a single use case while you run the application.
The captured information includes data at each method call, any sql calls to
the database and the response time of each call. You can trace
applications running on a single JVM or on multiple JVM's and view the
end-to-end call trace in a single sequence diagram.
The following are the three steps to generate the diagrams:
You may want to check the sample
screenshots of
the generated sequence and class diagrams.
This step changes class files at runtime.
No changes are done to the source files nor any changes are
persisted to file system. You can choose the packages to be instrumented.
Instrumented applications are slow to service the first request but perform with
little overhead later.
Below are the types of Java applications supported out-of-the box by
MaintainJ. In fact, any non-J2ME Java applications can use MaintainJ by
following these steps.
The JRE versions currently supported are 1.4, 1.5, 1.6 and 1.7.
a) J2SE applications/Applets/JUnit - Tracing J2SE applications (Swing or non-GUI), Applets and JUnit is supported.
b) J2EE applications - The following J2EE application server are supported - Tomcat 4, 5, 6 & 7, JBoss 3, 4, 5 & 6, WebLogic 8, 9 & 10, WebSphere 5, 6 & 7. Glassfish and Jetty servers are also supported. If your server is not supported, follow these steps to generate the trace files. We would add support to your server on request.
c) Databases - MaintainJ captures the actual runtime sql calls sent to the database regardless of the JDBC frameworks used by the application. MaintainJ supports Oracle, DB2, MySQL, PostgreSQL and Derby out of the box. Microsoft SQL Server also is supported. Contact support if you are using MS SQL Server or any other databases.
Next, run the instrumented application and demarcate the start and end points of a use case. Call trace for the use case will be logged to the given trace file (.ser file).
a) J2EE Applications - A JSP is provided to demarcate the start and end points. You need to click a 'Start Tracing' button before a use case starts and click 'Stop Tracing' at the end of the use case. The call trace will be logged to the given file when 'Stop Tracing' is clicked.
b) J2SE/Applet/JUnit - A Swing window in which you can start and stop tracing opens when your instrumented application starts. Click 'Start Tracing' button before a use case starts and 'Stop Tracing' at the end of the use case. The call trace will be logged to the given file when 'Stop Tracing' is clicked.
Create a MaintainJ Trace Files Project by following File->New->Project->MaintainJ->MaintainJ Trace Files Project. Copy the trace files to this project and open to view the diagrams in MaintainJ UML Editor.
1. Using MaintainJ, Java developers can quickly analyze, understand, document and
enhance large Java code bases.
The MaintainJ demo video
is recorded on a Java application
that has 8000+ classes, runs on Tomcat and MySQL and uses Spring and Hibernate frameworks.
2. MaintainJ generates detailed runtime sequence and class diagrams for a single use case.
The arguments and return value of the call are shown in the sequence diagram. The runtime
SQL calls made during a use case, regardless of the database frameworks used, are shown.
All these details help developers to quickly troubleshoot a problem or to analyze and
enhance the application.
3. MaintainJ supports
tracing applications deployed across multiple JVM's. The call trace
captured on different JVM’s can be merged to view the end-to-end call flow across JVM’s.
For example, when an application calls a web service running in a different JVM, the call
flow across the JVMs is shown in a single sequence diagram. The calls in each JVM are
shown in a different color.
4. MaintainJ supports
runtime impact analysis -
Users can capture the runtime call
trace for all the use cases of the application and use that information to exactly
determine the use cases impacted by a change to a Java class, method or database
table or field.
5. Users can filter out the unwanted details from the MaintainJ generated diagrams
and then export the diagrams as UML2
model files. These models can be imported into
other UML2 compliant tools like Rational Software Architect (RSA) where they can
be edited for enhancing the application.
6. Any UML diagrams generated at runtime can be verbose and difficult to read.
MaintainJ provides simple user interface to dynamically explore the sequence
diagrams. Users can also search for a class, method or database table or field used in the use case.
7. MaintainJ offers various options to filter out unwanted details from the
generated diagrams and to view them at the level of abstraction that the user
wants. For example, a use case in a web application typically spans the
web tier, business tier and data access tier. Users can apply
predefined filters
on the diagram to view just the business tier classes. In addition,
MaintainJ shows the interactions between the application classes
only (no framework or library classes are shown).
8. Users can easily troubleshoot multi-threaded applications using
MaintainJ - The sequence diagram shows the runtime interactions
between threads in different colors. This helps developers to quickly
troubleshoot a multi-threaded application, which would be hard to
do using a traditional debugger.
9. MaintainJ integrates seamlessly with JUnit
- Users can generate a
sequence diagram for every test case and check the sequence diagram
for any troubleshooting later.
10. MaintainJ saves lot of effort for teams that maintain large
Java applications - Different developers in a team repeatedly spend time
to understand the same use cases because there are no tools to quickly
document and share that knowledge. By facilitating documentation and
sharing of the "Maintenance Experience" within the team using the generated
UML diagrams, MaintainJ exponentially reduces the total maintenance effort.