개발/Java

서블릿이란?

728x90

서블릿은 자바를 통해 웹페이지를 동적으로 생성하는 서버측 프로그램이다.

 

서블릿은 JSP 표준이 나오기 전에 만들어진 표준으로, 자바로 웹 어플리케이션을 개발할 수 있도록 하기 위해 만들어졌다.

 

자바EE의 일부분이고, 

HTTP 통신 기반의 클래스를 살펴보면, 어노테이션 기반이든 매개변수든 서블릿 클래스가 활용된다.

 

서블릿 구현

서블릿의 개발 과정

 

서블릿은 JSP 표준이 나이고 전에 만들어진 표준으로 자바로 웹어플리케이션을 개발할 수 있도록 하기 위해서 만들어졌다.

 

1. 서블릿 규약에 따라 자바 코드를 작성한다.

2. 자바 코드를 컴파일 해서 클래스 파일을 생성한다.

3. 클래스 파일을 /WEB-INF/classess 폴더에 패키지에 알맞게 위치시킨다.

4. web.xml 파일에 서블릿 클래스를 설정한다.

5. 톰캣 등의 컨테이너에 연결한다.

6. 웹브라우저에서 확인한다.

 

직접 예제를 통해 알아보자.

 

<예제 환경>

IntelliJ IDEA 2020.2.4 (Ultimate Edition)

Tomcat 9.0.46

 

서블릿 클래스를 구현하려면 먼저 HttpServlet 클래스를 상속 받은 클래스를 작성해야 한다.

 

HttpServlet 클래스를 상속 받았다면, 처리하고자 하는 HTTP 방식에 따라 알맞은 메서드를 구현해야 한다.

 

메서드에서 request를 통해서 요청을 읽어오던가, response를 통해 응답을 전송할 수 있다.

여기서 setContentType() 메서드에 전달되는 값은 JSP에서 page 디렉티브의 contentType 속성값과 동일하다.

 

그리고 나서 getWriter()로 문자열 데이터를 출력할 수 있는 PrintWriter를 구해야 한다.

 

package example;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

public class Servlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        response.setContentType("text/html; charset=utf-8");

        PrintWriter out = response.getWriter();

        out.println("<html>");
        out.println("<head><title>현재시간</head></title>");
        out.println("<body>");
        out.println("현재 시간은");
        out.println(new Date());
        out.println("</body></html>");

    }
}

 

(참고 : 사실 JSP를 통해 HTML상에 자바 소스를 삽입하는 형태로 더 쉽게 개발이 가능하다.

JSP가 위와 같이 코딩을 해야 하는 단점을 개선한 것이기도 하다.)

 

 

web.xml로 매핑하기

 

서블릿 클래스를 생성하면, WEB-INF 폴더의 web.xml 파일에 서블릿 클래스를 등록하는 것이다.

 

    <servlet>
        <servlet-name>Servlet</servlet-name>
        <servlet-class>example.Servlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Servlet</servlet-name>
        <url-pattern>/servlet/Servlet</url-pattern>
    </servlet-mapping>

아래의 두가지를 설정해야 한다.

 

  • 서블릿으로 사용할 클래스 <servlet-name/>
  • 서블릿과 URL 간의 매핑 <url-pattern/> 

 

그리고 나서 서버를 재실행 하면, 정의한 url로 접속하면 아래와 같은 결과를 확인할 수 있다.

 

 

 

 

어노테이션으로 매핑하기

 

서블릿 2.5까지는 web.xml 파일에 서블릿을 등록해야만 서블릿 클래스를 사용할 수 있었는데, 3.0부터는 @WebServlet 어노테이션을 사용하면 web.xml 파일에 따로 등록하지 않아도 서블릿으로 등록된다.

 

애노테이션을 사용할 땐에는 서블릿이 범용적으로 사용되는지 서블릿인지의 여부이다. 

MVC 프레임워크는 어떤 URL을 서블릿이 처리할 지 미리 알 수 없다. 단지 다양한 요청 URL을 MVC 프레임워크가 처리할 수 있는 기능을 구현할 수 있을 뿐이다.

 

이는 Annotation을 사용할 경우, 서블릿이 처리해야 할 URL 패턴이 변경될 때 마다. 자바 소스코드의 urlPatterns 속성값을 변경하고 다시 컴파일 해야 한다.

 

아래와 같이 두개 이상의 URL 패턴을 처리할 수 있다.

@WebServlet(urlPatterns = {"/kim", "/minseong"})

       

 

@WebServlet 어노테이션을 사용할 때 고려할 점은 서블릿이 범용적으로 사용되는 서블릿인지의 여부이다.

예를 들어 MVC 프레임워크는 어떤 URL을 서블릿이 처리할 지 미리 알 수 없다. 다양한 요청 URL을 MVC 프레임워크가 처리할 수 있는 기능을 구현할 수 있을 뿐이다.

 

이는 @WebServlet 애노테이션을 사용할 경우 서블릿이 처리해야할 URL 패턴이 변경될 때 마다, 자바 소스 코드의 urlPatterns 속성값을 변경하고 다시 컴파일 해야한다.

 

tomcat 공식문서에는 아래와 같이 기술되어 있다.

이 annotation은 Servlet에 대한 configuration을 선언하기 위해 사용된다.
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
public @interface WebServlet

 

참고로 retention은 RUNTIME 이다.

(당연한 이야기이지만) 어플리케이션이 실행되는 동안 유지되어야 유저들이 WebServlet에서 url에 접근하려면 webservlet 어노테이션 정보가 런타임시에도 유지되어야 한다. 

 

필터

HTTP 요청과 응답을 변경할 수 있는 재사용 가능한 클래스 

JSP/서블릿 등을 실행하기 전에 요청이 올바른지, 자원에 접근할 수 있는 권한을 가졌는지의 여부를 미리 처리할 수 있다. 그리고 JSP나 서블릿이 생성한 응답 데이터를 변경하거나 취소할 수 있는 기능을 구현할 수 있다.

 

출처 : oracle dcos

 

위와 같이 여러 개의 필터가 모여 하나의 필터 체인을 형성하게 된다.

첫번째 필터가 변경하는 요청 정보는 클라이언트의 요청정보가 되지만, 체인의 두번째 필터가 변경하는 요청 정보는, 첫번째 필터에서 나온 결과이다. 즉 체인을 형성한다.

 

서블릿 컨테이너가 클라리언트를 대신하여, 서블릿의 메소드를 호출할 때 클라이언트가 보낸 HTTP 요청은 기본적으로 서블릿에 직접 전달됨. 서블릿이 생성하는 응답은 기본적으로 컨테이너에 의해 수정되지 않은 컨텐츠와 함께 클라이언트로 직접 다시 전달된다.

 

필터를 통해 할 수 있는 것들

  • 인증
  • 로깅
  • 이미지 변환
  • 데이터압축
  • 암호화 필터
  • 토크나이징 필터
  • XML 컨텐츠를 변형하는 XSLT 필터
  • MIME-TYPE 체인 필터
  • URL 및 기타 정보들을 캐시하는 필터

 

필터의 구현

필터를 구현하는데 3개의 클래스가 필요하다.

 

  • javax.servlet.Filter 인터페이스 : 클라이언트와 최종 사이에 위치하는 필터를 나타내는 객체가 구현해야 하는 인터페이스이다.
  • javax.servlet.ServletRequestWrapper 클래스 : 필터가 요청을 변경한 결과를 저장하는 래퍼이다.
  • javax.servlet.ServletResponseWrapper 클래스 : 필터가 응답을 변경하기 위해 사용하는 래퍼이다.

javax.servlet 패키지에 아래와 같이 Filter 인터페이스가 선언되어 있다.

public interface Filter {
    void init(FilterConfig var1) throws ServletException;

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;

    void destroy();
}

 

Filter 인터페이스

 

  • public void init(FilterConfig filterConfig) throws ServletExpcetion 
    • 필터를 초기화 할 때 호출된다.
  • void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;
    • 필터 기능을 수행한다. chain을 이용해서 체인의 다음 필터로 처리를 전달할 수 있다.
    • 서블릿 컨테이너는 사용자가 특정한 자원을 요청했을 때 그 자원 사이에 필터가 존재하면, 필터 객체의 doFilter() 메서드를 호출한다.
  • void destroy();
    • 필터가 웹 컨테이너에서 삭제될 때 호출된다.

아래의 예제를 살펴보자.

class FirstFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        
        // 1. requset 파라미터를 이용하여 요청의 필터 작업을 수행한다.
        // 2. 체인의 다음 필터를 처리
        // 3, response를 이용하여 응답의 필터링 작업 수행.

    }

    @Override
    public void destroy() {
        // 4. 주로 필터가 사용한 자원을 반납.
    }
}

init()메서드에 전달되는 FilterConfig는 필터의 초기화 파라미터를 읽어올 때 사용한다.

 

  • String getFilterName() : 설정 파일에서 <filter-name>에 지정할 필터의 이름을 리턴함.
  • String getInitParameter(String name) : 설정 파일의 <init-param>에서 지정한 초기화 파라미터의 값을 읽어온다. 존재하지 않는 경우 null을 리턴한다.
  • Enumeration<String> getInitParameterNames() : 초기화 파라미터의 이름 목록을 구한다.
  • ServletContext getServletContext()  : 서블릿 컨텍스트 객체를 구한다.

 

위 코드에서 Filter 인퍼테이스의 doFilter() 메서드는 요청이 있을 때 마다 매번 실행된다.

예를 들어 클라이언트가 요청한 자원이 필터를 거치는 경우 클라이언트의 요청이  있을 때 마다 doFilter() 메서드가 호출된다.

doFilter() 메서드는 JSP/서블릿과 마찬가지로 요청에 대해서 필요한 작업을 처리하게 된다.

 

 

RequsetWrapper 클래스를 통해 클라이언트의 요청을 변경할 수 있다.

 

 

필터의 동작 순서

  • 서블릿 컨테이너는 웹 어플리케이션을 시작할 때 web.xml에 등록된 필터의 인스턴스를 생성하고 init()을 호출한다.
  • 클라이언트의 요청이 들어오면 doFilter()를 호출한다.
  • doFilter()에서 작업을 실행하고 다음 필터의 doFilter()를 호출한다. (마지막까지 이 과정을 반복)
  • 마지막 필터는 서블릿의 service()를 호출한다.
  • 서블릿의 service가 끝나면 service를 호출했던 이전 필터로 돌아간다.
  • 반복해서 제일 처음 호출했던 필터까지 돌아간다.
  • 마지막으로 클라이언트에게 응답 결과를 보낸다.

 

필터 설정하기

1. (web.xml) 이용

 

    <filter>
        <filter-name>FilterName</filter-name>
        <filter-class>filter.FileCalss</filter-class>
        <init-param>
            <param-name>namespace</param-name>
            <param-value>value</param-value>
        </init-param>
    </filter>
  • <filter> : 웹어플리케이션에서 사용할 필터를 지정한다.
  • <filter-mapping> : 특정 자원에 대해 어떤 필터를 사용할지를 지정한다.
  • <init-parma> : 태그를 초기화할 때, 즉 init() 메서드를 호출할 때 전달할 파라미터를 설정한다. 주로 필터를 사용하기 전에 초기화 작업에 필요한 정보를 제공하기 위해 사용한다.
  • <dispatcher> : 필터가 적용되는 시점을 지정할 수 있다.
    • 클라이언트가 요청한 것인지, 아니면 RequestDispatcher의 forward()를 통해서 이동한 것인지, 아니면 include()를 통해서 포함되는 것인지에 따라서 필터를 적용하돌고 지정할 수 있음.
    • 태그가 가질 수 있는 값
      • REQUEST : 클라이언트의 요청인 경우 필터를 적용함.
      • FORWARD : forward()를 통해서 제어 흐름을 이동하는 경우에 필터를 적용한다.
      • INCLUDE : include()를 통해서 포함되는 경우에 필터를 적용한다.

 

요청 및 응답 래퍼 클래스

요청과 응답을 변경할 때 ServletRequsetWrapper, ServletResponseWrapper를 사용하여 변경할 수 있다.

하지만 대부분의 필터는 HTTP에 대한 요청과 응답을 필터링 하기 때문에 이 두 클래스를 상속받아 구현한 HttpServletRequestWrapper, HttpServletResponseWrapper 클래스를 상속받아 구현하는 것이 좋다.

모두 javax.servlet.http 패키지에 선언되어 있고, 이 두 클래스는 각각 HttpServletRequest, HttpServletResponse를 구현하고 있다.

 

필터를 통해 변경하고 싶은 정보가 있으면 아래와 같이 구현하면 된다.

  1. 이 래퍼 클래스를 상속받은 클래스를 만든다.
  2. 그 정보를 추출하는 메서드를 알맞게 오버라이드 해서 변경한 정보를 제공하도록 구현한다.
  3. 그리고 래퍼 클래스의 객체를 FilterChain의 doFilter() 메서드에 넘겨주면 된다.

 

요청 정보를 변경하여 최종 자원인 서블릿/JSP 등의 자원에 전달한다.

최종 자원으로부터의 응답을 변경하여 새로운 응답 정보를 클라이언트에 보낸다.

 

예제를 통해 살펴보자.

아래와 같이 HttpServletRequestWrapper 클래스를 상속받은 클래스를 만들고 그 정보를 추출하는 메서드를 알맞게 재정의 했다.

 

package filter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
 
public class MyRequestWrapper extends HttpServletRequestWrapper {

    HttpServletRequest request;

    public MyRequestWrapper(HttpServletRequest request) {

         super(request);
         // TODO Auto-generated constructor stub
         this.request = request;
    }

 

    @Override

    public String getParameter(String name) {

         // TODO Auto-generated method stub

        System.out.println("getParameter호출");

         String str = request.getParameter("name");

         if(str ==null) return null;

         return str.toUpperCase();
    }
}

 

그리고 아래의 Filter를 구현한 MyFilter의 doFiler에서 requestWrapper를 통해 request의 값을 처리하고, 

다음 필터로 requestWrapper를 넘겨주면 된다.

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

         MyRequestWrapper requestWrapper = new MyRequestWrapper((HttpServletRequest)request);

         // pass the request along the filter chain
         chain.doFilter(requestWrapper, response);
    }

 

ServletContextListener 

 

서블릿은 다양한 시점에서 발생하는 이벤트와 이벤트를 처리하기 위한 인터페이스를 정의하고 있다.

 

웹 컨테이너는 웹 어플리케이션(컨텍스트)이 시작되거나 종료되기 전에 시점에 특정 클래스의 메서드를 실행할 수 있는 기능을 제공함.

이 기능을 사용하면 웹 어플리케이션을 실행할 때 필요한 초기화 작업이나 웹 어플리케이션이 종료된 후 사용된 자원을 반환하는 등의 작업을 수행할 수 있다. 

 

아래와 같이 구현할 수 있다.

 

  • javax.servlet.ServletContextListener 인터페이스를 구현한 클래스를 작성한다.
  • web.xml 파일에 1번에서 작성한 클래스를 등록한다.

그리고 다음과 같은 두개의 메서드를 인터페이스에 정의하고 있다.

package javax.servlet;

import java.util.EventListener;

public interface ServletContextListener extends EventListener {
	// 웹 어플리케이션을 초기화 할 때 호출한다.
    void contextInitialized(ServletContextEvent var1);

	// 웹 어플리케이션을 종료할 때 호출한다.
    void contextDestroyed(ServletContextEvent var1);
}

 

 

웹 어플리케이션이 시작되거나 종료될 때 ServletContextListener 인터페이스를 구현한 클래스를 실행하려면

web.xml 파일에 <listener> 태그와 <listener-class> 태그를 사용해서 완전한 클래스 이름을 명시해주면 된다.

 

    <listener>
        <listener-class>jdbc.DBCPInitListner</listener-class>
    </listener>

한 개 이상의 <listener> 태그를 등록할 수 있고, 각 태그는 반드시 한개의 <listener-class> 태그를 가지고 있어야 한다.

 

ServletContextListener 인터페이스에 정의된 두 메서드는 모두 파라미터로 javax.servlet.ServletContextEvent 타입의 객체를 전달받는다. ServeletContextEvent 클래스는 웹 어플리케이션 컨텍스트를 구할 수 있는 getServeletContext() 메서드를 제공하고 있다.

 

package javax.servlet;

import java.util.EventObject;

public class ServletContextEvent extends EventObject {
    public ServletContextEvent(ServletContext source) {
        super(source);
    }

    public ServletContext getServletContext() {
        return (ServletContext)super.getSource();
    }
}

 

getServletContext()가 리턴하는 ServletContext 객체는 JSP의 application 기본 객체와 동일한 객체이다.

ServletContext 객체를 이용하면 web.xml 파일에 설정된 컨텍스트 초기화 파라미터를 구할 수 있다.

 

컨텍스트를 초기화 하는 파라미터를 아래와 같이 web.xml 파일에 설정할 수 있다.

    <context-param>
        <param-name>namespace</param-name>
        <param-value>com.mysql.jdbc.Driver</param-value>
    </context-param>

 

web.xml 파일에 설정한 초기화 파라미터 값을 구하는데 사용되는 ServletContext의 메서드는 아래와 같다.

 

  • String getInitParameter(String name)
    • 지정한 이름을 갖는 컨텍스트 초기화 파라미터 값을 리턴함. 존재하지 않으면 null을 리턴함. name 파라미터에는 <param-name> 태그로 지정한 이름을 입력한다.
  • Enumeration<String> getInitPArameterNames()
    • 컨텍스트 초기화 파라미터의 이름 목록을 enum 타입으로 리턴한다.

 

이를 활용해 커넥션 풀을 생성하는데 필요한 컨텍스트 초기화 파라미터를 web.xml에 설정할 수 있다.

 

혹은 Annotation을 통해 아래와 같이 web.xml에 등록하지 않고 리스너로 등록할 수 있다.

@WebListener
public class CListener implements ServletContextListener {
	...
}

 

 

 

리스너의 실행 순서

 

웹 어플리케이션에는 한 개 이상의 리스터를 web.xml 파일에 등록할 수 있다.

 

한 개 이상의 리스너가 등록된 경우, contextInitialized() 메서드는 등록된 순서대로 실행되고

contextDestroyed() 메서드는 등록된 반대 순서대로 실행됨.

 

 

리스너에서의 익셉션 처리

 

아래의 코드를 보면, catch 블록에서 RuntimeException을 throw 하는 것을 확인할 수 있다.

리스너에서 RuntimeException을 발생시키는 이유는, contextInitialized() 메서드 정의에 throws가 없기 때문이다.

이 메서드는 발생시킬 수 있는 Checked Exception을 지정하지 않고 있어서, Exceptiopn을 발생시키려면 RuntimeException (혹은 그 하위 Exception)을 발생시켜야 한다. 

 

    public void contextInitialized(ServletContextEvent sce){
        
        String poolConfig = sce.getServletContext().getInitParameter("poolConfig");

        Properties prop = new Properties();
        
        try{
            prop.load(new StringReader(poolConfig));             
        }catch (IOException e ){
            throw new RuntimeException(e);
        }
        
    }

 

*ServletContext

톰캣 컨텍스트 실행 시 각 컨텍스트마다 한 개의 ServletContext 객체를 생성한다.

ServletContext 객체는 웹 어플리케이션이 실행되면서 전체의 공통 자원이나 정보를 미리 바인딩 하여 서블릿들이 공유하여 사용할수 있도록 한다.

 

 

 

Servelet 2.3의 컨텍스트 라이프 사이클

 

크게 초기화 단계와 종료 단계로 나뉜다.

일반적으로 서블릿 엔진이 처음 시작할 때 각각의 컨텍스트가 초기화 되고, 서블릿 엔진을 종료할 때 각각의 컨텍스트도 함께 종료한다.

 

컨텍스트 초기화에 웹 어플리케이션에서 사용하는 데이터베이스 커넥션이나, 객체의 풀 또는 각종 설정 정보등을 초기화 하기에 알맞다.

왜냐하면 컨텍스트 초기화는 사용자들이 웹브라우저등을 이용해 웹 어플리케이션을 실행하는 시점보다 이전에 발생하기 때문이다.

 

 

 

*RequestDispatcher란?

클라이언트로부터 들어온 요청을 JSP/Servlet 내에서 원하는 자원으로 요청을 넘기는 역할을 수행하거나, 특정 자원에 처리 요청하고 처리 결과를 얻어오는 기능을 수행하는 인터페이스.

이름 그래도 Request를 Dispatch할 수 있는 인터페이스이다.

javax.sevlet 패키지에 존재하고 아래와 같이 정의되어 있다.

public interface RequestDispatcher {
    void forward(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    void include(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

요청을 보내는 방법으로 두개가 있다.

  • forward() : 다른 Servlet/JSP로 제어를 넘기는 역할을 한다.  
    • 포워딩된 대상 페이지가 최종 결과를 출력함.
  • include() :  처리 흐름 제어를 특정 대상에게 넘기고, 대상이 처리한 결과를 현제 페이지에서 처리한 결과에 포함시키는 기능
    • forward와 다르게 최초 흐름이 시작된 페이지가 브라우저로 최종 결과를 출력한다.

forward()의 동작 방식
include()의 동작 방식

 

include() 호출시에는 HttpServletRequest와 HttpServletResponse를 매개변수로 넘겨주는데 이 두 객체를 호출하는 페이지와 호출받는 쪽에서 공유하기 때문에, 서로 데이터를 이 두개의 객체에 담아 공유할 수 있음.

 

또한 브라우저로 데이터를 출력하는 출력스트림도 하나의 객체를 공유하므로, 출력 결과를 포함시키는 것처럼 보이게 하는 효과가 있는 것이다.

 

forward() 메서드에서는 제어를 호출하는 페이지로 넘기기 전에 출력 버퍼를 비워버리고 제어를 넘기지만, 

include()는 출력 벌퍼를 비우지 않기 때문에 호출하는 페이지에서 출력하는 내용에 이어서 호출되는 페이지에서 출력하는 내용까지 포함시킬 수 있음.

 

include()를 통해 다른 서블릿을 호출해도, 버퍼를 비우지 않음.

 

 

forward(), include()와 HttpServeltResponse의 sendRedirect()와의 차이점

이를 지정한 경로로 제어를 이동시킬 수 있다. 그러나 HTTP 리다이렉션을 이용하기 때문에 하나의 요청 범위 안에서 처리를 하는 것이 아니라 브라우저에게 Response 후 브라우저측에서 지정받은 요청 경로를 다시 재요청을 하는 방식이기에 두 번에 HTTP 트랜잭션이 발생하고, 서버측에서 최초에 받은 요청중에 처리한 내용을 리다이렉트 안에서 공유할 수 없는 문제가 있다.

 

 

2. @WebFilter Annotation 이용

서블릿 3.0, 톰캣 7부터 지원함.

 

Filter이름 지정

@WebFilter(filterName ="loggingFilter")

 

필터링 지정 방법

@WebFilter("/target") // Annotation에 맵핑 URL을 입력하는 방법

@WebFilter("/*") // Annotation에 와일드카드를 사용하여 입력하는 방법

// Annotation의 value 속성을 이용하는 방법
@WebFilter(value="/target") 
@WebFilter(value= {"/target", "/target2"})

// Annotation의 urlPatterns 속성을 이용하는 방법
@WebFilter(urlPatterns="/target") 
@WebFilter(urlPatterns= {"/target", "/target2"})

// 서블릿 등록시 사용한 서블릿 이름을 기준으로 지정
@WebFilter(servletNames="boardController"
@WebFilter(servletNames= {"boardController", "boardController2"})


// @WebFilter 초기 파라미터 설정 방법
@WebFilter(
    value = {"/target", "/target2"},
    initParams = @WebInitParam(name = "encoding", value = "UTF-8")
)
// @WebFilter 초기 파라미터를 여러개 지정할 때.
@WebFilter(
    initParams = {
        @WebInitParam(name = "encoding", value = "UTF-8"),
        @WebInitParam(name = "encoding2", value = "EUC-KR")
    }
)

 

Dispatcher 지정

dispatcherTypes 속성을 통해, 배열로 여러개를 지정할 수 있다.

디폴트 값은 DispatcherType.REQUEST 이다.

@WebFilter(
        dispatcherTypes= {
                DispatcherType.REQUEST,
                DispatcherType.INCLUDE
        }
)

 

주요 속성

  • urlPatterns : 필터를 적용할 URL 패턴 목록을 지정함.
  • servletNames : 필터를 적용할 서블릿 이름 목록을 지정함.
  • filterName : 필터의 이름을 지정함.
  • initParams : 초기화 파라미터 목록을 지정함. 
  • dispatcherTypes : 필터를 적용할 범위를 지정한다. Enum 타입인 DispatcherType에 정의된 값을 사용한다. 기본값은 DispatchType.REQUEST 이다.

 

*내장객체란? 

JSP 내에서 제공하는 특수한 레터런스 타입의 변수이다.

JSP -> 서블릿으로 translate 될 때, JSP 컨테이너가 자동적으로 제공한다.

객체 생성없이 바로 사용할 수 있는것이 특징이다.

 

 

 

 

출처 : 

 

https://dololak.tistory.com/605

https://javacan.tistory.com/tag/ServletContextEvent

참고 서적 : 최범균의 JSP 웹프로그래밍

 

'개발 > Java' 카테고리의 다른 글

JSP란?  (0) 2021.05.19
데이터베이스부터 JDBC까지  (0) 2021.05.19
java.util 톺아보기  (0) 2021.05.18
Java Formatter  (0) 2021.05.18
classpath와 자바 옵션들  (0) 2021.05.18
하프킴