[작성자:] thkmon

        <!– DB –>
        <dependency>
        <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.2</version>
        </dependency>
       
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.0</version>
        </dependency>
       
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
       
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
   
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:config/spring/context-*.xml</param-value>
    </context-param>

<?xml version=“1.0” encoding=“UTF-8”?>
<beans xmlns=“http://www.springframework.org/schema/beans“
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance“
xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd“>
<bean id=“dataSource” class=“org.apache.commons.dbcp.BasicDataSource” destroy-method=“close”>
<property name=“driverClassName” value=“com.mysql.jdbc.Driver”/>
<property name=“url” value=“jdbc:mysql://아이피주소:포트/디비명”/>
<property name=“username” value=“아이디”/>
<property name=“password” value=“비밀번호”/>
</bean>
</beans>

<?xml version=“1.0” encoding=“UTF-8”?>
<beans xmlns=“http://www.springframework.org/schema/beans“
    xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance“
    xmlns:context=“http://www.springframework.org/schema/context“
    xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd“>
    <bean id=“sqlSession” class=“org.mybatis.spring.SqlSessionFactoryBean”>
        <property name=“dataSource” ref=“dataSource” />
        <property name=“mapperLocations” value=“classpath:/mapper/**/*-mapper.xml” />
    </bean>

    <bean id=“sqlSessionTemplate” class=“org.mybatis.spring.SqlSessionTemplate”>
        <constructor-arg index=“0” ref=“sqlSession”/>
    </bean>
</beans>

<?xml version=“1.0” encoding=“UTF-8”?>
<!DOCTYPE mapper PUBLIC “-//mybatis.org//DTD Mapper 3.0//EN” “http://mybatis.org/dtd/mybatis-3-mapper.dtd“>

<mapper namespace=“test”>

    <!– <select id=“selectCount” parameterType=“hashmap” resultType=“hashmap”> –>
    <select id=“selectCount” resultType=“int”>

    <![CDATA[
         SELECT COUNT(*) FROM test

    ]]>

</select>

</mapper>

package com.bb.nddoc.common.dao;

import java.awt.List;
import org.mybatis.spring.SqlSessionTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

public class AbstractDAO {
    private static final Logger logger = LoggerFactory.getLogger(AbstractDAO.class);

    @Autowired
    private SqlSessionTemplate sqlSession;

    protected void printQueryId(String queryId) {
        logger.info(“QueryId : “ + queryId);
    }

    public Object insert(String queryId, Object params) {
        printQueryId(queryId);
        return sqlSession.insert(queryId, params);
    }

    public Object update(String queryId, Object params) {
        printQueryId(queryId);
        return sqlSession.update(queryId, params);
    }

    public Object delete(String queryId, Object params) {
        printQueryId(queryId);
        return sqlSession.delete(queryId, params);
    }

    public Object selectOne(String queryId) {
        printQueryId(queryId);
        return sqlSession.selectOne(queryId);
    }

    public Object selectOne(String queryId, Object params) {
        printQueryId(queryId);
        return sqlSession.selectOne(queryId, params);
    }

    @SuppressWarnings(“rawtypes”)
    public List selectList(String queryId) {
        printQueryId(queryId);
        return (List) sqlSession.selectList(queryId);
    }

    @SuppressWarnings(“rawtypes”)
    public List selectList(String queryId, Object params) {
        printQueryId(queryId);
        return (List) sqlSession.selectList(queryId, params);
    }
}

package com.bb.nddoc.dao.test;

import org.springframework.stereotype.Repository;
import com.bb.nddoc.common.dao.AbstractDAO;

@Repository(“testDAO”)
public class TestDAO extends AbstractDAO {

    public int selectCount() throws Exception {

        // 여기서 test.selectCount 란, 네임스페이스가 test 인 *-mapper.xml 내부의, id 가 selectCount 인 쿼리를 의미한다.

        // 즉, test-mapper.xml 파일에 담긴 쿼리를 뜻한다.​
        return (Integer) selectOne(“test.selectCount”);
    }
}

package com.bb.nddoc.model.test;

import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.bb.nddoc.service.test.TestServiceImpl;

@Controller
public class TestModel {
    
private static final Logger logger = LoggerFactory.getLogger(TestModel.class);
    
    @Resource(name=“testService”)
    private TestServiceImpl testService;
    
    @RequestMapping(value = “/test”, method = RequestMethod.GET)
    public String test(Model model) {
        
        try {
            int result = testService.select();
            logger.info(“result : “ + result);
        
        } catch (Exception e) {
            logger.error(e.getMessage());
            e.printStackTrace();
        }
        
        return “home”;
    }
}

package com.bb.nddoc.service.test;

public interface TestService {

    public int select() throws Exception;
}

package com.bb.nddoc.service.test;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.bb.nddoc.dao.test.TestDAO;

@Service(“testService”)
public class TestServiceImpl implements TestService {

    @Resource(name=“testDAO”)
    private TestDAO testDAO;
    
    public int select() throws Exception {
        return testDAO.selectCount();
    }
}

// 프로퍼티 파일 읽기 (PropertiesUtil 클래스의 readPropertiesFile 메서드)

// UTF-8 인코딩 형식의 properties 파일을 읽어서 HashMap 객체로 만들어 리턴하는 메서드.

​

package com.bb.classmerge.util; 

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class PropertiesUtil {

    /**
     * UTF-8 인코딩 형식의 properties 파일을 읽어서 HashMap 객체로 만들어 리턴한다.
     *
     * @param propFilePath
     * @return
     * @throws Exception
     */
    public static HashMap<String, String> readPropertiesFile(String propFilePath) throws Exception {
        if (propFilePath == null || propFilePath.length() == 0) {
            throw new Exception(“PropertiesUtil readPropertiesFile : propFilePath == null || propFilePath.length() == 0”);
        }

        File propFileObj = new File(propFilePath);
        if (!propFileObj.exists()) {
            throw new Exception(“PropertiesUtil readPropertiesFile : propFileObj does not exists. [“ + propFileObj.getAbsolutePath() + “]”);
        }
        
        if (!propFileObj.canRead()) {
            throw new Exception(“PropertiesUtil readPropertiesFile : propFileObj can not read. [“ + propFileObj.getAbsolutePath() + “]”);
        }

        HashMap<String, String> resultMap = new HashMap<String, String>();

        FileInputStream fileInputStream = null;
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;

        try {
            fileInputStream = new FileInputStream(propFileObj);
            inputStreamReader = new InputStreamReader(fileInputStream, “UTF-8”);
            bufferedReader = new BufferedReader(inputStreamReader);

            String oneLine = null;
            while ((oneLine = bufferedReader.readLine()) != null) {
                if (oneLine == null || oneLine.length() == 0) {
                    continue;
                }
                
                // 주석 무시
                if (oneLine.trim().startsWith(“#”)) {
                    continue;
                }
                
                int equalIndex = oneLine.indexOf(“=”);
                if (equalIndex < 0) {
                    continue;
                }
                
                // 좌측값(key값)만 trim 처리한다. 우측값(value값)은 의도적으로 공백이 포함될 수 있다고 판단한다.
                String leftText = oneLine.substring(0, equalIndex).trim();
                String rightText = oneLine.substring(equalIndex + 1);
                
                // 등호 좌측 텍스트가 존재하지 않을 경우 무시
                if (leftText.length() == 0) {
                    continue;
                }
                
                resultMap.put(leftText, rightText);
            }

        } catch (IOException e) {
            throw e;

        } catch (Exception e) {
            throw e;

        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
            } catch (Exception e) {
                // 무시
            } finally {
                bufferedReader = null;
            }

            try {
                if (inputStreamReader != null) {
                    inputStreamReader.close();
                }
            } catch (Exception e) {
                // 무시
            } finally {
                inputStreamReader = null;
            }

            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (Exception e) {
                // 무시
            } finally {
                fileInputStream = null;
            }
        }

        return resultMap;
    }
}

Sub 매크로1()
‘
‘ 매크로1 매크로
‘
‘ 바로 가기 키: Ctrl+k
‘

    Set myRange = Worksheets(“Sheet1”).Range(“A1:C10”)

    Dim result

    ‘SUM함수 사용

    result = Application.WorksheetFunction.Sum(myRange)
    MsgBox (“합계 : ” & result)

    ‘AVERAGE함수 사용 

    result = Application.WorksheetFunction.Average(myRange)
    MsgBox (“평균 : ” & result)

End Sub

AccrInt, AccrIntM, Acos, Acosh, Acot, Acoth, Aggregate, AmorDegrc, AmorLinc, And, Arabic, Asc, Asin, Asinh, Atan2, Atanh, AveDev, Average, AverageIf, AverageIfs, BahtText, Base, BesselI, BesselJ, BesselK, BesselY, Beta_Dist, Beta_Inv, BetaDist, BetaInv, Bin2Dec, Bin2Hex, Bin2Oct, Binom_Dist, Binom_Dist_Range, Binom_Inv, BinomDist, Bitand, Bitlshift, Bitor, Bitrshift, Bitxor, Ceiling, Ceiling_Math, Ceiling_Precise, ChiDist, ChiInv, ChiSq_Dist, ChiSq_Dist_RT, ChiSq_Inv, ChiSq_Inv_RT, ChiSq_Test, ChiTest, Choose, Clean, Combin, Combina, Complex, Confidence, Confidence_Norm, Confidence_T, Convert, Correl, Cosh, Cot, Coth, Count, CountA, CountBlank, CountIf, CountIfs, CoupDayBs, CoupDays, CoupDaysNc, CoupNcd, CoupNum, CoupPcd, Covar, Covariance_P, Covariance_S, CritBinom, Csc, Csch, CumIPmt, CumPrinc, DAverage, Days, Days360, Db, Dbcs, DCount, DCountA, Ddb, Dec2Bin, Dec2Hex, Dec2Oct, Decimal, Degrees, Delta, DevSq, DGet, Disc, DMax, DMin, Dollar, DollarDe, DollarFr, DProduct, DStDev, DStDevP, DSum, Duration, DVar, DVarP, EDate, Effect, EncodeURL, EoMonth, Erf, Erf_Precise, ErfC, ErfC_Precise, Even, Expon_Dist, ExponDist, F_Dist, F_Dist_RT, F_Inv, F_Inv_RT, F_Test, Fact, FactDouble, FDist, FilterXML, Find, FindB, FInv, Fisher, FisherInv, Fixed, Floor, Floor_Math, Floor_Precise, Forecast, Frequency, FTest, Fv, FVSchedule, Gamma, Gamma_Dist, Gamma_Inv, GammaDist, GammaInv, GammaLn, GammaLn_Precise, Gauss, Gcd, GeoMean, GeStep, Growth, HarMean, Hex2Bin, Hex2Dec, Hex2Oct, HLookup, HypGeom_Dist, HypGeomDist, IfError, IfNa, ImAbs, Imaginary, ImArgument, ImConjugate, ImCos, ImCosh, ImCot, ImCsc, ImCsch, ImDiv, ImExp, ImLn, ImLog10, ImLog2, ImPower, ImProduct, ImReal, ImSec, ImSech, ImSin, ImSinh, ImSqrt, ImSub, ImSum, ImTan, Index, Intercept, IntRate, Ipmt, Irr, IsErr, IsError, IsEven, IsFormula, IsLogical, IsNA, IsNonText, IsNumber, ISO_Ceiling, IsOdd, IsoWeekNum, Ispmt, IsText, Kurt, Large, Lcm, LinEst, Ln, Log, Log10, LogEst, LogInv, LogNorm_Dist, LogNorm_Inv, LogNormDist, Lookup, Match, Max, MDeterm, MDuration, Median, Min, MInverse, MIrr, MMult, Mode, Mode_Mult, Mode_Sngl, MRound, MultiNomial, Munit, NegBinom_Dist, NegBinomDist, NetworkDays, NetworkDays_Intl, Nominal, Norm_Dist, Norm_Inv, Norm_S_Dist, Norm_S_Inv, NormDist, NormInv, NormSDist, NormSInv, NPer, Npv, NumberValue, Oct2Bin, Oct2Dec, Oct2Hex, Odd, OddFPrice, OddFYield, OddLPrice, OddLYield, Or, PDuration, Pearson, Percentile, Percentile_Exc, Percentile_Inc, PercentRank, PercentRank_Exc, PercentRank_Inc, Permut, Permutationa, Phi, Phonetic, Pi, Pmt, Poisson, Poisson_Dist, Power, Ppmt, Price, PriceDisc, PriceMat, Prob, Product, Proper, Pv, Quartile, Quartile_Exc, Quartile_Inc, Quotient, Radians, RandBetween, Rank, Rank_Avg, Rank_Eq, Rate, Received, Replace, ReplaceB, Rept, Roman, Round, RoundDown, RoundUp, Rri, RSq, RTD, Search, SearchB, Sec, Sech, SeriesSum, Sinh, Skew, Skew_p, Sln, Slope, Small, SqrtPi, Standardize, StDev, StDev_P, StDev_S, StDevP, StEyx, Substitute, Subtotal, Sum, SumIf, SumIfs, SumProduct, SumSq, SumX2MY2, SumX2PY2, SumXMY2, Syd, T_Dist, T_Dist_2T, T_Dist_RT, T_Inv, T_Inv_2T, T_Test, Tanh, TBillEq, TBillPrice, TBillYield, TDist, Text, TInv, Transpose, Trend, Trim, TrimMean, TTest, Unichar, Unicode, USDollar, Var, Var_P, Var_S, VarP, Vdb, VLookup, WebService, Weekday, WeekNum, Weibull, Weibull_Dist, WorkDay, WorkDay_Intl, Xirr, Xnpv, Xor, YearFrac, YieldDisc, YieldMat, Z_Test, ZTest, Forecast_ETS, Forecast_ETS_ConfInt, Forecast_ETS_Seasonality, Forecast_ETS_STAT, Forecast_Linear

‘//원하는 윈도우를 포커스하기 위한 선언 

Private Declare Function SetForegroundWindow Lib “user32” (ByVal hwnd As Long) As Long
‘//윈도우 핸들을 찾기 위한 선언
Private Declare Function FindWindow Lib “user32” Alias “FindWindowA” (ByVal lpClassName As String, ByVal lpWindowName As String) As Long

‘//일정시간을 대기하는 함수 *Sleep(n) = n/1000초 동안 대기
Private Declare Sub Sleep Lib “kernel32” (ByVal dwMilliseconds As Long)

‘//키보드 상태확인을 위한 선언하기
Private Declare Function GetAsyncKeyState Lib “user32” (ByVal vKey As Long) As Integer
‘//키입력을 위한 선언하기
Const KEYEVENTF_EXTENDKEY = &H1
Const KEYEVENTF_KEYUP = &H2
Private Declare Sub keybd_event Lib “user32.dll” (ByVal bVk As Byte, ByVal bScan As Byte, ByVal dwFlags As Long, ByVal dwExtraInfo As Long)

‘//인터넷 익스플로러 선언

‘//도구-참조-Microsoft Internet controls​ (또는 C:\windows\system32\shdocvw.dll)

Dim IE As New InternetExplorer
‘//기억할 윈도우 핸들
Dim IEhWnd

Sub Macro1()

‘//익스플로러를 열어 지정해둔 주소로 접속한다
IE.Visible = True
IE.Navigate “naver.com”
IEhWnd = IE.hwnd ‘//새로 열린 윈도우 핸들을 기억한다

Call LoadWait ‘//로딩중 대기

Call goIE ‘//로딩 끝나면, 익스플로러를 열고(goIE)

Call KeyA: Call Enter: Call LoadWait ‘//”A”를 검색하고 로딩대기

Call KeyB: Call Enter: Call LoadWait ‘//”B”를 검색하고 로딩대기

Call KeyC: Call Enter: Call LoadWait ‘//”C”를 검색하고 로딩대기

‘Call goExcel ‘//엑셀로 돌아오기
End Sub

​

Function LoadWait()
‘//로딩하는 동안 대기한다

If IE.hwnd <> 0 Then ‘//익스플로러가 켜져있을 때만
Do While IE.Busy Or IE.ReadyState <> READYSTATE_COMPLETE ‘//익스플로러가 로딩 중이면 대기한다
DoEvents
Loop
Sleep (1000)

Else
MsgBox “익스플로러가 켜져있지 않습니다”
End
End If
End Function

Function goIE()
‘//기억해둔 윈도우 핸들을 불러낸다.
   ‘// 참고로 “IEhWnd = FindWindow(“IEFrame”, vbNullString)”라는
   ‘// 1줄을 추가하면 익스플로러를 찾아서 불러낸다
Call SetForegroundWindow(IEhWnd)
Call Sleep(1000) ‘//1초 쉰다
End Function

​

Function goExcel()
‘//다른 창에서 작업하다가 다시 엑셀로 돌아갈 때 유용하다

Dim ihWnd As Long
ihWnd = FindWindow(vbNullString, Application.Caption)

If ihWnd = 0 Then
    MsgBox “현재 엑셀을 찾을 수 없습니다”
Else
    Call SetForegroundWindow(ihWnd)
End If
End Function

Function Enter()
keybd_event 13, 0, 0, 0 ‘//엔터
keybd_event 13, 0, KEYEVENTF_KEYUP, 0
Call Sleep(100) ‘//0.1초 쉰다

​DoEvents
End Function

Function KeyA()
keybd_event 65, 0, 0, 0 ‘//A키
keybd_event 65, 0, KEYEVENTF_KEYUP, 0
Call Sleep(100) ‘//0.1초 쉰다

​DoEvents
End Function

Function KeyB()
keybd_event 66, 0, 0, 0 ‘//B키
keybd_event 66, 0, KEYEVENTF_KEYUP, 0
Call Sleep(100) ‘//0.1초 쉰다
DoEvents
End Function

Function KeyC()
keybd_event 67, 0, 0, 0 ‘C키
keybd_event 67, 0, KEYEVENTF_KEYUP, 0
Call Sleep(100) ‘//0.1초 쉰다

​DoEvents
End Function

std::string str1 = “Hello World.”;

// 아래 코드는 cout << “Hello World.” << endl; 와 같음

std::string str1 = “Hello World.”;

cout << str1.c_str() << endl;

int num = 10;
log(“num : %d”, num);

int num1 = 10;
int num2 = 20;
int num3 = num1 + num2;
log(“num3 : %d”, num3);

char* str = “10”;
log(“str : %s”, str);

std::string str1 = “10”;
log(“str1 : %s”, str1.c_str());

std::string str2 = “10”;
std::string str3 = “20”;
std::string str4 = str2 + str3;
log(“str4 : %s”, str4.c_str());

int num10 = 10;
std::string str10 = std::to_string(num10);

log(“str10 : %s”, str10.c_str());

char* str20 = “10”;
int num20 = std::atoi(str20);
log(“num20 : %d”, num20);

std::string str21 = “10”;
int num21 = std::stoi(str21);
log(“num21 : %d”, num21);

<dependency>
    <groupId>javax.websocket</groupId>
    <artifactId>javax.websocket-api</artifactId>
    <version>1.1</version>
    <scope>provided</scope>
</dependency>

​// 패키지 위치는 자유롭게 결정

package com.bb.vivria.socket;

import java.util.ArrayList;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(“/websocket”)
public class Websocket {

    /**
     * 웹소켓 세션을 담는 ArrayList
     */
    private static ArrayList<Session> sessionList = new ArrayList<Session>();

    
    /**
     * 웹소켓 사용자 연결 성립하는 경우 호출
     */
    @OnOpen
    public void handleOpen(Session session) {
        if (session != null) {
            String sessionId = session.getId();
            
            System.out.println(“client is connected. sessionId == [“ + sessionId + “]”);
            sessionList.add(session);
            
            // 웹소켓 연결 성립되어 있는 모든 사용자에게 메시지 전송
            sendMessageToAll(“***** [USER-“ + sessionId + “] is connected. *****”);
        }
    }
    

    /**
     * 웹소켓 메시지(From Client) 수신하는 경우 호출
     */
    @OnMessage
    public String handleMessage(String message, Session session) {
        if (session != null) {
            String sessionId = session.getId();
            System.out.println(“message is arrived. sessionId == [“ + sessionId + “] / message == [“ + message + “]”);

            // 웹소켓 연결 성립되어 있는 모든 사용자에게 메시지 전송
            sendMessageToAll(“[USER-“ + sessionId + “] “ + message);
        }

        return null;
    }
    

    /**
     * 웹소켓 사용자 연결 해제하는 경우 호출
     */
    @OnClose
    public void handleClose(Session session) {
        if (session != null) {
            String sessionId = session.getId();
            System.out.println(“client is disconnected. sessionId == [“ + sessionId + “]”);
            
            // 웹소켓 연결 성립되어 있는 모든 사용자에게 메시지 전송
            sendMessageToAll(“***** [USER-“ + sessionId + “] is disconnected. *****”);
        }
    }

    
    /**
     * 웹소켓 에러 발생하는 경우 호출
     */
    @OnError
    public void handleError(Throwable t) {
        t.printStackTrace();
    }
    
    
    /**
     * 웹소켓 연결 성립되어 있는 모든 사용자에게 메시지 전송
     */
    private boolean sendMessageToAll(String message) {
        if (sessionList == null) {
            return false;
        }

        int sessionCount = sessionList.size();
        if (sessionCount < 1) {
            return false;
        }

        Session singleSession = null;

        for (int i = 0; i < sessionCount; i++) {
            singleSession = sessionList.get(i);
            if (singleSession == null) {
                continue;
            }

            if (!singleSession.isOpen()) {
                continue;
            }

            sessionList.get(i).getAsyncRemote().sendText(message);
        }

        return true;
    }
}

<%@ page contentType=“text/html; charset=utf-8” %>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv=“Content-Type” content=“text/html; charset=UTF-8”>
<title>웹소켓 테스트 페이지</title>
<script type=“text/javascript”>
var g_webSocket = null;
window.onload = function() {
    g_webSocket = new WebSocket(“ws://localhost:8080/websocket”);
    
    
    /**
     * 웹소켓 사용자 연결 성립하는 경우 호출
     */
    g_webSocket.onopen = function(message) {
        addLineToChatBox(“Server is connected.”);
    };
    
    
    /**
     * 웹소켓 메시지(From Server) 수신하는 경우 호출
     */
    g_webSocket.onmessage = function(message) {
        addLineToChatBox(message.data);
    };

    /**
     * 웹소켓 사용자 연결 해제하는 경우 호출
     */
    g_webSocket.onclose = function(message) {
        addLineToChatBox(“Server is disconnected.”);
    };

    /**
     * 웹소켓 에러 발생하는 경우 호출
     */
    g_webSocket.onerror = function(message) {
        addLineToChatBox(“Error!”);
    };
}

/**
* 채팅 박스영역에 내용 한 줄 추가
*/
function addLineToChatBox(_line) {
    if (_line == null) {
        _line = “”;
    }
    
    var chatBoxArea = document.getElementById(“chatBoxArea”);
    chatBoxArea.value += _line + “\n”;
    chatBoxArea.scrollTop = chatBoxArea.scrollHeight;    
}

/**
* Send 버튼 클릭하는 경우 호출 (서버로 메시지 전송)
*/
function sendButton_onclick() {
    var inputMsgBox = document.getElementById(“inputMsgBox”);
    if (inputMsgBox == null || inputMsgBox.value == null || inputMsgBox.value.length == 0) {
        return false;
    }
    
    var chatBoxArea = document.getElementById(“chatBoxArea”);
    
    if (g_webSocket == null || g_webSocket.readyState == 3) {
        chatBoxArea.value += “Server is disconnected.\n”;
        return false;
    }
    
    // 서버로 메시지 전송
    g_webSocket.send(inputMsgBox.value);
    inputMsgBox.value = “”;
    inputMsgBox.focus();
    
    return true;
}

/**
* Disconnect 버튼 클릭하는 경우 호출
*/
function disconnectButton_onclick() {
    if (g_webSocket != null) {
        g_webSocket.close();    
    }
}

/**
* inputMsgBox 키입력하는 경우 호출
*/
function inputMsgBox_onkeypress() {
    if (event == null) {
        return false;
    }
    
    // 엔터키 누를 경우 서버로 메시지 전송
    var keyCode = event.keyCode || event.which;
    if (keyCode == 13) {
        sendButton_onclick();
    }
}
</script>
</head>
<body>
    <input id=“inputMsgBox” style=“width: 250px;” type=“text” onkeypress=“inputMsgBox_onkeypress()”>
    <input id=“sendButton” value=“Send” type=“button” onclick=“sendButton_onclick()”>
    <input id=“disconnectButton” value=“Disconnect” type=“button” onclick=“disconnectButton_onclick()”>
    <br/>
    <textarea id=“chatBoxArea” style=“width: 100%;” rows=“10” cols=“50” readonly=“readonly”></textarea>
</body>
</html>

​// 패키지 위치는 자유롭게 결정

package com.bb.vivria.controller;

import java.util.Locale;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class ChatController {
    @RequestMapping(value = “/chat”, method = RequestMethod.GET)
    public String home(Locale locale, Model model) {
        
        return “chat/test”;
    }
}

조합(Combination)하는 경우의 수 :
2,3,4
1,3,4
1,2,4
1,2,3
—–
순열(Permutation)하는 경우의 수 :
2,3,4
2,4,3
3,2,4
3,4,2
4,3,2
4,2,3
1,3,4
1,4,3
3,1,4
3,4,1
4,3,1
4,1,3
1,2,4
1,4,2
2,1,4
2,4,1
4,2,1
4,1,2
1,2,3
1,3,2
2,1,3
2,3,1
3,2,1
3,1,2

    public static void main(String[] args) {
        int[] inputArray = {1, 2, 3, 4, 4, 3, 2, 1, 1};
        ArrayList<int[]> combinationList = getCombination(inputArray, 3);
        System.out.println(“조합(Combination)하는 경우의 수 : “);
        print(combinationList);
        System.out.println(“—–“);
        
        System.out.println(“순열(Permutation)하는 경우의 수 : “);
        ArrayList<int[]> permutationList = getPermutation(inputArray, 3);
        print(permutationList);
    }
    
    
    /**
     * 순열 구하기
     */
    public static ArrayList<int[]> getPermutation(int[] inputArray, int selectCount) {
        ArrayList<int[]> resultList = new ArrayList<int[]>();
        
        ArrayList<int[]> combinationList = getCombination(inputArray, selectCount);
        int count = combinationList.size();
        for (int i=0; i<count; i++) {
            if (combinationList.get(i) == null) {
                continue;
            }
            
            int[] singleArray = combinationList.get(i);
            singleArray = removeDuplication(singleArray);
            if (singleArray == null || singleArray.length == 0) {
                continue;
            }
            
            addSinglePermutation(resultList, singleArray, 0);
        }
        
        if (resultList != null) {
            resultList = removeDuplication(resultList);
        }
        
        return resultList;
    }
    
    
    /**
     * 순열 구하기
     */
    public static void addSinglePermutation(ArrayList<int[]> resultList, int[] inputArray, int position) {
        
        int count = inputArray.length;
        for (int i=position; i<count; i++) {
            int[] inputArray2 = cloneArray(inputArray);
            swapArray(inputArray2, position, i);
            resultList.add(inputArray);
            
            addSinglePermutation(resultList, inputArray2, position + 1);
        }
    }
    
    
    /**
     * 조합 구하기
     */
    public static ArrayList<int[]> getCombination(int[] inputArray, int selectCount) {
        // 미리 중복 제거하고 실행
        inputArray = removeDuplication(inputArray);
                
        ArrayList<int[]> resultList = new ArrayList<int[]>();
        int[] hintArray = new int[inputArray.length];
        
        addSingleCombination(resultList, selectCount, inputArray, 0, hintArray, 0);
        return resultList;
    }
    
    
    /**
     * 조합 구하기 재귀메서드
     */
    public static void addSingleCombination(ArrayList<int[]> resultList, int selectCount, int[] inputArray, int position, int[] hintArray, int hintIndex) {
        
        if (hintIndex == selectCount) {
            int[] singleArray = resizeIntArray(hintArray, hintIndex);
            if (singleArray != null && singleArray.length > 0) {
                resultList.add(singleArray);
            }
            return;
        }
        
        int lastIndex = inputArray.length – 1;
        if (position > lastIndex) {
            return;
        }
        
        int[] hintArray2 = cloneArray(hintArray);
        hintArray[hintIndex] = 0;
        hintArray2[hintIndex] = inputArray[position];
        
        position++;
        
        addSingleCombination(resultList, selectCount, inputArray, position, hintArray, hintIndex);
        addSingleCombination(resultList, selectCount, inputArray, position, hintArray2, hintIndex + 1);
    }
    
    
    /**
     * int 배열을 복제한다.
     */
    public static int[] cloneArray(int[] inputArray) {
        if (inputArray == null) {
            return null;
        }
        
        int count = inputArray.length;
        int[] resultArray = new int[count];
        
        for (int i=0; i<count; i++) {
            resultArray[i] = inputArray[i];
        }
        
        return resultArray;
    }
    
    
    /**
     * int 배열의 두 요소의 값을 맞바꾼다.
     */
    public static boolean swapArray(int[] array, int i, int k) {
        if (array == null) {
            return false;
        }
        
        int count = array.length;
        int lastIndex = count – 1;
        
        if (i < 0 || k < 0 || i > lastIndex || k > lastIndex) {
            return false;
        }
        
        int temp = array[i];
        array[i] = array[k];
        array[k] = temp;
        
        return true;
    }
    
    
    /**
     * int 배열의 길이를 변경한다. (조정한 배열을 새로 얻는다)
     */
    public static int[] resizeIntArray(int[] inputArray, int newSize) {
        int lastIndex = -1;
        if (inputArray != null) {
            lastIndex = inputArray.length – 1;
        }
        
        int[] newArray = new int[newSize];
        
        for (int i=0; i<newSize; i++) {
            if (i > lastIndex) {
                newArray[i] = 0;
            } else {
                newArray[i] = inputArray[i];
            }
        }
        
        return newArray;
    }
    
    
    /**
     * 인트 배열의 중복을 제거한다.
     */
    public static int[] removeDuplication(int[] inputArray) {
        if (inputArray == null || inputArray.length == 0) {
            return null;
        }
        
        int count = inputArray.length;
        int[] resultArray = new int[count];
        
        int currentIndex = 0;

        int singleItem = 0;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputArray[i];
            
            for (int k=0; k<resultArray.length; k++) {
                if (resultArray[k] == singleItem) {
                    continue oLoop;
                }
            }
            
            resultArray[currentIndex] = singleItem;
            currentIndex++;
        }
        
        if (currentIndex != count) {
            resultArray = resizeIntArray(resultArray, currentIndex);
        }
        
        return resultArray;
    }
    
    
    /**
     * Generic int 배열인 ArrayList 의 중복을 제거한다.
     */
    public static ArrayList<int[]> removeDuplication(ArrayList<int[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return null;
        }
        
        int count = inputList.size();
        ArrayList<int[]> resultList = new ArrayList<int[]>();
        
        int[] singleItem = null;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputList.get(i);
            
            for (int k=0; k<resultList.size(); k++) {
                if (equals(singleItem, resultList.get(k))) {
                    continue oLoop;
                }
            }
            
            resultList.add(singleItem);
        }
        
        return resultList;
    }
    
    
    /**
     * int 배열 2개가 서로 같은지 비교한다.
     */
    public static boolean equals(int[] array1, int[] array2) {
        if (array1 == null && array2 == null) {
            return true;
        }
        
        if (array1 == null || array2 == null) {
            return false;
        }
        
        if (array1.length != array2.length) {
            return false;
        }
        
        int count = array1.length;
        for (int i=0; i<count; i++) {
            if (array1[i] != array2[i]) {
                return false;
            }
        }
        
        return true;
    }
    
    
    /**
     * 제네릭이 int 배열인 ArrayList를 출력한다.
     */
    public static void print(ArrayList<int[]> inputList) {
        System.out.println(convertToString(inputList));
    }
    
    
    /**
     * int 배열을 출력한다.
     */
    public static void print(int[] inputArray) {
        System.out.println(convertToString(inputArray, “,”));
    }
    
    
    /**
     * 제네릭이 int 배열인 ArrayList의 내용을 문자열 형태로 만든다.
     */
    public static String convertToString(ArrayList<int[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputList.size();
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(“\n”);
            }
            
            buff.append(convertToString(inputList.get(i), “,”));
        }
        
        return buff.toString();
    }

    
    /**
     * int 배열의 내용을 문자열 형태로 만든다.
     */
    public static String convertToString(int[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }

3,4,5,6
2,4,5,6
2,3,5,6
2,3,4,6
2,3,4,5
1,4,5,6
1,3,5,6
1,3,4,6
1,3,4,5
1,2,5,6
1,2,4,6
1,2,4,5
1,2,3,6
1,2,3,5
1,2,3,4

public static void main(String[] args) {
        int[] inputArray = {1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1, 4, 3, 2, 6, 5};
        ArrayList<int[]> resultList = getCombination(inputArray, 4);
        print(resultList);
    }
    
    
    /**
     * 제네릭이 int 배열인 ArrayList를 출력한다.
     */
    public static void print(ArrayList<int[]> inputList) {
        System.out.println(convertToString(inputList));
    }
    
    
    /**
     * int 배열을 출력한다.
     */
    public static void print(int[] inputArray) {
        System.out.println(convertToString(inputArray, “,”));
    }
    
    
    /**
     * 제네릭이 int 배열인 ArrayList의 내용을 문자열 형태로 만든다.
     */
    public static String convertToString(ArrayList<int[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputList.size();
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(“\n”);
            }
            
            buff.append(convertToString(inputList.get(i), “,”));
        }
        
        return buff.toString();
    }

    
    /**
     * int 배열의 내용을 문자열 형태로 만든다.
     */
    public static String convertToString(int[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }

    
    /**
     * 조합 구하기
     */
    public static ArrayList<int[]> getCombination(int[] inputArray, int selectCount) {
        // 미리 중복 제거하고 실행
        inputArray = removeDuplication(inputArray);
                
        ArrayList<int[]> resultList = new ArrayList<int[]>();
        int[] hintArray = new int[inputArray.length];
        
        getSingleCombination(resultList, selectCount, inputArray, 0, hintArray, 0);
        return resultList;
    }
    
    
    /**
     * 조합 구하기 재귀메서드
     */
    public static void addSingleCombination(ArrayList<int[]> resultList, int selectCount, int[] inputArray, int position, int[] hintArray, int hintIndex) {
        
        if (hintIndex == selectCount) {
            int[] singleArray = resizeIntArray(hintArray, hintIndex);
            if (singleArray != null && singleArray.length > 0) {
                resultList.add(singleArray);
            }
            return;
        }
        
        int lastIndex = inputArray.length – 1;
        if (position > lastIndex) {
            return;
        }
        
        int[] hintArray2 = cloneArray(hintArray);
        hintArray[hintIndex] = 0;
        hintArray2[hintIndex] = inputArray[position];
        
        position++;
        
        addSingleCombination(resultList, selectCount, inputArray, position, hintArray, hintIndex);
        addSingleCombination(resultList, selectCount, inputArray, position, hintArray2, hintIndex + 1);
    }
    
    
    /**
     * int 배열을 복제한다.
     */
    public static int[] cloneArray(int[] inputArray) {
        if (inputArray == null) {
            return null;
        }
        
        int count = inputArray.length;
        int[] resultArray = new int[count];
        
        for (int i=0; i<count; i++) {
            resultArray[i] = inputArray[i];
        }
        
        return resultArray;
    }
    
    
    /**
     * int 배열의 길이를 변경한다. (조정한 배열을 새로 얻는다)
     */
    public static int[] resizeIntArray(int[] inputArray, int newSize) {
        int lastIndex = -1;
        if (inputArray != null) {
            lastIndex = inputArray.length – 1;
        }
        
        int[] newArray = new int[newSize];
        
        for (int i=0; i<newSize; i++) {
            if (i > lastIndex) {
                newArray[i] = 0;
            } else {
                newArray[i] = inputArray[i];
            }
        }
        
        return newArray;
    }
    
    
    /**
     * int 배열의 중복을 제거한다.
     */
    public static int[] removeDuplication(int[] inputArray) {
        if (inputArray == null || inputArray.length == 0) {
            return null;
        }
        
        int count = inputArray.length;
        int[] resultArray = new int[count];
        
        int currentIndex = 0;

        int singleItem = 0;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputArray[i];
            
            for (int k=0; k<resultArray.length; k++) {
                if (resultArray[k] == singleItem) {
                    continue oLoop;
                }
            }
            
            resultArray[currentIndex] = singleItem;
            currentIndex++;
        }
        
        if (currentIndex != count) {
            resultArray = resizeIntArray(resultArray, currentIndex);
        }
        
        return resultArray;
    }

    public static void main(String[] args) {
        printAllNumberOfCases(5, 3);
    }

    
    /**
     * 경우의 수 출력
     */
    public static void printAllNumberOfCases(int totalCount, int selectCount) {
        printSingleCase(“”, 0, totalCount, selectCount);
    }
    
    
    public static void printSingleCase(String str, int position, int totalCount, int selectCount) {
        
        if (position == totalCount) {
            if (selectCount == 0) {
                System.out.println(str);
            }
            return;
        }
        
        position++;
        
        printSingleCase(str + “0”, position, totalCount, selectCount);
        printSingleCase(str + “1”, position, totalCount, selectCount – 1);
    }

00111
01011
01101
01110
10011
10101
10110
11001
11010
11100

    public static void main(String[] args) {
        ArrayList<String> caseList = getAllNumberOfCases(5, 3);
        System.out.println(caseList);
    }
    
    
    /**
     * 경우의 수 어레이리스트로 반환
     */
    public static ArrayList<String> getAllNumberOfCases(int totalCount, int selectCount) {
        ArrayList<String> caseList = new ArrayList<String>();
        getSingleCase(caseList, “”, 0, totalCount, selectCount);
        return caseList;
    }
    
    
    public static void getSingleCase(ArrayList<String> strList, String str, int position, int totalCount, int selectCount) {
        
        if (position == totalCount) {
            if (selectCount == 0) {
                strList.add(str);
            }
            return;
        }
        
        position++;
        
        getSingleCase(strList, str + “0”, position, totalCount, selectCount);
        getSingleCase(strList, str + “1”, position, totalCount, selectCount – 1);
    }

[00111, 01011, 01101, 01110, 10011, 10101, 10110, 11001, 11010, 11100]

    public static void main(String[] args) {
        printAllNumberOfCases(5);
    }

    
    /**
     * 모든 경우의 수 출력
     */
    public static void printAllNumberOfCases(int totalCount) {
        printSingleCase(“”, 0, totalCount);
    }
    
    
    public static void printSingleCase(String str, int position, int totalCount) {
        
        if (position == totalCount) {
            System.out.println(str);
            return;
        }
        
        position++;
        
        printSingleCase(str + “0”, position, totalCount);
        printSingleCase(str + “1”, position, totalCount);
    }

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

    public static void main(String[] args) {
        ArrayList<String> caseList = getAllNumberOfCases(5);
        System.out.println(caseList);
    }
    
    
    /**
     * 모든 경우의 수 어레이리스트로 반환
     */
    public static ArrayList<String> getAllNumberOfCases(int totalCount) {
        ArrayList<String> caseList = new ArrayList<String>();
        getSingleCase(caseList, “”, 0, totalCount);
        return caseList;
    }
    
    
    public static void getSingleCase(ArrayList<String> strList, String str, int position, int totalCount) {
        
        if (position == totalCount) {
            strList.add(str);
            return;
        }
        
        position++;
        
        getSingleCase(strList, str + “0”, position, totalCount);
        getSingleCase(strList, str + “1”, position, totalCount);
    }

[00000, 00001, 00010, 00011, 00100, 00101, 00110, 00111, 01000, 01001, 01010, 01011, 01100, 01101, 01110, 01111, 10000, 10001, 10010, 10011, 10100, 10101, 10110, 10111, 11000, 11001, 11010, 11011, 11100, 11101, 11110, 11111]

before : 서울,부산,포항,대전,전주,나주,부산,포항,대전,전주
서울,부산,포항,대전,전주,나주,부산,포항,대전,전주
서울,부산,포항,대전,전주,나주,부산,포항,대전
서울,부산,포항,대전,전주
서울,부산,포항,대전,전주
 
after : 서울,부산,포항,대전,전주,나주,부산,포항,대전,전주
서울,부산,포항,대전,전주,나주,부산,포항,대전
서울,부산,포항,대전,전주

    public static void main(String[] args) {
        
        String[] intArray1 = {“서울”, “부산”, “포항”, “대전”, “전주”, “나주”, “부산”, “포항”, “대전”, “전주”};
        String[] intArray2 = {“서울”, “부산”, “포항”, “대전”, “전주”, “나주”, “부산”, “포항”, “대전”, “전주”};
        String[] intArray3 = {“서울”, “부산”, “포항”, “대전”, “전주”, “나주”, “부산”, “포항”, “대전”};
        String[] intArray4 = {“서울”, “부산”, “포항”, “대전”, “전주”};
        String[] intArray5 = {“서울”, “부산”, “포항”, “대전”, “전주”};
        
        ArrayList<String[]> intArrayList = new ArrayList<String[]>();
        intArrayList.add(intArray1);
        intArrayList.add(intArray2);
        intArrayList.add(intArray3);
        intArrayList.add(intArray4);
        intArrayList.add(intArray5);
        
        ArrayList<String[]> resultList = removeDuplication(intArrayList);
        
        System.out.println(“before : “ + convertToString(intArrayList));
        System.out.println(” “);
        System.out.println(“after : “ + convertToString(resultList));
    }
    
    
    /**
     * Generic String 배열인 ArrayList 를 출력용 스트링으로 변환한다.
     */

    public static String convertToString(ArrayList<String[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputList.size();
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(“\n”);
            }
            
            buff.append(convertToString(inputList.get(i), “,”));
        }
        
        return buff.toString();
    }
    
    
    /**
     * String 배열을 출력용 스트링으로 변환한다.
     */

    public static String convertToString(String[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }
    
    
    /**
     * Generic String 배열인 ArrayList 의 중복을 제거한다.
     */

    public static ArrayList<String[]> removeDuplication(ArrayList<String[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return null;
        }
        
        int count = inputList.size();
        ArrayList<String[]> resultList = new ArrayList<String[]>();
        
        String[] singleItem = null;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputList.get(i);
            
            for (int k=0; k<resultList.size(); k++) {
                if (equals(singleItem, resultList.get(k))) {
                    continue oLoop;
                }
            }
            
            resultList.add(singleItem);
        }
        
        return resultList;
    }
    
    
    /**
     * String 배열이 같은지 비교한다.
     */

    public static boolean equals(String[] arr1, String[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        
        if (arr1 == null || arr2 == null) {
            return false;
        }
        
        if (arr1.length != arr2.length) {
            return false;
        }
        
        int count = arr1.length;
        for (int i=0; i<count; i++) {
            if (!arr1[i].equals(arr2[i])) {
                return false;
            }
        }
        
        return true;
    }

before : 1,2,3,4,5,1,2,3,4,5
1,2,3,4,5,1,2,3,4,5
1,2,3,4,5,1,2,3,4
1,2,3,4,5
1,2,3,4,5
 
after : 1,2,3,4,5,1,2,3,4,5
1,2,3,4,5,1,2,3,4
1,2,3,4,5

    public static void main(String[] args) {
        
        int[] intArray1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
        int[] intArray2 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
        int[] intArray3 = {1, 2, 3, 4, 5, 1, 2, 3, 4};
        int[] intArray4 = {1, 2, 3, 4, 5};
        int[] intArray5 = {1, 2, 3, 4, 5};
        
        ArrayList<int[]> intArrayList = new ArrayList<int[]>();
        intArrayList.add(intArray1);
        intArrayList.add(intArray2);
        intArrayList.add(intArray3);
        intArrayList.add(intArray4);
        intArrayList.add(intArray5);
        
        ArrayList<int[]> resultList = removeDuplication(intArrayList);
        
        System.out.println(“before : “ + convertToString(intArrayList));
        System.out.println(” “);
        System.out.println(“after : “ + convertToString(resultList));
    }
    
    
    /**
     * Generic int 배열인 ArrayList 를 출력용 스트링으로 변환한다.
     */

    public static String convertToString(ArrayList<int[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputList.size();
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(“\n”);
            }
            
            buff.append(convertToString(inputList.get(i), “,”));
        }
        
        return buff.toString();
    }
    
    
    /**
     * int 배열을 출력용 스트링으로 변환한다.
     */

    public static String convertToString(int[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }
    
    
    /**
     * Generic int 배열인 ArrayList 의 중복을 제거한다.
     */

    public static ArrayList<int[]> removeDuplication(ArrayList<int[]> inputList) {
        if (inputList == null || inputList.size() == 0) {
            return null;
        }
        
        int count = inputList.size();
        ArrayList<int[]> resultList = new ArrayList<int[]>();
        
        int[] singleItem = null;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputList.get(i);
            
            for (int k=0; k<resultList.size(); k++) {
                if (equals(singleItem, resultList.get(k))) {
                    continue oLoop;
                }
            }
            
            resultList.add(singleItem);
        }
        
        return resultList;
    }
    
    
    /**
     * int 배열이 같은지 비교한다.
     */

    public static boolean equals(int[] arr1, int[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        
        if (arr1 == null || arr2 == null) {
            return false;
        }
        
        if (arr1.length != arr2.length) {
            return false;
        }
        
        int count = arr1.length;
        for (int i=0; i<count; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        
        return true;
    }

before : 서울,부산,대구,전주,대전,제주,서울,대전,제주
after : 서울,부산,대구,전주,대전,제주

    public static void main(String[] args) {
        
        String[] strArray = {“서울”, “부산”, “대구”, “전주”, “대전”, “제주”, “서울”, “대전”, “제주”};
        String[] resultArray = removeDuplication(strArray);
        
        System.out.println(“before : “ + getString(strArray, “,”));
        System.out.println(“after : “ + getString(resultArray, “,”));
    }
    
    
    /**
     * 스트링 배열을 출력하기 쉽도록 한줄 스트링 형태로 변환한다.
     */

    public static String getString(String[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }
    
    
    /**
     * 스트링 배열의 중복을 제거한다.
     */

    public static String[] removeDuplication(String[] inputArray) {
        if (inputArray == null || inputArray.length == 0) {
            return null;
        }
        
        int count = inputArray.length;
        String[] resultArray = new String[count];
        
        int currentIndex = 0;
        
        String singleItem = null;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputArray[i];
            
            for (int k=0; k<resultArray.length; k++) {
                if (resultArray[k] == singleItem) {
                    continue oLoop;
                }
            }
            
            resultArray[currentIndex] = singleItem;
            currentIndex++;
        }
        
        if (currentIndex != count) {
            resultArray = resizeIntArray(resultArray, currentIndex);
        }
        
        return resultArray;
    }
    
    
    /**
     * 스트링 배열의 길이를 조정한다. (조정한 배열을 새로 얻는다)
     */

    public static String[] resizeIntArray(String[] inputArray, int newSize) {
        int lastIndex = -1;
        if (inputArray != null) {
            lastIndex = inputArray.length – 1;
        }
        
        String[] newArray = new String[newSize];
        
        for (int i=0; i<newSize; i++) {
            if (i > lastIndex) {
                newArray[i] = “”;
            } else {
                if (inputArray[i] == null) {
                    newArray[i] = “”;
                } else {
                    newArray[i] = inputArray[i];
                }
            }
        }
        
        return newArray;
    }

before : 1,2,3,4,5,1,2,3,4,5
after : 1,2,3,4,5

    public static void main(String[] args) {
        
        int[] intArray = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
        int[] resultArray = removeDuplication(intArray);
        
        System.out.println(“before : “ + convertToString(intArray, “,”));
        System.out.println(“after : “ + convertToString(resultArray, “,”));
    }
    
    
    /**
     * 인트 배열을 출력하기 쉽도록 한줄 스트링 형태로 변환한다.
     */

    public static String convertToString(int[] inputArray, String delimiter) {
        if (inputArray == null || inputArray.length == 0) {
            return “”;
        }
        
        StringBuffer buff = new StringBuffer();
        
        int count = inputArray.length;
        for (int i=0; i<count; i++) {
            if (buff.length() > 0) {
                buff.append(delimiter);
            }
            
            buff.append(inputArray[i]);
        }
        
        return buff.toString();
    }
    
    
    /**
     * 인트 배열의 중복을 제거한다.
     */

    public static int[] removeDuplication(int[] inputArray) {
        if (inputArray == null || inputArray.length == 0) {
            return null;
        }
        
        int count = inputArray.length;
        int[] resultArray = new int[count];
        
        int currentIndex = 0;

        int singleItem = 0;
        
        oLoop : for (int i=0; i<count; i++) {
            singleItem = inputArray[i];
            
            for (int k=0; k<resultArray.length; k++) {
                if (resultArray[k] == singleItem) {
                    continue oLoop;
                }
            }
            
            resultArray[currentIndex] = singleItem;
            currentIndex++;
        }
        
        if (currentIndex != count) {
            resultArray = resizeIntArray(resultArray, currentIndex);
        }
        
        return resultArray;
    }
    
    
    /**
     * 인트 배열의 길이를 조정한다. (조정한 배열을 새로 얻는다)
     */

    public static int[] resizeIntArray(int[] inputArray, int newSize) {
        int lastIndex = -1;
        if (inputArray != null) {
            lastIndex = inputArray.length – 1;
        }
        
        int[] newArray = new int[newSize];
        
        for (int i=0; i<newSize; i++) {
            if (i > lastIndex) {
                newArray[i] = 0;
            } else {
                newArray[i] = inputArray[i];
            }
        }
        
        return newArray;
    }

//[AesUtil.js]
var AesUtil=function(keySize,iterationCount){this.keySize=keySize/32;this.iterationCount=iterationCount;}
AesUtil.prototype.generateKey=function(salt,passPhrase) {var key=CryptoJS.PBKDF2(passPhrase,CryptoJS.enc.Hex.parse(salt),{keySize: this.keySize,iterations: this.iterationCount});return key;}
AesUtil.prototype.encrypt=function(salt,iv,passPhrase,plainText){var key=this.generateKey(salt,passPhrase);var encrypted=CryptoJS.AES.encrypt(plainText,key,{iv: CryptoJS.enc.Hex.parse(iv)});return encrypted.ciphertext.toString(CryptoJS.enc.Base64);}
AesUtil.prototype.decrypt=function(salt,iv,passPhrase,cipherText){var key=this.generateKey(salt,passPhrase);var cipherParams=CryptoJS.lib.CipherParams.create({ciphertext: CryptoJS.enc.Base64.parse(cipherText)});var decrypted=CryptoJS.AES.decrypt(cipherParams,key,{iv: CryptoJS.enc.Hex.parse(iv)});return decrypted.toString(CryptoJS.enc.Utf8);}
//[aes.js]
/*
CryptoJS v3.0.2
code.google.com/p/crypto-js
(c) 2009-2012 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
var CryptoJS=CryptoJS||function(p,h){var i={},l=i.lib={},r=l.Base=function(){function a(){}return{extend:function(e){a.prototype=this;var c=new a;e&&c.mixIn(e);c.$super=this;return c},create:function(){var a=this.extend();a.init.apply(a,arguments);return a},init:function(){},mixIn:function(a){for(var c in a)a.hasOwnProperty(c)&&(this[c]=a[c]);a.hasOwnProperty(“toString”)&&(this.toString=a.toString)},clone:function(){return this.$super.extend(this)}}}(),o=l.WordArray=r.extend({init:function(a,e){a=
this.words=a||[];this.sigBytes=e!=h?e:4*a.length},toString:function(a){return(a||s).stringify(this)},concat:function(a){var e=this.words,c=a.words,b=this.sigBytes,a=a.sigBytes;this.clamp();if(b%4)for(var d=0;d<a;d++)e[b+d>>>2]|=(c[d>>>2]>>>24-8*(d%4)&255)<<24-8*((b+d)%4);else if(65535<c.length)for(d=0;d<a;d+=4)e[b+d>>>2]=c[d>>>2];else e.push.apply(e,c);this.sigBytes+=a;return this},clamp:function(){var a=this.words,e=this.sigBytes;a[e>>>2]&=4294967295<<32-8*(e%4);a.length=p.ceil(e/4)},clone:function(){var a=
r.clone.call(this);a.words=this.words.slice(0);return a},random:function(a){for(var e=[],c=0;c<a;c+=4)e.push(4294967296*p.random()|0);return o.create(e,a)}}),m=i.enc={},s=m.Hex={stringify:function(a){for(var e=a.words,a=a.sigBytes,c=[],b=0;b<a;b++){var d=e[b>>>2]>>>24-8*(b%4)&255;c.push((d>>>4).toString(16));c.push((d&15).toString(16))}return c.join(“”)},parse:function(a){for(var e=a.length,c=[],b=0;b<e;b+=2)c[b>>>3]|=parseInt(a.substr(b,2),16)<<24-4*(b%8);return o.create(c,e/2)}},n=m.Latin1={stringify:function(a){for(var e=
a.words,a=a.sigBytes,c=[],b=0;b<a;b++)c.push(String.fromCharCode(e[b>>>2]>>>24-8*(b%4)&255));return c.join(“”)},parse:function(a){for(var e=a.length,c=[],b=0;b<e;b++)c[b>>>2]|=(a.charCodeAt(b)&255)<<24-8*(b%4);return o.create(c,e)}},k=m.Utf8={stringify:function(a){try{return decodeURIComponent(escape(n.stringify(a)))}catch(e){throw Error(“Malformed UTF-8 data”);}},parse:function(a){return n.parse(unescape(encodeURIComponent(a)))}},f=l.BufferedBlockAlgorithm=r.extend({reset:function(){this._data=o.create();
this._nDataBytes=0},_append:function(a){“string”==typeof a&&(a=k.parse(a));this._data.concat(a);this._nDataBytes+=a.sigBytes},_process:function(a){var e=this._data,c=e.words,b=e.sigBytes,d=this.blockSize,q=b/(4*d),q=a?p.ceil(q):p.max((q|0)-this._minBufferSize,0),a=q*d,b=p.min(4*a,b);if(a){for(var j=0;j<a;j+=d)this._doProcessBlock(c,j);j=c.splice(0,a);e.sigBytes-=b}return o.create(j,b)},clone:function(){var a=r.clone.call(this);a._data=this._data.clone();return a},_minBufferSize:0});l.Hasher=f.extend({init:function(){this.reset()},
reset:function(){f.reset.call(this);this._doReset()},update:function(a){this._append(a);this._process();return this},finalize:function(a){a&&this._append(a);this._doFinalize();return this._hash},clone:function(){var a=f.clone.call(this);a._hash=this._hash.clone();return a},blockSize:16,_createHelper:function(a){return function(e,c){return a.create(c).finalize(e)}},_createHmacHelper:function(a){return function(e,c){return g.HMAC.create(a,c).finalize(e)}}});var g=i.algo={};return i}(Math);
(function(){var p=CryptoJS,h=p.lib.WordArray;p.enc.Base64={stringify:function(i){var l=i.words,h=i.sigBytes,o=this._map;i.clamp();for(var i=[],m=0;m<h;m+=3)for(var s=(l[m>>>2]>>>24-8*(m%4)&255)<<16|(l[m+1>>>2]>>>24-8*((m+1)%4)&255)<<8|l[m+2>>>2]>>>24-8*((m+2)%4)&255,n=0;4>n&&m+0.75*n<h;n++)i.push(o.charAt(s>>>6*(3-n)&63));if(l=o.charAt(64))for(;i.length%4;)i.push(l);return i.join(“”)},parse:function(i){var i=i.replace(/\s/g,””),l=i.length,r=this._map,o=r.charAt(64);o&&(o=i.indexOf(o),-1!=o&&(l=o));
for(var o=[],m=0,s=0;s<l;s++)if(s%4){var n=r.indexOf(i.charAt(s-1))<<2*(s%4),k=r.indexOf(i.charAt(s))>>>6-2*(s%4);o[m>>>2]|=(n|k)<<24-8*(m%4);m++}return h.create(o,m)},_map:”ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=”}})();
(function(p){function h(f,g,a,e,c,b,d){f=f+(g&a|~g&e)+c+d;return(f<<b|f>>>32-b)+g}function i(f,g,a,e,c,b,d){f=f+(g&e|a&~e)+c+d;return(f<<b|f>>>32-b)+g}function l(f,g,a,e,c,b,d){f=f+(g^a^e)+c+d;return(f<<b|f>>>32-b)+g}function r(f,g,a,e,c,b,d){f=f+(a^(g|~e))+c+d;return(f<<b|f>>>32-b)+g}var o=CryptoJS,m=o.lib,s=m.WordArray,m=m.Hasher,n=o.algo,k=[];(function(){for(var f=0;64>f;f++)k[f]=4294967296*p.abs(p.sin(f+1))|0})();n=n.MD5=m.extend({_doReset:function(){this._hash=s.create([1732584193,4023233417,
2562383102,271733878])},_doProcessBlock:function(f,g){for(var a=0;16>a;a++){var e=g+a,c=f[e];f[e]=(c<<8|c>>>24)&16711935|(c<<24|c>>>8)&4278255360}for(var e=this._hash.words,c=e[0],b=e[1],d=e[2],q=e[3],a=0;64>a;a+=4)16>a?(c=h(c,b,d,q,f[g+a],7,k[a]),q=h(q,c,b,d,f[g+a+1],12,k[a+1]),d=h(d,q,c,b,f[g+a+2],17,k[a+2]),b=h(b,d,q,c,f[g+a+3],22,k[a+3])):32>a?(c=i(c,b,d,q,f[g+(a+1)%16],5,k[a]),q=i(q,c,b,d,f[g+(a+6)%16],9,k[a+1]),d=i(d,q,c,b,f[g+(a+11)%16],14,k[a+2]),b=i(b,d,q,c,f[g+a%16],20,k[a+3])):48>a?(c=
l(c,b,d,q,f[g+(3*a+5)%16],4,k[a]),q=l(q,c,b,d,f[g+(3*a+8)%16],11,k[a+1]),d=l(d,q,c,b,f[g+(3*a+11)%16],16,k[a+2]),b=l(b,d,q,c,f[g+(3*a+14)%16],23,k[a+3])):(c=r(c,b,d,q,f[g+3*a%16],6,k[a]),q=r(q,c,b,d,f[g+(3*a+7)%16],10,k[a+1]),d=r(d,q,c,b,f[g+(3*a+14)%16],15,k[a+2]),b=r(b,d,q,c,f[g+(3*a+5)%16],21,k[a+3]));e[0]=e[0]+c|0;e[1]=e[1]+b|0;e[2]=e[2]+d|0;e[3]=e[3]+q|0},_doFinalize:function(){var f=this._data,g=f.words,a=8*this._nDataBytes,e=8*f.sigBytes;g[e>>>5]|=128<<24-e%32;g[(e+64>>>9<<4)+14]=(a<<8|a>>>
24)&16711935|(a<<24|a>>>8)&4278255360;f.sigBytes=4*(g.length+1);this._process();f=this._hash.words;for(g=0;4>g;g++)a=f[g],f[g]=(a<<8|a>>>24)&16711935|(a<<24|a>>>8)&4278255360}});o.MD5=m._createHelper(n);o.HmacMD5=m._createHmacHelper(n)})(Math);
(function(){var p=CryptoJS,h=p.lib,i=h.Base,l=h.WordArray,h=p.algo,r=h.EvpKDF=i.extend({cfg:i.extend({keySize:4,hasher:h.MD5,iterations:1}),init:function(i){this.cfg=this.cfg.extend(i)},compute:function(i,m){for(var h=this.cfg,n=h.hasher.create(),k=l.create(),f=k.words,g=h.keySize,h=h.iterations;f.length<g;){a&&n.update(a);var a=n.update(i).finalize(m);n.reset();for(var e=1;e<h;e++)a=n.finalize(a),n.reset();k.concat(a)}k.sigBytes=4*g;return k}});p.EvpKDF=function(i,l,h){return r.create(h).compute(i,
l)}})();
CryptoJS.lib.Cipher||function(p){var h=CryptoJS,i=h.lib,l=i.Base,r=i.WordArray,o=i.BufferedBlockAlgorithm,m=h.enc.Base64,s=h.algo.EvpKDF,n=i.Cipher=o.extend({cfg:l.extend(),createEncryptor:function(b,d){return this.create(this._ENC_XFORM_MODE,b,d)},createDecryptor:function(b,d){return this.create(this._DEC_XFORM_MODE,b,d)},init:function(b,d,a){this.cfg=this.cfg.extend(a);this._xformMode=b;this._key=d;this.reset()},reset:function(){o.reset.call(this);this._doReset()},process:function(b){this._append(b);return this._process()},
finalize:function(b){b&&this._append(b);return this._doFinalize()},keySize:4,ivSize:4,_ENC_XFORM_MODE:1,_DEC_XFORM_MODE:2,_createHelper:function(){return function(b){return{encrypt:function(a,q,j){return(“string”==typeof q?c:e).encrypt(b,a,q,j)},decrypt:function(a,q,j){return(“string”==typeof q?c:e).decrypt(b,a,q,j)}}}}()});i.StreamCipher=n.extend({_doFinalize:function(){return this._process(!0)},blockSize:1});var k=h.mode={},f=i.BlockCipherMode=l.extend({createEncryptor:function(b,a){return this.Encryptor.create(b,
a)},createDecryptor:function(b,a){return this.Decryptor.create(b,a)},init:function(b,a){this._cipher=b;this._iv=a}}),k=k.CBC=function(){function b(b,a,d){var c=this._iv;c?this._iv=p:c=this._prevBlock;for(var e=0;e<d;e++)b[a+e]^=c[e]}var a=f.extend();a.Encryptor=a.extend({processBlock:function(a,d){var c=this._cipher,e=c.blockSize;b.call(this,a,d,e);c.encryptBlock(a,d);this._prevBlock=a.slice(d,d+e)}});a.Decryptor=a.extend({processBlock:function(a,d){var c=this._cipher,e=c.blockSize,f=a.slice(d,d+
e);c.decryptBlock(a,d);b.call(this,a,d,e);this._prevBlock=f}});return a}(),g=(h.pad={}).Pkcs7={pad:function(b,a){for(var c=4*a,c=c-b.sigBytes%c,e=c<<24|c<<16|c<<8|c,f=[],g=0;g<c;g+=4)f.push(e);c=r.create(f,c);b.concat(c)},unpad:function(b){b.sigBytes-=b.words[b.sigBytes-1>>>2]&255}};i.BlockCipher=n.extend({cfg:n.cfg.extend({mode:k,padding:g}),reset:function(){n.reset.call(this);var b=this.cfg,a=b.iv,b=b.mode;if(this._xformMode==this._ENC_XFORM_MODE)var c=b.createEncryptor;else c=b.createDecryptor,
this._minBufferSize=1;this._mode=c.call(b,this,a&&a.words)},_doProcessBlock:function(b,a){this._mode.processBlock(b,a)},_doFinalize:function(){var b=this.cfg.padding;if(this._xformMode==this._ENC_XFORM_MODE){b.pad(this._data,this.blockSize);var a=this._process(!0)}else a=this._process(!0),b.unpad(a);return a},blockSize:4});var a=i.CipherParams=l.extend({init:function(a){this.mixIn(a)},toString:function(a){return(a||this.formatter).stringify(this)}}),k=(h.format={}).OpenSSL={stringify:function(a){var d=
a.ciphertext,a=a.salt,d=(a?r.create([1398893684,1701076831]).concat(a).concat(d):d).toString(m);return d=d.replace(/(.{64})/g,”$1\n”)},parse:function(b){var b=m.parse(b),d=b.words;if(1398893684==d[0]&&1701076831==d[1]){var c=r.create(d.slice(2,4));d.splice(0,4);b.sigBytes-=16}return a.create({ciphertext:b,salt:c})}},e=i.SerializableCipher=l.extend({cfg:l.extend({format:k}),encrypt:function(b,d,c,e){var e=this.cfg.extend(e),f=b.createEncryptor(c,e),d=f.finalize(d),f=f.cfg;return a.create({ciphertext:d,
key:c,iv:f.iv,algorithm:b,mode:f.mode,padding:f.padding,blockSize:b.blockSize,formatter:e.format})},decrypt:function(a,c,e,f){f=this.cfg.extend(f);c=this._parse(c,f.format);return a.createDecryptor(e,f).finalize(c.ciphertext)},_parse:function(a,c){return”string”==typeof a?c.parse(a):a}}),h=(h.kdf={}).OpenSSL={compute:function(b,c,e,f){f||(f=r.random(8));b=s.create({keySize:c+e}).compute(b,f);e=r.create(b.words.slice(c),4*e);b.sigBytes=4*c;return a.create({key:b,iv:e,salt:f})}},c=i.PasswordBasedCipher=
e.extend({cfg:e.cfg.extend({kdf:h}),encrypt:function(a,c,f,j){j=this.cfg.extend(j);f=j.kdf.compute(f,a.keySize,a.ivSize);j.iv=f.iv;a=e.encrypt.call(this,a,c,f.key,j);a.mixIn(f);return a},decrypt:function(a,c,f,j){j=this.cfg.extend(j);c=this._parse(c,j.format);f=j.kdf.compute(f,a.keySize,a.ivSize,c.salt);j.iv=f.iv;return e.decrypt.call(this,a,c,f.key,j)}})}();
(function(){var p=CryptoJS,h=p.lib.BlockCipher,i=p.algo,l=[],r=[],o=[],m=[],s=[],n=[],k=[],f=[],g=[],a=[];(function(){for(var c=[],b=0;256>b;b++)c[b]=128>b?b<<1:b<<1^283;for(var d=0,e=0,b=0;256>b;b++){var j=e^e<<1^e<<2^e<<3^e<<4,j=j>>>8^j&255^99;l[d]=j;r[j]=d;var i=c[d],h=c[i],p=c[h],t=257*c[j]^16843008*j;o[d]=t<<24|t>>>8;m[d]=t<<16|t>>>16;s[d]=t<<8|t>>>24;n[d]=t;t=16843009*p^65537*h^257*i^16843008*d;k[j]=t<<24|t>>>8;f[j]=t<<16|t>>>16;g[j]=t<<8|t>>>24;a[j]=t;d?(d=i^c[c[c[p^i]]],e^=c[c[e]]):d=e=1}})();
var e=[0,1,2,4,8,16,32,64,128,27,54],i=i.AES=h.extend({_doReset:function(){for(var c=this._key,b=c.words,d=c.sigBytes/4,c=4*((this._nRounds=d+6)+1),i=this._keySchedule=[],j=0;j<c;j++)if(j<d)i[j]=b[j];else{var h=i[j-1];j%d?6<d&&4==j%d&&(h=l[h>>>24]<<24|l[h>>>16&255]<<16|l[h>>>8&255]<<8|l[h&255]):(h=h<<8|h>>>24,h=l[h>>>24]<<24|l[h>>>16&255]<<16|l[h>>>8&255]<<8|l[h&255],h^=e[j/d|0]<<24);i[j]=i[j-d]^h}b=this._invKeySchedule=[];for(d=0;d<c;d++)j=c-d,h=d%4?i[j]:i[j-4],b[d]=4>d||4>=j?h:k[l[h>>>24]]^f[l[h>>>
16&255]]^g[l[h>>>8&255]]^a[l[h&255]]},encryptBlock:function(a,b){this._doCryptBlock(a,b,this._keySchedule,o,m,s,n,l)},decryptBlock:function(c,b){var d=c[b+1];c[b+1]=c[b+3];c[b+3]=d;this._doCryptBlock(c,b,this._invKeySchedule,k,f,g,a,r);d=c[b+1];c[b+1]=c[b+3];c[b+3]=d},_doCryptBlock:function(a,b,d,e,f,h,i,g){for(var l=this._nRounds,k=a[b]^d[0],m=a[b+1]^d[1],o=a[b+2]^d[2],n=a[b+3]^d[3],p=4,r=1;r<l;r++)var s=e[k>>>24]^f[m>>>16&255]^h[o>>>8&255]^i[n&255]^d[p++],u=e[m>>>24]^f[o>>>16&255]^h[n>>>8&255]^
i[k&255]^d[p++],v=e[o>>>24]^f[n>>>16&255]^h[k>>>8&255]^i[m&255]^d[p++],n=e[n>>>24]^f[k>>>16&255]^h[m>>>8&255]^i[o&255]^d[p++],k=s,m=u,o=v;s=(g[k>>>24]<<24|g[m>>>16&255]<<16|g[o>>>8&255]<<8|g[n&255])^d[p++];u=(g[m>>>24]<<24|g[o>>>16&255]<<16|g[n>>>8&255]<<8|g[k&255])^d[p++];v=(g[o>>>24]<<24|g[n>>>16&255]<<16|g[k>>>8&255]<<8|g[m&255])^d[p++];n=(g[n>>>24]<<24|g[k>>>16&255]<<16|g[m>>>8&255]<<8|g[o&255])^d[p++];a[b]=s;a[b+1]=u;a[b+2]=v;a[b+3]=n},keySize:8});p.AES=h._createHelper(i)})();
//[pbkdf2.js]
/*
CryptoJS v3.0.2
code.google.com/p/crypto-js
(c) 2009-2012 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
var CryptoJS=CryptoJS||function(g,i){var f={},b=f.lib={},m=b.Base=function(){function a(){}return{extend:function(e){a.prototype=this;var c=new a;e&&c.mixIn(e);c.$super=this;return c},create:function(){var a=this.extend();a.init.apply(a,arguments);return a},init:function(){},mixIn:function(a){for(var c in a)a.hasOwnProperty(c)&&(this[c]=a[c]);a.hasOwnProperty(“toString”)&&(this.toString=a.toString)},clone:function(){return this.$super.extend(this)}}}(),l=b.WordArray=m.extend({init:function(a,e){a=
this.words=a||[];this.sigBytes=e!=i?e:4*a.length},toString:function(a){return(a||d).stringify(this)},concat:function(a){var e=this.words,c=a.words,o=this.sigBytes,a=a.sigBytes;this.clamp();if(o%4)for(var b=0;b<a;b++)e[o+b>>>2]|=(c[b>>>2]>>>24-8*(b%4)&255)<<24-8*((o+b)%4);else if(65535<c.length)for(b=0;b<a;b+=4)e[o+b>>>2]=c[b>>>2];else e.push.apply(e,c);this.sigBytes+=a;return this},clamp:function(){var a=this.words,e=this.sigBytes;a[e>>>2]&=4294967295<<32-8*(e%4);a.length=g.ceil(e/4)},clone:function(){var a=
m.clone.call(this);a.words=this.words.slice(0);return a},random:function(a){for(var e=[],c=0;c<a;c+=4)e.push(4294967296*g.random()|0);return l.create(e,a)}}),n=f.enc={},d=n.Hex={stringify:function(a){for(var e=a.words,a=a.sigBytes,c=[],b=0;b<a;b++){var d=e[b>>>2]>>>24-8*(b%4)&255;c.push((d>>>4).toString(16));c.push((d&15).toString(16))}return c.join(“”)},parse:function(a){for(var e=a.length,c=[],b=0;b<e;b+=2)c[b>>>3]|=parseInt(a.substr(b,2),16)<<24-4*(b%8);return l.create(c,e/2)}},j=n.Latin1={stringify:function(a){for(var e=
a.words,a=a.sigBytes,b=[],d=0;d<a;d++)b.push(String.fromCharCode(e[d>>>2]>>>24-8*(d%4)&255));return b.join(“”)},parse:function(a){for(var b=a.length,c=[],d=0;d<b;d++)c[d>>>2]|=(a.charCodeAt(d)&255)<<24-8*(d%4);return l.create(c,b)}},k=n.Utf8={stringify:function(a){try{return decodeURIComponent(escape(j.stringify(a)))}catch(b){throw Error(“Malformed UTF-8 data”);}},parse:function(a){return j.parse(unescape(encodeURIComponent(a)))}},h=b.BufferedBlockAlgorithm=m.extend({reset:function(){this._data=l.create();
this._nDataBytes=0},_append:function(a){“string”==typeof a&&(a=k.parse(a));this._data.concat(a);this._nDataBytes+=a.sigBytes},_process:function(a){var b=this._data,c=b.words,d=b.sigBytes,j=this.blockSize,h=d/(4*j),h=a?g.ceil(h):g.max((h|0)-this._minBufferSize,0),a=h*j,d=g.min(4*a,d);if(a){for(var f=0;f<a;f+=j)this._doProcessBlock(c,f);f=c.splice(0,a);b.sigBytes-=d}return l.create(f,d)},clone:function(){var a=m.clone.call(this);a._data=this._data.clone();return a},_minBufferSize:0});b.Hasher=h.extend({init:function(){this.reset()},
reset:function(){h.reset.call(this);this._doReset()},update:function(a){this._append(a);this._process();return this},finalize:function(a){a&&this._append(a);this._doFinalize();return this._hash},clone:function(){var a=h.clone.call(this);a._hash=this._hash.clone();return a},blockSize:16,_createHelper:function(a){return function(b,c){return a.create(c).finalize(b)}},_createHmacHelper:function(a){return function(b,c){return u.HMAC.create(a,c).finalize(b)}}});var u=f.algo={};return f}(Math);
(function(){var g=CryptoJS,i=g.lib,f=i.WordArray,i=i.Hasher,b=[],m=g.algo.SHA1=i.extend({_doReset:function(){this._hash=f.create([1732584193,4023233417,2562383102,271733878,3285377520])},_doProcessBlock:function(f,n){for(var d=this._hash.words,j=d[0],k=d[1],h=d[2],g=d[3],a=d[4],e=0;80>e;e++){if(16>e)b[e]=f[n+e]|0;else{var c=b[e-3]^b[e-8]^b[e-14]^b[e-16];b[e]=c<<1|c>>>31}c=(j<<5|j>>>27)+a+b[e];c=20>e?c+((k&h|~k&g)+1518500249):40>e?c+((k^h^g)+1859775393):60>e?c+((k&h|k&g|h&g)-1894007588):c+((k^h^g)-
899497514);a=g;g=h;h=k<<30|k>>>2;k=j;j=c}d[0]=d[0]+j|0;d[1]=d[1]+k|0;d[2]=d[2]+h|0;d[3]=d[3]+g|0;d[4]=d[4]+a|0},_doFinalize:function(){var b=this._data,f=b.words,d=8*this._nDataBytes,j=8*b.sigBytes;f[j>>>5]|=128<<24-j%32;f[(j+64>>>9<<4)+15]=d;b.sigBytes=4*f.length;this._process()}});g.SHA1=i._createHelper(m);g.HmacSHA1=i._createHmacHelper(m)})();
(function(){var g=CryptoJS,i=g.enc.Utf8;g.algo.HMAC=g.lib.Base.extend({init:function(f,b){f=this._hasher=f.create();”string”==typeof b&&(b=i.parse(b));var g=f.blockSize,l=4*g;b.sigBytes>l&&(b=f.finalize(b));for(var n=this._oKey=b.clone(),d=this._iKey=b.clone(),j=n.words,k=d.words,h=0;h<g;h++)j[h]^=1549556828,k[h]^=909522486;n.sigBytes=d.sigBytes=l;this.reset()},reset:function(){var f=this._hasher;f.reset();f.update(this._iKey)},update:function(f){this._hasher.update(f);return this},finalize:function(f){var b=
this._hasher,f=b.finalize(f);b.reset();return b.finalize(this._oKey.clone().concat(f))}})})();
(function(){var g=CryptoJS,i=g.lib,f=i.Base,b=i.WordArray,i=g.algo,m=i.HMAC,l=i.PBKDF2=f.extend({cfg:f.extend({keySize:4,hasher:i.SHA1,iterations:1}),init:function(b){this.cfg=this.cfg.extend(b)},compute:function(f,d){for(var g=this.cfg,k=m.create(g.hasher,f),h=b.create(),i=b.create([1]),a=h.words,e=i.words,c=g.keySize,g=g.iterations;a.length<c;){var l=k.update(d).finalize(i);k.reset();for(var q=l.words,t=q.length,r=l,s=1;s<g;s++){r=k.finalize(r);k.reset();for(var v=r.words,p=0;p<t;p++)q[p]^=v[p]}h.concat(l);
e[0]++}h.sigBytes=4*c;return h}});g.PBKDF2=function(b,d,f){return l.create(f).compute(b,d)}})();

<!DOCTYPE html>
<html>
<head>
<title>AES128 Example</title>
<meta charset=”UTF-8″>
<meta name=”viewport” content=”width=device-width, user-scalable=no” />
<link rel=”stylesheet” href=”/css/base.css”>
<script type=”text/javascript” src=”aes_util.js”></script>
<script type=”text/javascript”>

var g_keySize = 128;
var g_iterationCount = 10000;
var g_salt = “79752f1d3fd2432043c48e45b35b24645eb826a25c6f1804e9152665c345a552”;
var g_iv = “2fad5a477d13ecda7f718fbd8a9f0443”;
var g_passPhrase = “passPhrase”;

window.onload = function() {
    
    try {
        var resultDiv = document.getElementById(“resultDiv”);
        
        var aesUtil = new AesUtil(g_keySize, g_iterationCount);
        var encString = aesUtil.encrypt(g_salt, g_iv, g_passPhrase, “pass1234”);
        var decString = aesUtil.decrypt(g_salt, g_iv, g_passPhrase, encString);
        
        resultDiv.innerHTML = “encString : “ + encString + “<br>” + “decString : “ + decString;

​

    } catch (e) {
        alert(e);
        return false;
    }

}
</script>
</head>
<body>
 AES128 Example
 <br>
 <div id=”resultDiv”></div>
</body>
</html>

<!– https://mvnrepository.com/artifact/commons-codec/commons-codec –>
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.10</version>
</dependency>

package com.bb;

import java.security.SecureRandom;
import java.security.spec.KeySpec;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;

public class AesUtil {

    private static final int keySize = 128;
    private static final int iterationCount = 10000;
    private static String salt = “79752f1d3fd2432043c48e45b35b24645eb826a25c6f1804e9152665c345a552”;
    private static String iv = “2fad5a477d13ecda7f718fbd8a9f0443”;
    private static final String passPhrase = “passPhrase”;
    
    private final Cipher cipher;
    
    
    public AesUtil() {
        try {
            cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    
    public String encrypt(String plaintext) throws Exception {
        return encrypt(salt, iv, passPhrase, plaintext);
    }
    
    
    public String decrypt(String ciphertext) throws Exception {
        return decrypt(salt, iv, passPhrase, ciphertext);
    }
    
    
    private String encrypt(String salt, String iv, String passPhrase, String plaintext) throws Exception {
        SecretKey key = generateKey(salt, passPhrase);
        byte[] encrypted = doFinal(Cipher.ENCRYPT_MODE, key, iv, plaintext.getBytes(“UTF-8”));
        return encodeBase64(encrypted);
    }

    
    private String decrypt(String salt, String iv, String passPhrase, String ciphertext) throws Exception {
        SecretKey key = generateKey(salt, passPhrase);
        byte[] decrypted = doFinal(Cipher.DECRYPT_MODE, key, iv, decodeBase64(ciphertext));
        return new String(decrypted, “UTF-8”);
    }

    
    private byte[] doFinal(int encryptMode, SecretKey key, String iv, byte[] bytes) throws Exception {
        cipher.init(encryptMode, key, new IvParameterSpec(decodeHex(iv)));
        return cipher.doFinal(bytes);
    }

    
    private SecretKey generateKey(String salt, String passPhrase) throws Exception {
        SecretKeyFactory factory = SecretKeyFactory.getInstance(“PBKDF2WithHmacSHA1”);
        KeySpec spec = new PBEKeySpec(passPhrase.toCharArray(), decodeHex(salt), iterationCount, keySize);
        SecretKey key = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), “AES”);
        return key;
    }
    
    
    private static String encodeBase64(byte[] bytes) {
        return Base64.encodeBase64String(bytes);
    }

    
    private static byte[] decodeBase64(String str) {
        return Base64.decodeBase64(str);
    }

    
    private static String encodeHex(byte[] bytes) {
        return Hex.encodeHexString(bytes);
    }

    
    private static byte[] decodeHex(String str) throws Exception {
        return Hex.decodeHex(str.toCharArray());
    }
    
    
    private static String getRandomHexString(int length) {
        byte[] salt = new byte[length];
        new SecureRandom().nextBytes(salt);
        return encodeHex(salt);

    }
}

salt = getRandomHexString(32);
iv = getRandomHexString(16);

package com.bb;

public class AES128Test {

    public static void main(String[] args) {
        try {
            AesUtil aesUtil = new AesUtil();
            
            String encString = aesUtil.encrypt(“pass1234”);
            System.out.println(“encString : “ + encString);
            
            String decString = aesUtil.decrypt(encString);
            System.out.println(“decString : “ + decString);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

우분투에서 tomcat8로 자바 프로젝트 띄우기 1/2 : 톰캣을 띄워보자

http://blog.naver.com/bb_/220907952848

Sub 매크로1()
‘
‘ 매크로1 매크로
‘
‘ 바로 가기 키: Ctrl+k
‘

Call writeTextFile

End Sub

Function writeTextFile()
    
    On Error GoTo exmsg
    
    MsgBox (“파일쓰기 시작”)
    
    ‘파일 경로 지정
    Dim path
    path = “C:\test\test.txt”
    

    ‘Open path For Append As #1 일 경우 이어쓰기
    Open path For Output As #1
        Print #1, “첫번째 라인”
        Print #1, “두번째 라인”
        Print #1, “세번째 라인”
    Close #1
    
    MsgBox (“파일쓰기 끝”)
    Exit Function
    
exmsg:
    Close #1
    MsgBox (“Error” & Err.Number & ” : ” & Err.Description)

End Function

Sub 매크로1()
‘
‘ 매크로1 매크로
‘
‘ 바로 가기 키: Ctrl+k
‘

Call readTextFile

End Sub

Function readTextFile()
    
    On Error GoTo exmsg
    
    MsgBox (“파일읽기 시작”)
    
    ‘파일 경로 지정
    Dim path
    path = “C:\test\test.txt”
    
    Dim lineNum
    lineNum = 1
    
    Dim lineValue As String

    Open path For Input As #1
        Do While Not EOF(1)
            Line Input #1, lineValue
            Cells(lineNum, 1).Value = lineValue
            lineNum = lineNum + 1
        Loop
    Close #1
    
    MsgBox (“파일읽기 끝”)
    Exit Function
    
exmsg:
    Close #1
    MsgBox (“Error” & Err.Number & ” : ” & Err.Description)

End Function

​Const CP_UTF8 = 65001
Private Declare Function MultiByteToWideChar Lib “kernel32” (ByVal CodePage As Long, ByVal dwFlags As Long, ByVal lpMultiByteStr As Long, ByVal cchMultiByte As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long) As Long

Sub 매크로1()
‘
‘ 매크로1 매크로
‘
‘ 바로 가기 키: Ctrl+k
‘

Call readTextFile

End Sub

Function readTextFile()
    
    On Error GoTo exmsg
    
    MsgBox (“파일읽기 시작”)
    
    ‘파일 경로 지정
    Dim path
    path = “C:\test\test.txt”
    
    Dim utf8() As Byte
    Dim ucs2 As String
    Dim chars As Long
   
    Open path For Binary As #1
    ReDim utf8(LOF(1))
   
    Get #1, , utf8
   
    chars = MultiByteToWideChar(CP_UTF8, 0, VarPtr(utf8(0)), LOF(1), 0, 0)
    ucs2 = Space(chars)
   
    chars = MultiByteToWideChar(CP_UTF8, 0, VarPtr(utf8(0)), LOF(1), StrPtr(ucs2), chars)
    
    Close
    

    ‘엔터를 구분자로 Split 하기
    Dim tArray
    tArray = Split(ucs2 + “”, vbCrLf, , vbTextCompare)
   
    ‘파일 내용 표시
    For i = 0 To UBound(tArray)
        Cells(i + 1, 1).Value = tArray(i) + “”
    Next i

   
    MsgBox (“파일읽기 끝”)
    Exit Function
    
exmsg:
    Close #1
    MsgBox (“Error” & Err.Number & ” : ” & Err.Description)

End Function

Sub 매크로1()
‘
‘ 매크로1 매크로
‘ 바로 가기 키: Ctrl+k
‘
    Call doTest

End Sub

Function doTest()

    Dim a
    a = 10 / 0

    MsgBox (“함수의 끝”)

End Function

Function doTest()
​

    On Error Resume Next
    Dim a
    a = 10 / 0

    MsgBox (“함수의 끝”)

End Function

Function doTest()
 
    ‘에러 발생시 aaaaa 레이블로 이동(GoTo)
    On Error GoTo aaaaa

    Dim a
    a = 10 / 0
        
    ‘함수의 끝
    Exit Function 

aaaaa:
    MsgBox (“에러가 났어요!”)
    
End Function

MsgBox  (“에러코드 ” & Err.Number & ” 발생 : ” & Err.Description)

File file = new File(“pdf파일의위치”);
PDDocument document = PDDocument.load(file);

int pageCount = document.getNumberOfPages();

PDFRenderer pdfRenderer = new PDFRenderer(document);

// 0 페이지를 JPG파일로 저장
BufferedImage imageObj = pdfRenderer.renderImageWithDPI(0, 100, ImageType.RGB);
File outputfile = new File(“저장할jpg파일경로지정”);
ImageIO.write(imageObj, “jpg”, outputfile);

// 1 페이지를 JPG파일로 저장
BufferedImage imageObj = pdfRenderer.renderImageWithDPI(1, 100, ImageType.RGB);
File outputfile = new File(“저장할jpg파일경로지정”);
ImageIO.write(imageObj, “jpg”, outputfile);

// 2 페이지를 JPG파일로 저장
BufferedImage imageObj = pdfRenderer.renderImageWithDPI(2, 100, ImageType.RGB);
File outputfile = new File(“저장할jpg파일경로지정”);
ImageIO.write(imageObj, “jpg”, outputfile);

… (후략)

if (document != null) {
    document.close();
}

PDDocument document = new PDDocument();

// 추가할 JPG 파일 읽기
File oneFile = new File(“추가할JPG파일경로지정”);
InputStream inputStream = new FileInputStream(oneFile);
BufferedImage bufferedImage = ImageIO.read(inputStream);
float width = bufferedImage.getWidth();
float height = bufferedImage.getHeight();

// PDF 페이지 객체 1장 생성
PDPage page = new PDPage(new PDRectangle(width, height));
document.addPage(page);

// PDF 문서 객체에 페이지 1장 그리기
PDImageXObject pdImage = PDImageXObject.createFromFile(oneFile.getAbsolutePath(), document);
PDPageContentStream contentStream = new PDPageContentStream(document, page);
contentStream.drawImage(pdImage, 0, 0, width, height);

// 1장 그릴 때마다 사용한 객체 닫기

if (contentStream != null) {
    contentStream.close();
}

if (inputStream != null) {
    inputStream.close();
}

document.save(“결과PDF파일경로지정”);

if (document != null) {
    document.close();
}