CODEWITHSUNDEEP
java
J Fabian Meier
J Fabian Meier

Reputation: 35785

Find out used classes and methods from Java source code

For Java source files, I would like to find out:

What would be a reasonable way to achieve that?

EDIT:

To clarify: I want a list of source code files as input. The output should be (as specified above) which class uses which other class and which method calls which other method. I do not want to inspect other loaded classes at runtime, like when using reflection.

Upvotes: 7

Views: 2485

Answers (3)

Ori Marko
Ori Marko

Reputation: 58774

You need to use static analysis tool as STAN standalone mode:

The standalone application is targeted to architects and project managers who are typically not using the IDE.

Or JArchitect (available also using command line)

JArchitect is a powerful tool for static code analysis. It can provide a lot of insight into complex code bases. Using custom code queries you are able to build your own rule sets in a very comfortable way.

In the Class Browser right-click menu, JArchitect proposes to explore the graph of dependencies between members (methods + fields) of a type.

Another option is SourceTrail

The graph visualization provides a quick overview of any class, method, field, etc., of interest and all its relations. The graph is fully interactive. Use it to move through the codebase by focusing on related nodes and edges.


(source: sourcetrail.com)

Upvotes: 4

Matt Timmermans
Matt Timmermans

Reputation: 59144

Unfortunately, reflection doesn't give you all the information you need to do this.

I've done it with ASM (https://asm.ow2.io/).

It provides the ability to walk the byte code of all of your classes using the visitor pattern, including the actual method implementations, from which you can extract the references to other classes.

I'm sorry that I cannot provide the implementation, because it's proprietary.

Note that this works from your .jar files, not your sources. If you really need to work from sources, then have a look at https://github.com/javaparser . Really, though, it's better to use the byte code, since the java language changes frequently, while the byte code specification does not.

Upvotes: 2

Victor Grazi
Victor Grazi

Reputation: 16470

I am not sure how to get a listing, but for identifying refactoring opportunities, you might try IntelliJ IDEA. It will dull out the signature line of any methods that are not accessed in the project. It will also detect code segments that are repeated elsewhere in the project, so you can extract common code.

Upvotes: -1

Related Questions