Spring Cloud Stream with kafka binder rely on Spring-kafka. So the former has all functionalities supported by later, but the former will be more heavyweight. Below are some points help you make the choice:

1. If you might change kafka into another message middleware in the future, then Spring Cloud stream should be your choice since it hides implementation details of kafka.
2. If you want to integrate other message middle with kafka, then you should go for Spring Cloud stream, since its selling point is to make such integration easy.
3. If you want to enjoy the simplicity and not accept performance overhead, then choose spring-kafka
4. If you plan to migrate to public cloud service such as AWS Kensis, Azure EventHub, then use spring cloud stream which is part of spring cloud family. 

Use *Spring Cloud Stream* when you are creating a system where *one* channel is used for input does some processing and sends it to *one* output channel.  In other words it is more of an RPC system to replace say RESTful API calls.

If you plan to do an event sourcing system, use Spring-Kafka where you can publish and subscribe to the same stream.  This is something that Spring Cloud Stream does not allow you do do easily as it disallows the following

```
public interface EventStream {
    String STREAM = &quot;event_stream&quot;;

    @Output(EventStream.STREAM)
    MessageChannel publisher();

    @Input(EventStream.STREAM)
    SubscribableChannel stream();
}
```

A few things that *Spring Cloud Stream* helps you avoid doing are:

* setting up the serializers and deserializers

I find this relatively known GitHub repository, where they considered `launchSettings.json` file (which is used by Visual Studio 2017 for .Net Core projects) is to be **ignored**.

 https://github.com/github/gitignore/blob/master/VisualStudio.gitignore

Why should it be ignored? I used always in the company I work in to commit it, I am curious to know if there is any reason to ignore it.

Should I ignore the launchSettings.json file from being committed in Git?

I have this regex of mine that will check the string if it contains link or url `(i.e. https://eslint.org/docs/rules/no-useless-escape)`. Using this regex `/(\b(https?|ftp|file):\/\/[-A-Z0-9+&amp;@#\/%?=~_|!:,.;]*[-A-Z0-9+&amp;@#\/%=~_|])/ig`, I&#39;ve encountered and error while running my test cases in react about `Unnecessary escape character: \/                    no-useless-escape`. How to disable this eslint-error in order for me to proceed with my test case and use the regex.

Appreciate for any help!

Disable Unnecessary escape character: \/ no-useless-escape

Using Kafka as a messaging system in a microservice architecture what are the benefits of using spring-kafka vs. spring-cloud-stream + spring-cloud-starter-stream-kafka ?

The spring cloud stream framework supports more messaging systems and has therefore a more modular design. But what about the functionality ? Is there a gap between the functionality of spring-kafka and spring-cloud-stream + spring-cloud-starter-stream-kafka ? 
Which API is better designed?

Looking forward to read about your opinions

Spring-Kafka vs. Spring-Cloud-Stream (Kafka)

Using Kafka as a messaging system in a microservice architecture what are the benefits of using spring-kafka vs. spring-cloud-stream + spring-cloud-starter-stream-kafka ?
The spring cloud stream framework supports more messaging systems and has therefore a more modular design. But what about the functionality ? Is there a gap between the functionality of spring-kafka and spring-cloud-stream + spring-cloud-starter-stream-kafka ?
Which API is better designed?
Looking forward to read about your opinions

Whenever I see a blog post related to Spring testing I see either of these classes but do not understand the real difference:
 

    @RunWith(SpringRunner.class)
    @RunWith(SpringJUnit4ClassRunner.class)



What is the difference between SpringJUnit4ClassRunner and SpringRunner

I am using `Spring Data JPA` and `Spring Boot`. The layout of the application is this

    main
        +-- java
            +-- com/lapots/game/monolith
                +-- repository/relational
                    +--RelationalPlayerRepository.java
                +-- web
                    +--GrandJourneyMonolithApplication.java
                    +-- config
                        +-- RelationalDBConfiguration.java
    test
        +-- java
            +-- com/lapots/game/monolith
                +-- repository/relational
                    +-- RelationalPlayerRepositoryTests.java
                +-- web
                    +-- GrandJourneyMonolithApplicationTests.java


The repository for my object looks like this

    public interface RelationalPlayerRepository extends JpaRepository&lt;Player, Long&gt; {
    }

Additionally for the repositories I provided a configuration

    @Configuration
    @EnableJpaRepositories(basePackages = &quot;com.lapots.game.monolith.repository.relational&quot;)
    @EntityScan(&quot;com.lapots.game.monolith.domain&quot;)
    public class RelationalDBConfiguration {
    }

My main application looks like this

    @SpringBootApplication
    @ComponentScan(&quot;com.lapots.game.monolith&quot;)
    public class GrandJourneyMonolithApplication {

        @Autowired
        private RelationalPlayerRepository relationalPlayerRepository;

        public static void main(String[] args) {
            SpringApplication.run(GrandJourneyMonolithApplication.class, args);
        }

        @Bean
        public CommandLineRunner initPlayers() {
            return (args) -&gt; {
                Player p = new Player();
                p.setLevel(10);
                p.setName(&quot;Master1909&quot;);
                p.setClazz(&quot;warrior&quot;);

                relationalPlayerRepository.save(p);
            };
        }
    }
    
Test for application looks like this

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class GrandJourneyMonolithApplicationTests {

        @Test
        public void contextLoads() {
        }

    }
    
The test for repository looks like this

    @RunWith(SpringRunner.class)
    @DataJpaTest
    public class RelationalPlayerRepositoryTests {

        @Autowired
        private TestEntityManager entityManager;

        @Autowired
        private RelationalPlayerRepository repository;

        @Test
        public void testBasic() {
            Player expected = createPlayer(&quot;Master12&quot;, &quot;warrior&quot;, 10);
            this.entityManager.persist(expected);
            List&lt;Player&gt; players = repository.findAll();
            assertThat(repository.findAll()).isNotEmpty();
            assertEquals(expected, players.get(0));
        }

        private Player createPlayer(String name, String clazz, int level) {
            Player p = new Player();
            p.setId(1L);
            p.setName(name);
            p.setClazz(clazz);
            p.setLevel(level);
            return p;
        }
    }

But when I try to run the tests I get the error

    Tests run: 1, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 0.041 sec &lt;&lt;&lt; FAILURE! - in com.lapots.game.monolith.repository.relational.RelationalPlayerRepositoryTests
    initializationError(com.lapots.game.monolith.repository.relational.RelationalPlayerRepositoryTests)  Time elapsed: 0.006 sec  &lt;&lt;&lt; ERROR!
    java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=...) with your test
    at org.springframework.util.Assert.state(Assert.java:70)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.getOrFindConfigurationClasses(SpringBootTestContextBootstrapper.java:202)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.processMergedContextConfiguration(SpringBootTestContextBootstrapper.java:137)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildMergedContextConfiguration(AbstractTestContextBootstrapper.java:409)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildDefaultMergedContextConfiguration(AbstractTestContextBootstrapper.java:323)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildMergedContextConfiguration(AbstractTestContextBootstrapper.java:277)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildTestContext(AbstractTestContextBootstrapper.java:112)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.buildTestContext(SpringBootTestContextBootstrapper.java:82)
    at org.springframework.test.context.TestContextManager.&lt;init&gt;(TestContextManager.java:120)
    at org.springframework.test.context.TestContextManager.&lt;init&gt;(TestContextManager.java:105)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTestContextManager(SpringJUnit4ClassRunner.java:152)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.&lt;init&gt;(SpringJUnit4ClassRunner.java:143)
    at org.springframework.test.context.junit4.SpringRunner.&lt;init&gt;(SpringRunner.java:49)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at org.junit.internal.builders.AnnotatedBuilder.buildRunner(AnnotatedBuilder.java:104)
    at org.junit.internal.builders.AnnotatedBuilder.runnerForClass(AnnotatedBuilder.java:86)
    at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    at org.junit.internal.builders.AllDefaultPossibilitiesBuilder.runnerForClass(AllDefaultPossibilitiesBuilder.java:26)
    at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    at org.junit.internal.requests.ClassRequest.getRunner(ClassRequest.java:33)
    at org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:283)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeWithRerun(JUnit4Provider.java:173)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:153)
    at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:128)
    at org.apache.maven.surefire.booter.ForkedBooter.invokeProviderInSameClassLoader(ForkedBooter.java:203)
    at org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:155)
    at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:103)

What is the problem?
Domain `Player` loooks like this

    @Data
    @Entity
    @Table(schema = &quot;app&quot;, name = &quot;players&quot;)
    public class Player {
        @Id
        @GeneratedValue
        private Long id;

        @Transient
        Set&lt;Player&gt; comrades;

        @Column(unique = true)
        private String name;

        private int level;

        @Column(name = &quot;class&quot;)
        private String clazz;
    }

Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=...) with your test

I just migrate to spring mvc version `5.0.1.RELEASE` but suddenly in eclipse STS WebMvcConfigurerAdapter is marked as deprecated

    public class MvcConfig extends WebMvcConfigurerAdapter {
      @Override
      	public void addResourceHandlers(ResourceHandlerRegistry registry) {
      		registry.addResourceHandler(&quot;/resources/**&quot;).addResourceLocations(&quot;/resources/&quot;);
      		// to serve static .html pages...
      		registry.addResourceHandler(&quot;/static/**&quot;).addResourceLocations(&quot;/resources/static/&quot;);
      	}
      ....
      }

How can i remove this!

The type WebMvcConfigurerAdapter is deprecated

I have Spring Boot application version 1.5.x, which uses `org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory`, I&#39;m trying to migrate it to Spring Boot 2, but the app does not compile, although a have a dependency to `org.springframework.boot:spring-boot-starter-tomcat`. The compiler issues the error below:

    error: package org.springframework.boot.context.embedded.tomcat

TomcatEmbeddedServletContainerFactory is missing in Spring Boot 2

As per spring 5:

&gt;WebClient is an interface representing the main entry point for performing web requests.
&gt;
&gt;It has been created as a part of the Spring Web Reactive module and will be replacing the classic RestTemplate in these scenarios. The new client is a reactive, non-blocking solution that works over the HTTP/1.1 protocol

Does that mean, we need to recode for the old applications using RestTemplate if we want to upgrade to Spring 5?

Or there is some workaround to work with RestTemplate in Spring 5?


WebClient vs RestTemplate

We have a micro-services architecture, with Kafka used as the communication mechanism between the services.  Some of the services have their own databases.  Say the user makes a call to Service A, which should result in a record (or set of records) being created in that service’s database.  Additionally, this event should be reported to other services, as an item on a Kafka topic.  What is the best way of ensuring that the database record(s) are only written if the Kafka topic is successfully updated (essentially creating a distributed transaction around the database update and the Kafka update)?

We are thinking of using [spring-kafka][1] (in a Spring Boot WebFlux service), and I can see that it has a [KafkaTransactionManager][2], but from what I understand this is more about Kafka transactions themselves (ensuring consistency across the Kafka producers and consumers), rather than synchronising transactions across two systems (see [here][3]: “Kafka doesn&#39;t support XA and you have to deal with the possibility that the DB tx might commit while the Kafka tx rolls back.”).  Additionally, I think this class relies on Spring’s transaction framework which, at least as far as I currently understand, is thread-bound, and won’t work if using a reactive approach (e.g. WebFlux) where different parts of an operation may execute on different threads.  (We are using [reactive-pg-client][4], so are manually handling transactions, rather than using Spring’s framework.)

Some options I can think of:

1. Don’t write the data to the database: only write it to Kafka.  Then use a consumer (in Service A) to update the database.  This seems like it might not be the most efficient, and will have problems in that the service which the user called cannot immediately see the database changes it should have just created.
2. Don’t write directly to Kafka: write to the database only, and use something like [Debezium][5] to report the change to Kafka.  The problem here is that the changes are based on individual database records, whereas the business significant event to store in Kafka might involve a combination of data from multiple tables.
3. Write to the database first (if that fails, do nothing and just throw the exception).  Then, when writing to Kafka, assume that the write might fail.  Use the built-in auto-retry functionality to get it to keep trying for a while.  If that eventually completely fails, try to write to a dead letter queue and create some sort of manual mechanism for admins to sort it out.  And if writing to the DLQ fails (i.e. Kafka is completely down), just log it some other way (e.g. to the database), and again create some sort of manual mechanism for admins to sort it out.

Anyone got any thoughts or advice on the above, or able to correct any mistakes in my assumptions above?

Thanks in advance!


  [1]: https://spring.io/projects/spring-kafka
  [2]: https://docs.spring.io/spring-kafka/api/org/springframework/kafka/transaction/KafkaTransactionManager.html
  [3]: https://stackoverflow.com/questions/47354521/transaction-synchronization-in-spring-kafka
  [4]: https://github.com/reactiverse/reactive-pg-client
  [5]: https://debezium.io/

Synchronising transactions between database and Kafka producer

Nowadays in microservice world, i’m seeing alot of design in my workplace that uses kafka messaging when you can achieve similar results using rest api calls between microservices. Technically you can stop using rest api calls altogether and instead use kafka messaging. I really want to know the best practice, pros and cons, when to use api calls between microsevices, when to use kafka messaging. 


Lets put a real life example:

I have an inventory service and a vendor service. Everyday vendor service calls the vendor API to get new items and these need to be moved into inventory service. The number of items can be up to 10,000 objects.

For this use case, is it better to :

1. After getting new data from vendor API, call REST API of inventory service to store the new items.

2. After getting new data from vendor API, send them as message to a kafka topic, to be consumed by inventory service 

Which way would you choose and what is the consideration

Content Type	Original Author	Original Content on Stackoverflow
Question	Eike Behrends	View Question on Stackoverflow
Solution 1 - Spring	Warren Zhu	View Answer on Stackoverflow
Solution 2 - Spring	Archimedes Trajano	View Answer on Stackoverflow

Spring-Kafka vs. Spring-Cloud-Stream (Kafka)

Spring Problem Overview

Spring Solutions

Solution 1 - Spring

Solution 2 - Spring

Disable Unnecessary escape character: \/ no-useless-escape

Should I ignore the launchSettings.json file from being committed in Git?

Attributions