Dev Story..

설정 순서는 아래와 같다.

- Maven Dependency 설정

- Ehcache.xml작성(ehcache 설정파일)

- CacheManager 설정 (xml)

Maven Dependency 설정

<!-- EHCache 모듈 -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.6</version> 
</dependency>

<!-- Spring Caching Interface -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>

<!-- EHCache Support 모듈, 다른 Caching 지원모듈 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.20.RELEASE</version>
</dependency>

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         maxBytesLocalHeap="300M" <!-- CacheManager에 의해 관리되는 캐시의 메모리를 300M로 제한 -->
         updateCheck="false">

    <!-- 임시저장 경로를 설정 -->
    <diskStore path="java.io.tmpdir" />
    <!-- 
        Cache에 저장할 레퍼런스의 최대값을 100000으로 지정,
        maxDepthExceededBehavior = "continue" :  초과 된 최대 깊이에 대해 경고하지만 크기가 조정 된 요소를 계속 탐색
        maxDepthExceededBehavior = "abort" : 순회를 중지하고 부분적으로 계산 된 크기를 즉시 반환
    -->
    <sizeOfPolicy maxDepth="100000" maxDepthExceededBehavior="continue"/>

   <!-- default Cache 설정 (반드시 선언해야 하는 Cache) -->
    <defaultCache
            eternal="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="1200"
            overflowToDisk="false"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>

    <!-- 사용하고자 하는 캐시 별 설정 -->
    <cache name="LocalCacheData"
           eternal="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="1200"
           overflowToDisk="false"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU">
    </cache>

   <cache name="AuthMemberList"
           eternal="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="1200"
           overflowToDisk="false"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU">
    </cache>
</ehcache>

CacheManager Bean 설정

<!-- Annotation 기반 캐시 사용 (@Cacheable, @CacheEvict..) -->
<cache:annotation-driven/>

<!-- EHCache 기반 CacheManager 설정 -->
<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
    <property name="cacheManager" ref="ehcache"/>
</bean>

<!-- ehcache.xml 설정 로드 -->
<bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
    <property name="configLocation" value="classpath:config/ehcache.xml"/>
    <property name="shared" value="true"/>
</bean>

<test>
    <case id='1'>
        <param>100</param>
        <expected>mkyong</expected>
    </case>
    <case id='2'>
        <param>99</param>
        <expected>mkyong</expected>
    </case>
</test>

package com.test;

import org.apache.commons.io.IOUtils;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

public class ApplicationTest {

    @DisplayName("Test loading XML")
    @Test
    void loadXMLTest() {

        ClassLoader classLoader = getClass().getClassLoader();

        try (InputStream inputStream = classLoader.getResourceAsStream("xml/data.xml")) {

            String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
            System.out.println(result);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.InputStream;
import java.util.Properties;
 
public class ResourceLoadTestMain {
 
private String getResource() {
  InputStream is = getClass().getResourceAsStream("/main/resources/applicationResources.properties");
  Properties props = new Properties();
  try {
  props.load(is);
  } catch (Exception e) {
// TODO: handle exception
}
return props.get("file.target").toString();
}

public static void main(String argv[]) {
 
ResourceLoadTestMain main = new ResourceLoadTestMain ();

String[] strArr = main.getResource().split(",");
for(String str : strArr) {
System.out.println(str);
}
System.out.println();

}
}

업무를 진행하다가 오랜만에 XML을 파싱할 일이 생겨서 예제를 만들어본다.

우선 샘플로 사용할 sample.xml이다.

<?xml version="1.0" encoding="utf-8" ?>
<in>
	<propertie name="cnt_1"></propertie>
	<record name="record_1" ref="cnt_1">
		<propertie length="1"></propertie>
		<propertie length="2"></propertie>
	</record>
	<propertie name="cnt_2"></propertie>
	<record name="record_2" ref="cnt_2">
		<propertie length="1"></propertie>
		<propertie length="2"></propertie>
		<propertie length="3"></propertie>
		<propertie length="4"></propertie>
		<propertie length="5"></propertie>
		<propertie length="6"></propertie>
	</record>
</in>

다음으로는 JAVA소스다.

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
 
public class XmlParsingTestMain {
 
	public static void main(String argv[]) {
 
		try {
			File file = new File("sample.xml");
			
			DocumentBuilderFactory docBuildFact = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuild = docBuildFact.newDocumentBuilder();
			Document doc = docBuild.parse(file);
			doc.getDocumentElement().normalize();
 
			System.out.println("Root element : " + doc.getDocumentElement().getNodeName());
			System.out.println();
 
			NodeList nodeList = doc.getElementsByTagName("in");
			List<Object> inList = new ArrayList<Object>();
 
			System.out.println("nodeList.getLength() ::: " + nodeList.getLength());
			
			nodeList = nodeList.item(0).getChildNodes();
			
			for (int i = 0; i < nodeList.getLength(); i++) {
 
				Node node = nodeList.item(i);
 
				System.out.println("---------- nodeList "+ i + "번째 ------------------");
				
				if (node.getNodeType() == Node.ELEMENT_NODE) {
					// node엘리먼트 
					Element element = (Element)node;
 
					// node 명
					System.out.println("node name : " + node.getNodeName());
					
					Map<String, Object> map = new HashMap<String, Object>();
					
					
					if(!element.getAttribute("name").equals("")) {
						map.put("name", element.getAttribute("name"));
					}
					
					if(!element.getAttribute("ref").equals("")) {
						map.put("ref", element.getAttribute("ref"));
					}
					
					inList.add(map);
					
					if(node.getNodeName().equals("record")) {
						NodeList dataList = node.getChildNodes();
						
						List<Map<String, Object>> inList2 = new ArrayList<Map<String, Object>>();
						
						System.out.println("dataList.getLength() ::: " + dataList.getLength());
						for (int j = 0; j < dataList.getLength(); j++) {
							Node node2 = dataList.item(j);
							if (node2.getNodeType() == Node.ELEMENT_NODE) {
								Element ele2 = (Element) node2;
								Map<String, Object> map2 = new HashMap<String, Object>();
								
								map2.put("ref", ele2.getAttribute("ref"));
								map2.put("length", ele2.getAttribute("length"));
								
								inList2.add(map2);
							}
						}
						map.put("record", inList2);
					}
				}
 
				System.out.println("---------------------------------------------");
			}
			
			System.out.println(inList);
			for(Object node : inList) {
				if(node instanceof Map) {
					System.out.println(node);
				} else if (node instanceof List) {
					List<Map<String, Object>> list = (ArrayList<Map<String, Object>>)node;
					for(Object map : list) {
						System.out.println(map);
					}
				}
			}
 
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

1. 잡코리아, 사람인에 이력서를 작성한 후 이력서를 공개한다.

가장 확실하고, 쉽고, 추천해주고 싶은 방법이다.

본인도 지금까지 모든 프로젝트를 이 방법으로 구했다.

그리고 이력서를 공개할 때 희망급여와 희망근무지역을 선택할 수 있어서 전혀 조건이 맞지 않는 업체들은 사전에 필터링을 할 수 있어서 좋다.

단순 인력만 파견하는 업체에서 가장 연락이 많이 오지만 실질적으로 프로젝트를 수행하는 업체에서 직접 연락이 오기도 한다.

이력서 공개 후에 참고할만한 팁을 몇가지 적어보겠다.

- 먼저 연락오는 곳은 좋지 않은 곳일 확률이 높다.

먼저 연락이 오는 업체는 별로다 라는 인식이 많은데 프리랜서 일자리 구하는데에 있어서 만큼은 틀린 말이다.

인력파견업체는 인력만 넣어주고 끝이기 때문에 임금체불여부만 IT노동이나 잡플래닛 등을 통해서 확인하면 된다.

중요한 것은 고객사와 수행사 프로젝트 내용, 근무조건 등이 중요한 것이다.

- 마음에 들더라도 단가를 꼭 확정한 후 면접일정을 잡자.

하루에 면접 하나만 봐도 뭔가 지치고, 프로젝트 진행중이라면 근무시간에 면접보러가기 눈치가 보이기도 한다.

최대한 헛걸음을 하지 말아야 한다.

만나서 이야기 하자거나 하면 높은 확률로 단가를 깎으려고 할 것이다.

단가부터 확정짓고 나서 면접에서는 프로젝트에 대해 궁금한 거 같은거만 물어보고, 합격여부만 결정하는 편이 좋다고 생각한다.

- 전화를 끊기 전에 꼭 메일로 프로젝트 정보를 보내달라고 하자.

전화가 굉장히 여기저기서 많이 오기 때문에 말로만 듣다보면 헷갈린다.

이메일로 프로젝트 정보를 보내달라고 하면 다들 혼쾌히 보내준다.

- 구직중에는 이메일을 수시로 확인하자.

간혹 전화는 하지 않고, 이메일만 보내는 업체들도 있다.

그럴 경우는 뭔가 성의도 없어 보이고, 하나만 걸려라 식인것 같아서 무시했었는데 꼭 그렇지만도 않은 것 같다.

프로젝트 수십개를 쭈욱 나열해서 보내는 글들은 크게 영양가가 없을수도 있지만

프로젝트 딱 하나만 보낸 메일은 조금 주의깊게 볼 필요가 있다.

의외로 좋은 결과가 따라올수도 있다.

2. OKKY 사이트의 JOBS 게시판을 이용한다.

잡코리아나 사람인과는 다르게 정규직보다는 프리랜서 위주의 구인글이 대부분이라 보기 편하다.

마음에 드는 프로젝트가 있으면 담당자 이메일로 이력서 보내고, 이력서 보냈다고 문자 한통 남겨주자.

이메일을 보내면 씹히는 경우도 많고, 진행해보겠다는 답변이 오기도 한다.

지금까지 여기서 일을 구해본적이 한번도 없지만 프리랜서 프로젝트 정보가 이곳만큼 보기 편하게 정리된 곳도 없기 때문에 일자리 구할 때는 항상 들여다 본다.

3. 잡코리아, 사람인에서 프로젝트를 직접 검색한다.

사람인에서는 근무형태를 계약직/프리랜서로 선택해서 검색하면 어느정도 프리랜서 일자리만 골라서 볼수 있다.

하지만 잡코리아는 일일히 골라서 찾아보던가 검색어를 입력해서 검색해야 한다. (java 프리랜서, java 프로젝트 등)

굉장히 피곤한 방법이고, 쓸데없는 글도 많이 섞여서 보기 불편하다.

이 방법에 너무 힘을 쏟지는 않는 것을 개인적으로 추천한다.

4. 주기적으로 인력업체로 부터 오는 메일, 문자 등을 확인한다.

구직활동을 하다보면 본의 아니게 연락처나 이메일이 여기저기 뿌려지게 된다.

몇몇 인력업체들이 문자나 메일로 본인들이 가지고 있는 프로젝트 정보들을 잔뜩 보내온다.

일이 잘 안구해질땐 한번씩 봐보는 것도 나쁘지 않을 것 같다.

5. 인맥을 통해서 간다.

가끔 이전에 같이 일했던 업체나 동료들에게 같이 일해보지 않겠냐고 연락이 오기도 한다.

하지만 대부분 일하는 중간에 그런 연락들이 오다 보니 인맥을 통해서 가본적이 없다.

인맥을 통해서 가는 것은 그리 쉽지는 않은 방법이라고 생각한다.

위 5가지 방법을 제외하면 프리랜서 일자리 구하는 방법은 거의 없는 것 같다.

간혹 잡코리아, 사람인 외에 다른 구직사이트에도 이력서를 올려야 하냐고 물어보는 사람들이 많은데

잡코리아, 사람인 2개면 충분한 것 같다.

물론 귀찮지 않다면 파인드잡, 인크루트 등등 다른 곳에 올려보는 것도 좋을 것 같다.

마음에 드는 곳이 잘 안구해진다고 너무 조급하게 아무데나 들어가지는 말자.

별로 마음에 들지 않는 곳에 들어갔는데 바로 다음날 마음에 드는 일자리가 나올수도 있다.

package veddan.physicalcores;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

/**
 * Static utility class for finding the number of physical CPU cores.
 */
public class PhysicalCores {

    private static final Logger log = LoggerFactory.getLogger(PhysicalCores.class);

    private static final String OS_NAME = getOSName();

    private PhysicalCores() { }

    /**
     * 

     * Returns the number of "physical" hardware threads available.
     * On a machien with hyper threading, this value may be less than the number
     * reported by {@link Runtime#availableProcessors()}.
     * If you are running on a virtual machine, the value returned will be the
     * number of cores assigned to the VM, not the actual number of physical
     * cores on the machine.
     * Likewise, if the number of cores available to this process is less than the
     * installed number, the available number will be returned.
     * 

     * 

     * The first call to the method may take a long time, especially on Windows.
     * Subsequent calls will return a cached value.
     * The method is threadsafe.
     * 

     * @return number of physical cores, or {@code null} if it could not be determined
     */
    public static Integer physicalCoreCount() {
        return LazyHolder.physicalCoreCount;
    }

    private static class LazyHolder {
        private static final Integer physicalCoreCount = findPhysicalCoreCount();
    }

    private static Integer findPhysicalCoreCount() {
        if (OS_NAME == null) {
            return null;
        }
        if (isLinux()) {
            return readFromProc();
        }
        if (isWindows()) {
            return readFromWMIC();
        }
        if (isMacOsX()) {
            return readFromSysctlOsX();
        }
        if (isFreeBsd()) {
            return readFromSysctlFreeBSD();
        }

        log.warn("Unknown OS \"{}\". Please report this so a case can be added.", OS_NAME);
        return null;
    }

    private static Integer readFromProc() {
        final String path = "/proc/cpuinfo";
        File cpuinfo = new File(path);
        if (!cpuinfo.exists()) {
            log.info("Old Linux without {}. Will not be able to provide core count.", path);
            return null;
        }
        try (InputStream in = new FileInputStream(cpuinfo)) {
            String s = readToString(in, Charset.forName("UTF-8"));
            // Count number of different tuples (physical id, core id) to discard hyper threading and multiple sockets  
            Map<String, Set> physicalIdToCoreId = new HashMap<>();

            int coreIdCount = 0;
            String[] split = s.split("\n");
            String latestPhysicalId = null;
            for (String row : split)
                if (row.startsWith("physical id")) {
                    latestPhysicalId = row;
                    if (physicalIdToCoreId.get(row) == null)
                        physicalIdToCoreId.put(latestPhysicalId, new HashSet());

                } else if (row.startsWith("core id"))
                    // "physical id" row should always come before "core id" row, so that physicalIdToCoreId should
                    // not be null here.
                    physicalIdToCoreId.get(latestPhysicalId).add(row);

            for (Set coreIds : physicalIdToCoreId.values())
                coreIdCount += coreIds.size();

            return coreIdCount;
        } catch (SecurityException | IOException e) {
            String msg = String.format("Error while reading %s", path);
            log.error(msg, e);
        }
        return null;
    }

    private static Integer readFromWMIC() {
        ProcessBuilder pb = new ProcessBuilder("WMIC", "/OUTPUT:STDOUT", "CPU", "Get", "/Format:List");
        pb.redirectErrorStream(true);
        Process wmicProc;
        try {
            wmicProc = pb.start();
            wmicProc.getOutputStream().close();
        } catch (IOException | SecurityException e) {
            log.error("Failed to spawn WMIC process. " +
                      "Will not be able to provide physical core count.", e);
            return null;
        }
        waitFor(wmicProc);
        try (InputStream in = wmicProc.getInputStream()) {
            String wmicOutput = readToString(in, Charset.forName("US-ASCII"));
            return parseWmicOutput(wmicOutput);
        } catch (UnsupportedEncodingException e) {
            // Java implementations are required to support US-ASCII, so this can't happen
            throw new RuntimeException(e);
        } catch (SecurityException | IOException e) {
            log.error("Error while reading WMIC output file", e);
            return null;
        }
    }

    private static Integer parseWmicOutput(String wmicOutput) {
        String[] rows = wmicOutput.split("\n");
        int coreCount = 0;
        for (String row : rows) {
            if (row.startsWith("NumberOfCores")) {
                String num = row.split("=")[1].trim();
                try {
                    coreCount += Integer.parseInt(num);
                } catch (NumberFormatException e) {
                    log.error("Unexpected output from WMIC: \"{}\". " +
                              "Will not be able to provide physical core count.", wmicOutput);
                    return null;
                }
            }
        }
        return coreCount > 0 ? coreCount : null;
    }

    private static Integer readFromSysctlOsX() {
        String result = readSysctl("hw.physicalcpu", "-n");
        if (result == null) {
            return null;
        }
        try {
            return Integer.parseInt(result);
        } catch (NumberFormatException e) {
            log.error("sysctl returned something that was not a number: \"{}\"", result);
            return null;
        }
    }

    private static Integer readFromSysctlFreeBSD() {
        String result = readSysctl("dev.cpu");
        if (result == null) {
            return null;
        }
        Set cpuLocations = new HashSet<>();
        for (String row : result.split("\n")) {
            if (row.contains("location")) {
                cpuLocations.add(row.split("\\\\")[1]);
            }
        }
        return cpuLocations.isEmpty() ? null : cpuLocations.size();
    }

    private static String readSysctl(String variable, String... options) {
        List command = new ArrayList<>();
        command.add("sysctl");
        command.addAll(Arrays.asList(options));
        command.add(variable);
        ProcessBuilder pb = new ProcessBuilder(command);
        pb.redirectErrorStream(true);
        Process sysctlProc;
        try {
            sysctlProc = pb.start();
        } catch (IOException | SecurityException e) {
            log.error("Failed to spawn sysctl process. " +
                      "Will not be able to provide physical core count.", e);
            return null;
        }
        String result;
        try {
            result = readToString(sysctlProc.getInputStream(), Charset.forName("UTF-8")).trim();
        } catch (UnsupportedEncodingException e) {
            // Java implementations are required to support UTF-8, so this can't happen
            throw new RuntimeException(e);
        } catch (IOException e) {
            log.error("Error while reading from sysctl process", e);
            return null;
        }
        int exitStatus = waitFor(sysctlProc);
        if (exitStatus != 0) {
            log.error("Could not read sysctl variable {}. Exit status was {}", variable, exitStatus);
            return null;
        }
        return result;
    }

    private static boolean isLinux() {
        return OS_NAME.startsWith("Linux") || OS_NAME.startsWith("LINUX");
    }

    private static boolean isWindows() {
        return OS_NAME.startsWith("Windows");
    }

    private static boolean isMacOsX() {
        return OS_NAME.startsWith("Max OS X");
    }

    private static boolean isFreeBsd() {
        return OS_NAME.startsWith("FreeBSD");
    }

    private static String getOSName() {
        String name = getSystemProperty("os.name");
        if (name == null) {
            log.error("Failed to read OS name. " +
                      "Will not be able to provide physical core count.");
        }
        return name;
    }

    private static String getSystemProperty(String property) {
        try {
            return System.getProperty(property);
        } catch (SecurityException e) {
            String msg = String.format("Could not read system property \"%s\"", property);
            log.error(msg, e);
            return null;
        }
    }

    private static String readToString(InputStream in, Charset charset) throws IOException {
        try (InputStreamReader reader = new InputStreamReader(in , charset)) {
            StringWriter sw = new StringWriter();
            char[] buf = new char[10000];
            while (reader.read(buf) != -1) {
                sw.write(buf);
            }
            return sw.toString();
        }
    }

    private static int waitFor(Process proc) {
        try {
            return proc.waitFor();
        } catch (InterruptedException e) {
            log.warn("Interrupted while waiting for process", e);
            return 1;
        }
    }
}

출처: https://github.com/veddan/java-physical-cores/blob/master/src/main/java/veddan/physicalcores/PhysicalCores.java

전체 CPU 정보 확인

$ cat /proc/cpuinfo

논리 코어 수 확인

$ grep -c processor /proc/cpuinfo

물리 CPU 개수 확인

$ grep "physical id" /proc/cpuinfo | sort -u | wc -l

CPU당 물리 코어 수 확인

$ grep "cpu cores" /proc/cpuinfo | tail -1

또는 아래와 같이 간편하게 명령어 하나로도 확인이 가능하다.

$ lscpu

Architecture:          x86_64

CPU op-mode(s):        32-bit, 64-bit

Byte Order:            Little Endian

CPU(s):                4 //전체 코어 수

On-line CPU(s) list:   0-3

Thread(s) per core:    1

Core(s) per socket:    4 //소켓 당 코어 수

Socket(s):             1 //물리 소켓 수

NUMA node(s):          1

Vendor ID:             GenuineIntel

CPU family:            6

Model:                 58

Model name:            Intel(R) Xeon(R) CPU E3-1220 V2 @ 3.10GHz

Stepping:              9

CPU MHz:               3092.880

BogoMIPS:              6185.76

Virtualization:        VT-x

L1d cache:             32K

L1i cache:             32K

L2 cache:              256K

L3 cache:              8192K

NUMA node0 CPU(s):     0-3

var oParam = {

end_fn: function() {

$(Pv_grid).alopexGrid("dataGet", function(data) {

data._state.selected = data.CHECKED == "N" ? false : true;

});

$(Pv_grid).alopexGrid("refreshCell");

}

};

Gf_gridGetData_ByPaging(oParam.trId, oParam.grId, {param: oParam.param, resTotalCnt: oParam.resTotalCnt, end_fn: oParam.end_fn});

Apache Configuration for Java WebStart

Additional AddTypes required for Apache to send the correct Mime-Type for Java WebStart (jnlp) files.

httpd.conf

Add the following entries to the apache httpd.conf

AddType application/x-java-jnlp-file .jnlp

AddType application/x-java-archive .jar

AddType application/x-java-archive-diff .jardiff

Apache will then send the correct mime-type to the browser and therefore Java will be started when the jnlp file is clicked on.

rowSelectOption: {

clickSelect: true,

singleSelect: false

},

enableHeaderSelect: true,

rowOption: {

     allowSelect: function(data) {

return (data.type < 5)? true : false

}

}

https://grid.alopex.io/html/demo.html#!selectionmove/selectrow

행 선택적 제어

https://grid.alopex.io/html/demo.html#!column/allowSelect