File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
File name
Commit message
Commit date
package common.util;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
public class CommonUtil {
/**
* @author 최정우
* @since 2019.12.11
*
* 데이터의 표준화 사용 유무
*/
private static boolean IS_USE_STANDARD = true;
public static void setIsUseStandard (boolean isUseStandard) {
IS_USE_STANDARD = isUseStandard;
}
public static boolean getIsUseStandard () {
return IS_USE_STANDARD;
}
/**
* @author 최정우
* @since 2019.11.13
*
* 빈 문자열 검사
*/
public static boolean isNull(Object obj) {
return obj == null;
}
/**
* @author 최정우
* @since 2019.11.13
*
* string to int check
*/
public static boolean isInt (String text) {
try {
Integer.parseInt(text);
return true;
} catch(NumberFormatException e) {
return false;
}
}
/**
* @author 최정우
* @since 2019.11.13
*
* string to int check
*/
public static boolean isLong (String text) {
try {
Long.parseLong(text);
return true;
} catch(NumberFormatException e) {
return false;
}
}
/**
* @author 최정우
* @since 2019.11.13
*
* string to double check
*/
public static boolean isDouble (String text) {
try {
Double.parseDouble(text);
return true;
} catch (NumberFormatException e) {
return false;
} catch (Exception e) {
return false;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* object to int
*/
public static int parseInt (Object obj) {
try {
return Integer.parseInt(obj.toString());
} catch(Exception e) {
return 0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* string to int
*/
public static int parseInt (String text) {
try {
return Integer.parseInt(text);
} catch(NumberFormatException e) {
return 0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* int to double
*/
public static long parseLong (int number) {
try {
return (long) number;
} catch(Exception e) {
return 0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* object to double
*/
public static long parseLong (String text) {
try {
return Long.parseLong(text);
} catch(Exception e) {
return 0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* object to double
*/
public static long parseLong (Object obj) {
try {
if (obj instanceof Integer) {
return (long) obj;
} else {
return Long.parseLong(obj.toString());
}
} catch(Exception e) {
return 0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* int to double
*/
public static double parseDouble (int number) {
try {
return (double) number;
} catch(Exception e) {
return 0.0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* object to double
*/
public static double parseDouble (String text) {
try {
return Double.parseDouble(text);
} catch(Exception e) {
return 0.0;
}
}
/**
* @author 최정우
* @since 2020.01.08
*
* object to double
*/
public static double parseDouble (Object obj) {
try {
if (obj instanceof Integer) {
return (double) obj;
} else {
return Double.parseDouble(obj.toString());
}
} catch(Exception e) {
return 0.0;
}
}
/**
* @author 최정우
* @since 2019.11.13
*
* 문자열의 모든 공백 제거
*/
public static String allTrim(String text) {
return text.replaceAll("\\p{Z}", "");
}
/**
* @author 최정우
* @since 2019.11.13
*
* 문자열 앞뒤 공백 제거후, 문자열 사이에 존재하는 공백을 한개의 공백으로 치환
* ex) " abcd efg hijk " => "abcd efg hijk"
*/
public static String normalizeSpace(String text) {
return text.trim().replaceAll("\\s+", " ");
}
/**
* @author 최정우
* @since 2019.11.13
*
* 숫자 빼고 모든 문자 제거
*/
public static String getOnlyNumber (String text) {
return text.replaceAll("[^0-9]", "");
}
/**
* @author 최정우
* @since 2019.11.13
*
* 문자 빼고 모든 숫자 제거
*/
public static String getOnlyText (String text) {
return text.replaceAll("[0-9]", "");
}
/**
* @author 최정우
* @since 2019.11.13
*
* 특정 문자열 개수 check
*/
public static int getWordCount (String text, String word) {
int size = 0;
int fromIndex = -1;
while ((fromIndex = text.indexOf(word, fromIndex + 1)) >= 0) {
size++;
}
return size;
}
/**
* @author 최정우
* @since 2021.12.05
*
* 현재 서버 일시 구하기
*/
public static Date getDateTime() {
LocalDateTime localDateTime = LocalDateTime.now();
return Timestamp.valueOf(localDateTime);
}
/**
* @author 최정우
* @since 2019.11.13
*
* 문자열 to Date문자열
*/
public static boolean isDate (String text) {
if (StringUtil.isEmpty(text) == true || StringUtil.isEmpty(getOnlyNumber(text)) == true || getOnlyNumber(text).length() < 6) {
return false;
}
//공백을 제외한 문자얻기, 대문자로 치환
String newText = allTrim(text).toUpperCase();
try {
//문자열의 날짜 패턴 생성
String pattern = createDatePattern(newText);
if (pattern == null) {
return false;
}
SimpleDateFormat newPattern = new SimpleDateFormat(pattern);
//문자열 날짜 형태로 변환
newPattern.parse(newText);
return true;
} catch (Exception e) {
//e.printStackTrace();
return false;
}
}
/**
* @author 최정우
* @since 2019.11.13
*
* 문자열 to Date문자열
*/
public static String parseDateText (String text) {
if (StringUtil.isEmpty(text) == true || StringUtil.isEmpty(getOnlyNumber(text)) == true || getOnlyNumber(text).length() < 6) {
return null;
}
//공백을 제외한 문자얻기, 대문자로 치환
String newText = allTrim(text).toUpperCase();
//문자열의 날짜 패턴 생성
String pattern = createDatePattern(newText);
if (pattern == null) {
return null;
}
Date date = null;
String dateText = null;
try {
SimpleDateFormat newPattern = new SimpleDateFormat(pattern);
//문자열 날짜 형태로 변환
date = newPattern.parse(newText);
//DB에 저장할 날짜 패턴
SimpleDateFormat defalutPattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dateText = defalutPattern.format(date);
} catch (Exception e) {
//e.printStackTrace();
}
return dateText;
}
public static <T> List<T> mapToList (Map<?, T> map) {
List<T> items = new ArrayList<T>();
if (map != null) {
for(Map.Entry<?, T> item : map.entrySet()) {
items.add(item.getValue());
}
}
return items;
}
public static Map objectToMap(Object obj) {
if (obj != null) {
try {
return (Map) obj;
} catch (Exception e) {
return new HashMap();
}
} else {
return new HashMap();
}
}
/*
* 시간 타입
* PM, AM
*/
public final static List<String> TIME_TYPES = Arrays.asList(new String[] {"AM", "PM", "오전", "오후"});
/*
* 날짜 포맷 패턴's
*/
public final static List<Character> DATE_PATTERNS = Arrays.asList(new Character[] {'y', 'M', 'd', 'H', 'm', 's'});
/*
* 날짜 포맷 패턴's의 최대 문자열 수
*/
public final static List<Integer> DATE_PATTERNS_MAX_LENGTH = Arrays.asList(new Integer[] {4, 2, 2, 2, 2, 2});
/**
* @author 최정우
* @since 2019.11.13
*
* 문자열의 날짜 패턴 생성
*/
public static String createDatePattern (String date) {
List<Character> DATE_PATTERNS = Arrays.asList(new Character[] {'y', 'M', 'd', 'H', 'm', 's'});
//시간 표기가 (0~12 -> AM, PM사용)인지 (0~23)인지 확인 후, 날짜 포맷 패턴's에 있는 시간 패턴 변경
int timeTypeFindIndex = -1;
for (int i = 0; i < TIME_TYPES.size(); i++) {
//("AM", "PM", "오전", "오후" 중 1개)가 포함된 단어가 있는지 확인, Index 위치를 담기(없으면 -1)
if ((timeTypeFindIndex = date.indexOf(TIME_TYPES.get(i))) > -1) {
//문자열에 포함된 ("AM", "PM", "오전", "오후" 중 1개) 삭제
date = date.replaceAll(TIME_TYPES.get(i), "");
//시간 패턴 변경 [H -> h]
DATE_PATTERNS.set(3, 'h');
break;
}
}
//숫자를 뺀 나머지 문자열 가지고오기 ex) "2020.08.03" -> ".."
//숫자를 뺀 나머지 문자열 가지고오기 ex) "2020.08.03 19:20:21" -> "..::"
final char[] separators = getOnlyText(date).toCharArray();
/*
System.out.println("");
System.out.println("@@@@@@@@@@@@@@ textToDateText @@@@@@@@@@@@@@");
System.out.println("공백제거 텍스트 : " + date);
System.out.println("숫자제거 텍스트 : " + String.valueOf(separators));
*/
//사용할 최대 패턴 수
int maxPatterSize = 0;
if (DATE_PATTERNS.size() <= separators.length) {
maxPatterSize = DATE_PATTERNS.size();
} else {
maxPatterSize = separators.length;
}
//구분자별 Index 위치's (사용할 최대 패턴 수 + 시작점:-1, 종료점:date문자열의 최종 길이)
List<Integer> sizeByPatterns = new ArrayList<Integer>();
//System.out.println("");
//System.out.println("newText : " + date);
//구분자 별 Index 위치 파악 후, 앞에 있는 문자열의 수 찾은 후, 추가 (마지막 패턴 뒤에 있는 문자열을 따로 처리해줘야함)
int fromIndex = -1;
for (int i = 0; i < maxPatterSize; i++) {
//구분자
char separator = separators[i];
//'현재 찾은 위치' : 이전에 찾은 위치(찾기 시작할 위치 => fromIndex) + 1 부터 찾기 시작함
int currentFromIndex = date.indexOf(separator, fromIndex + 1);
//현재 패턴의 문자열 수 = '현재 찾은 위치' - '이전에 찾은 위치' - 1 [추가]
sizeByPatterns.add(currentFromIndex - fromIndex - 1);
//System.out.print("[" + sizeByPatterns.get(i) +"] ");
//'현재 찾은 위치'는 '이전에 찾은 위치'가 됨
fromIndex = currentFromIndex;
}
//마지막 패턴 뒤에 있는 문자열 = '문자열의 길이' - '마지막에 찾은 위치(이전에 찾은 위치)' - 1 [추가]
sizeByPatterns.add(date.length() - fromIndex - 1);
//System.out.println("");
//System.out.println("시간 타입 체킹 Index : " + timeTypeFindIndex);
//패턴을 담을 변수
StringBuilder pattern = new StringBuilder();
//DATE_PATTERS 순서 대로, 각 구분자 별 Index 위치 크기만큼 문자열에 패턴 삽입 + 구분자 삽입
//마지막 전까지만 for문 돌림
for (int i = 0, patternIndex = 0; i < sizeByPatterns.size() && patternIndex < DATE_PATTERNS.size(); i++, patternIndex++) {
//패턴 추가
int usingSize = 0;
for (int j = 0; j < sizeByPatterns.get(i); j++) {
if (j >= usingSize + DATE_PATTERNS_MAX_LENGTH.get(patternIndex)) {
usingSize += DATE_PATTERNS_MAX_LENGTH.get(patternIndex++);
/*단 한개의 패턴이라도 '최대 문자열 수'를 넘어서면 -> '날짜 아님'*/
if (i >= sizeByPatterns.size() || patternIndex >= DATE_PATTERNS.size()) {
return null;
}
}
pattern.append(DATE_PATTERNS.get(patternIndex));
}
//날짜 구분자 추가 (마지막 구분자까지만)
if (i < separators.length) {
pattern.append(separators[i]);
}
}
if (timeTypeFindIndex > -1) {
pattern.insert(timeTypeFindIndex, 'a');
}
return pattern.toString();
}
/**
* @author 최정우
* @since 2020.01.26
*
* ping 체크
*/
public static boolean pingCheck (String ip) {
InetAddress inetAddress;
try {
inetAddress = InetAddress.getByName(ip);
return inetAddress.isReachable(1000);
} catch (UnknownHostException e) {
return false;
} catch (IOException e) {
return false;
} catch (Exception e) {
return false;
}
}
/**
* @author 최정우
* @since 2020.01.26
*
* 현재 client의 HttpServletRequest 조회
*/
public static HttpServletRequest getHttpServletRequest () {
try {
ServletRequestAttributes servletRequestAttribute = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
return servletRequestAttribute.getRequest();
} catch (Exception e) {
return null;
}
}
/**
* @author 최정우
* @since 2020.01.26
*
* 현재 client의 HttpSession 조회
*/
public static HttpSession getHttpSession (boolean create) {
try {
HttpServletRequest request = getHttpServletRequest();
if (request != null) {
return request.getSession(create);
} else {
return null;
}
} catch (Exception e) {
return null;
}
}
/**
* @author 최정우
* @since 2020.01.26
*
* HttpServletRequest를 활용한 Client IP 가지고오기
* Header의 X-FORWARDED-FOR 값을 통해 IP 조회, 만약 Header에 X-FORWARDED-FOR가 없으면 getRemoteAddr() 이걸로 조회
*/
public static String getClientIp () {
try {
HttpServletRequest request = getHttpServletRequest();
if (null != request.getHeader("X-FORWARDED-FOR")) {
return request.getHeader("X-FORWARDED-FOR");
} else {
return request.getRemoteAddr();
}
} catch (Exception e) {
return null;
}
}
/**
* @author 최정우
* @since 2020.01.26
*
* ping 체크 (ip + port)
*/
public static boolean pingCheck(String ip, int port) {
Socket socket = new Socket();
try {
socket.connect(new InetSocketAddress(ip, port), 1000);
boolean isConnect = socket.isConnected();
socket.close();
return isConnect;
} catch (UnknownHostException e) {
return false;
} catch (IOException e) {
return false;
} catch (Exception e) {
return false;
}
}
/************************************* objectSetValue : Object to Object (start) *************************************/
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] VO객체(valueObject)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetValue (Object targetObject, Object valueObject) {
objectSetValue(targetObject, valueObject, null, null);
}
public static void objectSetValue (Object targetObject, Object valueObject, Class<?>[] ignoreClasses) {
objectSetValue(targetObject, valueObject, ignoreClasses, null);
}
public static void objectSetValue (Object targetObject, Object valueObject, String[] ignoreFields) {
objectSetValue(targetObject, valueObject, null, ignoreFields);
}
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] VO객체(valueObject)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드 (+ 제거할 변수 목록)
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetValue (Object targetObject, Object valueObject, Class<?>[] ignoreClasses, String[] ignoreFields) {
//빈값 체크
if (valueObject == null || targetObject == null) {
return;
}
//vo객체의 클래스 정보 얻기
Class<?> valueObjectClass = valueObject.getClass();
//vo객체의 클래스의 값이 null이 될 때 까지 반복
while (valueObjectClass != null) {
/* Class 필터 */
boolean isIgnoreClassFind = false;
if (ignoreClasses != null) {
for (Class<?> ignoreClass : ignoreClasses) {
if (valueObjectClass.getName().equals(ignoreClass.getName())) {
//System.out.println("["+valueObjectClass.getName()+"] 제거(값 세팅 안하고 return) @@@@@@@@@@@@@@@@@@@@@");
isIgnoreClassFind = true;
break;
}
}
//제거할 Class를 찾았을 때 -> 다음 상위 클래스로 이동
if (isIgnoreClassFind == true) {
//vo객체가 상속받은 상위클래스 정보 얻기
valueObjectClass = valueObjectClass.getSuperclass();
continue;//while문으로 이동
}
}/* Class 필터 */
//vo객체의 Field목록 얻기
Field[] valueObjectFields = valueObjectClass.getDeclaredFields();
//Field 목록이 있을 때 -> 값 세팅하러 가기
if (valueObjectFields != null && valueObjectFields.length > 0) {
for (int i = 0; i < valueObjectFields.length; i++) {
/* Field 필터 */
boolean isIgnoreFieldFind = false;
if (ignoreFields != null) {
for (String ignoreField : ignoreFields) {
if (valueObjectFields[i].getName().equals(ignoreField)) {
//System.out.println("["+valueObjectFields[i].getName()+"] 제거(값 세팅 안하고 return) @@@@@@@@@@@@@@@@@@@@@");
isIgnoreFieldFind = true;
break;
}
}
//제거할 Field를 찾았을 때 -> 다음 Field로 이동
if (isIgnoreFieldFind == true) {
continue;//for문으로 이동
}
}/* Field 필터 */
//현재 vo객체 정보를 target객체에 값 세팅하기
objectSetValueForField(targetObject, targetObject.getClass(), valueObject, valueObjectFields[i]);
}
}
//vo객체가 상속받은 상위클래스 정보 얻기
valueObjectClass = valueObjectClass.getSuperclass();
}
}
/**
* @author 최정우
* @since 2020.04.22
*
* public objectSetValue에서만 호출 가능
*
*/
private static void objectSetValueForField (Object targetObject, Class<?> targetObjectSuperClass, Object valueObject, Field valueObjectField) {
//빈값 체크
if (valueObject == null || valueObjectField == null || targetObject == null || targetObjectSuperClass == null) {
return;
}
//Field 접근자 타입이 private라도 필드 정보에 접근가능하게 해줌
valueObjectField.setAccessible(true);
try {
//vo객체의 변수필드의 명칭을 이용하여, 목표 객체의 변수필드 찾기. 만약, 못 찾으면 -> NoSuchFieldException오류 발생 -> catch로 이동
Field targetObjectField = targetObjectSuperClass.getDeclaredField(valueObjectField.getName());
targetObjectField.setAccessible(true);//private 변수도 접근가능하도록 settting
//데이터 전달 객체의 필드 데이터 타입
String valueObjectFieldType = valueObjectField.getType().getName();
//타겟 객체의 필드 데이터 타입
String targetFieldType = targetObjectField.getType().getTypeName();
/* 목표 객체의 변수필드가 상수(final)이 아니고, 데이터 타입이 같고 때 -> 같은 클래스의 변수필드 인지 확인 */
if (Modifier.isFinal(targetObjectField.getModifiers()) == false) {
//데이터 타입이 완전 똑같을 때
if (valueObjectFieldType.equals(targetFieldType)) {
//값 세팅
targetObjectField.set(targetObject, valueObjectField.get(valueObject));
} else {
//타겟 변수가 기본형 변수 일 때
if (targetObjectField.getType().isPrimitive()) {
String typeFullName = "java.lang." + targetFieldType;
if (typeFullName.toLowerCase().equals(valueObjectFieldType.toLowerCase())) {
//값 세팅
targetObjectField.set(targetObject, valueObjectField.get(valueObject));
} else {
throw new NoSuchFieldException();
}
} else if (targetObjectField.getType().isInterface()) {//타겟 변수가 인터페이스 일 때
//데이터 전달 객체 변수의 타입이 '타겟 변수의 인터페이스'구현체인지 확인하기
boolean isImpl = false;
//데이터 전달 객체 변수 객체 생성
Class<?> runtimeClass = ClassLoader.getSystemClassLoader().loadClass(valueObjectFieldType);
//데이터 전달 객체 변수의 '인터페이스' 목록 가지고오기
Class<?>[] impls = runtimeClass.getInterfaces();
//인터페이스가 있는지 없는지 확인
for(Class<?> clz : impls) {
if(clz.getName().equals(targetFieldType)) {
isImpl = true;
}
}
//구현체라면
if (isImpl == true) {
//값 세팅
targetObjectField.set(targetObject, valueObjectField.get(valueObject));
} else {
throw new NoSuchFieldException();
}
} else {
throw new NoSuchFieldException();
}
}
}
} catch (NoSuchFieldException e) {//목표 객체에서 변수를 발견 못했을 때 -> 목표 객체의 상위클래스 변수에서 찾아보기
//목표 객체의 상위클래스가 존재할 때 -> 재귀 호출
if (targetObjectSuperClass.getSuperclass() != null) {
try {
//목표객체의 상위클래스에서 변수 찾아서 값넣어주기 위해 재귀호출함
objectSetValueForField(targetObject, targetObjectSuperClass.getSuperclass(), valueObject, valueObjectField);
} catch (Exception e1) {
e1.printStackTrace();
}
} else {
return;
}
} catch (Exception e) {
e.printStackTrace();
}
}
/************************************* objectSetValue : Object to Object (end) *************************************/
/************************************* objectSetMapValue : Map to Object (start) *************************************/
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] Map객체(Map<?, ?>)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드 (+ 제거할 변수 목록)
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetMapValue (Object targetObject, Map<?, ?> valueObject) {
objectSetMapValue(targetObject, valueObject, null);
}
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] Map객체(Map<?, ?>)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드 (+ 제거할 변수 목록)
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetMapValue (Object targetObject, Map<?, ?> valueObject, String[] ignoreFields) {
//빈값 체크
if (valueObject == null || targetObject == null) {
return;
}
for(Map.Entry<?, ?> elem : valueObject.entrySet()) {
String fieldName = StringUtil.toString(elem.getKey());
Object fieldValue = elem.getValue();
if (fieldValue == null) continue;
String fieldType = elem.getValue().getClass().getTypeName();
/* Field 필터 */
boolean isIgnoreFieldFind = false;
if (ignoreFields != null) {
for (String ignoreField : ignoreFields) {
if (fieldName.equals(ignoreField)) {
//System.out.println("["+valueObjectFields[i].getName()+"] 제거(값 세팅 안하고 return) @@@@@@@@@@@@@@@@@@@@@");
isIgnoreFieldFind = true;
break;
}
}
//제거할 Field를 찾았을 때 -> 다음 Field로 이동
if (isIgnoreFieldFind == true) {
continue;//for문으로 이동
}
}/* Field 필터 */
objectSetValueForField(targetObject, targetObject.getClass(), fieldName, fieldType, fieldValue);
}
}
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] Map객체(Map<?, ?>)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드 (+ 제거할 변수 목록)
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetValueForField (Object targetObject, Class<?> targetObjectSuperClass, String fieldName, String fieldType, Object fieldValue) {
//System.out.println("targetObjectName : " + targetObject.getClass().getName() + ", targetObjectSuperClassName : " + targetObjectSuperClass.getName() + ", fieldName : " + fieldName + ", fieldType : " + fieldType);
//빈값 체크
if (StringUtil.isEmpty(fieldName) == true || StringUtil.isEmpty(fieldType) == true || fieldValue == null
|| targetObject == null || targetObjectSuperClass == null) {
return;
}
try {
//vo객체의 변수필드의 명칭을 이용하여, 목표 객체의 변수필드 찾기. 만약, 못 찾으면 -> NoSuchFieldException오류 발생 -> catch로 이동
Field targetObjectField = targetObjectSuperClass.getDeclaredField(fieldName);
targetObjectField.setAccessible(true);//private 변수도 접근가능하도록 settting
//System.out.println("targetObjectFieldName : " + targetObjectField.getName() + ", targetObjectField Type Name : " + targetObjectField.getType().getTypeName() + ", " + targetObjectField.getType().getName() + ", 기본형 유무 : " + targetObjectField.getType().isPrimitive() + ", 인터페이스 유무 : " + targetObjectField.getType().isInterface());
//타겟 객체의 필드 데이터 타입
String targetFieldType = targetObjectField.getType().getTypeName();
/* 목표 객체의 변수필드가 상수(final)이 아니고, 데이터 타입이 같고 때 -> 같은 클래스의 변수필드 인지 확인 */
if (Modifier.isFinal(targetObjectField.getModifiers()) == false) {
//데이터 타입이 완전 똑같을 때
if (fieldType.equals(targetFieldType)) {
//값 세팅
targetObjectField.set(targetObject, fieldValue);
//System.out.println("셋팅 완료");
} else {
//타겟 변수가 기본형 변수 일 때
if (targetObjectField.getType().isPrimitive()) {
String typeFullName = "java.lang." + targetFieldType;
if (typeFullName.toLowerCase().equals(fieldType.toLowerCase())) {
//값 세팅
targetObjectField.set(targetObject, fieldValue);
//System.out.println("셋팅 완료");
} else {
throw new NoSuchFieldException();
}
} else if (targetObjectField.getType().isInterface()) {//타겟 변수가 인터페이스 일 때
//데이터 전달 객체 변수의 타입이 '타겟 변수의 인터페이스'구현체인지 확인하기
boolean isImpl = false;
//데이터 전달 객체 변수 객체 생성
Class<?> runtimeClass = ClassLoader.getSystemClassLoader().loadClass(fieldType);
//데이터 전달 객체 변수의 '인터페이스' 목록 가지고오기
Class<?>[] impls = runtimeClass.getInterfaces();
//인터페이스가 있는지 없는지 확인
for(Class<?> clz : impls) {
if(clz.getName().equals(targetFieldType)) {
isImpl = true;
}
}
//구현체라면
if (isImpl == true) {
//값 세팅
targetObjectField.set(targetObject, fieldValue);
//System.out.println("셋팅 완료");
} else {
throw new NoSuchFieldException();
}
} else {
throw new NoSuchFieldException();
}
}
} else {
return;
}
} catch (NoSuchFieldException e) {//목표 객체에서 변수를 발견 못했을 때 -> 목표 객체의 상위클래스 변수에서 찾아보기
//목표 객체의 상위클래스가 존재할 때 -> 재귀 호출
if (targetObjectSuperClass.getSuperclass() != null) {
try {
//목표객체의 상위클래스에서 변수 찾아서 값넣어주기 위해 재귀호출함
objectSetValueForField(targetObject, targetObjectSuperClass.getSuperclass(), fieldName, fieldType, fieldValue);
} catch (Exception e1) {
e1.printStackTrace();
}
} else {
return;
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("");
}
/**
* @author 최정우
* @since 2020.04.22
*
* [리플렉션 활용] Map객체(Map<?, ?>)의 변수들의 값 -> 목표 객체(targetObject)에 setting 해주는 메서드 (+ 제거할 변수 목록)
*
* 단, '명칭'과 '데이터 타입'이 같아야 값이 세팅됨
*/
public static void objectSetValueForField (Object targetObject, Class<?> targetObjectSuperClass, String fieldName, Object fieldValue) {
//빈값 체크
if (StringUtil.isEmpty(fieldName) == true || fieldValue == null || targetObject == null || targetObjectSuperClass == null) {
return;
}
try {
//vo객체의 변수필드의 명칭을 이용하여, 목표 객체의 변수필드 찾기. 만약, 못 찾으면 -> NoSuchFieldException오류 발생 -> catch로 이동
Field targetObjectField = targetObjectSuperClass.getDeclaredField(fieldName);
targetObjectField.setAccessible(true);//private 변수도 접근가능하도록 settting
/* 목표 객체의 변수필드가 상수(final)이 아니고, 데이터 타입이 같고 때 -> 같은 클래스의 변수필드 인지 확인 */
if (Modifier.isFinal(targetObjectField.getModifiers()) == false) {
//값 세팅
targetObjectField.set(targetObject, targetObjectField.getType().cast(fieldValue));
//같은 클래스일 때 ->
} else {
return;
}
} catch (NoSuchFieldException e) {//목표 객체에서 변수를 발견 못했을 때 -> 목표 객체의 상위클래스 변수에서 찾아보기
//목표 객체의 상위클래스가 존재할 때 -> 재귀 호출
if (targetObjectSuperClass.getSuperclass() != null) {
try {
//목표객체의 상위클래스에서 변수 찾아서 값넣어주기 위해 재귀호출함
objectSetValueForField(targetObject, targetObjectSuperClass.getSuperclass(), fieldName, fieldValue);
} catch (Exception e1) {
e1.printStackTrace();
}
} else {
return;
}
} catch (Exception e) {
e.printStackTrace();
}
}
/************************************* objectSetMapValue : Map to Object (end) *************************************/
/**
* @author 최정우
* @since 2020.04.22
*
* public objectSetValue에서만 호출 가능
*
*/
public static void objectHTMLFilter (Object targetObject, Class<?> targetObjectClass) {
//빈값 체크
if (targetObject == null || targetObjectClass == null) {
return;
}
//vo객체의 Field목록 얻기
Field[] valueObjectFields = targetObjectClass.getDeclaredFields();
Field test = null;
//Field 목록이 있을 때 -> 값 세팅하러 가기
if (valueObjectFields != null && valueObjectFields.length > 0) {
for (int i = 0; i < valueObjectFields.length; i++) {
//현재 vo객체 정보를 target객체에 값 세팅하기
//Field 접근자 타입이 private라도 필드 정보에 접근가능하게 해줌
valueObjectFields[i].setAccessible(true);
try {
//System.out.println("valueObjectFields["+i+"].getType().getName() : " + valueObjectFields[i].getType().getName() + ", name : " + valueObjectFields[i].getName() + ", value : " + valueObjectFields[i].get(targetObject) + ", getGenericType().getTypeName() : " + valueObjectFields[i].getGenericType().getTypeName());
/* 목표 객체의 변수필드가 상수(final)이 아니고, 데이터 타입이 같고 때 -> 같은 클래스의 변수필드 인지 확인 */
if (Modifier.isFinal(valueObjectFields[i].getModifiers()) == false) {
if (valueObjectFields[i].getGenericType().getTypeName().equals("java.lang.String")) {
String value = StringUtil.toString(valueObjectFields[i].get(targetObject));
if (StringUtil.isEmpty(value) == false) {
//같은 클래스일 때 -> 값 세팅
valueObjectFields[i].set(targetObject, StringUtil.cleanXSS(value));
} else {
continue;
}
} else if (valueObjectFields[i].getGenericType().getTypeName().contains("List")) {
List<Object> list = (List<Object>) valueObjectFields[i].get(targetObject);
if (list != null) {
for (int j = 0; j < list.size(); j++) {
if (list.get(j) == null) {
continue;
} else if (list.get(j).getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (list.get(j).getClass().getTypeName().equals("java.lang.String")) {
String value = StringUtil.toString(list.get(j));
list.set(j, StringUtil.cleanXSS(value));
} else if (list.get(j).getClass().getTypeName().contains("java.lang")) {
continue;
} else if (list.get(j).getClass().getTypeName().contains("List")
|| list.get(j).getClass().getTypeName().contains("[]")
|| list.get(j).getClass().getTypeName().contains("Map")
|| list.get(j).getClass().getTypeName().contains("Set")
|| list.get(j).getClass().getTypeName().contains("Collection")
|| list.get(j).getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(list.get(j), list.get(j).getClass());
} else {
continue;
}
}
}
} else if (valueObjectFields[i].getGenericType().getTypeName().contains("[]")) {
Object[] arr = (Object[]) valueObjectFields[i].get(targetObject);
if (arr != null) {
for (int j = 0; j < arr.length; j++) {
if (arr[j] == null) {
continue;
} else if (arr[j].getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (arr[j].getClass().getTypeName().equals("java.lang.String")) {
String value = StringUtil.toString(arr[j]);
arr[j] = StringUtil.cleanXSS(value);
} else if (arr[j].getClass().getTypeName().contains("java.lang")) {
continue;
} else if (arr[j].getClass().getTypeName().contains("List")
|| arr[j].getClass().getTypeName().contains("[]")
|| arr[j].getClass().getTypeName().contains("Map")
|| arr[j].getClass().getTypeName().contains("Set")
|| arr[j].getClass().getTypeName().contains("Collection")
|| arr[j].getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(arr[j], arr[j].getClass());
} else {
continue;
}
}
}
} else if (valueObjectFields[i].getGenericType().getTypeName().contains("Map")) {
if (valueObjectFields[i].getGenericType().getTypeName().contains("Map$Entry")
|| valueObjectFields[i].getGenericType().getTypeName().contains("Map$Node")) {
Map.Entry<Object, Object> entry = (Map.Entry<Object, Object>) valueObjectFields[i].get(targetObject);
if (entry != null) {
if (entry.getValue() == null) {
continue;
} else if (entry.getValue().getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (entry.getValue().getClass().getTypeName().equals("java.lang.String")) {
String value = StringUtil.toString(entry.getValue());
entry.setValue(StringUtil.cleanXSS(value));
} else if (entry.getValue().getClass().getTypeName().contains("java.lang")) {
continue;
} else if (entry.getValue().getClass().getTypeName().contains("List")
|| entry.getValue().getClass().getTypeName().contains("[]")
|| entry.getValue().getClass().getTypeName().contains("Map")
|| entry.getValue().getClass().getTypeName().contains("Set")
|| entry.getValue().getClass().getTypeName().contains("Collection")
|| entry.getValue().getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(entry.getValue(), entry.getValue().getClass());
} else {
continue;
}
}
} else {
Map<Object, Object> map = (Map<Object, Object>) valueObjectFields[i].get(targetObject);
if (map != null) {
for (Object key : map.keySet()) {
if (map.get(key) == null) {
continue;
} else if (map.get(key).getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (map.get(key).getClass().getTypeName().equals("java.lang.String")) {
String value = StringUtil.toString(map.get(key));
map.put(key, StringUtil.cleanXSS(value));
} else if (map.get(key).getClass().getTypeName().contains("java.lang")) {
continue;
} else if (map.get(key).getClass().getTypeName().contains("List")
|| map.get(key).getClass().getTypeName().contains("[]")
|| map.get(key).getClass().getTypeName().contains("Map")
|| map.get(key).getClass().getTypeName().contains("Set")
|| map.get(key).getClass().getTypeName().contains("Collection")
|| map.get(key).getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(map.get(key), map.get(key).getClass());
} else {
continue;
}
}
}
}
} else if (valueObjectFields[i].getGenericType().getTypeName().contains("Set")) {
Set<Object> set = (Set<Object>) valueObjectFields[i].get(targetObject);
if (set != null) {
for (Object obj : set) {
if (obj == null) {
continue;
} else if (obj.getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (obj.getClass().getTypeName().equals("java.lang.String")) {
set.remove(obj);
String value = StringUtil.toString(obj);
set.add(StringUtil.cleanXSS(value));
} else if (obj.getClass().getTypeName().contains("java.lang")) {
continue;
} else if (obj.getClass().getTypeName().contains("List")
|| obj.getClass().getTypeName().contains("[]")
|| obj.getClass().getTypeName().contains("Map")
|| obj.getClass().getTypeName().contains("Set")
|| obj.getClass().getTypeName().contains("Collection")
|| obj.getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(obj, obj.getClass());
} else {
continue;
}
}
}
} else if (valueObjectFields[i].getGenericType().getTypeName().contains("java.util.Collection")) {
Collection<Object> collection = (Collection<Object>) valueObjectFields[i].get(targetObject);
if (collection != null) {
for (Object obj : collection) {
if (obj == null) {
continue;
} else if (obj.getClass().getTypeName().indexOf(".") < 0) {
continue;
} else if (obj.getClass().getTypeName().equals("java.lang.String")) {
collection.remove(obj);
String value = StringUtil.toString(obj);
collection.add(StringUtil.cleanXSS(value));
} else if (obj.getClass().getTypeName().contains("java.lang")) {
continue;
} else if (obj.getClass().getTypeName().contains("List")
|| obj.getClass().getTypeName().contains("[]")
|| obj.getClass().getTypeName().contains("Map")
|| obj.getClass().getTypeName().contains("Set")
|| obj.getClass().getTypeName().contains("Collection")
|| obj.getClass().getTypeName().contains("kr.co.sppartners")) {
objectHTMLFilter(obj, obj.getClass());
} else {
continue;
}
}
}
}
else {
continue;
}
} else {
continue;
}
} catch (Exception e) {
e.printStackTrace();
//System.out.println("valueObjectFields[i].getGenericType().getTypeName() 에러발생 : " + valueObjectFields[i].getGenericType().getTypeName());
}
}
}
//System.out.println("targetObjectClass.getSimpleName() : " + targetObjectClass.getSimpleName());
if (targetObjectClass.getSimpleName() != "CommonVO" && targetObjectClass.getSuperclass() != null) {
try {
//목표객체의 상위클래스에서 변수 찾아서 값넣어주기 위해 재귀호출함
objectHTMLFilter(targetObject, targetObjectClass.getSuperclass());
} catch (Exception e1) {
e1.printStackTrace();
}
} else {
return;
}
}
/**
* @author 최정우
* @since 2019.12.09
*
* 데이터 셋 목록 Convert LinkedHashMap<String, Object> to List<String>
*/
public static List<List<String>> rowDataMapToList (List<LinkedHashMap<String, Object>> rowMapData) throws Exception {
List<List<String>> rowData = new ArrayList<List<String>>();
for (int i = 0; i < rowMapData.size(); i++) {
List<String> row = new ArrayList<String>();
LinkedHashMap<String, Object> mapdata = rowMapData.get(i);
for( String key : mapdata.keySet() ){
if (mapdata.get(key) == null) {
row.add(null);//null값 대체
} else {
row.add(mapdata.get(key).toString());
}
}
rowData.add(row);
}
return rowData;
}
public static int getRandomInt (int min, int max) {
return (int) Math.round(Math.random() * (max - min));// + min;
}
/**
* 작성일 : 210316 작성자 : 최정우
*
* Exception -> String
*
* @param e : Exception
*/
public static String exceptionToString(Exception e) {
StringWriter errors = new StringWriter();
e.printStackTrace(new PrintWriter(errors));
return "[Error] " + errors.toString();
}
}