The project is using SonarCloud static code analysis. The latest results are showing that it has found several blockers and critical severity code smells (major, minor, and info level we ignore). In this task, those are fixed or marked as false positives. To mark false positives, SuppressWarnings annotation should be used in code as explained in the linked documentation.

Links: Blocker and critical severity code smells in SonarCloud Sonar false positives

Note: When Submitting a PR please provide a hyperlinked list of all the issues that you are issuing a fix for. See this example

We want to present the design patterns better as the current does not reach its goal of explaining how the pattern works in a simplest possible way. I'm hugely inspired by https://github.com/kamranahmedse/design-patterns-for-humans repository.

Let's do this by adding 'Explanation' section to the patterns' README.md file. For an example see http://java-design-patterns.com/patterns/bridge/.

Let's track the issue progress here with the following checklist that indicates the patterns where explanation section is already available.

• [x] abstract-document
• [x] abstract-factory
• [x] active-object
• [x] acyclic-visitor
• [x] adapter
• [x] aggregator-microservices
• [x] ambassador
• [x] api-gateway
• [x] arrange-act-assert
• [x] async-method-invocation
• [x] balking
• [x] bridge
• [x] builder
• [x] business-delegate
• [x] bytecode
• [x] caching
• [x] callback
• [x] chain
• [x] circuit-breaker
• [x] cloud-static-content-hosting
• [ ] collection-pipeline
• [ ] combinator
• [x] command
• [ ] commander
• [x] composite
• [x] composite-entity
• [x] converter
• [ ] cqrs
• [x] dao
• [ ] data-bus
• [ ] data-locality
• [ ] data-mapper
• [x] data-transfer-object
• [x] decorator
• [ ] delegation
• [x] dependency-injection
• [ ] dirty-flag
• [ ] double-buffer
• [ ] double-checked-locking
• [ ] double-dispatch
• [ ] eip-aggregator
• [ ] eip-message-channel
• [ ] eip-publish-subscribe
• [ ] eip-splitter
• [ ] eip-wire-tap
• [ ] event-aggregator
• [ ] event-based-asynchronous
• [ ] event-driven-architecture
• [ ] event-queue
• [ ] event-sourcing
• [x] execute-around
• [ ] extension-objects
• [x] facade
• [x] factory
• [ ] factory-kit
• [x] factory-method
• [ ] fan-out-fan-in
• [ ] feature-toggle
• [x] filterer
• [x] fluentinterface
• [ ] flux
• [x] flyweight
• [ ] front-controller
• [x] game-loop
• [ ] guarded-suspension
• [ ] half-sync-half-async
• [ ] hexagonal
• [ ] intercepting-filter
• [x] interpreter
• [x] iterator
• [x] layers
• [ ] lazy-loading
• [ ] leader-election
• [ ] leader-followers
• [x] lockable-object
• [ ] marker-interface
• [ ] master-worker
• [x] mediator
• [x] memento
• [ ] model-view-controller
• [ ] model-view-presenter
• [x] model-view-viewmodel
• [ ] module
• [ ] monad
• [ ] monostate
• [x] multiton
• [ ] mute-idiom
• [ ] naked-objects
• [x] null-object
• [ ] object-mother
• [x] object-pool
• [x] observer
• [ ] page-object
• [x] parameter-object
• [ ] partial-response
• [x] pipeline
• [x] poison-pill
• [x] presentation-model
• [x] priority-queue
• [x] private-class-data
• [ ] producer-consumer
• [x] promise
• [ ] property
• [x] prototype
• [x] proxy
• [ ] queue-based-load-leveling
• [ ] reactor
• [ ] reader-writer-lock
• [x] registry
• [x] repository
• [ ] resource-acquisition-is-initialization
• [x] retry
• [ ] role-object
• [ ] saga
• [ ] semaphore
• [x] separated-interface
• [ ] servant
• [ ] serverless
• [ ] service-layer
• [ ] service-locator
• [ ] sharding
• [x] singleton
• [x] spatial-partition
• [x] special-case
• [x] specification
• [x] state
• [ ] step-builder
• [ ] strangler
• [x] strategy
• [ ] subclass-sandbox
• [x] table-module
• [x] template-method
• [x] thread-pool
• [x] throttling
• [ ] thread-local-storage
• [x] tolerant-reader
• [x] trampoline
• [x] transaction-script
• [x] twin
• [ ] type-object
• [x] unit-of-work
• [ ] update-method
• [ ] value-object
• [x] version-number
• [x] visitor

#I think this is a very nice repo to learn java design patterns.But as I see, there still no translations for other languages.So I want to join this repo and translate this into chinese if It's possible.(I' m a Chinese)

In the pattern template there is section for Tutorials. Here we should list tutorials explaining the pattern. One example is here http://java-design-patterns.com/patterns/hexagonal/.

In issue https://github.com/iluwatar/java-design-patterns/issues/1016 we switched using Checkstyle's builtin google_checks.xml. The new ruleset finds over 6k warnings. In this issue we try fix those gradually, one pattern at a time. If you want to help, please comment on the issue which patterns will you be working on. We will follow the progress using the following table.

[x] abstract-document [x] abstract-factory [x] acyclic-visitor [x] adapter [x] aggregator-microservices [x] ambassador [x] api-gateway [x] async-method-invocation [x] balking [x] bridge [x] builder [x] business-delegate [x] bytecode [x] caching [x] callback [x] chain [x] circuit breaker [x] collection-pipeline [x] command [x] commander [x] composite [x] converter [x] cqrs [x] dao [x] data-bus [x] data-locality [x] data-mapper [x] data-transfer-object [x] decorator [x] delegation [x] dependency-injection [x] dirty-flag [x] double-checked-locking [x] double-dispatch [x] eip-aggregator [x] eip-message-channel [x] eip-publish-subscribe [x] eip-splitter [x] eip-wire-tap [x] event-aggregator [x] event-asynchronous [x] event-driven-architecture [x] event-queue [x] event-sourcing [x] execute-around [x] extension-objects [x] facade [x] factory-kit [x] factory-method [x] feature-toggle [x] fluentinterface [x] flux [x] flyweight [x] front-controller [x] guarded-suspension [x] half-sync-half-async [x] hexagonal [x] intercepting-filter [x] interpreter [x] iterator [x] layers [x] lazy-loading [x] leader-election [x] marker [x] master-worker-pattern [x] mediator [x] memento [x] model-view-controller [x] model-view-presenter [x] module [x] monad [x] monostate [x] multiton [x] mute-idiom [x] mutex [x] naked-objects [x] null-object [x] object-mother [x] object-pool [x] observer [x] page-object [x] partial-response [x] pipeline [x] poison-pill [x] priority-queue [x] private-class-data [x] producer-consumer [x] promise [x] property [x] prototype [x] proxy [x] queue-load-leveling [x] reactor [x] reader-writer-lock [x] repository [x] resource-acquisition-is-initialization [x] retry [x] semaphore [x] servant [x] serverless [x] service-layer [x] service-locator [x] singleton [x] spatial-partition [x] specification [x] state [x] step-builder [x] strategy [x] template-method [x] thread-pool [x] throttling [x] tls [x] tolerant-reader [x] trampoline [x] twin [x] typeobjectpattern [x] unit-of-work [x] value-object [x] visitor

Links: https://github.com/checkstyle/checkstyle/blob/master/src/main/resources/google_checks.xml https://google.github.io/styleguide/javaguide.html

@iluwatar What do u think if we create presentations for these nice collections of design patterns. Either one for each for one for all. Something based on impress.js or similar would be great I think. Happy to contribute. Kiitos

This task is part of the Java 11 transition plan https://github.com/iluwatar/java-design-patterns/wiki/16.-Java-11-Transition

This is a refactoring ticket where we start to utilize new Java 11 functionality.

1. Collecting to unmodifiable collections is possible using the new Collector for Streams operations to put the results into an immutable collection (see https://www.infoq.com/articles/upgrading-java-8-to-12/)

2. Predicate::not provides an easy way to negate predicate lambdas or method references, again reducing the boilerplate in our code (see https://www.infoq.com/articles/upgrading-java-8-to-12/)

3. New methods on Optional give even more options for coding in a functional style when using an Optional instead of having to use clumsy if statements (see https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

4. Streams have new methods ofNullable, dropWhile, takeWhile (see https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

5. String has new helper methods (see https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

6. InputStream finally gets a super useful method to transfer data to an OutputStream (see https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

7. Convenience Factory Methods for Collections make it significantly easier to create collections like lists, maps and sets (see https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

It's a huge task to do this for all the patterns at once so it is possible to create pull requests for individual patterns. This way we can complete the task gradually. The following checklist tracks which patterns have already been refactored.

[x] abstract-document [x] abstract-factory [x] acyclic-visitor [x] adapter [x] aggregator-microservices [x] ambassador [x] api-gateway [x] async-method-invocation [x] balking [x] bridge [x] builder [x] business-delegate [x] bytecode [x] caching [x] callback [x] chain [x] circuit-breaker [x] collection-pipeline [x] command [x] commander [x] composite [x] converter [x] cqrs [x] dao [x] data-bus [x] data-locality [x] data-mapper [x] data-transfer-object [x] decorator [x] delegation [x] dependency-injection [x] dirty-flag [x] double-checked-locking [x] double-dispatch [x] eip-aggregator [x] eip-message-channel [x] eip-publish-subscribe [x] eip-splitter [x] eip-wire-tap [x] event-aggregator [x] event-asynchronous [x] event-driven-architecture [x] event-queue [x] event-sourcing [x] execute-around [x] extension-objects [x] facade [x] factory-kit [x] factory-method [x] faq.md [x] feature-toggle [x] fluentinterface [x] flux [x] flyweight [x] front-controller [x] guarded-suspension [x] half-sync-half-async [x] hexagonal [x] intercepting-filter [x] interpreter [x] iterator [x] layers [x] lazy-loading [x] leader-election [x] marker [x] master-worker-pattern [x] mediator [x] memento [x] model-view-controller [x] model-view-presenter [x] module [x] monad [x] monostate [x] multiton [x] mute-idiom [x] mutex [x] naked-objects [x] null-object [x] object-mother [x] object-pool [x] observer [x] page-object [x] partial-response [x] pipeline [x] poison-pill [x] priority-queue [x] private-class-data [x] producer-consumer [x] promise [x] property [x] prototype [x] proxy [x] queue-load-leveling [x] reactor [x] reader-writer-lock [x] repository [x] resource-acquisition-is-initialization [x] retry [x] semaphore [x] servant [x] serverless [x] service-layer [x] service-locator [x] singleton [x] spatial-partition [x] specification [x] state [x] step-builder [x] strategy [x] template-method [x] thread-pool [x] throttling [x] tls [x] tolerant-reader [x] trampoline [x] twin [x] typeobjectpattern [x] unit-of-work [x] value-object [x] visitor

Added two modules to demonstrate locks.

Mutex demonstrates a simple mutual exclusion lock. This is a binary lock which only allows one thread at a time to access the resource. See: Locks on Wikipedia

Semaphore demonstrates a semaphore for controlling access to a pool of resources. See Semaphores on Wikipedia

The main class of both programs is App.java.

I haven't created any documentation yet. Let me know if you want any changes or need some explanations of the code, etc.

This task is part of the Java 11 transition plan https://github.com/iluwatar/java-design-patterns/wiki/16.-Java-11-Transition

Start using local-variable type inference (var). It is a nice example of syntactic sugar that helps reduce boilerplate code (see https://www.infoq.com/articles/upgrading-java-8-to-12/ and https://winterbe.com/posts/2018/09/24/java-11-tutorial/)

It's a huge task to do this for all the patterns at once so it is possible to create pull requests for individual patterns. This way we can complete the task gradually. The following checklist tracks which patterns have already been refactored.

[x] abstract-document [x] abstract-factory [x] acyclic-visitor [x] adapter [x] aggregator-microservices [x] ambassador [x] api-gateway [x] async-method-invocation [x] balking [x] bridge [x] builder [x] business-delegate [x] bytecode [x] caching [x] callback [x] chain [x] circuit-breaker [x] collection-pipeline [x] command [x] commander [x] composite [x] converter [x] cqrs [x] dao [x] data-bus [x] data-locality [x] data-mapper [x] data-transfer-object [x] decorator [x] delegation [x] dependency-injection [x] dirty-flag [x] double-checked-locking [x] double-dispatch [x] eip-aggregator [x] eip-message-channel [x] eip-publish-subscribe [x] eip-splitter [x] eip-wire-tap [x] event-aggregator [x] event-asynchronous [x] event-driven-architecture [x] event-queue [x] event-sourcing [x] execute-around [x] extension-objects [x] facade [x] factory-kit [x] factory-method [x] feature-toggle [x] fluentinterface [x] flux [x] flyweight [x] front-controller [x] guarded-suspension [x] half-sync-half-async [x] hexagonal [x] intercepting-filter [x] interpreter [x] iterator [x] layers [x] lazy-loading [x] leader-election [x] marker [x] master-worker-pattern [x] mediator [x] memento [x] model-view-controller [x] model-view-presenter [x] module [x] monad [x] monostate [x] multiton [x] mute-idiom [x] mutex [x] naked-objects [x] null-object [x] object-mother [x] object-pool [x] observer [x] page-object [x] partial-response [x] pipeline [x] poison-pill [x] priority-queue [x] private-class-data [x] producer-consumer [x] promise [x] property [x] prototype [x] proxy [x] queue-load-leveling [x] reactor [x] reader-writer-lock [x] repository [x] resource-acquisition-is-initialization [x] retry [x] role-object [x] semaphore [x] servant [x] serverless [x] service-layer [x] service-locator [x] singleton [x] spatial-partition [x] specification [x] state [x] step-builder [x] strategy [x] template-method [x] thread-pool [x] throttling [x] tls [x] tolerant-reader [x] trampoline [x] twin [x] typeobjectpattern [x] unit-of-work [x] value-object [x] visitor

Java Design Patterns is analyzed with SonarQube.com static analysis. The analysis shows some blocker level code smells that should be fixed:

https://sonarqube.com/component_issues/index?id=com.iluwatar%3Ajava-design-patterns#resolved=false|severities=BLOCKER|types=CODE_SMELL

This is a pull request for a blog post about Hexagonal Architecture. The code samples have been embedded using gist-it. Looking forward to your comments.

Spring Boot has recently released 3.x. In this task we are going to upgrade the dependency. There is a helpful migration guide available here: https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-3.0-Migration-Guide

Acceptance criteria

• Spring Boot upgraded to 3.x

    Code snippet of **_<org.apache.commons.logging.LogFactory: org.apache.commons.logging.LogFactory getFactory()>_** in _**org.slf4j:jcl-over-slf4j:jar:1.7.16:compile**_ (loaded version):

Code snippet of <org.apache.commons.logging.LogFactory: org.apache.commons.logging.LogFactory getFactory()> in commons-logging:commons-logging:jar:1.2:compile (shadowed but expected to invoke method): .......

As a result, these conflicting method included in commons-logging:commons-logging:jar:1.2:compile deals with different cases, which changes the control flows and data flows. So being forced to use these methods in org.slf4j:jcl-over-slf4j:jar:1.7.16:compile may lead to inconsisitent semantic behaviors.

Originally posted by @HelloCoCooo in https://github.com/iluwatar/java-design-patterns/issues/868#issuecomment-480587255

Available since Java 16, we can now use the record type for immutable classes. It's well described at https://dzone.com/articles/what-are-java-records

Acceptance criteria

• The repository code has been refactored to use the record type

Java's switch expression syntax has vastly evolved over the years. It's well described at https://medium.com/@javatechie/the-evolution-of-switch-statement-from-java-7-to-java-17-4b5eee8d29b7

Acceptance criteria

• Java 17 switch expressions have been applied throughout the repository

Available since Java 15, we can now use the text blocks feature. See the tutorial at https://www.baeldung.com/java-text-blocks

Acceptance criteria

• Text blocks have been applied throughout the repository to improve readability