[Spring] 기초

webpage.xml

spring + spring-boot 에서 beans 태그 사용함

1. beans를 사용하여 beans, bean 태그를 사용하여 Controller 및 환경설정

2. context : Spring 프레임워크의 bean에 대한 종속성을 관리하는 엔진 (package 그룹단위별로 관리)

3. mvc : Spring 프레임 워크의 Model, View, Controller 형태의 구성

beans : bean태그를 활성화 하는 부모태그

bean : 가상의 컨테이너 이며, id: 가상의 주소, class: 자바 경로

아래 두 줄은 같은 코드

<bean id="" class=""></bean> : 이거는 태그와 태그 사이에 다른 태그(옵션)를 넣을수있다는 점이 다름

<bean id="" class=""/> : 태그 안에 아무것도 안넣겠다는 뜻

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

이런 태그 사용 가능

여기서!!!

beans <-> mvc 바꿔주고

beans 태그를 beans:beans 로 바꿔주면

<?xml version="1.0" encoding="UTF-8"?>
<!-- mvc : mvc가 기본형태가 됐을 때 Spring에서 기본으로 MVC형태 코드를 작성하며 실행이 됨 -->
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:beans="http://www.springframework.org/schema/beans"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd 
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/mvc/spring-context.xsd 
      http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc.xsd">
      
	<!-- @를 이용하여 각 class 별로 MVC 형태 구현함 -->
	<annotation-driven></annotation-driven>
	<beans:bean class="spring_learning.mainpage"></beans:bean>
</beans:beans>

이런태그 사용 가능

webpage2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- mvc : mvc가 기본형태가 됐을 때 Spring에서 기본으로 MVC형태 코드를 작성하며 실행이 됨 -->
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:beans="http://www.springframework.org/schema/beans"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans.xsd 
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/mvc/spring-context.xsd 
      http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc.xsd">
      
	<!-- @를 이용하여 각 class 별로 MVC 형태 구현함 -->
	<annotation-driven></annotation-driven>
	
	<!-- resources : 패키지를 정하여 설정하는 태그 //지금은 그냥 다풀어둠 원래 이렇게 안씀 -->
	<resources location="/" mapping="/**"></resources>
		
	<!-- 
	View 형태를 어떤 형태의 파일로 보여지도록 할 것인지 환경설정
		prefix : jsp 파일이 모여있는 디렉토리를 설정 
		suffix : Controller에서 View 파일 속성을 설정할 수 있음
	-->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/"></beans:property>	<!-- 공부할라고 잠깐 보안열어둠 신경 ㄴ -->
		<beans:property name="suffix" value=".jsp"></beans:property>	<!-- suffix : 어떤 파일을 View로 만들지 -->
	</beans:bean>
	
	<!-- Controller의 패키지 및 class명을 설정하여 작동시킴 -->
	<beans:bean class="spring_learning.mainpage"></beans:bean>
	<beans:bean class="spring_learning.mainpage2"></beans:bean>
</beans:beans>

mainpage2.java

package spring_learning;

import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.ModelAndView;

//Spring Controller + View 기초 

//Controller : 여러개의 컨트롤을 한번에 다 때려박을수 있음 
//@Controller : 해당 일반 class를 web에서 작동할 수 있도록 변경하도록 함 
@Controller
public class mainpage {
	
	PrintWriter pw = null;

	//@GetMapping : doGet
	//@PostMapping : doPost
	//@RequestMapping : doService 실무에서는 잘 안씀 (get+post) 보안쓰레기
	
	//throws + HttpServletRequest + HttpServletResponse : View를 사용하지 않음 
	@GetMapping("/abc.do")	//get, post를 어노테이션으로 사용 
	public void abc(HttpServletRequest req, HttpServletResponse res) throws Exception {
		//인자 있으면 바로 이거실행 view없이 작동 
		res.setContentType("text/html;charset=utf-8");
		this.pw = res.getWriter();
		this.pw.write("<script>alert('어렵다 ㅎ..')</script>");
		this.pw.close();
		System.out.println("abc페이지");
	}

	//View 무조건 사용하는 메소드를 말함 
	//bbb.jsp를 찾음 없으면 404 뜸 
	//컨트롤 찾으면서 View를 찾아라 
	//인자 비어있으면 do찾으면서 view찾음 
	@PostMapping("/bbb.do")	
	public void bbb(HttpServletRequest req) {	
		//Front-end 값을 이관받음 
		String pdnm = req.getParameter("pdnm");
		//View(bbb.jsp)로 이관함 
		req.setAttribute("pdnm", pdnm);
	}
	
	//return 형태의 메소드는 View 파일명을 다르게 사용할 수 있음
	//기본은 return null : do와 이름을 같은 jsp를 찾게 됨
	//return "어쩌고"; : do와 다른 이름의 jsp를 찾게 됨 
	@PostMapping("/ccc.do")
	public String ccc(HttpServletRequest req) {
		String pdnm = req.getParameter("pdnm");
		req.setAttribute("pdnm", pdnm);
		return "/product_list";	//subfix 설정해둬서 .jsp붙이지 않아도 붙은것처럼 작동 	
		//return null이면 ccc.jsp를 찾음 
	}
	
	//request로 view(jsp)로 전달하는 방식이 아님 
	@PostMapping("/ddd.do")
	public ModelAndView ddd(HttpServletRequest req) {	//ModelAndView : 모델에 있는 값을 뷰로 전달		
		String pdnm = req.getParameter("pdnm");			
		String pcode = req.getParameter("pcode");
		String pmoney = req.getParameter("pmoney");
		
		//ModelAndView (기본 자료형 Object 배열)
		ModelAndView mv = new ModelAndView();
		
		mv.addObject("pdnm",pdnm);			//addObject : 키배열 형태로 값을 저장시킴 
		mv.addObject("pcode",pcode);
		mv.addObject("pmoney",pmoney);
		
		//setView : null은 Mapping 이름과 동일한 jsp를 찾음
		//mv.setView(null);
		//null이면 ddd.do 로 감 => 코드안쓴거랑 동일 
		//이거로 경로지정하려면 View 인터페이스를 사용햐야함 그래서 실무에서안씀 아래코드 사용 
		
		//다른 view로도 이동할 수 있음 
		//Mapping과 다른 이름을 사용하고 싶을 경우 
		mv.setViewName("bbb");	
		 
		return mv;	//무조건 ModelAndView 객체명을 사용해야함 
	}
	
	@PostMapping("/eee.do")
	public String eee(HttpServletRequest req, Model m) {
		String pdnm = req.getParameter("pdnm");			
		String pcode = req.getParameter("pcode");
		String pmoney = req.getParameter("pmoney");
		
		//Model(interface)를 이용하여 JSP로 값을 전달 (JSTL형태로 값 출력)
		m.addAttribute("pdnm",pdnm);
		m.addAttribute("pcode",pcode);
		m.addAttribute("pmoney",pmoney);
		
		return "ddd";
	}
}

@Controller

Spring MVC에서 컨트롤러 역할을 하는 클래스임을 선언하는 어노테이션.
클라이언트의 요청을 받아서 처리하고, 적절한 뷰를 반환함.
REST API 개발에는 @RestController를 사용해야 함.

요청 매핑 (Request Mapping)

클라이언트 요청을 특정 메서드와 매핑하는 기능
Spring 4.3 이후에는 @RequestMapping보다 @GetMapping, @PostMapping을 더 많이 사용

@GetMapping("/경로")	GET	데이터를 조회할 때 사용
@PostMapping("/경로")	POST	데이터를 생성하거나 처리할 때 사용
@RequestMapping("/경로")	GET + POST	여러 요청을 동시에 처리 (보안상 비추천)

1. abc(HttpServletRequest req, HttpServletResponse res)

@GetMapping("/abc.do")
public void abc(HttpServletRequest req, HttpServletResponse res) throws Exception {
    res.setContentType("text/html;charset=utf-8");
    this.pw = res.getWriter();
    this.pw.write("<script>alert('어렵다 ㅎ..')</script>");
    this.pw.close();
    System.out.println("abc페이지");
}

GET 요청을 처리 (@GetMapping("/abc.do"))
View 없이 직접 응답을 생성 (HttpServletResponse 사용)
클라이언트에게 JavaScript Alert 창을 띄우는 방식

주의할 점

HttpServletResponse를 직접 사용하는 방식은 비효율적이며, Spring에서는 거의 사용되지 않음
RestController가 아니라면 가급적 Model이나 ModelAndView를 활용하는 것이 좋음

2. bbb(HttpServletRequest req)

@PostMapping("/bbb.do")
public void bbb(HttpServletRequest req) {	
    String pdnm = req.getParameter("pdnm");
    req.setAttribute("pdnm", pdnm);
}

POST 요청을 처리 (@PostMapping("/bbb.do"))
클라이언트에서 전달받은 pdnm 값을 JSP로 전달 (req.setAttribute)
별도로 return이 없어서 기본적으로*bbb.jsp를 찾음
만약 해당 JSP 파일이 없으면 404 오류 발생

3. ccc(HttpServletRequest req)

@PostMapping("/ccc.do")
public String ccc(HttpServletRequest req) {
    String pdnm = req.getParameter("pdnm");
    req.setAttribute("pdnm", pdnm);
    return "/product_list";
}

POST 요청을 처리 (@PostMapping("/ccc.do"))
return "/product_list";
→ JSP 파일(product_list.jsp)로 이동
return null;이면 ccc.jsp를 자동으로 찾음

주의할 점

req.setAttribute()는 JSP에서 JSTL 없이 데이터를 바로 출력할 수 없음
JSTL을 사용할 경우 Model 객체를 사용하는 것이 적절

4. ddd(HttpServletRequest req)

@PostMapping("/ddd.do")
public ModelAndView ddd(HttpServletRequest req) {	
    String pdnm = req.getParameter("pdnm");			
    String pcode = req.getParameter("pcode");
    String pmoney = req.getParameter("pmoney");

    ModelAndView mv = new ModelAndView();
    mv.addObject("pdnm", pdnm);
    mv.addObject("pcode", pcode);
    mv.addObject("pmoney", pmoney);

    mv.setViewName("bbb");	// "bbb.jsp"로 이동
    return mv;
}

POST 요청을 처리 (@PostMapping("/ddd.do"))
ModelAndView를 사용하여 데이터 전달 및 뷰 지정
addObject("키", 값)을 사용하여 데이터를 JSP로 전달
mv.setViewName("bbb"); → "bbb.jsp"로 이동
JSTL 사용 가능 (${pdnm} 형태로 데이터 출력)

ModelAndView 특징

ModelAndView는 데이터(Model)와 뷰(View)를 함께 처리할 수 있는 객체
하지만 Model 객체를 사용하는 것이 더 일반적
최근 Spring Boot에서는 ModelAndView보다 Model을 선호

5. eee(HttpServletRequest req, Model m)

@PostMapping("/eee.do")
public String eee(HttpServletRequest req, Model m) {
    String pdnm = req.getParameter("pdnm");			
    String pcode = req.getParameter("pcode");
    String pmoney = req.getParameter("pmoney");

    m.addAttribute("pdnm", pdnm);
    m.addAttribute("pcode", pcode);
    m.addAttribute("pmoney", pmoney);

    return "ddd";
}

POST 요청을 처리 (@PostMapping("/eee.do"))
Model 객체를 사용하여 데이터를 전달 → JSTL에서 활용 가능
return "ddd"; → "ddd.jsp"로 이동
req.setAttribute() 대신 m.addAttribute()를 사용하여 JSP에서 JSTL을 활용 가능

Model 사용의 장점

Model 객체를 사용하면 JSP에서 JSTL을 사용하여 데이터를 쉽게 출력 가능
ModelAndView보다 간결하고 현대적인 방식

<!-- ddd.jsp -->
<p>상품명: ${pdnm}</p>
<p>상품코드: ${pcode}</p>
<p>상품가격: ${pmoney}</p>

실무에서 추천하는 방식

방법 장점 단점 실무 사용 여부

HttpServletResponse 사용	빠르게 응답 가능	유지보수 어려움, 비효율적	❌ 거의 안 씀
HttpServletRequest.setAttribute() 사용	JSP에서 바로 사용 가능	JSTL 사용 불가, 코드가 지저분해짐	⚠️ 거의 안 씀
ModelAndView 사용	Model + View를 한 번에 처리	Model보다 코드가 길어짐	⭕ 일부 사용
Model 사용 (addAttribute())	가장 현대적, JSTL 사용 가능	없음	✅ 추천

1️⃣ View 없이 응답 (HttpServletResponse) → 추천 X
2️⃣ JSP로 데이터 전달 (HttpServletRequest) → 추천 X
3️⃣ ModelAndView 사용 (addObject) → 가능하지만 최근엔 잘 안 씀
4️⃣ Model 사용 (addAttribute) → 가장 일반적인 방식 (추천 ✅)

지금은 Model 방식이 가장 널리 쓰이고, RestController를 활용한 API 개발이 주류
+ @RestController, ResponseEntity, DTO 등 공부

db_config.xml

이 XML 파일은 Spring의 설정 파일로, 애플리케이션에서 사용할 다양한 설정을 정의
특히 DB 연결 설정과 관련된 빈(Bean) 구성이 포함

<?xml version="1.0" encoding="UTF-8"?>
<beans
   xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:mvc="http://www.springframework.org/schema/mvc"
   xmlns:cache="http://www.springframework.org/schema/cache"
   xmlns:jdbc="http://www.springframework.org/schema/jdbc"
   xmlns:mybatis-spring="http://www.springframework.org/schema/mybatis-spring"
   xmlns:util="http://www.springframework.org/schema/util"
   xsi:schemaLocation="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                   
                  http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
                  http://www.springframework.org/schema/cache https://www.springframework.org/schema/cache/spring-cache.xsd
                  http://www.springframework.org/schema/jdbc https://www.springframework.org/schema/jdbc/spring-jdbc.xsd
                  http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd
                  http://mybatis.org/schema/mybatis-spring https://mybatis.org/schema/mybatis-spring.xsd
                  ">
	<!-- DB접속 정보 활성화하는 XML -->
	<context:annotation-config/>	<!-- Model에서 DB를 사용할 수 있도록 함 -->
	<!-- Connection 데이터베이스 정보 -->
	<!-- destroy-method="close" : 문법이 완료되었을 경우 자동으로 Database를 종료 -->
	<bean id="dbinfo" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
	<property name="url" value="디비주소"/>
	<property name="username" value="사용자이름"/>
	<property name="password" value="비번"/>
	</bean>
</beans>

1. XML 네임스페이스 및 XSD 스키마 설정

<beans>부분은 Spring XML 설정에서 네임스페이스와 XSD 스키마를 정의
다양한 Spring 기능을 활성화할 수 있도록 여러 네임스페이스를 선언

네임스페이스 설명

beans	Spring 빈 설정
context	@ComponentScan, @Bean 등을 사용하여 Spring 컨테이너 설정
mvc	Spring MVC 설정 (DispatcherServlet, View Resolver 등)
cache	Spring의 캐시 기능 활성화
jdbc	데이터베이스 관련 설정 (JDBC)
mybatis-spring	MyBatis 연동을 위한 설정
util	유틸리티 관련 설정 (리스트, 맵 등)

xsi:schemaLocation

각 네임스페이스가 어떤 스키마(XSD 파일)를 참조하는지 명시
https://www.springframework.org/schema/... 경로에서 해당 스키마 정보를 가져옴
Spring이 XML을 검증할 때 사용됨

2. Spring에서 DB 연동을 위한 설정

<!-- DB 접속 정보 활성화 -->
<context:annotation-config/>	<!-- Model에서 DB를 사용할 수 있도록 설정 -->

<context:annotation-config/>

Spring이 @Autowired, @Resource, @PostConstruct 같은 어노테이션을 인식할 수 있도록 설정
특히 DAO에서 @Autowired로 DB 객체를 주입할 때 필요

3. 데이터베이스 연결 설정

<!-- Connection 데이터베이스 정보 -->
<!-- destroy-method="close" : 스프링 컨테이너 종료 시 DB 커넥션을 자동으로 닫음 -->
<bean id="dbinfo" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mrp"/>
    <property name="username" value="project"/>
    <property name="password" value="a123456"/>
</bean>

<bean> 태그를 활용한 DB 연결

이 설정을 통해 MySQL 데이터베이스에 접속할 수 있음.

속성 값 설명

id="dbinfo"	dbinfo	빈의 ID (주입할 때 사용)
class="org.apache.commons.dbcp.BasicDataSource"	BasicDataSource	Apache Commons DBCP를 사용한 커넥션 풀 설정
destroy-method="close"	close	스프링 종료 시 DB 연결 해제

MySQL 접속 정보 설정

속성 값 설명

driverClassName	MySQL JDBC 드라이버 (8.x 버전)
url	MySQL 서버 주소 (DB명: mrp)
username	DB 접속 계정
password	DB 접속 비밀번호

결론: XML 설정을 통해 데이터베이스 연동하는 방법

1. 네임스페이스 선언 (xmlns)
→ Spring의 다양한 기능을 사용하기 위해 필요한 설정 추가

2. <context:annotation-config/> 추가
→ DAO에서 @Autowired를 사용하여 DB 객체 주입 가능

3. DB 커넥션 풀 설정 (BasicDataSource)

driverClassName, url, username, password를 설정
destroy-method="close"로 스프링 종료 시 자동으로 DB 연결 닫기

+ MyBatis 또는 JPA와 함께 활용

mainpage2.java

package spring_learning;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.dbcp.BasicDataSource;
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 org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;


@Controller
public class mainpage2 {
	
	//WEB-INF 파일 : Controller, Model이 접근할 수 있는 디렉토리 (브라우저에서는 접근불가) 
	//return 사용시 WEB-INF/디렉토리명/파일명 형태로 구성하게됨 => 진짜 MVC
	
	/*
	DTO로 Front-end의 값을 받을 수 있음 (lombok)
	별도의 값을 받아서 처리해야 할 경우는 Servlet 형태의 request로 받으면 됨 
	⭐Front의 name값과 동일하겨 DTO가 작성되어야 함⭐
	
	DTO 활용 : Front-end 값 이관, Model에 값을 이관, Database에서 사용 
	*/
	@GetMapping("/login.do")
	public String login(user_DTO dto, HttpServletRequest req, Model m) {
		String ck = req.getParameter("mcheck");
		System.out.println(ck);
		
		//Model로 해당 jsp에 변수를 이관함 출력은 jstl 변수 선언으로 출력 
		m.addAttribute("mid",dto.getMid());
		
//		System.out.println(dto.getMid());
//		System.out.println(dto.getMpass());
		System.out.println(dto.getMemail());
		return "WEB-INF/view/login";	//=> login.jsp는 강제실행이 불가능함! Controller가 해줘야함 
	}
	
	
	
	//@Autowired : java에서 사용하는 class 또는 interface의 값을 xml에 있는 id 기준으로 대체하는 형태 
	//문서파일을 자바파일에 주입시키는거 (의존성 주입) 
	@Autowired
	BasicDataSource dbinfo;
	
	//DB Query문 작성 및 데이터를 가져오기 위한 interface
	Connection con = null;
	PreparedStatement ps = null;
	ResultSet rs = null;
	//Database + XML + Connection + Controller
	@GetMapping("/event_list.do")
	public String event_list(HttpServletRequest req) {
		 try {
			 //db_config.xml에 있는 정보를 Connection으로 이관 
	         this.con = this.dbinfo.getConnection();
	         String sql="select * from event order by eidx desc";
	         this.ps = this.con.prepareStatement(sql);
	         this.rs = this.ps.executeQuery();
	         
	         /*
	         ResultSet을 JSP로 전송 (올바른 코드가 아님)
	         단점 : this.ps, this.rs close()가 불가능함 
	         */
	         req.setAttribute("rs", this.rs);	
	      } catch (Exception e) {
	         
	      }finally {
	         try {
	        	 this.rs.close();
	        	 this.ps.close();
	         }catch (Exception e) {
				
			}
	      }
	      return null;
	   }
	
	/*
	 RequestMapping : GET POST PUT 등등 모든 통신을 다 받을 수 있음 (기본) => 보안이 굉장히 약함
	 value 속성 : 가상의 경로 
	 method 속성 : 통신방법(Front-end 데이터 이관 방법)
	 이런 속성들을 알고있으면 써도 되기는 함 
	 */
//	@RequestMapping("/event_infook.do") : 이렇게 쓰면 보안 다뚫림 쓰레기 
	@RequestMapping(value="/event_infook.do",method=RequestMethod.POST)	//이렇게 쓰면 POST만 받는다는 의미 잘쓴 RequestMapping
	public String eventok(event_DTO dto) {
		try {
			this.con = this.dbinfo.getConnection();
			String sql = "insert into event values ('0',?,?,?,?,?,?,now())";
			this.ps = this.con.prepareStatement(sql);
			this.ps.setString(1, dto.getEname());
			this.ps.setString(2, dto.getEtel());
			this.ps.setString(3, dto.getEmail());
			this.ps.setString(4, dto.getInfo1());
			this.ps.setString(5, dto.getInfo2());
			this.ps.setString(6, dto.getEmemo());
			int result = this.ps.executeUpdate();
			System.out.println(result);
			
			
		}catch (Exception e) {
			
		}finally {
			try {
				this.ps.close();
			}catch (Exception e) {
				
			}
		}
		return null;
	}
}

1. Controller 클래스 선언

@Controller
public class mainpage2 {

@Controller 어노테이션

이 클래스가 Spring MVC의 Controller 역할을 수행한다고 선언
HTTP 요청을 처리하고, View로 데이터를 넘겨주는 역할

2. 로그인 처리 (/login.do)

@GetMapping("/login.do")
public String login(user_DTO dto, HttpServletRequest req, Model m) {
    String ck = req.getParameter("mcheck");
    System.out.println(ck);
    
    // Model로 해당 JSP에 변수를 이관 (JSTL에서 사용 가능)
    m.addAttribute("mid", dto.getMid());
    
    System.out.println(dto.getMemail());

    return "WEB-INF/view/login";  // JSP 직접 실행 불가! 반드시 Controller를 거쳐야 함.
}

DTO 활용 (user_DTO)

Front-end에서 넘어온 값을 DTO로 받음 (name 속성과 DTO 필드명이 동일해야 함)
user_DTO에 담긴 데이터를 Model을 통해 View로 전달
JSTL을 사용해 View(jsp)에서 mid 값을 출력할 수 있음

JSP 경로 (WEB-INF/view/login.jsp)

"WEB-INF/view/login"을 반환하면 Spring이 WEB-INF/view/login.jsp를 찾아 렌더링
WEB-INF 아래의 JSP 파일은 브라우저에서 직접 실행할 수 없고, 반드시 Controller를 통해 접근해야 함
보안상 안전한 방식

3. 데이터베이스 연결 설정 (@Autowired)

@Autowired
BasicDataSource dbinfo;

@Autowired 어노테이션

XML에서 설정한 dbinfo 빈을 Java 코드에 자동 주입
DB 연결 정보 (BasicDataSource)를 사용할 수 있도록 설정

Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;

DB 연결 객체 (Connection) 선언
SQL 실행을 위한 PreparedStatement 및 결과 저장을 위한 ResultSet 선언

4. 이벤트 리스트 조회 (/event_list.do)

@GetMapping("/event_list.do")
public String event_list(HttpServletRequest req) {
    try {
        // XML에 설정된 DB 정보를 가져와서 Connection 객체로 생성
        this.con = this.dbinfo.getConnection();
        
        // 이벤트 목록 조회 SQL 실행
        String sql = "SELECT * FROM event ORDER BY eidx DESC";
        this.ps = this.con.prepareStatement(sql);
        this.rs = this.ps.executeQuery();
        
        // 결과를 JSP로 전달 (비추천 방식)
        req.setAttribute("rs", this.rs);
        
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            this.rs.close();
            this.ps.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return null;
}

SQL 실행 과정

dbinfo.getConnection() → DB 연결
SQL 실행 → SELECT * FROM event ORDER BY eidx DESC
ResultSet을 request에 저장 (req.setAttribute("rs", this.rs))

⚠ ❗ 문제점 (비추천 방식)

ResultSet은 JSP에서 직접 다루기 어려움
this.rs.close()를 JSP에서 하지 못하므로 메모리 누수 위험
→ DTO를 활용해 데이터 전달하는 방식으로 변경하는 게 좋음

5. 이벤트 정보 처리 (/event_infook.do)

@RequestMapping(value = "/event_infook.do", method = RequestMethod.POST)
public String eventok(event_DTO dto) {
    System.out.println(dto.getEmail());
    System.out.println(dto.getEtel());
    return null;
}

@RequestMapping 대신 @PostMapping 사용하는 게 좋음

@RequestMapping(value = "/event_infook.do", method = RequestMethod.POST) → @PostMapping("/event_infook.do")
보안 강화를 위해 method = RequestMethod.POST을 명시적으로 선언

DTO (event_DTO) 활용

email, etel 값을 event_DTO 객체로 전달받아 사용
System.out.println(dto.getEmail()); → 콘솔에서 확인 가능

결론

1. 로그인 처리 (/login.do)

DTO (user_DTO)를 사용하여 Front-end 데이터 받기
Model을 사용하여 JSP로 데이터 전달

2. 데이터베이스 연동 (@Autowired)

BasicDataSource를 활용하여 DB 연결
SQL 실행 및 결과 조회 (ResultSet)

3. 이벤트 목록 조회 (/event_list.do)

PreparedStatement로 SQL 실행 후 JSP로 데이터 전달
비추천 방식 (ResultSet을 직접 JSP로 넘김)
DTO를 사용하여 데이터 전달하는 방식이 더 좋음

4. 이벤트 정보 처리 (/event_infook.do)

DTO를 활용하여 데이터를 안전하게 전달받고 처리
@PostMapping을 사용하여 보안 강화

event_DTO.java

package spring_learning;

import lombok.Getter;
import lombok.Setter;

@Setter
@Getter
public class event_DTO {
	int eidx;
	String ename, etel, email, info1, info2, ememo, ejoin;
}

Lombok 라이브러리 사용 (어노테이션 활용 @Getter, @Setter)

@Getter → 모든 필드에 대한 getter 메서드 자동 생성
@Setter → 모든 필드에 대한 setter 메서드 자동 생성
코드가 간결해지고 유지보수가 쉬워짐

커맨드 + O 를 이용해서 보이지않는 getter, setter 볼 수 있음

저작자표시 비영리 변경금지 (새창열림)

webpage.xml

webpage2.xml

mainpage2.java

실무에서 추천하는 방식

db_config.xml

mainpage2.java

event_DTO.java

티스토리툴바