개발 흔적 남기기

자바 8에서는 Stream이 추가되었는데, 이 기술은 컬렉션이나 배열등을 람다식으로 표현하여 간결하고 가독성 좋은 코드를 만들어주고 복잡하고 많은 양의 코드를 원하는 인스턴스끼리 조합하여 필터링을 해주는등 편리함을 제공합니다.

보통 컬렉션의 첫번째 값을 가져오거나, 특정 조건을 만족하는 데이터만 필터링을 하거나 중복데이터를 제거하거나 이러한 작업을 한결 더 편하게 가공해줍니다.

바로 예시부터 보겠습니다.

아래의 컬렉션을 기준으로 예제들을 진행하겠습니다.

예시데이터

name, jum이라는 문자열이 키값으로 해당 키값에 해당하는 데이터를 넣어놓은 LIST입니다.

List<HashMap<Object, Object>> list = new ArrayList<HashMap<Object, Object>>();
list.add(new HashMap<Object, Object>(){{put("name", "영희");put("jum", 95);}});
list.add(new HashMap<Object, Object>(){{put("name", "영수");put("jum", 80);}});
list.add(new HashMap<Object, Object>(){{put("name", "민수");put("jum", 75);}});
list.add(new HashMap<Object, Object>(){{put("name", "철수");put("jum", 79);}});
list.add(new HashMap<Object, Object>(){{put("name", "민희");put("jum", 85);}});
list.add(new HashMap<Object, Object>(){{put("name", "유리");put("jum", 40);}});
System.out.println("---- Original ----");
list.forEach(System.out::println);

해당 list데이터를 점수가 80점 이상인 데이터만 처리하라고 하면 어떻게 해야할까요?

각각 HashMap데이터의 "jum"인 키를 조회하여 값이 80점 이상인 데이터만 새로운 컬렉션에 넣어주면 될겁니다.

반복문을 통한 필터링

아래 소스를 보시죠. forEach 람다식으로 표현하였습니다.

List<HashMap<Object, Object>> fliter_list = new ArrayList<HashMap<Object, Object>>();
list.forEach(x->{
  int jum = (int) x.get("jum");
  if(jum > 80) {
    fliter_list.add(x);
  }
});
System.out.println("---- Filtering ----");
fliter_list.forEach(System.out::println);

80점 이상인 영희와 민희데이터만 가져온 걸 볼 수 있습니다.

stream filter

80점 이상인 데이터만 필터링하기

Stream<HashMap<Object, Object>> fliter_list = list.stream().filter(xx-> (int) xx.get("jum") > 80);
System.out.println("---- Filtering ----");
fliter_list.forEach(System.out::println);

위에서 복잡하게 80점 이상인 데이터만 호출하여 표출하던 부분이 filter를 통해 손 쉽게 가공이 되었습니다.

이번에는 80점 이상이면서 이름에 "영"이라는 String이 들어간 데이터를 필터링 해보겠습니다.

Stream<HashMap<Object, Object>> fliter_list = list.stream().filter(xx-> 
	(int) xx.get("jum") > 80 && xx.get("name").toString().contains("영")
);
System.out.println("---- Filtering ----");
fliter_list.forEach(System.out::println);

&&연산자를 통해 80점이상과 영이라는 String이 둘 조건이 만족되는 데이터만 필터링 된 것을 볼 수 있습니다.

둘중 하나만 만족해도 나오게 하려면 or 연산자인 || 으로 처리하면 됩니다.

stream을 사용하면서 유의해야 할 점은 최종연산자까지 사용을 해야 동작을 한다는 것입니다.

중간연산자(filter, peek, distinct, ...)까지만 정의하면 의미없는 코드가 되며, 최종연산(collect, forEach, count, ...)을 처리해야 그때부터 중간연산자들도 동작을 시작합니다.

중복제거하기 distinct

List<String> animals = Arrays.asList("dog", "cat", "dog", "cat", "monkey", "rabbit");
Stream<String> filter = animals.stream().distinct();
filter.forEach(System.out::println);

중복된 dog, cat의 문자열배열이 사라진 것을 볼 수 있다.

list내 map객체의 중복된 key값 제거는 단순하게 distinct를 활용하여 제거는 힘듭니다.

JAVA Functional 처리를 통한 필터링처리가 필요한데, 이부분은 추후 포스팅하도록 하겠습니다.

autoboxing이란 래퍼(Wrapper) 클래스의 객체로 변환하는 것을 말합니다.

여기서 래퍼클래스란 기본 타입의 데이터를 객체로 취급해야 하는 경우가 있는데 기본 타입의 데이터를 그대로 사용할수는 없고 데이터를 객체로 변환해야 하는데 해당하는 데이터들을 객체로 포장해주는 것을 말합니다.

아래는 예시입니다.

Integer a = 100;

과 같이 처리하면 Integer는 래퍼 클래스이므로 오토박싱이 일어나면서 new Integer(100)을 알아서 처리해줍니다. 

unboxing이란 래퍼 유형의 객체를 해당 기본 값으로 변환하는 것을 말합니다.

예를들면 Integer가 int로 변환되는것을 말합니다.

Integer a = new Integer(100);
int test = a; //unboxing

래퍼클래스인 Integer a값을 primitivie 변수인 int test에 대입하면 알아서 언박싱되면서 값을 처리해줍니다.

아래는 primitivie type 과 Wrapper class의 대조 표입니다.

참고 사이트

https://www.geeksforgeeks.org/autoboxing-unboxing-java/

자바에서는 클래스를 사용해서 직접 메소드를 참조시켜 메소드를 사용할 수 있는데, 이때 "::" 기호를 사용합니다.

주로 List데이터를 출력할때 System.out.println을 통해 확인하는데

참조 연산자를 사용하면 쉽게 데이터를 확인해볼 수 있습니다.

클래스의 메소드 참조

단순 반복문 출력

import java.util.ArrayList;
import java.util.List;

public class MethodRef {

	public static void main(String[] args) {
		List<String> names = new ArrayList<String>();
		names.add("Matilda");
		names.add("Leon");
		names.add("Naples");
		names.add("Harry Potter");
		names.add("Iron Man");
		
		for(int i=0; i<names.size(); i++) {
			System.out.println(names.get(i));
		}
	}

}

보통 반복문 for문을 활용하여 데이터를 확인하였을텐데,

forEach문을 사용하면 int i와 같은 변수 선언도 필요없이 바로 확인 할 수 있습니다.

names.forEach(d->
	System.out.println(d)
);

여기에 메소드 참조(::)를 사용하면 더욱 간단하게 확인 할 수 있습니다.

names.forEach(System.out::println);

간단한 예제라 사실 큰 의미는 없지만 개발하면서 빠르게 데이터를 확인해볼때, 메소드 참조를 통해 콘솔에 쉽게 찍을 수 있었습니다.

System.out 클래스의 println메소드 사용

아래는 forEach와 메소드참조로 변경한 전체 소스입니다.

import java.util.ArrayList;
import java.util.List;

public class MethodRef {

	public static void main(String[] args) {
		List<String> names = new ArrayList<String>();
		names.add("Matilda");
		names.add("Leon");
		names.add("Naples");
		names.add("Harry Potter");
		names.add("Iron Man");
		
		names.forEach(System.out::println);
	}

}

클래스의 메소드 사용

처음 더블콜론(::)을 설명할 때 클래스를 직접 사용하고 메소드를 참조시킨다고 하였는데, 관련된 예제를 보겠습니다.

import java.util.ArrayList;
import java.util.List;

public class RamdaT {
	
	private void someFunction(String str) {
		System.out.println(str);
	}

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("Apple");
		list.add("Banana");
		list.add("Cherry");
		
		list.forEach(System.out::println);
		
		System.out.println();System.out.println();System.out.println();
		
		list.forEach((new RamdaT())::someFunction);
	}

}

RamdaT라는 클래스에서 someFunction()이라는 함수를 작성하고 파라미터로 전달받은 str변수를 sysout을 통해 출력해주는 예제입니다.

List 컬랙션에 3개의 과일 리스트를 추가하고 출력하는데 처음 forEach부분은 System.out클래스의 println메소드를 통해 출력시킨 부분이고, 두번째는 이번 예제 클래스에서 정의한 RamdaT클래스를 사용하고 someFunction이라는 메소드를 직접 사용하였습니다. 람다에 의해 사용된 변수는 자연스럽게 someFunction함수의 파라미터로 처리되어 아래와 같은 출력을 확인 할 수 있습니다.

개발을 하다보면 자주 서버의 시간을 확인하여 기준일로 두어 조회하거나 시간을 출력해주거나 다양한 용도로 사용하는데 이때마다 JAVA에서 날짜를 구하는 방식은 Calendar.getInstance(); 메소드를 활용하여 날짜를 파싱하고 변경하고 출력하는 형태였다. (1.8미만 버전)

날짜를 변경할때 사용하는 cal.add(); 메소드는 상수를 사용하여 매번 찾게 만들고, 번거롭고 힘든 작업이었다.

1.8이상의 자바를 사용중이라면 LocalDate, LocalTime, LocalDateTime등을 사용하여 훨씬 쉽게 작성이 가능하다.

소스를 통해 차이점을 확인해보자.

Calendar - 오늘 날짜 구하기

Calendar cal = Calendar.getInstance();
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
String date = sdf.format(cal.getTime());
System.out.println(date);

LocalDate -  오늘 날짜 구하기

LocalDate now = LocalDate.now();
System.out.println(now);

동일한 데이터이지만 훨씬 간단하게 날짜를 호출하는걸 확인 할 수 있다.

그럼 LocalDate 클래스는 어떤식으로 형변환을 할 수 있을까?

- format 메소드를 활용하면 된다.

LocalDate now = LocalDate.now();
String format = now.format(DateTimeFormatter.ofPattern("yyyy.MM.dd"));

System.out.println(now);
System.out.println(format);

LocalDate 클래스는 날짜 데이터, LocalTime 클래스는 시간, LocalDateTime 클래스는 시간 날짜 데이터를 가져올 수 있다.

서버의 현재 시간 가져오기, 제어하기

서버 날짜 및 시간 구하기

LocalDate ld = LocalDate.now();  // 날짜 구하기
System.out.println("LocalDate     > " + ld);

LocalTime lt = LocalTime.now();  // 시간 구하기
System.out.println("LocalTime     > " + lt);

LocalDateTime ldt = LocalDateTime.now();  //날짜 + 시간 구하기
System.out.println("LocalDateTime > " + ldt);

날짜를 추가, 감소하기 // 시간을 추가, 감소하기

LocalDate ld = LocalDate.now();  // 날짜 구하기
LocalDate nld = ld.plusDays(5);
System.out.println("LocalDate      > " + ld);  //현재 날짜
System.out.println("plusDate       > " + nld); //5일 뒤

LocalTime lt = LocalTime.now();  // 시간 구하기
LocalTime nlt = lt.minusHours(2);  // 시간 빼기
System.out.println("LocalTime      > " + lt); // 현재시간
System.out.println("minusHours     > " + nld); //2시간 전 시간

LocalDateTime ldt = LocalDateTime.now();  //날짜 + 시간 구하기
LocalDateTime nldt = ldt.plusDays(3).plusHours(3); //3일 + 3시간 뒤
System.out.println("LocalDateTime     > " + ldt);  // 현재 날짜 + 시간
System.out.println("3day 3hours after > " + nldt); // 3일 + 3시간 뒤 출력

plus~(), minus~() 메소드를 통하여 제어가 가능하다.

LocalDate 날짜 관련에서 사용가능 메소드

LocalDate.plusYears(long); //년추가
LocalDate.plusMonths(long); //월추가
LocalDate.plusWeeks(long); //주추가
LocalDate.plusDays(long); //일추가
LocalDate.minusYears(long); //년감소
LocalDate.minusMonths(long); //월감소
LocalDate.minusWeeks(long); //주감소
LocalDate.minusDays(long); //일감소

LocalTime 시간 관련에서 사용가능 메소드

LocalTime.now().plusHours(long); //시간추가
LocalTime.now().plusMinutes(long); //분추가
LocalTime.now().plusSeconds(long); //초추가
LocalTime.now().plusNanos(long); //나노초추가
LocalTime.now().minusHours(long); //시간감소
LocalTime.now().minusMinutes(long); //분감소
LocalTime.now().minusSeconds(long); //초감소
LocalTime.now().minusNanos(long); //나노초감소

LocalDateTime에서는 모두 사용 가능하다.

자바에서 POI 라이브러리를 활용하여 엑셀 읽기를 해보겠다.

과거버전 xls가 아닌 xlsx를 다루는점 참고하길 바라며, 라이브러리는 apache에서 다운받아 사용하거나

maven추가로 사용하면 된다.

지금부터만드는 자바Class 및 함수는 엑셀을 읽고 List로 리턴하는 함수이다.

Maven추가

<!-- excel -->
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi</artifactId>
  <version>3.17</version>
</dependency>	
<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>3.17</version>
</dependency>

POI 3.17버전으로 사용하였다.

JAVA 엑셀을 읽는 XlsxUtils Class 생성

package egov.mongo.utils;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class XlsxUtils {
	
	@SuppressWarnings("resource")
	public static List<List<String>> readToList(String path){
		List<List<String>> list = new ArrayList<List<String>>();
		
		try {
			FileInputStream fi = new FileInputStream(path);
			XSSFWorkbook workbook = new XSSFWorkbook(fi);
			XSSFSheet sheet = workbook.getSheetAt(0);
			
			for(int i=0; i<sheet.getLastRowNum(); i++) {
				XSSFRow row = sheet.getRow(i);
				if(row != null) {
					List<String> cellList = new ArrayList<String>();
					for(int j=0; j<row.getLastCellNum(); j++) {
						XSSFCell cell = row.getCell(j);
						if(cell != null) {
							cellList.add( cellReader(cell) ); //셀을 읽어와서 List에 추가
						}
					}
					list.add(cellList); // 추가된 로우List를 List에 추가
				}
			}
		}catch(FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}
		
		return list;
	}
	
	
	@SuppressWarnings("incomplete-switch")
	private static String cellReader(XSSFCell cell) {
		String value = "";
		CellType ct = cell.getCellTypeEnum();
		if(ct != null) {
			switch(cell.getCellTypeEnum()) {
			case FORMULA:
				value = cell.getCellFormula();
				break;
			case NUMERIC:
			    value=cell.getNumericCellValue()+"";
			    break;
			case STRING:
			    value=cell.getStringCellValue()+"";
			    break;
			case BOOLEAN:
			    value=cell.getBooleanCellValue()+"";
			    break;
			case ERROR:
			    value=cell.getErrorCellValue()+"";
			    break;
			}
		}
		return value; 
	}
}

스트림을 통해 파라미터로 넘어온 경로를 확인하고 엑셀파일을 엑셀Workbook에 읽어서 파싱을 시작한다.

첫번째 시트만 읽도록 처리해놨다.

로우의 수만큼 차례대로 셀을 확인하여 셀의 타입을 cellReader함수에서 체크하고 List배열에 담는다.

Main.java

public class Main {

	public static void main(String[] args) {
		String filePath = "C:/test/ttt.xlsx";
		List<List<String>> readList = XlsxUtils.readToList(filePath);
		
		readList.forEach(row->{
			row.forEach(cell->{
				System.out.print(cell+", ");
			});
			System.out.println();
		});
	}
}

위 문법이 어렵다면(자바 1.8이하라면)

아래방법 for문으로 확인하면 된다.

public class Main {

	public static void main(String[] args) {
		String filePath = "C:/test/ttt.xlsx";
		List<List<String>> readList = XlsxUtils.readToList(filePath);
		
		for(int i=0; i<readList.size(); i++) {
			for(int j=0; j<readList.get(i).size(); j++) {
				System.out.print(readList.get(i).get(j)+", ");
			}
			System.out.println();
		}
	}
}

정상적으로 엑셀 데이터를 읽어와서 List에 담긴걸 확인할 수 있다.

CSV(comma-separated values)는 쉼표로 구분한 텍스트 파일로 확장자가.csv로 이다.

엑셀로 읽기도 편하고 간편하게 파일을 읽고 쓰는 방식으로 쉼표로 구분되어 있는 csv파일을 자바에서 읽는 방법을 포스팅한다.

CsvUtils.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class CsvUtils {
	
	private static Log logger = LogFactory.getLog(CsvUtils.class);
	
	public static List<List<String>> readToList(String path) {
		List<List<String>> list = new ArrayList<List<String>>();
		File csv = new File(path);
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(csv));
			Charset.forName("UTF-8");
			String line = "";
			
			while((line=br.readLine()) != null) {
				String[] token = line.split(",");
				List<String> tempList = new ArrayList<String>(Arrays.asList(token));
				list.add(tempList);
			}
			
		} catch (FileNotFoundException e) {
			logger.error(e);
		} catch (IOException e) {
			logger.error(e);
		} finally {
			try {
				if(br != null) {br.close();}
			} catch (IOException e) {
				logger.error(e);
			}
		}
		return list;
	}
}

로거부분은 제외하고 봐도 무관하다.

파라미터로 넘어온 경로를 읽어서 csv파일을 읽고 리스트로 return처리를 하는 함수다.

사용 호출부분

main.java

import java.util.List;

public class Main {

	public static void main(String[] args) {
    
		String path = "csv파일이 있는 경로 지정";
		List<List<String>> list = CsvUtils.readToList(path);
		for(int i=0; i<list.size(); i++) {
			List<String> line = list.get(i);
			for(int j=0; j<line.size(); j++) {
				System.out.print(line.get(j)+",");
			}
			System.out.println();
		}
	}
}

csv데이터

결과

한글 처리시 유의점은 UTF-8로 csv파일이 인코딩이 된 문서여야 읽힌다는 점이다.

엑셀에서 csv로 저장시에도 기본 인코딩인 유니코드로만 저장되는 점을 발견하였고, 강제 인코딩 방법으론

csv파일을 엑셀로 열지 말고 메모장으로 열어주고 다른 이름으로 저장 클릭 후 인코딩을 UTF-8로 처리하면 정상적으로 한글이 읽힌다.

Java 1.8버전 이하에서는 날짜를 구하려면 Calendar 객체를 호출하고 데이트포맷을 설정하여 문자열로 받아와 출력을 해줘야 한다.

Java에서 날짜를 구하는 함수를 만들어서 공유하고자 포스팅한다.

오늘 날짜 구하기

Calendar cal = Calendar.getInstance();
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
String date = sdf.format(cal.getTime());
System.out.println(date);

어제 날짜 구하기 - Calendar.add() 메소드 활용

Calendar cal = Calendar.getInstance();
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
cal.add(cal.DATE, -1); //날짜를 하루 뺀다.
String date = sdf.format(cal.getTime());
System.out.println(date);

내일 날짜 구하기 - Calendar.add() 메소드 활용

Calendar cal = Calendar.getInstance();
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
cal.add(cal.DATE, +1); //날짜를 하루 더한다.
String date = sdf.format(cal.getTime());
System.out.println(date);

세달 전 날짜 구하기 - Calendar.add() 메소드 활용

Calendar cal = Calendar.getInstance();
String format = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(format);
cal.add(cal.MONTH, -3); //세달 전
String date = sdf.format(cal.getTime());
System.out.println(date);

이와 같이 Calendar 객체의 add() 메소드를 활용하여 원하는 날짜를 구하면 된다.

아래는 매번 호출하고 사용하는게 번거로워 만들어놓은 자바소스를 공유한다.

DateUtils.getDate()메소드에 cal Instanse객체를 넣고 원하는 날짜 이전, 이후 날짜를 입력하면 데이터가 호출된다.

Main.java

public static void main(String[] args){
    Calendar calendar = Calendar.getInstance();
    //오늘
    String today = DateUtils.getDate(cal, "date"); //오늘
    String yesterday = DateUtils.getDate(cal, "date", "date", -1); //어제
    String before4Day = DateUtils.getDate(cal, "date", "date", -4); //4일전
    String month = DateUtils.getDate(cal, "month"); //이번달
    String beforeMonth = DateUtils.getDate(cal, "month", "month", -1); //지난달
    String year = DateUtils.getDate(cal, "year"); //올해
    String before3year = DateUtils.getDate(cal, "year", "year", -3); //3년전
    System.out.println(today);
    System.out.println(yesterday);
    System.out.println(before4Day);
    System.out.println(month);
    System.out.println(beforeMonth);
    System.out.println(year);
    System.out.println(before3year);
}

DateUtils.java

import java.text.SimpleDateFormat;
import java.util.Calendar;

public class DateUtils {
	
	private static final String F_YEAR = "yyyy";
	private static final String F_MONTH = "yyyy.MM";
	private static final String F_MONTH2 = "yyyy-MM";
	private static final String F_DATE = "yyyy.MM.dd";
	private static final String F_DATE2 = "yyyy-MM-dd";
	private static final String F_TIMESTAMP = "yyyy.MM.dd HH:mm:ss";

	/*******************************/
	/********** 공통사용 함수 **********/
	/*******************************/
	
	/**
	 * 날짜 출력 함수
	 * @param cal
	 * @param type
	 * @return
	 */
	public static String getDate(Calendar cal, String type) {
		return getDateFormatter(type).format(cal.getTime());
	}
	
	/**
	 * 날짜 출력 함수(이전 날짜 전용)  ex)어제, 일주일전, 지난달, 작년 등
	 * @param cal
	 * @param type
	 * @param before
	 * @param beforeValue
	 * @return
	 */
	@SuppressWarnings("static-access")
	public static String getDate(Calendar cal, String type, String before, int beforeValue){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(cal.getTime());
		SimpleDateFormat sdf = getDateFormatter(type);
		
		if(before != null && !before.trim().equals("")) {
			int beforeType = 0;
			before = before.trim().toLowerCase();
			switch(before) {
			case "year"://년
				beforeType = calendar.YEAR;
				break;
			case "month"://월
				beforeType = calendar.MONTH;
				break;
			case "week"://주
				beforeType = calendar.DATE;
				break;
			case "date"://일
				beforeType = calendar.DATE;
				break;
			}
			calendar.add(beforeType, beforeValue);
		}
		String date = sdf.format(calendar.getTime());
		return date;
	}
	
	/**
	 * SimpleDateFomat형 날짜 포맷용 설정 상수에서 가져옴
	 * @param type
	 * @return
	 */
	public static SimpleDateFormat getDateFormatter(String type) {
		if(type != null) {
			type = type.trim().toLowerCase();
			switch(type) { //상단에 선언된 상수 String형 포맷을 받아온다.
			case "year":
				type = F_YEAR;
				break;
			case "month":
				type = F_MONTH;
				break;
			case "month2":
				type = F_MONTH2;
				break;
			case "week":
				type = F_DATE;
				break;
			case "date":
				type = F_DATE;
				break;
			case "date2":
				type = F_DATE2;
				break;				
			case "timestamp":
				type = F_TIMESTAMP;
				break;
			}
			SimpleDateFormat sdf = new SimpleDateFormat(type);
			return sdf;
		}else {
			return null;
		}
	}
}

표시하고자 하는 형태의 구분자는 상수값에서 변경해서 쓰시면 됩니다.

ex)

private static final String F_DATE = "yyyy.MM.dd";

-> private static final String F_DATE = "yyyy-MM-dd";

HttpServletRequest 으로 넘어오는 모든 request값을 확인하는 방법으로 getParamterNames() 메소드가 존재한다.

바로 소스를 통해 확인해보자.

Enumeration params = request.getParameterNames();
while(params.hasMoreElements()) {
  String name = (String) params.nextElement();
  System.out.print(name + " : " + request.getParameter(name) + "     "); 
}
System.out.println();

해당 방법을 통하여 key, value값을 쉽게 확인 할 수 있다.