japicmp - GitLite

KO | EN

gitlite — search

#llm #golang #machine-learning #deep-learning #docker #java #awesome #cli #kubernetes #awesome-list #vue #pytorch #security #open-source

japicmp

(★ 773)

Comparison of two versions of a jar archive

파일 탐색기

최종 버전 다운로드 (.zip)

- - ci.yml
  - gh-release.yml
  - increment-version.yml
  - mvn-set-version.yml
  - mvn-site.yml
  - release.yml
  - snapshot.yml
- dependabot.yml
- japicmp_guava.html
- japicmp_guava.md
- japicmp_guava.png
- japicmp_guava_markdown.png
- japicmp_online.png
- pom.xml
- pom.xml
- pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- - pom.xml
- pom.xml
- - site.xml
.editorconfig
.gitattributes
.gitignore
.travis.yml
LICENSE
pom.xml
README.md
release.py
run-in-maven-docker.sh

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/siom79/japicmp

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd japicmp

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Maven (Java)

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
JDK (Java) Java 프로젝트를 빌드/실행하려면 필요합니다.
Maven mvn 명령어를 쓰기 위한 빌드 도구입니다.

Use the maven site plugin (`mvn site`) to generate the following reports:

Maven으로 의존성 설치와 빌드를 진행합니다.

* If necessary: Set the release version in maven using [this Action](https://github.com/siom79/japicmp/actions/workflows/mvn-set-version.yml) on the release branch

Maven으로 의존성 설치와 빌드를 진행합니다.

* Update maven site report with [Action](https://github.com/siom79/japicmp/actions/workflows/mvn-site.yml) on the release branch

Maven으로 의존성 설치와 빌드를 진행합니다.

✅ BUILD SUCCESS 메시지가 뜨면 성공입니다. target/ 폴더에 결과물이 생성됩니다.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

![japicmp](https://raw.githubusercontent.com/siom79/japicmp/master/src/site/resources/images/japicmp.png)

The website is located at [https://siom79.github.io/japicmp](https://siom79.github.io/japicmp/).

japicmp is a tool to compare two versions of a jar archive:
``` bash
java -jar japicmp-.0-jar-with-dependencies.jar -n new-version.jar -o old-version.jar
```
It can also be used as a library:
```java
JarArchiveComparatorOptions comparatorOptions = new JarArchiveComparatorOptions();
JarArchiveComparator jarArchiveComparator = new JarArchiveComparator(comparatorOptions);
List<JApiClass> jApiClasses = jarArchiveComparator.compare(oldArchives, newArchives);
```
japicmp is available in the Maven Central Repository:
[![maven](https://img.shields.io/maven-central/v/com.github.siom79.japicmp/japicmp.svg)](https://central.sonatype.com/artifact/com.github.siom79.japicmp/japicmp)
``` xml
<dependency>
	<groupId>com.github.siom79.japicmp</groupId>
	<artifactId>japicmp</artifactId>
	<version>0.26.1</version>
</dependency>
```
A maven plugin allows you to integrate the checks into your build:

``` xml
<plugin>
	<groupId>com.github.siom79.japicmp</groupId>
	<artifactId>japicmp-maven-plugin</artifactId>
	<version>0.26.1</version>
	<configuration>
		<oldVersion>
			<dependency>
				<groupId>japicmp</groupId>
				<artifactId>japicmp-test-v1</artifactId>
				<version>${oldversion}</version>
				<type>jar</type>
			</dependency>
		</oldVersion>
		<newVersion>
			<file>
				<path>${project.build.directory}/${project.artifactId}-${project.version}.${project.packaging}</path>
			</file>
		</newVersion>
		<parameter>
			
		</parameter>
	</configuration>
	<executions>
		<execution>
			<phase>verify</phase>
			<goals>
				<goal>cmp</goal>
			</goals>
		</execution>
	</executions>
</plugin>
```

A Sonar Qube plugin integrates the results from the japicmp analysis into your code quality report: [sonar-japicmp-plugin](https://github.com/siom79/sonar-japicmp-plugin).

By using the available Ant task, you can also integrate japicmp into your Ant build files:

``` xml
<taskdef resource="japicmp/ant/antlib.xml" classpathref="task.classpath"/>
<japicmp oldjar="${project.build.directory}/guava-18.0.jar"
	 newjar="${project.build.directory}/guava-19.0.jar"
	 oldclasspathref="old.classpath"
	 newclasspathref="new.classpath"
	 onlybinaryincompatiblemodifications="false"
	 onlyModifications="true"
	 />
```

[melix](https://github.com/melix) has developed a [gradle plugin](https://github.com/melix/japicmp-gradle-plugin) for japicmp.

## Online-Version

There is an online version of japicmp that lets you compare two artifacts from the maven central repository
without installing the tool first. Just click [this](https://www.japicmp.de) link and give it a try.

![japicmp-online](https://raw.githubusercontent.com/siom79/japicmp/master/doc/japicmp_online.png)

## MCP-Server

The [japicmp MCP server](https://github.com/siom79/japicmp-mcp-server) exposes japicmp's API comparison capabilities as
a tool for AI assistants that support the [Model Context Protocol (MCP)](https://modelcontextprotocol.io).
It allows AI agents such as Claude to compare two versions of a Maven artifact directly from a conversation — resolving
both JARs from Maven Central and returning a structured Markdown compatibility report, including binary and source
compatibility status, a semantic versioning verdict, and a detailed diff of every changed class, method, constructor,
and field.

## Motivation

Every time you release a new version of a library or a product, you have to tell your clients or customers what
has changed in comparison to the last release. Without the appropriate tooling, this task is tedious and error-prone.
This tool/library helps you to determine the differences between the java class files that are contained in two given
jar archives.

This library does not use the Java Reflection API to compute the differences, as the usage of the Reflection API makes
it necessary to include all classes the jar archive under investigation depends on are available on the classpath.
To prevent the inclusion of all dependencies, which can be a lot of work for bigger applications, this library makes
use of the [javassist](https://www.javassist.org/) library to inspect the class files.
This way you only have to provide the two jar archives on the command line (and eventually libraries that contain
classes/interfaces you have extended/implemented).

This approach also detects changes in instrumented and generated classes. You can even evaluate changes in class file attributes (like synthetic) or annotations.
The comparison of annotations makes this approach suitable for annotation-based APIs like JAXB, JPA, JAX-RS, etc.

The goal of this project is to provide a fast and easy to use API comparison for Java. Therefore it does not aim
to integrate change tracking of other types of artifacts (configuration files, etc.) as a generic implementation means
to make compromises in terms of performance and ease of usage. japicmp for example compares two archives with about 1700 classes each
in less than one second and therewith can be easily integrated in each build.

## Features

* Comparison of two jar archives without the need to add all of their dependencies to the classpath.
* Differences are printed on the command line in a simple diff format.
* Differences can optionally be printed as [Markdown](https://www.markdownguide.org/), XML or HTML file.
* Per default private and package protected classes and class members are not compared. If necessary, the access modifier of the classes and class members to be
  compared can be set to public, protected, package or private.
* Per default all classes are tracked. If necessary, certain packages, classes, methods or fields can be excluded or explicitly included. Inclusion and exclusion is also possible based on annotations.
* All changes between all classes/methods/fields are compared. japicmp differentiates between source and binary compatible changes (as described in the [Java Language Specification](http://docs.oracle.com/javase/specs/jls/se7/html/jls-13.html) and the [OpenJDK-Wiki](https://wiki.openjdk.org/spaces/csr/pages/32342052/Kinds+of+Compatibility)).
* All changes between annotations are compared, hence japicmp can be used to track annotation-based APIs like JAXB, JPA, JAX-RS, etc.
* A maven plugin is available that allows you to compare the current artifact version with some older version from the repository.
* The option `--semantic-versioning` tells you which part of the version you have to increment in order to follow [semantic versioning](http://semver.org/).
* If a class is serializable, changes are evaluated regarding the [Java Object Serialization Specification](http://docs.oracle.com/javase/7/docs/platform/serialization/spec/serialTOC.html).
* Per default synthetic classes and class members (e.g. [bridge methods](https://docs.oracle.com/javase/tutorial/java/generics/bridgeMethods.html)) are hidden. They can be listed by using the option `--include-synthetic`.
* The maven plugin allows project-specific filtering and reports using a custom [Groovy](https://groovy-lang.org/) script.

## Downloads

You can download the latest version from the [release page](https://github.com/siom79/japicmp/releases) or directly from the [maven central repository](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22japicmp%22).

## Buy me a coffee

If you like japicmp and would like to do me a favor for all the work I've done over
the years, please consider buying me a coffee [here](https://www.buymeacoffee.com/mmois).

<a href="https://www.buymeacoffee.com/mmois" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="41" width="174"></a>

# Development

## Reports

Use the maven site plugin (`mvn site`) to generate the following reports:
 * findbugs
 * checkstyle
 * japicmp

## Release

This is the release procedure:
* Create a branch named release-v0.XX.X
* Update ReleaseNotes.md.
* If necessary: Set the release version in maven using [this Action](https://github.com/siom79/japicmp/actions/workflows/mvn-set-version.yml) on the release branch
* Increment version in README.md / Site-Report by running [this Action](https://github.com/siom79/japicmp/actions/workflows/increment-version.yml) on the release branch
* Run release [Action](https://github.com/siom79/japicmp/actions/workflows/release.yml)
* Login to [Central repository](https://central.sonatype.com/publishing)
	* Download released artifact from staging repository.
	* Close and release staging repository if sanity checks are successful.
* Update maven site report with [Action](https://github.com/siom79/japicmp/actions/workflows/mvn-site.yml) on the release branch
* Run Github Release [Action](https://github.com/siom79/japicmp/actions/workflows/gh-release.yml) on the tag
* Merge release branch into master

If the release fails, the version must be reverted and the tag created during the release has to be deleted:
```bash
mvn versions:set -DnewVersion=<new-version>-SNAPSHOT
mvn versions:commit
git push
git push --delete origin japicmp-base-<new-version>
```
Afterward, the release action can be executed again.

## Contributions

Pull requests are welcome, but please follow these rules:

* The basic editor settings (indentation, newline, etc.) are described in the `.editorconfig` file (see [EditorConfig](http://editorconfig.org/)).
* Provide a unit test for every change.
* Name classes/methods/fields expressively.
* Fork the repo and create a pull request (see [GitHub Flow](https://guides.github.com/introduction/flow/index.html)).

## Website

The website can be generated by running this github [Action](https://github.com/siom79/japicmp/actions/workflows/mvn-site.yml)
on the tag.

It uses the [maven-scm-publish-plugin](https://maven.apache.org/plugins/maven-scm-publish-plugin/index.html) to
generate the site report and push it to the [gh-pages](https://github.com/siom79/japicmp/tree/gh-pages) branch.