Understanding Spring MVC Framework and Its Components

Spring controls women, supports MVC, and uses Front Controller to handle URL mapping and reduce dependency for different environments.

### Introduction to Spring MVC
* 🌸 Spring MVC is introduced as a framework that supports the **Model-View-Controller (MVC) pattern**.
* In Spring MVC, the controller's function is implemented as a **service**, and the view output is handled by passing a **JSP template**.
* 🎯 The main role of the Front Controller in Spring MVC is to **receive user requests**, **forward them to the actual controller**, and then **forward the processed values**.
* 📦 The Front Controller in Spring MVC can easily **package input values to be passed to the user**.
* 🔗 By using Spring MVC's Front Controller, it is possible to **reduce coupling** and use the framework in **different environments**.
* 📜 Configuration files are used in Spring MVC to specify which **controller will handle the URLs**.
* ⚙ When using Spring MVC, the mapping information that was previously set in the application has now moved to the **Spring configuration**.
* 💡 While many developers tend to use well-known libraries like Spring due to time constraints, it may be beneficial to **develop skills by building functionalities individually**.

Hello, this is lesson 6. Nice to meet you. I think from today, we can have a time where we can actually look forward to Spring. Since today is not the first practical session but the first session, let's start by finding out what MBC, which controls women called Spring, is. For those taking this class, it is natural to have studied servlets and JSP before and have experience in creating a program in the MVC pattern. If you don't have such experience, I briefly explained the basic concepts and choices, so I will continue with supplementary explanations. First of all, the Spring we are talking about supports the MVC. It means that the monster practices. You will understand what that means when you see it. Originally, we had Model 1 and Model 2 regarding the model. There was a conceptual part called the controller, and then there was a part responsible for view output, but they were combined into one.

When my model goes in, it was divided into this, but when it is not, basically, the part of the control that is resolved is implemented as a service, and then we could find the template that is responsible for the output that is responsible for passing the fellow named jsp as a belt. At that time, we used the dispatch philosophy to do forwarding. So, all controllers need to implement the dispatch function, and we think we should have a little experience with all controllers. Therefore, how do we implement this? Only the controller function is purely implemented, and since this is not a servlet but a woman, you can think of it as a general Java class. It is a bit oddly expressed the concept of a general Java class, but you can find it as a general Java class. It's just a plain Java object.

I will become a god. So if you don't stay in your body here, then since the controller is missing now, of course, only the dispatch function will remain. However, now that the controller is gone, the function of dispatch is an opportunity to forward this, so the function is almost the same. So, instead of creating multiple of these, just make one. When you do this, the role of this guy becomes simple. When a user request comes in, he actually forwards that request to my controller, the actual controller that I have, and then receives the value returned by processing that request and forwards it to B. It acts as an intermediary. However, it's not that simple. The role of this guy is very important. Receiving a user's request means not just routing the request, but also that if there are input values to be passed to the user, it can easily package those input values.

Let's talk about how to easily deliver user input here. Instead of using Market Parameter and Sub-later like we've done so far, we can block all the functions of the service here. So, by using the basic input side, we can provide a basic format that can be used here, such as offering strings or integers, for example. The second point is not just simply delivering in basic form, but we can organize data in various ways, such as organizing by dates, must-have items, or experiences. Then, here, we can handle input without using any third-party libraries, and even when trying to pass on data the child has, there is no dispatch function here. The dispatch will now return the request here without using any libraries.

You will receive it. Then, when returning, you will need a page from this side. It means that the return information that says what page of mine is needed will inform about the information for the Envue page. By calling the child, now you can limit the service function here. The main reason we separate this guy is to make it possible to reduce the distance for things like services or requests or happy cities, so that you can reduce the coupling here and allow you to use it in different environments. This way, you can lower the coupling here and make it possible for you to use it in different environments. So, how do we make this well? It's very important. It's about how Spring provided this. We will create a controller using the Front Controller Live that we are providing. In a way, if we make this Front Controller very well, it will be very pleasant.

It seems that you can also develop such a way to break up. You can make the capital to now 1t dry up and play a role in the sub lg g pad ultra spray function. So, should we bring up various u options? All those u options should be received and processed by the child, so all the children must be scheduled to come in. Therefore, appropriate controllers need to handle all that, so they should have separate information on which controller will handle the url. That's why when using the font controller, you need a configuration file. We need to know about things like which one is being processed and so on. That's why in the past, we mapped urls and things here, or if there was a later version upgrade, we had set it up here through annotations. The content has been moved here. Here, everything is just for this phone.

Only the settings for the game are set up, so for this reason, we are mapping information here. So in a way, it may seem like nothing has changed significantly, even if we set it to 20. The mapping information we set here has simply moved up to the Spring. By doing this, questioning whether one must definitely use this for the frontend, as I mentioned earlier, by reducing the compatibility with this, maybe in the end, even if the actual environment changes, we may still be able to do it. We used to create this directly in the past, so we created a separate control separated from this and the experimental results to reduce the dependency and make it possible for us to use this in different environments in the future. Nowadays, if we use Spring instead of creating it ourselves, when we complete something, we create an environment that can be distinguished from Tomcat.

Now, when it comes to the six cleaning times called Spring, we may also know another problem. This is my personal opinion, but in fact, I don't think it's good to develop this using the methodology. Many developers seem to struggle with time issues and find it difficult to match certain markers, so they tend to rush to well-known libraries and use them. If possible, since these things are not difficult, wouldn't it be better to build skills by developing them individually? Anyway, we are going to use Spring to control the leaves. This controller will deliver two pieces of information, and when the dispatch requests it, it will find the appropriate value and deliver the related data.

Yes, it was mentioned that the output data used at that time is called a model. That's correct. If it's like this, it's possible. Calling something like spray 0 b c is using this library directly. Where is this library used? It exists in the Spring's MVC library. If you look there, there is something called dispatch * sira. We will set this up and use it later. We will cover the details in the next session. Thank you very much, and we will continue with the next set.

Spring MVC (스프링 웹 MVC) 강의 01 - Spring MVC란

뉴렉쌤이 유툽으로 제공하는 IT 전문가를 위한 프로그래밍 강의 (현재 온라인 서비스는 공사중입니다  ver 0.0.1.)
분야 :  가리지 않음 모든 분야

제작 : (주) 뉴렉처
ⓒ2021. Newlecture All rights reserved.

국비지원 무료 과정 모집 안내 : (2024년 6월 3일에 시작하는 자바 풀스택 과정 모집중 입니다.) 
국비지원 무료과정입니다. 빈자리 없을 수도 있습니다. 선착순 지원 서두르세요. 

https://www.newlecture.com/class/detail?id=3




뉴렉처

The Spring framework supports the MVC pattern, combining the model, view, and controller.

The controller in Spring is implemented as a service, using the dispatch philosophy for forwarding, and it is essentially a plain Java object.

The controller plays a crucial role in receiving user requests, forwarding them to the actual controller, and then sending the processed value to the view, while also packaging any input values for the user.

Creating a User-Friendly Input Delivery System

Develop a basic format for user input, offering strings or integers without using third-party libraries.

Organize data in various ways, such as by dates, must-have items, or experiences, to handle input effectively.

Create a controller using the Front Controller Live to efficiently manage and process user requests.

The Transition to Using Spring for URL Mapping

The transition to using Spring for URL mapping allows for better control and management of the process.

By moving the mapping information to Spring, it becomes easier to handle and process different environments in the future.

This transition also helps to reduce dependency and improves compatibility with the frontend, providing a more flexible solution.

Using Spring for Controlling Leaves in MVC

Developers often struggle with time issues when using well-known libraries in Spring for controlling leaves in MVC.

There is a suggestion to build skills by developing individually instead of rushing to use these libraries.

The output data used in this process is called a model, and the Spring's MVC library is where the specific library for controlling leaves is used.