web & spring 정리

- 서블릿 매핑방식

 1) web.xml

 

 

 - <servlet> 속성

  : servlet-name & servlet-class

 

 - <servlet-mapping> 속성

  : servlet-name & url-pattern

 

 

2) annotation 이용

 

- scope  + session 얻어오는 방식

 

1) request scope  ===> HttpServletRequest
 *   범위: 요청 ~ 응답
 *   적용: jsp에서 데이터를 보여주고 끝나는 작업의 데이터
 *   ex) 게시판의 목록 보여주기
 *   
 *  2) session scope  ===> HttpSession
 *   범위: 브라우저 close할 때까지, 보안때문에 timeout 적용해서 일정시간동안 
 *   요청이 없으면 삭제됨
 *   적용: 브라우저가 종료전까지 유지가 되는 데이터. 대표적으로 장바구니, 로그인
 *   
 *  3) application scope ===> ServletContext
 *   범위: tomcat 서버 close할때까지 사용 가능

 

protected void doGet(HttpServletRequest request, 
			HttpServletResponse response) throws ServletException, IOException {
		
		//data를 언제까지 사용할 수 있을지 테스트 - forward
		
		//request scope 저장
		request.setAttribute("request","request" );
		
		//session scope 저장
		HttpSession session = request.getSession();
		session.setAttribute("session", "session");
		
		
		//application scope
		ServletContext ctx = getServletContext();
		ctx.setAttribute("application", "application");
		
        //forward
		RequestDispatcher dis = request.getRequestDispatcher("info.jsp");
		dis.forward(request, response);
		
        //redirect
        response.sendRedirect("info.jsp");
		
	}

 

+ redirect, forward방식 

 forward방식은 같은 request를 사용하기 때문에 RequestDispatcher를 활용하는 방식

 redirect는 바로 .jsp로 요청 ==> 그렇기 때문에 url이 .jsp로 변경된다.

 

 

-용어정리 (IoC, POJO, DI)

oC 

 

- DI: 객체간의 의존 관계를 생성자 인수(constructor argument)나 setter method arguments로 명시하고, 객체를 생성할 때 생성자나 세터를 통해 의존 관계를 주입하는 방식을 따르는 디자인 패턴이다.

 

- 스프링 IoC 컨테이너는 스프링 애플리케이션에서 존재하는 객체를 생성하고, 의존 관계를 주입하는 일을 담당한다.

 

- 의존 관계를 만들고 주입하는 책임은 애플리케이션의 객체가 아닌 스프링 컨테이너에 있기 때문에 DI를 IoC(제어의 역전) 이라고도 부른다. * 일반 형태처럼 new를 사용해서 handling 하는 것이 아니다.

 

- 스프링 컨테이너가 애플리케이션 객체에 추가 기능을 부여하고 애플리케이션 객체를 평범한 자바 객체 POJO(Plain Old Java Object)로 모델링할 수 있다.

 

=> 한마디로 POJO 클래스는 프레임워크가 지정하는 인터페이스나 클래스를 구현/ 확장하지 않는 자바 클래스

* 모든 빈은 독립적인 빈(클래스)로 작성할 수 있다. => POJO(Plain Old Java Object)

 

 

- Injection 방식

 

 MyBatis 연동 ///제어의 역행(Inversion of Control:IoC) 
 빈끼리의 연동방법은 외부에서 주입방법을 사용한다(의존성 주입:Dependency Injection -DI)

1.constructor 주입 : 생성자 주입방식

public class DBService {
	
	//변수, property
	public String name;

	public DBService() {
	}

	//생성자 주입
	public DBService(String x) {
		System.out.println("DBService 생성자~~~~");
		this.name = x;
	}
	
}

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

	<bean id="xyz" class="com.service.DBService">
		<constructor-arg name="x" value="홍길동"/>
	</bean>
	<bean id="aaa" class="com.service.MyService">
		<constructor-arg name="name" value="이순신"/>
		<constructor-arg name="age" value="40"/>
	</bean>
</beans>

=> constructor-arg를 활용하여 주입

2.setter 주입 : set method 활용

public class DBService {
	
	//변수, property
	public String name;

	public DBService() {
		System.out.println("DBService 생성자");
	}

	//setter- based injection
	public void setName(String name) {
		System.out.println("setName 메서드");
		this.name = name;
	}
}

 

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="xyz" class="com.service.DBService">
		<property name="name" value="홍길동"></property>
	</bean>
	<!-- setter 주입방법 -->
	<bean id="aaa" class="com.service.MyService">
		<property name="name" value="이순신"></property>
		<property name="age" value="40"></property>
	</bean>
</beans>

=> property를 활용

 

- component scan

: @ 이 부여된 클래스들을 자동으로 스캔해서 빈으로 등록한다. 

*예시에서는 com.*에 있는  @Service, @Repository, @Controller, @Component등과 같이 클래스 레벨로 지정된 빈들을 자동으로 등록하게 된다.

<!-- 
	 	base-package="com.*"형식과 같이
	 	패키지를 지정하면 자동으로 지정된 패키지내에 존재하는 빈들이 자동생성된다.
	 	단, @Service, @Repository, @Controller, @Component등과 같이
	 	클래스 레벨로 지정된 빈들만 해당된다.
	 	
	 	<context:component-scan 내에 어노테이션 활성화 기능이 내장됨(annotation-config가 내장)
	  -->
	 <context:component-scan base-package="com.*"/>

 

- ViewResolver

:  servlet-context.xml 에서 등록

 * servlet-context.xml 에서는 웹 환경과 의존되는 빈 등록( 웹환경과 의존적이지 않은 빈 등록 가능)
1. Controller
2. ViewResolver 

<bean id="viewResolver" class ="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name ="prefix" value="/WEB-INF/views/"/>
		<property name ="suffix" value=".jsp"/>
	</bean>

viewresolver를 등록하기 전에는 명시적으로 파일 경로를 입력해야함 

ex ) return "/WEB-INF/views/hello.jsp" 

 

등록 후에는

//  http://localhost:9000/app/xyz
	@RequestMapping("/xyz")
	public String method() {
		System.out.println("MainController.method");
		//file명만 알려주면 됨 - viewResolver를 등록했기 때문에
		return "hello";
	}
	

 

- parameter를 넘기는 방식

 

1) ?

 *이부분이 확실하지는 않지만 기억으로는 ---?num=1 이런식으로 넘겨졌던 것 같다.

 

2) REST

: 하나의 URI가 고유한 리소스를 다루는 공통적인 규칙을 가지는 방식

ex) board/2  => board라는 값은 게시판의 리소스를 가진다. /2는 게시판의 2번째 글을 달라

 

+@RequestParam과 @PathVariable 

설명을 적기가 힘들다.. 참고용 블로그 

elfinlas.github.io/2018/02/18/spring-parameter/

	@RequestMapping("/loginForm")
	public String loginForm() {
		System.out.println("loginForm");
		return "loginForm"; // WEB-INF/views/loginForm.jsp를 찾아줌
	}
	
	//이론시험
	@RequestMapping("/login")
	public String login(@ModelAttribute User user) {
		System.out.println("login");
		System.out.println(user);
		return "loginForm";
	}
	
	//modelattribute 생략
	@RequestMapping("/login6")
	public String login6(User user) {
		System.out.println("login");
		System.out.println(user);
		return "loginForm";
	}
	
	@RequestMapping("/login2")
	public String login2(@RequestParam("userid")String id, 
			@RequestParam("passwd")String pw) {
		System.out.println("login");
		System.out.println(id+"\t"+pw);
		return "loginForm";
	}
	
	//변수명과 param이 같으면 생략가능
	@RequestMapping("/login3")
	public String login3(@RequestParam String userid, 
			@RequestParam String passwd) {
		System.out.println("login");
		System.out.println(userid+"\t"+passwd);
		return "loginForm";
	}
	
	//변수명과 param이 같으면 생략가능
	@RequestMapping("/login4")
	public String login4(String userid, 
			String passwd) {
		System.out.println("login");
		System.out.println(userid+"\t"+passwd);
		return "loginForm";
	}
	
	//map은 requestparam을 꼭 지정해줘야함
	@RequestMapping("/login5")
	public String login5(@RequestParam Map<String, String >map) {
		System.out.println("login");
		System.out.println(map);
		return "loginForm";
	}

 

- getMapping & PostMapping 

RequeestMapping대신 사용

//@GetMapping
	//@RequestMapping(value="/login", method = RequestMethod.GET)
	@GetMapping("/login")
	public String login(User user) {
		System.out.println("login:GET");
		System.out.println(user);
		return "loginForm";
	}
	
	//@PostMapping - requestmapping 대신 사용 가능
	//@RequestMapping(value="/login2",method = RequestMethod.POST)
	@PostMapping("/login2")
	public String login2(User user) {
		System.out.println("login:POST");
		System.out.println(user);
		return "loginForm";
	}

 

- dto 형식으로 받아올때 방식

 * dto: User

@RequestMapping("/list")
	public String list(Model m) {
		m.addAttribute("username","홍길동");
		m.addAttribute("age",10);
		return "list"; //WEB-INF/views/list.jsp
	}
	
	@RequestMapping("/list2")
	public String list2(Map<String,User> map) {
		map.put("xxx", new User("hong","10"));
		
		return "list2"; //WEB-INF/views/list.jsp
	}
	
	@RequestMapping("/list3")
	public String list3(@ModelAttribute("xyz") ArrayList<User> list) {
		list.add(new User("hong","10"));
		list.add(new User("hong2","20"));
		list.add(new User("hong3","30"));
		return "list3"; //WEB-INF/views/list.jsp
	}

 

- jsp의 요청파라미터를 얻는 방법 

1) dto class

2) RequestParam

	//뷰만 지정된 형태로서 리턴타입이 String이면 JSP 파일명을 의미한다.
	//이름이 같아도 메소드 전달방식이 다르기 때문에 충돌이 나지 않는다.
	@RequestMapping(value="/login", method=RequestMethod.GET)
	public String loginForm() {
		return "loginForm";
	}
	
	//jsp의 요청파라미터 얻는 방법 2 - dto class
	@RequestMapping(value="/login", method=RequestMethod.POST)
	public String login(@ModelAttribute("xxx") User user) { //request.setAttribute("user", user)동일
		
		System.out.println(user);
		return "login";  //  /WEB-INF/views/login.jsp
	}
	
	//jsp의 요청파라미터 얻는 방법 1 - @RequestParam 사용
	@RequestMapping(value="/login", method=RequestMethod.POST)
	public String login(@RequestParam String userid,//이전 request.getParameter("userid")와 동일
			@RequestParam String passwd) {
		
		System.out.println(userid+"\t"+passwd);
		
		return "login";
	}

 

+ redirect, forward 추가 

//redirect
	@RequestMapping("/xxx")
	public String xxx(Model m) {
		System.out.println("xxx>>>");
		//main에서는 이 값을 보여줄 수가 없음 - redirect라서 request가 다르므로
		m.addAttribute("username", "홍길동");
		
		//xxx로 요청하면 main으로 redirect
		return "redirect:main";
	}
	
	//forward
	@RequestMapping("/yyy")
	public String yyy(Model m) {
		System.out.println("yyy>>>");
		//forward기 때문에 가져올 수 있다. & url변경도 안됨
		m.addAttribute("username", "홍길동");
		
		return "forward:main";
	}

 

- ResponseBody 

: 자바 객체를 HTTP 요청의 body 내용으로 매핑하는 역할

jsp가 아닌 값자체로 해석하기 때문에 jsp가 없어도 에러가 나지 않는다.

 + @RestController  => @Controller + @ResponseBody 가 혼합됨

//main.jsp가 없으니 에러남
	@RequestMapping("/main")
	public User main() {
		User user = new User("hong","1245");
		return user;
	}
	
	@RequestMapping("/main2")
	@ResponseBody   // -> 덕분에 user를 모델로 보지 않음
	public User main2() {
		User user = new User("hong","1245");
		return user;
	}