Spring/spring-integration-extensions
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

INTEXT-44 - Polishing

Browse Source 
* Upgrade to Gradle 1.6
* Upgrade Sonar plugin to SonarRunner
* Upgrade a few dependencies (e.g. JUnit, Spring Integration)
* Remove deprecations (e.g. JUnit)
* Convert spaces to tabs
* Add author tags
* Add @since
This commit is contained in:
Gunnar Hillert
2013-06-03 00:02:47 -04:00
parent e46cbfdcb4
commit 5bf4b9871e
55 changed files with 1706 additions and 1833 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
spring-integration-kafka/build.gradle
View File

@@ -1,12 +1,9 @@
description = 'Spring Integration Kafka Adapter'
description = 'Spring Integration Kafka Support'
buildscript {
repositories {
maven { url 'https://repo.springsource.org/plugins-snapshot' }
}
dependencies {
classpath 'org.springframework.build.gradle:docbook-reference-plugin:0.1.5'
}
}
apply plugin: 'java'
@@ -17,24 +14,28 @@ apply plugin: 'idea'
group = 'org.springframework.integration'
repositories {
mavenLocal()
mavenCentral()
maven { url 'http://repo.springsource.org/libs-milestone' }
maven { url 'http://repo.springsource.org/plugins-release' }
maven { url 'https://repo.springsource.org/libs-snapshot' }
maven { url 'https://repo.springsource.org/libs-snapshot' }
}
sourceCompatibility=1.6
targetCompatibility=1.6
ext {
junitVersion = '4.10'
junitVersion = '4.11'
log4jVersion = '1.2.12'
mockitoVersion = '1.9.0'
mockitoVersion = '1.9.5'
springVersion = '3.1.3.RELEASE'
springIntegrationVersion = '2.2.0.RELEASE'
springIntegrationVersion = '2.2.3.RELEASE'
idPrefix = 'kafka'
linkHomepage = 'https://github.com/SpringSource/spring-integration-extensions'
linkCi = 'https://build.springsource.org/browse/INTEXT'
linkIssue = 'https://jira.springsource.org/browse/INTEXT'
linkScmUrl = 'https://github.com/SpringSource/spring-integration-extensions'
linkScmConnection = 'https://github.com/SpringSource/spring-integration-extensions.git'
linkScmDevConnection = 'git@github.com:SpringSource/spring-integration-extensions.git'
}
eclipse {
@@ -61,47 +62,48 @@ dependencies {
compile "org.springframework:spring-beans:$springVersion"
compile "org.springframework:spring-context:$springVersion"
compile "org.springframework:spring-expression:$springVersion"
compile "org.springframework.integration:spring-integration-core:$springIntegrationVersion"
compile("org.apache:kafka_2.9.2:0.8.0-SNAPSHOT") {
exclude module: 'log4j'
}
compile("org.apache.zookeeper:zookeeper:3.3.4") {
exclude module: 'log4j'
exclude module: 'jline'
}
compile "org.scala-lang:scala-library:2.9.2"
compile "org.scala-lang:scala-compiler:2.9.2"
compile("log4j:log4j:1.2.15") {
exclude module: 'jms'
exclude module: 'jmx'
exclude module: 'jmxtools'
exclude module: 'jmxri'
compile "org.springframework.integration:spring-integration-core:$springIntegrationVersion"
compile("org.apache:kafka_2.9.2:0.8.0-SNAPSHOT") {
exclude module: 'log4j'
}
compile("org.apache.zookeeper:zookeeper:3.3.4") {
exclude module: 'log4j'
exclude module: 'jline'
}
compile "org.scala-lang:scala-library:2.9.2"
compile "org.scala-lang:scala-compiler:2.9.2"
compile("log4j:log4j:1.2.15") {
exclude module: 'jms'
exclude module: 'jmx'
exclude module: 'jmxtools'
exclude module: 'jmxri'
}
compile "org.slf4j:slf4j-simple:1.6.4"
compile "net.sf.jopt-simple:jopt-simple:3.2"
compile "org.xerial.snappy:snappy-java:1.0.4.1"
//runtime "zkclient:zkclient:20120522"
}
compile "org.slf4j:slf4j-simple:1.6.4"
compile "net.sf.jopt-simple:jopt-simple:3.2"
compile "org.xerial.snappy:snappy-java:1.0.4.1"
//runtime "zkclient:zkclient:20120522"
runtime "com.101tec:zkclient:0.2"
runtime "com.yammer.metrics:metrics-core:2.2.0"
runtime "com.yammer.metrics:metrics-annotation:2.2.0"
runtime "com.101tec:zkclient:0.2"
runtime "com.yammer.metrics:metrics-core:2.2.0"
runtime "com.yammer.metrics:metrics-annotation:2.2.0"
compile "org.apache.avro:avro:1.7.3"
compile "org.apache.avro:avro-compiler:1.7.3"
compile "org.apache.avro:avro:1.7.3"
compile "org.apache.avro:avro-compiler:1.7.3"
testCompile "org.springframework.integration:spring-integration-test:$springIntegrationVersion"
testCompile "junit:junit-dep:$junitVersion"
testCompile("log4j:log4j:$log4jVersion") {
exclude module: 'jms'
exclude module: 'jmx'
exclude module: 'jmxtools'
exclude module: 'jmxri'
}
exclude module: 'jms'
exclude module: 'jmx'
exclude module: 'jmxtools'
exclude module: 'jmxri'
}
testCompile "org.mockito:mockito-all:$mockitoVersion"
testCompile "org.springframework:spring-test:$springVersion"
testCompile "org.springframework.integration:spring-integration-stream:$springIntegrationVersion"
jacoco group: "org.jacoco", name: "org.jacoco.agent", version: "0.5.6.201201232323", classifier: "runtime"
testCompile "org.springframework.integration:spring-integration-stream:$springIntegrationVersion"
jacoco group: "org.jacoco", name: "org.jacoco.agent", version: "0.6.2.201302030002", classifier: "runtime"
}
@@ -130,44 +132,18 @@ artifacts {
archives javadocJar
}
apply plugin: 'docbook-reference'
apply plugin: 'sonar-runner'
reference {
sourceDir = file('src/reference/docbook')
}
apply plugin: 'sonar'
sonar {
if (rootProject.hasProperty('sonarHostUrl')) {
server.url = rootProject.sonarHostUrl
sonarRunner {
sonarProperties {
property "sonar.jacoco.reportPath", "${buildDir.name}/jacoco.exec"
property "sonar.links.homepage", linkHomepage
property "sonar.links.ci", linkCi
property "sonar.links.issue", linkIssue
property "sonar.links.scm", linkScmUrl
property "sonar.links.scm_dev", linkScmDevConnection
property "sonar.java.coveragePlugin", "jacoco"
}
database {
if (rootProject.hasProperty('sonarJdbcUrl')) {
url = rootProject.sonarJdbcUrl
}
if (rootProject.hasProperty('sonarJdbcDriver')) {
driverClassName = rootProject.sonarJdbcDriver
}
if (rootProject.hasProperty('sonarJdbcUsername')) {
username = rootProject.sonarJdbcUsername
}
if (rootProject.hasProperty('sonarJdbcPassword')) {
password = rootProject.sonarJdbcPassword
}
}
project {
dynamicAnalysis = "reuseReports"
withProjectProperties { props ->
props["sonar.core.codeCoveragePlugin"] = "jacoco"
props["sonar.jacoco.reportPath"] = "${buildDir.name}/jacoco.exec"
}
}
logger.info("Sonar parameters used: server.url='${server.url}'; database.url='${database.url}'; database.driverClassName='${database.driverClassName}'; database.username='${database.username}'")
}
task api(type: Javadoc) {
@@ -212,7 +188,7 @@ task schemaZip(type: Zip) {
task docsZip(type: Zip) {
group = 'Distribution'
classifier = 'docs'
description = "Builds -${classifier} archive containing api and reference " +
description = "Builds -${classifier} archive containing api " +
"for deployment at static.springframework.org/spring-integration/docs."
from('src/dist') {
@@ -222,10 +198,6 @@ task docsZip(type: Zip) {
from (api) {
into 'api'
}
from (reference) {
into 'reference'
}
}
task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
@@ -300,5 +272,5 @@ task dist(dependsOn: assemble) {
task wrapper(type: Wrapper) {
description = 'Generates gradlew[.bat] scripts'
gradleVersion = '1.3'
gradleVersion = '1.6'
}

BIN
spring-integration-kafka/gradle/wrapper/gradle-wrapper.jar vendored
View File

Binary file not shown.

4
spring-integration-kafka/gradle/wrapper/gradle-wrapper.properties vendored
View File

@@ -1,6 +1,6 @@
#Wed Sep 05 13:34:36 EDT 2012
#Sun Jun 02 23:08:46 EDT 2013
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=http\://services.gradle.org/distributions/gradle-1.1-bin.zip
distributionUrl=http\://services.gradle.org/distributions/gradle-1.6-bin.zip

8
spring-integration-kafka/gradlew vendored
View File

@@ -1,4 +1,4 @@
#!/bin/bash
#!/usr/bin/env bash
##############################################################################
##
@@ -61,9 +61,9 @@ while [ -h "$PRG" ] ; do
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/"
cd "`dirname \"$PRG\"`/" >&-
APP_HOME="`pwd -P`"
cd "$SAVED"
cd "$SAVED" >&-
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -101,7 +101,7 @@ if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query businessSystem maximum file descriptor limit: $MAX_FD_LIMIT"
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi

180
spring-integration-kafka/gradlew.bat vendored
View File

@@ -1,90 +1,90 @@
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windowz variants
if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
goto execute
:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windowz variants
if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
goto execute
:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

9
spring-integration-kafka/publish-maven.gradle
View File

@@ -31,7 +31,7 @@ def customizePom(pom, gradleProject) {
generatedPom.project {
name = gradleProject.description
description = gradleProject.description
url = 'https://github.com/SpringSource/spring-integration-extensions'
url = linkHomepage
organization {
name = 'SpringSource'
url = 'http://springsource.org'
@@ -43,10 +43,11 @@ def customizePom(pom, gradleProject) {
distribution 'repo'
}
}
scm {
url = 'https://github.com/SpringSource/spring-integration-extensions'
connection = 'scm:git:git://github.com/SpringSource/spring-integration-extensions'
developerConnection = 'scm:git:git://github.com/SpringSource/spring-integration-extensions'
url = linkScmUrl
connection = 'scm:git:' + linkScmConnection
developerConnection = 'scm:git:' + linkScmDevConnection
}
developers {

119
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/KafkaConsumerContextParser.java
View File

@@ -37,86 +37,87 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaConsumerContextParser extends AbstractSingleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(final Element element) {
return KafkaConsumerContext.class;
}
@Override
protected Class<?> getBeanClass(final Element element) {
return KafkaConsumerContext.class;
}
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
final Element consumerConfigurations = DomUtils.getChildElementByTagName(element, "consumer-configurations");
parseConsumerConfigurations(consumerConfigurations, parserContext, builder, element);
}
final Element consumerConfigurations = DomUtils.getChildElementByTagName(element, "consumer-configurations");
parseConsumerConfigurations(consumerConfigurations, parserContext, builder, element);
}
private void parseConsumerConfigurations(final Element consumerConfigurations, final ParserContext parserContext,
final BeanDefinitionBuilder builder, final Element parentElem) {
for (final Element consumerConfiguration : DomUtils.getChildElementsByTagName(consumerConfigurations, "consumer-configuration")) {
final BeanDefinitionBuilder consumerConfigurationBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConfiguration.class);
final BeanDefinitionBuilder consumerMetadataBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerMetadata.class);
private void parseConsumerConfigurations(final Element consumerConfigurations, final ParserContext parserContext,
final BeanDefinitionBuilder builder, final Element parentElem) {
for (final Element consumerConfiguration : DomUtils.getChildElementsByTagName(consumerConfigurations, "consumer-configuration")) {
final BeanDefinitionBuilder consumerConfigurationBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConfiguration.class);
final BeanDefinitionBuilder consumerMetadataBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerMetadata.class);
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "group-id");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "group-id");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "value-decoder");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "key-decoder");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "key-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "value-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerConfigurationBuilder, consumerConfiguration, "max-messages");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, parentElem, "consumer-timeout");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "value-decoder");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "key-decoder");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "key-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, consumerConfiguration, "value-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerConfigurationBuilder, consumerConfiguration, "max-messages");
IntegrationNamespaceUtils.setValueIfAttributeDefined(consumerMetadataBuilder, parentElem, "consumer-timeout");
final Map<String, Integer> topicStreamsMap = new HashMap<String, Integer>();
final Map<String, Integer> topicStreamsMap = new HashMap<String, Integer>();
for (final Element topicConfiguration : DomUtils.getChildElementsByTagName(consumerConfiguration, "topic")) {
final String topic = topicConfiguration.getAttribute("id");
final String streams = topicConfiguration.getAttribute("streams");
final Integer streamsInt = Integer.valueOf(streams);
topicStreamsMap.put(topic, streamsInt);
}
for (final Element topicConfiguration : DomUtils.getChildElementsByTagName(consumerConfiguration, "topic")) {
final String topic = topicConfiguration.getAttribute("id");
final String streams = topicConfiguration.getAttribute("streams");
final Integer streamsInt = Integer.valueOf(streams);
topicStreamsMap.put(topic, streamsInt);
}
consumerMetadataBuilder.addPropertyValue("topicStreamMap", topicStreamsMap);
consumerMetadataBuilder.addPropertyValue("topicStreamMap", topicStreamsMap);
final BeanDefinition consumerMetadataBeanDef = consumerMetadataBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerMetadataBeanDef, "consumerMetadata_" + consumerConfiguration.getAttribute("group-id")),
parserContext.getRegistry());
final BeanDefinition consumerMetadataBeanDef = consumerMetadataBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerMetadataBeanDef, "consumerMetadata_" + consumerConfiguration.getAttribute("group-id")),
parserContext.getRegistry());
final String zookeeperConnectBean = parentElem.getAttribute("zookeeper-connect");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, parentElem, zookeeperConnectBean);
final String zookeeperConnectBean = parentElem.getAttribute("zookeeper-connect");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, parentElem, zookeeperConnectBean);
final BeanDefinitionBuilder consumerConfigFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConfigFactoryBean.class);
consumerConfigFactoryBuilder.addConstructorArgReference("consumerMetadata_" + consumerConfiguration.getAttribute("group-id"));
final BeanDefinitionBuilder consumerConfigFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConfigFactoryBean.class);
consumerConfigFactoryBuilder.addConstructorArgReference("consumerMetadata_" + consumerConfiguration.getAttribute("group-id"));
if (StringUtils.hasText(zookeeperConnectBean)) {
consumerConfigFactoryBuilder.addConstructorArgReference(zookeeperConnectBean);
}
if (StringUtils.hasText(zookeeperConnectBean)) {
consumerConfigFactoryBuilder.addConstructorArgReference(zookeeperConnectBean);
}
final BeanDefinition consumerConfigFactoryBuilderBeanDefinition = consumerConfigFactoryBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerConfigFactoryBuilderBeanDefinition, "consumerConfigFactory_" + consumerConfiguration.getAttribute("group-id")), parserContext.getRegistry());
final BeanDefinition consumerConfigFactoryBuilderBeanDefinition = consumerConfigFactoryBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerConfigFactoryBuilderBeanDefinition, "consumerConfigFactory_" + consumerConfiguration.getAttribute("group-id")), parserContext.getRegistry());
final BeanDefinitionBuilder consumerConnectionProviderBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConnectionProvider.class);
consumerConnectionProviderBuilder.addConstructorArgReference("consumerConfigFactory_" + consumerConfiguration.getAttribute("group-id"));
final BeanDefinitionBuilder consumerConnectionProviderBuilder = BeanDefinitionBuilder.genericBeanDefinition(ConsumerConnectionProvider.class);
consumerConnectionProviderBuilder.addConstructorArgReference("consumerConfigFactory_" + consumerConfiguration.getAttribute("group-id"));
final BeanDefinition consumerConnectionProviderBuilderBeanDefinition = consumerConnectionProviderBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerConnectionProviderBuilderBeanDefinition, "consumerConnectionProvider_" + consumerConfiguration.getAttribute("group-id")), parserContext.getRegistry());
final BeanDefinition consumerConnectionProviderBuilderBeanDefinition = consumerConnectionProviderBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(consumerConnectionProviderBuilderBeanDefinition, "consumerConnectionProvider_" + consumerConfiguration.getAttribute("group-id")), parserContext.getRegistry());
final BeanDefinitionBuilder messageLeftOverBeanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(MessageLeftOverTracker.class);
final BeanDefinition messageLeftOverBeanDefinition = messageLeftOverBeanDefinitionBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(messageLeftOverBeanDefinition, "messageLeftOver_" + consumerConfiguration.getAttribute("group-id")),
parserContext.getRegistry());
final BeanDefinitionBuilder messageLeftOverBeanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(MessageLeftOverTracker.class);
final BeanDefinition messageLeftOverBeanDefinition = messageLeftOverBeanDefinitionBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(messageLeftOverBeanDefinition, "messageLeftOver_" + consumerConfiguration.getAttribute("group-id")),
parserContext.getRegistry());
consumerConfigurationBuilder.addConstructorArgReference("consumerMetadata_" + consumerConfiguration.getAttribute("group-id"));
consumerConfigurationBuilder.addConstructorArgReference("consumerConnectionProvider_" + consumerConfiguration.getAttribute("group-id"));
consumerConfigurationBuilder.addConstructorArgReference("messageLeftOver_" + consumerConfiguration.getAttribute("group-id"));
consumerConfigurationBuilder.addConstructorArgReference("consumerMetadata_" + consumerConfiguration.getAttribute("group-id"));
consumerConfigurationBuilder.addConstructorArgReference("consumerConnectionProvider_" + consumerConfiguration.getAttribute("group-id"));
consumerConfigurationBuilder.addConstructorArgReference("messageLeftOver_" + consumerConfiguration.getAttribute("group-id"));
final AbstractBeanDefinition consumerConfigurationBeanDefinition = consumerConfigurationBuilder.getBeanDefinition();
final AbstractBeanDefinition consumerConfigurationBeanDefinition = consumerConfigurationBuilder.getBeanDefinition();
final String consumerConfigurationBeanName = "consumerConfiguration_" + consumerConfiguration.getAttribute("group-id");
registerBeanDefinition(new BeanDefinitionHolder(consumerConfigurationBeanDefinition, consumerConfigurationBeanName),
parserContext.getRegistry());
}
}
final String consumerConfigurationBeanName = "consumerConfiguration_" + consumerConfiguration.getAttribute("group-id");
registerBeanDefinition(new BeanDefinitionHolder(consumerConfigurationBeanDefinition, consumerConfigurationBeanName),
parserContext.getRegistry());
}
}
}

21
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/KafkaInboundChannelAdapterParser.java
View File

@@ -28,22 +28,23 @@ import org.w3c.dom.Element;
* The Kafka Inbound Channel adapter parser
*
* @author Soby Chacko
* @since 0.5
*
*/
public class KafkaInboundChannelAdapterParser extends AbstractPollingInboundChannelAdapterParser {
@Override
protected BeanMetadataElement parseSource(final Element element, final ParserContext parserContext) {
final BeanDefinitionBuilder highLevelConsumerMessageSourceBuilder =
BeanDefinitionBuilder.genericBeanDefinition(KafkaHighLevelConsumerMessageSource.class);
@Override
protected BeanMetadataElement parseSource(final Element element, final ParserContext parserContext) {
final BeanDefinitionBuilder highLevelConsumerMessageSourceBuilder =
BeanDefinitionBuilder.genericBeanDefinition(KafkaHighLevelConsumerMessageSource.class);
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(highLevelConsumerMessageSourceBuilder, element, "kafka-decoder");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(highLevelConsumerMessageSourceBuilder, element, "kafka-decoder");
final String kafkaConsumerContext = element.getAttribute("kafka-consumer-context-ref");
final String kafkaConsumerContext = element.getAttribute("kafka-consumer-context-ref");
if (StringUtils.hasText(kafkaConsumerContext)) {
highLevelConsumerMessageSourceBuilder.addConstructorArgReference(kafkaConsumerContext);
}
if (StringUtils.hasText(kafkaConsumerContext)) {
highLevelConsumerMessageSourceBuilder.addConstructorArgReference(kafkaConsumerContext);
}
return highLevelConsumerMessageSourceBuilder.getBeanDefinition();
return highLevelConsumerMessageSourceBuilder.getBeanDefinition();
}
}

11
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/KafkaNamespaceHandler.java
View File

@@ -21,18 +21,19 @@ import org.springframework.integration.config.xml.AbstractIntegrationNamespaceHa
* The namespace handler for the Kafka namespace
*
* @author Soby Chacko
* @since 0.5
*
*/
public class KafkaNamespaceHandler extends AbstractIntegrationNamespaceHandler {
/* (non-Javadoc)
* @see org.springframework.beans.factory.xml.NamespaceHandler#init()
*/
@Override
@Override
public void init() {
registerBeanDefinitionParser("zookeeper-connect", new ZookeeperConnectParser());
registerBeanDefinitionParser("zookeeper-connect", new ZookeeperConnectParser());
registerBeanDefinitionParser("inbound-channel-adapter", new KafkaInboundChannelAdapterParser());
registerBeanDefinitionParser("outbound-channel-adapter", new KafkaOutboundChannelAdapterParser());
registerBeanDefinitionParser("producer-context", new KafkaProducerContextParser());
registerBeanDefinitionParser("consumer-context", new KafkaConsumerContextParser());
registerBeanDefinitionParser("outbound-channel-adapter", new KafkaOutboundChannelAdapterParser());
registerBeanDefinitionParser("producer-context", new KafkaProducerContextParser());
registerBeanDefinitionParser("consumer-context", new KafkaConsumerContextParser());
}
}

21
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/KafkaOutboundChannelAdapterParser.java
View File

@@ -26,20 +26,21 @@ import org.w3c.dom.Element;
/**
*
* @author Soby Chacko
* @since 0.5
*
*/
public class KafkaOutboundChannelAdapterParser extends AbstractOutboundChannelAdapterParser {
@Override
protected AbstractBeanDefinition parseConsumer(final Element element, final ParserContext parserContext) {
final BeanDefinitionBuilder kafkaProducerMessageHandlerBuilder =
BeanDefinitionBuilder.genericBeanDefinition(KafkaProducerMessageHandler.class);
@Override
protected AbstractBeanDefinition parseConsumer(final Element element, final ParserContext parserContext) {
final BeanDefinitionBuilder kafkaProducerMessageHandlerBuilder =
BeanDefinitionBuilder.genericBeanDefinition(KafkaProducerMessageHandler.class);
final String kafkaServerBeanName = element.getAttribute("kafka-producer-context-ref");
final String kafkaServerBeanName = element.getAttribute("kafka-producer-context-ref");
if (StringUtils.hasText(kafkaServerBeanName)) {
kafkaProducerMessageHandlerBuilder.addConstructorArgReference(kafkaServerBeanName);
}
if (StringUtils.hasText(kafkaServerBeanName)) {
kafkaProducerMessageHandlerBuilder.addConstructorArgReference(kafkaServerBeanName);
}
return kafkaProducerMessageHandlerBuilder.getBeanDefinition();
}
return kafkaProducerMessageHandlerBuilder.getBeanDefinition();
}
}

85
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/KafkaProducerContextParser.java
View File

@@ -32,58 +32,59 @@ import org.w3c.dom.Element;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaProducerContextParser extends AbstractSimpleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(final Element element) {
return KafkaProducerContext.class;
}
@Override
protected Class<?> getBeanClass(final Element element) {
return KafkaProducerContext.class;
}
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
final Element topics = DomUtils.getChildElementByTagName(element, "producer-configurations");
parseProducerConfigurations(topics, parserContext);
}
final Element topics = DomUtils.getChildElementByTagName(element, "producer-configurations");
parseProducerConfigurations(topics, parserContext);
}
private void parseProducerConfigurations(final Element topics, final ParserContext parserContext) {
for (final Element producerConfiguration : DomUtils.getChildElementsByTagName(topics, "producer-configuration")){
final BeanDefinitionBuilder producerConfigurationBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerConfiguration.class);
private void parseProducerConfigurations(final Element topics, final ParserContext parserContext) {
for (final Element producerConfiguration : DomUtils.getChildElementsByTagName(topics, "producer-configuration")){
final BeanDefinitionBuilder producerConfigurationBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerConfiguration.class);
final BeanDefinitionBuilder producerMetadataBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerMetadata.class);
producerMetadataBuilder.addConstructorArgValue(producerConfiguration.getAttribute("topic"));
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "value-encoder");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "key-encoder");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "key-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "value-class-type");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "partitioner");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "compression-codec");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "async");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "batch-num-messages");
final BeanDefinitionBuilder producerMetadataBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerMetadata.class);
producerMetadataBuilder.addConstructorArgValue(producerConfiguration.getAttribute("topic"));
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "value-encoder");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "key-encoder");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "key-class-type");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "value-class-type");
IntegrationNamespaceUtils.setReferenceIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "partitioner");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "compression-codec");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "async");
IntegrationNamespaceUtils.setValueIfAttributeDefined(producerMetadataBuilder, producerConfiguration, "batch-num-messages");
final BeanDefinition producerMetadataBeanDef = producerMetadataBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(producerMetadataBeanDef, "producerMetadata_" + producerConfiguration.getAttribute("topic")),
parserContext.getRegistry());
final BeanDefinition producerMetadataBeanDef = producerMetadataBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(producerMetadataBeanDef, "producerMetadata_" + producerConfiguration.getAttribute("topic")),
parserContext.getRegistry());
final BeanDefinitionBuilder producerFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerFactoryBean.class);
producerFactoryBuilder.addConstructorArgReference("producerMetadata_" + producerConfiguration.getAttribute("topic"));
final BeanDefinitionBuilder producerFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(ProducerFactoryBean.class);
producerFactoryBuilder.addConstructorArgReference("producerMetadata_" + producerConfiguration.getAttribute("topic"));
final String brokerList = producerConfiguration.getAttribute("broker-list");
if (StringUtils.hasText(brokerList)) {
producerFactoryBuilder.addConstructorArgValue(producerConfiguration.getAttribute("broker-list"));
}
final String brokerList = producerConfiguration.getAttribute("broker-list");
if (StringUtils.hasText(brokerList)) {
producerFactoryBuilder.addConstructorArgValue(producerConfiguration.getAttribute("broker-list"));
}
final BeanDefinition producerfactoryBeanDefinition = producerFactoryBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(producerfactoryBeanDefinition, "prodFactory_" + producerConfiguration.getAttribute("topic")), parserContext.getRegistry());
final BeanDefinition producerfactoryBeanDefinition = producerFactoryBuilder.getBeanDefinition();
registerBeanDefinition(new BeanDefinitionHolder(producerfactoryBeanDefinition, "prodFactory_" + producerConfiguration.getAttribute("topic")), parserContext.getRegistry());
producerConfigurationBuilder.addConstructorArgReference("producerMetadata_" + producerConfiguration.getAttribute("topic"));
producerConfigurationBuilder.addConstructorArgReference("prodFactory_" + producerConfiguration.getAttribute("topic"));
producerConfigurationBuilder.addConstructorArgReference("producerMetadata_" + producerConfiguration.getAttribute("topic"));
producerConfigurationBuilder.addConstructorArgReference("prodFactory_" + producerConfiguration.getAttribute("topic"));
final AbstractBeanDefinition producerConfigurationBeanDefinition = producerConfigurationBuilder.getBeanDefinition();
final String producerConfigurationBeanName = "producerConfiguration_" + producerConfiguration.getAttribute("topic");
registerBeanDefinition(new BeanDefinitionHolder(producerConfigurationBeanDefinition, producerConfigurationBeanName),
parserContext.getRegistry());
}
}
final AbstractBeanDefinition producerConfigurationBeanDefinition = producerConfigurationBuilder.getBeanDefinition();
final String producerConfigurationBeanName = "producerConfiguration_" + producerConfiguration.getAttribute("topic");
registerBeanDefinition(new BeanDefinitionHolder(producerConfigurationBeanDefinition, producerConfigurationBeanName),
parserContext.getRegistry());
}
}
}

29
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/config/xml/ZookeeperConnectParser.java
View File

@@ -25,22 +25,23 @@ import org.w3c.dom.Element;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ZookeeperConnectParser extends AbstractSimpleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(final Element element) {
return ZookeeperConnect.class;
}
@Override
protected Class<?> getBeanClass(final Element element) {
return ZookeeperConnect.class;
}
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
super.doParse(element, parserContext, builder);
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element,
BeanDefinitionParserDelegate.SCOPE_ATTRIBUTE);
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-connect");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-connection-timeout");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-session-timeout");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-sync-time");
}
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element,
BeanDefinitionParserDelegate.SCOPE_ATTRIBUTE);
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-connect");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-connection-timeout");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-session-timeout");
IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "zk-sync-time");
}
}

31
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/core/KafkaConsumerDefaults.java
View File

@@ -19,22 +19,23 @@ package org.springframework.integration.kafka.core;
* Kafka adapter specific message headers.
*
* @author Soby Chacko
* @since 0.5
*/
public class KafkaConsumerDefaults {
//High level consumer
public static final String GROUP_ID = "groupid";
public static final String SOCKET_TIMEOUT = "30000";
public static final String SOCKET_BUFFER_SIZE = "64*1024";
public static final String FETCH_SIZE = "300 * 1024";
public static final String BACKOFF_INCREMENT = "1000";
public static final String QUEUED_CHUNKS_MAX = "100";
public static final String AUTO_COMMIT_ENABLE = "true";
public static final String AUTO_COMMIT_INTERVAL = "10000";
public static final String AUTO_OFFSET_RESET = "smallest";
//Overriding the default value of -1, which will make the consumer to wait indefinitely
public static final String CONSUMER_TIMEOUT = "5000";
public static final String REBALANCE_RETRIES_MAX = "4";
public final class KafkaConsumerDefaults {
//High level consumer
public static final String GROUP_ID = "groupid";
public static final String SOCKET_TIMEOUT = "30000";
public static final String SOCKET_BUFFER_SIZE = "64*1024";
public static final String FETCH_SIZE = "300 * 1024";
public static final String BACKOFF_INCREMENT = "1000";
public static final String QUEUED_CHUNKS_MAX = "100";
public static final String AUTO_COMMIT_ENABLE = "true";
public static final String AUTO_COMMIT_INTERVAL = "10000";
public static final String AUTO_OFFSET_RESET = "smallest";
//Overriding the default value of -1, which will make the consumer to wait indefinitely
public static final String CONSUMER_TIMEOUT = "5000";
public static final String REBALANCE_RETRIES_MAX = "4";
private KafkaConsumerDefaults() {
}
}
}

15
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/core/ZookeeperConnectDefaults.java
View File

@@ -18,14 +18,15 @@ package org.springframework.integration.kafka.core;
/**
*
* @author Soby Chacko
* @since 0.5
*
*/
public class ZookeeperConnectDefaults {
public static final String ZK_CONNECT = "localhost:2181";
public static final String ZK_CONNECTION_TIMEOUT = "6000";
public static final String ZK_SESSION_TIMEOUT = "6000";
public static final String ZK_SYNC_TIME = "2000";
public final class ZookeeperConnectDefaults {
public static final String ZK_CONNECT = "localhost:2181";
public static final String ZK_CONNECTION_TIMEOUT = "6000";
public static final String ZK_SESSION_TIMEOUT = "6000";
public static final String ZK_SYNC_TIME = "2000";
private ZookeeperConnectDefaults() {
}
private ZookeeperConnectDefaults() {
}
}

25
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/inbound/KafkaHighLevelConsumerMessageSource.java
View File

@@ -25,23 +25,24 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*
*/
public class KafkaHighLevelConsumerMessageSource extends IntegrationObjectSupport implements MessageSource<Map<String, Map<Integer, List<Object>>>> {
private final KafkaConsumerContext kafkaConsumerContext;
private final KafkaConsumerContext kafkaConsumerContext;
public KafkaHighLevelConsumerMessageSource(final KafkaConsumerContext kafkaConsumerContext) {
this.kafkaConsumerContext = kafkaConsumerContext;
}
public KafkaHighLevelConsumerMessageSource(final KafkaConsumerContext kafkaConsumerContext) {
this.kafkaConsumerContext = kafkaConsumerContext;
}
@Override
public Message<Map<String, Map<Integer, List<Object>>>> receive() {
return kafkaConsumerContext.receive();
}
@Override
public Message<Map<String, Map<Integer, List<Object>>>> receive() {
return kafkaConsumerContext.receive();
}
@Override
public String getComponentType() {
return "kafka:inbound-channel-adapter";
}
@Override
public String getComponentType() {
return "kafka:inbound-channel-adapter";
}
}

15
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/outbound/KafkaProducerMessageHandler.java
View File

@@ -21,21 +21,22 @@ import org.springframework.integration.kafka.support.KafkaProducerContext;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaProducerMessageHandler extends AbstractMessageHandler {
private final KafkaProducerContext kafkaProducerContext;
private final KafkaProducerContext kafkaProducerContext;
public KafkaProducerMessageHandler(final KafkaProducerContext kafkaProducerContext) {
this.kafkaProducerContext = kafkaProducerContext;
}
public KafkaProducerMessageHandler(final KafkaProducerContext kafkaProducerContext) {
this.kafkaProducerContext = kafkaProducerContext;
}
public KafkaProducerContext getKafkaProducerContext() {
return kafkaProducerContext;
}
@Override
protected void handleMessageInternal(final Message<?> message) throws Exception {
kafkaProducerContext.send(message);
}
protected void handleMessageInternal(final Message<?> message) throws Exception {
kafkaProducerContext.send(message);
}
}

35
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/serializer/avro/AvroBackedKafkaDecoder.java
View File

@@ -26,29 +26,30 @@ import org.apache.commons.logging.LogFactory;
/**
* @author Soby Chacko
* @since 0.5
*/
public class AvroBackedKafkaDecoder<T> implements Decoder<T> {
private static final Log LOG = LogFactory.getLog(AvroBackedKafkaDecoder.class);
private static final Log LOG = LogFactory.getLog(AvroBackedKafkaDecoder.class);
private final Class clazz;
private final Class clazz;
public AvroBackedKafkaDecoder(final Class clazz) {
this.clazz = clazz;
}
public AvroBackedKafkaDecoder(final Class clazz) {
this.clazz = clazz;
}
@Override
@SuppressWarnings("unchecked")
public T fromBytes(final byte[] bytes) {
final Schema schema = ReflectData.get().getSchema(clazz);
final AvroSerializer avroSerializer = new AvroSerializer();
@Override
@SuppressWarnings("unchecked")
public T fromBytes(final byte[] bytes) {
final Schema schema = ReflectData.get().getSchema(clazz);
final AvroSerializer avroSerializer = new AvroSerializer();
try {
return (T) avroSerializer.deserialize(bytes, schema);
} catch (IOException e) {
LOG.error("Failed to decode byte array for schema: " + schema.getFullName(), e);
}
try {
return (T) avroSerializer.deserialize(bytes, schema);
} catch (IOException e) {
LOG.error("Failed to decode byte array for schema: " + schema.getFullName(), e);
}
return null;
}
return null;
}
}

35
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/serializer/avro/AvroBackedKafkaEncoder.java
View File

@@ -25,28 +25,29 @@ import org.apache.commons.logging.LogFactory;
/**
* @author Soby Chacko
* @since 0.5
*/
public class AvroBackedKafkaEncoder<T> implements Encoder<T> {
private static final Log LOG = LogFactory.getLog(AvroBackedKafkaEncoder.class);
private static final Log LOG = LogFactory.getLog(AvroBackedKafkaEncoder.class);
private final Class clazz;
private final Class clazz;
public AvroBackedKafkaEncoder(final Class clazz) {
this.clazz = clazz;
}
public AvroBackedKafkaEncoder(final Class clazz) {
this.clazz = clazz;
}
@Override
@SuppressWarnings("unchecked")
public byte[] toBytes(final T source) {
final Schema schema = ReflectData.get().getSchema(clazz);
final AvroSerializer avroSerializer = new AvroSerializer();
@Override
@SuppressWarnings("unchecked")
public byte[] toBytes(final T source) {
final Schema schema = ReflectData.get().getSchema(clazz);
final AvroSerializer avroSerializer = new AvroSerializer();
try {
return avroSerializer.serialize(source, schema);
} catch (IOException e) {
LOG.error("Failed to encode source for schema: " + schema.getFullName());
}
try {
return avroSerializer.serialize(source, schema);
} catch (IOException e) {
LOG.error("Failed to encode source for schema: " + schema.getFullName());
}
return null;
}
return null;
}
}

27
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/serializer/avro/AvroSerializer.java
View File

@@ -30,23 +30,24 @@ import java.io.IOException;
/**
* @author Soby Chacko
* @since 0.5
*/
public class AvroSerializer<T> {
public T deserialize(final byte[] bytes, final Schema schema) throws IOException {
final Decoder decoder = DecoderFactory.get().binaryDecoder(bytes, null);
final DatumReader<T> reader = new ReflectDatumReader<T>(schema);
public T deserialize(final byte[] bytes, final Schema schema) throws IOException {
final Decoder decoder = DecoderFactory.get().binaryDecoder(bytes, null);
final DatumReader<T> reader = new ReflectDatumReader<T>(schema);
return reader.read(null, decoder);
}
return reader.read(null, decoder);
}
public byte[] serialize(final T input, final Schema schema) throws IOException {
final DatumWriter<T> writer = new ReflectDatumWriter<T>(schema);
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
public byte[] serialize(final T input, final Schema schema) throws IOException {
final DatumWriter<T> writer = new ReflectDatumWriter<T>(schema);
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
final Encoder encoder = EncoderFactory.get().binaryEncoder(stream, null);
writer.write(input, encoder);
encoder.flush();
final Encoder encoder = EncoderFactory.get().binaryEncoder(stream, null);
writer.write(input, encoder);
encoder.flush();
return stream.toByteArray();
}
return stream.toByteArray();
}
}

27
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/serializer/avro/AvroSpecificDatumSerializer.java
View File

@@ -30,23 +30,24 @@ import java.io.IOException;
/**
* @author Soby Chacko
* @since 0.5
*/
public class AvroSpecificDatumSerializer<T> {
public T deserialize(final byte[] bytes, final Schema schema) throws IOException {
final Decoder decoder = DecoderFactory.get().binaryDecoder(bytes, null);
final DatumReader<T> reader = new SpecificDatumReader<T>(schema);
public T deserialize(final byte[] bytes, final Schema schema) throws IOException {
final Decoder decoder = DecoderFactory.get().binaryDecoder(bytes, null);
final DatumReader<T> reader = new SpecificDatumReader<T>(schema);
return reader.read(null, decoder);
}
return reader.read(null, decoder);
}
public byte[] serialize(final T input, final Schema schema) throws IOException {
final DatumWriter<T> writer = new SpecificDatumWriter<T>(schema);
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
public byte[] serialize(final T input, final Schema schema) throws IOException {
final DatumWriter<T> writer = new SpecificDatumWriter<T>(schema);
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
final Encoder encoder = EncoderFactory.get().binaryEncoder(stream, null);
writer.write(input, encoder);
encoder.flush();
final Encoder encoder = EncoderFactory.get().binaryEncoder(stream, null);
writer.write(input, encoder);
encoder.flush();
return stream.toByteArray();
}
return stream.toByteArray();
}
}

23
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/serializer/common/StringEncoder.java
View File

@@ -22,20 +22,21 @@ import java.util.Properties;
/**
* @author Soby Chacko
* @since 0.5
*/
public class StringEncoder implements Encoder {
private String encoding = "UTF8";
private String encoding = "UTF8";
public void setEncoding(final String encoding){
this.encoding = encoding;
}
public void setEncoding(final String encoding){
this.encoding = encoding;
}
@Override
public byte[] toBytes(final Object o) {
final Properties props = new Properties();
props.put("serializer.encoding", encoding);
@Override
public byte[] toBytes(final Object o) {
final Properties props = new Properties();
props.put("serializer.encoding", encoding);
final VerifiableProperties verifiableProperties = new VerifiableProperties(props);
return new kafka.serializer.StringEncoder(verifiableProperties).toBytes((String)o);
}
final VerifiableProperties verifiableProperties = new VerifiableProperties(props);
return new kafka.serializer.StringEncoder(verifiableProperties).toBytes((String)o);
}
}

53
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ConsumerConfigFactoryBean.java
View File

@@ -22,38 +22,39 @@ import java.util.Properties;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ConsumerConfigFactoryBean implements FactoryBean<ConsumerConfig> {
private final ConsumerMetadata consumerMetadata;
private final ZookeeperConnect zookeeperConnect;
private final ConsumerMetadata consumerMetadata;
private final ZookeeperConnect zookeeperConnect;
public ConsumerConfigFactoryBean(final ConsumerMetadata consumerMetadata,
final ZookeeperConnect zookeeperConnect){
this.consumerMetadata = consumerMetadata;
this.zookeeperConnect = zookeeperConnect;
}
public ConsumerConfigFactoryBean(final ConsumerMetadata consumerMetadata,
final ZookeeperConnect zookeeperConnect){
this.consumerMetadata = consumerMetadata;
this.zookeeperConnect = zookeeperConnect;
}
@Override
public ConsumerConfig getObject() throws Exception {
final Properties properties = new Properties();
properties.put("zookeeper.connect", zookeeperConnect.getZkConnect());
properties.put("zookeeper.session.timeout.ms", zookeeperConnect.getZkSessionTimeout());
properties.put("zookeeper.sync.time.ms", zookeeperConnect.getZkSyncTime());
properties.put("auto.commit.interval.ms", consumerMetadata.getAutoCommitInterval());
properties.put("consumer.timeout.ms", consumerMetadata.getConsumerTimeout());
properties.put("group.id", consumerMetadata.getGroupId());
@Override
public ConsumerConfig getObject() throws Exception {
final Properties properties = new Properties();
properties.put("zookeeper.connect", zookeeperConnect.getZkConnect());
properties.put("zookeeper.session.timeout.ms", zookeeperConnect.getZkSessionTimeout());
properties.put("zookeeper.sync.time.ms", zookeeperConnect.getZkSyncTime());
properties.put("auto.commit.interval.ms", consumerMetadata.getAutoCommitInterval());
properties.put("consumer.timeout.ms", consumerMetadata.getConsumerTimeout());
properties.put("group.id", consumerMetadata.getGroupId());
return new ConsumerConfig(properties);
}
return new ConsumerConfig(properties);
}
@Override
public Class<?> getObjectType() {
return ConsumerConfig.class;
}
@Override
public Class<?> getObjectType() {
return ConsumerConfig.class;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public boolean isSingleton() {
return true;
}
}

281
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ConsumerConfiguration.java
View File

@@ -35,175 +35,176 @@ import java.util.concurrent.Future;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ConsumerConfiguration {
private static final Log LOGGER = LogFactory.getLog(ConsumerConfiguration.class);
private static final Log LOGGER = LogFactory.getLog(ConsumerConfiguration.class);
private final ConsumerMetadata consumerMetadata;
private final ConsumerConnectionProvider consumerConnectionProvider;
private final MessageLeftOverTracker messageLeftOverTracker;
private ConsumerConnector consumerConnector;
private volatile int count = 0;
private int maxMessages = 1;
private final ConsumerMetadata consumerMetadata;
private final ConsumerConnectionProvider consumerConnectionProvider;
private final MessageLeftOverTracker messageLeftOverTracker;
private ConsumerConnector consumerConnector;
private volatile int count = 0;
private int maxMessages = 1;
private ExecutorService executorService = Executors.newCachedThreadPool();
private ExecutorService executorService = Executors.newCachedThreadPool();
public ConsumerConfiguration(final ConsumerMetadata consumerMetadata,
final ConsumerConnectionProvider consumerConnectionProvider,
final MessageLeftOverTracker messageLeftOverTracker) {
this.consumerMetadata = consumerMetadata;
this.consumerConnectionProvider = consumerConnectionProvider;
this.messageLeftOverTracker = messageLeftOverTracker;
}
public ConsumerConfiguration(final ConsumerMetadata consumerMetadata,
final ConsumerConnectionProvider consumerConnectionProvider,
final MessageLeftOverTracker messageLeftOverTracker) {
this.consumerMetadata = consumerMetadata;
this.consumerConnectionProvider = consumerConnectionProvider;
this.messageLeftOverTracker = messageLeftOverTracker;
}
public ConsumerMetadata getConsumerMetadata() {
return consumerMetadata;
}
public ConsumerMetadata getConsumerMetadata() {
return consumerMetadata;
}
public Map<String, Map<Integer, List<Object>>> receive() {
count = messageLeftOverTracker.getCurrentCount();
public Map<String, Map<Integer, List<Object>>> receive() {
count = messageLeftOverTracker.getCurrentCount();
final List<Callable<List<MessageAndMetadata>>> tasks = new LinkedList<Callable<List<MessageAndMetadata>>>();
final Object lock = new Object();
final List<Callable<List<MessageAndMetadata>>> tasks = new LinkedList<Callable<List<MessageAndMetadata>>>();
final Object lock = new Object();
final Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = getConsumerMapWithMessageStreams();
for (final List<KafkaStream<byte[], byte[]>> streams : consumerMap.values()) {
for (final KafkaStream<byte[], byte[]> stream : streams) {
tasks.add(new Callable<List<MessageAndMetadata>>() {
@Override
public List<MessageAndMetadata> call() throws Exception {
final List<MessageAndMetadata> rawMessages = new ArrayList<MessageAndMetadata>();
try {
while (count < maxMessages) {
final MessageAndMetadata messageAndMetadata = stream.iterator().next();
synchronized (lock) {
if (count < maxMessages) {
rawMessages.add(messageAndMetadata);
count++;
} else {
messageLeftOverTracker.addMessageAndMetadata(messageAndMetadata);
}
}
}
} catch (ConsumerTimeoutException cte) {
LOGGER.info("Consumer timed out");
}
return rawMessages;
}
});
}
}
final Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = getConsumerMapWithMessageStreams();
for (final List<KafkaStream<byte[], byte[]>> streams : consumerMap.values()) {
for (final KafkaStream<byte[], byte[]> stream : streams) {
tasks.add(new Callable<List<MessageAndMetadata>>() {
@Override
public List<MessageAndMetadata> call() throws Exception {
final List<MessageAndMetadata> rawMessages = new ArrayList<MessageAndMetadata>();
try {
while (count < maxMessages) {
final MessageAndMetadata messageAndMetadata = stream.iterator().next();
synchronized (lock) {
if (count < maxMessages) {
rawMessages.add(messageAndMetadata);
count++;
} else {
messageLeftOverTracker.addMessageAndMetadata(messageAndMetadata);
}
}
}
} catch (ConsumerTimeoutException cte) {
LOGGER.info("Consumer timed out");
}
return rawMessages;
}
});
}
}
return executeTasks(tasks);
}
return executeTasks(tasks);
}
private Map<String, Map<Integer, List<Object>>> executeTasks(final List<Callable<List<MessageAndMetadata>>> tasks) {
private Map<String, Map<Integer, List<Object>>> executeTasks(final List<Callable<List<MessageAndMetadata>>> tasks) {
final Map<String, Map<Integer, List<Object>>> messages = new ConcurrentHashMap<String, Map<Integer, List<Object>>>();
messages.putAll(getLeftOverMessageMap());
final Map<String, Map<Integer, List<Object>>> messages = new ConcurrentHashMap<String, Map<Integer, List<Object>>>();
messages.putAll(getLeftOverMessageMap());
try {
for (final Future<List<MessageAndMetadata>> result : executorService.invokeAll(tasks)) {
if (!result.get().isEmpty()) {
final String topic = result.get().get(0).topic();
if (!messages.containsKey(topic)) {
messages.put(topic, getPayload(result.get()));
} else {
try {
for (final Future<List<MessageAndMetadata>> result : executorService.invokeAll(tasks)) {
if (!result.get().isEmpty()) {
final String topic = result.get().get(0).topic();
if (!messages.containsKey(topic)) {
messages.put(topic, getPayload(result.get()));
} else {
final Map<Integer, List<Object>> existingPayloadMap = messages.get(topic);
getPayload(result.get(), existingPayloadMap);
}
}
}
} catch (Exception e) {
throw new MessagingException("Consuming from Kafka failed", e);
}
final Map<Integer, List<Object>> existingPayloadMap = messages.get(topic);
getPayload(result.get(), existingPayloadMap);
}
}
}
} catch (Exception e) {
throw new MessagingException("Consuming from Kafka failed", e);
}
if (messages.isEmpty()) {
return null;
}
if (messages.isEmpty()) {
return null;
}
return messages;
}
return messages;
}
private Map<String, Map<Integer, List<Object>>> getLeftOverMessageMap() {
private Map<String, Map<Integer, List<Object>>> getLeftOverMessageMap() {
final Map<String, Map<Integer, List<Object>>> messages = new ConcurrentHashMap<String, Map<Integer, List<Object>>>();
final Map<String, Map<Integer, List<Object>>> messages = new ConcurrentHashMap<String, Map<Integer, List<Object>>>();
for (final MessageAndMetadata mamd : messageLeftOverTracker.getMessageLeftOverFromPreviousPoll()) {
final String topic = mamd.topic();
for (final MessageAndMetadata mamd : messageLeftOverTracker.getMessageLeftOverFromPreviousPoll()) {
final String topic = mamd.topic();
if (!messages.containsKey(topic)) {
final List<MessageAndMetadata> l = new ArrayList<MessageAndMetadata>();
l.add(mamd);
messages.put(topic, getPayload(l));
} else {
final Map<Integer, List<Object>> existingPayloadMap = messages.get(topic);
final List<MessageAndMetadata> l = new ArrayList<MessageAndMetadata>();
l.add(mamd);
getPayload(l, existingPayloadMap);
}
}
messageLeftOverTracker.clearMessagesLeftOver();
return messages;
}
if (!messages.containsKey(topic)) {
final List<MessageAndMetadata> l = new ArrayList<MessageAndMetadata>();
l.add(mamd);
messages.put(topic, getPayload(l));
} else {
final Map<Integer, List<Object>> existingPayloadMap = messages.get(topic);
final List<MessageAndMetadata> l = new ArrayList<MessageAndMetadata>();
l.add(mamd);
getPayload(l, existingPayloadMap);
}
}
messageLeftOverTracker.clearMessagesLeftOver();
return messages;
}
private Map<Integer, List<Object>> getPayload(final List<MessageAndMetadata> messageAndMetadatas) {
final Map<Integer, List<Object>> payloadMap = new ConcurrentHashMap<Integer, List<Object>>();
private Map<Integer, List<Object>> getPayload(final List<MessageAndMetadata> messageAndMetadatas) {
final Map<Integer, List<Object>> payloadMap = new ConcurrentHashMap<Integer, List<Object>>();
for (final MessageAndMetadata messageAndMetadata : messageAndMetadatas) {
if (!payloadMap.containsKey(messageAndMetadata.partition())) {
final List<Object> payload = new ArrayList<Object>();
payload.add(messageAndMetadata.message());
payloadMap.put(messageAndMetadata.partition(), payload);
} else {
final List<Object> payload = payloadMap.get(messageAndMetadata.partition());
payload.add(messageAndMetadata.message());
}
for (final MessageAndMetadata messageAndMetadata : messageAndMetadatas) {
if (!payloadMap.containsKey(messageAndMetadata.partition())) {
final List<Object> payload = new ArrayList<Object>();
payload.add(messageAndMetadata.message());
payloadMap.put(messageAndMetadata.partition(), payload);
} else {
final List<Object> payload = payloadMap.get(messageAndMetadata.partition());
payload.add(messageAndMetadata.message());
}
}
}
return payloadMap;
}
return payloadMap;
}
private void getPayload(final List<MessageAndMetadata> messageAndMetadatas, final Map<Integer, List<Object>> existingPayloadMap) {
for (final MessageAndMetadata messageAndMetadata : messageAndMetadatas) {
if (!existingPayloadMap.containsKey(messageAndMetadata.partition())) {
final List<Object> payload = new ArrayList<Object>();
payload.add(messageAndMetadata.message());
existingPayloadMap.put(messageAndMetadata.partition(), payload);
} else {
final List<Object> payload = existingPayloadMap.get(messageAndMetadata.partition());
payload.add(messageAndMetadata.message());
}
}
}
private void getPayload(final List<MessageAndMetadata> messageAndMetadatas, final Map<Integer, List<Object>> existingPayloadMap) {
for (final MessageAndMetadata messageAndMetadata : messageAndMetadatas) {
if (!existingPayloadMap.containsKey(messageAndMetadata.partition())) {
final List<Object> payload = new ArrayList<Object>();
payload.add(messageAndMetadata.message());
existingPayloadMap.put(messageAndMetadata.partition(), payload);
} else {
final List<Object> payload = existingPayloadMap.get(messageAndMetadata.partition());
payload.add(messageAndMetadata.message());
}
}
}
@SuppressWarnings("unchecked")
public Map<String, List<KafkaStream<byte[], byte[]>>> getConsumerMapWithMessageStreams() {
if (consumerMetadata.getValueDecoder() != null) {
return getConsumerConnector().createMessageStreams(
consumerMetadata.getTopicStreamMap(),
consumerMetadata.getValueDecoder(),
consumerMetadata.getValueDecoder());
}
@SuppressWarnings("unchecked")
public Map<String, List<KafkaStream<byte[], byte[]>>> getConsumerMapWithMessageStreams() {
if (consumerMetadata.getValueDecoder() != null) {
return getConsumerConnector().createMessageStreams(
consumerMetadata.getTopicStreamMap(),
consumerMetadata.getValueDecoder(),
consumerMetadata.getValueDecoder());
}
return getConsumerConnector().createMessageStreams(consumerMetadata.getTopicStreamMap());
}
return getConsumerConnector().createMessageStreams(consumerMetadata.getTopicStreamMap());
}
public int getMaxMessages() {
return maxMessages;
}
public int getMaxMessages() {
return maxMessages;
}
public void setMaxMessages(final int maxMessages) {
this.maxMessages = maxMessages;
}
public void setMaxMessages(final int maxMessages) {
this.maxMessages = maxMessages;
}
public ConsumerConnector getConsumerConnector() {
if (consumerConnector == null) {
consumerConnector = consumerConnectionProvider.getConsumerConnector();
}
public ConsumerConnector getConsumerConnector() {
if (consumerConnector == null) {
consumerConnector = consumerConnectionProvider.getConsumerConnector();
}
return consumerConnector;
}
return consumerConnector;
}
}

15
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ConsumerConnectionProvider.java
View File

@@ -20,16 +20,17 @@ import kafka.javaapi.consumer.ConsumerConnector;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ConsumerConnectionProvider {
private final ConsumerConfig consumerConfig;
private final ConsumerConfig consumerConfig;
public ConsumerConnectionProvider(final ConsumerConfig consumerConfig) {
this.consumerConfig = consumerConfig;
}
public ConsumerConnectionProvider(final ConsumerConfig consumerConfig) {
this.consumerConfig = consumerConfig;
}
public ConsumerConnector getConsumerConnector() {
return kafka.consumer.Consumer.createJavaConsumerConnector(consumerConfig);
}
public ConsumerConnector getConsumerConnector() {
return kafka.consumer.Consumer.createJavaConsumerConnector(consumerConfig);
}
}

227
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ConsumerMetadata.java
View File

@@ -22,153 +22,154 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ConsumerMetadata<K,V> {
//High level consumer defaults
private String groupId = KafkaConsumerDefaults.GROUP_ID;
private String socketTimeout = KafkaConsumerDefaults.SOCKET_TIMEOUT;
private String socketBufferSize = KafkaConsumerDefaults.SOCKET_BUFFER_SIZE;
private String fetchSize = KafkaConsumerDefaults.FETCH_SIZE;
private String backoffIncrement = KafkaConsumerDefaults.BACKOFF_INCREMENT;
private String queuedChunksMax = KafkaConsumerDefaults.QUEUED_CHUNKS_MAX;
private String autoCommitEnable = KafkaConsumerDefaults.AUTO_COMMIT_ENABLE;
private String autoCommitInterval = KafkaConsumerDefaults.AUTO_COMMIT_INTERVAL;
private String autoOffsetReset = KafkaConsumerDefaults.AUTO_OFFSET_RESET;
private String rebalanceRetriesMax = KafkaConsumerDefaults.REBALANCE_RETRIES_MAX;
private String consumerTimeout = KafkaConsumerDefaults.CONSUMER_TIMEOUT;
//High level consumer defaults
private String groupId = KafkaConsumerDefaults.GROUP_ID;
private String socketTimeout = KafkaConsumerDefaults.SOCKET_TIMEOUT;
private String socketBufferSize = KafkaConsumerDefaults.SOCKET_BUFFER_SIZE;
private String fetchSize = KafkaConsumerDefaults.FETCH_SIZE;
private String backoffIncrement = KafkaConsumerDefaults.BACKOFF_INCREMENT;
private String queuedChunksMax = KafkaConsumerDefaults.QUEUED_CHUNKS_MAX;
private String autoCommitEnable = KafkaConsumerDefaults.AUTO_COMMIT_ENABLE;
private String autoCommitInterval = KafkaConsumerDefaults.AUTO_COMMIT_INTERVAL;
private String autoOffsetReset = KafkaConsumerDefaults.AUTO_OFFSET_RESET;
private String rebalanceRetriesMax = KafkaConsumerDefaults.REBALANCE_RETRIES_MAX;
private String consumerTimeout = KafkaConsumerDefaults.CONSUMER_TIMEOUT;
private String topic;
private int streams;
private Decoder<V> valueDecoder;
private Decoder<K> keyDecoder;
private Map<String, Integer> topicStreamMap;
private String topic;
private int streams;
private Decoder<V> valueDecoder;
private Decoder<K> keyDecoder;
private Map<String, Integer> topicStreamMap;
public String getGroupId() {
return groupId;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(final String groupId) {
this.groupId = groupId;
}
public void setGroupId(final String groupId) {
this.groupId = groupId;
}
public String getSocketTimeout() {
return socketTimeout;
}
public String getSocketTimeout() {
return socketTimeout;
}
public void setSocketTimeout(final String socketTimeout) {
this.socketTimeout = socketTimeout;
}
public void setSocketTimeout(final String socketTimeout) {
this.socketTimeout = socketTimeout;
}
public String getSocketBufferSize() {
return socketBufferSize;
}
public String getSocketBufferSize() {
return socketBufferSize;
}
public void setSocketBufferSize(final String socketBufferSize) {
this.socketBufferSize = socketBufferSize;
}
public void setSocketBufferSize(final String socketBufferSize) {
this.socketBufferSize = socketBufferSize;
}
public String getFetchSize() {
return fetchSize;
}
public String getFetchSize() {
return fetchSize;
}
public void setFetchSize(final String fetchSize) {
this.fetchSize = fetchSize;
}
public void setFetchSize(final String fetchSize) {
this.fetchSize = fetchSize;
}
public String getBackoffIncrement() {
return backoffIncrement;
}
public String getBackoffIncrement() {
return backoffIncrement;
}
public void setBackoffIncrement(final String backoffIncrement) {
this.backoffIncrement = backoffIncrement;
}
public void setBackoffIncrement(final String backoffIncrement) {
this.backoffIncrement = backoffIncrement;
}
public String getQueuedChunksMax() {
return queuedChunksMax;
}
public String getQueuedChunksMax() {
return queuedChunksMax;
}
public void setQueuedChunksMax(final String queuedChunksMax) {
this.queuedChunksMax = queuedChunksMax;
}
public void setQueuedChunksMax(final String queuedChunksMax) {
this.queuedChunksMax = queuedChunksMax;
}
public String getAutoCommitEnable() {
return autoCommitEnable;
}
public String getAutoCommitEnable() {
return autoCommitEnable;
}
public void setAutoCommitEnable(final String autoCommitEnable) {
this.autoCommitEnable = autoCommitEnable;
}
public void setAutoCommitEnable(final String autoCommitEnable) {
this.autoCommitEnable = autoCommitEnable;
}
public String getAutoCommitInterval() {
return autoCommitInterval;
}
public String getAutoCommitInterval() {
return autoCommitInterval;
}
public void setAutoCommitInterval(final String autoCommitInterval) {
this.autoCommitInterval = autoCommitInterval;
}
public void setAutoCommitInterval(final String autoCommitInterval) {
this.autoCommitInterval = autoCommitInterval;
}
public String getAutoOffsetReset() {
return autoOffsetReset;
}
public String getAutoOffsetReset() {
return autoOffsetReset;
}
public void setAutoOffsetReset(final String autoOffsetReset) {
this.autoOffsetReset = autoOffsetReset;
}
public void setAutoOffsetReset(final String autoOffsetReset) {
this.autoOffsetReset = autoOffsetReset;
}
public String getRebalanceRetriesMax() {
return rebalanceRetriesMax;
}
public String getRebalanceRetriesMax() {
return rebalanceRetriesMax;
}
public void setRebalanceRetriesMax(final String rebalanceRetriesMax) {
this.rebalanceRetriesMax = rebalanceRetriesMax;
}
public void setRebalanceRetriesMax(final String rebalanceRetriesMax) {
this.rebalanceRetriesMax = rebalanceRetriesMax;
}
public String getConsumerTimeout() {
return consumerTimeout;
}
public String getConsumerTimeout() {
return consumerTimeout;
}
public void setConsumerTimeout(final String consumerTimeout) {
this.consumerTimeout = consumerTimeout;
}
public void setConsumerTimeout(final String consumerTimeout) {
this.consumerTimeout = consumerTimeout;
}
public String getTopic() {
return topic;
}
public String getTopic() {
return topic;
}
public void setTopic(final String topic) {
this.topic = topic;
}
public void setTopic(final String topic) {
this.topic = topic;
}
public int getStreams() {
return streams;
}
public int getStreams() {
return streams;
}
public void setStreams(final int streams) {
this.streams = streams;
}
public void setStreams(final int streams) {
this.streams = streams;
}
public Decoder<V> getValueDecoder() {
return valueDecoder;
}
public Decoder<V> getValueDecoder() {
return valueDecoder;
}
public void setValueDecoder(final Decoder<V> valueDecoder) {
this.valueDecoder = valueDecoder;
}
public void setValueDecoder(final Decoder<V> valueDecoder) {
this.valueDecoder = valueDecoder;
}
public Decoder<K> getKeyDecoder() {
return keyDecoder;
}
public Decoder<K> getKeyDecoder() {
return keyDecoder;
}
public void setKeyDecoder(final Decoder<K> keyDecoder) {
this.keyDecoder = keyDecoder;
}
public void setKeyDecoder(final Decoder<K> keyDecoder) {
this.keyDecoder = keyDecoder;
}
public Map<String, Integer> getTopicStreamMap() {
return topicStreamMap;
}
public Map<String, Integer> getTopicStreamMap() {
return topicStreamMap;
}
public void setTopicStreamMap(final Map<String, Integer> topicStreamMap) {
this.topicStreamMap = topicStreamMap;
}
public void setTopicStreamMap(final Map<String, Integer> topicStreamMap) {
this.topicStreamMap = topicStreamMap;
}
}

19
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/DefaultPartitioner.java
View File

@@ -20,17 +20,18 @@ import kafka.utils.Utils;
/**
* @author Soby Chacko
* @since 0.5
*
* This class is for internal use only and therefore is at default access level
*/
class DefaultPartitioner<T> implements Partitioner<T> {
/**
* Uses the key to calculate a partition bucket id for routing
* the data to the appropriate broker partition
* @return an integer between 0 and numPartitions-1
*/
@Override
public int partition(final T key, final int numPartitions) {
return Utils.abs(key.hashCode()) % numPartitions;
}
/**
* Uses the key to calculate a partition bucket id for routing
* the data to the appropriate broker partition
* @return an integer between 0 and numPartitions-1
*/
@Override
public int partition(final T key, final int numPartitions) {
return Utils.abs(key.hashCode()) % numPartitions;
}
}

65
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/KafkaConsumerContext.java
View File

@@ -30,47 +30,48 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaConsumerContext implements BeanFactoryAware {
private Map<String, ConsumerConfiguration> consumerConfigurations;
private String consumerTimeout = KafkaConsumerDefaults.CONSUMER_TIMEOUT;
private ZookeeperConnect zookeeperConnect;
private Map<String, ConsumerConfiguration> consumerConfigurations;
private String consumerTimeout = KafkaConsumerDefaults.CONSUMER_TIMEOUT;
private ZookeeperConnect zookeeperConnect;
public Collection<ConsumerConfiguration> getConsumerConfigurations() {
return consumerConfigurations.values();
}
public Collection<ConsumerConfiguration> getConsumerConfigurations() {
return consumerConfigurations.values();
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
consumerConfigurations = ((ListableBeanFactory) beanFactory).getBeansOfType(ConsumerConfiguration.class);
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
consumerConfigurations = ((ListableBeanFactory) beanFactory).getBeansOfType(ConsumerConfiguration.class);
}
public Message<Map<String, Map<Integer, List<Object>>>> receive() {
final Map<String, Map<Integer, List<Object>>> consumedData = new HashMap<String, Map<Integer, List<Object>>>();
public Message<Map<String, Map<Integer, List<Object>>>> receive() {
final Map<String, Map<Integer, List<Object>>> consumedData = new HashMap<String, Map<Integer, List<Object>>>();
for (final ConsumerConfiguration consumerConfiguration : getConsumerConfigurations()) {
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
for (final ConsumerConfiguration consumerConfiguration : getConsumerConfigurations()) {
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
if (messages != null){
consumedData.putAll(messages);
}
}
return MessageBuilder.withPayload(consumedData).build();
}
if (messages != null){
consumedData.putAll(messages);
}
}
return MessageBuilder.withPayload(consumedData).build();
}
public String getConsumerTimeout() {
return consumerTimeout;
}
public String getConsumerTimeout() {
return consumerTimeout;
}
public void setConsumerTimeout(final String consumerTimeout) {
this.consumerTimeout = consumerTimeout;
}
public void setConsumerTimeout(final String consumerTimeout) {
this.consumerTimeout = consumerTimeout;
}
public ZookeeperConnect getZookeeperConnect() {
return zookeeperConnect;
}
public ZookeeperConnect getZookeeperConnect() {
return zookeeperConnect;
}
public void setZookeeperConnect(final ZookeeperConnect zookeeperConnect) {
this.zookeeperConnect = zookeeperConnect;
}
public void setZookeeperConnect(final ZookeeperConnect zookeeperConnect) {
this.zookeeperConnect = zookeeperConnect;
}
}

51
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/KafkaProducerContext.java
View File

@@ -26,38 +26,39 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaProducerContext implements BeanFactoryAware {
private Map<String, ProducerConfiguration> topicsConfiguration;
private Map<String, ProducerConfiguration> topicsConfiguration;
@SuppressWarnings("unchecked")
public void send(final Message<?> message) throws Exception {
final ProducerConfiguration producerConfiguration =
getTopicConfiguration(message.getHeaders().get("topic", String.class));
@SuppressWarnings("unchecked")
public void send(final Message<?> message) throws Exception {
final ProducerConfiguration producerConfiguration =
getTopicConfiguration(message.getHeaders().get("topic", String.class));
if (producerConfiguration != null) {
producerConfiguration.send(message);
}
}
if (producerConfiguration != null) {
producerConfiguration.send(message);
}
}
private ProducerConfiguration getTopicConfiguration(final String topic){
final Collection<ProducerConfiguration> topics = topicsConfiguration.values();
private ProducerConfiguration getTopicConfiguration(final String topic){
final Collection<ProducerConfiguration> topics = topicsConfiguration.values();
for (final ProducerConfiguration producerConfiguration : topics){
if (producerConfiguration.getProducerMetadata().getTopic().equals(topic)){
return producerConfiguration;
}
}
for (final ProducerConfiguration producerConfiguration : topics){
if (producerConfiguration.getProducerMetadata().getTopic().equals(topic)){
return producerConfiguration;
}
}
return null;
}
return null;
}
public Map<String, ProducerConfiguration> getTopicsConfiguration() {
return topicsConfiguration;
}
public Map<String, ProducerConfiguration> getTopicsConfiguration() {
return topicsConfiguration;
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
topicsConfiguration = ((ListableBeanFactory)beanFactory).getBeansOfType(ProducerConfiguration.class);
}
@Override
public void setBeanFactory(final BeanFactory beanFactory) throws BeansException {
topicsConfiguration = ((ListableBeanFactory)beanFactory).getBeansOfType(ProducerConfiguration.class);
}
}

27
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/MessageLeftOverTracker.java
View File

@@ -22,23 +22,24 @@ import java.util.List;
/**
* @author Soby Chacko
* @since 0.5
*/
public class MessageLeftOverTracker {
private final List<MessageAndMetadata> messageLeftOverFromPreviousPoll = new ArrayList<MessageAndMetadata>();
private final List<MessageAndMetadata> messageLeftOverFromPreviousPoll = new ArrayList<MessageAndMetadata>();
public void addMessageAndMetadata(final MessageAndMetadata messageAndMetadata){
messageLeftOverFromPreviousPoll.add(messageAndMetadata);
}
public void addMessageAndMetadata(final MessageAndMetadata messageAndMetadata){
messageLeftOverFromPreviousPoll.add(messageAndMetadata);
}
public List<MessageAndMetadata> getMessageLeftOverFromPreviousPoll(){
return messageLeftOverFromPreviousPoll;
}
public List<MessageAndMetadata> getMessageLeftOverFromPreviousPoll(){
return messageLeftOverFromPreviousPoll;
}
public void clearMessagesLeftOver(){
messageLeftOverFromPreviousPoll.clear();
}
public void clearMessagesLeftOver(){
messageLeftOverFromPreviousPoll.clear();
}
public int getCurrentCount() {
return messageLeftOverFromPreviousPoll.size();
}
public int getCurrentCount() {
return messageLeftOverFromPreviousPoll.size();
}
}

109
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ProducerConfiguration.java
View File

@@ -28,75 +28,76 @@ import java.io.ObjectOutputStream;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ProducerConfiguration<K,V> {
private final Producer<K,V> producer;
private final ProducerMetadata<K,V> producerMetadata;
private final Producer<K,V> producer;
private final ProducerMetadata<K,V> producerMetadata;
public ProducerConfiguration(final ProducerMetadata<K, V> producerMetadata, final Producer<K, V> producer){
this.producerMetadata = producerMetadata;
this.producer = producer;
}
public ProducerConfiguration(final ProducerMetadata<K, V> producerMetadata, final Producer<K, V> producer){
this.producerMetadata = producerMetadata;
this.producer = producer;
}
public ProducerMetadata<K, V> getProducerMetadata() {
return producerMetadata;
}
public ProducerMetadata<K, V> getProducerMetadata() {
return producerMetadata;
}
public void send(final Message<?> message) throws Exception {
final V v = getPayload(message);
public void send(final Message<?> message) throws Exception {
final V v = getPayload(message);
if (message.getHeaders().containsKey("messageKey")) {
producer.send(new KeyedMessage<K, V>(producerMetadata.getTopic(), getKey(message), v));
} else {
producer.send(new KeyedMessage<K, V>(producerMetadata.getTopic(), v));
}
}
if (message.getHeaders().containsKey("messageKey")) {
producer.send(new KeyedMessage<K, V>(producerMetadata.getTopic(), getKey(message), v));
} else {
producer.send(new KeyedMessage<K, V>(producerMetadata.getTopic(), v));
}
}
@SuppressWarnings("unchecked")
private V getPayload(final Message<?> message) throws Exception {
if (producerMetadata.getValueEncoder().getClass().isAssignableFrom(DefaultEncoder.class)) {
return (V) getByteStream(message.getPayload());
} else if (message.getPayload().getClass().isAssignableFrom(producerMetadata.getValueClassType())) {
return producerMetadata.getValueClassType().cast(message.getPayload());
}
@SuppressWarnings("unchecked")
private V getPayload(final Message<?> message) throws Exception {
if (producerMetadata.getValueEncoder().getClass().isAssignableFrom(DefaultEncoder.class)) {
return (V) getByteStream(message.getPayload());
} else if (message.getPayload().getClass().isAssignableFrom(producerMetadata.getValueClassType())) {
return producerMetadata.getValueClassType().cast(message.getPayload());
}
throw new Exception("Message payload type is not matching with what is configured");
}
throw new Exception("Message payload type is not matching with what is configured");
}
@SuppressWarnings("unchecked")
private K getKey(final Message<?> message) throws Exception {
final Object key = message.getHeaders().get("messageKey");
@SuppressWarnings("unchecked")
private K getKey(final Message<?> message) throws Exception {
final Object key = message.getHeaders().get("messageKey");
if (producerMetadata.getKeyEncoder().getClass().isAssignableFrom(DefaultEncoder.class)) {
return (K) getByteStream(key);
}
if (producerMetadata.getKeyEncoder().getClass().isAssignableFrom(DefaultEncoder.class)) {
return (K) getByteStream(key);
}
return message.getHeaders().get("messageKey", producerMetadata.getKeyClassType());
}
return message.getHeaders().get("messageKey", producerMetadata.getKeyClassType());
}
private static boolean isRawByteArray(final Object obj){
return obj instanceof byte[];
}
private static boolean isRawByteArray(final Object obj){
return obj instanceof byte[];
}
private static byte[] getByteStream(final Object obj) throws IOException {
if (isRawByteArray(obj)){
return (byte[])obj;
}
private static byte[] getByteStream(final Object obj) throws IOException {
if (isRawByteArray(obj)){
return (byte[])obj;
}
final ByteArrayOutputStream out = new ByteArrayOutputStream();
final ObjectOutputStream os = new ObjectOutputStream(out);
os.writeObject(obj);
final ByteArrayOutputStream out = new ByteArrayOutputStream();
final ObjectOutputStream os = new ObjectOutputStream(out);
os.writeObject(obj);
return out.toByteArray();
}
return out.toByteArray();
}
@Override
public boolean equals(final Object obj){
return EqualsBuilder.reflectionEquals(this, obj);
}
@Override
public boolean equals(final Object obj){
return EqualsBuilder.reflectionEquals(this, obj);
}
@Override
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
@Override
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
}

69
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ProducerFactoryBean.java
View File

@@ -27,48 +27,49 @@ import java.util.Properties;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ProducerFactoryBean<K,V> implements FactoryBean<Producer<K,V>> {
private final String brokerList;
private final ProducerMetadata<K,V> producerMetadata;
private final String brokerList;
private final ProducerMetadata<K,V> producerMetadata;
public ProducerFactoryBean(final ProducerMetadata<K,V> producerMetadata, final String brokerList){
this.producerMetadata = producerMetadata;
this.brokerList = brokerList;
}
public ProducerFactoryBean(final ProducerMetadata<K,V> producerMetadata, final String brokerList){
this.producerMetadata = producerMetadata;
this.brokerList = brokerList;
}
@Override
public Producer<K, V> getObject() throws Exception {
final Properties props = new Properties();
props.put("metadata.broker.list", brokerList);
props.put("compression.codec", producerMetadata.getCompressionCodec());
@Override
public Producer<K, V> getObject() throws Exception {
final Properties props = new Properties();
props.put("metadata.broker.list", brokerList);
props.put("compression.codec", producerMetadata.getCompressionCodec());
if (producerMetadata.isAsync()){
props.put("producer.type", "async");
if (producerMetadata.getBatchNumMessages() != null){
props.put("batch.num.messages", producerMetadata.getBatchNumMessages());
}
}
if (producerMetadata.isAsync()){
props.put("producer.type", "async");
if (producerMetadata.getBatchNumMessages() != null){
props.put("batch.num.messages", producerMetadata.getBatchNumMessages());
}
}
final ProducerConfig config = new ProducerConfig(props);
final EventHandler<K, V> eventHandler = new DefaultEventHandler<K, V>(config,
producerMetadata.getPartitioner() == null ? new DefaultPartitioner<K>() : producerMetadata.getPartitioner(),
producerMetadata.getValueEncoder(), producerMetadata.getKeyEncoder(),
new ProducerPool(config), new HashMap<String, kafka.api.TopicMetadata>());
final ProducerConfig config = new ProducerConfig(props);
final EventHandler<K, V> eventHandler = new DefaultEventHandler<K, V>(config,
producerMetadata.getPartitioner() == null ? new DefaultPartitioner<K>() : producerMetadata.getPartitioner(),
producerMetadata.getValueEncoder(), producerMetadata.getKeyEncoder(),
new ProducerPool(config), new HashMap<String, kafka.api.TopicMetadata>());
final kafka.producer.Producer<K, V> prod = new kafka.producer.Producer<K, V>(config,
eventHandler);
return new Producer<K, V>(prod);
}
final kafka.producer.Producer<K, V> prod = new kafka.producer.Producer<K, V>(config,
eventHandler);
return new Producer<K, V>(prod);
}
@Override
public Class<?> getObjectType() {
return Producer.class;
}
@Override
public Class<?> getObjectType() {
return Producer.class;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public boolean isSingleton() {
return true;
}
}

175
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ProducerMetadata.java
View File

@@ -24,116 +24,117 @@ import org.springframework.beans.factory.InitializingBean;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ProducerMetadata<K,V> implements InitializingBean {
private Encoder<K> keyEncoder;
private Encoder<V> valueEncoder;
private Class<K> keyClassType;
private Class<V> valueClassType;
private final String topic;
private String compressionCodec = "default";
private Partitioner<K> partitioner;
private boolean async = false;
private String batchNumMessages;
private Encoder<K> keyEncoder;
private Encoder<V> valueEncoder;
private Class<K> keyClassType;
private Class<V> valueClassType;
private final String topic;
private String compressionCodec = "default";
private Partitioner<K> partitioner;
private boolean async = false;
private String batchNumMessages;
public ProducerMetadata(final String topic) {
this.topic = topic;
}
public ProducerMetadata(final String topic) {
this.topic = topic;
}
public String getTopic() {
return topic;
}
public String getTopic() {
return topic;
}
public Encoder<K> getKeyEncoder() {
return keyEncoder;
}
public Encoder<K> getKeyEncoder() {
return keyEncoder;
}
public void setKeyEncoder(final Encoder<K> keyEncoder) {
this.keyEncoder = keyEncoder;
}
public void setKeyEncoder(final Encoder<K> keyEncoder) {
this.keyEncoder = keyEncoder;
}
public Encoder<V> getValueEncoder() {
return valueEncoder;
}
public Encoder<V> getValueEncoder() {
return valueEncoder;
}
public void setValueEncoder(final Encoder<V> valueEncoder) {
this.valueEncoder = valueEncoder;
}
public void setValueEncoder(final Encoder<V> valueEncoder) {
this.valueEncoder = valueEncoder;
}
public Class<K> getKeyClassType() {
return keyClassType;
}
public Class<K> getKeyClassType() {
return keyClassType;
}
public void setKeyClassType(final Class<K> keyClassType) {
this.keyClassType = keyClassType;
}
public void setKeyClassType(final Class<K> keyClassType) {
this.keyClassType = keyClassType;
}
public Class<V> getValueClassType() {
return valueClassType;
}
public Class<V> getValueClassType() {
return valueClassType;
}
public void setValueClassType(final Class<V> valueClassType) {
this.valueClassType = valueClassType;
}
public void setValueClassType(final Class<V> valueClassType) {
this.valueClassType = valueClassType;
}
//TODO: Use an enum
public String getCompressionCodec() {
if (compressionCodec.equalsIgnoreCase("gzip")) {
return "1";
} else if (compressionCodec.equalsIgnoreCase("snappy")) {
return "2";
}
//TODO: Use an enum
public String getCompressionCodec() {
if (compressionCodec.equalsIgnoreCase("gzip")) {
return "1";
} else if (compressionCodec.equalsIgnoreCase("snappy")) {
return "2";
}
return "0";
}
return "0";
}
public void setCompressionCodec(final String compressionCodec) {
this.compressionCodec = compressionCodec;
}
public void setCompressionCodec(final String compressionCodec) {
this.compressionCodec = compressionCodec;
}
public Partitioner<K> getPartitioner() {
return partitioner;
}
public Partitioner<K> getPartitioner() {
return partitioner;
}
public void setPartitioner(final Partitioner<K> partitioner) {
this.partitioner = partitioner;
}
public void setPartitioner(final Partitioner<K> partitioner) {
this.partitioner = partitioner;
}
@Override
@SuppressWarnings("unchecked")
public void afterPropertiesSet() throws Exception {
if (valueEncoder == null) {
setValueEncoder((Encoder<V>) new DefaultEncoder(null));
}
@Override
@SuppressWarnings("unchecked")
public void afterPropertiesSet() throws Exception {
if (valueEncoder == null) {
setValueEncoder((Encoder<V>) new DefaultEncoder(null));
}
if (keyEncoder == null) {
setKeyEncoder((Encoder<K>) getValueEncoder());
}
}
if (keyEncoder == null) {
setKeyEncoder((Encoder<K>) getValueEncoder());
}
}
public boolean isAsync() {
return async;
}
public boolean isAsync() {
return async;
}
public void setAsync(final boolean async) {
this.async = async;
}
public void setAsync(final boolean async) {
this.async = async;
}
public String getBatchNumMessages() {
return batchNumMessages;
}
public String getBatchNumMessages() {
return batchNumMessages;
}
public void setBatchNumMessages(final String batchNumMessages) {
this.batchNumMessages = batchNumMessages;
}
public void setBatchNumMessages(final String batchNumMessages) {
this.batchNumMessages = batchNumMessages;
}
@Override
public boolean equals(final Object obj){
return EqualsBuilder.reflectionEquals(this, obj);
}
@Override
public boolean equals(final Object obj){
return EqualsBuilder.reflectionEquals(this, obj);
}
@Override
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
@Override
public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}
}

57
spring-integration-kafka/src/main/java/org/springframework/integration/kafka/support/ZookeeperConnect.java
View File

@@ -19,42 +19,43 @@ import org.springframework.integration.kafka.core.ZookeeperConnectDefaults;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ZookeeperConnect {
private String zkConnect = ZookeeperConnectDefaults.ZK_CONNECT;
private String zkConnectionTimeout = ZookeeperConnectDefaults.ZK_CONNECTION_TIMEOUT;
private String zkSessionTimeout = ZookeeperConnectDefaults.ZK_SESSION_TIMEOUT;
private String zkSyncTime = ZookeeperConnectDefaults.ZK_SYNC_TIME;
private String zkConnect = ZookeeperConnectDefaults.ZK_CONNECT;
private String zkConnectionTimeout = ZookeeperConnectDefaults.ZK_CONNECTION_TIMEOUT;
private String zkSessionTimeout = ZookeeperConnectDefaults.ZK_SESSION_TIMEOUT;
private String zkSyncTime = ZookeeperConnectDefaults.ZK_SYNC_TIME;
public String getZkConnect() {
return zkConnect;
}
public String getZkConnect() {
return zkConnect;
}
public void setZkConnect(final String zkConnect) {
this.zkConnect = zkConnect;
}
public void setZkConnect(final String zkConnect) {
this.zkConnect = zkConnect;
}
public String getZkConnectionTimeout() {
return zkConnectionTimeout;
}
public String getZkConnectionTimeout() {
return zkConnectionTimeout;
}
public void setZkConnectionTimeout(final String zkConnectionTimeout) {
this.zkConnectionTimeout = zkConnectionTimeout;
}
public void setZkConnectionTimeout(final String zkConnectionTimeout) {
this.zkConnectionTimeout = zkConnectionTimeout;
}
public String getZkSessionTimeout() {
return zkSessionTimeout;
}
public String getZkSessionTimeout() {
return zkSessionTimeout;
}
public void setZkSessionTimeout(final String zkSessionTimeout) {
this.zkSessionTimeout = zkSessionTimeout;
}
public void setZkSessionTimeout(final String zkSessionTimeout) {
this.zkSessionTimeout = zkSessionTimeout;
}
public String getZkSyncTime() {
return zkSyncTime;
}
public String getZkSyncTime() {
return zkSyncTime;
}
public void setZkSyncTime(final String zkSyncTime) {
this.zkSyncTime = zkSyncTime;
}
public void setZkSyncTime(final String zkSyncTime) {
this.zkSyncTime = zkSyncTime;
}
}

BIN
spring-integration-kafka/src/main/resources/org/springframework/integration/config/xml/spring-integration-kafka.gif
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 572 B

After

Width:  |  Height:  |  Size: 539 B

72
spring-integration-kafka/src/reference/docbook/SIAdapterLowerPrefix.xml
View File

@@ -1,72 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<chapter xmlns="http://docbook.org/ns/docbook" version="5.0" xml:id="SIAdapterLowerPrefix">
<title>Kafka Adapter</title>
<para>
The Spring Integration Kafka Adapter provides...
</para>
<itemizedlist>
<listitem>
<para><emphasis><link linkend='SIAdapterLowerPrefix-outbound-channel-adapter'>Outbound Channel adapter</link></emphasis></para>
</listitem>
<listitem>
<para><emphasis><link linkend='SIAdapterLowerPrefix-outbound-gateway'>Outbound Gateway</link></emphasis></para>
</listitem>
<listitem>
<para><emphasis><link linkend='SIAdapterLowerPrefix-inbound-channel-adapter'>Inbound Channel Adapter</link></emphasis></para>
</listitem>
</itemizedlist>
<section id="jpa-java-implementation">
<title>Java Implementation</title>
<para>Each of the provided components will use the
<classname>org.springframework.integration.kafka.core.KafkaExecutor</classname>
class...
</para>
</section>
<section id="jpa-common-configuration-attributes">
<title>Common Configuration Attributes</title>
<para>
Certain configuration parameters are shared amongst all Kafka
components and are described below:
</para>
<para><emphasis role="bold">auto-startup</emphasis></para>
<para>
Lifecycle attribute signaling if this component should
be started during Application Context startup.
Defaults to <code>true</code>.
<emphasis>Optional</emphasis>.
</para>
<para><emphasis role="bold">id</emphasis></para>
<para>
Identifies the underlying Spring bean definition, which
is an instance of either <classname>EventDrivenConsumer</classname>
or <classname>PollingConsumer</classname>.
<emphasis>Optional</emphasis>.
</para>
</section>
<section id="SIAdapterLowerPrefix-outbound-channel-adapter">
<title>Outbound Channel Adapter</title>
<para>
The Kafka Outbound channel adapter allows you to...
</para>
</section>
<section id="SIAdapterLowerPrefix-outbound-gateway">
<title>Outbound Gateway</title>
<para>
Outbound gateways are similar to outbound channel adapters except that it can also be used to
get a result on the <emphasis>reply channel</emphasis> after performing
the given...
</para>
</section>
<section id="SIAdapterLowerPrefix-inbound-channel-adapter">
<title>Inbound Channel Adapter</title>
<para>
An inbound channel adapter is used to execute...
</para>
</section>
</chapter>

4
spring-integration-kafka/src/reference/docbook/history.xml
View File

@@ -1,4 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<appendix xmlns="http://docbook.org/ns/docbook" version="5.0" xml:id="history">
<title>Change History</title>
</appendix>

BIN
spring-integration-kafka/src/reference/docbook/images/logo.png
View File

Binary file not shown.

67
spring-integration-kafka/src/reference/docbook/index.xml
View File

@@ -1,67 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<book xmlns="http://docbook.org/ns/docbook" version="5.0"
xml:id="spring-integration-reference" xmlns:xi="http://www.w3.org/2001/XInclude">
<bookinfo>
<title>Spring Integration Kafka Adapter</title>
<titleabbrev>Kafka Adapter ${version}</titleabbrev>
<productname>Spring Integration</productname>
<releaseinfo>${version}</releaseinfo>
<!-- TODO: this isn't showing up. -->
<mediaobject>
<imageobject role="fo">
<imagedata fileref="images/logo.png" format="PNG" align="center" />
</imageobject>
<imageobject role="html">
<imagedata fileref="images/logo.png" format="PNG" align="center" />
</imageobject>
</mediaobject>
<!-- END TODO -->
<authorgroup>
<author><firstname>Soby Chacko</firstname></author>
</authorgroup>
<legalnotice>
<para>© SpringSource Inc., 2012</para>
</legalnotice>
</bookinfo>
<toc></toc>
<part id="whats-new-part">
<title>What's new?</title>
<partintro id="spring-integration-intro">
<para>
For those who are already familiar with Spring Integration, this
chapter
provides a brief overview of the new features of version 2.2. If you are
interested in the changes and features, that were introduced in
earlier
versions, please take a look at chapter:
<xref linkend="history" />
</para>
</partintro>
<xi:include href="./whats-new.xml" />
</part>
<part id="spring-integration-adapters">
<title>Integration Adapters</title>
<partintro id="spring-integration-adapters">
<para>This section covers the various Channel Adapters and Messaging
Gateways provided
by Spring Integration to support Message-based communication with
external systems.
</para>
</partintro>
<xi:include href="./SIAdapterLowerPrefix.xml" />
</part>
<part id="spring-integration-appendices">
<title>Appendices</title>
<partintro id="spring-integration-adapters">
<para>Advanced Topics and Additional Resources</para>
</partintro>
<xi:include href="./history.xml" />
</part>
</book>

15
spring-integration-kafka/src/reference/docbook/resources.xml
View File

@@ -1,15 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<appendix xmlns="http://docbook.org/ns/docbook" version="5.0" xml:id="resources">
<title>Additional Resources</title>
<section id="resources-home">
<title>Spring Integration Home</title>
<para>
The definitive source of information about Spring Integration is the
<ulink url="http://www.springsource.org/spring-integration">Spring Integration Home</ulink> at
<ulink url="http://www.springsource.org">http://www.springsource.org</ulink>. That site serves as a hub of
information and is the best place to find up-to-date announcements about the project as well as links to
articles, blogs, and new sample applications.
</para>
</section>
</appendix>

8
spring-integration-kafka/src/reference/docbook/whats-new.xml
View File

@@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<chapter xmlns="http://docbook.org/ns/docbook" version="5.0" xml:id="whats-new">
<title>What's new?</title>
<para>
This chapter provides an overview of the new features and improvements
that have been added to the Kafka Adapter:
</para>
</chapter>

23
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/config/xml/KafkaConsumerContextParserTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.config.xml;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
@@ -27,21 +27,22 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Soby Chacko
* @since 0.5
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class KafkaConsumerContextParserTests {
@Autowired
private ApplicationContext appContext;
@Autowired
private ApplicationContext appContext;
@Test
@SuppressWarnings("unchecked")
public void testConsumerContextConfiguration() {
final KafkaConsumerContext consumerContext = appContext.getBean("consumerContext", KafkaConsumerContext.class);
Assert.assertNotNull(consumerContext);
@Test
@SuppressWarnings("unchecked")
public void testConsumerContextConfiguration() {
final KafkaConsumerContext consumerContext = appContext.getBean("consumerContext", KafkaConsumerContext.class);
Assert.assertNotNull(consumerContext);
final ConsumerMetadata cm = appContext.getBean("consumerMetadata_default1", ConsumerMetadata.class);
Assert.assertNotNull(cm);
}
final ConsumerMetadata cm = appContext.getBean("consumerMetadata_default1", ConsumerMetadata.class);
Assert.assertNotNull(cm);
}
}

8
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/config/xml/KafkaInboundAdapterParserTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.config.xml;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
@@ -24,6 +24,10 @@ import org.springframework.integration.endpoint.SourcePollingChannelAdapter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Soby Chacko
* @since 0.5
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class KafkaInboundAdapterParserTests {
@@ -39,7 +43,7 @@ public class KafkaInboundAdapterParserTests {
final SourcePollingChannelAdapter adapter = appContext.getBean("kafkaInboundChannelAdapter",
SourcePollingChannelAdapter.class);
Assert.assertNotNull(adapter);
Assert.assertNotNull(adapter);
Assert.assertFalse(adapter.isAutoStartup());
}
}

30
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/config/xml/KafkaOutboundAdapterParserTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.config.xml;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
@@ -26,21 +26,25 @@ import org.springframework.integration.kafka.support.KafkaProducerContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Soby Chacko
* @since 0.5
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class KafkaOutboundAdapterParserTests {
@Autowired
private ApplicationContext appContext;
@Autowired
private ApplicationContext appContext;
@Test
public void testOutboundAdapterConfiguration(){
final PollingConsumer pollingConsumer = appContext.getBean("kafkaOutboundChannelAdapter", PollingConsumer.class);
final KafkaProducerMessageHandler messageHandler = appContext.getBean(KafkaProducerMessageHandler.class);
Assert.assertNotNull(pollingConsumer);
Assert.assertNotNull(messageHandler);
final KafkaProducerContext producerContext = messageHandler.getKafkaProducerContext();
Assert.assertNotNull(producerContext);
Assert.assertEquals(producerContext.getTopicsConfiguration().size(), 2);
}
@Test
public void testOutboundAdapterConfiguration(){
final PollingConsumer pollingConsumer = appContext.getBean("kafkaOutboundChannelAdapter", PollingConsumer.class);
final KafkaProducerMessageHandler messageHandler = appContext.getBean(KafkaProducerMessageHandler.class);
Assert.assertNotNull(pollingConsumer);
Assert.assertNotNull(messageHandler);
final KafkaProducerContext producerContext = messageHandler.getKafkaProducerContext();
Assert.assertNotNull(producerContext);
Assert.assertEquals(producerContext.getTopicsConfiguration().size(), 2);
}
}

64
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/config/xml/KafkaProducerContextParserTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.config.xml;
import junit.framework.Assert;
import org.junit.Assert;
import kafka.javaapi.producer.Producer;
import kafka.serializer.Encoder;
import org.junit.Test;
@@ -30,44 +30,48 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class KafkaProducerContextParserTests {
@Autowired
private ApplicationContext appContext;
@Autowired
private ApplicationContext appContext;
@Test
@SuppressWarnings("unchecked")
public void testProducerContextConfiguration(){
final KafkaProducerContext producerContext = appContext.getBean("producerContext", KafkaProducerContext.class);
Assert.assertNotNull(producerContext);
@Test
@SuppressWarnings("unchecked")
public void testProducerContextConfiguration(){
final KafkaProducerContext producerContext = appContext.getBean("producerContext", KafkaProducerContext.class);
Assert.assertNotNull(producerContext);
final Map<String, ProducerConfiguration> topicConfigurations = producerContext.getTopicsConfiguration();
Assert.assertEquals(topicConfigurations.size(), 2);
final Map<String, ProducerConfiguration> topicConfigurations = producerContext.getTopicsConfiguration();
Assert.assertEquals(topicConfigurations.size(), 2);
final ProducerConfiguration producerConfigurationTest1 = topicConfigurations.get("producerConfiguration_test1");
Assert.assertNotNull(producerConfigurationTest1);
final ProducerMetadata producerMetadataTest1 = producerConfigurationTest1.getProducerMetadata();
Assert.assertEquals(producerMetadataTest1.getTopic(), "test1");
Assert.assertEquals(producerMetadataTest1.getCompressionCodec(), "0");
Assert.assertEquals(producerMetadataTest1.getKeyClassType(), java.lang.String.class);
Assert.assertEquals(producerMetadataTest1.getValueClassType(), java.lang.String.class);
final ProducerConfiguration producerConfigurationTest1 = topicConfigurations.get("producerConfiguration_test1");
Assert.assertNotNull(producerConfigurationTest1);
final ProducerMetadata producerMetadataTest1 = producerConfigurationTest1.getProducerMetadata();
Assert.assertEquals(producerMetadataTest1.getTopic(), "test1");
Assert.assertEquals(producerMetadataTest1.getCompressionCodec(), "0");
Assert.assertEquals(producerMetadataTest1.getKeyClassType(), java.lang.String.class);
Assert.assertEquals(producerMetadataTest1.getValueClassType(), java.lang.String.class);
final Encoder valueEncoder = appContext.getBean("valueEncoder", Encoder.class);
Assert.assertEquals(producerMetadataTest1.getValueEncoder(), valueEncoder);
Assert.assertEquals(producerMetadataTest1.getKeyEncoder(), valueEncoder);
final Encoder valueEncoder = appContext.getBean("valueEncoder", Encoder.class);
Assert.assertEquals(producerMetadataTest1.getValueEncoder(), valueEncoder);
Assert.assertEquals(producerMetadataTest1.getKeyEncoder(), valueEncoder);
final Producer producerTest1 = appContext.getBean("prodFactory_test1", Producer.class);
Assert.assertEquals(producerConfigurationTest1, new ProducerConfiguration(producerMetadataTest1, producerTest1));
final Producer producerTest1 = appContext.getBean("prodFactory_test1", Producer.class);
Assert.assertEquals(producerConfigurationTest1, new ProducerConfiguration(producerMetadataTest1, producerTest1));
final ProducerConfiguration producerConfigurationTest2 = topicConfigurations.get("producerConfiguration_" + "test2");
Assert.assertNotNull(producerConfigurationTest2);
final ProducerMetadata producerMetadataTest2 = producerConfigurationTest2.getProducerMetadata();
Assert.assertEquals(producerMetadataTest2.getTopic(), "test2");
Assert.assertEquals(producerMetadataTest2.getCompressionCodec(), "0");
final ProducerConfiguration producerConfigurationTest2 = topicConfigurations.get("producerConfiguration_" + "test2");
Assert.assertNotNull(producerConfigurationTest2);
final ProducerMetadata producerMetadataTest2 = producerConfigurationTest2.getProducerMetadata();
Assert.assertEquals(producerMetadataTest2.getTopic(), "test2");
Assert.assertEquals(producerMetadataTest2.getCompressionCodec(), "0");
final Producer producerTest2 = appContext.getBean("prodFactory_test2", Producer.class);
Assert.assertEquals(producerConfigurationTest2, new ProducerConfiguration(producerMetadataTest2, producerTest2));
}
final Producer producerTest2 = appContext.getBean("prodFactory_test2", Producer.class);
Assert.assertEquals(producerConfigurationTest2, new ProducerConfiguration(producerMetadataTest2, producerTest2));
}
}

27
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/config/xml/ZookeeperConnectParserTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.config.xml;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
@@ -27,8 +27,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @author Soby Chacko
* @since 1.0
*
* @since 0.5
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@@ -42,18 +41,18 @@ public class ZookeeperConnectParserTests {
final ZookeeperConnect broker = appContext.getBean("zookeeperConnect", ZookeeperConnect.class);
Assert.assertEquals("localhost:2181", broker.getZkConnect());
Assert.assertEquals("10000", broker.getZkConnectionTimeout());
Assert.assertEquals("10000", broker.getZkSessionTimeout());
Assert.assertEquals("200", broker.getZkSyncTime());
Assert.assertEquals("10000", broker.getZkConnectionTimeout());
Assert.assertEquals("10000", broker.getZkSessionTimeout());
Assert.assertEquals("200", broker.getZkSyncTime());
}
@Test
public void testDefaultKafkaBrokerConfiguration() {
final ZookeeperConnect broker = appContext.getBean("defaultZookeeperConnect", ZookeeperConnect.class);
@Test
public void testDefaultKafkaBrokerConfiguration() {
final ZookeeperConnect broker = appContext.getBean("defaultZookeeperConnect", ZookeeperConnect.class);
Assert.assertEquals(ZookeeperConnectDefaults.ZK_CONNECT, broker.getZkConnect());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_CONNECTION_TIMEOUT, broker.getZkConnectionTimeout());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_SESSION_TIMEOUT, broker.getZkSessionTimeout());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_SYNC_TIME, broker.getZkSyncTime());
}
Assert.assertEquals(ZookeeperConnectDefaults.ZK_CONNECT, broker.getZkConnect());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_CONNECTION_TIMEOUT, broker.getZkConnectionTimeout());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_SESSION_TIMEOUT, broker.getZkSessionTimeout());
Assert.assertEquals(ZookeeperConnectDefaults.ZK_SYNC_TIME, broker.getZkSyncTime());
}
}

50
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/serializer/AvroBackedKafkaSerializerTest.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.serializer;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.integration.kafka.serializer.avro.AvroBackedKafkaDecoder;
import org.springframework.integration.kafka.serializer.avro.AvroBackedKafkaEncoder;
@@ -23,37 +23,37 @@ import org.springframework.integration.kafka.test.utils.TestObject;
/**
* @author Soby Chacko
* @since 1.0
* @since 0.5
*/
public class AvroBackedKafkaSerializerTest {
@Test
@SuppressWarnings("unchecked")
public void testDecodePlainSchema() {
final AvroBackedKafkaEncoder avroBackedKafkaEncoder = new AvroBackedKafkaEncoder(TestObject.class);
@Test
@SuppressWarnings("unchecked")
public void testDecodePlainSchema() {
final AvroBackedKafkaEncoder avroBackedKafkaEncoder = new AvroBackedKafkaEncoder(TestObject.class);
final TestObject testObject = new TestObject();
testObject.setTestData1("\"Test Data1\"");
testObject.setTestData2(1);
final TestObject testObject = new TestObject();
testObject.setTestData1("\"Test Data1\"");
testObject.setTestData2(1);
final byte[] data = avroBackedKafkaEncoder.toBytes(testObject);
final byte[] data = avroBackedKafkaEncoder.toBytes(testObject);
final AvroBackedKafkaDecoder avroBackedKafkaDecoder = new AvroBackedKafkaDecoder(TestObject.class);
final TestObject decodedFbu = (TestObject) avroBackedKafkaDecoder.fromBytes(data);
final AvroBackedKafkaDecoder avroBackedKafkaDecoder = new AvroBackedKafkaDecoder(TestObject.class);
final TestObject decodedFbu = (TestObject) avroBackedKafkaDecoder.fromBytes(data);
Assert.assertEquals(testObject.getTestData1(), decodedFbu.getTestData1());
Assert.assertEquals(testObject.getTestData2(), decodedFbu.getTestData2());
}
Assert.assertEquals(testObject.getTestData1(), decodedFbu.getTestData1());
Assert.assertEquals(testObject.getTestData2(), decodedFbu.getTestData2());
}
@Test
@SuppressWarnings("unchecked")
public void anotherTest() {
final AvroBackedKafkaEncoder avroBackedKafkaEncoder = new AvroBackedKafkaEncoder(java.lang.String.class);
final String testString = "Testing Avro";
final byte[] data = avroBackedKafkaEncoder.toBytes(testString);
@Test
@SuppressWarnings("unchecked")
public void anotherTest() {
final AvroBackedKafkaEncoder avroBackedKafkaEncoder = new AvroBackedKafkaEncoder(java.lang.String.class);
final String testString = "Testing Avro";
final byte[] data = avroBackedKafkaEncoder.toBytes(testString);
final AvroBackedKafkaDecoder avroBackedKafkaDecoder = new AvroBackedKafkaDecoder(java.lang.String.class);
final String decodedS = (String) avroBackedKafkaDecoder.fromBytes(data);
final AvroBackedKafkaDecoder avroBackedKafkaDecoder = new AvroBackedKafkaDecoder(java.lang.String.class);
final String decodedS = (String) avroBackedKafkaDecoder.fromBytes(data);
Assert.assertEquals(testString, decodedS);
}
Assert.assertEquals(testString, decodedS);
}
}

429
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/support/ConsumerConfigurationTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.integration.kafka.support;
import junit.framework.Assert;
import org.junit.Assert;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;
@@ -33,274 +33,275 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ConsumerConfigurationTests {
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForSingleTopicFromSingleStream() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForSingleTopicFromSingleStream() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(1);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(1);
final KafkaStream stream = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic", streams);
final KafkaStream stream = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic", streams);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream.iterator()).thenReturn(iterator);
final MessageAndMetadata messageAndMetadata = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator.next()).thenReturn(messageAndMetadata);
Mockito.when(messageAndMetadata.message()).thenReturn("got message");
Mockito.when(messageAndMetadata.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata.partition()).thenReturn(1);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream.iterator()).thenReturn(iterator);
final MessageAndMetadata messageAndMetadata = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator.next()).thenReturn(messageAndMetadata);
Mockito.when(messageAndMetadata.message()).thenReturn("got message");
Mockito.when(messageAndMetadata.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata.partition()).thenReturn(1);
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
Assert.assertEquals(messages.size(), 1);
Assert.assertEquals(messages.get("topic").size(), 1);
Assert.assertEquals(messages.get("topic").get(1).get(0), "got message");
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
Assert.assertEquals(messages.size(), 1);
Assert.assertEquals(messages.get("topic").size(), 1);
Assert.assertEquals(messages.get("topic").get(1).get(0), "got message");
Mockito.verify(stream, Mockito.times(1)).iterator();
Mockito.verify(iterator, Mockito.times(1)).next();
Mockito.verify(messageAndMetadata, Mockito.times(1)).message();
Mockito.verify(messageAndMetadata, Mockito.times(1)).topic();
}
Mockito.verify(stream, Mockito.times(1)).iterator();
Mockito.verify(iterator, Mockito.times(1)).next();
Mockito.verify(messageAndMetadata, Mockito.times(1)).message();
Mockito.verify(messageAndMetadata, Mockito.times(1)).topic();
}
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForSingleTopicFromMultipleStreams() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForSingleTopicFromMultipleStreams() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(3);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(3);
final KafkaStream stream1 = Mockito.mock(KafkaStream.class);
final KafkaStream stream2 = Mockito.mock(KafkaStream.class);
final KafkaStream stream3 = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream1);
streams.add(stream2);
streams.add(stream3);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic", streams);
final KafkaStream stream1 = Mockito.mock(KafkaStream.class);
final KafkaStream stream2 = Mockito.mock(KafkaStream.class);
final KafkaStream stream3 = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream1);
streams.add(stream2);
streams.add(stream3);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic", streams);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator1 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator2 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator3 = Mockito.mock(ConsumerIterator.class);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator1 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator2 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator3 = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream1.iterator()).thenReturn(iterator1);
Mockito.when(stream2.iterator()).thenReturn(iterator2);
Mockito.when(stream3.iterator()).thenReturn(iterator3);
final MessageAndMetadata messageAndMetadata1 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata2 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata3 = Mockito.mock(MessageAndMetadata.class);
Mockito.when(stream1.iterator()).thenReturn(iterator1);
Mockito.when(stream2.iterator()).thenReturn(iterator2);
Mockito.when(stream3.iterator()).thenReturn(iterator3);
final MessageAndMetadata messageAndMetadata1 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata2 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata3 = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator1.next()).thenReturn(messageAndMetadata1);
Mockito.when(iterator2.next()).thenReturn(messageAndMetadata2);
Mockito.when(iterator3.next()).thenReturn(messageAndMetadata3);
Mockito.when(iterator1.next()).thenReturn(messageAndMetadata1);
Mockito.when(iterator2.next()).thenReturn(messageAndMetadata2);
Mockito.when(iterator3.next()).thenReturn(messageAndMetadata3);
Mockito.when(messageAndMetadata1.message()).thenReturn("got message");
Mockito.when(messageAndMetadata1.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata1.partition()).thenReturn(1);
Mockito.when(messageAndMetadata1.message()).thenReturn("got message");
Mockito.when(messageAndMetadata1.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata1.partition()).thenReturn(1);
Mockito.when(messageAndMetadata2.message()).thenReturn("got message");
Mockito.when(messageAndMetadata2.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata2.partition()).thenReturn(2);
Mockito.when(messageAndMetadata2.message()).thenReturn("got message");
Mockito.when(messageAndMetadata2.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata2.partition()).thenReturn(2);
Mockito.when(messageAndMetadata3.message()).thenReturn("got message");
Mockito.when(messageAndMetadata3.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata3.partition()).thenReturn(3);
Mockito.when(messageAndMetadata3.message()).thenReturn("got message");
Mockito.when(messageAndMetadata3.topic()).thenReturn("topic");
Mockito.when(messageAndMetadata3.partition()).thenReturn(3);
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
Assert.assertEquals(messages.size(), 1);
int sum = 0;
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
Assert.assertEquals(messages.size(), 1);
int sum = 0;
final Map<Integer, List<Object>> values = messages.get("topic");
final Map<Integer, List<Object>> values = messages.get("topic");
for (final List<Object> l : values.values()) {
sum += l.size();
}
for (final List<Object> l : values.values()) {
sum += l.size();
}
Assert.assertEquals(sum, 3);
}
Assert.assertEquals(sum, 3);
}
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForMultipleTopicsFromMultipleStreams() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageForMultipleTopicsFromMultipleStreams() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(9);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(9);
final KafkaStream stream1 = Mockito.mock(KafkaStream.class);
final KafkaStream stream2 = Mockito.mock(KafkaStream.class);
final KafkaStream stream3 = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream1);
streams.add(stream2);
streams.add(stream3);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic1", streams);
messageStreams.put("topic2", streams);
messageStreams.put("topic3", streams);
final KafkaStream stream1 = Mockito.mock(KafkaStream.class);
final KafkaStream stream2 = Mockito.mock(KafkaStream.class);
final KafkaStream stream3 = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream1);
streams.add(stream2);
streams.add(stream3);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic1", streams);
messageStreams.put("topic2", streams);
messageStreams.put("topic3", streams);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator1 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator2 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator3 = Mockito.mock(ConsumerIterator.class);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator1 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator2 = Mockito.mock(ConsumerIterator.class);
final ConsumerIterator iterator3 = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream1.iterator()).thenReturn(iterator1);
Mockito.when(stream2.iterator()).thenReturn(iterator2);
Mockito.when(stream3.iterator()).thenReturn(iterator3);
final MessageAndMetadata messageAndMetadata1 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata2 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata3 = Mockito.mock(MessageAndMetadata.class);
Mockito.when(stream1.iterator()).thenReturn(iterator1);
Mockito.when(stream2.iterator()).thenReturn(iterator2);
Mockito.when(stream3.iterator()).thenReturn(iterator3);
final MessageAndMetadata messageAndMetadata1 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata2 = Mockito.mock(MessageAndMetadata.class);
final MessageAndMetadata messageAndMetadata3 = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator1.next()).thenReturn(messageAndMetadata1);
Mockito.when(iterator2.next()).thenReturn(messageAndMetadata2);
Mockito.when(iterator3.next()).thenReturn(messageAndMetadata3);
Mockito.when(iterator1.next()).thenReturn(messageAndMetadata1);
Mockito.when(iterator2.next()).thenReturn(messageAndMetadata2);
Mockito.when(iterator3.next()).thenReturn(messageAndMetadata3);
Mockito.when(messageAndMetadata1.message()).thenReturn("got message1");
Mockito.when(messageAndMetadata1.topic()).thenReturn("topic1");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
Mockito.when(messageAndMetadata1.message()).thenReturn("got message1");
Mockito.when(messageAndMetadata1.topic()).thenReturn("topic1");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
Mockito.when(messageAndMetadata2.message()).thenReturn("got message2");
Mockito.when(messageAndMetadata2.topic()).thenReturn("topic2");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
Mockito.when(messageAndMetadata2.message()).thenReturn("got message2");
Mockito.when(messageAndMetadata2.topic()).thenReturn("topic2");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
Mockito.when(messageAndMetadata3.message()).thenReturn("got message3");
Mockito.when(messageAndMetadata3.topic()).thenReturn("topic3");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
Mockito.when(messageAndMetadata3.message()).thenReturn("got message3");
Mockito.when(messageAndMetadata3.topic()).thenReturn("topic3");
Mockito.when(messageAndMetadata1.partition()).thenAnswer(getAnswer());
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
int sum = 0;
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
int sum = 0;
final Collection<Map<Integer, List<Object>>> values = messages.values();
final Collection<Map<Integer, List<Object>>> values = messages.values();
for (final Map<Integer, List<Object>> m : values) {
for (final List<Object> l : m.values()) {
sum += l.size();
}
}
for (final Map<Integer, List<Object>> m : values) {
for (final List<Object> l : m.values()) {
sum += l.size();
}
}
Assert.assertEquals(sum, 9);
}
Assert.assertEquals(sum, 9);
}
private Answer<Object> getAnswer() {
return new Answer<Object>() {
private int count = 0;
private Answer<Object> getAnswer() {
return new Answer<Object>() {
private int count = 0;
@Override
public Object answer(final InvocationOnMock invocation) throws Throwable {
if (count++ == 1) {
return 1;
} else if (count++ == 2) {
return 2;
}
@Override
public Object answer(final InvocationOnMock invocation) throws Throwable {
if (count++ == 1) {
return 1;
} else if (count++ == 2) {
return 2;
}
return 3;
}
};
}
return 3;
}
};
}
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageAndVerifyMessageLeftoverFromPreviousPollAreTakenFirst() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
@Test
@SuppressWarnings("unchecked")
public void testReceiveMessageAndVerifyMessageLeftoverFromPreviousPollAreTakenFirst() {
final ConsumerMetadata consumerMetadata = Mockito.mock(ConsumerMetadata.class);
final ConsumerConnectionProvider consumerConnectionProvider =
Mockito.mock(ConsumerConnectionProvider.class);
final MessageLeftOverTracker messageLeftOverTracker = Mockito.mock(MessageLeftOverTracker.class);
final ConsumerConnector consumerConnector = Mockito.mock(ConsumerConnector.class);
Mockito.when(messageLeftOverTracker.getCurrentCount()).thenReturn(3);
final MessageAndMetadata m1 = new MessageAndMetadata("key1", "value1", "topic1", 1, 1L);
final MessageAndMetadata m2 = new MessageAndMetadata("key2", "value2", "topic2", 1, 1L);
final MessageAndMetadata m3 = new MessageAndMetadata("key1", "value3", "topic3", 1, 1L);
Mockito.when(messageLeftOverTracker.getCurrentCount()).thenReturn(3);
final MessageAndMetadata m1 = new MessageAndMetadata("key1", "value1", "topic1", 1, 1L);
final MessageAndMetadata m2 = new MessageAndMetadata("key2", "value2", "topic2", 1, 1L);
final MessageAndMetadata m3 = new MessageAndMetadata("key1", "value3", "topic3", 1, 1L);
final List<MessageAndMetadata> mList = new ArrayList<MessageAndMetadata>();
mList.add(m1);
mList.add(m2);
mList.add(m3);
final List<MessageAndMetadata> mList = new ArrayList<MessageAndMetadata>();
mList.add(m1);
mList.add(m2);
mList.add(m3);
Mockito.when(messageLeftOverTracker.getMessageLeftOverFromPreviousPoll()).thenReturn(mList);
Mockito.when(messageLeftOverTracker.getMessageLeftOverFromPreviousPoll()).thenReturn(mList);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
Mockito.when(consumerConnectionProvider.getConsumerConnector()).thenReturn(consumerConnector);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(5);
final ConsumerConfiguration consumerConfiguration = new ConsumerConfiguration(consumerMetadata,
consumerConnectionProvider, messageLeftOverTracker);
consumerConfiguration.setMaxMessages(5);
final KafkaStream stream = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic1", streams);
final KafkaStream stream = Mockito.mock(KafkaStream.class);
final List<KafkaStream<byte[], byte[]>> streams = new ArrayList<KafkaStream<byte[], byte[]>>();
streams.add(stream);
final Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = new HashMap<String, List<KafkaStream<byte[], byte[]>>>();
messageStreams.put("topic1", streams);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream.iterator()).thenReturn(iterator);
final MessageAndMetadata messageAndMetadata = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator.next()).thenReturn(messageAndMetadata);
Mockito.when(messageAndMetadata.message()).thenReturn("got message");
Mockito.when(messageAndMetadata.topic()).thenReturn("topic1");
Mockito.when(messageAndMetadata.partition()).thenReturn(1);
Mockito.when(consumerConfiguration.getConsumerMapWithMessageStreams()).thenReturn(messageStreams);
final ConsumerIterator iterator = Mockito.mock(ConsumerIterator.class);
Mockito.when(stream.iterator()).thenReturn(iterator);
final MessageAndMetadata messageAndMetadata = Mockito.mock(MessageAndMetadata.class);
Mockito.when(iterator.next()).thenReturn(messageAndMetadata);
Mockito.when(messageAndMetadata.message()).thenReturn("got message");
Mockito.when(messageAndMetadata.topic()).thenReturn("topic1");
Mockito.when(messageAndMetadata.partition()).thenReturn(1);
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
int sum = 0;
final Map<String, Map<Integer, List<Object>>> messages = consumerConfiguration.receive();
int sum = 0;
final Collection<Map<Integer, List<Object>>> values = messages.values();
final Collection<Map<Integer, List<Object>>> values = messages.values();
for (final Map<Integer, List<Object>> m : values) {
for (final List<Object> l : m.values()) {
sum += l.size();
}
for (final Map<Integer, List<Object>> m : values) {
for (final List<Object> l : m.values()) {
sum += l.size();
}
}
Assert.assertEquals(sum, 5);
}
Assert.assertEquals(sum, 5);
Assert.assertTrue(messages.containsKey("topic1"));
Assert.assertTrue(messages.containsKey("topic2"));
Assert.assertTrue(messages.containsKey("topic3"));
Assert.assertTrue(messages.containsKey("topic1"));
Assert.assertTrue(messages.containsKey("topic2"));
Assert.assertTrue(messages.containsKey("topic3"));
Assert.assertTrue(valueFound(messages.get("topic1").get(1), "value1"));
Assert.assertTrue(valueFound(messages.get("topic2").get(1), "value2"));
Assert.assertTrue(valueFound(messages.get("topic3").get(1), "value3"));
}
Assert.assertTrue(valueFound(messages.get("topic1").get(1), "value1"));
Assert.assertTrue(valueFound(messages.get("topic2").get(1), "value2"));
Assert.assertTrue(valueFound(messages.get("topic3").get(1), "value3"));
}
private boolean valueFound(final List<Object> l, final String value){
for (final Object o : l){
if (value.equals(o)){
return true;
}
}
private boolean valueFound(final List<Object> l, final String value){
for (final Object o : l){
if (value.equals(o)){
return true;
}
}
return false;
}
return false;
}
}

77
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/support/KafkaConsumerContextTest.java
View File

@@ -28,53 +28,54 @@ import java.util.Map;
/**
* @author Soby Chacko
* @since 0.5
*/
public class KafkaConsumerContextTest {
@Test
public void testMergeResultsFromMultipleConsumerConfiguration() {
final KafkaConsumerContext kafkaConsumerContext = new KafkaConsumerContext();
final ListableBeanFactory beanFactory = Mockito.mock(ListableBeanFactory.class);
final ConsumerConfiguration consumerConfiguration1 = Mockito.mock(ConsumerConfiguration.class);
final ConsumerConfiguration consumerConfiguration2 = Mockito.mock(ConsumerConfiguration.class);
@Test
public void testMergeResultsFromMultipleConsumerConfiguration() {
final KafkaConsumerContext kafkaConsumerContext = new KafkaConsumerContext();
final ListableBeanFactory beanFactory = Mockito.mock(ListableBeanFactory.class);
final ConsumerConfiguration consumerConfiguration1 = Mockito.mock(ConsumerConfiguration.class);
final ConsumerConfiguration consumerConfiguration2 = Mockito.mock(ConsumerConfiguration.class);
final Map<String, ConsumerConfiguration> map = new HashMap<String, ConsumerConfiguration>();
map.put("config1", consumerConfiguration1);
map.put("config2", consumerConfiguration2);
final Map<String, ConsumerConfiguration> map = new HashMap<String, ConsumerConfiguration>();
map.put("config1", consumerConfiguration1);
map.put("config2", consumerConfiguration2);
Mockito.when(beanFactory.getBeansOfType(ConsumerConfiguration.class)).thenReturn(map);
kafkaConsumerContext.setBeanFactory(beanFactory);
Mockito.when(beanFactory.getBeansOfType(ConsumerConfiguration.class)).thenReturn(map);
kafkaConsumerContext.setBeanFactory(beanFactory);
final Map<String, Map<Integer, List<Object>>> result1 = new HashMap<String, Map<Integer, List<Object>>>();
final List<Object> l1 = new ArrayList<Object>();
l1.add("got message1 - l1");
l1.add("got message2 - l1");
final Map<Integer, List<Object>> innerMap1 = new HashMap<Integer, List<Object>>();
innerMap1.put(1, l1);
result1.put("topic1", innerMap1);
final Map<String, Map<Integer, List<Object>>> result1 = new HashMap<String, Map<Integer, List<Object>>>();
final List<Object> l1 = new ArrayList<Object>();
l1.add("got message1 - l1");
l1.add("got message2 - l1");
final Map<Integer, List<Object>> innerMap1 = new HashMap<Integer, List<Object>>();
innerMap1.put(1, l1);
result1.put("topic1", innerMap1);
final Map<String, Map<Integer, List<Object>>> result2 = new HashMap<String, Map<Integer, List<Object>>>();
final List<Object> l2 = new ArrayList<Object>();
l2.add("got message1 - l2");
l2.add("got message2 - l2");
l2.add("got message3 - l2");
final Map<String, Map<Integer, List<Object>>> result2 = new HashMap<String, Map<Integer, List<Object>>>();
final List<Object> l2 = new ArrayList<Object>();
l2.add("got message1 - l2");
l2.add("got message2 - l2");
l2.add("got message3 - l2");
final Map<Integer, List<Object>> innerMap2 = new HashMap<Integer, List<Object>>();
innerMap2.put(1, l2);
result1.put("topic2", innerMap2);
final Map<Integer, List<Object>> innerMap2 = new HashMap<Integer, List<Object>>();
innerMap2.put(1, l2);
result1.put("topic2", innerMap2);
Mockito.when(consumerConfiguration1.receive()).thenReturn(result1);
Mockito.when(consumerConfiguration2.receive()).thenReturn(result2);
Mockito.when(consumerConfiguration1.receive()).thenReturn(result1);
Mockito.when(consumerConfiguration2.receive()).thenReturn(result2);
final Message<Map<String, Map<Integer, List<Object>>>> messages = kafkaConsumerContext.receive();
Assert.assertEquals(messages.getPayload().size(), 2);
Assert.assertEquals(messages.getPayload().get("topic1").size(), 1);
Assert.assertEquals(messages.getPayload().get("topic1").get(1).get(0), "got message1 - l1");
Assert.assertEquals(messages.getPayload().get("topic1").get(1).get(1), "got message2 - l1");
final Message<Map<String, Map<Integer, List<Object>>>> messages = kafkaConsumerContext.receive();
Assert.assertEquals(messages.getPayload().size(), 2);
Assert.assertEquals(messages.getPayload().get("topic1").size(), 1);
Assert.assertEquals(messages.getPayload().get("topic1").get(1).get(0), "got message1 - l1");
Assert.assertEquals(messages.getPayload().get("topic1").get(1).get(1), "got message2 - l1");
Assert.assertEquals(messages.getPayload().get("topic2").size(), 1);
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(0), "got message1 - l2");
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(1), "got message2 - l2");
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(2), "got message3 - l2");
}
Assert.assertEquals(messages.getPayload().get("topic2").size(), 1);
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(0), "got message1 - l2");
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(1), "got message2 - l2");
Assert.assertEquals(messages.getPayload().get("topic2").get(1).get(2), "got message3 - l2");
}
}

440
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/support/ProducerConfigurationTests.java
View File

@@ -37,267 +37,271 @@ import java.io.ObjectInputStream;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ProducerConfigurationTests {
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithNonDefaultKeyAndValueEncoders() throws Exception {
final ProducerMetadata<String, String> producerMetadata = new ProducerMetadata<String, String>("test");
producerMetadata.setValueEncoder(new StringEncoder(null));
producerMetadata.setKeyEncoder(new StringEncoder(null));
producerMetadata.setKeyClassType(String.class);
producerMetadata.setValueClassType(String.class);
final Producer<String, String> producer = Mockito.mock(Producer.class);
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithNonDefaultKeyAndValueEncoders() throws Exception {
final ProducerMetadata<String, String> producerMetadata = new ProducerMetadata<String, String>("test");
producerMetadata.setValueEncoder(new StringEncoder(null));
producerMetadata.setKeyEncoder(new StringEncoder(null));
producerMetadata.setKeyClassType(String.class);
producerMetadata.setValueClassType(String.class);
final Producer<String, String> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<String, String> configuration = new ProducerConfiguration<String, String>(producerMetadata, producer);
final ProducerConfiguration<String, String> configuration = new ProducerConfiguration<String, String>(producerMetadata, producer);
final Message<String> message = MessageBuilder.withPayload("test message").
setHeader("messageKey", "key")
.setHeader("topic", "test").build();
final Message<String> message = MessageBuilder.withPayload("test message")
.setHeader("messageKey", "key")
.setHeader("topic", "test")
.build();
configuration.send(message);
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final KeyedMessage capturedKeyMessage = argument.getValue();
Assert.assertEquals(capturedKeyMessage.key(), "key");
Assert.assertEquals(capturedKeyMessage.message(), "test message");
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
Assert.assertEquals(capturedKeyMessage.key(), "key");
Assert.assertEquals(capturedKeyMessage.message(), "test message");
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key/value encoder, but send a serializable object for both key/value
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersAndCustomSerializableKeyAndPayloadObject() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
/**
* User does not set an explicit key/value encoder, but send a serializable object for both key/value
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersAndCustomSerializableKeyAndPayloadObject() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<TestPayload> message = MessageBuilder.withPayload(new TestPayload("part1", "part2")).
setHeader("messageKey", new TestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
final Message<TestPayload> message = MessageBuilder.withPayload(new TestPayload("part1", "part2"))
.setHeader("messageKey", new TestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test")
.build();
configuration.send(message);
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final KeyedMessage capturedKeyMessage = argument.getValue();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final ByteArrayInputStream keyInputStream = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyObjectInputStream = new ObjectInputStream (keyInputStream);
final Object keyObj = keyObjectInputStream.readObject();
final ByteArrayInputStream keyInputStream = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyObjectInputStream = new ObjectInputStream (keyInputStream);
final Object keyObj = keyObjectInputStream.readObject();
final TestKey tk = (TestKey)keyObj;
final TestKey tk = (TestKey)keyObj;
Assert.assertEquals(tk.getKeyPart1(), "compositePart1");
Assert.assertEquals(tk.getKeyPart2(), "compositePart2");
Assert.assertEquals(tk.getKeyPart1(), "compositePart1");
Assert.assertEquals(tk.getKeyPart2(), "compositePart2");
final byte[] messageBytes = (byte[])capturedKeyMessage.message();
final byte[] messageBytes = (byte[])capturedKeyMessage.message();
final ByteArrayInputStream messageInputStream = new ByteArrayInputStream (messageBytes);
final ObjectInputStream messageObjectInputStream = new ObjectInputStream (messageInputStream);
final Object messageObj = messageObjectInputStream.readObject();
final ByteArrayInputStream messageInputStream = new ByteArrayInputStream (messageBytes);
final ObjectInputStream messageObjectInputStream = new ObjectInputStream (messageInputStream);
final Object messageObj = messageObjectInputStream.readObject();
final TestPayload tp = (TestPayload)messageObj;
final TestPayload tp = (TestPayload)messageObj;
Assert.assertEquals(tp.getPart1(), "part1");
Assert.assertEquals(tp.getPart2(), "part2");
Assert.assertEquals(tp.getPart1(), "part1");
Assert.assertEquals(tp.getPart2(), "part2");
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key encoder, but a value encoder, and sends the corresponding data
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyEncoderAndNonDefaultValueEncoderAndCorrespondingData() throws Exception {
final ProducerMetadata<byte[], TestPayload> producerMetadata = new ProducerMetadata<byte[], TestPayload>("test");
final AvroBackedKafkaEncoder<TestPayload> encoder = new AvroBackedKafkaEncoder<TestPayload>(TestPayload.class);
producerMetadata.setValueEncoder(encoder);
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
producerMetadata.setValueClassType(TestPayload.class);
final Producer<byte[], TestPayload> producer = Mockito.mock(Producer.class);
/**
* User does not set an explicit key encoder, but a value encoder, and sends the corresponding data
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyEncoderAndNonDefaultValueEncoderAndCorrespondingData() throws Exception {
final ProducerMetadata<byte[], TestPayload> producerMetadata = new ProducerMetadata<byte[], TestPayload>("test");
final AvroBackedKafkaEncoder<TestPayload> encoder = new AvroBackedKafkaEncoder<TestPayload>(TestPayload.class);
producerMetadata.setValueEncoder(encoder);
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
producerMetadata.setValueClassType(TestPayload.class);
final Producer<byte[], TestPayload> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], TestPayload> configuration = new ProducerConfiguration<byte[], TestPayload>(producerMetadata, producer);
final TestPayload tp = new TestPayload("part1", "part2");
final Message<TestPayload> message = MessageBuilder.withPayload(tp).
setHeader("messageKey", "key")
.setHeader("topic", "test").build();
final ProducerConfiguration<byte[], TestPayload> configuration = new ProducerConfiguration<byte[], TestPayload>(producerMetadata, producer);
final TestPayload tp = new TestPayload("part1", "part2");
final Message<TestPayload> message = MessageBuilder.withPayload(tp)
.setHeader("messageKey", "key")
.setHeader("topic", "test")
.build();
configuration.send(message);
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final KeyedMessage capturedKeyMessage = argument.getValue();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final ByteArrayInputStream keyInputStream = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyObjectInputStream = new ObjectInputStream (keyInputStream);
final Object keyObj = keyObjectInputStream.readObject();
final ByteArrayInputStream keyInputStream = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyObjectInputStream = new ObjectInputStream (keyInputStream);
final Object keyObj = keyObjectInputStream.readObject();
Assert.assertEquals("key", keyObj);
Assert.assertEquals(capturedKeyMessage.message(), tp);
Assert.assertEquals("key", keyObj);
Assert.assertEquals(capturedKeyMessage.message(), tp);
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does set an explicit key encoder, but not a value encoder, and sends the corresponding data
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithNonDefaultKeyEncoderAndDefaultValueEncoderAndCorrespondingData() throws Exception {
final ProducerMetadata<TestKey, byte[]> producerMetadata = new ProducerMetadata<TestKey, byte[]>("test");
final AvroBackedKafkaEncoder<TestKey> encoder = new AvroBackedKafkaEncoder<TestKey>(TestKey.class);
producerMetadata.setKeyEncoder(encoder);
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyClassType(TestKey.class);
final Producer<TestKey, byte[]> producer = Mockito.mock(Producer.class);
/**
* User does set an explicit key encoder, but not a value encoder, and sends the corresponding data
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithNonDefaultKeyEncoderAndDefaultValueEncoderAndCorrespondingData() throws Exception {
final ProducerMetadata<TestKey, byte[]> producerMetadata = new ProducerMetadata<TestKey, byte[]>("test");
final AvroBackedKafkaEncoder<TestKey> encoder = new AvroBackedKafkaEncoder<TestKey>(TestKey.class);
producerMetadata.setKeyEncoder(encoder);
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyClassType(TestKey.class);
final Producer<TestKey, byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<TestKey, byte[]> configuration = new ProducerConfiguration<TestKey, byte[]>(producerMetadata, producer);
final TestKey tk = new TestKey("part1", "part2");
final Message<String> message = MessageBuilder.withPayload("test message").
setHeader("messageKey", tk)
.setHeader("topic", "test").build();
final ProducerConfiguration<TestKey, byte[]> configuration = new ProducerConfiguration<TestKey, byte[]>(producerMetadata, producer);
final TestKey tk = new TestKey("part1", "part2");
final Message<String> message = MessageBuilder.withPayload("test message").
setHeader("messageKey", tk)
.setHeader("topic", "test").build();
configuration.send(message);
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final KeyedMessage capturedKeyMessage = argument.getValue();
Assert.assertEquals(capturedKeyMessage.key(), tk);
Assert.assertEquals(capturedKeyMessage.key(), tk);
final byte[] payloadBytes = (byte[])capturedKeyMessage.message();
final byte[] payloadBytes = (byte[])capturedKeyMessage.message();
final ByteArrayInputStream payloadBis = new ByteArrayInputStream (payloadBytes);
final ObjectInputStream payloadOis = new ObjectInputStream (payloadBis);
final Object payloadObj = payloadOis.readObject();
final ByteArrayInputStream payloadBis = new ByteArrayInputStream (payloadBytes);
final ObjectInputStream payloadOis = new ObjectInputStream (payloadBis);
final Object payloadObj = payloadOis.readObject();
Assert.assertEquals("test message", payloadObj);
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key/value encoder, but send a serializable String key/value pair
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersAndStringKeyAndValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<String> message = MessageBuilder.withPayload("test message").
setHeader("messageKey", "key")
.setHeader("topic", "test").build();
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final ByteArrayInputStream keyBis = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyOis = new ObjectInputStream (keyBis);
final Object keyObj = keyOis.readObject();
Assert.assertEquals("key", keyObj);
final byte[] payloadBytes = (byte[])capturedKeyMessage.message();
final ByteArrayInputStream payloadBis = new ByteArrayInputStream (payloadBytes);
final ObjectInputStream payloadOis = new ObjectInputStream (payloadBis);
final Object payloadObj = payloadOis.readObject();
Assert.assertEquals("test message", payloadObj);
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key/value encoder, but send non-serializable object for both key/value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButNonSerializableKeyAndValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<NonSerializableTestPayload> message = MessageBuilder.withPayload(new NonSerializableTestPayload("part1", "part2")).
setHeader("messageKey", new NonSerializableTestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
/**
* User does not set an explicit key/value encoder, but send non-serializable key and serializable value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButNonSerializableKeyAndSerializableValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<TestPayload> message = MessageBuilder.withPayload(new TestPayload("part1", "part2")).
setHeader("messageKey", new NonSerializableTestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
/**
* User does not set an explicit key/value encoder, but send serializable key and non-serializable value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButSerializableKeyAndNonSerializableValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<NonSerializableTestPayload> message = MessageBuilder.withPayload(new NonSerializableTestPayload("part1", "part2")).
setHeader("messageKey", new TestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
Assert.assertEquals("test message", payloadObj);
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key/value encoder, but send a serializable String key/value pair
*/
@Test
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersAndStringKeyAndValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<String> message = MessageBuilder.withPayload("test message").
setHeader("messageKey", "key")
.setHeader("topic", "test").build();
configuration.send(message);
Mockito.verify(producer, Mockito.times(1)).send(Mockito.any(KeyedMessage.class));
final ArgumentCaptor<KeyedMessage> argument = ArgumentCaptor.forClass(KeyedMessage.class);
Mockito.verify(producer).send(argument.capture());
final KeyedMessage capturedKeyMessage = argument.getValue();
final byte[] keyBytes = (byte[])capturedKeyMessage.key();
final ByteArrayInputStream keyBis = new ByteArrayInputStream (keyBytes);
final ObjectInputStream keyOis = new ObjectInputStream (keyBis);
final Object keyObj = keyOis.readObject();
Assert.assertEquals("key", keyObj);
final byte[] payloadBytes = (byte[])capturedKeyMessage.message();
final ByteArrayInputStream payloadBis = new ByteArrayInputStream (payloadBytes);
final ObjectInputStream payloadOis = new ObjectInputStream (payloadBis);
final Object payloadObj = payloadOis.readObject();
Assert.assertEquals("test message", payloadObj);
Assert.assertEquals(capturedKeyMessage.topic(), "test");
}
/**
* User does not set an explicit key/value encoder, but send non-serializable object for both key/value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButNonSerializableKeyAndValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<NonSerializableTestPayload> message = MessageBuilder.withPayload(new NonSerializableTestPayload("part1", "part2")).
setHeader("messageKey", new NonSerializableTestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
/**
* User does not set an explicit key/value encoder, but send non-serializable key and serializable value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButNonSerializableKeyAndSerializableValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<TestPayload> message = MessageBuilder.withPayload(new TestPayload("part1", "part2")).
setHeader("messageKey", new NonSerializableTestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
/**
* User does not set an explicit key/value encoder, but send serializable key and non-serializable value
*/
@Test(expected = NotSerializableException.class)
@SuppressWarnings("unchecked")
public void testSendMessageWithDefaultKeyAndValueEncodersButSerializableKeyAndNonSerializableValue() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setValueEncoder(new DefaultEncoder(null));
producerMetadata.setKeyEncoder(new DefaultEncoder(null));
final Producer<byte[], byte[]> producer = Mockito.mock(Producer.class);
final ProducerConfiguration<byte[], byte[]> configuration = new ProducerConfiguration<byte[], byte[]>(producerMetadata, producer);
final Message<NonSerializableTestPayload> message = MessageBuilder.withPayload(new NonSerializableTestPayload("part1", "part2")).
setHeader("messageKey", new TestKey("compositePart1", "compositePart2"))
.setHeader("topic", "test").build();
configuration.send(message);
}
}

63
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/support/ProducerFactoryBeanTests.java
View File

@@ -15,49 +15,50 @@
*/
package org.springframework.integration.kafka.support;
import junit.framework.Assert;
import org.junit.Assert;
import kafka.javaapi.producer.Producer;
import org.junit.Test;
import org.mockito.Mockito;
/**
* @author Soby Chacko
* @since 0.5
*/
public class ProducerFactoryBeanTests {
@Test
public void createProducerWithDefaultMetadata() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
final ProducerMetadata<byte[], byte[]> tm = Mockito.spy(producerMetadata);
final ProducerFactoryBean<byte[], byte[]> producerFactoryBean = new ProducerFactoryBean<byte[], byte[]>(tm, "localhost:9092");
final Producer producer = producerFactoryBean.getObject();
@Test
public void createProducerWithDefaultMetadata() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
final ProducerMetadata<byte[], byte[]> tm = Mockito.spy(producerMetadata);
final ProducerFactoryBean<byte[], byte[]> producerFactoryBean = new ProducerFactoryBean<byte[], byte[]>(tm, "localhost:9092");
final Producer producer = producerFactoryBean.getObject();
Assert.assertTrue(producer != null);
Assert.assertTrue(producer != null);
Mockito.verify(tm, Mockito.times(1)).getPartitioner();
Mockito.verify(tm, Mockito.times(1)).getCompressionCodec();
Mockito.verify(tm, Mockito.times(1)).getValueEncoder();
Mockito.verify(tm, Mockito.times(1)).getKeyEncoder();
Mockito.verify(tm, Mockito.times(1)).isAsync();
Mockito.verify(tm, Mockito.times(0)).getBatchNumMessages();
}
Mockito.verify(tm, Mockito.times(1)).getPartitioner();
Mockito.verify(tm, Mockito.times(1)).getCompressionCodec();
Mockito.verify(tm, Mockito.times(1)).getValueEncoder();
Mockito.verify(tm, Mockito.times(1)).getKeyEncoder();
Mockito.verify(tm, Mockito.times(1)).isAsync();
Mockito.verify(tm, Mockito.times(0)).getBatchNumMessages();
}
@Test
public void createProducerWithAsyncFeatures() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setAsync(true);
producerMetadata.setBatchNumMessages("300");
final ProducerMetadata<byte[], byte[]> tm = Mockito.spy(producerMetadata);
final ProducerFactoryBean<byte[], byte[]> producerFactoryBean = new ProducerFactoryBean<byte[], byte[]>(tm, "localhost:9092");
final Producer producer = producerFactoryBean.getObject();
@Test
public void createProducerWithAsyncFeatures() throws Exception {
final ProducerMetadata<byte[], byte[]> producerMetadata = new ProducerMetadata<byte[], byte[]>("test");
producerMetadata.setAsync(true);
producerMetadata.setBatchNumMessages("300");
final ProducerMetadata<byte[], byte[]> tm = Mockito.spy(producerMetadata);
final ProducerFactoryBean<byte[], byte[]> producerFactoryBean = new ProducerFactoryBean<byte[], byte[]>(tm, "localhost:9092");
final Producer producer = producerFactoryBean.getObject();
Assert.assertTrue(producer != null);
Assert.assertTrue(producer != null);
Mockito.verify(tm, Mockito.times(1)).getPartitioner();
Mockito.verify(tm, Mockito.times(1)).getCompressionCodec();
Mockito.verify(tm, Mockito.times(1)).getValueEncoder();
Mockito.verify(tm, Mockito.times(1)).getKeyEncoder();
Mockito.verify(tm, Mockito.times(1)).isAsync();
Mockito.verify(tm, Mockito.times(2)).getBatchNumMessages();
}
Mockito.verify(tm, Mockito.times(1)).getPartitioner();
Mockito.verify(tm, Mockito.times(1)).getCompressionCodec();
Mockito.verify(tm, Mockito.times(1)).getValueEncoder();
Mockito.verify(tm, Mockito.times(1)).getKeyEncoder();
Mockito.verify(tm, Mockito.times(1)).isAsync();
Mockito.verify(tm, Mockito.times(2)).getBatchNumMessages();
}
}

28
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/test/utils/NonSerializableTestKey.java
View File

@@ -15,21 +15,25 @@
*/
package org.springframework.integration.kafka.test.utils;
/**
* @author Soby Chacko
* @since 0.5
*/
public class NonSerializableTestKey {
private final String keyPart1;
private final String keyPart2;
private final String keyPart1;
private final String keyPart2;
public NonSerializableTestKey(final String keyPart1, final String keyPart2) {
this.keyPart1 = keyPart1;
this.keyPart2 = keyPart2;
}
public NonSerializableTestKey(final String keyPart1, final String keyPart2) {
this.keyPart1 = keyPart1;
this.keyPart2 = keyPart2;
}
public String getKeyPart1() {
return keyPart1;
}
public String getKeyPart1() {
return keyPart1;
}
public String getKeyPart2() {
return keyPart2;
}
public String getKeyPart2() {
return keyPart2;
}
}

28
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/test/utils/NonSerializableTestPayload.java
View File

@@ -15,20 +15,24 @@
*/
package org.springframework.integration.kafka.test.utils;
/**
* @author Soby Chacko
* @since 0.5
*/
public class NonSerializableTestPayload {
private final String part1;
private final String part2;
private final String part1;
private final String part2;
public NonSerializableTestPayload(final String part1, final String part2) {
this.part1 = part1;
this.part2 = part2;
}
public NonSerializableTestPayload(final String part1, final String part2) {
this.part1 = part1;
this.part2 = part2;
}
public String getPart1() {
return part1;
}
public String getPart1() {
return part1;
}
public String getPart2() {
return part2;
}
public String getPart2() {
return part2;
}
}

30
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/test/utils/TestKey.java
View File

@@ -17,22 +17,26 @@ package org.springframework.integration.kafka.test.utils;
import java.io.Serializable;
/**
* @author Soby Chacko
* @since 0.5
*/
public class TestKey implements Serializable {
private static final long serialVersionUID = -6415387283545560656L;
private static final long serialVersionUID = -6415387283545560656L;
private final String keyPart1;
private final String keyPart2;
private final String keyPart1;
private final String keyPart2;
public TestKey(final String keyPart1, final String keyPart2) {
this.keyPart1 = keyPart1;
this.keyPart2 = keyPart2;
}
public TestKey(final String keyPart1, final String keyPart2) {
this.keyPart1 = keyPart1;
this.keyPart2 = keyPart2;
}
public String getKeyPart1() {
return keyPart1;
}
public String getKeyPart1() {
return keyPart1;
}
public String getKeyPart2() {
return keyPart2;
}
public String getKeyPart2() {
return keyPart2;
}
}

32
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/test/utils/TestObject.java
View File

@@ -15,24 +15,28 @@
*/
package org.springframework.integration.kafka.test.utils;
/**
* @author Soby Chacko
* @since 0.5
*/
public class TestObject {
public String testData1;
public int testData2;
public String testData1;
public int testData2;
public String getTestData1() {
return testData1;
}
public String getTestData1() {
return testData1;
}
public void setTestData1(final String testData1) {
this.testData1 = testData1;
}
public void setTestData1(final String testData1) {
this.testData1 = testData1;
}
public int getTestData2() {
return testData2;
}
public int getTestData2() {
return testData2;
}
public void setTestData2(final int testData2) {
this.testData2 = testData2;
}
public void setTestData2(final int testData2) {
this.testData2 = testData2;
}
}

30
spring-integration-kafka/src/test/java/org/springframework/integration/kafka/test/utils/TestPayload.java
View File

@@ -17,22 +17,26 @@ package org.springframework.integration.kafka.test.utils;
import java.io.Serializable;
/**
* @author Soby Chacko
* @since 0.5
*/
public class TestPayload implements Serializable {
private static final long serialVersionUID = -8560378224929007403L;
private static final long serialVersionUID = -8560378224929007403L;
private final String part1;
private final String part2;
private final String part1;
private final String part2;
public TestPayload(final String part1, final String part2){
this.part1 = part1;
this.part2 = part2;
}
public TestPayload(final String part1, final String part2){
this.part1 = part1;
this.part2 = part2;
}
public String getPart1() {
return part1;
}
public String getPart1() {
return part1;
}
public String getPart2() {
return part2;
}
public String getPart2() {
return part2;
}
}