HD

오라클 테이블 구조 복사 & 데이터 복사

hunecenter — Mon, 19 May 2025 11:38:08 +0900

테이블 구조 및 데이터 복사하기

CREATE TABLE 신규테이블명 AS SELECT * FROM 복사할테이블명 [WHERE]

테이블 구조만 복사하기

CREATE TABLE 신규테이블명 AS SELECT * FROM 복사할테이블명 WHERE 1=2

테이블이 존재할경우, 데이터만 복사하기(구조가 같은경우)

INSERT INTO 복사대상테이블명 SELECT * FROM 원본테이블명 [WHERE]

테이블이 존재할경우, 데이터만 복사하기(구조가 다를경우)

INSERT INTO 복사대상테이블명 (COL1, COL2) SELECT COL1, COL2 FROM 원본테이블명 [WHERE]

로그인 세션 시간 표시

hunecenter — Tue, 13 Dec 2022 10:05:40 +0900

은행권이나 홈텍스 등에서 많이 볼수있는 화면이다. 아래사진과 같이 고객의 요청으로 해당 시간을 표시되고 시간이 다되면 로그아웃이 되는 기능을 구현해보았다. (연장기능은 제외)

[작업]

추가적으로 작업할 소스는 3개이다.

- filter Java 생성

사용자가 로그인을 할때 web.xml의 session-conifg에 지정된 시간 cookie를 생성

- web.xml session-config(session 시간), 생성한 filter 등록

- jsp로 사용자 화면구성

script로 cookie를 가져와 사용자 화면에 세션 시간표시

우선 servlet filter를 모르고 작업하는 사람들도 있을수 있기에 한번 읽어보고 이해하고 작업하면 좋겠다.

https://atoz-develop.tistory.com/entry/Servlet-Filter-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0

Servlet Filter 사용하기

Servlet Filter 사용하기 Filter의 개념과 사용하는 이유 필터는 서블릿 실행 전, 후에 어떤 작업을 하고자 할때 사용한다. 예를 들어 클라이언트가 보낸 데이터의 암호를 해제한다거나, 서블릿이 실

atoz-develop.tistory.com

[JAVA]

package module.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

/**
 * 
 * @Class Name  : SessionFilter.java
 * @Description :  Session time Filter
 * @Modification Information
 *
 *    수정일              수정자         수정내용
 *    -------  -------  -------------------
 *    2022.12.13.  HD    최초생성
 *
 * @author HD
 * @since 2022.12.13.
 * @version 1.0
 * @see javax.servlet.Filter
 */

public class SessionFilter implements Filter {
	
	/** org.slf4j.Logger */
	private static final Logger LOG = LoggerFactory.getLogger( SessionFilter.class );
	
	/** org.springframework.web.context.WebApplicationContext */
	private WebApplicationContext context;
	
	/**
	 * 필터 초기화
	 * @param filterConfig javax.servlet.FilterConfig
	 * @throws ServletException javax.servlet.ServletException
	 */
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		context = WebApplicationContextUtils.getWebApplicationContext( filterConfig.getServletContext() );
	}

	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		HttpServletResponse httpResponse = (HttpServletResponse) response;
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        long serverTime = System.currentTimeMillis();
        long sessionExpireTime = serverTime + httpRequest.getSession().getMaxInactiveInterval() * 1000;
        Cookie cookie = new Cookie("egovLatestServerTime", "" + serverTime);
        //cookie.setSecure(true);
        cookie.setPath("/");
        httpResponse.addCookie(cookie);
        cookie = new Cookie("egovExpireSessionTime", "" + sessionExpireTime);
        cookie.setPath("/");
        
        httpResponse.addCookie(cookie);

        chain.doFilter(request, response);
	}
	
	/**
	 * 필터 종료 메소드
	 */
	@Override
	public void destroy() {
		/*
		 * EMPTY METHOD
		 */
	}


}

 <!-- 2022-12-13 sessionFilter 추가 -->
 <filter>
 	<filter-name>SessionFilter</filter-name>
    <filter-class>module.filter.SessionFilter</filter-class> (패키지명+클래스파일명)
 </filter>
 <filter-mapping>
 	<filter-name>SessionFilter</filter-name>
    <url-pattern>*</url-pattern>
 </filter-mapping>
 
 <!--session 시간 30분 -->
 <session-config>
 	<session-timeout>30</session-timeout>
 </session-config>

[html & script]

<script>
function getCookie(cname) {
	 	  var name = cname + "=";
	 	  var decodedCookie = decodeURIComponent(document.cookie);
	 	  var ca = decodedCookie.split(';');
	 	  for(var i = 0; i <ca.length; i++) {
	 	    var c = ca[i];
	 	    while (c.charAt(0) == ' ') {
	 	      c = c.substring(1);
	 	    }
	 	    if (c.indexOf(name) == 0) {
	 	      return c.substring(name.length, c.length);
	 	    }
	 	  }
	 	  return "";
	 	}
	  
	  	function pad(n, width) {
	  	  n = n + '';
	  	  return n.length >= width ? n : new Array(width - n.length + 1).join('0') + n;
	  	}
	  
		var objLeftTime;
		var objClickInfo;
		var latestTime;
		var expireTime;
		var timeInterval = 1000; // 1초 간격 호출
		var firstLocalTime = 0;
		var elapsedLocalTime = 0;
		var stateExpiredTime = false;
		var logoutUrl = "로그아웃 URL";
		var timer;
	  
		function init() {
			objLeftTime = document.getElementById("leftTimeInfo");
			
			if (objLeftTime == null) {
				console.log("'leftTimeInfo' ID is not exist!");
				return;
			}
			//objClickInfo = document.getElementById("clickInfo");
			//console.log(objLeftTime.textContent);

			latestTime = getCookie("egovLatestServerTime");
			expireTime = getCookie("egovExpireSessionTime");
			//console.log("latestServerTime = "+latestTime);
			//console.log("expireSessionTime = "+expireTime);
			
			elapsedTime = 0;
			firstLocalTime = (new Date()).getTime();
			showRemaining();
			
			timer = setInterval(showRemaining, timeInterval); // 1초 간격 호출
		}

		function showRemaining() {
			elapsedLocalTime = (new Date()).getTime() - firstLocalTime;
			
			var timeRemaining = expireTime - latestTime - elapsedLocalTime;
			if ( timeRemaining < timeInterval ) {
				clearInterval(timer);
				objLeftTime.innerHTML = "00:00:00";
				//objClickInfo.text = '시간만료'; //시간만료
				stateExpiredTime = true;
				alert('로그인 세션시간이 만료 되었습니다.');//로그인 세션시간이 만료 되었습니다.
				//$("#logoutForm").submit();
				// reload content main page
				$("#sessionInfo").hide();

				//parent.frames["_content"].location.href = logoutUrl;
				//parent.frames["_content"].location.reload();

				return;
			}
			var timeHour = Math.floor(timeRemaining/1000/60 / 60); 
			var timeMin = Math.floor((timeRemaining/1000/60) % 60);
			var timeSec = Math.floor((timeRemaining/1000) % 60);
			
			objLeftTime.innerHTML = pad(timeHour,2) +":"+ pad(timeMin,2) +":"+ pad(timeSec,2);
			
		}
  </script>
  
  <html>
  	<!-- 시간변경되는부분 -->
  	<span id="leftTimeInfo">00:00:00</span> 
   </html>

[참고]

https://www.egovframe.go.kr/wiki/doku.php?id=egovframework:com:v3.10:sec:login_session_management

egovframework:com:v3.10:sec:login_session_management [eGovFrame]

로그인후 만료시간까지의 남은 시간을 표시한다. 세션에 객체 정보 저장, 취득, 제거의 기능을 갖으며 HttpServletRequest 객체의 HttpSession 정보를 사용하여 처리된다. 유형대상소스설명비고 Filteregovf

www.egovframe.go.kr

FCM(firebase) 연동

hunecenter — Mon, 7 Nov 2022 14:56:25 +0900

-하이브리드 앱 프로젝트중 클라이언트쪽에서 PUSH알림 기능을 요구해 FCM연동을 처음접하게되었다.

-PUSH알림은 사용자가 Q&A를 작성하고 관리자가 답변또는 그해당글을 볼때 발송된다.

-이번 프로젝트 하이브리드 앱에 FMC연동 프로세스는 이렇다.

[프로세스]

순서	프로세스
1	사용자가 앱을 실행
2	앱실행시 백단에 만들어 놓은 api url호출 UUID, firebaseToken을 post로 값 전달
3	UUID, firebaseToken를 DB에 저장
4	UUID DB값을 조회해 로그인
5	로그인 사용자가 Q&A글을 작성
6	관리자가 답글을 달거나 해당 글을 보면 사용자한테 알림(PUSH) firebaseToken값을 DB로 조회 FCM API호출
7	핸드폰에서 PUSH 메시지를 클릭했을때 해당앱이 켜짐

- 해당 소스 내용을 참고해서 커스텀 및 Controller를 작성하면 될거같다!

[model]

public class FCMMessage
{
  private boolean validate_only;
  private Message message;

  public static FCMMessageBuilder builder()
  {
    return new FCMMessageBuilder(); } 
  public FCMMessage(boolean validate_only, Message message) { this.validate_only = validate_only; this.message = message; } 
  public boolean isValidate_only() { return this.validate_only; } 
  public Message getMessage() { return this.message; }


  public static class FCMMessageBuilder
  {
    private boolean validate_only;
    private FCMMessage.Message message;

    public FCMMessageBuilder validate_only(boolean validate_only)
    {
      this.validate_only = validate_only; return this; } 
    public FCMMessageBuilder message(FCMMessage.Message message) { this.message = message; return this; } 
    public FCMMessage build() { return new FCMMessage(this.validate_only, this.message); } 
    public String toString() { return "FCMMessage.FCMMessageBuilder(validate_only=" + this.validate_only + ", message=" + this.message + ")"; } 
  }
  public static class Message {
    private FCMMessage.Notification notification;
    private String token; // 특정 device에 알림을 보내기위해 사용

    public static MessageBuilder builder() { return new MessageBuilder(); } 
    public Message(FCMMessage.Notification notification, String token) { this.notification = notification; this.token = token; } 
    public FCMMessage.Notification getNotification() { return this.notification; } 
    public String getToken() { return this.token; }


    public static class MessageBuilder
    {
      private FCMMessage.Notification notification;
      private String token;

      public MessageBuilder notification(FCMMessage.Notification notification)
      {
        this.notification = notification; return this; } 
      public MessageBuilder token(String token) { this.token = token; return this; } 
      public FCMMessage.Message build() { return new FCMMessage.Message(this.notification, this.token); } 
      public String toString() { return "FCMMessage.Message.MessageBuilder(notification=" + this.notification + ", token=" + this.token + ")"; }  } 
  }
  
  /**
   * // 모든 mobile os를 아우를수 있는 Notification
   * @author JHY
   *
   */
  public static class Notification {  
	private String title;
    private String body;
    private String image;

    public static NotificationBuilder builder() { return new NotificationBuilder(); } 
    public Notification(String title, String body, String image) { this.title = title; this.body = body; this.image = image; } 
    public String getTitle() { return this.title; } 
    public String getBody() { return this.body; } 
    public String getImage() { return this.image; }


    public static class NotificationBuilder
    {
      private String title;
      private String body;
      private String image;

      public NotificationBuilder title(String title)
      {
        this.title = title; return this; } 
      public NotificationBuilder body(String body) { this.body = body; return this; } 
      public NotificationBuilder image(String image) { this.image = image; return this; } 
      public FCMMessage.Notification build() { return new FCMMessage.Notification(this.title, this.body, this.image); } 
      public String toString() { return "FCMMessage.Notification.NotificationBuilder(title=" + this.title + ", body=" + this.body + ", image=" + this.image + ")"; }

    }
  }
}

[Service]

public interface FirebaseService {

	/** 결과_성공 */
	public static final String RESULT_SUCCESS = "SUCCESS";
	
	/** 사용자 code 없음 */
	public static final String NO_USER_CODE = "NO_USER_CODE";
	
	/** firebase 토큰 없음 */
	public static final String NO_FIREBASE_TOKEN= "NO_FIREBASE_TOKEN";
	
	/** 결과_실패  */
	public static final String RESULT_FAIL = "FAIL";
	
	//public final String MESSAGING_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
	public final String MESSAGING_SCOPE = "https://www.googleapis.com/auth/firebase.messaging";
	public final String[] SCOPES = { MESSAGING_SCOPE };
    
    public final String PROJECT_ID = "push-apps-58e3d";
	
    //https://firebase.google.com/docs/cloud-messaging/migrate-v1 참고
    public final String API_URL = "https://fcm.googleapis.com/v1/projects/"+PROJECT_ID+"/messages:send";
	
	//토큰 취득
	public abstract String getAccessToken() throws IOException;
	
	//메시지 발송
	public abstract void sendMessageTo(String userCode, String title, String body, String link) throws IOException;
	
	// 파라미터를 FCM이 요구하는 body 형태로 만들어준다.
	public abstract String makeMessage(String targetToken, String title, String body, String link) throws JsonProcessingException;
	
	//앱 실행시 userCode, firebaseToken값 체크
	public abstract JsonObject firebaseToeknChk(MobilePwd mobilePwd);
	
}

[ServiceImpl]

@Service("FirebaseService")
public class FirebaseServiceImpl implements  FirebaseService{
	
	private static final Logger LOG = LoggerFactory.getLogger( FirebaseServiceImpl.class );
	
	/**
	 * 토큰 취득
	 * <br>
	 * doc : https://firebase.google.com/docs/cloud-messaging/auth-server
	 */
	@Override
	public String getAccessToken() throws IOException {
    	//doc URL 참고
		 String firebaseConfigPath = "../firebase/test.json";
		
		 /*InputStream resource = new FileInputStream(firebaseConfigPath);
		 try ( BufferedReader reader = new BufferedReader(
		   new InputStreamReader(resource)) ) {
		     String readerStr = reader.lines()
		       .collect(Collectors.joining("\n"));
		     System.out.println("파일 읽는지 확인 : " + readerStr);
		 }*/
		 
	     GoogleCredentials googleCredentials = GoogleCredentials
	             .fromStream(new FileInputStream(firebaseConfigPath))
	             .createScoped(Arrays.asList(SCOPES));
	     googleCredentials.refresh();
	     return googleCredentials.getAccessToken().getTokenValue();
	}

	/**
	 * PUSH 메시지 발송
	 * <br>
	 * doc : https://firebase.google.com/docs/cloud-messaging/auth-server
	 */
	@Override
	public void sendMessageTo(String userCode, String title, String body, String link) throws IOException {
		if(!"".equals(ReplaceNull(userCode))) {
			UserInfo userInfo = userDao.getUserInfo(userCode);//회원조회
			if(userInfo!=null) {
				if(!"".equals(ReplaceNull(userInfo.getUserPin()))) {
					String message = makeMessage(userInfo.getUserPin(), title, body, link);

					OkHttpClient client = new OkHttpClient();
			        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"),message);
			        Request request = new Request.Builder()
			                .url(API_URL)
			                .post(requestBody)
			                .addHeader(HttpHeaders.AUTHORIZATION, "Bearer " + getAccessToken())
			                .addHeader(HttpHeaders.CONTENT_TYPE, "application/json; UTF-8")
			                .build();

			        Response response = client.newCall(request).execute();
			        /**
			         * success message
			         * <br>
			         * {
			  		 *	 "name": "projects/${projectid}/messages/0:1666597000351490%e54c69bfe54c69bf"
					 * }

			         */
			        LOG.info("result message : "+response.body().string());
				}
				
			}
			
		}
		
	}

	/**
	 * 메시지 생성
	 * <br>
	 * doc : https://firebase.google.com/docs/cloud-messaging/send-message#java_3
	 * <br>
	 * json 형태
	 * <br>
	 * {
	 *    "message":{
	 *       "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
	 *       "notification":{
	 *         "body":"This is an FCM notification message!",
	 *         "title":"FCM Message"
	 *       }
	 *    }
	 * }
	 */
	@Override
	public String makeMessage(String targetToken, String title, String body, String link) throws JsonProcessingException {
		// object를 json 형태 String 으로 반환
		ObjectMapper objectMapper = new ObjectMapper();
		
		FCMMessage fcmMessage = FCMMessage.builder()
                .message(FCMMessage.Message.builder()
                        .token(targetToken)
                        .notification(FCMMessage.Notification.builder()
                                .title(title)
                                .body(body)
                                .image(null)
                                .build()
                        )
                        .build()
                )
                .validate_only(false)
                .build();
		
		LOG.info("fcmMessage json : "+objectMapper.writeValueAsString(fcmMessage));
		
        return objectMapper.writeValueAsString(fcmMessage);
	}

	/**
	 * 
	 */
	@Override
	public JsonObject firebaseToeknChk(String uuid, String firebaseToken) {
		//회원 UUID, FIREBASE_TOKEN등록
	}
}

[참고]

https://firebase.google.com/docs/cloud-messaging

Firebase 클라우드 메시징

Firebase 클라우드 메시징(FCM)은 비용 없이 안정적으로 메시지를 보낼 수 있는 플랫폼 간 메시징 솔루션입니다.

firebase.google.com

https://sol-devlog.tistory.com/11

[SpringBoot] FCM을 통해 Push알림 보내보기

( + 진행 당시, 기능 구현에 집중하다보니 전체적인 설계나 코드가 클린하지 못할 수 있으니 이 부분은 리팩토링 하면서 적용하시면 좋을 것 같아요! :) ) 현재 참여하고 있는 IT연합 동아리 YAPP에

sol-devlog.tistory.com

Java @Scheduled Cron 표현식

hunecenter — Tue, 4 Oct 2022 14:40:05 +0900

매번 프로젝트 스케쥴 걸때마다 찾아다녀서 기억 할겸 기록!!

Cron 표현식의 각 시간단위는 아래의 범위로 구성 (Cron 표현식 6~7자리)

초	분	시	일	월	요일	년도
0 ~ 59	0 ~ 59	0 ~ 23	1 ~ 31	1 ~ 12	0 ~ 6	생략가능

@scheduled 옵션

옵션	내용
fixedDelay	이전 작업이 종료된 후 설정 시간만큼 기다린 후에 시작한다. (밀리세컨드) @Scheduled(fixedDelay = 1000)
fixedRate	이전 작업이 종료되지 않아도 설정된 시간마다 시작한다. (밀리세컨드) @Scheduled(fixedRate = 1000)
initialDelay	작업 시작 시, 설정된 시간만큼 기다린 후 시작한다. (밀리세컨드) @Scheduled(fixedRate = 1000, initialDelay = 2000)
cron	원하는 시간대를 설정하여 작업을 실행한다. @Scheduled(cron = "* * * * * *") (초(0-59), 분(0-59), 시간(0-23), 일(1-31), 월(1-12), 요일(1-7, 1:일, 7:토))
zone	시간대를 설정 한다. 미설정 시 로컬 시간대가 적용된다. *@Scheduled(cron = " * * * * ", zone = "Asia/Seoul")*

Cron 표현식 특수문자

* : 모든 값(매시, 매일, 매주처럼 사용한다.)
? : 특정 값이 아닌 어떤 값이든 상관 없음
- : 범위를 지정할 때
, : 여러 값을 지정할 때
/ : 증분값, 즉 초기값과 증가치를 설정할 때
L : 지정할 수 있는 범위의 마지막 값 표시
W : 가장 가까운 평일(weekday)을 설정할 때
# : N번 째 특정 요일을 설정할 때

Cron 표현식 예시

//매 10분마다
@Scheduled( cron = "0 0/10 * * * *")

//매 3시간마다
@Scheduled( cron = "0 0 0/3 * * *")

//2018년도 매일 14시 30분마다
@Scheduled( cron = "0 30 14 * * * 2018")

//매일 10시 ~ 19시 사이에 10분 간격으로
@Scheduled( cron = "0 0/10 10-19 * * *")

//매일 10시와 19시에만 10분 간격으로
@Scheduled( cron = "0 0/10 10,19 * * *")

//매달 25일 01시 30분에
@Scheduled( cron = "0 30 1 25 * *")

//매주 월, 금요일 10시와 19시 사이 10분마다
@Scheduled( cron = "0 10 10-19 ? * MON,FRI")

//매달 마지막날 15시 30분
@Scheduled( cron = "0 30 15 L * *")

//2021~2022년 매월의 마지막 토요일 오후 1시 20분
@Scheduled( cron = "0 20 13 ? * 6L 2021-2022")

//매 10분마다
@Scheduled( cron = "0 0/10 * * * *")

//매 3시간마다
@Scheduled( cron = "0 0 0/3 * * *")

//2022년도 매일 14시 30분마다
@Scheduled( cron = "0 30 14 * * * 2022")

//매일 10시 ~ 19시 사이에 10분 간격으로
@Scheduled( cron = "0 0/10 10-19 * * *")

//매일 10시와 19시에만 10분 간격으로
@Scheduled( cron = "0 0/10 10,19 * * *")

//매달 25일 01시 30분에
@Scheduled( cron = "0 30 1 25 * *")

//매주 월, 금요일 10시와 19시 사이 10분마다
@Scheduled( cron = "0 10 10-19 ? * MON,FRI")

//매달 마지막날 15시 30분
@Scheduled( cron = "0 30 15 L * *")

//2021~2022년 매월의 마지막 토요일 오후 1시 20분
@Scheduled( cron = "0 20 13 ? * 6L 2021-2022")

JAVA 사용 예시

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * @Class Name  : SchdulService.java
 * @Description :  
 * @Modification Information
 *
 *    수정일              수정자         수정내용
 *    -------  -------  -------------------
 *    2022. 10. 4.	HD    	최초생성
 *
 * @author HD
 * @since 2022. 10. 4.
 * @version 1.0
 * @see
 */
@Component
public class SchdulService {
 
	@Scheduled( cron = "0 */1 * * * ?" ) //1분에 한번(테스트용)
	public void startSchdulService(){
		System.out.println("1분마다 스케쥴 실행");
	}
}

참고링크

https://en.wikipedia.org/wiki/Cron#CRON_expression

cron - Wikipedia

From Wikipedia, the free encyclopedia Jump to navigation Jump to search Job scheduler for Unix-like operating systems The cron command-line utility is a job scheduler on Unix-like operating systems. Users who set up and maintain software environments use c

en.wikipedia.org

https://sun-p.tistory.com/115

98DAY / 스프링 스케쥴러 CRON식

스프링 스케쥴러 https://spring.io/guides/gs/scheduling-tasks/ CRON 크론 표현식 초 | 분 | 시 | 일 | 월 | 요일 | 연도 0~59 | 0~59 | 0~23 | 1~31 | 1~12 | 0~6 | 생략가능 요일 : 0 (일..

sun-p.tistory.com

http://www.cronmaker.com/;jsessionid=node0e22c4uy0l2pwjt8qafmy2wl4508784.node0?0

(cronmaker Quartz cron방식으로 생성 테스트)

CronMaker

www.cronmaker.com

Tomcat Server.xml 암호화 (feat.AES)

hunecenter — Thu, 23 Jun 2022 10:58:39 +0900

프로젝트 중에 Server.xml DB Resource 부분에 url, id, password 암호화를 할수없냐는 문의가 들어와서 찾아 보고 적용을 해보았다.

암호화하는 역할을 하는 DataSourceFactory를 가지고 참조해 소스를 수정 및 추가를 하였다.

작업한 소스는 총2개이다 Encryptor.java, EncryptedDataSourceFactory.java

※EncryptedDataSourceFactory의 full path 기억하기

[Encryptor.java]

package secured;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;

public class Encryptor {

    private static final String ALGORITHM = "AES";
	
    private static final String defaultSecretKey = "SecretKeyTest";//AES secretKey

    private Key secretKeySpec;

    public Encryptor() throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
            UnsupportedEncodingException {
        this(null);
    }

    public Encryptor(String secretKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
            UnsupportedEncodingException {
        this.secretKeySpec = generateKey(secretKey);
    }

    public String encrypt(String plainText) throws InvalidKeyException, NoSuchAlgorithmException,
            NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        byte[] encrypted = cipher.doFinal(plainText.getBytes("UTF-8"));
        return asHexString(encrypted);
    }

    public String decrypt(String encryptedString) throws InvalidKeyException, IllegalBlockSizeException,
            BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] original = cipher.doFinal(toByteArray(encryptedString));
        return new String(original);
    }

    private Key generateKey(String secretKey) throws UnsupportedEncodingException, NoSuchAlgorithmException {
        if (secretKey == null) {
            secretKey = defaultSecretKey;
        }
        byte[] key = (secretKey).getBytes("UTF-8");
        MessageDigest sha = MessageDigest.getInstance("SHA-1");
        key = sha.digest(key);
        key = Arrays.copyOf(key, 16); // use only the first 128 bit

        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        kgen.init(128); // 192 and 256 bits may not be available

        return new SecretKeySpec(key, ALGORITHM);
    }

    private final String asHexString(byte buf[]) {
        StringBuffer strbuf = new StringBuffer(buf.length * 2);
        int i;
        for (i = 0; i < buf.length; i++) {
            if (((int) buf[i] & 0xff) < 0x10) {
                strbuf.append("0");
            }
            strbuf.append(Long.toString((int) buf[i] & 0xff, 16));
        }
        return strbuf.toString();
    }

    private final byte[] toByteArray(String hexString) {
        int arrLength = hexString.length() >> 1;
        byte buf[] = new byte[arrLength];
        for (int ii = 0; ii < arrLength; ii++) {
            int index = ii << 1;
            String l_digit = hexString.substring(index, index + 2);
            buf[ii] = (byte) Integer.parseInt(l_digit, 16);
        }
        return buf;
    }

    public static void main(String[] args) throws Exception {
    	Encryptor aes = new Encryptor(defaultSecretKey);
    	String url ="jdbc:mysql://127.0.0.1:3306/testDb?characterEncoding=UTF-8";
    	System.out.println("url:" + aes.encrypt(url));
    	String testid = "test";
    	System.out.println("Id:" + aes.encrypt(testid));
    	String testpassword = "test";
    	System.out.println("Pw:" + aes.encrypt(testpassword));
    }

}

[EncryptedDataSourceFactory.java]

package secured;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.sql.SQLException;
import java.util.Properties;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.naming.Context;
import javax.sql.DataSource;

import org.apache.tomcat.jdbc.pool.DataSourceFactory;
import org.apache.tomcat.jdbc.pool.PoolConfiguration;
import org.apache.tomcat.jdbc.pool.XADataSource;

public class EncryptedDataSourceFactory extends DataSourceFactory {


    private Encryptor encryptor = null;

    public EncryptedDataSourceFactory() {
        try {
            encryptor = new Encryptor(); // If you've used your own secret key, pass it in...
        } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException | UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public DataSource createDataSource(Properties properties, Context context, boolean XA) throws InvalidKeyException,
            IllegalBlockSizeException, BadPaddingException, SQLException, NoSuchAlgorithmException,
            NoSuchPaddingException {
        // Here we decrypt our password.
        PoolConfiguration poolProperties = EncryptedDataSourceFactory.parsePoolProperties(properties);
        poolProperties.setUrl(encryptor.decrypt(poolProperties.getUrl())); //dbConUrl 복호화
        poolProperties.setUsername(encryptor.decrypt(poolProperties.getUsername())); //username복호화
        poolProperties.setPassword(encryptor.decrypt(poolProperties.getPassword())); //password복호화
        /*
        setValidationQuery Option
        SELECT 1(mysql), SELECT 1 FROM DUAL(oracle), SELECT 1(mssql) 
        */
        poolProperties.setValidationQuery("SELECT 1");
        poolProperties.setTestWhileIdle(true);
        poolProperties.setTimeBetweenEvictionRunsMillis(720000);//2시간 단위로 SELECT 1 검증
        
        // The rest of the code is copied from Tomcat's DataSourceFactory.
        if (poolProperties.getDataSourceJNDI() != null && poolProperties.getDataSource() == null) {
            performJNDILookup(context, poolProperties);
        }
        org.apache.tomcat.jdbc.pool.DataSource dataSource = XA ? new XADataSource(poolProperties)
                : new org.apache.tomcat.jdbc.pool.DataSource(poolProperties);
        dataSource.createPool();

        return dataSource;
    }

}

[Encryptor.java bulid]

server.xml에 암호화한 값들을 넣어주기위해 Encryptor.java를 먼저 컴파일해서 값을 확인해본다.

[jar 추출]

(순서) - Export -> java에 JAR file -> JAR file에 경로와 jar파일명 설정후 Finish (하단 이미지 참조)

012

[Server.xml 설정]

Resource 부분에 factory="com.github.tomcatEncryptModule.EncryptedDataSourceFactory"를 추가해준다.

<Resource auth="Container" 
      		factory="com.github.tomcatEncryptModule.EncryptedDataSourceFactory" #여기가 중요
			driverClassName="com.mysql.jdbc.Driver"
			maxActive="50" 
			maxIdle="10" 
			maxWait="-1" 
			name="jdbc/testDB" 
			password="암호화값" 
			type="javax.sql.DataSource" 
			url="암호화값" 
			username="암호화값"/>

서버 재기동후 정상으로 작동되는지 확인!!

[적용후 개인생각]

만약 이걸 각 프로젝트마다 defaultSecretKey가 바뀐다 생각을 하면 소스 수정후 jar로 묶는 작업이 번거로울수 있다보니 해당 지정된 properties파일을 생성해서 properties에 defaultSecretKey관리 변수를 추가후 관리 해주는 방안도 있을거 같다.

//예시
//AES secretKey
private static final String defaultSecretKey = properties.getProperty("SecretKey");

[jar 파일]

tomcatEncryptModule-0.0.1.jar

0.13MB

[git url]

https://github.com/hunecenter94/tomcat-jdbc-encrypt-module

GitHub - hunecenter94/tomcat-jdbc-encrypt-module: tomcatEncryptModule (server.xml) Aes Encrypt & Decrypt

tomcatEncryptModule (server.xml) Aes Encrypt & Decrypt - GitHub - hunecenter94/tomcat-jdbc-encrypt-module: tomcatEncryptModule (server.xml) Aes Encrypt & Decrypt

github.com

[참조]

http://www.jdev.it/encrypting-passwords-in-tomcat/

Encrypting passwords in Tomcat – JDev

Apache Tomcat is by far the most popular (open source) web server and Java servlet container. It has been around for a long time and – at the time of writing this post – has reached version 7.0.29. As Apache rightfully claims on its web site, Tomcat p

www.jdev.it

https://jar-download.com/artifacts/org.apache.tomcat/tomcat-jdbc/7.0.19/source-code/org/apache/tomcat/jdbc/pool/DataSourceFactory.java

org.apache.tomcat.jdbc.pool.DataSourceFactory Maven / Gradle / Ivy

org.apache.tomcat tomcat-jdbc 7.0.19 compile group: 'org.apache.tomcat', name: 'tomcat-jdbc', version: '7.0.19' //Thanks for using https://jar-download.com libraryDependencies += "org.apache.tomcat" % "tomcat-jdbc" % "7.0.19" //Thanks for using https://jar

jar-download.com

https://tomcat.apache.org/tomcat-8.0-doc/api/org/apache/tomcat/jdbc/pool/DataSourceFactory.html

DataSourceFactory (Apache Tomcat 8.0.53 API Documentation)

JNDI object factory that creates an instance of BasicDataSource that has been configured based on the RefAddr values of the specified Reference, which must match the names and data types of the BasicDataSource bean properties. Properties available for conf

tomcat.apache.org

리눅스 톰켓 한글 깨짐 현상 해결

hunecenter — Tue, 8 Mar 2022 22:43:12 +0900

1. server.xml 확인

2. Tomcat/bin 디렉토리에 setenv.sh shell 파일 작성

JAVA_OPTS="$JAVA_OPTS -Dfile.encoding=\"utf-8\""

위와 같이 작성후 톰켓을 재기동하면 된다!!

[참고]

https://wiper2019.tistory.com/226

[Tomcat] catalina.sh 와 setenv.sh

스프링으로 외부 속성파일의 값을 @value 어노테이션으로 스프링 빈에 주입할 수 있다. 그런데 아무리 뒤져봐도 프로퍼티 파일에 관련된 내용이 없어 도대체 이 값이 어디서 가져오는 건지 찾아

wiper2019.tistory.com

https://bboks.net/380

유튜브 API데이터 가져오기

hunecenter — Fri, 4 Mar 2022 15:39:19 +0900

[리소스 유형]

유튜브 리소스 유형

[작업]

[지원되는 작업]

[소스]

$(document).ready(function() {
	youtube('cnt', 'playListId', 'key');
});

function youtube(cnt, playListId, key){
	$.ajax({
		type: "GET",
		dataType: "jsonp",
		cache: false,
		async: false,
		url : "https://www.googleapis.com/youtube/v3/playlistItems?part=snippet&playlistId="+playListId+"&key="+key,
		success: function(response) {
			if(response.items.length > 0){
				for(var i = 0; i <cnt; i++){
					var youtube = '<li>';
					youtube += "<a target='_blank' href='https://www.youtube.com/watch?v="+response.items[i].snippet.resourceId.videoId+"&list="+response.items[i].snippet.playlistId+"' title='새창 열기'>";
					youtube += '<img src="' + response.items[i].snippet.thumbnails.standard.url + '" alt="유튜브_'+i+'_번째글">';
					youtube += "<p class='desc'>";
					youtube += "<span>";
					youtube += response.items[i].snippet.title;
					youtube += "</span>";
					youtube += "</p>";
					youtube += "</a>";
					youtube += "</li>";
					$("#youtubeSlider").append(youtube); //해당 append 해줄 id 또는 class
				}
			}
		}
	});
}

[youtube 무료 건수]
Queries /일 10,000건
Queries /분 /사용자 180,000건
Queries /분 1,800,000건

[참고]

https://developers.google.com/youtube/v3/docs/playlists/list

Playlists: list | YouTube Data API | Google Developers

Playlists: list API 요청 매개변수와 일치하는 재생목록의 모음을 반환합니다. 예를 들어 인증된 사용자가 보유한 전체 재생목록을 검색하거나, 고유 ID를 통해 하나 또는 여러 개의 재생목록을 검색

developers.google.com

https://brunch.co.kr/@joypinkgom/99

16화 유튜브 API - 12. 할당량 최적화

오늘은 할당량(Quota) 이야기를 해 볼까 한다. 유튜브(Youtube) API - 3.API 살펴보기 글에서 할당량과 최적화의 필요에 대해 간단히 다룬 바 있다. 할당량이란 API 남용을 막고 자원을 관리하기 위해 구

brunch.co.kr

페이스북 무기한 토큰 방법 (다른방법)

hunecenter — Tue, 15 Feb 2022 10:58:50 +0900

https://hune.tistory.com/47?category=808762

facebook 무기한 토큰 만들기2 (feat.2021-08-19)

1. 토큰 생성 2. 토큰 기간 확장 확장된 새 액세스 토큰 복사 3. 무기한 토큰 생성 2번에서 생성한 토큰을 액세스 토큰에 붙여 놓기 filed쪽에 me?fields=access_token 작성후 제출 버튼 클릭 호출된 access_

hune.tistory.com

위 링크의 1번,2번,4번 내용은같다.

3번 작업(수정)

filed쪽에 me?fields=access_token or me?fields=accounts 로 작성후 제출 버튼 클릭(2022-02-15 작성)
하단 사진과 같이 access_token이 무기한 토큰이다.
밑에 access_token을 복사해서 만료일이 (받지 않음) 인지 체크하면 완료!

JAVA 접근장치, 운영체제, 브라우저 확인

hunecenter — Sat, 12 Feb 2022 10:32:52 +0900

고객의 요청에 의해 접근장치, 운영체제, 브라우저를 확인해서 로그를 남겨 달라는 말에 따로 ClientUtil.class로 빼서 구현을 해보았다.

[pom.xml 기입]

<dependency>
	<groupId>com.github.ua-parser</groupId>
    <artifactId>uap-java</artifactId>
    <version>1.4.3</version>
</dependency>

[소스]

package project.client.util;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ua_parser.Client;
import ua_parser.Parser;

/**
 * Client Utility Class
 * @Class Name  : ClientUtil.java
 * @Description :
 * @Modification Information
 *
 *    수정일        수정자        수정내용
 *    -----------  --------  -------------------
 *    2022.02.10.   HD        최초생성
 *
 * @author HD
 * @since 2022.02.10
 * @version 1.0
 */

public class ClientUtil {

    private static final Logger LOG = LoggerFactory.getLogger(ClientUtil.class.getName());
    
    /**
     * <pre>
     * 접근장치를 반환하는 메소드
     * </pre>
     * @param request HttpServletRequest
     * @return 접근장치 문자열
     */
    public static String getAcesEqpmt(HttpServletRequest request) {
        String headerStr = request.getHeader( "User-Agent" ).toUpperCase();
        String acesEqpmt = "PC";
        
        if ( headerStr.contains( "MOBILE" ) || headerStr.contains( "MOBI" ) ) {
            acesEqpmt = "MOBILE";
        }

        return acesEqpmt;
    }
    
    /**
     * <pre>
     * 운영체제를 반환하는 메소드
     * </pre>
     * @param request HttpServletRequest
     * @return 운영체제 문자열
     */
    public static String getOs(HttpServletRequest request) {
        String headerStr = request.getHeader( "User-Agent" );
        String os = "";
        
        try {
            Parser parser = new Parser();
            Client client = parser.parse( headerStr );
            os = client.os.family;
        } catch ( IOException e ) {
            LOG.error("ERROR : ",e.getMessage());
        }
        
        return os;
    }
    
    /**
     * <pre>
     * 브라우저 이름을 반환하는 메소드
     * </pre>
     * @param request HttpServletRequest
     * @return 브라우저 이름 문자열
     */
    public static String getBrowserNm(HttpServletRequest request) {
        String headerStr = request.getHeader( "User-Agent" ).toUpperCase();
        String browser = "";

        if ( headerStr.indexOf("TRIDENT") > -1 || headerStr.indexOf("MSIE") > -1 ) { //IE

            if ( headerStr.indexOf("TRIDENT/7") > -1 ) {
                browser = "IE 11";
            } else if ( headerStr.indexOf("TRIDENT/6") > -1 ) {
                browser = "IE 10";
            } else if ( headerStr.indexOf("TRIDENT/5") > -1 ) {
                browser = "IE 9";
            } else if ( headerStr.indexOf("TRIDENT/4") > -1 ) {
                browser = "IE 8";
            } else if ( headerStr.indexOf("EDG") > -1 || headerStr.indexOf("EDGE") > -1 ) {
                browser = "IE Edge";
            }

        } else if ( headerStr.indexOf("WHALE") > -1 ) { //네이버 WHALE
            browser = "Whale";
        } else if ( headerStr.indexOf("OPERA") > -1 || headerStr.indexOf("OPR") > -1 ) { //오페라
            browser = "Opera";
        } else if ( headerStr.indexOf("FIREFOX") > -1 ) { //파이어폭스
            browser = "Firefox";
        } else if ( headerStr.indexOf("SAFARI") > -1 && headerStr.indexOf("CHROME") == -1 ) { //사파리
            browser = "Safari";
        } else if ( headerStr.indexOf("CHROME") > -1 ) { //크롬
            browser = "Chrome";
        } else {
            browser = "Other";
        }

        //LOG.debug("userAgent 확인 ["+userAgent+"]");
        //LOG.debug("브라우저/버전 확인 ["+browser+"]");

        return browser;
    }
}

[참고]

https://github.com/ua-parser/uap-java

GitHub - ua-parser/uap-java: Java implementation of ua-parser

Java implementation of ua-parser. Contribute to ua-parser/uap-java development by creating an account on GitHub.

github.com

https://velog.io/@ggong/User-agent-%EC%A0%95%ED%99%95%ED%95%98%EA%B2%8C-%ED%95%B4%EC%84%9D%ED%95%98%EA%B8%B0

User-agent 정확하게 해석하기

user agent는 HTTP 요청을 보내는 디바이스와 브라우저 등 사용자 소프트웨어의 식별 정보를 담고 있는 request header의 한 종류이다. 임의로 수정될 수 없는 값이고, 보통 HTTP 요청 에러가 발생했을 때

velog.io

log 파일을 실시간으로 볼때 유용한 TailMe

hunecenter — Thu, 10 Feb 2022 10:53:25 +0900

- 에디터로 매번 보다가 실시간 볼수있는 파일을 찾아서 올려봅니다.

※ 사용법은 *.log 확장자 파일을 넣으면 실시간으로 로그확인이 가능

TailMe.zip

0.88MB