Practice! Querydsl

hello everyone
Finally, the Spring Core Principles - Advanced course is ready to open.
Thank you for waiting and supporting us for a long time.

- Title: Spring Core Principles - Advanced
- Release Schedule: Released between Wednesday, October 27th and Wednesday, November 3rd
- Number of lectures: 120 lectures
- Lecture materials: 360 PDF pages

If you learned the basics of Spring and object-oriented development in the basic course, the advanced course covers in-depth topics to gain a deeper understanding of Spring and backend development.

Advanced Key Topics

- Spring Core Design Patterns
- Concurrency issues and thread locals
- Spring AOP

These are difficult topics, but if you want to become a skilled backend developer, you must study them in depth at least once .
You can think of this lecture as a single lecture that covers the core, complex and difficult content of Spring.

Please refer to the following lecture introduction for more details.

 

Introduction to the course

*Spring Framework*

To become a skilled developer, you need to have a deep understanding of the tools you frequently use in your work.
Spring is the most widely used backend technology in practice.
Therefore, it is important for backend developers to have a deep understanding of Spring.

We learned the basics of Spring and object-oriented development in Spring Core Principles - Fundamentals.

*Spring Core Principles - Basics*

Object-oriented design and spring
- SOLID - SRP, OCP, DIP
Spring Container and Spring Beans
- Spring Container - IoC, DI
- Dependency injection
- Empty creation cycle and scope

*Spring Core Principles - Advanced*

To deeply understand Spring and become a capable developer in practice, you need to learn three key advanced concepts based on what you learned in the basics. In this advanced chapter, you will learn these advanced concepts.

1. Spring Core Design Patterns
2. Thread locals to deal with concurrency issues
3. Spring AOP

*1. Spring Core Design Patterns*

Spring's internal technologies are built around several core design patterns. Therefore, in order to understand Spring in depth, you must first learn the design patterns that Spring frequently uses.

*Key design patterns taught in the lecture*

- Template method pattern
- Strategy Patterns
- Template callback pattern
- Proxy pattern
- Decorator pattern

In this lecture, we will explain these design patterns very easily by creating example codes one by one. And we will also learn how to apply the design patterns learned in this way to applications.

 

*2. Thread Local*

Spring is mainly used for developing web applications. Web applications use multi-threading to handle multiple requests at the same time. Therefore, concurrency issues can occur where multiple threads compete.

*Concurrency issues and thread local content covered in the lecture*

- Web application
- Multithreading
- Concurrency issues

In this lecture, you will learn about concurrency issues that occur when using Spring, and also learn about the concept of thread locals that can conveniently solve concurrency issues.
Thread locals are an essential concept to understand how Spring works well in a multithreaded environment without concurrency issues.

 

*3. Spring AOP*

Spring AOP is a very useful technology that is used a lot in practice and feels like magic. Many developers use Spring AOP, but not many developers understand and use the principles of how Spring AOP works.

Beyond simply knowing and using the features of Spring AOP, you need to deeply understand the operating principles of Spring AOP to be able to solve fundamental problems when failures occur.

*Spring AOP contents delivered in lecture*

- Concepts, terminology
- Proxy - JDK dynamic proxy, CGLIB
- How it works
- Real-world examples
- Practical precautions

In this lecture, we will go beyond a simple summary of Spring AOP's functions and cover everything about Spring AOP, from its operating principles to practical examples and precautions that frequently arise in practice.

 

*etc*

Additionally, we will cover advanced techniques in Spring containers, such as bean postprocessing, and various *practical tips* for developing Spring applications.

- Extension points for the Spring container - empty postprocessors
- Various practical tips for developing Spring applications

 

After attending the lecture

As this is an advanced course, the content covered in this lecture is not easy.
However , if you want to become a skilled backend developer, this is something you must study at least once .
If you follow this lecture to the end without giving up, you will experience a tremendous increase in your skills as a developer and be able to use Spring more confidently than anyone else.
Since this is a difficult subject, I have thoroughly prepared the lecture. I will help you complete this content on your own.

thank you