3week - MVC

Notice

Recent Posts

Recent Comments

Link

« 2025/03 »
일	월	화	수	목	금	토
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

Tags more

Archives

Today

Total

관리 메뉴

C-log

3week - MVC 본문

📕JAVA/Spring

3week - MVC

4:Bee 2024. 3. 20. 13:49

728x90

* 대면 수업 내용

model

view

controller

dispatcher servlet

contextloadlistener

Maven을 사용하는 이유와 장점

* 싱글톤 패턴을 알아야한다.

# MVC 생성(Controller&View)

### pom.xml은 무엇인가

* HomeController.java

package kr.ac.hansung.cse.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.http.HttpServletRequest;

@Controller
public class HomeController {

    //private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
    private static final Logger logger = LoggerFactory.getLogger("kr.ac.hansung.controller.HomeController");


//    @RequestMapping(value = "/", method = RequestMethod.GET)
    @GetMapping("/")
    public String home(HttpServletRequest request) {

        String url = request.getRequestURL().toString();
        String clientIPaddr = request.getRemoteAddr();

        logger.info("Request URL: {}, Client IP: {}", url, clientIPaddr);

        return "home";
    }
}

위의 코드는 스프링 MVC 웹 애플리케이션에서 홈 페이지를 처리하는 컨트롤러입니다. 각 부분에 대한 설명은 다음과 같습니다:

* @Controller - 어노테이션
해당 클래스가 스프링 MVC의 컨트롤러임을 나타낸다. 이는 추후에 appServlet에서 Controller 클래스를 탐색할 때 중요한 역할을 한다.

* @GetMapping("/") - 어노테이션 ?
HTTP GET 요청을 처리하는 핸들러 메서드를 지정한다. 이 메서드는 "/" 경로로 들어오는 GET 요청을 처리한다.

* HttpServletRequest request
클라이언트로부터 요청을 받아들이는데 사용됩니다. 이를 통해 요청 URL과 클라이언트의 IP 주소를 가져온다.

* Logger logger
로그를 출력하기 위한 Logger 객체입니다. 여기서는 SLF4J 로깅 API를 사용하고 있다.

* logger.info("Request URL: {}, Client IP: {}", url, clientIPaddr)
로그에 요청 URL과 클라이언트 IP 주소를 출력한다.

* return "home";
"home"이라는 뷰 이름을 반환하여 해당 뷰를 표시한다. 스프링 MVC는 이 뷰 이름을 기반으로 실제 뷰 파일을 찾아 클라이언트에게 반환한다.

따라서 이 컨트롤러는 "/" 경로로 들어오는 GET 요청을 처리하고, 요청 URL과 클라이언트의 IP 주소를 로그에 출력한 후, "home"이라는 뷰를 표시한다. 아래 코드는 반환된 home 뷰에 해당되는 jsp이다. jsp는 크게 어려움이 없기에 패스 하도록 하자.

* home.jsp

<%--
  Created by IntelliJ IDEA.
  User: nykim
  Date: 2022/12/13
  Time: 12:55 오전
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <p><a href="${pageContext.request.contextPath}/offers"/>Show Current offers</p>
  </body>
</html>

* helloSpring-1.0-SNAPSHOT.war

helloSpring-1.0-SNAPSHOT.war 파일은 Maven 또는 Gradle과 같은 빌드 도구를 사용하여 생성된 웹 애플리케이션 아카이브(WAR) 파일이다. 이 파일은 스프링 프레임워크 또는 다른 웹 프레임워크를 사용하여 개발한 웹 애플리케이션의 배포를 위해 사용된다.

## 지금까지의 패키지 파일 구조

지금까지 파일의 구조를 살펴보면 controller 패키지 파일과 dao 패키지 파일 마지막으로 service 패키지 파일로 구성이 되어 있다. 이러한 구조는 아래 이미지와 같이 이루어져 있다.

지금까지의 파일 구조를 살펴보면 각각의 책임을 분명히 하여 애플리케이션의 구조를 명확하게 하고 유지보수와 확장성을 향상시키는 데 중요한 역할을 한다. 이의 구체적인 설명은 아래 appServlet을 통해 설명하겠다.

appServlet 설정 파일은 주로 웹 애플리케이션의 프론트 컨트롤러인 DispatcherServlet을 구성하는 데 사용되며 이는 웹 요청을 처리하고 라우팅하는 역할을 수행한다.

* appServlet : servlet-context.xml, doa-context.xml, service-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:beans="http://www.springframework.org/schema/beans"
             xmlns:context="http://www.springframework.org/schema/context"
             xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->

    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />

    <!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
    <resources mapping="/resources/**" location="/resources/" />

    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>

    <context:component-scan base-package="kr.ac.hansung.cse.controller" />

</beans:beans>

<context:component-scan base-package="kr.ac.hansung.cse.controller" />

@Controller
public class HomeController {
...

servlet-context.xml 코드는 Spring MVC 웹 애플리케이션의 설정을 담고 있으며 여기서 <context:component-scan base-package="kr.ac.hansung.cse.controller" /> 부분이 핵심적인 역할을 한다. <context:component-scan> 태그는 Spring Framework에게 지정된 controller 패키지 내에서 어노테이션이 붙은 클래스를 스캔하도록 지시한다. 이를 통해 해당 클래스들을 Spring의 ApplicationContext에 빈(Bean)으로 등록하게 된다. 이렇게 웹 요청을 처리하는 controller로 인식되어 해당 컨트롤러의 메서드들이 웹 요청에 응답할 수 있게 된다.

### dispatch란?

### Servlet이란?

Servlet은 자바를 사용하여 웹 페이지를 동적으로 생성하는 서버 측 프로그램 또는 자바 클래스이다. 웹 서버에서 동작하며 클라이언트의 요청에 따라 처리 후 결과를 클라이언트에게 돌려주는 역할을 한다. 서블릿은 주로 HTML, XML 등을 생성하고, 데이터베이스 연동과 같은 비즈니스 로직 처리를 담당한다. 서블릿은 자바 EE(Enterprise Edition) 사양의 일부로 웹 애플리케이션을 개발하기 위한 자바의 표준 기술이다. 서블릿을 사용하면 플랫폼 독립적인 웹 애플리케이션을 구축할 수 있다.

### dispatchServlet이란?

DispatcherServlet은 스프링 MVC(모델-뷰-컨트롤러) 프레임워크에서 중심적인 역할을 하는 서블릿으로 웹 애플리케이션에서 들어오는 모든 요청을 처리한다. 스프링 웹 MVC의 프론트 컨트롤러로서 DispatcherServlet은 클라이언트로부터 받은 요청을 적절한 핸들러 또느 컨트롤러에 전달하고 그 결과를 클라이언트에게 반환하는 역할을 한다.

* root-context.xml은 제거

root-context.xml 파일은 루트 컨텍스트를 설정하는 데 사용된다. 그러나 최근의 스프링 프레임워크 버전에서는 root-context.xml을 사용하지 않고 Java 기반의 설정 클래스를 사용하여 루트 컨텍스트를 설정하는 것이 일반적이다. Java 기반의 설정 클래스를 사용하면 XML 파일보다 유연하고 프로그래밍 방식으로 설정을 조작할 수 있다.

* web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- The definition of the Root Spring Container shared by all Servlets
        and Filters -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/spring/appServlet/service-context.xml
            /WEB-INF/spring/appServlet/doa-context.xml
        </param-value>
    </context-param>

    <!-- Creates the Spring Container shared by all Servlets and Filters -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Processes application requests -->
    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

위의 XML 파일은 스프링 MVC 웹 애플리케이션의 web.xml 설정 파일이다. 이 파일은 웹 애플리케이션의 배치 및 초기화를 구성하는 데 사용된다. 각 요소의 역할은 다음과 같다

* web-app
이 요소는 이 XML 파일이 웹 애플리케이션의 설정 파일임을 나타낸다.

* context-param
이 요소는 웹 애플리케이션의 루트 컨텍스트를 설정하는 데 사용된다. 여기서는 contextConfigLocation이라는 컨텍스트 파라미터를 설정하여 service-context.xml 및 dao-context.xml 파일을 지정하고 있습니다.

* listener
ContextLoaderListener 클래스를 등록하여 웹 애플리케이션의 루트 컨텍스트를 생성한다.

* servlet
이 요소는 스프링 MVC 애플리케이션의 서블릿을 설정하는 데 사용된다. 여기서는 DispatcherServlet을 등록하고 servlet-context.xml 파일을 로드하는데 사용된다.

* servlet-mapping
서블릿 매핑을 설정하는 데 사용된다. 이 경우 / 경로에 대한 모든 요청을 appServlet 서블릿에 매핑한다.

이렇게 하면 스프링 MVC 웹 애플리케이션이 초기화되고 설정되며 클라이언트의 요청을 처리하기 위한 준비가 완료된다.

지금까지의 폴더 파일 구성은 아래와 같다.

# MVC 구현(Model&Controller&View)

모델구현

* Offer.java

package kr.ac.hansung.cse.model;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
@NoArgsConstructor

public class Offer {
    private int id;
    private String name;
    private String email;
    private String text;
}

위의 코드는 Java 클래스인 Offer를 정의하고 있다. 이 클래스는 주로 데이터베이스나 사용자 입력과 같은 외부 데이터를 표현하기 위해 사용된다. 각 어노테이션들을 주의깊게 살펴보자

* @Getter
Lombok 라이브러리의 어노테이션으로 자동으로 필드에 대한 getter 메서드를 생성한다. 이것은 id, name, email, text 필드에 대한 getter 메서드를 자동으로 생성한다.

* @Setter
Lombok 라이브러리의 어노테이션으로 자동으로 필드에 대한 setter 메서드를 생성한다. 이것은 id, name, email, text 필드에 대한 setter 메서드를 자동으로 생성한다.

* @ToString
Lombok 라이브러리의 어노테이션으로 자동으로 toString() 메서드를 생성한다. 이 메서드는 객체의 필드 값을 문자열로 반환한다.

* @NoArgsConstructor
Lombok 라이브러리의 어노테이션으로 인자를 받지 않는 기본 생성자를 자동으로 생성한다.

* private int id
Offer 객체의 id를 저장하는 필드이다.

* private String name
Offer 객체의 이름을 저장하는 필드이다.

* private String email
Offer 객체의 이메일 주소를 저장하는 필드이다.

* private String text
Offer 객체의 텍스트를 저장하는 필드이다.

이 클래스의 역할은 주로 데이터를 표현하고 저장하는 데에 있다. 이 클래스의 인스턴스는 데이터베이스 테이블의 레코드를 나타낼 수 있고 웹 어플리케이션에서 폼 데이터를 나타낼 수도 있다. Getter와 Setter 메서드는 필드에 접근하여 데이터를 설정하거나 가져올 수 있도록 해주고 toString() 메서드는 객체를 문자열로 표현하여 로깅 및 디버깅 목적으로 사용될 수 있다.

* OfferController.java

package kr.ac.hansung.cse.controller;

import kr.ac.hansung.cse.model.Offer;
import kr.ac.hansung.cse.service.OfferService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

@Controller
public class OfferController {
    @Autowired
    private OfferService offerService;
    //offerDao로 부터 mysql들을 조작 컨트롤 한다.
    @GetMapping("/offers")
    public String showOffer(Model model){
        List<Offer> offers = offerService.getAllOffers();
        model.addAttribute("id_offers", offers);

        return "offers";
    }
}

위의 코드는 스프링 MVC 웹 애플리케이션에서 Offer 객체를 처리하는 컨트롤러인 OfferController를 정의하고 있다. 이 컨트롤러의 역할과 코드를 분석해보자.

* @Controller
해당 클래스가 스프링 MVC의 컨트롤러임을 나타낸다.

* @Autowired private OfferService offerService;
OfferService 타입의 빈을 자동으로 주입받는다. 이것은 스프링 프레임워크에 의해 OfferService의 구현체가 생성되고 offerService 필드에 주입된다.

* @GetMapping("/offers")
HTTP GET 요청을 처리하는 핸들러 메서드를 지정한다. 이 메서드는 "/offers" 경로로 들어오는 GET 요청을 처리한다.

* public String showOffer(Model model)
Model 객체를 매개변수로 받는 메서드이다. 이 모델 객체는 컨트롤러에서 뷰로 데이터를 전달하는 데 사용된다.

* List<Offer> offers = offerService.getAllOffers();
offerService를 사용하여 모든 Offer 객체를 가져온다. 이는 서비스 계층에 있는 OfferService 객체를 통해 데이터베이스나 다른 곳에서 Offer 정보를 가져오는 역할을 한다.

* model.addAttribute("id_offers", offers);
모델에 "id_offers"라는 이름으로 Offer 목록을 추가한다. 이렇게 하면 뷰에서 이 데이터에 접근할 수 있게 된다.

* return "offers";
"offers"라는 뷰 이름을 반환한다. 이는 스프링 MVC가 내부적으로 이 이름을 가지는 뷰를 찾아 클라이언트에게 반환한다.

따라서 OfferController는 /offers 경로로 들어오는 GET 요청을 처리하고 이를 통해 Offer 객체를 조회하여 뷰로 전달하는 역할을 한다. 이러한 디자인은 MVC (Model-View-Controller) 패턴을 따르며 각 요소의 역할을 분리하여 코드를 보다 구조화하고 유지보수하기 쉽게 만든다.

* offers.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
  User: rdwoo1024
  Date: 2024-03-27
  Time: 오후 5:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <c:forEach var="offer" items="${id_offers}">
        <p><c:out value="${offer}"></c:out></p>
    </c:forEach>
</body>
</html>

위의 코드는 JSP 파일인 offer.jsp이다. 이 파일은 Offer 객체의 목록을 출력하는 역할을 한다. 코드를 분석하고 역할을 살펴보자.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
JSTL(Core) 태그 라이브러리를 사용하기 위한 태그 라이브러리 선언한다. 이를 통해 JSP 파일에서 JSTL의 제어 구문 및 반복문을 사용할 수 있다.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
해당 JSP 페이지의 콘텐츠 유형을 HTML로 설정하고 문자 인코딩을 UTF-8로 설정한다.

<c:forEach var="offer" items="${id_offers}">
JSTL의 <c:forEach> 태그를 사용하여 ${id_offers}에 있는 객체들을 반복하며 처리한다. ${id_offers}는 컨트롤러에서 모델에 추가된 Offer 객체들의 리스트를 가리킨다.

<p><c:out value="${offer}"></c:out></p>
반복문 안에서 Offer 객체를 출력하는 부분이다. <c:out> 태그를 사용하여 ${offer} 값을 출력한다. 이를 <p> 태그로 둘러싸서 각 Offer 객체를 단락으로 나타낸다.

<title>Title</title>
HTML 문서의 제목을 나타내는 부분이다.

<body>
HTML 문서의 본문을 시작하는 태그이다.

<html>, <head>, <body>
HTML 문서의 구조를 정의하는 태그이다.

따라서 offer.jsp 파일은 Offer 객체 목록을 반복하여 출력하는 역할을 한다. 이를 통해 Offer 객체의 정보를 웹 페이지 상에 표시할 수 있다

* OfferService.java

package kr.ac.hansung.cse.service;

import kr.ac.hansung.cse.dao.OfferDao;
import kr.ac.hansung.cse.model.Offer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class OfferService {
    @Autowired
    private OfferDao offerDao;
    public List<Offer> getAllOffers(){
        return offerDao.getOffers();
    }
}

위의 코드는 OfferService라는 서비스 클래스이다. 이 클래스는 주로 데이터베이스와 상호 작용하여 Offer 객체에 대한 비즈니스 로직을 처리한다. 코드를 분석하고 역할을 설명해보겠한다

@Service
해당 클래스가 스프링의 서비스로 인식되도록 하는 어노테이션이다. 이는 스프링 컨테이너가 해당 클래스를 빈으로 등록하고 필요한 곳에서 주입하여 사용할 수 있도록 한다.

@Autowired private OfferDao offerDao;
OfferDao 인터페이스를 구현한 빈을 자동으로 주입받는다. 이것은 스프링 프레임워크에 의해 OfferDao의 구현체가 생성되고 offerDao 필드에 주입된다.

public List<Offer> getAllOffers()
모든 Offer 객체를 가져오는 메서드이다. 이 메서드는 DAO 계층에 있는 OfferDao 객체를 사용하여 데이터베이스에서 Offer 데이터를 가져온다.

return offerDao.getOffers();
OfferDao 객체의 getOffers() 메서드를 호출하여 모든 Offer 객체를 가져온다. 이 메서드는 데이터베이스에서 Offer 정보를 조회하여 리스트로 반환한다.

따라서 OfferService 클래스는 주로 DAO 계층과 상호 작용하여 데이터베이스에서 Offer 데이터를 가져오는 역할을 한. 이를 통해 컨트롤러나 다른 서비스 계층에서 필요한 데이터를 제공한다. 이러한 방식으로 비즈니스 로직을 서비스 계층에 분리함으로써 코드의 응집성을 높이고 유지보수성을 향상시킨다.

*OfferDao.java

package kr.ac.hansung.cse.dao;

import kr.ac.hansung.cse.model.Offer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import javax.sql.DataSource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository
public class OfferDao {

    private JdbcTemplate jdbcTemplate;  // psa(portable service abstraction, sql(x) api

    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public int getRowCount() {
        String sqlStatement= "select count(*) from offers";
        return jdbcTemplate.queryForObject(sqlStatement, Integer.class);

    }
    //query and return a single object
    public Offer getOffer(String name) {

        String sqlStatement= "select * from offers where name=?";
        return jdbcTemplate.queryForObject(sqlStatement, new Object[] {name},
                new RowMapper<Offer>() {

                    @Override
                    public Offer mapRow(ResultSet rs, int rowNum) throws SQLException {

                        Offer offer= new Offer();

                        offer.setId(rs.getInt("id"));
                        offer.setName(rs.getString("name"));
                        offer.setEmail(rs.getString("email"));
                        offer.setText(rs.getString("text"));

                        return offer;
                    }
                });
    }

    //query and return multiple objects
    // cRud method
    public List<Offer> getOffers() {

        String sqlStatement= "select * from offers";
        return jdbcTemplate.query(sqlStatement, new RowMapper<Offer>() {

            @Override
            public Offer mapRow(ResultSet rs, int rowNum) throws SQLException {

                Offer offer= new Offer();

                offer.setId(rs.getInt("id"));
                offer.setName(rs.getString("name"));
                offer.setEmail(rs.getString("email"));
                offer.setText(rs.getString("text"));

                return offer;
            }
        });
    }


    // Crud method
    public boolean insert(Offer offer) {

        String name= offer.getName();
        String email= offer.getEmail();
        String text = offer.getText();

        String sqlStatement= "insert into offers (name, email, text) values (?,?,?)";

        return (jdbcTemplate.update(sqlStatement, new Object[] {name, email, text}) == 1);
    }

    // crUd method
    public boolean update(Offer offer) {

        int id = offer.getId();
        String name= offer.getName();
        String email= offer.getEmail();
        String text = offer.getText();

        String sqlStatement= "update offers set name=?, email=?, text=? where id=?";

        return (jdbcTemplate.update(sqlStatement, new Object[] {name, email, text, id}) == 1);
    }

    //cruD method
    public boolean delete(int id) {
        String sqlStatement= "delete from offers where id=?";
        return (jdbcTemplate.update(sqlStatement, new Object[] {id}) == 1);
    }

}

OfferDao 클래스는 데이터베이스와 상호작용하기 위한 DAO(Data Access Object) 클래스로서, 주로 데이터베이스에 대한 CRUD(Create, Read, Update, Delete) 작업을 수행한다. 이 클래스는 JDBC(Java Database Connectivity)를 사용하여 데이터베이스에 쿼리를 실행하고 결과를 처리한다.

@Repository
해당 클래스가 스프링의 빈으로 등록되는 리포지토리 클래스임을 나타낸다. 이는 스프링이 해당 클래스를 컴포넌트 스캔을 통해 빈으로 등록하고, 필요한 곳에서 주입하여 사용할 수 있도록 한다.

private JdbcTemplate jdbcTemplate;
JDBC를 사용하여 데이터베이스와 상호작용하기 위한 JdbcTemplate 객체를 선언한다.

public void setDataSource(DataSource dataSource) { ... }
DataSource 객체를 받아서 JdbcTemplate 객체를 초기화하는 메서드이다. 이 메서드는 스프링의 의존성 주입(Dependency Injection)을 통해 데이터베이스 연결을 설정한다.

public int getRowCount() { ... }
데이터베이스 테이블의 행 수를 반환하는 메서드이다.

public Offer getOffer(String name) { ... }
이름을 기준으로 특정 Offer 객체를 조회하는 메서드이다.

public List<Offer> getOffers() { ... }
모든 Offer 객체의 리스트를 조회하는 메서드이다.

public boolean insert(Offer offer) { ... }
새로운 Offer 객체를 데이터베이스에 삽입하는 메서드이다.

public boolean update(Offer offer) { ... }
기존의 Offer 객체를 업데이트하는 메서드이다.

public boolean delete(int id) { ... }
특정 id를 가진 Offer 객체를 삭제하는 메서드이다.

이러한 메서드들을 통해 OfferDao 클래스는 데이터베이스와의 상호작용을 추상화하고 서비스나 컨트롤러 등에서 데이터베이스에 접근하여 CRUD 작업을 수행할 수 있도록 한다. 이를 통해 비즈니스 로직과 데이터 액세스 로직을 분리하고 코드의 재사용성과 유지보수성을 향상시킨다.

# MVC 통합테스트(MYSQL)

해당 파트는 강의를 통해 정리해 두는 것 보단 보는 것이 쉽다. 따로 정리해 두진 않았으니 각 개인들 마다 offfer 파트를 중심으로 자료를 찾아 실습을 해보기 바란다.

##중간고사를 위한 이론 정리

Controller와 View에 관해서

* Model

Model은 Controller가 수행한 결과물을 저장하는 곳이다. Controller가 Model에 결과를 넘겨 주면 View에서 결과물을 꺼내서 처리를 하는 방식이 되겠다. Model에서는 POJO객체가 생성이 된다. Named Object가 집합되어 있는 것이 Model이다. (Named Object는 스프링 MVC의 Model에서 사용되는 데이터 객체를 가리키는 용어로 이해할 수 있다.)

* Model은 어떻게 구현하는가

세가지가 있는데 java.util.map, Model, ModelMap 방식이 있다.

1. public String getGreeting(Map<String, Object> model ) { ... }

이 방법은 java.util.Map 인터페이스를 사용하여 모델을 전달한다. 메서드 내에서 데이터는 model 매개변수에 추가된다. 이 방법은 가장 일반적이고 범용적인 방법 중 하나이며 모델을 생성하고 관리하는 데 많은 유연성을 제공한다.

이 코드는 "/greeting" 엔드포인트에 매핑된 메서드입니다. 이 메서드는 서비스로부터 "greeting"을 가져와서 모델에 "greeting"이라는 이름으로 설정합니다. 그리고 "home"이라는 뷰를 반환합니다.

여기서 model.put("greeting", greeting)은 "greeting"이라는 이름으로 service에서 가져온 "greeting"을 모델에 추가하는 역할을 합니다. 이 모델은 뷰에 전달되어 화면에 표시됩니다. 따라서 뷰에서는 "greeting"이라는 이름으로 모델에 설정된 값에 접근하여 해당 "greeting"을 표시할 수 있습니다.

2. public String getGreeting(Model model ) { ... }

이 방법은 스프링 프레임워크의 org.springframework.ui.Model 인터페이스를 사용하여 모델을 전달한다. 이 인터페이스는 데이터를 추가하고 검색하는 데 사용된다. 주로 스프링 MVC 컨트롤러에서 많이 사용되는 방법 중 하나이다.

Map을 사용하는 경우 각 모델 속성의 이름을 결정해야 한다. 이는 지루하고 어려운 과정일 수 있다. 예를 들어, "greeting"이라는 이름을 사용하여 greeting 변수를 모델에 추가한다.

Model 인터페이스는 addAttribute()와 같은 편리한 메서드를 제공하여 Model을 채우는 데 사용된다. addAttribute()는 Map의 put()과 동일하지만 모델 속성의 이름을 자동으로 생성한다. 이렇게 하면 여전히 각 모델 속성의 이름을 수동 적으로 직접 결정할 수 있지만 이름을 자동으로 생성할 수도 있다.

Key값이 없이 Value값만 존재하며 직접 집어 넣는 방식의 Model Map이다. 원래라면 value값을 명시적으로 지정해야한다.

3. public String getGreeting(ModelMap model ) { ... }

이 방법은 org.springframework.ui.ModelMap 클래스를 사용하여 모델을 전달한다. ModelMap은 Model과 유사하지만 추가적인 편의 기능을 제공한다. ModelMap은 내부적으로 LinkedHashMap을 사용하여 데이터를 유지하므로 데이터가 추가된 순서대로 유지된다.

addAttribute Chained Call을 통해서 key와 value값을 생성하는 Map 방식이다.

* Controller

@Controller annotation

@Controller 어노테이션은 클래스가 컨트롤러 역할을 한다는 것을 나타낸다. 이 어노테이션을 사용하여 Spring에게 해당 클래스를 컨트롤러로 인식하도록 지정한다.

@RequestMapping annotation

@RequestMapping 어노테이션은 특정 URL을 클래스 전체 또는 특정 핸들러 메서드와 매핑하는 데 사용된다. 이 경우 해당 어노테이션은 home() 메서드가 URL /에 대한 GET 요청을 처리할 것임을 지정한다.

@Controller(@Compponet,@Service,@Repository)

@Component, @Service, @Repository는 Spring 프레임워크에서 빈을 선언하고 관리하기 위해 사용되는 어노테이션입니다. 이들은 모두 @Component 어노테이션의 특수한 형태이며, 각각의 목적에 따라 사용됩니다.

@Component: Spring 애플리케이션에서 구성 요소를 나타내는 일반적인 어노테이션입니다. 다른 세부 어노테이션들의 부모 역할을 합니다. 클래스를 빈으로 등록하고 Spring 컨테이너에 의해 관리되게 합니다.
@Service: 비즈니스 로직이 포함된 서비스 계층의 클래스를 나타냅니다. 주로 서비스 클래스에 사용되며, 비즈니스 로직을 구현하고 트랜잭션 관리 등을 담당합니다.
@Repository: 데이터 액세스 로직을 담당하는 클래스를 나타냅니다. 주로 DAO(Data Access Object)나 데이터베이스와의 상호작용을 담당하는 클래스에 사용됩니다. 주로 데이터베이스에 접근하고 조작하는 메서드를 가지며, 예외를 스프링의 일관된 예외로 변환해주는 역할을 합니다.
이 세 가지 어노테이션은 모두 @Component 어노테이션을 기반으로 하며, 개발자에게 코드를 더 명확하게 표현하고 의미를 전달하기 위해 사용됩니다. 또한, 컴포넌트 스캔(Component Scan) 시에 Spring이 이들을 인식하여 자동으로 빈으로 등록해줍니다.

@Controller(Mapping Requests : Class)

Class : 클래스는 컨트롤러의 기본 구성 요소입니다. @Controller 애노테이션이 지정된 클래스는 스프링 MVC에서 컨트롤러 역할을 수행합니다. 컨트롤러 클래스는 요청을 처리하는 여러 개의 메서드를 포함할 수 있습니다.

@Controller
@RequestMapping("/appointments")
public class AppointmentsController 
{
    // an HTTP POST for /appointments
    @RequestMapping(method = RequestMethod.POST)
    public Map<String, Appointment> get() {
        return appointmentBook.getAppointmentsForToday();
    }
     
    // an HTTP GET for /appointments/new
    @RequestMapping(value="/new", method = RequestMethod.GET)
    public AppointmentForm getNewForm() {
        return new AppointmentForm();
    }
}

상세 코드 설명 :

위의 코드는 Spring MVC에서 요청을 처리하는 컨트롤러를 정의하는 예시입니다.

1. @Controller: 이 어노테이션은 해당 클래스가 컨트롤러임을 나타냅니다. Spring이 이 클래스를 컴포넌트 스캔하여 빈으로 등록하고, 요청 매핑을 처리할 준비를 합니다.
2. @RequestMapping("/appointments"): 클래스 수준에서의 요청 매핑입니다. 이 클래스의 모든 핸들러 메서드에 대한 요청 URL의 접두사를 지정합니다. 즉, 이 클래스 내의 모든 메서드에 대한 요청은 "/appointments"로 시작해야 합니다.
3. @RequestMapping(method = RequestMethod.POST): HTTP POST 메서드에 대한 요청을 처리하는 핸들러 메서드를 지정합니다. "/appointments"로 들어오는 POST 요청은 이 메서드에서 처리됩니다.
4. public Map<String, Appointment> get() { ... }: POST 요청을 처리하는 메서드입니다. appointmentBook에서 오늘의 예약을 가져와서 Map으로 반환합니다.
5. @RequestMapping(value="/new", method = RequestMethod.GET): "/appointments/new" 경로로 들어오는 HTTP GET 요청을 처리하는 핸들러 메서드를 지정합니다.
6. public AppointmentForm getNewForm() { ... }: GET 요청을 처리하는 메서드입니다. 새로운 예약을 위한 폼을 생성하여 반환합니다.

이렇게 컨트롤러를 정의하면 Spring MVC는 요청에 따라 적절한 핸들러 메서드를 호출하여 요청을 처리하고, 그 결과를 클라이언트에 반환합니다.

@Controller(Mapping Requests : Handler)

Handler : Class를 제외하고 사용하기에 코드의 양을 줄일 수 있다는 장점이 있다.
핸들러는 요청에 대한 처리 로직을 정의하는 메서드입니다. 컨트롤러 클래스 내부의 각 메서드는 특정 URL 경로와 HTTP 요청 메서드(예: GET, POST)와 매핑되어 요청을 처리하는 핸들러 역할을 합니다. 핸들러는 @RequestMapping 애노테이션을 사용하여 특정 URL 경로와 요청 메서드에 매핑됩니다.

@Controller
public class EmployeeController 
{
    @RequestMapping("/employee-management/employees")
    public String getAllEmployees(Model model)
    {
        //application code
        return "employeesList";
    }
     
    @RequestMapping("/employee-management/employees/add")
    public String addEmployee(EmployeeVO employee)
    {
        //application code
        return "employeesDetail";
    }
}

상세 코드 설명 :

위의 코드는 Spring MVC에서 요청을 처리하는 컨트롤러인 EmployeeController 클래스를 보여줍니다.

1. @Controller: 이 어노테이션은 해당 클래스가 컨트롤러임을 나타냅니다. Spring이 이 클래스를 컴포넌트 스캔하여 빈으로 등록하고, 요청 매핑을 처리할 준비를 합니다.
2. @RequestMapping("/employee-management/employees"): "/employee-management/employees" 경로로 들어오는 요청을 처리하는 메서드인 getAllEmployees()를 지정합니다.
3. public String getAllEmployees(Model model) { ... }: "/employee-management/employees" 경로로 들어오는 요청을 처리하는 메서드입니다. Model 객체를 매개변수로 받아와서, 이를 사용하여 뷰에 데이터를 전달합니다. 메서드 내부에서는 애플리케이션 로직을 수행한 후, "employeesList" 뷰를 반환합니다.
4. @RequestMapping("/employee-management/employees/add"): "/employee-management/employees/add" 경로로 들어오는 요청을 처리하는 메서드인 addEmployee()를 지정합니다.
5. public String addEmployee(EmployeeVO employee) { ... }: "/employee-management/employees/add" 경로로 들어오는 요청을 처리하는 메서드입니다. EmployeeVO 객체를 매개변수로 받아와서, 이를 사용하여 새 직원을 추가하는 등의 애플리케이션 로직을 수행합니다. 그 후, "employeesDetail" 뷰를 반환합니다.

이렇게 컨트롤러를 정의하면 Spring MVC는 요청에 따라 적절한 핸들러 메서드를 호출하여 요청을 처리하고, 그 결과를 클라이언트에 반환합니다.

위의 코드에서 첫 번째 클래스 AppointmentsController와 두 번째 클래스 EmployeeController는 모두 스프링 MVC의 컨트롤러입니다. 그러나 두 클래스 간에는 몇 가지 차이가 있습니다.

URL 매핑:
AppointmentsController(class) : @RequestMapping("/appointments")로 지정되어 있어, 모든 핸들러 메서드는 /appointments 경로 아래에서 요청을 처리합니다.
EmployeeController(handler) : @RequestMapping("/employee-management/employees")로 지정되어 있어, 모든 핸들러 메서드는 /employee-management/employees 경로 아래에서 요청을 처리합니다.
HTTP 요청 메서드:
AppointmentsController(class) : 첫 번째 핸들러 메서드(get())는 HTTP POST 메서드와 매핑되어 있으며, 두 번째 핸들러 메서드(getNewForm())는 HTTP GET 메서드와 매핑되어 있습니다.
EmployeeController(handler) : 두 개의 핸들러 메서드 모두 명시적으로 HTTP 요청 메서드를 지정하지 않았으므로, 기본적으로 GET 요청에 매핑됩니다.
리턴 타입:
AppointmentsController(class) : 첫 번째 핸들러 메서드(get())는 Map<String, Appointment>을 반환하고, 두 번째 핸들러 메서드(getNewForm())는 AppointmentForm 객체를 반환합니다.
EmployeeController(handler) : 두 개의 핸들러 메서드 모두 String을 반환합니다. 첫 번째 메서드는 employeesList 문자열을 반환하고, 두 번째 메서드는 employeesDetail 문자열을 반환합니다.
이러한 차이점들은 각 컨트롤러가 서로 다른 경로와 요청 유형에 대한 요청을 처리하고, 각 핸들러 메서드가 다른 유형의 데이터를 반환한다는 것을 나타냅니다.

@Controller Example(추가적 설명)

Add attributes to the model

Retrieve request parameters as regular parameters

@RequestParam은 Spring MVC에서 HTTP 요청의 파라미터 값을 메서드의 매개변수로 바인딩할 때 사용되는 어노테이션입니다. 이 어노테이션을 사용하면 HTTP 요청의 쿼리 문자열이나 POST 요청의 폼 데이터를 메서드의 매개변수로 전달할 수 있습니다.

아래의 코드를 보면 doLogin() 메서드가 GET 방식의 "/login" 경로에 매핑되어 있습니다. 이 메서드는 @RequestParam 어노테이션을 사용하여 username과 password라는 두 개의 파라미터를 받고 있습니다. 클라이언트에서 요청이 들어오면 Spring MVC는 해당 요청의 쿼리 문자열에서 username과 password 파라미터를 찾아 해당 매개변수에 바인딩합니다.

즉, 이 메서드는 GET 방식으로 "/login" 경로에 요청이 들어오면 클라이언트가 전달한 username과 password를 받아와서 처리하는 역할을 합니다. 처리 후에는 성공 페이지의 경로인 success를 반환합니다.

* View

JSTL & prefix

<?xml version="1.0" encoding="UTF-8" ?>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>

<c:forEach var="i" begin="0" end="5">
	Item <c:out value="${i}"/><p>
</c:forEach>

<c:if test="${fn:length(friends) > 0}" >
	<%@include file="welcome.jsp" %>
</c:if>

JSTL(JavaServer Pages Standard Tag Library)은 JSP(JavaServer Pages)에서 자주 사용되는 반복, 조건 등의 로직을 간편하게 구현할 수 있도록 제공되는 라이브러리입니다. JSTL은 XML 형식으로 정의되어 있으며, JSP 페이지에서 사용하기 위해서는 <%@taglib %> 디렉티브를 사용하여 태그 라이브러리를 선언해야 합니다.

여기서 prefix는 태그 라이브러리에 정의된 각 태그를 식별하기 위한 접두사(prefix)를 의미합니다. JSP 페이지에서 JSTL 태그를 사용할 때는 해당 접두사와 태그 이름을 사용하여 태그를 참조합니다. 예를 들어, c:forEach는 JSTL Core 라이브러리에 정의된 반복 처리를 위한 태그이며, fn:length는 JSTL Functions 라이브러리에 정의된 함수를 호출하는 태그입니다.

아래는 주어진 코드에서 사용된 JSTL 태그들의 설명입니다:

1. <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>: 이 디렉티브는 JSTL Core 라이브러리를 사용하기 위한 것으로, c 접두사를 사용하여 해당 라이브러리의 태그들을 참조할 것임을 선언합니다.
2. <%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>: 이 디렉티브는 JSTL Functions 라이브러리를 사용하기 위한 것으로, fn 접두사를 사용하여 해당 라이브러리의 함수를 참조할 것임을 선언합니다.
3. <c:forEach var="i" begin="0" end="5">: 이 태그는 JSTL Core 라이브러리의 반복 처리를 위한 태그입니다. var 속성은 반복문 내에서 현재 항목을 참조할 변수명을 지정하고, begin과 end 속성은 반복 범위의 시작과 끝을 지정합니다.
4. <c:if test="${fn:length(friends) > 0}" >: 이 태그는 JSTL Core 라이브러리의 조건 처리를 위한 태그입니다. test 속성에는 조건을 지정하며, ${fn:length(friends) > 0}는 JSTL Functions 라이브러리의 fn:length() 함수를 사용하여 friends라는 객체의 길이가 0보다 큰지를 확인하는 조건입니다.

따라서 JSTL을 사용하면서 prefix를 설정하여 해당 라이브러리의 태그들을 쉽게 참조할 수 있으며, 반복, 조건 등의 로직을 간결하게 작성할 수 있습니다.

728x90

저작자표시

'📕JAVA > Spring' 카테고리의 다른 글

6week (0)	2024.04.21
5week (0)	2024.04.20
4week (0)	2024.04.04
2week (0)	2024.03.12
OT - 1week (0)	2024.03.05

'📕JAVA/Spring' Related Articles

Comments

C-log

3week - MVC 본문

3week - MVC

# MVC 생성(Controller&View)

### pom.xml은 무엇인가

## 지금까지의 패키지 파일 구조

### dispatch란?

### Servlet이란?

### dispatchServlet이란?

# MVC 구현(Model&Controller&View)

# MVC 통합테스트(MYSQL)

##중간고사를 위한 이론 정리

* Model

* Model은 어떻게 구현하는가

1. public String getGreeting(Map<String, Object> model ) { ... }

2. public String getGreeting(Model model ) { ... }

3. public String getGreeting(ModelMap model ) { ... }

* Controller

* View

'📕JAVA > Spring' 카테고리의 다른 글

티스토리툴바