양이의 기술블로그

List

리스트는 특정 타입 값들이 순차적으로 정렬된 컬렉션입니다.

LinkedList, ArrayList 클래스를 일반적으로 사용합니다.

리스트는 자바의 배열하고 다릅니다. 

리스트는 크기 지정에 한계가 없으므로 리스트를 사용하기 전에 크기를 지정할 필요가 없습니다.

LinkedList 와 ArrayList 가 각각 적합한 경우에 대해 알아보겠습니다.

배열과 리스트 차이

- 배열은 정의할 때 크기를 지정해야 함.

- 배열의 원소에 인덱스값을 지정하여 직접 접근가능(랜덤접근)

- 배열 크기를 늘려야할때 새로운 배열을 만들고 재정렬하는 절차를 가짐 

- 정수 타입 배열은 final 을 지정할 수 없음

ArrayList 

리스트의 데이터로 배열을 사용하는 List 인터페이스이다.

- ArrayList 클래스 생성시 배열의 초기 크기 지정할 수 있음 (default 10)

- 크기가 추가될때 마다 자동으로 배열을 재할당 함 (단,시간이 소요되고 메모리용량 소모함-> 큰 컬렉션을 이용할거면 미리 크기를 지정함)

- ArrayList 시작위치나 중간 위치에 값을 추가하려고 하면 모든 원소는 공간을 위해 이동해야됨 (=>크기가 크다면 연산량이 많은 작업임)

- 배열 크기 재할당은 단반향으로 이루어짐

- 원소를 줄여도 배열 크기는 줄지않음

LinkedList

연결리스트를 구현 할수 있는 또다른 리스트 구현체입니다.

원소들을 저장하는데 배열을 이용하지 않고 리스트안에서 다음 원소를 가리키는 내부 객체를 이용합니다.(노드참조값)

결론

ArrayList 순차적인 추가/삭제 유리함

인덱스를 참조하고 있어서 검색할때 LinkedList 보다 빠르다.

LinkedList 는 비순차적인 추가/삭제에 유리함

factory method pattern 

주의! 팩토리 메소드와 추상팩토리 패턴은 다르다.

팩토리 메소드 패턴

객체를 만들어내는 부분을 서브클래스에 위임하는 하는 패턴이다.

키워드를 호출하는 부분을 서브클래스에 위임하는것으로 팩토리 메소드 패턴은 객체를 만들어내는 공장(팩토리)라고 이해하면 된다.

로봇으로 예제를 들어보자.

여러 종류의 로봇을 생산하는 공장도 있어야한다. 

로봇과 로봇공장을 만들어서 예제를 돌려봅니다.

<Robot>

package pattern.factory;

public abstract class Robot {
	public abstract String getName();
}

public class SuperRobot extends Robot {
	@Override
	public String getName() {
		return "SuperRobot";
	}
}

public class PowerRobot extends Robot {
	@Override
	public String getName() {
		return "PowerRobot";
	}
}

<Robot Factory>

로봇의 팩토리 클래스이다.

public abstract class RobotFactory {
	abstract Robot createRobot(String name);
}

아래 클래스는 기본 팩토리클래스를 상속받아 실제 로직을 구현한 팩토리이다.

public class SuperRobotFactory extends RobotFactory {
	@Override
	Robot createRobot(String name) {
		switch( name ){
			case "super": return new SuperRobot();
			case "power": return new PowerRobot();
		}
		return null;
	}
}

아래 클래스도 기본팩토리를 상속받아 실제 로직을 구현한 팩토리지만 위와 다른점은 클래스이름을 String 으로 받아서 직접 인스턴스 생성한다.

package pattern.factory;

public class ModifiedSuperRobotFactory extends RobotFactory {
	@Override
	Robot createRobot(String name) {
		try {
			Class<?> cls = Class.forName(name);
			Object obj = cls.newInstance();
			return (Robot)obj;
		} catch (Exception e) {
			return null;
		}
	}
}

<Test Code>

public class FactoryMain {
	public static void main(String[] args) {

		RobotFactory rf = new SuperRobotFactory();
		Robot r = rf.createRobot("super");
		Robot r2 = rf.createRobot("power");

		System.out.println(r.getName());
		System.out.println(r2.getName());

		RobotFactory mrf = new ModifiedSuperRobotFactory();
		Robot r3 =  mrf.createRobot("pattern.factory.SuperRobot");
		Robot r4 =  mrf.createRobot("pattern.factory.PowerRobot");

		System.out.println(r3.getName());
		System.out.println(r4.getName());
	}
}

결과

main() 에서 new() 키워드가 없다는것을 확인할 수 있음.

객체 생성을 팩토리에 위임한 결과이다. 

main() 에서는 팩토리를 통해 원하는 로봇 객체를 얻는다.

팩토리 메소드 패턴을 사용하는 경우 직접 객체를 생성해 사용하는것을 방지하고 서브 클래스에 위임함으로써 효율적인 코드 제어를 할 수 

있고 의존성을 제거한다.

팩토리 메소드 패턴을 사용하는 이유는 클래스간의 결합도를 낮추기 위한것이다. 

즉, 로봇 클래스에 변경이 일어나도 다른 클래스에도 영향을 주지않는다.

팩토리 메소드 패턴을 사용하는 경우 직접 객체를 생성해 사용하는것을 방지하고 서브 클래스에 위임함으로써 보다 효율적인 코드 제어

할 수 있고 의존성을 제거한다.

결과적으로 결합도를 낮출수 있다.

Singleton-pattern

단 하나의 인스턴스를 생성해 사용하는 패턴

why?

고정된 메모리 영역을 얻으면서 한번의 new로 인스턴스를 사용하기 때문에 메모리 낭비를 방지할 수 있음

또한,싱글톤으로 만들어진 클래스의 인스턴스는 전역 인스턴스이기 때문에 다른 클래스의 인스턴스들이 데이터를 공유하기 쉽다

커넥션 풀, 스레드 풀 등 객체생성시 싱글톤 사용

1. eager initialization  (이른 초기화)

싱글톤 패턴중에 가장 기본적인 싱글톤 패턴이다

이른 초기화 방식은 싱글톤 객체를 미리 생성해 놓은 방식이다.

전역변수로 instance 변수 생성하고 private static 선언하여 직접 바로 접근할 수 없도록 합니다.

생성자에도 private 접근 제어 키워드를 붙여 다른 클래스에서 new EagerInitialization() 방식으로 새로운 인스턴스 생성하는 것을 방지한다.

오로지 정적메소드인 getInstance() 메서드를 통해 인스턴스를 접근하도록 하여 동일한 인스턴스를 사용하는 기본 싱글톤원칙을 지키게한다.

/**
 *
 * 가장 기본적인 singleton pattern
 * new EagerInitialization () 될때 어떠한 예외처리도 할 수 없다는것이 단점
 */
public class EagerInitialzation {

	//private 으로 선언하여 외부에서 접근 불가
	//static 으로 인스턴스화 없이 사용 가능함
	private static EagerInitialzation instance = new EagerInitialzation();

	// private 으로 생성자 선언하여 new 키워드로 인스턴스 생성 불가능
	private EagerInitialzation(){
		System.out.println("call EagerInitialzation constructor");
	}

	//instance의 직접 접근도 불가능하고 생성자도 불가능하기 때문에 getInstance() 로 만 인스턴스 가질수있음
	public static EagerInitialzation getInstance(){
		return instance;
	}
}

2. Static block initialization

이른초기화와 같은 방식으로 초기에 인스턴스 만들어놓지만 static 구문에 로직을 추가하여 수행하는 패턴이다

logic을 담을수 있기 때문에 복잡한 초기변수 셋팅이나 예외처리를 위한 구문을 담을수 있다.

/**
 *
 * Static block initialization
 * logic을 담을수 있기 때문에 복잡한 초기변수 셋팅이나 위와 같이 에러처리를 위한 구문을 담을수 있다.
 */
public class StaticBlockInitialization {

	private static StaticBlockInitialization instance;

	private StaticBlockInitialization (){ }
	// static 으로 정의하여 초기화 블럭을 이용하여 클래스가 로딩될때 최초 한번 실행하게 됨.
	static {
		try {
			System.out.println("instance create...");
			instance = new StaticBlockInitialization();
		}catch (Exception e){
			throw new RuntimeException("Exception creating StaticBlockinitalation instace.....");
		}
	}

	public static StaticBlockInitialization getInstance(){
		return instance;
	}
}

3. Lazy initialization (게으른 초기화)

게으른 초기화는 인스턴스를 사용하는 시점에 사용한다. 

instance 변수를 private static 으로 전역변수로 만들고 생성자도 private 로 선언하여 외부에서 생성 못하게 한다.

오직 getIntance() 메소드를 통해 인스턴스 생성 및 호출되는데, 최초 호출일 경우 인스턴스 객체 생성한다.

만약 멀티 쓰레드를 방식에서 getInstance() 를 두번 호출하게 되면 인스턴스가 두번 생성될 수 있는 문제점이 있다.

/**
 * Eager initialization,static block 방법은 클래스가 로딩될때 인스턴스 생성하기 때문에 프로그램이 커지만 부담이 될수 있다.
 * Lazy 초기화는 인스턴스를 사용하는 시점에 사용한다.
 * 만약 멀티 쓰레드 방식이라서 getinstance()를 두번 호출하게 되면 두번 생성 될수 있다.
 */
public class LazyInitialization {

	private static LazyInitialization instance;
	private LazyInitialization(){};

	public static LazyInitialization getInstance(){
		if (instance == null)
			instance = new LazyInitialization();
		return instance;
	}
}

4.Thread Safe Lazy initialization(스레드 안전한 늦은 초기화)

Lazy 싱글톤 방식에서 thread safe 문제가 있어 이를 보완하기 위해 멀티쓰레드에서 스레드들이 동시 접근하는

동시성을 synchronized 키워드를 이용해 해결하는 방식이다.

/**
 * sychronized 블록으로 인해, 수 많은 쓰레드 들이 인스턴스 호출하게 되면 높은 cost 비용으로 인해
 *  프로그램 전반에 성능저하가 일어난다.
 *
 */
public class ThreadSafeInitialization {
	private static ThreadSafeInitialization instance;
	private ThreadSafeInitialization(){}

	//여러 thread 들이 동시에 접근해서 인스턴스를 생성시키는 위험은 없어짐!
	public static synchronized ThreadSafeInitialization getInstance(){
		if (instance==null)
			instance = new ThreadSafeInitialization();
		return instance;
	}
}

synchronized 키워드를 사용할 경우 자바 내부적으로 해당 영역이나 메서드를 lock,unlock 처리하기때문에 많은 cost가 발생함

=> 성능저하됨!

4-1. Thread Safe Initialization + double - checked locking 기법 싱글톤 패턴

위에 Thread safe initialization 에서 synchronized 처리된 메서드가 성능저하가 발생되어 완화하기 위해

Double checked locking 기법을 사용한다.

instance가 null 일 경우에 synchronized 블럭에 접근하고 한번더 instance의 null 유무를 체크한다.

if문 두번다 null 일 경우 new를 통해 인스턴스화시킨다.

그후 instance 가 null이 아니기때문에 synchronized 블록을 타지 않는다.

Double checked locking 으로 성능저하 줄임

public class ThreadSafeLazyInitialization {
 
    private static ThreadSafeLazyInitialization instance;
 
    private ThreadSafeLazyInitialization(){}
     
    public static ThreadSafeLazyInitialization getInstance(){
        //Double-checked locking
        if(instance == null){
            synchronized (ThreadSafeLazyInitialization.class) {
                if(instance == null)
                    instance = new ThreadSafeLazyInitialization();
            }
 
        }
        return instance;
    }
}

jvm 이란?

Jave Virture Machine 의 약자로 자바 가상머신이라 부른다.

자바와 운영체제사이에서 중계자 역할을 한다.

자바가 운영체제 종류에 영향받지 않고 돌아갈 수 있도록 한다.

메모리 관리를 자동으로 해준다(GC)

JVM은 운영체제와 플랫폼 종류에 의존적이지 않고 독립적으로 JAVA 프로그램이 실행된다.

<자바실행과정>

java Compiler 에 의해 .java 파일은 Byte code로 변환된다

Class Loader는 변환된 Byte Code 파일을 Jvm 내로 class를 로드하고 Link 작업을 통해 배치등 일련의 작업을 한다.

런타임시 .class를 load 한다.

Execution Engine(실행엔진) Class Loader를 통해 JVM 내부로 넘어와 Runtime Data Area에 배치된 Byte Code 들을 명령어 단위로 실행시킴

* GC 는 어플리케이션이 생성한 객체 생존 여부를 판단하여, 더이상 참조되지 않거나 null 인 객체의 메모리를 해체시켜 메모리를 반납을 함

* Runtime Data Area(JVM) 런타임 데이터 영역은 JVM 메모리로 java 어플리케이션이 실행하면서 할당받은 메모리 영역이다

Method Static Area : 클래스,변수,Method,Static변수,상수 정보들이 저장되는 영역

Heep Area : new 명령어로 생성된 인스턴스와 객체가 저장되는 구역. GC 이슈는 이영역에서 일어남

Stack Area : Method 내에서 상용되는 값들(매개변수, 지역변수, 리턴값) 메소드가 호출될때 LIFO 로 생성됨.실행이 완료되면 LIFO 삭제

PC Register : CPU의 Register와 비슷한 역할함. 현재 수행중인 JVM명령의 주조값이 저장됨

* Method Satic Area , heep..영역은 모든 스레드에서 공유할 수 있다.

Young Generation : 객체가 생성될때 마다 저장된다. 즉 막 생성된 객체들의 인큐베이터이다. 생성된 기간이 흐르고 우선순위가 낮아지면

Young 세대의 객체들은 Old 세대로 이동하게 된다. 이영역은 객체가 사라질 때는 Minor GC 수행된다.

Old Generation : young Generation 영역에 있는 객체가 오래되서 저장되는 공간이다.이영역에서 사라질때는  Full GC 수행됨

Permanent Generation : 클래스 로더에 의해 로드되는 클래스,메소드 등에서 대한 메타정보가 저장되는 영역으로 JVM 에 의해 사용됨

Spring Batch 개념

- 데이타 프로세싱과 관련된 다양한 방법들을 설정으로 관리할 수 있으며 관련한 통계 정보를 제공(commit 개수, Rollbak, restart ..등)

- 다양한 실행 방법 지원 (command line, Quartz..)

- 각종 읽기와 쓰기 기능의 구성요소를 같은 인터페이스들로 추상화 시키고 있고, 그어 맞는 기본 구현 클래스 제공

- 추가 코딩없이 설정만으로 기존 모듈 활용 가능

- 유연한 Exception 처리

시스템 내의 Soc(Separation of Concern)을 위해 논리적으로 티어 구분을 한다. 

개념 적으로 구분했지만, 논리적인 컴포넌트 배포를 매핑할 때와 데이터 소스나 타겟과 통합하는데 효율적이다.

- Run 티어 : 스케줄링과 애플리케이션 실행에 관련

- Job 티어 : 일반적으로 배치 잡의 실행을 책임. 연속적으로 배치 Step 을 실행시키고 모든 Step 이 실행되서 정확한 상태에 있고 모든 정책이 정확하게 적용됐는지를 보장

- Application 티어 : 프로그램을 실행하는데 필요한 컴포넌트를 포함, 배치 기능을 수행하는데 적용되는 특정 태스크와 정책을 적용.

- Data 티어 : 데이터베이스, 파일, 큐들을 포함하는 물리적인 데이터 소스와 통합

구성요소 

Job 

하나의 배치작업을 정의, 예를 들어 "API 서버의 사용로그 테이블의 데이타를 로그 분석 시스템으로 옮기는 배치"

Job Instance

배치가 실제 실행되면, 각각의 실행을 Instance 라고 한다. 예를 들어 Batch Job이 매주 한번씩 수행된다고 할때 각각의 수행되는 Batch Job을 Batch Instance 라고 한다. 

Job Execution

배치가 실행될때, 각 배치의 실행시, 실제 수행된 Execution을 정의한다.

예를 들어 Batch job 이 월요일 오전에 수행되었을때, 첫번째 실패하고 두번째에 Retry에 의해 성공했다면 이 각각 다른 Job Execution이 실행되고, 같은 작업을 시도하였기 때문에 같은 Job instance 가 된다.

Job parameter

매번 배치 작업이 수행될때 마다 전달되는 Parameter 이다. 예를 들어 매주 수행되는 배치가 있을때, 시작 시간,데이타를 읽을 범위 들 지정하여 Batch Job Instance 를 생성한다면, 이렇게 넘어가는 인가가 JobParamer 이다

Spring 에서 Batch Job 구성

Step 

Spring 에서 Batch Job 은 Step의 모음으로 구성된다. Job 은 Step이 순차적으로 수행되게 된다.

Tasklet 

Tasklet은 각 Step 에서 수행되는 로직이다. 개발자가 custom logic 을 만들수 있고 또는 보통 Batch 의 경우 데이타를 ETL(Extract Transform Loading)하는 형태이기 때문에 ,Spring Batch에서 미리 정의해놓은 Reader, Processor, Writer interface 를 사용할 수 있다.

ItemReader - 데이타를 읽는 컴포넌트

ItemProcessor - 읽은 데이타 처리

ItemWriter - 처리한 데이타를 저장

개발환경구축하기 

내가 사용한 OS 는 centOS6 버젼!

우선 

톰캣+아파치 설치이전에 리눅스 환경설정 후 셋팅 한다.

1. 리눅스 캐리터셋 설정

2. 리눅스 호스트네임 설정

3. 리눅스 커널 튜닝

4. 리눅스 방화벽 설정,호스트네임 추가

5.아파치+톰갯 셋팅

6 구축테스트

7.리눅스 crontab 설정

리눅스 캐릭터셋 설정 : 

#vi /etc/sysconfig/i18n

아래 추가

LANG="ko_KR.UTF-8"

SUPPORTED="en_US.UTF-8:en_US:en:ko_KR.eucKR:ko_KR:ko:ko_KR.UTF-8"

리눅스 OS 튜닝

# ulimit -a

# vi /etc/sysctl.conf

추가

fs.file-max = 62787 

# vi /etc/security/limits.conf

추가 

* soft nproc 62787 

* hard nproc 62787

* soft nofile 62787

* hard nofile 62787

# vi /etc/security/limits.d/90-nproc.conf

추가 

* soft nproc 62787

* hard nproc 62787

# reboot (튜낭후 리부팅)

아파치 설치 유무 및 실행 유무

# ps -ef|grep httpd

# /etc/init.d/httpd stop

열려있는 포트 확인

# netstat -apn | grep "LISTEN"

추가

export JAVA_HOME=/usr/local/java

export PATH=$PATH:$JAVA_HOME/bin:

시스템적용

# source /etc/profile

자바확인

# javac

톰캣설치

# cd /usr/local/server

# /usr/local/server 에 압축해제

# tar -xzvf apache-tomcat-7.0.55.tar.gz -C /usr/local/server/

톰캣심볼링 설정

# ln -s apache-tomcat-7.0.55 tomcat

톰캣 환경변수 설정

# vi /etc/profile

추가

export APACHE_HOME=/usr/local/server/apache

export CATALINA_HOME=/usr/local/server/tomcat

export CLASSPATH=$JAVA_HOME/lib/tools.jar

export PATH=$PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin:$APACHE_HOME/bin

export LD_LIBRARY_PATH=/usr/local/apr/lib

시스템적용

# source /etc/profile

톰캣 라이브러리 설치

# cd /usr/local/src/

# tar -xzvf tomcat-native-1.1.31-src.tar.gz

# cd tomcat-native-1.1.31-src/jni/native

컴파일

# ./configure --with-apr=/usr/local/server/apache/bin/apr-1-config --with-java-home=$JAVA_HOME

# make

# make install

apr 경로확인

# cd /usr/local/

있으면  컴파일 성공!

서비스 재시작 

# service iptables restart

톰캣 설정 변경(웹 동적파일 경로)

웹컨텍스트폴더(동적파일)수정

# vi /usr/local/server/tomcat/conf/server.xml

<Host name="도메인명" appBase="동적파일경로" unpackWARs="true" autoDeploy="true">

<Context path="" docBase="정적파일(jsp,ftl,img)/home/web/패키지명/WebContent" reloadable="true">

톰캣 + 아파치 연동

# cd /usr/local/src

connector 라이브러리 압축 해제

# tar -xvzf tomcat-connectors-1.2.40-src.tar.gz

# cd /tomcat-connectors-1.2.40-src/native

connector 컴파일

# ./configure --with-apxs=/usr/local/server/apache/bin/apxs

# make

# make install

mod_jk 생성확인(mod_jk.so파일)

# cd /usr/local/server/apache/modules

톰캣 + 아파치 설정 파일

노드설정시 : # cd /usr/local/server/apache/bin/apache-node.sh

아파치 기존 설정파일  : # cd /usr/local/server/apache/conf/extra/httpd-default.conf

uri 설정파일 :              # cd /usr/local/server/apache/conf/extra/httpd-mpm.conf  

아파치 설정 파일 : # cd /usr/local/server/apache/conf/httpd.conf 

톰캣+아파치 연동 설정파일:  # cd /usr/local/server/apache/conf/mod-jk.conf

uri 파라미터 파일  : # cd /usr/local/server/apache/conf/uriworkermap.properties

워커 설정 파일:      # cd /usr/local/server/apache/conf/workers.properties 

톰캣 노드 설정 파일 : # cd /usr/local/server/tomcat/bin/tomcat-node.sh

톰캣 기본 설정(path,host,user 등등 설정): # cd /usr/local/server/tomcat/conf/server.xml

os 유저추가 

# useradd

유저 비번변경

# passwd 

폴더 일반유저 권한으로 변경

# chown -R 일반유저계정.일반유저계정 변경할폴더

일반유저로 실행

# cd /usr/local/server/apache/bin 

# chown root:root httpd

# chmod +s httpd

# chown 일반계정:일반계정 apachectl

# chmod 755 폴더/파일

Decorator Pattern (데코레이터 패턴)

데코레이터 패턴

- 데코레이터는 서브 클래스를 만드는 것을 통해서 기능을 유현하게 확장할 수 있는 방법을 제공한다.

- 한 객체를 여러 개의 테코레이터로 감쌀수 있다.

- 기존 코들르 수정하지 않고도 기능을 확장할 수 있다.  

단점 

- 데코레이터 패턴을 이용해 디자인을 하다 보면 답다한 클래스가 많아질 수 있음

- 겹겹이 애워싼 객체의 정체를 알기가 힘들다

- 상속을 통해 확장할 수도 있지만, 디자인 유연성 면에서는 별로 좋지 않다.

그럼 이제부터 데이레이터 패턴 사용 하지 않은 예를 들면 !!

카페에서 음료를 주문할때 음료하나에 시럽,우유,휘핑 등을 추가하는 경우가 있다.

이 행동을 구현하면 

- 음료를 나타내는 추상 메소드 Beverage 는 카페에서 판매되는 모든 음료는 이 클래스의 서브 클래스가 된다. 즉 Beverage 가 부모클래스 , 슈퍼클래스 이다. 

- beverage 라는 음료 클래스에 우유,두유,모카,휘핑 크림을 나타내는 인스턴스 변수를 추가한다.

- 첨가물에 첨부 여부와 첨가물을 설정한다

- cost() 에서 추가된 첨가물의 가격을 계산한다. 서브클래스에서 cost()메소드를 재구현한다.

자 근데 이런식으로 하면 문제점이 무엇인가 ?

첨가물 가격이 바뀔때 마다 기존 코드를 수정해야된다.

첨가물의 종류가 많아지면 새로운 메소드를 추가해야한다.

새로운 음료가 출시될 수도 있다. 그 중에는 첨가물이 들어가면 안되는 음료도 있다. !! (필요없는 첨가물 메소드 상속 받게됨)

손님이 모카를 두번 추가하면 어떻게 할것인가 ????

부모클래스와 자식클래스

- 자식클래스를 만드는 방식으로 행동을 상속 받으면 그 행동은 컴파일시! 완전히 결정되고 모든 서브 클래스에서 똑같은 행동을 상속 받아야한다.

- 하지만 구성을 통해 객체의 행동을 확장하면 실행 중에 동적으로 행동을 설정할 수 있다.

Decorator pattern 적용

- Beverage 는 가장 기본이 되는  Component 클래스이다. 

- 음료 종류마다 Beverage에 대한 구상 클래스를 하나씩 만든다. (DripCoffee,DripCoffee)

- 각각의 첨가물을 나타내는 데코레이터를 추가(Mocha, Milk )하고  cost(), getDescription() 를 구현해야한다.

- 각 데코레이터 안에는 Beverage 클래스가 들어있다.

- 데코레이터에는 구성요소에 대한 레퍼런스가 들어있는 인스턴스 변수가 있다!!! (private Beverage beverage)        

Beverage.java