리플랙션 API를 이용한 Front Controller 자동화

본 내용은 스프링 프레임워크의 내부 구조를 이해하는데 도움이 된다.

 

리플랙션 API를 이용한 Front Controller 자동화

 

아래와 같은 신규 학생(회원)을 등록하는 폼이 있다.

 

 

사용자가 값을 입력하고 [등록] 버튼을 클릭해서 신규 학생 등록을 요청하면 작업을 처리할 컨트롤러에게 입력한 데이터를 전달해야 한다.

 

// 매개변수값을 꺼내서 Map에 담음
model.put("student", new Student()
        .setStudentNo(req.getParameter("student_no"))
    .setStudentName(req.getParameter("student_name"))
    .setAddress(req.getParameter("address"))
    .setAge(Integer.parseInt(req.getParameter("age")))
    .setDepartment(req.getParameter("department"))
    .setGender(req.getParameter("gender"))
    .setGrade(Integer.parseInt(req.getParameter("grade")))
    .setPassword(req.getParameter("password"))
    .setPhoneNumber(req.getParameter("phone_number"))
);

 

이를 위해 위와 같이 VO 객체를 생성하고 setter()를 통해 요청 파라미터 값을 세팅하는 코드를 직접 작성한다면 추후 유지보수가 어렵게 된다.

이 때 리플랙션 API를 활용하면 이렇게 객체를 생성하고 메소드를 호출하는 것을 자동화할 수 있다.

 

자동화 시나리오

신규 학생을 등록할때 전달할 데이터 준비를 자동화하는 시나리오는 다음과 같다.

 

① 웹 브라우저에서 학생 등록을 요청하며 사용자가 입력한 파라미터 값을 서블릿에 전달한다.
② 서블릿(Front controller)이 학생 등록을 처리하는 StudentAddController에게 어떤 데이터가 필요한지 물어본다.
③ StudentAddController는 작업하는데 필요한 데이터의 이름과 타입 정보를 담은 배열을 리턴한다.
④ Front controller는 요청 파라미터로 StudentAddController가 필요한 데이터 객체를 만든다.
⑤ Front controller는 StudentAddController를 execute하면서 ④에서 만든 데이터를 전달한다.

 

자동화 구현

1. DataBinding 인터페이스 정의 및 구현

모든 controller가 파라미터 데이터가 필요한 건 아니므로 DataBinding 인터페이스를 정의해서 이 인터페이스를 구현한 controller에게만 데이터 객체를 만들어 전달할 것이다.

bind 패키지에 아래와 같은 DataBinding 인터페이스를 생성한다.

 

DataBinding.java

/**
 * 요청 파라미터 데이터가 필요한 controller는 이 인터페이스를 구현한다.
 */
public interface DataBinding {
    /**
     * 필요한 데이터 정의
     * @return 데이터의 이름과 타입 정보를 담은 Object[]
     * Ex) new Object[]{"데이터이름", 데이터타입, "데이터이름", 데이터타입, ...}
     */
    Object[] getDataBinders();
}

 

getDataBinders()의 리턴값은 데이터 이름과 데이터 타입 정보를 담은 Object 배열이다.

 

이제 요청 파라미터 데이터가 필요한 controller에서 이 인터페이스를 구현하도록 변경한다.

 

StudentAddController.java

/**
 * 신규 학생 등록
 */
public class StudentAddController implements Controller, DataBinding {
 
    /**
     * 필요한 데이터 정의
     * @return 데이터의 이름과 타입 정보를 담은 Object[]
     */
    @Override
    public Object[] getDataBinders() {
        return new Object[]{"student", com.atoz_develop.spms.vo.Student.class};
    }

위와 같이 반환하면 요청 파라미터 데이터를 Student 객체에 담아서 "student"라는 이름으로 전달해 달라는 의미이다.

 

2. Front controller 변경

이제 front controller에서 직접 Student 객체를 생성하고 setter()를 호출하는 코드를 제거한뒤 controller에게 필요한 데이터를 묻고 데이터를 준비하는 코드를 추가해야 한다.

필요한 부분만 볼 수 있도록 관련 없는 코드는 생략하였다.

 

DispatcherServlet.java

/**
 * Front Controller
 */
@WebServlet("*.do")
public class DispatcherServlet extends HttpServlet {
 
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
        // DataBinding 구현 여부 확인 후 데이터를 준비하는 prepareRequestData() 호출
        if(pageController instanceof DataBinding) {
            prepareRequestData(req, model, (DataBinding) pageController);
        }
 
        // PageController에 실행 요청
        String viewUrl = pageController.execute(model);
    }
 
    /**
     * 데이터 준비
     * @param request
     * @param model
     * @param dataBinding
     * @throws Exception
     */
    private void prepareRequestData(HttpServletRequest request, Map<String, Object> model, DataBinding dataBinding) throws Exception {
 
        // 필요한 데이터 확인
        Object[] dataBinders = dataBinding.getDataBinders();
        String dataName = null;
        Class<?> dataType = null;
        Object dataObj = null;
 
        for(int i=0; i<dataBinders.length; i+=2) {
            dataName = (String) dataBinders[i];
            dataType = (Class<?>) dataBinders[i+1];
            // dataName과 일치하는 요청 매개변수 값을 dataType 인스턴스에 저장하고 반환
            dataObj = ServletRequestDataBinder.bind(request, dataType, dataName);
            model.put(dataName, dataObj);
        }
    }
}

 

1) service()

service() 메소드에서 기존의 코드를 제거하고 컨트롤러가 DataBinding을 구현했는지 확인한 뒤 데이터를 준비하는 메소드인 prepareRequestData()를 호출하도록 한다.

 

if (pageController instanceof DataBinding) {
    prepareRequestData(...)
}

 

2) prepareRequestData()

먼저 컨트롤러에게 필요한 데이터를 확인한다.

 

Object[] dataBinders = dataBinding.getDataBinders();

getDataBinders()가 반환하는 것은 {"데이터 이름", 데이터 타입, "데이터 이름", 데이터 타입, ...}과 같은 Object 배열이다.

 

데이터 이름과 데이터 타입이 1쌍 씩 들어있으므로 2씩 증가시키며 for문을 돌린다.

 

for (int i=0; i<dataBinders.length; i+=2) {
    dataName = (String)dataBinders[i];
    dataType = (Class<?>) dataBinders[i+1];
    ...
}

 

3) ServletRequestDataBinder.bind()

곧 구현할 ServletRequestDataBinder는 요청 파라미터 값을 자바 객체에 담아주는 역할을 수행한다.

이 메소드는 dataName과 일치하는 요청 파라미터를 찾고 dataType을 통해 해당 클래스의 인스턴스를 생성한다. 찾은 매개변수 값을 인스턴스에 저장하고 그 인스턴스를 반환한다.

 

dataObj = ServletRequestDataBinder.bind(request, dataType, dataName);
model.put(dataName, dataObj);

 

최종적으로 반환받은 데이터 객체를 Map 객체 model에 담아 컨트롤러가 사용할 수 있도록 준비한다.

 

3. ServletRequestDataBinder 클래스 구현

bind 패키지에 ServletRequestDataBinder 클래스를 생성하고 아래와 같이 작성한다.

bind(), isPrimitiveType(), createValueObject(), findSetter()의 총 4개 클래스 메소드를 구현한다.

 

ServletRequestDataBinder.java

public class ServletRequestDataBinder {
    /**
     * 요청 파라미터 값을 자바 객체에 담아서 반환한다.
     * Front controller에서 호출
     * @param request 요청 파라미터 값
     * @param dataType 데이터 타입
     * @param dataName 데이터 이름
     * @return 데이터 객체
     * @throws Exception
     */
    public static Object bind(ServletRequest request, Class<?> dataType, String dataName) throws Exception {
        // 데이터 타입이 primitive type인지 확인
        if(isPrimitiveType(dataType)) {
            // primitive type이면 즉시 객체를 생성해서 반환
            return createValueObject(dataType, request.getParameter(dataName));
        }
 
        // 요청 파라미터명
        Set<String> paramNames = request.getParameterMap().keySet();
        for(String s:paramNames) {
            System.out.println(s);
        }
        // 값을 저장할 객체 생성
        Object dataObject = dataType.getDeclaredConstructor.newInstance();
        Method m = null;
 
        // 요청 파라미터 개수만큼 반복하면서 데이터 객체에 값을 할당
        for(String paramName: paramNames) {
            // 파라미터명과 일치하는 setter() 찾음
            m = findSetter(dataType, paramName);
            if(m != null) {
                // setter()를 찾았으면 dataObject에 대해 호출
                // setter() 호출 시 요청 파라미터의 값을 형식에 맞춰 넘김
                // invoke() : 메소드 호출
                // getParameterTypes() : 메소드의 매개변수 목록을 배열로 반환
                m.invoke(dataObject, createValueObject(m.getParameterTypes()[0], request.getParameter(paramName)));
            }
        }
 
        return dataObject;
    }
 
    /**
     * type이 primitive type인지 확인
     * @param type
     * @return int, long, float, double, boolean, java.util.Date, java.lang.String 타입이면 true, 아니면 false
     * byte, short는 필요 시 추가
     */
    private static boolean isPrimitiveType(Class<?> type) {
        if(type.getName().equals("int") || type == Integer.class ||
        type.getName().equals("long") || type == Long.class ||
        type.getName().equals("float") || type == Float.class ||
        type.getName().equals("double") || type == Double.class ||
        type.getName().equals("boolean") || type == Boolean.class ||
        type == Date.class || type == String.class) {
            return true;
        }
 
        return false;
    }
 
    /**
     * Primitive type의 객체를 생성
     * @param type
     * @param value
     * @return
     */
    private static Object createValueObject(Class<?> type, String value) {
        if(type.getName().equals("int") || type == Integer.class) {
            return Integer.valueOf(value);
        } else if(type.getName().equals("long") || type == Long.class) {
            return Long.valueOf(value);
        } else if(type.getName().equals("float") || type == Float.class) {
            return Float.valueOf(value);
        } else if(type.getName().equals("double") || type == Double.class) {
            return Double.valueOf(value);
        } else if(type.getName().equals("boolean") || type == Boolean.class) {
            return Boolean.valueOf(value);
        } else if(type == Date.class) {
            return java.sql.Date.valueOf(value);
        } else {
            return value;
        }
    }
 
    /**
     * 클래스(type)을 조사해서 주어진 이름(name))과 일치하는 setter()를 찾는다.
     * @param type
     * @param name
     * @return
     */
    private static Method findSetter(Class<?> type, String name) {
        // 데이터 타입에서 메소드 목록 얻음
        // getMethods() : 클래스에 선언된 모든 public 메소드 목록을 배열로 반환
        Method[] methods = type.getMethods();
 
        String propName = null;
 
        // 메소드 목록을 반복하여 setter()에 대해서만 작업 수행
        for(Method m: methods) {
            if(!m.getName().startsWith("set")) continue;
            // setter()일 경우
            // 메소드 이름에서 'set' 제외
            propName = m.getName().substring(3);
            // 요청 파라미터 이름과 일치하는지 확인
            if(propName.toLowerCase().equals(name.toLowerCase())) {
                //일치하는 setter()를 찾으면 반환
                return m;
            }
        }
 
        return null;
    }
}

 

1) bind()

Front controller에서 호출할 public 메소드이다. request, 데이터 타입, 데이터 이름을 받아서 데이터 객체를 만드는 일을 수행한다.

public static Object bind(ServletRequest request, Class<?> dataType, String dataName) throws Exception {
    ...
    return dataObject;
}

 

첫 번째 코드는 dataType이 primitive type인지 확인하는 일이다. Primitive type일 경우 즉시 객체를 생성해서 반환한다.

if (isPrimitiveType(dataType)) {
    return createValueObject(dataType, request.getParameter(dataName));
}

 

Primitive type이 아니면 먼저 request 객체를 통해 요청 파라미터 이름 목록을 얻는다.

Set<String> paramNames = request.getParameterMap().keySet();

request.getParameterMap()은 파라미터 이름과 값을 맵 객체에 담아 반환한다. 때문에 keySet()으로 파라미터 이름 목록만 꺼낸다.

 

그리고 데이터를 저장할 객체를 생성한다.

new 연산자로 인스턴스를 생성하듯 Class.getDeclaredConstructor().newInstance() 메소드를 호출해서도 인스턴스를 생성할 수 있다.

Object dataObject = dataType.getDeclaredConstructor().newInstance();

 

다음은 요청 파라미터 개수만큼 for문을 돌려 setter를 호출해서 값을 할당한다.

Method m = null;

for (String paramName: paramNames) {
    m = findSetter(dataType, paramName);
    if (m != null) {
        m.invoke(dataObject, createValueObject(m.getParameterTypes()[0], request.getParameter(paramName)));
    }
}

findSetter()는 데이터 타입과 파라미터명을 전달하여 setter()를 반환하도록 구현하였다.

invoke()는 메소드를 호출하는 메소드로 일반적으로 한 인스턴스의 메소드를 호출할 때

인스턴스.메소드(인자값)으로 호출한다면 invoke() 메소드는 invoke(인스턴스, 인자값)과 같이 호출한다고 보면 된다.

 

2) isPrimitiveType()

isPrimitiveType() 메소드는 이 클래스 내부에 정의된 private 메소드로 int, long, float, double, boolean, java.util.Date, java.lang.String 타입을 primitive type으로 간주하여 true를 반환한다.

 

3) createValueObject()

createValueObject() 메소드는 요청 파라미터 값을 갖고 객체를 생성한다.

if (type.getName().equals("int) || type == Integer.class) {
    return Integer.valueOf(value);
}
...

 

4) findSetter()

findSetter()는 클래스를 조사하여 주어진 name과 일치하는 setter() 메소드를 찾는다.

 

먼저 Class에서 메소드 목록을 얻는다.

Method[] methods = type.getMethods();

 

메소드 목록을 반복하여 setter()를 찾는다.

for (Method m: methods) {
    if (!m.getName().startsWith("set")) continue;
...

 

Setter()일 경우 요청 파라미터 이름과 일치하는지 확인한다.

예를 들어 요청 파라미터 이름이 name이면 메소드가 setName()인지 확인한다.

propName = m.getName().substring(3);
if (propName.toLowerCase().equals(name.toLowerCase())) {
    return m;
}

일치하는 setter()를 찾으면 반환한다.

 

사용된 리플랙션 API

리플랙션 API를 통해 클래스에 어떤 메소드가 있는지, 메소드의 이름은 무엇인지, 클래스의 이름은 무엇인지 등을 알 수 있다. Controller가 필요한 데이터 객체를 생성하고 요청 파라미터 값을 세팅하는 것을 자동화하기 위해 사용된 리플랙션 API 목록은 다음과 같다.

 

메소드	설명
Class.getDeclaredConstructor().newInstance()	클래스의 인스턴스를 생성
Class.getName()	클래스 이름 반환
Class.getMethods()	클래스에 선언된 모든 public 메소드 목록을 배열로 반환
Method.invoke()	메소드 호출
Method.getParameterTypes()	메소드의 매개변수 목록을 배열로 반환

 

References

열혈강의 자바 웹 개발 워크북(프리렉, 2016, 엄진영)