스프링에서 controller로 이동시 veiw에서 url로 파라미터를 전달할 수 있는데, 대표적 형태가 2가지 형태가 있다.

1유형 : http://www.test.com/board?seq=1
2유형 : http://www.test.com/board/1

 

@PathVariable 과 @RequestParam어노테이션은 url파라미터로 전달받은 value를 메서드의 파라미터로 받을 수 있게 해주는 어노테이션이다.

 

 

@RequestParam사용법

1유형 : http://www.test.com/board?seq=2
@GetMapping("/board")
public String save(@RequestParam("seq") int seq){
    .....
}

위와 같을 경우 int seq로 들어온 값은 1이 된다.

 

파라미터의 value로 null이 들어오는 것을 방지하기 위해선 아래와 같이 required 설정을 false로 한다. (defualt : true)

String형으로 데이터 타입을 변환한 이유는 seq가 ""이 들어올 경우 NumberFormatException이 발생하게 된다.

@GetMapping("/board")
public String save(@RequestParam(value = "seq", required = false) String seq){
    .....
}

 

 

@PathVariable 사용법

2유형 : http://www.test.com/board/1
@GetMapping("/board/{seq}")
public String save(@PathVariable int seq){
    .....
}

 

위와 같을 경우 int seq로 들어온 값은 1이 된다.

주의할 점은 URL에 특수문자나 구분기호 " , , ` , . " 등을 사용하면 인식을 못한다.

@GetMapping("/board/{seq}")
public String save(@PathVariable("seq") int num){
    .....
}

변수명을 바꿔서 사용하고 싶은 경우 @PathVariable('템플릿 변수명') url로 들어온 템플릿 변수명과 맵핑을 시켜주면 된다.

 

@RequestParam와 @PathVariable 복합 사용법

http://www.test.com/user/user?name=test
@PostMapping("/user/{category}")
public String save(@PathVariable("category") String category, @RequestParam(value = "name", required = false) String name){
    ....
}

위와 같이 코드를 실행하게 되면 category = user, name = test가 된다.

Spring Security란? 

영어에서 번역됨-Spring Security는 엔터프라이즈 애플리케이션에 대한 인증, 권한 부여 및 기타 보안 기능을 제공하는 Java / Java EE 프레임 워크입니다. 위키백과(영어)

 

본인이 이해한 바로는.. 특정페이지에 대한 접근을 제어하거나 권한을 부여할 때 사용하거나,

DB의 저장되는 비밀번호를 암호화 해줄 때 사용한다. (그 외에도 많겠지만..)

 

 

우선 SpringBoot에서 Security를 사용하기 위해선.. (Spring Boot + gradle 기준)

build.gradle파일에서 dependencies 안에 추가해준다.

implementation 'org.springframework.boot:spring-boot-starter-security'

 

자 이제 Security의 설정을 하기 위해 Config파일을 생성한다. (클래스명은 본인 맘대로!)

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean // 로그인 시 실행되는 메소드
    public AuthenticationProvider authenticationProvider(){return new LoginAuthenticationProvider();}

    @Bean // 로그인 성공 시 실행되는 메소드 
    public AuthenticationSuccessHandler successHandlerHandler() {
        return new LoginSuccessHandler();
    }

    @Bean // 로그인 실패 시 실행되는 메소드
    public AuthenticationFailureHandler failureHandlerHandler() {
        return new LoginFailureHandler();
    }

    @Bean // 패스워드 암호화 관련 메소드
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/css/**", "/js/**");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()// 세션을 사용하지 않고 JWT 토큰을 활용하여 진행, csrf토큰검사를 비활성화
                .authorizeRequests() // 인증절차에 대한 설정을 진행
                .antMatchers("/", "/error/*", "/login", "/loginProc").permitAll() // 설정된 url은 인증되지 않더라도 누구든 접근 가능
                .anyRequest().authenticated()// 위 페이지 외 인증이 되어야 접근가능(ROLE에 상관없이)
                .and()
                .formLogin().loginPage("/login")  // 접근이 차단된 페이지 클릭시 이동할 url
                .loginProcessingUrl("/loginProc") // 로그인시 맵핑되는 url
                .usernameParameter("userId")      // view form 태그 내에 로그인 할 id 에 맵핑되는 name ( form 의 name )
                .passwordParameter("userPw")      // view form 태그 내에 로그인 할 password 에 맵핑되는 name ( form 의 name )
                .successHandler(successHandlerHandler()) // 로그인 성공시 실행되는 메소드
                .failureHandler(failureHandlerHandler()) // 로그인 실패시 실행되는 메소드
                .permitAll()
                .and()
                .logout() // 로그아웃 설정
                .logoutUrl("/logout") // 로그아웃시 맵핑되는 url
                .logoutSuccessUrl("/") // 로그아웃 성공시 리다이렉트 주소
                .invalidateHttpSession(true); // 세션 clear
    }
}

 설명을 해 보자면..

 

- @Configuration

환경 세팅(스프링의 기본 설정 정보들)을 돕는 어노테이션

클래스의 어노테이션을 @Configuration라고 선언하면 스프링에게 이 클래스는 환경 구성 파일이고 @Bean 어노테이션을 통하여 Bean임을 알려주게 된다.

 

- @Bean

개발자가 작성한 메서드의 return 되는 객체를 Bean으로 만드는 것이다.

 

그렇다면 Bean은 무엇일까?

Spring IoC 컨테이너가 관리하는 자바 객체를 빈(Bean)이라고 한다.

 

- WebSecurityConfigurerAdapter

스프링 시큐리티 설정에 관련된 클래스로 해당 클래스에 있는 메서드를 오버라이딩하여 시큐리티를 설정한다.

 

 

로그인에 관련된 메서드 : return되는 클래스들은 커스텀으로 구현하여야 한다.

@Bean
public AuthenticationProvider authenticationProvider(){return new LoginAuthenticationProvider();}

@Bean
public AuthenticationSuccessHandler successHandlerHandler() {
    return new LoginSuccessHandler();
}

@Bean
public AuthenticationFailureHandler failureHandlerHandler() {
    return new LoginFailureHandler();
}

 

패스워드 암호화와 관련된 메소드

@Bean
public PasswordEncoder passwordEncoder(){
    return new BCryptPasswordEncoder();
}

 

정적 페이지는 어디서든 접근 가능하도록 설정하는 메서드

@Override
public void configure(WebSecurity web) throws Exception {
    web.ignoring().antMatchers("/css/**", "/js/**");
}

 

접속 권한을 제어하는 메서드

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            .csrf().disable()// 세션을 사용하지 않고 JWT 토큰을 활용하여 진행, csrf토큰검사를 비활성화
            .authorizeRequests() // 인증절차에 대한 설정을 진행
            .antMatchers("/", "/error/*", "/login", "/loginProc").permitAll() // 설정된 url은 인증되지 않더라도 누구든 접근 가능
            .anyRequest().authenticated()// 위 페이지 외 인증이 되어야 접근가능(ROLE에 상관없이)
            .and()
            .formLogin().loginPage("/login")  // 접근이 차단된 페이지 클릭시 이동할 url
            .loginProcessingUrl("/loginProc") // 로그인시 맵핑되는 url
            .usernameParameter("userId")      // view form 태그 내에 로그인 할 id 에 맵핑되는 name ( form 의 name )
            .passwordParameter("userPw")      // view form 태그 내에 로그인 할 password 에 맵핑되는 name ( form 의 name )
            .successHandler(successHandlerHandler()) // 로그인 성공시 실행되는 메소드
            .failureHandler(failureHandlerHandler()) // 로그인 실패시 실행되는 메소드
            .permitAll()
            .and()
            .logout() // 로그아웃 설정
            .logoutUrl("/logout") // 로그아웃시 맵핑되는 url
            .logoutSuccessUrl("/") // 로그아웃 성공시 리다이렉트 주소
            .invalidateHttpSession(true); // 세션 clear
}

스프링의 의존성 관리방법

스프링 프레임워크의 특징 : 객체의 생성과 의존관계를 컨테이너가 자동으로 관리한다.(IoC)

 

IoC 지원 형태

Dependency Lookup

컨테이너가 애플리케이션 운용에 필요한 객체를 생성하고 클라이언트는 컨테이너가 생성한 객체를 검색하여 사용하는 방식(실제 개발에서 사용하지 않는다.)

 

Dependency Injection

객체 사이의 의존관계를 스프링 설정 파일에 등록된 정보를 바탕으로 컨테이너가 자동으로 처리해 준다. 따라서 의존성 설정을 바꾸고 싶을 때 프로그램 코드를 수정하지않고 스프링 설정 파일 수정만으로 변경사항을 적용할 수 있다.(유지보수 향상)

컨테이너가 직접 객체들 사이에 의존관계를 처리하는 것.

DI는 Setter Injection과 Constructor Injection으로 나뉜다. (두 방법 모두 멤버변수를 원하는 값으로 설정하는 것을 목적으로 하고 있어 결과 값은 같다.)

 

Constructor Injection : 스프링 설정파일에 <constructor-arg> 를 사용한다. <bean> 태그 안에서 선언한다.

 

<constructor-arg> 태그 속성 설명

ref  생성자 인자로 전달할 객체의 아이디를 참조한다.
value  매개변수로 전달된 데이터가 기본형타입일 때 사용, 매개변수로 전달될 값 지정.
index  매개변수의 번호(순서) 지정

 

xml 파일 예시

<bean id="tv" class="polymorphism.SamsungTV" init-method="initMethod" destroy-method="endMethod" lazy-init="true" scope="singleton">
		
		<!-- Constructor Injection -->
		<constructor-arg index="0" ref="apple"/>
		<constructor-arg index="1" value="270000"/>
		
</bean>
	
<bean id="sony" class="polymorphism.SonySpeaker"/>
<bean id="apple" class="polymorphism.AppleSpeaker"/>



Setter Injection : 스프링 설정파일에 <constructor-arg>대신 <property> 를 사용한다. <bean> 태그 안에서 선언한다.

 

<property>태그 속성 설명

name   속성값은 호출하고자 하는 메소드 이름 (속성값이 speaker이면 setSpeaker()를 호출한다.)
ref   setter 메소드를 호출하면서 다른객체를 인자로 넘길 때 사용.
value   매개변수로 전달된 데이터가 기본형타입일 때 사용, 매개변수로 전달될 값 지정.

 

xml 파일 예시

<bean id="tv" class="polymorphism.SamsungTV" init-method="initMethod" destroy-method="endMethod" lazy-init="true" scope="singleton">
		
		<!-- Setter Injection -->
		<property name="speaker" ref="sony"></property>
		<property name="price" value="270000"></property>
		
</bean>
	
<bean id="sony" class="polymorphism.SonySpeaker"/>
<bean id="apple" class="polymorphism.AppleSpeaker"/>

 

 

참조 문헌 - 스프링 퀵 스타트

참조글의 4) bean.xml 생성 부분을 참조하면 된다. 파일 네임만 작성 후 finish를 하면 아래 코드와 같은 파일이 완성된다. (네임 스페이스의 체크박스 추가 X)

 

 

<beans> 태그 

<?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">
</beans>

루트 엘리먼트이다. 스프링 컨테이너는 <bean> 저장소에 해당하는 XML설정 파일을 참조하여 <bean>의 생명주기를 관리하고 여러가지 서비스를 제공한다.
STS를 이용하여 만든 스프링 설정 파일에는 beans 네임스페이스가 기본 네임스페이스로 선언되어 있으며, spring-beans.xsd 스키마 문서가 schemaLocation으로 등록되어있다.
따라서, 사용할 수 있는 자식 엘리먼트는 <bean>, <description>, <alias>, <import> 이다.

 

BeanFactory는 인스턴스를 생성하고 설정하고 많은 수의 bean을 관리하는 실질적인 컨테이너

 

<bean> 태그

<bean id="tv" class="polymorphism.SamsungTV" init-method="initMethod" 
      destroy-method="endMethod" lazy-init="true" scope="singleton"/>

스프링 설정 파일에 클래스를 등록 할때 사용한다.

<beans> 태그 안에 위치해야 한다.

 

<bean> 속성

속성명 속성 정리
id 속성값은 고유한 식별값이여야 한다.(카멜케이스 사용), 컨테이너로부터 <bean> 객체를 요청할 때 사용
name 고유한 식별값이여야하지만, id와 다르게 작성 규칙이 존재하지 않음. (더 명확한 id를 많이 사용한다.)
class 생략할 수 없는 속성이다. 속성값은 연결할 class의 패키지명.클래스명이다(정확하게 등록해야 한다.)
init-method 스프링 컨테이너에서 객체를 생성할 때 기본생성자를 호출한다. 객체 생성후 바로 실행되는 메소드 지정할 수 있다. (Serlvet객체의 멤버변수의 초기화 작업이 필요하다면 사용) 속성명은 연결한 클래스의 메소드 명이다.
 destroy-method 스프링 컨테이너가 객체를 삭제하기 직전에 호출될 임의의 메소드를 지정한다.
lazy-init  스프링에서 컨테이너가 구동되는 시점에 <bean> 객체를 생성한다. (메모리 관리 비효율적)
lazy-init의 속성값을 true로 설정하면  <bean>이 사용되는 시점에서 객체를 생성한다.(메모리 관리에 효율적) 
scope 컨테이너가 생성한 bean을 어느 범위에서 사용할 수 있는지를 지정할 때 사용.
기본값은 singleton(단 하나만 생성되도록 운용)이다.
속성값으로 prototype을 설정하면 매번 새로운 객체가 생성된다.

 

Bean에 연결한 Class 예시

package polymorphism;

public class SamsungTV implements TV{
	public SamsungTV() {
		System.out.println("===>SamsungTV 객체 생성 ");
	}
	
    public void initMethod() {
		System.out.println("객체 초기화 작업 처리...");
	}
	
	public void powerOn() {
		System.out.println("SamsungTV---전원 켠다.");
	}
	
    public void powerOff() {
		System.out.println("SamsungTV---전원 끈다.");
	}
	
    public void volumeUp() {
		System.out.println("SamsungTV---소리 올린다");
	}
	
    public void volumeDown() {
		System.out.println("SamsungTV---소리 내린다");
	}
	
	public void endMethod() {
		System.out.println("객체 삭제전 처리할 로직 처리...");
	}
}

상속받은 인터페이스는 생략....

 

생성한 XML파일을 자바에 연결 하는 방법

package polymorphism;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

public class TVUser {
	public static void main(String[] args) {
				
		AbstractApplicationContext factory = new GenericXmlApplicationContext("applicationContext.xml");
				
		TV tv = (TV)factory.getBean("tv");
		tv.powerOn();
		tv.volumeUp();
		tv.volumeDown();
		tv.powerOff();
		
		factory.close();
	}
}

 

GenericXmlApplicationContext 

파일 시스템이나 클레스 경로에 있는 XML 설정 파일을 로딩하여 구동하는 컨테이너

파라미터에 xml파일의 filename을 작성한다.

 

getBean의 파라미터엔 bean태그의 id속성값을 작성한다.

 

 

실행화면 

INFO : org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from class path resource [applicationContext.xml]
INFO : org.springframework.context.support.GenericXmlApplicationContext - Refreshing org.springframework.context.support.GenericXmlApplicationContext@75a1cd57: startup date [Sun Jul 18 16:02:46 KST 2021]; root of context hierarchy
===>SamsungTV 객체 생성 
객체 초기화 작업 처리...
SamsungTV---전원 켠다.
SamsungTV---소리 올린다
SamsungTV---소리 내린다
SamsungTV---전원 끈다.
INFO : org.springframework.context.support.GenericXmlApplicationContext - Closing org.springframework.context.support.GenericXmlApplicationContext@75a1cd57: startup date [Sun Jul 18 16:02:46 KST 2021]; root of context hierarchy
객체 삭제전 처리할 로직 처리...

 

 

 

 

참조 문헌 - 스프링 퀵 스타트

AOP(Aspect Oriented Programming)란?

직역으로 관점지향 프로그래밍이다.

프로젝트에서 공통 부분을 처리한다. 예) log 처리, session 체크, DB체크  

 

Log 사용 예시

 

1) 이클립스에서 Dynamic Web Project를 생성한다.

2) pom.xml을 생성한다. ( 프로젝트 우클릭 → Configure →  Convert to Maven Project )

3)  pom.xml 에서 </build> 태그 밑에 코드를 추가한다.

 

pom.xml  코드 예시

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>testAOP</groupId>
  <artifactId>testAOP</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <release>16</release>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.2.3</version>
      </plugin>
    </plugins>
  </build>
  
    <dependencies>
  
  	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>5.3.6</version>
	</dependency>
	
	<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-aop</artifactId>
  		<version>5.3.6</version>
  	</dependency>
	
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.9.4</version>
	</dependency>
	
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjrt</artifactId>
	    <version>1.9.4</version>
	</dependency>
	
	</dependencies>
</project>

 

추가 후 pom.xml을 저장하면 Maven Dependencies가 생성되고 jar파일이 추가된 것을 볼 수 있다.

 

4) bean.xml 파일을 생성한다.

 

파일 생성 방법

src/main/java 우클릭 후 New → Other.. 클릭한다.

 

 

java 폴더안에 Spring Bean Configuration File 클릭 후 Next > 클릭

 

File name 작성 후 Next > 클릭

 

aop, beans 체크 후 Finish 한다.

 

생성된 bean.xml 파일 코드

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

</beans>

5) Log에서 불러올 Dto Class를 생성한다.

 

Dto Class 예시

package com.dto;

public class Cat {
	private String name;
	private int age;
	private String color;
	
	public Cat() {}

	public Cat(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
	public void info() {
		System.out.println("이름 : " + name);
		System.out.println("나이 : " + age);
		System.out.println("컬러 : " + color);
	}
}

 

변수 생성 후 info 메소드를 작성한다.

 


6) Log AOP를 사용할 클래스를 생성한다. 

 

LogAop Class 예시

package com.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class LogAop {
	
	// 패키지명 안에 있는 어떤 클래스든 호출될 때 무조건 들어와서 실행된다.
	@Around("within(com.dto.*)")
	public Object loggerAop(ProceedingJoinPoint joinpoint) throws Throwable{
		// 신호과 왔을때
		String signatureStr = joinpoint.getSignature().toShortString();
		
		System.out.println(signatureStr + " 시작");
		
		try {
			Object obj = joinpoint.proceed();  // 실행시 (클래스가 호출 된 시점)
			
			return obj;
			
		} finally {
			// System.currentTimeMillis() : 밀리세컨 단위의 시간
			System.out.println("실행 후 : " + System.currentTimeMillis());
			System.out.println(signatureStr + " 종료");
		}	
	}
}

 


7) bean.xml에 코드를 추가한다.

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	
	<!-- AOP 객체생성 -->
	<bean id="logAop" class="com.aop.LogAop"/>
	
	<!-- AOP에 관한 어노테이션 사용하겠다 -->
	<aop:aspectj-autoproxy/>
	
	
	<bean id="myCat" class="com.dto.Cat">
		<!-- 객체에 값 넣기 -->
		<property name="name" value="야옹이"/>
		<property name="age" value="2"/>
		<property name="color" value="흰색"/>
	</bean>
</beans>

8) 코드를 실행할 MainClass를 생성한다.

 

MainClass 예시

package com.main;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import com.dto.Cat;

public class MainClass {
	public static void main(String[] args) {
			
		// Java에서 xml을 실행 시
		// bean.xml을 읽어와라
		AbstractApplicationContext ctx = new GenericXmlApplicationContext("bean.xml");
		
		// xml에서 생선된 Object를 읽어 들인다.
		Cat myCat = ctx.getBean("myCat", Cat.class);
		
		myCat.info(); // info()메소드 호출
		System.out.println("=================================");
		myCat.setAge(1);
		System.out.println("=================================");
		myCat.info();
	}
}

 

실행화면

Cat.info() 시작
이름 : 야옹이
나이 : 2
컬러 : 흰색
실행 후 : 1626263390713
Cat.info() 종료
=================================
Cat.setAge(..) 시작
실행 후 : 1626263390713
Cat.setAge(..) 종료
=================================
Cat.info() 시작
이름 : 야옹이
나이 : 1
컬러 : 흰색
실행 후 : 1626263390713
Cat.info() 종료

Dynamic Web Project로 스프링 프로젝트 생성하기

 

 

Dynamic Web Project 생성한다.

 

Configure → Convert to Maven Project 생성한다.

 

pom.xml파일이 생성된다.

 

pom.xml에 Spring Web MVC 라이브러리 추가하기

https://mvnrepository.com/artifact/org.springframework/spring-webmvc/5.3.6

드래그 부분 복사해서 pom.xml의 <dependencies> tag안에 넣어준다.

위 코드를 넣으면 알아서 jar파일을 다운로드 해준다 (설정파일)

 

pom.xml 예시

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>sample01</groupId>
  <artifactId>sample01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <release>16</release>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.2.3</version>
      </plugin>
    </plugins>
  </build>
  
  <dependencies>
  	<dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-webmvc</artifactId>
    	<version>5.3.6</version>
	</dependency>
  </dependencies>
  
</project>

 

WEB_INF 폴더를 추가한다.(spring, views)

 

dispatcherServlet.xml 생성하기

spring 폴더안에 Spring Bean Configuration File을 생성한다.

 

name 지정 후 Next> Beans와 context 체크한다.

 

dispatcherServlet.xml 예시

<?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"
	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/context/spring-context-4.3.xsd">

	<!-- spring MVC annotation(주석문, 지시문)을 사용하기 위한 설정 -->
	<context:annotation-config />
	
	<!-- bean 객체를 생성할 때 사용 
	 	 장점 : XML에서 바로 객체를 생성하면 singleton이 필요 없어진다.
		 사용자의 view의 위치, 확장자명 설정 -->
	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- property : class의 내부 변수  -->
		<!-- prefix : views의 경로 설정 -->
		<property name="prefix" value="/WEB-INF/views/"></property>
		<!-- suffix : 사용할 확장자 설정 -->
		<property name="suffix" value=".jsp"></property>
	</bean>
	
	<!-- base-package : 스프링에서 사용할 공통 패키지 설정 -->
	<context:component-scan base-package="bit.com.a"></context:component-scan>
	
</beans>

 

 

Web.xml 파일을 생성한다.

 

Web.xml 예시

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
  <display-name>sample01</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <servlet>
  	<servlet-name>dispatcherServlet</servlet-name>
  	<servlet-class>
  		<!-- 맨 처음 서블릿을 알려주는 코드 -->
  		org.springframework.web.servlet.DispatcherServlet
  	</servlet-class>
  	
  	<init-param>
  		<param-name>contextConfigLocation</param-name>
  		<param-value>
  			/WEB-INF/spring/dispatcherServlet.xml
  		</param-value>
  	</init-param>
  	
  	<!-- load-on-startup 1 : 제일 첫번째로 가야할 XML이다 설정, 여기부터 시작해라 -->
  	<load-on-startup>1</load-on-startup>
  	
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>dispatcherServlet</servlet-name>
  	<url-pattern>/</url-pattern>
  </servlet-mapping>
  
  <!-- 한글설정하기
  		jsp파일에서 setcharacterEncoding을 안해주어도 된다.
   -->
  <filter>
  	<filter-name>encodingFilter</filter-name>
  	<filter-class>
  		org.springframework.web.filter.CharacterEncodingFilter
  	</filter-class>
  	
  	<init-param>
  		<param-name>encoding</param-name>
  		<param-value>UTF-8</param-value>
  	</init-param>
  	
  	<!-- forceEncoding : 강하게 설정 -->
  	<init-param>
  		<param-name>forceEncoding</param-name>
  		<param-value>true</param-value>
  	</init-param>
  		
  </filter>
  
  <filter-mapping>
  	<filter-name>encodingFilter</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

 

java 예시

package bit.com.a;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller		// annotation
public class HelloController {
	
	@RequestMapping("hello")
	public String helloMethod() { // 컨드롤러에 왔니 ?
		System.out.println("HelloController helloMethod()");
		
		return "hello";		// hello.jsp로 가라!
	}
	
}

 

views폴더에 hello.jsp 파일을 생성한다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>hello.jsp</h1>
</body>
</html>

 

webapp폴더에 index.jsp파일을 생성한다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

<a href="hello">hello로 이동</a>
</body>
</html>

 

실행화면

 

+ Recent posts