Almost every developer heard about design patterns. They was introduced long time ago to solve particular set of repeating problems in systems of different complexity level and size. But there is an opinion that many design patters just filled holes in the OOP languages of that time. Java as one of them has transformed and improved significantly in the last 10 years. So may be we could review design patterns implementation in modern Java world? Some of them are now may be easily replaced with language idioms, some others may be covered with existing libraries and frameworks. I'm sure you know some design patterns that are dead now or became anti-patterns in their initial implementation. Lets make this fun and useful review together!

1. The modern view on
implementation of
classic design patterns in
Java
Mikalai Alimenkou
http://xpinjection.com
@xpinjection

4. Disclaimer
This is only my
personal experience

5. Familiar with design patterns?

6. Holy bible for developers 

7. Java have long/slow roadmap

8. You could follow code samples
https://github.com/xpinjection/design-patterns

9. #1: Singleton

10. DI fight against Singleton

11. This is common anti-
pattern now
Isolate existing
Singletons from new
code with DI
DI containers ‘killed’
Singleton pattern

13. #2: Builder

14. ‘Storing’ VS ‘runtime’
style builders
Builder is the most
common pattern
Java is still bad in
handling properties

16. #3: Prototype

17. DI container handle
prototypes in their
own way
Clone method in
Object is confusing
Useful for domain
model with DDD style

19. #4: Factory Method

20. Use basic functional
interfaces if possible
Doesn’t work for
abstract factory
Constructor is also a
function

22. #5: Adapter

23. Functional interfaces
are interchangeable
Doesn’t work for
complex interfaces
Use basic functional
interfaces if possible

25. #6: Proxy

26. May be done with
composite functions
Inline lambda
wrapping is also
available
Main usage with AOP
and DI containers

27. Libs for manual proxy creation
• java.lang.reflect.Proxy
• Byte Buddy (http://bytebuddy.net)
• cglib (https://github.com/cglib/cglib)
• javassist (https://github.com/jboss-
javassist/javassist)

29. #7: Template Method

30. Utilize basic functional
interfaces
Inline needed parts
in tests and simple
clients
Use composition
instead of inheritance

32. #8: Command

33. Collect commands in
collection or combine
them
Doesn’t work with
complex commands
(with ‘undo’)
Dude, this is just a
plain lambda!

35. #9: Chain of Responsibility

36. Combine consumers
in the chain
Doesn’t work for
“workflow” handlers
May be use typed
functions pipeline?

38. #10: Strategy

39. Inline strategy in tests
and other light clients
Store strategies in
single holder as
static methods
Dude, this is just a
plain lambda again!

41. #11: Iterator

42. Use Streams
everywhere
Create own streams
with Spliterator
Forget about manual
iterations

44. #12: Decorator

45. Wrap function with
lambda
Combine functions
to provide additional
behavior
Use the Proxy
approaches

47. #13: Observer

48. Pass methods as
listeners
Observer and
Listener are
functional interfaces
Inline listener logic
in lambda

50. #14: Visitor

51. Use general
implementation
Try to use default
methods where
applicable
Very rarely used design
pattern

53. And remember…

54. @xpinjection
http://xpinjection.com
mikalai.alimenkou@xpinjection.com