Open-source project
spring-projects/spring-integration-samples avatar
spring-projects/spring-integration-samples

Spring Integration Samples: the README says four categories and lists five

You are looking for examples, code snippets, sample applications for Spring Integration? This is the place.

2,376 stars2,515 forksJavaLicense varies

At a glance

What is it?
Fifty plus runnable samples for Spring Integration, grouped by difficulty and split into Gradle subprojects on main, with older versions kept on separate branches. The category list, the duplicate entries and the absent license file are the details worth knowing before you clone it.
Who is it for?
This repository is worth cloning if you are moving to a messaging architecture and want working code for a specific adapter rather than an abstract description of one, because every sample ships its own README with run instructions and the Basic set alone covers thirty integrations. Check three things first.
Can I use it commercially?
Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
Is it still maintained?
Yes. The repository last received commits 26 days ago.
What is it written in?
Mainly Java, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • spring-projects/spring-integration-samples2,376 ★ · +1
Star history
Repository2026-09-302026-11-15
spring-projects/spring-integration-samples2.4k2.4k

1 Stars in the last 46 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The README announces four categories and then lists five

The opening paragraph says the samples are split into 4 distinct categories, and the bullets immediately below it name Basic, Intermediate, Advanced, Applications and DSL. Five names under a sentence that says four. The directory listing at the root matches the five, with advanced/, applications/, basic/, dsl/, intermediate/ and a src/ directory alongside them, so the tree supports five and only the prose count is wrong. The categories are also not a single difficulty ladder. DSL is described as holding demos for Spring Integration Java Configuration and the Java DSL Extension, which is a subject rather than a level, and it is listed before Basic in the category descriptions even though Basic is where the README tells a newcomer to start. Basic is for technically motivated minimum configurations, Intermediate targets developers already past getting started who need help with problems such as error handling or configuring an Aggregator for messages that may never arrive.

Thirty entries in the Basic list, and four of them are TCP

The Basic category is where the inventory is, with thirty entries, and it is organised by adapter rather than by problem. Transports and protocols take the largest share: amqp, ftp, sftp, jdbc, jms, jmx, jpa, mail for IMAP and POP3, mongodb, mqtt, xmpp and zip, plus http, xml and tcp. The TCP family is split four ways, tcp-amqp which bridges the Spring Integration TCP adapters to the AMQP adapters, tcp-broadcast which sends one message to multiple connected TCP clients, tcp-client-server built on TcpOutboundGateway and TcpInboundGateway together with a Gateway and a Service Activator, and tcp-with-headers which sends headers alongside the payload using JSON. Two web service samples sit next to each other as ws-inbound-gateway and ws-outbound-gateway, the latter combining the Web Service Outbound Gateway, a Content Enricher and a Chain. Naming is not uniform: oddeven is one word, testing-examples is plural, and xmpp is annotated as formerly known as Jabber with GoogleTalk named as the worked example.

async-gateway is listed twice and one entry is missing its separator

The Intermediate category is where the list starts to fray. async-gateway appears two lines apart with two different descriptions, first as a usage example of an asynchronous Gateway and then as an example showing usage of an Asynchronous Gateway, so the same directory is announced twice and it is not clear from the entry whether one sample or two exist. The monitoring entry breaks the format used by every other line, dropping the hyphen that separates the directory name from its description and running straight into The project used in the Spring Integration Management and Monitoring Webinar. The list also ends partway through the multipart-http entry, at the words Demonstrating the sending of HTTP multip, so the Advanced and Applications categories described above are named but never itemised in what is visible here. A reader working through Intermediate by directory name will therefore find that the README's own index is not a complete map.

Main needs Spring Integration 6.0 and Java 17, older code lives on other branches

Version targeting is expressed as branch names rather than as releases, and the repository has no GitHub releases at all. The main branch requires Spring Integration 6.0 or above, and samples running against earlier versions are on the 5.5.x branch and other branches. The project requires Java 17 or above. That combination is the whole of the compatibility statement, so there is no matrix of tested versions, no support policy, and nothing to pin with a version number; a build that depends on a specific Spring Integration line has to pick the branch that matches it. For IDE use the instruction is to open the project with the import option against a build.gradle file from the root project directory. The tree supports that: gradlew and gradlew.bat wrappers are checked in, a gradle/ directory holds the wrapper itself, and settings.gradle and gradle.properties sit next to build.gradle.

There is no LICENSE file in the tree and no license in the metadata

The top level of the repository holds .github/, .gitignore, README.md, the five category directories, src/, build.gradle, settings.gradle, gradle.properties, the gradle/ directory and the two wrapper scripts. A LICENSE file is not among them, and the project metadata records no license at all, so the two sources that would normally settle the question are both empty. That is worth stating plainly rather than working around: nothing in this repository states what license these samples are under, and the Spring Integration link and the Extensions link in the README point at other projects whose terms are their own. The samples are meant to be read, copied and modified, which is exactly the situation where an unstated license matters. Check the terms with the project before lifting code from these directories into anything you distribute.

Every sample and every category carries its own README

The documentation strategy is two levels of markdown. Each of the five category directories holds a README.md with a description of that category, and inside them each sample directory carries its own README.md explaining the details, with running the sample given as the example. The root README then works as an index, one line per sample with the components it demonstrates, and in the Basic section those lines name the concrete pieces: a Service Activator wired to a Channel, a Gateway applied to a message exchange, the MAIL and XML modules, an XPath Splitter, an XPath Router, an XSLT Transformer, an Inbound Channel Adapter, a Filter, a Router and a Poller, a Poller with Interval Triggers. So the entry point is not a tutorial. It is a table of contents with one sentence per sample, and the sentence tells you which component to look at before you decide whether to open the sample at all.

The root is a Gradle build with per sample subprojects

The layout is a Gradle build at the root with settings.gradle for the multi-project definition and a build.gradle at the root project directory, which is the file the IDE import instruction points at. The category directories are therefore subprojects of one build rather than thirty independent repositories, and the checked in wrapper means the same Gradle version resolves on any machine that clones it. What the visible text does not give is a single command that builds or runs everything. There is no instruction for running the whole tree at once, no list of subprojects, and no per sample dependency matrix in what is available here; the run instructions live in the per sample README files instead. A CI job that wants to compile all thirty Basic samples has to discover the subproject layout from settings.gradle itself rather than from documentation.

Samples that are not here are pointed at three other places

Three pointers sit outside the repository, and each names a different kind of gap. The Spring Integration Extensions project is offered first, with the note that it also provides numerous samples, which is where a component that lives outside the core framework would be demonstrated. Community sample projects are credited to Xavier Padró by name, with no further description attached. Then there is the monitoring entry, which is not a directory at all but the project used in the Spring Integration Management and Monitoring Webinar, also available on the SpringSourceDev YouTube channel. The project homepage is the springsource.org Spring Integration page, and a badge at the top of the README links to a scan service keyed on the project name. Nothing in these pointers carries a version statement, so a sample adopted from outside main inherits whatever framework version its author used.

Editorial conclusion

This repository is worth cloning if you are moving to a messaging architecture and want working code for a specific adapter rather than an abstract description of one, because every sample ships its own README with run instructions and the Basic set alone covers thirty integrations. Check three things first. The category scheme is not consistently applied, with the README announcing four categories and then listing five, so do not trust the count when you navigate. Version targeting is done through branch names, since main needs Spring Integration 6.0 and Java 17 and there are no releases to pin. And there is no license file in the tree and no license recorded in the project metadata, so check with the project before copying sample code into anything you publish.

Frequently asked questions

What Java and Spring Integration versions do the samples on main need?

The main branch requires Spring Integration 6.0 or above, and the project requires Java 17 or above. Samples for earlier framework versions live on the 5.5.x branch and other branches.

How is spring-integration-samples organised?

Over fifty samples live in five category directories: basic, intermediate, advanced, applications and dsl. Each category has its own README.md, and each sample directory has its own README.md explaining how to run it.

Does spring-integration-samples have a license file?

There is no LICENSE file among the top level entries, and the project metadata records no license. Nothing in the repository states the terms these samples are published under.

Where can I find Spring Integration samples beyond this repository?

The Spring Integration Extensions project, which the README says also provides numerous samples, and a community sample project credited to Xavier Padró. The monitoring sample also exists as the project from a Spring Integration Management and Monitoring Webinar.

How do I open spring-integration-samples in an IDE?

Use the IDE's import option against a build.gradle file from the root project directory. The repository ships a Gradle wrapper with gradlew and gradlew.bat, so the wrapper version resolves without a separate install.

Are there any GitHub releases for spring-integration-samples?

No, the repository has no GitHub releases. Version targeting is done with branch names, with main for Spring Integration 6.0 and above and 5.5.x plus other branches for earlier versions.

Official sources

  1. Issues
  2. Project website
  3. README
  4. spring-projects/spring-integration-samples on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/spring-projects-spring-integration-samples.svg)](https://hysenlabs.com/projects/spring-projects-spring-integration-samples)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/spring-projects-spring-integration-samples.svg)](https://hysenlabs.com/projects/spring-projects-spring-integration-samples)

Was this useful?