CamelAct

CSS 강의

CamelAct — Fri, 23 Aug 2024 17:11:16 +0900

Overview

CSS는 Cascading Style Sheets를 의미한다

. Cascading : 계단식

. Style : 멋을 내다

. Sheets : 종이 한 장

=> 계단식으로 스타일을 정의하는 문서

웹 문서의 콘텐츠에 스타일을 추가하는 언어(색상, 크기, 위치 등)

CSS 기본 문법

선택자 {
  속성명: 속성값;
}

선택자: 어떤 요소에 스타일 을 적용할지에 대한 정보
{중괄호}: 선택한 요 소에 적 용할 스 타 일 을 정의하는 영역
속성명: 어떤 스타일을 정의하고 싶은지에 대한 정보 (색상, 크기 등)
속성값 : 어떻게 정의하고 싶은지에 대한 정보

p {
  color: red;
}

선택자 : p 태 그에 스타일을 적용하겠다.
{중괄호} : 이 안에, p 태그에 대한 스타일을 정의하겠다.
속성명 color를 정의하겠다. 이건 글자색을 의미한다.
속성값 : red로 정의하겠다. 빨간색 글자를 원한다.

선택자

선택자란 말 그대로 선택을 해주는 요소입니다. 이를 통해 특정 요소들을 선택하여 스타일을 적용할 수 있게 됩니다. 먼저 CSS에서 스타일이 어떤 방식으로 정의 되는지 알아봅시다.

선택자의 종류는 아래와 같습니다.

전체 선택자

* {
  color:red;
}

태그 선택자

body {
    /*body css code*/
    background-color:green;
}

header {
    /*header css code*/
    background-color:black;
    color:white;
}

클래스 선택자

<p class="name">
  dev2820
</p>

.name {
    /*name class css*/
    color:green;
}

아이디 선택자

<h1 id="title">
  제목
</h1>

#title {
    /*title id css*/
    color:red;
}

속성 선택자

<a href="http://www.google.com">google</a>
<input type="password">

a[href="https://www.google.com"] {
    /*href 속성값이 http://www.google.com 인 a 태그*/
    text-decoration:none;
    color: green;
}
input[type="password"] {
    /*input*/
    border-radius:4px;
}
a[href] {
    /*href 속성을 지닌 모든 a 태그*/
}
a[href*="https://"] {
    /*href 속성값이 https://로 시작하는 a 태그*/
}
img[src$=".png"] {
    /*src 속성값이 .png로 끝나는 img 태그*/
}
[class *= "it"]{
   /* 클래스 값에 'it'가 포함되는 요소를 선택하기 */
} 

[class ^= "it"]{ 
   /* 클래스 값에 'it'로 시작하는 요소를 선택하기 */
 } 

[class $= "it"]{ 
   /* 클래스 값에 'it'로 끝나는 요소를 선택하기 */
}

의사 클래스(Pseudo class) 선택자

<a href="google.com">google</a>
<a href="https://google.com">google</a>
<div>hover me</div>
<input value="focus"></input>
<button>active</button>

a:link {
    /*방문하지 않은 a 태그*/
    color:red;
}
a:visited {
    /*방문한 a 태그*/
    color:blue;
}
div:hover {
    /*커서가 올라가 있는 div 요소*/
    color:gold;
}
input:focus {
    /*포커싱 되어있는 input 태그*/
  /*tab 또는 click으로 input에 focus를 주면 확인할 수 있습니다.*/
    background-color:green;
}
button:active {
    /*활성화한 button 태그*/
    background-color:red;
}

구조 선택자

<html>
  위는 안채워진 p태그, 아래는 채워진 p태그
  <p></p>
  <p>abcde</p>
</html>

:root {
  background-color:green;
  
}
p {
  border:2px solid black;
}
p:empty {
  border:2px solid blue;
}

부정 선택자

<h1 class="title">a</h1>
<h1>b</h1>

h1:not(.title) {
  color:red;
}

그룹 선택자

hl, p, div{ color: blue; }

자식 결합자

<ul class="list">
    <li class="a">a</li>
    <li class="b">b</li>
    <li class="c">c</li>
    <ul>
      <li class="d">d</li>
    </ul>
</ul>

ul.list > li {
     /*ul 태그 자식 요소인 모든 li를 선택*/
    color:green;
}

형제 결합자

hl ~ p{ /* h1 요소의 뒤에 오는 형제 중 모든 p요소를 선택하기 */ } 
hl + p{ /* h1 요소의 벓 뒤에 오는 형제 p요소를 선택하기 */ }

복합 선택자

div#title.box.big {

}

위 css는 <div id="title" class="box big">를 가리킵니다. 이렇게 tag, id, class선택자는 여러개를 함께 사용할 수 있습니다.

선택자 우선 순위(*암기)

!important 선언 > 인라인 CSS > ID 선택자 > class 선택자 = 의사 클래스 > tag 선택자 = 가상 요소 > 브라우저 기본 CSS(default css)

참고 : https://velog.io/@dev2820/CSS-CSS-%EC%84%A0%ED%83%9D%EC%9E%90-%EC%A0%95%EB%A6%AC

React에서 CSS 적용

Inline style 사용

/* App.js */
import "./App.css";

function App() {
  return (
    <div>
      <p style={{ backgroundColor: "red", marginTop: "10px" }}>
        글자를 파랗게 만들어줘
      </p>
    </div>
  );
}

export default App;

※ 주의: 속성 키명은 react가 js 라이브러리여서 - 를 쓰면 -(빼기) 연산자로 받아들이므로 camelCase를 이용한다.

CSS 파일을 통한 stylesheet 사용

/* App.css */
p {
  background-color: red !important;
  margin-top: 10px;
}

/* App.js */
import "./App.css";

function App() {
    return (
        <div>
            <p> 글자를 파랗게 만들어줘 </p>
        </div>
    );
}

export default App;

style 변수 사용

/* App.js */

function App() {
  const style = {
    marginTop: "10px",
    backgroundColor: "red",
  };

  return (
    <div>
      <p style={style}>글자를 파랗게 만들어줘</p>
    </div>
  );
}

export default App;

텍스트 꾸미기 속성

font-family: 요소를 구성하는 텍스트의 글꼴을 정의한다. 글꼴명을 속성값으로 지정한다. 여러 개의 글꼴을 연달아 기입하여 우선 순 위 를 지정할 수 있다.

* { 
  font-family: Times, monospace, serif;
}

font-size: 글자 크기, 아래는 단위

px: 모니터 상의 화소 하나 크기에 대응하는 절대적인 크기

rem: <html> 태그의 font-size에 대응하는 상대적인 크기

em: 부모태그(상위태그)의 font-size에 대응하는 상태적인 크기

span{ font-size: 16px; } 
span{ font-size: 2rem; } 
span{ font-size: 1.5em; }

See the Pen font-size by Peace Kwak (@Peace-Kwak) on CodePen.

text-align : 글자의 정렬을 정의한다.

left / right : 왼쪽 또는 오른쪽 정렬한다.

center : 가운데 정렬한다.

justify : 양끝 정렬한다.

p { text-align: right; }

color: 색 정의

span{ color: red; } 
span{ color: #FF0000; } 
span{ color: rgb(100%, 0%, 0%); }

block, inline

블록 레벨 요소: 자기가 속한 영역의 너비를 모두 차지하여 블록을 형성한다.(*암기)

ex) div, p, h1

인라인 요소: 자기에게 필요한 만큼의 공간만 차지한다.

ex) span, a

display 속성은 요소를 블록과 인라인 요소 중 어느 쪽으로 처리할지 정의한다.

div{ display: inline; }
a{ display: block; }

display 속성 값

inline : 인라인으로 처리한다.

block: 블록 레벨로 처리한다.

inline-block 인라인으로 배치라되, 블록 레벨 요소의 속성을 추가할 수 있도록 처리한다. width, height를 설정할 수 있음

none : 디스플레이하지 않는다.

border

span{ border: 2px solid green; }

border-color: color 정의 방식과 동일

border-width: thin, medium, thick 등의 키워드 또는 px, em, rem 등의 단위

border-style: none, solid, dotted, dashed 등

See the Pen text-align:border by Peace Kwak (@Peace-Kwak) on CodePen.

Box Model

브라우저가 요소를 렌더링 할 때, 각각의 요소는 기본적으로 사각형 형태로 영역을 차지하게 된다. 이 영역을 '박스'라 표현하며, CSS는 박스의 크기, 위치, 속성(색, 배경, 테두리, 모양 등)을 결정할 수있다.

하나의 박스는 네 개의 영역으로 구성된다.

contents, padding, border, margin 영역을 살펴보면 아래와 같다.

See the Pen contents, padding, border, margin by Peace Kwak (@Peace-Kwak) on CodePen.

상하좌우 여백을 개별 정의 할 수 있다.

div{
  width: 100px; height: 100px; 
  padding: 10px; 
  border: 5px solid red; 
  margin: 20px; 
  padding-top: 10px; 
  padding-right: 20px; 
  padding-bottom: 30px; 
  padding-left: 40px;
  margin-top: 40px; 
  margin-right: 30px; 
  margin-bottom: 20px; 
  margin-left: 10px;
}

span{ 
  display: inline-block; 
  width: 100px; height: 100px; 
  margin: 10px 20px 30px 40px;
}

box-sizing: 박스의 크기 기준 정의

content-box: 기본값, 너비와 높이가 콘텐츠 영역만 포함한다.

border-box: 너비와 높이가 안쪽 여백과 테두리까지 포함한다.

See the Pen Untitled by Peace Kwak (@Peace-Kwak) on CodePen.

backgroud

background-color: 배경 색을 정의한다.

background-image: 배경 이미지를 정의한다.

background-position: 벼경 이미지의 초기 위치를 정의한다.

background-size: 배경 이미지의 크기 정의한다. cover: 찌그러지지 않고 잘려서 최대 사이즈, contain : 찌그러지지 않으며 잘리지 않는 최대 사이즈

background-repeat: 배경 이미지의 반복을 정의한다.

See the Pen backgroud by Peace Kwak (@Peace-Kwak) on CodePen.

div{ 
  box-sizing: border-box; 
  width: 500px; height:500px;
  border: 1px solid red; 
  background-image: url(./my-cat.jpeg)
  background-repeat: no-repeat; 
  background-position: left top;
  background-size: 300px 300px
}

float

none: 기본값, 원래 상태

left: 자신을 포함하고 있는 박스의 왼편에 떠 있어야 함

right: 자신을 포함하고 있는 박스의 오른편에 떠 있어야 함

See the Pen float by Peace Kwak (@Peace-Kwak) on CodePen.

clear

clear 속성은 float 요소 이후에 표시되는 요소가 float을 해제(clear)하여 float 요소의 아래로 내려가게 할 수 있다.

none: 기본값, 아래로 이동되지 않음을 나타내는 키워드

left: float이 left인 요소의 아래로 내려가겠다.

right: float이 right인 요소의 아래로 내려가겠다.

both: float이 left 및 right인 요소의 아래로 내려가겠다.

See the Pen clear by Peace Kwak (@Peace-Kwak) on CodePen.

position

position은 문서 상에 요소를 배치하는 방법을 정의한다.

position이 요소의 배치 방법을 결정하면, top, bottom, right, left가 최종 위치를 결정하는 방식

position 속성 5가지

static : 기본값, 요소를 일반적인 문서 흐름에 다라 배치한다.

relative: 일반적인 문서 흐름에 따라 배치하되, 상하좌우 위치 값에 따라 오프셋을 적용한다.

absolute: 일반적인 문서 흐름에서 제거하고, 가장 가까운 postion 지정 요소에 대해 상대적으로 오프셋을 적용한다.

fixed: 일반적인 문서 흐름에서 제거하고 지정한 위치에 고정된다.

sticky: 일반적인 문서 흐름에서 제거하고, 스크롤 동작이 존재하는 가장 가까운 요소에 대해 오프셋을 적용한다.

position:relative

See the Pen position by Peace Kwak (@Peace-Kwak) on CodePen.

position:absolute

See the Pen position:absolute by Peace Kwak (@Peace-Kwak) on CodePen.

flexbox

floexbox란 박스 내 요소 간의 공간 배분과 정렬 기능을 제공하기 위한 1차원 레이아웃 모델이다.

floxbox를 1차원 모델이라 부르는 이유는, 레이아웃을 다룰 때 한 번에 하나의 차원(행이나 열)만 다룬다는 특성 때문이다.

행방향(세로)가 주축이다.

See the Pen flexbox by Peace Kwak (@Peace-Kwak) on CodePen.

flex-direction

flex-direction 속성은 flexbox 내 요소를 배치할 때 사용할 주축 및 방향(정방향, 역방향)을 지정한다.

row: 기본값, 주축은 행이고 방향은 콘텐츠의 방향과 동일

row-reverse: 주축은 행이고 방향은 콘텐츠의 방향과 반대

column: 주축은 열이고 방향은 콘텐츠의 방향과 동일

column-reverse: 주축은 열이고 방향은 콘텐츠의 방향과 반대

flexbox 연계

justify-content : 주죽 배치 방법

align-items: 교차축 배치 방법

align-self: 교차축 개별요소 배치 방법

flex-wrap: 줄 바꿈 여부

See the Pen justify-content by Peace Kwak (@Peace-Kwak) on CodePen.

inherit, initial, unset

상속이란 하위 요소가 상위 요소의 스타일 속성값을 물려받는 것을 의미한다.

상속 된다 : color, font-family, font-size, font-weight, text-align, cursor 등 (*암기)

상속 안 된다 : background-color, background-image, background-repeat, border, display 등 (*암기)

참고 : https://www.w3.org/TR/CSS21/propidx.html

inherit: 상위 요소로부터 해당 속성의 값을 받아 사용한다.

initial: 해당 속성의 브라우저 기본값을 요소에 적용한다.

unset: 상속 속성에 대해서는 inherit처럼, 상속되지 않는 속성에 대해서는 initial처럼 적용된다.

inherit 사용 예제

See the Pen inherit by Peace Kwak (@Peace-Kwak) on CodePen.

initial, unset 사용 예제

See the Pen initial by Peace Kwak (@Peace-Kwak) on CodePen.

z-index

요소의 쌓임 순서를 정의할 수있다. 정수 값을 지정하여 쌓임 맥락에서의 레벨을 정의하는 방식으로 적용되며, 위치 지정 요소에 대해 적용할 수 있는 속성이다. => 위치 지정 요소란, postion 속성이 정의되어 있는 요소를 말한다.

See the Pen z-index by Peace Kwak (@Peace-Kwak) on CodePen.

word-break

CSS 속성 은 텍스트가 콘텐츠 상자를 넘어갈 때마다 줄 바꿈을 표시할지 여부를 설정합니다.

단어를 기준으로 개행되지 않고 단어가 잘리도록 개행되면 문제가 됩니다.

word-break로 이를 해결할 수 있습니다.

참고 : https://developer.mozilla.org/en-US/docs/Web/CSS/word-break

HTMLCSSResult

	div { width : 400px; border : 1px solid black; }
	div { width : 400px; border : 1px solid black; word-break: keep-all; }

https://codepen.io/Peace-Kwak/pen/NWZzdYz

[ENG][IPv4][IPv6]Using IP Checker

CamelAct — Wed, 2 Nov 2022 13:35:25 +0900

Overview

We use IP addresses in various situations. It is necessary to check the IP address that users enter incorrectly and prevent errors. The following is an example of checking whether IPv4 and IPv6 is a normal format, and in the case of IPv6, if it is long format, it is converted to a universal short format.

IPv6 can be abbreviated for 0, so the following addresses are the same.

1:ab8:18a3:0000:0000:8a2e:0120:3
1:0ab8:18a3:0000:0000:8a2e:120:3
1:ab8:18a3:0000:0000:8a2e:120:3
1:ab8:18a3::8a2e:120:3
1:0ab8:18a3::8a2e:0120:3
1:ab8:18a3::8a2e:0120:3
1:0ab8:18a3::8a2e:120:3
1:ab8:18a3::8a2e:120:3

In order to handle it as a program, writing the same address is easy to manage.

1:ab8:18a3:0:0:8a2e:120:3

Code Example

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.regex.Pattern;

public class MyFilterOption {
	public static void main(String[] args) throws UnknownHostException {
		new MyFilterOption().start();
	}

	private static String regexIPv4 = "^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
	private static String regexIPv6 = "(^((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?$)|(^((([0-9A-Fa-f]{1,4}:){6}([0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}((([0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}((([0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}((([0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}((([0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}((([0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))):\\*$)";

	public static boolean checkIpv4OrIpv6(String ipAddr) {
		Pattern pattern;

		pattern = Pattern.compile(regexIPv6);
		if (pattern.matcher(ipAddr).matches() == true) {
			return true;
		}

		pattern = Pattern.compile(regexIPv4);
		if (pattern.matcher(ipAddr).matches() == true) {
			return true;
		}

		return false;
	}

	public void getIpValue(String ipValue) {
		try {
			if (!checkIpv4OrIpv6(ipValue)) {
				throw new UnknownHostException();
			}

			InetAddress inetAddress = InetAddress.getByName(ipValue);
			String shortFormat = inetAddress.getHostAddress();
			System.out.println(shortFormat);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void start() throws UnknownHostException {
		getIpValue("1:ab8:18a3:0000:0000:8a2e:0120:3");
		getIpValue("1:0ab8:18a3:0000:0000:8a2e:120:3");
		getIpValue("1:ab8:18a3:0000:0000:8a2e:120:3");
		getIpValue("1:ab8:18a3::8a2e:120:3");
		getIpValue("1:0ab8:18a3::8a2e:0120:3");
		getIpValue("1:ab8:18a3::8a2e:0120:3");
		getIpValue("1:0ab8:18a3::8a2e:120:3");
		getIpValue("1:ab8:18a3::8a2e:120:3");

		/*
		  1:ab8:18a3:0:0:8a2e:120:3
		 */
	}
}

Console Result

1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3
1:ab8:18a3:0:0:8a2e:120:3

Conclusion

N/A

[ENG][Mina]Using Apache Mina sshd - shell command line

CamelAct — Wed, 31 Aug 2022 18:05:57 +0900

Overview

Apache Mina was used. In the past, there are many examples of ssh connection using Jsch on the Internet. But Jsch doesn't update anymore. This can be a security risk. Apache Mina is constantly updated, and the method used is almost similar to that of Jsch, so it can be replaced.

First of all, there weren't too many examples. The examples in Apache Mina were too poorly explained to work properly.

https://github.com/apache/mina-sshd

There are too many codes, and I just want to connect through ssh and do a shell command, but the code I found does not work.

https://www.baeldung.com/java-ssh-connection

Running the example here only works half way through. One line command line commands work fine. However, consecutive shell command input does not work.

You will get an error with "channel.open()" and "channel.waitFor(..").

The following is an example code that confirms the normal operation of the Shell Command.

Code Example

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.Collections;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.sshd.client.SshClient;
import org.apache.sshd.client.channel.ChannelShell;
import org.apache.sshd.client.channel.ClientChannelEvent;
import org.apache.sshd.client.future.ConnectFuture;
import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.common.util.io.input.NoCloseInputStream;
import org.apache.sshd.common.util.io.output.NoCloseOutputStream;
import org.springframework.web.socket.TextMessage;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SshdMina {
	private static final ExecutorService executor = Executors.newCachedThreadPool();

	private static final int PIPE_STREAM_BUFFER_SIZE = 1024 * 100;
	final PipedInputStream sshClientInputStream = new PipedInputStream(PIPE_STREAM_BUFFER_SIZE);
	final PipedOutputStream sshClientOutputStream = new PipedOutputStream();
	private final PipedInputStream bizInputStream = new PipedInputStream(PIPE_STREAM_BUFFER_SIZE);
	private final PipedOutputStream bizOutputStream = new PipedOutputStream();

	public static void main(String[] args) throws Exception {
		new SshdMina().boot();
	}

	private SshdMina() throws IOException {
		sshClientInputStream.connect(bizOutputStream);
		sshClientOutputStream.connect(bizInputStream);
	}

	private void boot() throws Exception {
		final SshClient client = SshClient.setUpDefaultClient();
		client.start();
		final ConnectFuture connect = client.connect("your usename", "your ip address", 22);
		connect.await(5000L);
		final ClientSession session = connect.getSession();
		session.addPasswordIdentity("your password");
		session.auth().verify(5000L);

		final ChannelShell channel = session.createShellChannel();
		channel.setIn(new NoCloseInputStream(sshClientInputStream));
		channel.setOut(new NoCloseOutputStream(sshClientOutputStream));
		channel.setErr(new NoCloseOutputStream(sshClientOutputStream));

		channel.setPtyType("xterm-256color");
		channel.setEnv("LANG", "en_US.UTF-8");
		channel.open();

		beginRead();
		beginWriteStd();

		channel.waitFor(Collections.singleton(ClientChannelEvent.CLOSED), 0);
	}

	void beginRead() {
		executor.execute(() -> {
			final byte[] buffer = new byte[10240];
			String line = "";
			while (!Thread.currentThread().isInterrupted()) {
				try {
					while (bizInputStream.available() > 0) {
						int i = bizInputStream.read(buffer, 0, 1024);
						if (i < 0) {
							break;
						}
						line = new String(buffer, 0, i);
						System.out.println(line);
						System.out.flush();
					}

					try {
						Thread.sleep(100);
					} catch (Exception ee) {
					}
				
					
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		});
	}

	void beginWriteStd() {
		executor.execute(() -> {
			try {
				final Scanner in = new Scanner(System.in);
				while (!Thread.currentThread().isInterrupted()) {
					final String command = in.nextLine();

					bizOutputStream.write((command + "\n").getBytes());
					bizOutputStream.flush();
				}

				in.close();
			} catch (Throwable e) {
				e.printStackTrace();
			}
		});
	}
}

build.gralde

implementation group: 'org.apache.sshd', name: 'sshd-core', version: '2.9.0'
implementation group: 'net.i2p.crypto', name: 'eddsa', version: '0.3.0'

Console Result

[root@control-plane ~]# pwd
18:38:28.166 [sshd-ClientInputStreamPump[31304]-thread-1] DEBUG org.apache.sshd.common.channel.Window - waitForSpace(Window[client/remote](ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22])) available: 2093782
18:38:28.166 [sshd-ClientInputStreamPump[31304]-thread-1] DEBUG org.apache.sshd.common.channel.Window - waitAndConsume(Window[client/remote](ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22])) - requested=4, available=2093782
18:38:28.166 [sshd-ClientInputStreamPump[31304]-thread-1] DEBUG org.apache.sshd.client.session.ClientSessionImpl - encode(ClientSessionImpl[root@/10.251.94.146:22]) packet #38 sending command=94[SSH_MSG_CHANNEL_DATA] len=13
18:38:28.166 [sshd-ClientInputStreamPump[31304]-thread-1] DEBUG org.apache.sshd.common.io.nio2.Nio2Session - writeBuffer(Nio2Session[local=/10.251.94.146:44560, remote=/10.251.94.146:22]) writing 44 bytes
18:38:28.167 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=1
p18:38:28.167 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=1
w18:38:28.168 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=3
18:38:28.168 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=7
d
/root
18:38:28.168 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=25
 ]0;root@control-plane:~ 18:38:28.168 [sshd-SshClient[3bd323e9]-nio2-thread-8] DEBUG org.apache.sshd.client.channel.ChannelShell - handleData(ChannelShell[id=0, recipient=0]-ClientSessionImpl[root@/10.251.94.146:22]) SSH_MSG_CHANNEL_DATA len=24
[root@control-plane ~]#
[root@control-plane ~]# ls -lrt

[ENG][아키텍처]기본 베이스

CamelAct — Wed, 31 Aug 2022 01:10:32 +0900

Library/Framework./Platform

Library : 재사용이 필요한 기능들을 모듈화해서 언제든지 호출하여 사용가능하도록 한 것
Framework : 원하는 기능 구현에만 빠르게 집중하여 개발할 수 있도록 공통적으로 필요한 기능을 갖추고 있다. 프레임워크 안에 기능을 추가해야하고, 프레임워크가 정한 규칙, Life cycle에 의존하여 개발해야한다.
Platform : 프로그램이 실행되는 환경을 말함, 어플리케이션을 동작시킬 때 기반이 되는 OS와 그밖의 환경, 설정 등

Complexity

시간 복잡도 - 문제 해결하는데 걸리는 시간과 함수 관계
공간 복잡도 - 완료하는데 필요한 자원 공간의 양

Stakeholder의 의견이 조율이 되지 않을 때에는 어떻게 해야하나?

먼저 Stakeholder들간의 의견들을 토대로 후보모델들을 분석해야 한다. ATAM과 같은 방법을 통하여 각 stakeholder가 가지는 요구사항과 그에 따른 품질 속성, 후보모델들의 architecture를 분석한다.
그리고, 각 후보모델들에 대한 분석 결과를 기반으로, CBAM(Cost Benefit Analysis Method)와 같은 평가방법을 통해 architecture 중에 최적의 architecture를 선택한다.

Balanced mvc?

MVC Style 과 Client-Server Style을 통합한 것
Client 와 Server 각각에 MVC Style이 적용되어 있다

MVC와 MVVM의 차이를 설명해보세요

MVC는 상호 통신을 하지만 MVVM의 경우 단 방향으로 통신하며, 모든 응답은 event로 처리되거나 binding 한다
Comment) MVC에서는 View가 직접 Model을 참조할 수 있다는 차이점이 있다고 조언

본인의 설계가 타당한지 어떻게 확신하는가?

평가검증에서 QA Scenario 정의하고 scenario를 성공하기 위한 Architectural Approach를 제시

Product line 과 Application과 Domain 관점에서 차이

Product 들을 categorising 한 후 필요한 product들을 선택해서 최종 product 를 만들어 내는 것으로 재사용성을 극대화하며, 수많은 모델로 파생되는 것에 효율적으로 대응할 수 있게 된다.
전체 product들의 기능들을 use case별로 나열하고 해당 기능들을 category별로 정리를 한 후, product별 공통적인 기능, 특정 category의 Product가 필요로 하는 기능들로 분류한다.
그리고, 기능별 category, 공통 기능으로서의 category, family product들이 가지는 공통 기능등으로 나누어, category별 기능 component들을 정의하여 개발
실제 product 개발시 category별 기능들을 선택하여 조합하여 최종 product를 정의하여 개발
수많은 파생모델이 존재하는 경우, category별 개발된 component

SPL

#. SPL? (Software Product Line)
- 재사용 단위인 core asset을 이용하여, 공통 부분은 가져다 쓰고, 가변 부분은 개발하여 product을 만들어내는 방법

#. SPL 효과
- 생산성 향상
- 품질 향상
- 비용 감소
- 빠른 제품 출시

아키텍처 드라이버를 도출하는 단계를 설명하라

Architecture driver란 SW architecture가 가져야하는 Functional Requirement와 Non-functional Requirement이다.
목표를 설정 -> Use case들을 도출 -> Use case diagram에서 quality scenario 도출 -> quality attribute들을 도출 한 후, architecture를 결정하는데 있어 중요한 것들을 선택.

Architecture Design / Architecture Style / Architecture Pattern / Design Pattern 의 차이점

Architecture Design: Architecture를 만들어(design해) 가는 과정 전체
Architecture Style: high level의 컴포넌트 간의 관계를 보여준다. 각 컴포넌트는 package 정도의 단위이다. 구조적인 표현에 초점, 품질속성과 관련 장단점 추리기
Architecture Pattern: 보다 세분화된 컴포넌트 간의 관계를 보여준다. Functional View(Component Diagram)가 그려진다. 문제와 연관된 솔루션 제시
Design Pattern: Class 단위의 세분화된 구조를 보여준다. Information View(대략적인 Class Diagram)와 Behavior View(Sequence Diagram, State Machine Diagram)가 그려진다.

COR과 decorator는 responsibility를 덧붙이는 구조로 유사한것 같은데 차이점은?

cor은 연결리스트와 같이 수평한 구조로 책임을 덧붙이며, decorator는 계층적으로 책임을 덧붙입니다.

State Machine Diagram에서 병렬 수행을 나타내는 notation은 무엇인가?

Parallelization node & Synchronization node

State Machine Diagram에서 transition을 표시하는 3가지

Event (trigger), Guard (condition), Activity (Effect)

스테이트 다이어그램에서 orthogonal 스테이트가 무엇인지
Compatible and independent 하게 동시에 존재하는 2개 이상의 스테이트

OOAD와 SW Architecture 차이가 무엇인가?

: OOAD는 주어진 문제에 맞도록 클래스간의 구조와 동작들에 패턴을 적용하여, 클래스에 대한 패턴
: SW Architecture는 전체 system을 목적에 맞는 architecture style을 적용하여 subsystem이나 component단위로 분리하고 component들간의 관계와 communication을 정의하는 것으로, 전체 System에서의 subsystem과 component들에 대한 패턴
이러한 관점에서 보았을 때, SW공학은 비기능적인 요구사항을 고려하여 비기능적 요구사항을 만족시키기 위한 개발 과정에서 구조적인 변경 가능성을 최소화 해 줄 수 있다. 반면 OOAD는 넓은 범위에서 component별 구조를 고려하지 않기 때문에 추후 발생할 비기능적인 요구사항이나 NFR변경에 취약한 구조가 될 수 있다.

알고리즘을 다양하게 쓸 수 있는 패턴들과 component level interface를 정의하는 게 어떤 차이가 있나?

=> Strategy pattern.
=> Provided interface <-> required interface
: Strategy는 특정 behavior나 method의 알고리즘이나 동작 방식이 runtime에 바뀔 수 있는 경우 적용하는 패턴으로, context class가 strategy interface를 member로 가짐으로서 알고리즘을 변경할 수 있다.
: Strategy pattern의 경우, 해당 클래스를 사용하는 client측에서 어떤 알고리즘을 쓸 것인가를 확인하고 명시적으로 알고리즘을 교체하지만, component level interface는 외부 component가 내부 component를 볼 수 없기 때문에 component level interface를 통해 제공되는 behavior가 변경되더라도 이를 알 수 없다.

마이크로 커널을 클래스 레벨로 어떻게 구성할 것인가?

Microkernel architecture - system requirement가 빈번히 변경되는 경우, minimum functionality만을 제공하는 core system과 각 feature들을 분리하고, 특정 기능이 필요한 경우 해당 기능을 구현한 plugin을 사용하여 기능을 동작하는 architecture style.
: Microkernel에서 core system은 정해진 순서에 따라 동작을 진행하고, 그 과정에서 plugin의 인터페이스를 순서대로 호출하도록 해야 한다. 그리고, plugin 개발자는 core system에서 요구하는 plugin에서 제공해야하는 interface들을 구현하는 형태로 plugin을 개발하여 제공하면 된다. 따라서, 이러한 형태에 가장 적합한 Template method pattern을 적용하여, core system에서 필요로 하는 인터페이스를 abstract class로 정의하여 두고, plugin개발자는 concrete class로 plugin을 개발하여 제공함으로써 기능을 동작하도록 할 수 있다.

ADD (Attribute Driven Design) 방법론

기능 요구사항, 품질 요구사항을 아키텍처에 반영하는 아키텍처 설계 방법이다.
분해할 모듈을 선택 > 선택한 모듈을 분해하고 정제(동인 결정, 스타일 선택, 기능 할당, 하위 인터페이스 정의, 하위 제약사항 변경) > 계속 반복

Architecture viewpoint 중 Logical View에서는 use case를 묶어서 component에 할당하게 되는데, 어떤 use case들이 한 component로 할당되도록 하는 판단 기준이 있나?

cohesion은 높고 coupling은 낮도록 component 나누거나 합치기

Abstract Class를 상속하는 것 보다 Interface를 구현하도록 하는 것이 갖는 장점은?

Abstract Class : is a 관계가 명확하고 일부 구현이 필요한 경우
Interface : 역할 구분을 명확하게 하고 다중 상속, 일부 구현이 필요 없는 경우

Repository Style과 Black board style의 공통점과 차이점을 설명하고, 저장되는 내용의 차이도 설명하라

Data centric architecture로 Data를 어떻게 다루는지에 따라 구성된 Architecture라는 점에서 공통점이 있다.
Repository style은 data storage가 passive한 역할을 수행하며, system의 subsystem 또는 component들이 data를 읽거나 쓰고자 할 때 storage에 정보를 저장하거나 읽어준다.
Blackboard style은 data storage가 active한 역할을 수행하며, data storage의 state에 따라 event가 trigger되어 subsystem이나 component에 해당하는 Knowledge source가 연산이나 동작을 수행한다. Blackboard style은 control이 있다.

SW 개발 vs 모델링

- SW 개발 = 모델링 + 구현 + 테스트
- 모델링 = 요구사항 정의 + 분석 + 설계

[ENG][아키텍처]Re-engineering

CamelAct — Wed, 31 Aug 2022 01:07:48 +0900

Reverse Engineering 무엇인가요?

제품의 유지보수, 개선 또는 교체를 돕기 위해 제품에 대한 설계 수준의 충분한 이해 를 얻는 프로세스.
재문서화, 설계 복구

Reengineering 무엇인가요?

리엔지니어링은 일반적으로 일부 형태의 리버스 엔지니어링(보다 추상적인 설명을 달성하 기 위해)에 이어 일부 형태의 순방향 엔지니어링 또는 구조 조정을 포함합니다.

Reengineering 방식은?

새로운 형태로 재구성하고 새로운 형태의 후속 구현.
모놀리식 시스템을 별도로 판매할 수 있는 부품으로 분할
디자인 개선 ‒ 유지보수성, 이식성 등을 개선합니다.
신기술의 활용

리팩토링 대상을 선정한다
선정된 대상을 테스트 코드 작성한다.
코드를 분해한 후 재조립한다.
재조립 코드를 테스트한다.
위 과정을 반복한다.

Test Driven Refactoring 무엇인가요?

1 실패한 단위 테스트를 만듭니다.
2. 해당 테스트를 통과하는 프로덕션 코드를 작성합니다
3. 방금 만든 혼란을 정리하십시오.

Golden Master Test

프로세스를 수행한 다음 저장된 "골드 마스터"와 향후 실행을 비교하여 예기치 않은 변경 사항을 발견합니다.

Smell

Long Method

Large Class

Primitive Obsession 객체를 처음 접하는 사람은 보통 숫자와 통화를 연동하는 돈 관련 클래스나 전화번호와 우편번호 같은 특수 문자열 클래스 등의 사소한 작업에 작은 객체를 잘 사용하지 않으려는 경향이 있다.
우물 안 개구리가 되지 않으려면 데이터 값을 객체로 전환해보자.

Long parameter lists

Data Clump 여러 다른 클래스 안에 동일한 변수 그룹이 존재함

Switch Statements

Temporary Field 메서드 범위 안에 있어야할 변수가 클래스 안에 있음

Refused Bequest 하위 클래스가 원치 않는 상위 클래스의 메서드를 상속

Alternative Classes with Different Interfaces 동일한 기능의 클래스인데 다른 이름일 경우

Divergent Change 클래스가 다른 방식으로 계속 변경된다

Shotgun Surgery

Parallel Inheritance Hierarchy 클래스에 대한 하위 클래스를 만들 때마다 다른 클래스에 대한 하위 클
래스를 만들어야 하는 자신을 발견하게 됩니다

Duplicate Code

Lazy Class 클래스를 이해하고 유지하려면 항상 시간과 비용이 듭니다

Data Class 필드와 Getter/Setter만 있는 클래스

Dead Code

Speculative Generality 사용하지 않는 클래스, 메서드, 필드 또는 매개변수가 있습니다. • 때
때로 지원을 위해 "만약에 대비하여" 코드가 생성됩니다.

Feature envy 자기가 속한 클래스보다 다른 클래스에 관심을 가지고 있는 경우이다

Inappropriate Intimacy 두 개 이상의 클래스가 서로의 필드에 너무 많이 관여

Message Chains

Middle Man 너무 많은 위임

Incomplete Library Class

치료 방법

Long Method - Extract Method

Large Class - Extract Class, Extract Subclass

Primitive Obsession - consider turning it into a class

Long parameter lists - Replace Parameter With Method

Data Clump - Extract Class, Introduce Parameter Object, Preserve Whole Object

Switch Statements - Extract Method, Move Method, Replace Type Code

Temporary Field - Extract Class, Replace Method with Method Object.

Refused Bequest - Create a new subclass and use Push Down Method and Push Down Field on the unused methods

Alternative Classes with Different Interfaces - Rename Method, Move Method, Add Parameter and Parameterize Method

Divergent Change - Extract Class

Shotgun Surgery - Move Method and Move Field

Parallel Inheritance Hierarchy - Merge Class

Duplicate Code - Extract Method

Lazy Class - Collapse Hierarchy

Data Class - Encapsulate Field, Encapsulate Collection

Dead Code - Collapse Hierarchy

Speculative Generality - Collapse Hierarchy, 사용하지 않는 클래스, 메소드, 필드

Feature envy - Extract Method

Inappropriate Intimacy - Move Method, Move Field, Extract Class, Replace Inheritance With Delegation

Message Chains - Hide Delegate

Middle Man - Remove Middle Man, Inline Method

Incomplete Library Class - Introduce Foreign Method

CC = Cyclomatic Complexity

CC는 정량적 수치를 기반으로 여러 설계를 직접 분석할 수 있는 등 설계 단계에서 사용이 유용하다.
Threshold = 10

NPath

조건부 * 조건부 * 조건부 … Threshold = 200

[ENG][아키텍처]Architectural Evaluation

CamelAct — Wed, 31 Aug 2022 01:07:13 +0900

ATAM - Architecture Tradeoff Analysis Method

Quality Attribute를 기준으로 시나리오를 정하고, 우선순위 결정(유틸리티 트리 만들기) 우선순위가 높은 시나리오에 대해 S R T N 를 알아보고 대안 아키텍처를 결정

Sensitivity Point 란 무엇인가요?

A는 B에 영향을 준다 Sensitivity Point
CBAM - Cost Benefit Analysis Method

What is the procedure of applying x method?

품질 속성 시나리오를 작성한다. 그중에서 개발 난이도, 중요도 등을 고려하여 우선순위를 정하여 유틸리티 트리를 작성한다.
대안 아키텍쳐를 나열하고 품질 속성별로 T를 작성한다, - 포인트 지점이 R이 되고 이를 분석하여 두 아키텍처를 비교한다

SAAM VS ATAM VS CBAM

차이점에 대해서 설명하세요

SAAM – Software Architecture Analysis Method
– 변경 용이성, 기능 집중, 평가 용이,
– 직접 / 간접 시나리오를 작성하고, 이를 기반으로 아키텍처의 영향도를 분석하여 평가하는 아키텍처 평가 방법

ATAM – Architecture Trade-off Analysis Method
– 품질속성 만족 여부 판단, 이해 관계 평가,
– 품질속성 시나리오에 기반하여 아키텍처 Tradeoff를 분석하고, 이에 대한 risk를 찾아내는 아키텍처 평가 방법

CBAM – Cost Benefit Analysis Method
– 의사결정 요구 충족, ATAM바탕 분석,
– 아키텍처를 기반으로 비용, 이익 등을 분석하여 아키텍처적 판단을 내리는 경제 측면의 평가 방법

정적분석, 무엇이 있나요?

소프트웨어 지표 복잡도, 결합도
객체지향 지표
의존성 분석

동적분석, 무엇이 있나요?

메모리 분석, 쓰레드 프로세스 분석

Architecture Style의 Applicability를 평가하는 방법은 무엇입니까?

: 각 설계 스타일에 대해서 Applicable situation을 작성한 후, 각 상황에 대한 시스템의 수요를 적어 일치하는 지 평가한다.
: 각 설계 스타일에 대해서 Pros, Cons를 적고 시스템에 가져올 장점과 시스템에서 어떻게 단점을 해결할 것인지 적고 Match하는지 평가한다.

[ENG][아키텍처]Applying Tactics for NRF

CamelAct — Wed, 31 Aug 2022 01:06:12 +0900

conventional NFR의 효과적인 tactic이 무엇인가?

availability, efficiency 등 ISO 9126에 있는 것들에 대한 건 다 숙지해 놓을 것
Q) efficiency
resource 관점의 efficiency
runtime 관점의 efficiency
구별해서 이야기 할 것

Methods and tactics are widely available for Conventional NFRs.
Architects should utilize existing approaches and tactics.
&번역
방법과 전술은 기존 NFR에 널리 사용 가능합니다.
건축가는 기존 접근 방식과 전술을 활용해야 합니다.

ISO 9026, 범용적, 가용성 높음

Architecture Design for Non-Conventional NFRs

Methods and tactics are not widely available for NonConventional NFRs.
Architects should define an effective process for the particular NFR, and apply the process.
iTechnical Hardship for this is high
&번역
방법과 전술은 비재래식 NFR에 널리 사용되지 않습니다.
설계자는 특정 NFR에 대한 효과적인 프로세스를 정의하고 프로세스를 적용해야 합니다.
이에 대한 iTechnical 어려움이 높음

대상 시스템에 특정한 NFR, 가용성 낮음

Tactics 무엇인가요?

전술: 품질 시나리오에서의 자극(Stimulus)에 대한 기대 응답 (Response)를 수행하기 위한 여러 방법 및 패턴을 의미함

Tactics의 종류를 나열해 보세요.

Modifiability Tactics
응집성 증가, 모듈 분할, 캡슐화, 중재자 사용, 공통 추상 서비스, 의존성 제약, 바인딩 지연 시간

Availability Tactics
오류 감지, 오류 복구: 준비/수리, 오류 예방

Interoperability Tactics - 상호운용성
인터페이스 관리,

Usability Tactics
취소, Undo, 정지/재시작

Performance Tactics
연산 부하 감소, 실행 횟수 제한, 큐 크기 제한

Security Tactics
공격 감지, 메시지 무결성 검증, 사용자 인증, 데이타 암호화

Testability Tactics
특화된 인터페이스, 기록/재생, 데이타 소스의 추상화, 구조적 복잡성 제약

Design for Non-Functional Requirements Step 말하세요.

Identify Facts and Policies
Define Criteria for Tactics
Propose Architecture Tactics
Evaluate Architecture Tactics
Analyze Impacts of Tactics
Apply Architecture Tactics
Validate Conformance

Tactics for Availability 가용성 Tactics 말해보세요

Prevention
Phase Commitment Transaction
Active Redundancy
Passive Redundancy
Spare

Fault Tolerance
Ping/Echo
Heartbeat
Voting
Process Monitor / Watch Dog
Exceptions

Recoverability
Shadowing
State Resynchronization
Rollback with Checkpoint

Recoverability는 뭘 복구하려는 건가?

sw product가 복구대상. 복구하고 어느정도 퍼포먼스 유지
fail할 당시에 어떤 data를 처리하고 있다가 function fail했다면,
이때 partially update해버리는 경우가 있다
마저해서 성공하게 하거나 처음으로 롤백시켜줘야함.

[ENG][아키텍처]Applying Viewpoints

CamelAct — Wed, 31 Aug 2022 01:05:44 +0900

View 란?

시스템을 이루는 SW요소들의 집합 과 SW요소들의 연관 관계를 추상적 으로 표현한 것

Module View 무엇인가요?

Module간의 상호 연결 관계

Runtime View = Component and Connector View(C&C View)

예를 들어 뭐가 있을까요?
split lower upper merge 등

파이프-필터 스타일(Pipe-and-Filter Style)
공유-데이터 스타일(Shared-Data Style)
게시-구독 스타일(Publish-Subscribe Style)
클라이언트-서버 스타일(Client-Server Style)
피어 투 피어 스타일(Peer-to-Peer Style)

Allocation View 무엇인가요?

folder hierarchy

배치 스타일(Deployment Style)
컴포넌트-커넥터 스타일의 요소를 실행 플랫폼에 할당 } 일반적으로 통신 프로세스 스타일(Communicating-Processes Style)요소를 할당

4+1 View

Logical View
Process View
Development View
Physical View
+Use Cases/Scenarios

유스케이스 뷰

(Usecase View)
다른 뷰를 검증하는데 사용
사용자, 설계자, 개발자, 테스트 관점
유스케이스 다이어그램

논리 뷰
(Logical View)
시스템 기능 적인 요구사항이 어떻게 제공되는지
클래스나 컴포넌트의 종류와 관계를 설명하고 설계가 실제로 구현 되는지 설명
설계자 관점 (순서도나 UML 그리는 시점)
클래스/시퀀스 다이어그램

프로세스 뷰
(Process View)
시스템의 비기능적인 속성으로 자원의 효율적인 사용, 병행 실행, 비동기, 이벤트 처리 등을 표현한 뷰
성능, 확장성, 효율성 관련
시스템 통합자의 관점
시퀀스/협력 다이어그램

Development 뷰
개발 환경 안에서 정적인 소프트웨어 모듈의 구성을 보여주는 뷰
컴포넌트 구조와 의존성을 보여주고 컴포넌트에 관한 부가적인 정보 정의
실제 구현할 수 있는지 여부를 확인
직접 만드는 개발자의 관점
컴포넌트 다이어그램

Physical 뷰
컴포넌트가 물리적 환경에서 배치 연결 작업이 어떻게 실행 되는지를 매핑해서 보여주는 뷰
배치(배포) 다이어그램

Context View 무엇인가요?

시스템과 환경사이의 상호작용과 의존성 관계를 표현한다
시스템과 관련된 사람, 시스템 및 외부 엔터티 포함 상호 작용, 하이레벨로 이해를 위한, 미리 알고있는 관점, 10, 20년된 시스템의 2.0 버젼은 이거 필요 없다 ~= usecase view

DFD - Data Flow Diagram 무엇인가요?

특정 기능을 나타냅니다. 레벨 0 DFD에서는 전체 대상 시스템을 나타냅니다
공통 터미널 - .사용자, 외부 시스템, 하드웨어 장치
데이터 저장소
데이터 흐름 정의

DFD의 터미널에 유스케이스 액터가 안되는 경우가 있는지

DFD에서 터미널이란 입력 정보를 주는 주체, 인풋 아웃풋
usecase에서 엑터는 특정 기능을 인보크하는 주체 또는 인보크를 당하는 주체
= 터미널에 있었다고 해서 전부 액터로 쓸필요는 없다

Functional View 무엇인가요?

시스템의 기능적 요소, 해당 책임, 인터페이스 및 기본 상호 작용.
시스템의 Functional elements와 elements들의 책임, 컴포넌트 간의 interface, interaction 을 의미한다. 이
해관계자들이 가장 먼저 읽게 되는 첫 부분으로 다른 뷰들의 모습을 이끌어내야 한다.

Functional Context

액터 정의, 기능 그룹 정의, 사용 사례 정의, 호출 정의, 관계 정의

Functional Viewpoint Steps

1. Refine Use Case Model - 유즈케이스 다이어그램 다시 그리기
2. Define Functional Components - 파란색 묶는거
3. Allocate Functional Components - 배포 뷰에 할당
4. Design Functional Components - 아래

Functional component를 잘 찾았는지 아는 기준은?

functional component는 modularity가 높아야 함.
cohesion높고(한 component가 one & only 기능만 handle)
coupling 낮아야함(component간에 dependency 최소화)

Design Functional Components 무엇을 정의해야 하나요?

Defining Visibility - Black, White Box
Defining Variability - Mediator, Facade
Defining Interfaces - Opened, Closed

인터페이스 디자인 원리 말하세요.

노출이 적을수록 좋다
Method가 Field보다 좋다
Factory가 Constructor보다 좋다
한 가지 기능, SRP
구현이 API에 영향 주어서는 안 된다.
접근성 최소화 캡슐화
이름을 잘 지어라
테스트에 염두

white box / black box

white box compo와 black box compo는 UML에서 어떻게 표현할까?
package diagram : 안이 다 보임.아예 interface 정의가 없음
class들의 단순한 집합
자바의 패키지는 white box이다. 외부로부터 패키지쓸때 바로 접근
component diagram : black box. interface정의 있음

Information View 무엇인가요?

정적 데이터 구조의 높은 수준 보기
영구 데이터를 다룬다. 설계를 저장하고, 다루고, 관리하고, 정보를 분배하는 방법을 묘사한다. 내용, 구조, 지연, 참조, ownership, data migration을 고려한다.

Information Context 무엇인가요?

클래스 정의, 관계 정의, 카디널리티 정의,

Information Viewpoint Steps

1. Refine Object Model - 클래스 다이어그램 다시 그리기
2. Define Data Components - 파란색 묶는거
3. Allocate Data Components - 배포 뷰에 할당
4. Design Data Components - 메서드, 어트리뷰트, 인터페이스 정의 등

Behavior View 무엇인가요?

시스템의 런타임 구조, 즉 동작을 설명합니다
시스템의 동시성을 묘사한다. 동시에 동작하는 시스템의 부분들을 식별하고 어떻게 중재하고 조절되는지를 표현한다. 과정, 스레드, 상호동작을 고려한다.

Behavior Context 무엇인가요?

행동 패턴 관찰, 기능 그룹에 대한 스케치 제어 흐름

Behavior Viewpoint Steps

1. Define Overall Control Flow - 재작성
2. Identify Complex Behavior - 하나 골라서 상세히 작성
3. Define Detailed Control Flows

Behavior 용어 정의, activity와 action의 차이

action : atomic operation(완료하거나 중지하거나 둘중하나뿐인상태)
fault 발생시 abort 되는 단위
activity : group of action

Detail activity 설명할때 diagram쓰는 이유와 장단점

1. common vocabulary. 내 설계를 다른 사람이 볼때 오해없어
2. specific purpose : 내목적에 맞는 diagram
3. limited vocabulary : (장점)precise (단점) 표현력이 떨어짐
표현력 떨어지는걸 보안하기 위해 슈도코드로 표현.

Development View 무엇인가요?

소프트웨어 개발 프로세스 를 지원하는 아키텍처를 설명합니다
시스템이 배포될 환경을 기술한다. 하드웨어 환경, 기술적 환경, 런타임 환경을 고려한다.

Deployment Views 무엇인가요?

시스템이 적용되는 환경을 설명합니다

Deployment Viewpoint Steps

1. Define Nodes
2. Define Network Connectivity
3. Deploy Software Artifacts

Operational View 무엇인가요?
시스템이 프로덕션 환경에서 실행될 때 시스템이 어떻게 작동, 관리 및 지원되는지 설명합니다, 개발 끝나고 운영할 때 이렇게 운영하는 관점, 지침

facade, mediator의 차이가 뭔가요?

내부를 안보여주는것은 똑같다

facade : 외부 component가 직접 들어오지 못하게 블랙박스화 하는 것.
외부에서 온것을 내부에 delegate 하는것.
외부와 내부를 decoupled 시킴(독립적으로 유지보수 된다) 메시지를 받은대로 그냥 넘겨주는것, 흐름을 클라이언트가 결정할 수 있다.
flow가 client마다 다르다면 facade.
mdeiator : 컨트롤 알고리즘 로직 수행등을 한다. 내부적으로 취합할게 있다면, 기능을 수행할 순서가 정해져 있다면. mediator = coordinator
flow가 고정되어 있다면 mediator

[ENG][아키텍처]Skeleton/Core Architecture

CamelAct — Wed, 31 Aug 2022 01:04:51 +0900

Architect란?

Architect : 한정된 자원 내에서 기능 및 품질 요구사항을 최대한 끌어올릴수 있도록 균형을 맞추는 사람, Concern을 잘 포착하고 이것을 설계에 반영함
통찰력, 추상화, 설득력 필요

Architecture Style Pattern 적용 효과

안정성, 의사소통, 생산성, 재사용, 접근성
디자인 패턴에서는 솔루션이 들어가야한다
아키텍쳐스타일에선 유형이 들어가야한다.

Architecture 설득 방법.

ATAM, Trade off, Risk 등을 분석 설득, 판단의 근거를 Tracebility하게 남겨두어야 근거로 쓸 수 있다.
Architecture: Definition

아키텍처란?

프로그램 혹은 컴퓨팅 시스템의 소프트웨어 아키텍처란 소프트웨어 구성요소, 이들 구성요소의 가시적인 속성, 그리고 구성요소 사이에 관계 로 구성된 시스템의 전체적인 구조 또는 구조들을 말한다

Architecture Style & Pattern 차이?

Architecture Description의 세 가지는?

Skeleton Architecture - Architecture Styles
Design for NFRs - Architecture Tactics for NFRs
Design for Views - Architecture Viewpoints

Quality Attributes and Software Architecture

Robustness : 견고함

Trade off 예를 들어 설명하세요.

기능과 품질은 상호 독립적(orthogonal)이다.
품질 속성은 반드시 초기 설계에 반영이 되어야 한다.
아키텍처 구성에 있어 품질 속성 간 Trade-off가 있을 수 있다.

Skeleton Architecture Design, Step 말하세요.

구조적 특성 관찰,
후보 Architectural Styles 정의,
후보 아키텍처 스타일 평가,
아키텍처 스타일 통합,
정교한 스켈레톤 아키텍처

아키텍처 스타일 통합 순서

1. Tiers 관련된 스타일
- Tier-based Architecture Styles
- Client Server architecture style
- N-tier architecture style
- Peer-to-Peer architecture style
- Load-balancing Architecture Styles
- Broker architecture style
- Dispatcher architecture style
- Master Slave architecture style•
- Edge-based architecture style

2. 서비스 관련 스타일
- Microservice architecture style
- Service-Oriented Architecture (SOA) style

3 레이어드 스타일
- Layered architecture Style
- MVC architecture style

4. 행동 스타일
- Batch Sequential architecture style
- Pipe-n-Filter architecture style
- Event-Driven architecture style
- Publish-and-Subscriber architecture style

5. 가변성 있는 스타일
- Micro Kernel architecture style
- Microservice architecture style
- Blackboard architecture style
Component간의 Interactions

Skeleton Architecture를 완성한 후 Component간의 Interactions을 정의하는 이유는 무엇인가?

: Interaction은 Component간의 의존성과 영구적인 관계에 대한 설명이 될 수 있으며, function call과 커뮤니케이션이 필요한 Component간의 메시지 전송을 보여준다.

[ENG][아키텍처]Architecture Styles

CamelAct — Wed, 31 Aug 2022 01:04:01 +0900

Active Repository Architecture Style

이 스타일은 리포지토리의 데이터 세트가 응용 프로그램( 예: 접근 모듈)에서 수동으로 액세스하는 공유 리포지토리 아키텍처 스타일을 약간 수정한 것입니다. 데이터세트 의 수동적 공유 는 Active Repository 아키텍처 스타일에서 능동 공유 로 변경됩니다 . 활성 저장소 는 구독자, 즉 응용 프로 그램의 레지스트리를 유지 관리하고 저장소 업데이트 이벤트를 구독자에게 적극적으로 알립니다.

Batch Sequential Style

대용량 처리에 용이
구성 요소가 완료될 때까지 실행되고 다음 구성 요소가 시작되기 전에 전체 출력을 전송합니다. 사용자는 실행 중에 시스템과 상호 작용하지 않습니다. 그들은 출력을 받기 위해 실행이 끝날 때까지 기다립니다.
각 Sub System을 독립적으로 처리하는 프로그램이 될 수 있다.

cons : 대기시간이 길고, 대화식 인터페이스 제공 불가, 동시성 미지원

Blackboard Style

Shared data, database와 같은 데이터 중심 패턴 중에 하나
명확히 정의된 문제 해법이 없을 때 문제를 풀어가는 하나의 방식을 정의한 패턴
대략적으로 해법을 수립하기 위해 특수한 서비스 시스템의 지식을 조합하는 패턴

pros : 완벽한 해법을 찾기 어려운 경우에 사용할 수 있음; 다양한 실험 가능
KS, Control, Blackboard 가 독립적으로 동작하여 가변성이나 유지보수 성이 좋음
KS는 타 문제 도메인에 재사용될 수 있음
장애 허용(Fault tolerance)과 저항성(robustness)을 지원함

cons : 계산 결과가 항상 동일하지 않아 테스트가 어려움
어떤 좋은 해법도 완벽하다고 장담할 수 없음
좋은 전략 수립 어려움; 효율이 낮음
많은 시간에 걸쳐 수정되어야 하므로 개발에 많은 노력이 필요

Broker Style

아키텍처는 특정 시스템 혹은 특정 구현의 세 부 사항을 컴포넌트나 서비스 사용자로부터 숨겨야 함
Broker 컴포넌트가 클라이언트와 서버의 정보를 가지고 있어 서로간의 통신을 조율
클라이언트와 서버 Proxy를 두어 특정 환경과 관련된 부분을 처리
브로커는 그때그때마다 서버 호출이 바뀔수 있다 Stateless <-> 디스패처는 Dedicated

pros :
컴포넌트간의 위치 투명성, 컴포넌트의 가변성(Changeability)과 확장성(Extensibility)이 보장, 플랫폼 간의 이식가능성(Portability) 제공함, 재사용 컴포넌트 확보에 용이(Reusability)

cons :
성능에 대한 불이익, 브로커 장애 발생 시를 대비해, 컴포넌트를 복제해 둠으로써 신뢰성을 보장해야 함, 테스트 디버깅의 복잡함

Client-Sever Style

pros : 분산 환경에서 UI presentation와 business logic의 분리에 용이함.
Server의 reusability가 높음.

cons : 요구 사항 변경시 client/server 양단을 변경해야하는 번거로움이 있음.
Server의 가용성, 안정성을 유지하는데 어려움이 있음.
Server/Client가 분산되어 있어 보다 복잡하고 어려운 보안 이슈가 발생할 수 있음

Dispatch Style

QoS evaluator랑 Sever allocator

pros : 서버의 교환가능성 보장, 서버의 위치 투명성 보장, 서버의 재구성 가능, 장애 허용성 보장, availability가 높아짐, Scalability가 높아짐.

cons : 명시적이며 우회적인 연결을 설정하기 때문에 효율성이 낮음, 디스패처 컴포넌트의 인터페이스에 발생하는 변경에 민감함

Edge Style

pros : 응답 지연(Latency) 감소, 대역폭(Bandwidth) 요구 감소, 신뢰성(Reliability) 증가

cons : 저장매체가 제한이 됨, 전원의 소모가 큼

Layered Style

각 레이어는 펑션콜이지 네트웍이 아니다
소프트웨어를 레이어 단위로 분할
각 레이어는 인터페이스를 가진 가상 머신(virtual machine)
가상 머신은 엄격한 순서 관계에 따라 상호작용

하위 레이어의 변경은 인터페이스 뒤에서 은폐됨
하위 레이어의 변경이 상위 레이어에 영향을 미치지 않음

시스템의 규모가 커서 분해할 필요가 있을 경우
하위 레벨과 상위 레벨 이슈가 서로 혼재해 있다는 점이 주된 특징인 시스템 설계

pros :
레이어 별 연동을 한정할 수 있어 Loosely coupled 원칙을 지킬 수 있음, 레이어 재사용 가능

cons : 레이어 동작 변경 시 단계별 재작업 필요, 효율이 낮음 - 계층의 원칙을 지키기 위해 각 계층을 모두 거침

Master Slave Style

pros : 교환가능성(Exchangeability)와 확장성(Extensibility)을 도입, 관심사항(Concerns)의 분리가 가능, 병렬 계산을 신중히 구현하면, 특정 계산에서의 성능 향상 가능

cons : Master의 작업 분할, 할당, 대기, 결과 계산 등을 위한 처리 시간과 공간 필요 - Feasibility
병렬 계산을 위해서는 하드웨어에 종속, 변경용이성과 이식성 하락 - 머신 종속성의 제약을 받음

Microkernel Style

시스템의 요구사항이 변할 때, 이를 쉽게 시스템에 반영하기 위한 패턴, 일반적인 시스템의 기능에서 최소 핵심 기능은 공통으로 두고 변경이 가능한 확장 부분을
- 플러그인 방식으로 추가할 수 있는 패턴
- Microkernel 은 파일이나 프로세스처럼 리소스를 저장하는 역할을 하고 다른 컴 포넌트들이 접속할 수 있도록 인터페이스를 제공함
- Microkernel 내에 구현할 필요가 없는 핵심 기능은 Internal server로 분리시 켜 크기나 복잡성을 줄임
- External server에는 External server 자체의 뷰를 구현하고 Microkernel 의 인터페이스를 이용하여 연동함
- Client는 Microkernel의 통신 기능을 이용하여 External server와 통신

pros : 모듈 단위 개발로 확장과 포팅이 용이, 이식성이 보장, 유연성과 교환가능성이 확보, 유지보수성과 가변성을 향상, 확장성(Scalability) 확보(새 머신 추가), 신뢰성 지원(서버 문제), 투명성을 제공

cons : 메시지 전달하는 방식으로 자원에 접근하여 태스크 스위칭에 많은 오버헤드 초래, 시스템 설계가 복잡하고 개발이 어려움

MVC Style

시스템이 3개의 레이어로 명확하게 분할된 경우.
시스템이 고도로 사용자 상호 작용하는 경우
비즈니스 프로세스 를 기본 데이터 표현 과 독립 적으로 모델링 해야 하는 경우.

pros :
동일한 모델로부터 여러 View 들을 표현할 수 있음
View의 추가, 변경, 삭제가 자유로움
프레임워크로 확장하여 구현이 가능함

cons :
설계가 복잡하고 개발이 어려움
View와 Controller는 밀접히 관련되어 있음 - 재사용 어려움
모델의 인터페이스를 변경하면 View와 Controller로 변경 되어야 함

Micro Service Style

도메인은 공통 REST 기반 웹 인터페이스
서비스를 독립적으로 배포할 수 있습니다

pros : 확장성, 탄력성, 진화성
오류의 고립(Fault Isolation)을 돕는다. 새로운 기술을 도입, 적용하기가 용이하다.

cons : 성능, 단순성, 비용
여러 서비스를 배치를 하는 것이 좀 더 복잡해 진다.
어려운 트랜잭션 관리, 테스트의 어려움, 디버깅의 어려움,

N-Tier Style

cons : 2개 이상의 티어에 있는 데이터를 가져갈 때 어려움

Publish-Subscribe Style

Publish-Subscribe : Subject와 Observer 간에 직접적인 Dependency 존재
Public Broker Subscribe: 메시지 브로커 따로 존재, 비동기 방식

pros : 새로운 event handler (event listener)를 추가하기 용이함.
동적인 등록 절차를 통해 event source와 listener가 연결되므로 event source와 listener가 runtime에 변경되기 용이함

cons: Event listener의 동작이 언제 끝날지 예상되지 않아 테스트와 디버깅이 어려움.
Non-deterministic 한 문제: 전달하지 못할 수도 있음

Pipe-n-Filter Style

pros :
Concurrency: High throughput
Reusability: 단계별 프로세싱이 filter로 filter를 변경함으로써 Encapsulation되어 끼워넣거나 치환하기가 쉽다.
Modifiability: pipe를 통한 filter간 연결로 filter간 low coupling이 형성되어 새로운 filter를 추가할 때 다른 filter에 주는 영향이 적다.
Flexibility: Sequential execution과 parallel execution 두가지를 지원함.

cons :
Interaction이 많은 경우에 적합하지 않음.
Pip를 통과할 때마다 data parsing에 대한 overhead가 늘어남.
다중 입력을 받는 Filter의 경우 모든 입력을 받아야 출력을 산출
필터의 입출력에 단 하나의 데이터 타입을 사용하는 경우, 과부하 발생
에러 처리가 어려움

batch sequential 스타일과의 차이점
Batch-sequential 스타일은 각 단계에서 다음 단계로 데이터를 전달하기 전에 데이터를 완전히 처리함

Peer to Peer Style

pros : 분할은 분산 시스템 플랫폼 상의 배치에 있어 유연성(flexibility)을 제공, CPU와 디스크 자원의 효율적인 사용, 탈중화된 컴퓨팅 지원, 특정 노드 장애 감내

cons : 보안이 힘듦, 서비스 품질 보장 어려움, 노드 갯수에 따라 성능 좌우

Presentation Abstraction Control Architecture Style

PAC 스타일의 시스템은 대화형 소프트웨어 시스템을 위한 협력 에이전트의 트리와 같은 계층을 정의합니다.
계층에는 최상위 에이전트, 중간 수준 에이전트가 포함됩니다.

사용자와 상호작용하는 부분 뿐만아니라 계층간의 상호작용도 함께 분리

Presentation(View, Controller), Abstraction(Model), Control

Shared Repository Style

cons:
데이터와 계산을 데이터 저장소와 데이터 접근자에 매핑시키는 방법이 중요
성능은 향상시키지만 복잡성을 증가시키고 신뢰성과 보안을 감소,
스트럭쳐가 바뀌면 사용하는 부분에서 다 바꾸어주어야한다

Sensor Controller Actuator Architecture Style

이 스타일은 주로 시스템 환경 컨텍스트를 읽는 센서와 환경 설정을 제어하는 액 추에이터를 연결하는 임베디드 시스템을 설계하는 데 사용됩니다. 수행 동작 결정, 명령 전송 등을 수행. closed-loop

이 스타일의 시스템은 서비스 공급자가 서버 노드에 배포한 여러 서비스와 함께 개발 및 실행됩 니다. 따라서 서비스를 재사용함으로써 대상 시스템의 개발 노력을 줄이고 품질을 높일 수 있습 니다.

SOA 데이터베이스가 하나,
마이크로서비스는 데이터베이스도 다 분리

[ENG][아키텍처]Requirement Engineering

CamelAct — Wed, 31 Aug 2022 01:01:39 +0900

Error/Fault/Failure

Error/Fault/Failure 각각을 설명하세요.
Error
- Incorrect usage of software by users - Bad design by architects - Bad programming by developers - Inadequate testing by testers - Incorrect configuration by build members
Fault
- An incorrect statement - Wrong data type - Wrong formula in design document - Missing functionality in the system
Failure
- Faulty piece of code is executed leading to an incorrect state that propagates to the program’s output.

Error : 개발 개발자에의해 나온 도중에 나온 문제점
Fault: 기능 동작상의 비정상적 상황 발생 > 개발 끝난 이후에 나온 운용중에 나온 문제, 원치 않는 입력이나 원치 않는 상황
System Failure : Server의 system down > 서버나 component가 아예 멈추는 것

유입의 순서 : Error - Fault - Failure
발견의 순서 : Failure - Fault - Error

Needs와 Requirements 무엇이 다른가?

needs
: 고객이 실제 원하는것, 인포말
requirement
: 시스템이 무엇을 할 것인가, 완전한 문장, 개발자 측면

Requirements 대상과 목적에 따른 구분 세 가지는?

Business Requirements
조직의 목표, 프로젝트 이유, Business Use Cases, 비즈니스 규칙은 프로젝트 수준이 아니라 전사적 수준으로 다루어야 함

User Requirements
사용자 엑세스 서비스 조건, 사용자 서비스, Functional Requirements, Non-functional Requirements

System Requirements
운영상의 제약, 시스템의 기능, System Specification, Sub-system specification Software Requirements Specification (SRS)

요구 추출 기법 대강 방법 말해보시오.

요구 모델링 목적은?

추상적 요구사항을 정확하고 상세하게 정의
- 식별된 고객의 needs 만족을 확인하는 방법 제공
- business owner’s view를 architect’s view으로 변환

요구 모델링 단계는?

모델링의 관점은?

구조 관점 : Structured Analysis
Data Flow Diagram (DFD)
Entity-Relation Diagram (ERD)
State Transition Diagram (STD)
Class Diagram

기능 관점 : Use Case Analysis, Goal and Scenario Based Analysis
Use Case Modeling (UC)
Goal-Scenario Modeling (GS)

행위 관점: Behavior Analysis
Sequence Diagram, Communication Diagram (UML)

요구사항 우선순위화, 우선순위는 어떻게 매기는가?

Value, Cost, Risk 제약 안에서 Product value를 최대화

요구 명세, 요구문서 품질 요소 세 가지

Correct 정확성
Complete 완전성
Consistent 일관성

Definition of SW Quality, 품질 요구란 무엇인가?

소프트웨어가 수행할 작업이 아니라 소프트웨어가 수행하는 방식을 설명하는 소프트웨어 요구사항(예: 소프트웨어 성능 요구사항, 소프트웨어 외부 인터페이스 요구사항, 설계 제약 및 소프트웨어 품질 속성).

서비스 품질 요구 사항은 시스템 또는 시스템 환경의 일부 속성을 설명하는 데 가장 자주 사용됩니다. 이러한 요구 사항은 솔루션에 대한 제약 조건입니다. 비기능적 요구사항이라고도 합니다.

품질 속성, Types of Quality Aspects, 품질 속성 네가지?

각 품질 속성의 관계는?

Process Quality : Quality of Life-cycle Process
Internal Quality 주로 개발자나 유지보수자가 보는 품질 속성으로 소프트웨어 실행 중 발견하기 힘든 속성임, Development-time 품질
External Quality 사용자 시각에서 소프트웨어의 runtime시 관찰되는 속성, Run-time 품질
Quality in Use : 소프트웨어가 포함된 환경의 품질에 대한 사용자 관점
환경에서 소프트웨어를 사용한 결과에서 평가

Quality Model of ISO 9126 , 6 Main Factors and Sub-Factors for each

PERFUM - 향수

Functionality 기능을 사용할 때 오류가 있는가?, 기능들이 모두 잘 동작하는가?

- Suitability
- Accurateness
- Interoperability
- Compliance
- Security

Usability 사용성은시스템의 입력을 준비시키고, 동작시키며, 출력하는데 드는 노력을측정함
- Understandability
- Learabiliiy
- Operability

Efficiency 시스템이 프로세서 자원이나 디스크 용량, 메모리, 통신 대역폭 등을 얼마나잘 이용하는지에 관한 척도임
- Time Behavior
- Resource Behavior

Maintainability 소프트웨어를 얼마나 쉽게 수정할 수 있는지 측정한 느력, 수정에는 정정 개선 환경변화 수용, 요구사항 수용 등이 있다.
- Analyzability
- Changeability
- Stability
- Testability

Portability 소프트웨어가 다른 환경으로 이식될 수 있는 능력
- Adaptability
- Installability
- Conformance(일치성)
- Replaceability

Reliability 소프트웨어가 특정상황에서 특정기간 동안 일정 수준 이상으로 동작할 수 있는 능력
- Maturity
- Fault Tolerance
- Recoverability

하위 특성 대강 나열

품질 요구 카테고리, 몇가지 예를 들어 보시오.

Availability 서비스가 이용가능하고 완벽하게 작동하는 기간에 대한 비율 (예: 가용성 99.9%

Integrity(무결성) 정보손실을 방지하고 시스템에 입력된 데이터의 정확성을 지키는 문제를 다룸

Interoperability(상호운영성) 시스템이 다른 장비와, 소프트웨어와 얼마나 쉽게 데이터와 서비스를 교환할 수있는지, 외부 하드웨어와 손쉽게 통합할 수 있는지를 말함

Performance 성능은 사용자의 조회 및 동작에 대한 시스템의 민첩한 정도를 말하며

Reliability 소프트웨어가 실행되는 특정시간 동안 장애가 발생하지 않을 확률을 말함 0.001%

Modifiability SW 설계나 코드가 얼마나 쉽고, 수정하기 쉬우며, 확장이 용이한가를 다룸

Scalability 성능이나 정확성 차이 없이 더 많은 사용자, 데이터, 서버, 트랜잭션, 네트워크 트래픽 등 다른 서비스를 수용할 수 있는 애플리케이션의 능력을 나타냄

Process of Requirement Engineering, 요구공학 절차는?

요구사항 추출
요구 사항 모델링과 분석
요구사항 우선순위화
요구사항 명세
품질요구
요구사항 검증
요구사항 관리

Agile Constructs for Requirement Management, 무엇인가요?

Agile Development: 빠른 프로토타이핑과 빠른 개발 경험에 비중을 둔 방법론 중 하나. 문서화나 과정 사양의 비중은 낮춤. ex) XP(eXtream Programming,

요구사항에 대한 백로그를 만들고
계획과 우선순위를 하며
분할 그룹 생성 등에 이점을 줌

반복적으로 진행하고 결과물을 한 번에 배포하는 것이 아니라 나눠서 공유함. 사용자로부터 적극적으로 요구사항을 받아서 반영함.

Agile Principles, 무엇인가요?

짧은 변경주기를 적용한다.
- 변경을 수용할 수 있는 가능성을 확보한다. (60% baseline)
- 문서를 강조하지 않고 변경 장려, 개발 초기부터 테스트 병행을 권고
- Pair programming, informative workspace 유지
- 고객이 가장 중요하게 생각하는 것을 먼저 구현
- 1～3주 내에 구현할 수 있는 요구사항(유저 스토리)

Requirements for Platform Software에서 고려해야할 품질은?
Scalability
Distributed processing capabilities

SW품질이란?

explicit req.(문서로 정확히 정의된 요구사항),
implicit req.(예상되는 변경/요구) 모두 만족해야함.

SW품질 달성 방안

신뢰성 달성 방안 - Fault Tolerance

변경용이성 달성 방안 - 응집성, Information Hide, 커플링 제한, 인터페이스화, Polymorphism, Plug-in, Configuration files

효율성 달성 방안 - 계산 시간 축소, 큐 사이즈 제한, 수행시간 제한, 동시 처리

가용성 달성 방안 - Active Redundancy, Ping/echo, Heartbeat

사용성 달성 방안 - Cancel, undo, 쓰는 메뉴만 노출, 예상 시간, 진행률 표시

Security 달성 방안 : 메시지 무결성 검증, 사용자 인증, 노출 제한, 접근 제한, 데이터 암호화,

Performance 달성 방안 : Periodic cleaning, 실행 횟수 제한, 동시성 도입, 큐 크기 제한

Testability 달성 방안 : 데이터 소스 추상화, 구조 복잡성 제거

Interoperability 달성 방안 : 인터페이스 관리,

Modifiability 달성 방안 : 모듈 분할, 결합성 감소, 캡슐화, 중재자 사용

Traceability 달성 방안 : 고유한 데이터 조각(예: 주문 날짜/시간 또는 일련 번호)의 사용

[ENG][아키텍처]Design Patterns - Pattern

CamelAct — Wed, 31 Aug 2022 00:58:52 +0900

Abstract Factory

구체적인 클래스를 지정하지 않고 관련성을 갖는 객체들의 집합, 서로 독립적인 객체들의 집합을 생성할 수 있는 인터페이스를 제공하는 패턴.
위임, DIP, Composition

Adapter

Composit
클래스의 인터페이스를 사용자가 기대하는 다른 인터페이스로 변환하는 패턴으로, 호환성이 없는 인터페이스 때문에 함께 동작할 수 없는 클래스들이 함께 작동하도록 해 줍니다.

Bridge

구현부에서 추상층을 분리하여 각자 독립적으로 변형할 수 있게 하는 패턴.
추상적 개념과 이에 대한 구현 사이의 지속적인 종속 관계를 피하고 싶을 때 사용. 추상적 개념과 구현 모두가 독립적으로 서브클래싱을 통해 확장되어야 할때 사용.

어댑터 패턴과 브릿지 패턴의 차이는?

다른점, 어댑터는 인터페이스가 다를경우 해결하려고, 디자인된 이후에 적용하는 목적, 브릿지는 그런 구조적인 문제가 생길까바 미리 만들어두는 디자인, 미리 대비하는 패턴
구조적으로 어댑터는 간단한싱글 인터페이스, 브릿지는 복잡한 분리, 전체를 앱스트랙트 시킨다.

Builder

Composition
복잡한 객체의 생성 과정과 표현 방법을 분리하여 동일한 생성 절차에서 서로 다른 표현 결과를 만들 수 있게 하는 패턴.

빌더 패턴과 팩토리 패턴의 차이점을 서술하세요.
팩토리 패턴이랑 비교하면 클라이언트가 원하는 결과물이 다름
빌더는 스텝 바이 스텝으로 만드는 프로세스에 중점, 맨 마지막에 결과가 합쳐져서 나옴, 하나의 군에대한 생성하는 다양한 방식에 대한 정보를 감춘다
팩토리는 요청을 할 때마다 즉각적으로 리턴한다음 나중에 prepare로 만드는 것
여러 군들에 대한 생성을 감춘다

빌더는
- 메인 클래스의 인스턴스 생성전. 한번에 클래스 생성 및 처리
- 클래스 생성시 인자값이 클래스 (데이터) 구조와 일치 (C# JSON ??)
- 메인 클래스의 인스턴스가. 각 클래스와 같은 기능
- 복잡한 객체의 단계별 생성에 중점
- 마지막 단계에서 생성한 제품 반환

팩토리는
- 메인 클래스의 인스턴스 생성 후. 각 클래스를 생성하여 사용
- 또는. 메인 클래스의 인자값에 클래스를 생성하여 사용
- 메인 클래스의 인스턴스가. 각 클래스와 같은 기능
- 제품의 유사군들의 존재하는 경우 유연한 설계에 중점
- 만드는 즉시 제품을 반환

Chain Of Responsibility

요청을 처리할 수 있는 기회를 하나 이상의 객체에게 부여하여 요청을 보내는 객체와 그 요청을 받는 객체 사이의 결합을 피하는 패턴.
요청을 받을 수 있는 객체를 연쇄적으로 묶고, 실제 요청을 처리할 객체를 만날 때까지 객체 고리를 따라서 요청을 전달.
요구를 처리하는 객체들을 사슬 모양으로 늘어놓고, 요청이 들어오면 누가 처리할 지를 차례차례 체크해 나가는 Chain of Responsibility 패턴
- 장점 : sender와 receiver의 디커플링, 추가에 유연함
- 단점 : client는 누가 request를 handle하는지 알 수 없다.
- Java의 try-catch 패턴

Command

DIP
실행될 기능을 캡슐화함으로써 주어진 여러 기능을 실행할 수 있는 재사용성이 높은 클래스를 설계하는 패턴
즉, 이벤트가 발생했을 때 실행될 기능이 다양하면서도 변경이 필요한 경우에 이벤트를 발생시키는 클래스를 변경하지 않고 재사용하고자 할 때 유용하다.

Request를 캡슐화 시킵니다. 클라이언트는 command 객체를 invoker에 넣어 실행할 수 있습니다. 동작시키는 Invoker와 전달받는 Receiver를 디커플링 시킵니다.

Composite

DIP
객체들의 관계를 트리구조로 구성하여 부분-전체 계층을 표현하는 패턴. 사용자가 단일 객체와 복합 객체 모두 동일하게 다룸.

Decorator

OCP
주어진 상황 및 용도에 따라 어떤 객체에 책임을 덧붙이는 패턴. 기능 확장이 필요할 때 서브클래싱 대신 쓸 수 있는 유연한 대안이 될 수 있다.

Decorator 객체가 Inheritance와 Association이 모두 존재해야하는 이유

Inheritance : 감싸는 기능, 확장에서 모든 type이 같아야하기 때문에
Association : 객체를 감싸서 기능을 추가 확장하므로

Facade

서브시스템에 있는 인터페이스 집합에 대해서 하나의 통합된 인터페이스를 제공하는 패턴. 서브시스템을 좀더 사용하기 편하게 만드는 상위 수준의 인터페이스를 정의합니다.

Factory Method

DIP
객체를 생성하는 인터페이스는 미리 정하되, 인스턴스를 만들 클래스의 결정은 서브클래스 쪽에서 내리는 패턴. (서브클래스에서 클래스의 인스턴스 생성)

AbstractFactory와 무엇이 다른가요?

팩토리메소드는 상속, 템플릿메소드 패턴을 포함한다
if( type == "z"){ pizza = new Zpizza();

Abtract 팩토리는 델리게이션, 팩토리를 이용해서 만드는것만 전문적인 클래스를 사용한다, 한 레벨 더 높은 추상화 = 컴포지션 + 델리게이션
pizza = factory.createPizza();

Flyweight

크기가 큰 객체가 여러 개 있을 때, 공유를 통해 이들을 효율적으로 지원하는 패턴. 해쉬 테이블에 자주 사용되고 반복적이며 메모리가 큰 것을 저장해두고 재사용하는것

인스턴스를 가능한 한 공유시켜서, 쓸데없이 new를 하지 않도록 한다. – 인스턴스가 필요할 때 마다 new를 하는 것이 아니라, 이미 만들어져 있는 인스턴스를 이용할 수 있으면 공유하자.
Prototype은 복제를 하는 것이고 Flyweight는 있는것 그대로 쓴다.

Iterator

SRP, DIP,
내부 표현부를 노출하지 않고 어떤 객체 집합에 속한 원소들을 순차적으로 접근할 수 있는 방법을 제공하는 패턴.

Interpreter

주어진 언어에 대해, 그 언어의 문법을 위한 표현 수단을 정의하고, 그 표현 수단을 사용하여 해당 언어로 작성된 문장을 해석하는 해석기를 정의하는 패턴.

프로그램이 해결하려고 하는 문제를 간단한 ‘미니 언어’로 표현함
– 구체적인 문제를 미니 언어로 쓰여진 ‘미니 프로그램’으로 표현한다.
– 미니 프로그램을 자바 언어로 ‘통역’하는 역할을 하는 프로그램을 만 든다.
– 통역 프로그램은 미니 언어를 이해하고 미니 프로그램을 해석 및 실 행한다.
– 해결해야 할 문제에 변화가 생겼을 때, 프로그램을 고치지 않고 미니 프로그램을 고쳐서 해결한다.

Mediator

Loosely coupled, 코드 리유즈 어려움
한 집합에 속해있는 객체들의 상호작용을 캡슐화하는 객체를 정의하는 패턴.
객체들이 직접 서로를 참조하지 않도록 함으로써 객체들 사이의 Loose coupling을 촉진시키며, 개발자가 객체들의 상호작용을 독립적으로 다양화시킬 수 있게 만듭니다.

Memento

현재 객체의 상태를 기록하여 보존하기 위한 Memento 패턴
– Caretaker 역할은 중간 중간 Originator 역할에게 부탁하여 ‘현 재의 상태’를 표현하는 Memento 역할을 만든다.
– Caretaker 역할은 필요할 때 서랍 안에서 Memento 역할을 꺼 내서 Originator 역할에게 건네주면, 그 상태로 복원이 된다.

MVC

MVC (모델-뷰-컨트롤러) 는 사용자 인터페이스, 데이터 및 논리 제어를 구현하는데 널리 사용되는 소프트웨어 디자인 패턴입니다. 소프트웨어의 비즈니스 로직과 화면을 구분하는데 중점을 두고 있습니다. 이러한 "관심사 분리" 는 더나은 업무의 분리와 향상된 관리를 제공합니다.

Observer

Loosely coupled
객체들 사이에 일 대 다 의존 관계를 정의해 두어, 어떤 객체의 상태가 변할 때 그 객체에 의존성을 가진 다른 객체들이 그 변화를 통지받고 자동으로 갱신될 수 있게 만드는 패턴.
주체(Subject)와 감시자(Observer) 사이에서 주체의 변경이 일어났을 때 감시자에게 알려주어 변화되어야 하는 객체들에게 전달(Update)합니다.
cons : -> subject의 state가 바뀔때마다 noti가 올것임. 특정 상태일때만 알면 될때는 overhead가 될 수 있음. 그래서 ChangeManager를 중간에 둘수도 있겠다.

Push VS Pull
Push 방식은 observer.update(data1, data2, data3); 와 같이 Observable에서 update메서드로 직접 넣어주는 방식. observer은 update의 인자로 넘어온 값들을 사용하게 된다.

Pull 방식은 observer.update(this, arg); 와 같이 Observable 인스턴스를 보내고, observer.update 함수에서 observable.getXXX() 함수를 사용하여 가져가는 방식.

Prototype

생성할 객체의 종류를 명시하는 데에 원형이 되는(Prototypical) 인스턴스를 이용하고, 그 원형을 복사함으로써 새로운 객체를 생성하는 패턴.
클래스로부터 인스턴스를 새로 만드는 것이 아니라, 현재 존재 하는 인스턴스를 복사(복제)해서 새로운 인스턴스를 만들 필요 가 있을 때, 이 작업을 편하게 하기 위해 사용한다

pros : 인스턴스를 만드는 복잡한 과정을 몰라도 되고 속도가 빠르다
cons : 복사본 자체를 만드는일 자체가 복잡할 수 있다.

객체를 빨리 생성하는 패턴

Proxy

어떤 다른 객체로 접근하는 것을 통제하기 위해서 그 객체의 대리자(Surrogate) 또는 Placeholder를 제공하는 패턴.

Proxy pattern의 활용되는 방식

Real subject가 필요한 경우에 생성될 수 있도록 컨트롤 하거나 생성되기 전까지 대리인 역할을 한다. Real subject가 생성되면 Client로부터의 요청사항을 Real subject로 전달한다.
Client와 Real subject가 서로 다른 주소체계에 있거나 Real subject가 생성하는데 오래걸리거나 비싸거나, Real subject에 접근하는 권한의 관리가 필요할 경우 활용된다.

- remote proxy : responsible for encoding a request and its arguments and for sending the encoded request to the real subject in a different address space –
- virtual proxy : may cache additional information about the real subject so that they can postpone accessing it –
- protection proxy : checks that the caller has the access permissions required to perform a request

원격 프록시 : 요청과 해당 인수를 인코딩하고 인코딩된 요청을 다른 주소 공간의 실제 주체에게 보내는 역할을 합니다.
- 가상 프록시 : 실제 주제에 대한 추가 정보를 캐시에 저장하여 액세스를 연기할 수 있습니다.
- 보호 프록시 : 호출자가 요청을 수행하는 데 필요한 액세스 권한이 있는지 확인합니다.

Singleton

어떤 클래스의 인스턴스는 오직 하나임을 보장하며, 이 인스턴스에 접근할 수 있는 전역적인 접촉점을 제공하는 패턴.

State

OCP, 위임, DIP
객체의 내부상태에 따라 스스로 행동을 변경할 수 있게끔 허가하는 패턴.
상태가 변할 때마다 서브클래스 중 하나의 인스턴스로 변경함.

장점으로는 한 State와 관계된 모든 동작들이 하나의 Object 안에 모두 모인다.
State 추가 시 다른 Object에 대한 수정 없이 하나의 Object만 추가되면 된다.
따라서 State에 따른 조건문 없이 관리가 가능하다.
단점으로는 State 수만큼 Object가 관리되어야 함으로 Object가 늘어나고,
State 안에 동작이 추가될 경우 모든 Object들에 대해서 추가되어야 해서 수정범위가 늘어나게 된다.

Strategy

Has a 관계가 아닌 Is a 관계로 코드 재사용성이 높다, Composition, Polymorphism, 위임, DIP,
같은 계열의 알고리즘군을 정의하고, 각각의 알고리즘을 캡슐화하여 교환해서 사용할 수 있도록 만든 패턴.
알고리즘을 사용하는 사용자와 상관없이 독립적으로 알고리즘을 다양하게
변경할 수 있게 합니다.

Strategy는 알고리즘이 다양하고 상호교환이 필요할 때 사용합니다.

Template Method

객체의 연산에는 알고리듬의 뼈대만을 정의하고 각 단계에서 수행할 구체적 처리는 서브클래스 쪽으로 미루는 패턴.
알고리즘의 구조 자체는 그대로 놔둔 채 알고리즘 각 단계의 처리를 서브클래스에서 재정의할 수 있게 합니다.

Template Method 패턴은 어떤 부분이 opened, closed 되어있나요?

Visit

객체 구조를 이루는 원소에 대해 수행할 연산을 표현하는 패턴.
연산을 적용할 원소의 클래스를 변경하지 않고도(구조 변경 없이) 새로운 연산을 정의(새로운 기능 추가)할 수 있게 합니다. 다양한 객체에 새로운 기능을 추가해야 하는데 캡슐화가 별로 중요하지 않은 경우에 사용.
데이터 구조와 처리를 분리하자.
– 데이터 구조를 돌아다니는 “방문자”를 정의해서, 이 방문자가 “처리”를 담당하도록 하자.
– 새로운 처리를 추가하고 싶을 때는, 새로운 “방문자”를 만든다.

Mediator VS Facade

Mediator는 Colleague간 복잡한 Communication을 간접적으로 서로 통신하는데 사용, Facade는 복잡한 Sub System의 Interface를 제공하여 클라이언트가 Sub System과의 디펜던시가 생기지 않도록 한다.
Mediator는 양방향 통신, Facade는 단방향 통신

[ENG][아키텍처]Design Patterns - Concept

CamelAct — Wed, 31 Aug 2022 00:55:45 +0900

디자인패턴을 세 가지 특성으로 분류하고 목적 기준으로 말해보세요.

갱 오브 카테고리

- Creational : New를 하지 않는다, 객체 인스턴스 생성을 위한 패턴으로, 클라이언트와 그 클라이언트에서 생성할 객체 인스턴스 사이의 연결을 끊어주는 패턴이다.

- Structural : 구조적인 패턴, 클래스 및 객체들을 구성(합성)을 통해서 더 큰 구조로 만들 수 있게 해주는 것과 관련된 패턴이다.

- Behavioral : 클래스에 책임할당, 정적관계와 의사소통, 클래스와 객체들이 상호작용하는 방법 및 역할을 분담하는 방법과 관련된 패턴이다.

디자인패턴을 범위 기준으로 말해보세요.

클래스 패턴에서는 클래스 사이의 관계가 상속을 통해서 어떤 식으로 정의되는지를 다룬다. 클래스 패턴에서는 컴파일 시에 관계가 결정된다.

오브젝트 패턴에서는 객체 사이의 관계를 다루며, 객체 사이의 관계는 보통 구성을 통해서 정의된다. 객체 패턴에서는 일반적으로 실행 중에 관계가 생성되기 때문에 더 동적이고 유연하다.

General Responsibility Assignment Software Pattern, GRASP에 대해서 설명하세요.

- Creator : 생성되는 객체의 컨텍스트를 알고 있는 다른 객체가 있다면, 컨텍스트를 알고 있는 객체에 객체의 생성을 부여.

- Controller : 시스템 이벤트(사용자의 요청)를 처리할 객체를 만들자.

- Pure Fabrication : 도메인에 관련된 문제를 대표하는 것이 아니라면 기능적인
책임을 별도로 한 곳으로 관리하는 객체를 만들자.

- Information Expert : 책임을 수행할 수 있는 데이터를 가지고 있는 객체에 책임을 부여하는 것.
객체는 데이터와 처리로직이 함께 묶여 있는 것.
정보 은닉을 통해 자신의 데이터를 감추고 오직 Method로만 데이터를 처리하고, 외부에는 그 기능(책임)만을 제공한다.

- High Cohesion : 모듈 하나에서 응집되어 있는지 : 높을수록 좋다

- Indirection : 두 객체 사이의 직접적인 Coupling을 피하고 싶으면, 그 사이에 다른 매개체를 통해 전달하는 것.

- Low Coupling : 여러 모듈간 측정 인터디펜턴시 : 약할수록 좋다

- Polymorphism : 객체의 종류에 따라 행동양식이 바뀐다면, Polymorphism 기능을 사용하자.

- Protected Variations : 변경될 여지가 있는 곳에 안정된 인터페이스를 정의해서 사용하자.
- Don’t talk to Stranger : 높은 결합을 피하기 위해. 특히, 클라이언트 개체가 서버 개체의 내부 구조 및 연결에 대해 소유해야 하는 지식의 정도를 제한합니다.

Coupling과 Cohesion의 차이를 설명하세요.

Coupling : 여러 모듈간 측정 인터디펜턴시 : 약할수록 좋다
Cohesion : 모듈 하나에서 응집되어 있는지 : 높을수록 좋다

Pattern-Oriented Software Architecture, 세 가지로 구분

아키텍처 패턴 : 시스템 전체에 대한, 조직에 대한 결정, 소프트웨어의 전체적인 구조, 관계 가이드 룰, ex) MVC 패턴
디자인 패턴 : 위보다 작은 서브시스템 컴포넌트 리파인, 전체 시스템에 영향을 미치지 않음, ex) 옵저버패턴
코팅 패턴 : 스페시픽한 프로그래밍 랭기지, ex) 포인터**

[ENG][아키텍처]Principles of SW Design

CamelAct — Wed, 31 Aug 2022 00:54:15 +0900

SOLID, S가 무엇의 약자이고 무엇을 의미하나요?

What are the benefits of OCP?
What are the mechanisms for implementing OCP?

1. SRP : 단일 책임의 원칙 : 단일 책임 원칙. 클래스는 단 하나의 기능만을 갖고, 하나의 기능을 여러 component에 나누어 놓지마라.
SRP Single responsibility principle,

2. OCP : 개방 폐쇄 원칙 OCP : 확장에 대해 열려 있어야 하고, 수정에 대해서는 닫혀 있어야 한다'는 프로그래밍 원칙, Open Closed Principle
자동차 운전을 할 수 있다. 소나타, 그랜저, BMW...
즉, 자동차가 바뀌더라도 내가 운전하는 방식은 동일해야 한다.

3. LSP : 서브타입은 대체할 수 있어야한다 베이스 타입을, Liskov substitution principle
어떠한 서브타입으로 바꾸어도라도 프로그램 동작에 문제가 없어야한다
상속 : 큐는 리스트를 상속하지 말고 List를 가져다가 쓰는 방식으로 해야 그 각각의 특징을 살릴 수 있다, 상속이 항상 좋은건 아니라는것, 개체들간의 합성이라는 것
상속을 했을 때 부모의 함수를 썼지만 예상되는 결과를 받아오지 못하는 현상
&
너비와 높이의 조회(getter) 및 할당(setter) 메서드를 가진 직사각형 클래스로부터 정사각형 클래스를 파생하는 경우를 들 수 있다. 정사각형 클래스는 항상 너비와 높이가 같다고 간주할 수 있다. 정사각형 객체가 직사각형을 다루는 문맥에서 사용되는 경우, 정사각형의 크기는 독립적으로 변경할 수 없기 때문에 (혹은 그래서는 안되기 때문에) 예기치 못한 행동을 하게 된다.

4. ISP 인터페이스 분리 Interface Segregation Principle
클라이언트가 자신이 이용하지 않는 메서드에 의존하면 안된다는 원칙
인터페이스를 더 잘게 나누어 사용하자
복합기에 print(), copy(), fax() 메소드가 있다. 프린터는 print()를, 복사기는 copy()를, 팩스는 fax()를 사용한다. 세 가지 메소드는 같은 파일에 존재하므로, 프린터의 print()로직만 바뀌어도 복사기와 팩스도 재컴파일을 해야 한다.
클라이언트는 자신이 사용하는 메소드를 가지는 인터페이스만 구현하도록 한다. 인터페이스를 분리하면 프린터의 print() 로직이 바뀌어도 복사기와 팩스는 영향을 받지 않는다.

5. DIP 디펜던시 역전 원칙 Dependency Inversion Principle
상위 모듈은 하위 모듈의 구현에 의존해서는 안 된다. 하위의 모듈이 상위 모듈에 정의한 추상 타입에 의존해야 한다. DIP는 의존 관계를 맺을 때 변화하기 쉬운 것 또는 자주 변화하는 것에 의존하기 보다는, 변화하기 어려운것, 거의 변화가 없는 것에 의존하라는 원칙입니다.
카드 결제(상위 모듈은)는 신한 카드 결제(하위 모듈)에 의존해서는 안된다. 신한 카드 결제(하위 모듈)은 카드 결제(상위 모듈)에 정의한 카드 결제 인터페이스(추상 타입)에 의존해야 한다.

What are the benefits of applying SOLID?

SW design을 더 이해하기 쉽고, 유연하고 유지보수하기 수월하게 함

Refinement 무엇인가요?

높은 수준의 Design으로부터 낮은 수준 Design으로 세밀화

Give examples of applying Separation of Concerns?

SoC, SoC는 긴 복잡한 함수를 쓰지 말라고 이야기하는 것입니다. 함수의 크기가 커지기 시작하면 함수가 너무 많은 작업을 처리한 다는 것이고, 이는 함수를 분리 해야하는 신호입니다. 다른 섹션의 세부사항을 알지 않고도 개발된 코드를 재사용할 수 있게 함.

SRP 와 SoC의 차이점.

SRP는 각 모듈에 대한거고. Soc 는 절차에 관한 것으로 더 큰 범위다. SRP를 만족한다고 soc가 만족되는것은 아니다

Modularity 무엇인가?

상호 연결은 간단하고 작아야 합니다.
SoC를 잘 구현하면 Modularity가 좋아짐
OOP의 장점이기도 함,
클래스의 소스 코드는 다른 클래스의 소스 코드와 독립적으로 작성 및 유지 관리할 수 있고, 일단 만들어진 객체는 시스템 내부에서 쉽게 전달됨

Information Hiding 장단점은 무엇인가?

내부 디자인 결정사항을 외부로부터 숨김, Encapsulation

pros :
캡슐화의 장점은 객체의 세부내용이 외부에 은폐(정보은닉)되어, 변경이 발생할 때 오류발생이 적으며 재사용이 용이하다.
다시말해 객체들 간의 메시지를 주고 받을 때 각 객체의 세부 내용은 알 필요가 없으므로 인터페이스가 간결해지고, 객체간의 결합도가 낮아진다

cons :
절차지향언어는 컴퓨터 처리구조와 비슷해서 빠르지만, 객체지향 언어는 상대적으로 실행속도가 느림., 클래스, 객체, 상속 등 구조 설계도 해야해서 절차지향언어에 비해 설계시간이 많이 듬

Divide and Conquer 무엇인가?

문제를 재귀적으로 해결한다, 더 작은 하위 문제로.

디자인 패턴을 설계할때 꼭 써야 하는가?

확장성을 예상가능하다.(OCP)
오랫동안 산업에서 많이 사용된 패턴이라 이미 검증되고 테스트된 구조이기때문에 설계 과정의 속도를 높일 수 있다.
같은 이유로 커뮤니케이션에 수월하다.
재사용 가능하다. 변경 용이성, 재사용성, 유지보수 용이성

[ENG][아키텍처]OO Analysis & Design - Consistency

CamelAct — Wed, 31 Aug 2022 00:53:42 +0900

Consistency, Use Case Model & Class Diagram

Use case에 등장하는 명사(Noun)들을 추출하여 클래스로 만들 수 있다.

Consistency, Use Case Model & Sequence Diagram

Use case에서 등장하는 actor와 system 사이의 상호작용을 시나리오에 따라 sequence diagram으로 나타낼 수 있다.

Consistency, Functional & Information

Consider datasets manipulated by use cases
Consider functionality which manipulates the dataset.

Use case가 dataset을 사용하고 dataset은 information view에서 persistent object classes 형태로 표현 됨
Dataset을 사용할 functionallity를 고려해야하고 이것이 Functional View에 표현 됩니다.

Consistency, State Machine Diagram & Class Diagram

정의한 상태별로 클래스가 구성된다. 해당 클래스의 Method는 실행 가능한 Event에 대해서는 구현하고 그렇지 않은 함수는 Block처리하여 두 다이어그램의 일관성을 유지한다.

Consistency, Activity Diagram & Use Case Diagram

모든 Use case가 Activity 또는 Action으로 표현되어야 하며 Activity에서는 전체적인 제어흐름도 확인할 수 있는 다이어그램이다. 등장하지 않았던 Action이 나타나면 Consistency에 어긋난다.

Consistency, Functional & Behavior

Activity Diagram should only include the functionality of use cases.
A use case should be reflected in some control flow.
Verify the functionality of Swimlane Elements

Behavior Control flow는 1 use case 이상이 매핑되어야 합니다.
Control flow는 use case의 Functionality를 포함한다.
Activity Diagram의 Swimlane Elements들은 functionality는 functional view에서 Component, Layer Tier의 Functionality로 표현된다.

Consistency, Information & Behavior

Activity 다이어그램은 Data nodes, Object Nodes 들이 포함될 수 있다.

Consistency, Activity Diag. & State M. Diag.

Objects/Data Nodes can be given ‘State’ information.
State transitions on both diagrams must be consistent.

Activity의 Data, Object Node들이 State Information으로 주어질 수 있다.
Transition이 Control flow로 드러나야한다.

Consistency, Information & State

State Diagram의 Transition 들이 class의 public Method가 될 수 있어야한다.
없다면 class의 public method로 추가되어야 한다.

Consistency, Sequence & Activity

Sequence Diagram은 1개의 Usecase를 이용하여 작성되며 Activity Diagram에서 Control flow는 1개 혹은 여러 개의 Usecase Diagram으로 이루어 짐.
모든 Usecase가 Sequence Diagram과 Activity Diagram으로 반영되어 있어야 함.
Sequence들이 모두 Activity Diagram으로 포함되어야 함.

[ENG][아키텍처]OO Analysis & Design - Diagram

CamelAct — Wed, 31 Aug 2022 00:52:41 +0900

Cardinality를 Car와 Tire를 예를 들어 설명하시오.

Car 0..1 ◆ㅡ 4 Tire : 0이 있어서 말이 된다, 0이 없으면 말이 안 됨, 타이어 가게가 있어서, 0은 차가 없어도 타이어가 존재할 수 있어서
Car * ◇ㅡ 4 Tire : 말이 안된다, 여러 차가 타이어를 공유는 있을 수 없음

Cardinality를 Student와 Class를 예를 들어 설명하시오.

Student 1 ㅡ 0..* Registration 0..* ㅡ 1..* Class

Order the strengths of 5 class diagram relationship types. Justify the ordering.

Inheritance
Composition : 소멸까지
Aggregation : Classifier 간의 관계에서 사용. + 집합 + 필수요소
Association : Classifier 간의 관계에서 사용. + 필수는 아님
Dependency : Method 간의 관계에서 사용.

cardinality가 중요한가? 꼭 정확히 적어야 하나?

cardinality를 정확히 써야 array를 써야할지 아닐지 명확히 할수 있다.
코딩은 이 cardinality(요구사항)을 그대로 따르게 되어 있다.
객체간 관계가 1 - 1 인데 0이 나오는 것을 허용하게 하면 안된다.

association과 dependency 차이?

dependency 주로 함수내에서 instance를 생성, 사용, 호출하거나 매개변수로 쓰이는 등 instance를 잠시 사용할때 사용. 주로 class diagram에서는 생략
association : instance의 reference를 계속 유지하고 있을 경우

association과 aggregation 왜 구분해서 사용하나? 둘다 멤버변수 가지는데?

aggregation : new Car(new Engine)처럼 car에 engine을 강제할수있게 됨.
whole-part 관계를 나타낼때 사용. 부품(part)없이 전체를 만들수 없다.
association : new Car()해도 쓸수 있는것

class 관계에서 strong과 weak의 의미는 뭔가요?

상호작용이 강하다. 약하다의 의미
life time관련해서 둘이 서로 depend하는지
method invoke 관점
link persistence : dependency 빼면 나머지 4개는 다 link를 보존하고 있음

Use Case Diagram 무엇인가요?

Actor가 목표를 위해 시스템을 어떻게 이용하는지를 표현함, Functional requirement 를 나타냄.
Action을 중심으로 시스템을 구성하고 시스템의 범위와 기능을 정의한 모델

Component Diagram 무엇인가요?

컴포넌트들과 시스템이 어떻게 연결되어 있는지 모델링한 다이어그램
Provided Interface
Required Interface

Component Diagram의 Components 와 Deployment Diagram의 Components 의 차이점은 무엇인가요?

컴포넌트 다이어그램의 컴포넌트는 만드는 소스파일, 개발중인 것
디플로이먼트 다이어그램에의 컴포넌트는 런타임 수준, 컴포넌트의 인스턴스

Sequence Diagram 시퀀스 다이어그램은 언제 사용하나요?

Usecase 1개의 시간의 순서에 따른 컨트롤 플로우.
특정기능(usecase 1개)에 대해서 객체간에 메시지 흘러가는 순서를 나타낼때.

Applying MVC style paradigm in drawing Sequence Diagram

MVC style paradigm을 적용하여 CRUD 류의 Sequence diagram을 그릴 수 있음 (User - View - Control - Model)

Sequence Diagram, alt와 opt 차이는?

alt는 워크플로우의 조건 if else에서 각 조건을 표시한다
opt는 하나의 영역만 조건에 존재 하는 경우에 사용한다.

Sequence Diagram, 기타 용어

critical : 하나의 스레드만 접근하여 표현하는 operator
ignore : 특정 메시지를 무시할 경우
consider : 특정 메시지를 중요하게 고려할 경우
assert : 절대 처리(정의된 로직이 반드시 성립되는 처리)
neg : negative 절대 발생하면 안되는 상황
State Machine Diagram
What is Event in State Machine Diagram? Give examples.
도어는 "열림", "닫힘" 또는 "잠김"의 세 가지 상태 중 하나일 수 있습니다. 열기, 닫기, 잠금 및 잠금 해제 이벤트에 응답할 수 있습니다. 모든 이벤트가 모든 상태에서 유효한 것은 아닙니다. 예를 들어 문이 열려 있으면 닫을 때까지 잠글 수 없습니다. 또한 상태 전환에는 가드 조건이 첨부될 수 있습니다. 문이 열림이면 doorWay->isEmpty 조건이 충족되는 경우에만 닫기 이벤트에 응답할 수 있습니다.

어떤 경우에 적용하면 좋나요?

state sensitive, state dependent한 behavior가 있고,
state에 따라 할수 있는 action이 고정되어 있는 경우.
시스템안에 set of state가 잘 정의될 수 있는 경우.
예) 자동차 시동은 P에서만 걸리고 D에서는 안걸린다
구현은 간단한 것은 enum state로, 복잡하다면 state pattern 사용

구성요소 설명해 보시오.

Transition : 오브젝트가 다른 상태로 변경
Event(Trigger) : system에 영향을 미치는 어떠한 동작 (구체적이지 않은)
Guard(Condition) : event의 파라미터의 값으로 동적으로 체크되는 Boolean expressions
Action(Effect) : 하나의 event가 dispatch되면 state machine은 action을 수행하는 것으로 응답 한다.
Orthogonal State: State의 동시성을 표기하는 기능
Swallow History : Composite state의 같은 Level의 첫 state로 복원
Deep History : Last State로 복원

Class Diagram과 일관성 확인 방법은?

State Action에 대해서 Class의 Attribute가 제공되어야하고
Event는 Class의 Method로 제공되어야 한다.

Timing Diagram 언제 쓰는가?

타이밍 다이어그램은 시퀀스 다이어그램 의 특수한 형태입니다 . 타이밍 다이어그램과 시퀀스 다이어그램의 차이점은 축이 반대로 되어 왼쪽에서 오른쪽으로 시간이 증가하고 생명선이 수직으로 배열된 별도의 구획에 표시된다는 것입니다.

Activity Diagram, When would you use an Activity Diagram?

각 기능 블록에 대한 Action과 Activity를 정의
단계별 작업흐름을 그림으로 표현
둥근네모를 액티비티, 화살표를 액션, 마름모를 디시젼 심볼

Deployment Diagram 무엇인가요?

시스템이 적용되는 환경을 설명합니다
Define Nodes
Define Network Connectivity
Deploy Software Artifacts

UML Constructs for Parallel Processing, 무슨 다이어그램을 쓰면 되나요?

Using an activity diagram, fork and join, can display parallel processing via UML.
Sequence, State

[ENG][아키텍처]OO Analysis & Design - Concept

CamelAct — Wed, 31 Aug 2022 00:45:50 +0900

UML Diagram의 분류

UML Diagram을 세 가지 타입으로 구분하고 각 타입별 대표적인 것 한 두개씩 말해보세요.
Structural Diagram : 클래스 다이어그램, 컴포넌트다이어그램, 오브젝트 다이어그램, 컴포짓스트럭쳐 다이어그램, 디플로이먼트 다이어그램, 패키지 다이어그램

Behavioral Diagram : 액티비티 다이어그램, 유스케이스다이어그램, 스테이트머신 다이어그램, 인터렉션 다이어그램

Interaction Diagram : 시퀀스 다이어그램, 커뮤니케이션 다이어그램, 인터랙션 오버뷰 다이어그램, 타이밍 다이어그램

UML 만드는 3가지 방법

Sketch, Blueprint, Programming language

OOA가 무엇이고 사용되는 다이어그램은?

오브젝트 관계를 분석하는 단계, 정의, 컨셉잡기, 환경 등을 포함, 개념 식별
usecase diagram
domain model

OOD가 무엇이고 사용되는 다이어그램은?

위에서 분석한 오브젝트를 더 정확하게 디자인함, 메소드 호출, 책임 할당
sequence diagram
class diagram

UP의 4단계 프로세스에 대해 설명하세요

Inception(개시)
대강의 비전과 요구사항, 비즈니스 케이스, 범위, 대략적, 비용 추정에 대해 정의, 용어집, 보충 명세서, 프로토타입과 개념 증명, Iteration 계획, Usecase Model
Elaboration(정련)
정제된 비전, 핵심 아키텍처(구조) 정의, 높은 위험성 해결, 대부분의 요구사항과 범위 식별, 보다 현실적인 추정, OOA, Domain Model, Class Diagram, Sequence Diagram
Construction(구축)
좀더 쉬운 부분의 반복적인 구현 및 배치 준비
Transition(전이)
베타 테스트, 배치

Requirements의 유형과 설명하세요.

기능적 요구 사항(functional requirements)
- 시스템이 무엇을 하여야 하는지를 기술한 것
- 예) 현금인출, 잔금조회, 계좌이체, 현금 서비스등의 외형적 기능

비기능적 요구 사항(nonfunctional requirements)
- 개발 과정이 고수해야 할 제약조건
- 예) 하드웨어 자원의 제약, 소프트웨어 품질 특성에 대한 수준
- 사용용이성, 효율성, 신뢰성, 유지보수성, 재사용성

FURPS가 무엇인지 나열하세요.

Functionality, Usability, Reliability, Performance, Supportability

Why is Required Interface essential in designing platform SW?

내부적으로 직접 구현하지는 않는 상황 - 외부로부터 플러그인으로 받을 수 있도록, 범용으로 쓰려고, 가변적으로.
platform sw에 가변적인 부분이 있고, 플랫폼은 단독으로 동작을 하지 않는다.
그 위에 application이 돌아야 하는데, 이 application이 해당 가변적인 부분을 interface로 반드시 구현하도록 하기 위해.

Provided Interface

컴포넌트에서 기능을 제공하기 위해 노출되는 Interface

UP의 단계

[ENG][아키텍처]OOP Concepts

CamelAct — Wed, 31 Aug 2022 00:37:43 +0900

OOP, 다이나믹 바인딩이 OOP에서 왜 필수인가요? 장점, 단점은?

- 장점 : runtime시에 클래스를 변경할 수 있다.
- 단점 : 어떤 값이 들어올지 몰라서 들어올 값보다 많은 메모리 공간을 차지하고 있기 때문에 메모리 공간이 낭비될 수 있다.
들어오는 값이 메모리 타입에 맞는지 확인하기 때문에 속도가 늦어진다.

OOP 5가지 원칙에 대해서 설명해 보세요.

Abstraction
- 객체의 공통된 속성들 중 필요한 부분을 포착해서 클래스로 정의하는 설계 기법
- 구체적인 사물들의 공통적인 특징을 파악해서 이를 하나의 개념(집합)으로 다루는 것
Encapsulation
- 외부에 노출할 필요가 없는 정보들은 은닉
- 필요한 정보만 보여주게끔 설계
Inheritance
- 부모 클래스가 자손 클래스에게 속성을 물려주는 것
- 코드의 재사용
Polymorphism
- 같은 형태이지만 다른 기능을 하는 것
- 오버라이딩(Overriding) 은 상위 클래스가 가지고 있는 메서드를 하위 클래스가 재정의해서 사용
- 오버로딩(Overloading) 은 이름의 메서드 여러개를 가지면서 매개변수의 유형과 개수가 다르도록 하는 기술
Composition
- ‘Has-a’ 관계. 런타임에 동적으로 다른 객체의 reference를 얻어 정의됨. Interface를 통해서만 접근하므로 Encapsulation 원칙을 망가뜨리지 않음

Encapsulation, 무엇인가요?

SW가 어떻게 동작하는지 자세히 몰라도 쉽게 사용할 수 있도록 설계/구현함

Information Hiding, 무엇인가요?

Client에게 interface만 제공하고 data에 대한 접근은 막음(Visibility)

Inheritance, 무엇인가요?

‘Is-a’ , ‘Is a kind of’ 관계라고도 하며 Class를 organize 하는 방식, Generalization이라고도 표현함. 공통 속성을 갖는 Class들을 묶어서 공통 속성이 한 번만 정의되도록 함

Polymorphism, 무엇인가요? 4가지 기억

Descendants(자손)
부모의 X에서 X b = new Y()를 할 수 있다. 반대는불가

다형성은 "여러 객체에게 동일한 명령을 내렸을 때 서로 다르게 반응하는 현상"을 의미합니다.
1) 인터페이스(interface)
2) 추상클래스(abstract)
3) 메소드 오버라이딩
4) 메소드 오버로딩

컴파일 타임과 런타임시에 Polymorphism을 설명하세요.

메소드 오버라이딩을 통해 컴파일 타임/런타임 폴리모피즘 가능
컴파일시 - 메소드명은 같으나 파라미터가 다른경우 -> Overloading
런타임시 - 상속을 통해 메소드 명, 파라미터가 같은 경우 -> Overriding

Abstract Class

추상 클래스와 인터페이스의 차이점은 무엇입니까?
인터페이스 : 역할 구분을 하고 싶다면, 구현할 컴포넌트의 표준을 정하는 것
추상클래스 : abstract is a 관계가 명확할 때, 구체화시킬 구현체를 추상화시키는 기법

추상화란?

여러 가지 사물이나 개념에서 공통되는 특성이나 속성 따위를 추출하여 파악하는 작용, 구체적인 것을 감추고 보고 싶어하는 전체적인 특성을 드러내는 것

Generic Class & Template 무엇인가?

클래스를 디자인할 때 클래스를 사용할 타입을 지정하지 않고, 클래스를 사용할 때 지정하여 사용하는 기술을 뜻한다. 미리 정의하지 않은 타입은 매개변수로 제공한다. 예를 들어, List 클래스는 내부에 포함할 원소들의 타입으로 매개변수화 될 수 있다. 정수형의 리스트를 선언하고 싶으면 List 타입에 Integer 타입을 매개변수로 넘겨주면 되고, String 객체의 리스트를 만들고 싶다면 String을 넘기면 된다. C++에서는 Template이라고 하며, Ada와 Eiffel에서는 Generic이라고 한다.

OOP, C와 같은 절차적 프로그램의 일반적인 단점은 무엇입니까?

장점
1. 개인 프로젝트에 적합한 언어입니다.
2. 객체지향 프로그래밍과 비교하여 속도가 빠른편입니다.

단점
1. 유지보수가 어렵습니다.
2. 코드의 순서가 바뀌면 의도한 대로 프로그램이 동작하지 않을 수 있습니다.
3. 프로그램의 분석과 디버깅이 어렵습니다.
4. 위와 같은 단점으로 인해 대형 프로젝트에는 부적합합니다.

OOP, Functional Programming 장점

자료 처리를 수학적 함수의 계산으로 취급하고 상태와 가변 데이터를 멀리하는 것이 핵심이며, 객체지향 프로그래밍보다 강한 추상화를 통해서 상태 변경에 따른 부작용에서 자유로울 수 있다.

OOP, Convert from C to OOP

도메인 엔티티를 식별해내고 그것을 객체로 만듭니다
Procedure에 있던 책임을 GRASP 원칙을 지키면서 객체들에 옮겨줍니다
Procedure을 Usecase라고 본다면 Loose coupling, high cohesion으로 묶어서 객체화, Component화 합니다.
Abstraction, Encapsulation하여 객체를 만들어야합니다.

OOP 개념

[ENG][자료구조]Priority Queue 이론과 예제

CamelAct — Sun, 26 Jun 2022 22:48:39 +0900

Overview

큐(Queue)는 먼저 들어오는 데이터가 먼저 나가는 FIFO(First In First Out) 형식의 자료구조입니다.

우선순위 큐(Priority Queue)는 먼저 들어오는 데이터가 아니라, 우선순위가 높은 데이터가 먼저 나가는 형태의 자료구조이다. 우선순위 큐는 일반적으로 힙(Heap)을 이용하여 구현합니다.

부모 노드의 키 값이 자식 노드보다 크거나 같은 완전 이진트리입니다.

삽입 또는 삭제 연산을 위한 시간 복잡도는 O(n)입니다.

반면 힙트리는 완전 이진트리 구조이므로 힙트리의 높이는 log₂(n+1)이며, 힙의 시간 복잡도는 O(log₂n)입니다.

자식 노드를 구하고 싶을 때

- 왼쪽 자식 노드 index = (부모 노드 index) * 2

- 오른쪽 자식 노드 index = (부모 노드 index) * 2 + 1

부모 노드를 구하고 싶을 때

- 부모 노드 index = (자식 노드 index) / 2

Usecase

- 명품 스토어 대기열에 명단을 넣는데 VVIP라면 먼저 거래할 수 있도록 한다.

Structure

http://m.blog.naver.com/c_18/220026838448

Code Example

package com.algorithm.basic;

public class PriorityQueue {
	final int MAX_SIZE = 1000;

	int heap[] = new int[MAX_SIZE];
	int heapSize = 0;

	void init() {
		heapSize = 0;
	}

	void push(int value) {
		if (heapSize + 1 > MAX_SIZE) {
			return;
		}

		heap[heapSize] = value;

		int current = heapSize;
		while (current > 0 && heap[current] < heap[(current - 1) / 2]) {
			int temp = heap[(current - 1) / 2];
			heap[(current - 1) / 2] = heap[current];
			heap[current] = temp;
			current = (current - 1) / 2;
		}

		heapSize = heapSize + 1;
	}

	int pop() {
		if (heapSize <= 0) {
			return -1;
		}

		int value = heap[0];
		heapSize = heapSize - 1;

		heap[0] = heap[heapSize];

		int current = 0;
		while (current < heapSize && current * 2 + 1 < heapSize) {
			int child;
			if (current * 2 + 2 >= heapSize) {
				child = current * 2 + 1;
			} else {
				child = heap[current * 2 + 1] < heap[current * 2 + 2] ? current * 2 + 1 : current * 2 + 2;
			}

			if (heap[current] < heap[child]) {
				break;
			}

			int temp = heap[current];
			heap[current] = heap[child];
			heap[child] = temp;

			current = child;
		}
		return value;
	}

	void print(int[] heap, int heap_size) {
		for (int i = 0; i < heap_size; i++) {
			System.out.print(heap[i] + " ");
		}
		System.out.println();
	}

	public static void main(String arg[]) throws Exception {
		PriorityQueue priorityQueue = new PriorityQueue();
		
		int N = 10;

		priorityQueue.init();

		priorityQueue.push(1);
		priorityQueue.push(3);
		priorityQueue.push(6);
		priorityQueue.push(5);
		priorityQueue.push(2);
		priorityQueue.push(7);
		priorityQueue.push(4);
		priorityQueue.push(8);
		priorityQueue.push(9);
		priorityQueue.push(0);

		for (int i = 0; i < N; i++) {
			System.out.print(priorityQueue.pop() + " ");
		}
		System.out.println();
	}
}

Console Result

0 1 2 3 4 5 6 7 8 9

Conclusion

N/A

[ENG][블로그에]구글 에드센스 광고 게시

CamelAct — Sat, 25 Jun 2022 22:20:52 +0900

에드센스 연동

블로그 관리에서 수익 메뉴 - Google AdSense를 확인 후 연동하기 버튼을 클릭합니다.

연동이 된다면 상세보기를 통해 연동 확인을 합니다.

아래에 내려보면 광고를 어디에 게시할지 설정을 할 수 있습니다.

실제 광고 수익을 얻기 위해선 구글 에드센스에 연동이 되어야합니다.

하기 안내 페이지에 접근하여 연동을 합니다.

https://www.google.com/adsense/start/

Google AdSense - ウェブサイトを収益化

Google AdSense を使用してウェブサイトを収益化しましょう。広告のサイズは自動的に最適化され、表示とクリックが促進されます。

www.google.com

지금 이 블로그는 연동되어 있는데, 처음이라면 자신의 블로그 주소와

사이트 심사 버튼을 클릭하여 심사 받도록 합니다.

에드고시라는 말이 있는데 그만큼 에드센스 승인 받기가 어렵다는 말입니다.

이 블로그는 운이 좋아서 한 번에 통과하였습니다.

글을 매일 하루에 한 개씩 쓰고, 내용이 어느정도 알차게 쓰면 통과되는 것으로 보입니다.

에드센스 고시를 통과하게되면 위와 같이 메일로 활성화 되었음 알 수 있습니다.

[ENG][자료구조]Queue 이론과 예제

CamelAct — Fri, 24 Jun 2022 22:52:56 +0900

Overview

큐의 구조는 스택과 다르게 '선입선출'의 구조를 가지고 있습니다.

스택은 막힌 박스와 같아 먼저 들어온 것이 가장 나중에 나가는 구조지만, 큐는 먼저 들어온 것이 먼저 나가는 구조입니다. 좋은 예로 은행에 있는 번호표가 있습니다. 은행에 방문하여 먼저 온 사람이 먼저 업무를 봐야 합니다. 은행에서는 번호표를 나눠줍니다. 먼저 온 손님은 늦게 온 손님보다 먼저 서비스를 받게 하기 위해서죠. 이러한 은행의 번호표의 체계가 큐(Queue)입니다.

- enqueue : 큐 맨 뒤에 어떠한 요소를 추가, 마지막으로 온 손님에게 번호표 발부

- dequeue : 큐 맨 앞쪽의 요소를 삭제, 창구에서 서비스를 받은 손님의 번호표를 대기목록에서 삭제

- peek : front에 위치한 데이터를 읽음, 다음 서비스를 받을 손님이 누구인지 확인

- front : 큐의 맨 앞의 위치(인덱스), 다음 서비스를 받을 손님의 번호

- rear : 큐의 맨 뒤의 위치(인덱스), 마지막에 온 손님의 번호

Usecase

- 은행 줄 서기

Structure

https://ko.wikipedia.org/wiki/%ED%81%90_(%EC%9E%90%EB%A3%8C_%EA%B5%AC%EC%A1%B0)

Code Example

package com.data.structure;

public class MyQueue {
	final int MAX_N = 1000;

	int front;
	int rear;
	int queue[] = new int[MAX_N];

	void init() {
		front = 0;
		rear = 0;
	}

	boolean queueIsEmpty() {
		return (front == rear);
	}

	boolean queueIsFull() {
		if ((front + 1) % MAX_N == rear) {
			return true;
		} else {
			return false;
		}
	}

	boolean enqueue(int value) {
		if (queueIsFull()) {
			System.out.print("queue is full!");
			return false;
		}
		queue[front] = value;
		front++;
		if (front == MAX_N) {
			front = 0;
		}

		return true;
	}

	Integer dequeue() {
		if (queueIsEmpty()) {
			System.out.print("queue is empty!");
			return null;
		}

		Integer value = new Integer(queue[rear]);

		rear++;
		if (rear >= MAX_N) {
			rear = 0;
		}
		return value;
	}

	public static void main(String arg[]) throws Exception {
		MyQueue myQueue = new MyQueue();

		int N = 10;

		myQueue.init();

		for (int i = 0; i < N; i++) {
			myQueue.enqueue(i);
		}

		while (!myQueue.queueIsEmpty()) {
			Integer value = myQueue.dequeue();
			if (value != null) {
				System.out.print(value.intValue() + " ");
			}
		}
		System.out.println();
	}
}

Console Result

0 1 2 3 4 5 6 7 8 9

Conclusion

N/A

[ENG][자료구조]Stack 이론과 예제

CamelAct — Thu, 23 Jun 2022 22:25:52 +0900

Overview

한쪽 끝에서만 자료를 넣고 뺄 수 있는 LIFO(Last In First Out) 형식의 자료 구조
즉, 가장 최근에 스택에 추가한 항목이 가장 먼저 제거될 항목이다.

- pop(): 스택에서 가장 위에 있는 항목을 제거한다.
- push(item): item 하나를 스택의 가장 윗부분에 추가한다.
- peek(): 스택의 가장 위에 있는 항목을 반환한다.
- isEmpty(): 스택이 비어 있을 때에 true를 반환한다.

배열과 달리 스택은 i번째 항목에 접근할 수 없다.

Usecase

- 웹 브라우저 방문기록 (뒤로 가기)
- 실행 취소 (undo)
- 역순 문자열 만들기
- 수식의 괄호 검사 (연산자 우선순위 표현을 위한 괄호 검사, 후위 표기법 계산)

Structure

https://ko.wikipedia.org/wiki/%EC%8A%A4%ED%83%9D

Code Example

package com.data.structure;

class MyStack {

	public final int MAX_N = 1000;

	public int top;
	public int stack[] = new int[MAX_N];

	public void stackInit() {
		top = 0;
	}

	public boolean stackIsEmpty() {
		return (top == 0);
	}

	public boolean stackIsFull() {
		return (top == MAX_N);
	}

	public boolean push(int value) {
		if (stackIsFull()) {
			System.out.println("stack overflow!");
			return false;
		}
		stack[top] = value;
		top++;

		return true;
	}

	public Integer pop() {
		if (top == 0) {
			System.out.println("stack is empty!");
			return null;
		}

		top--;
		Integer value = new Integer(stack[top]);

		return value;
	}

	public static void main(String arg[]) throws Exception {
		MyStack myStack = new MyStack();
		
		int N = 10;

		myStack.stackInit();
		
		for (int i = 0; i < N; i++) {
			int value = i;
			myStack.push(value);
		}

		while ( ! myStack.stackIsEmpty()) {
			Integer value = myStack.pop();
			if (value != null) {
				System.out.print(value.intValue() + " ");
			}
		}
	}
}

Console Result

9 8 7 6 5 4 3 2 1 0

Conclusion

N/A

[ENG][디자인패턴]Prototype 패턴 이론과 설명

CamelAct — Wed, 22 Jun 2022 16:21:24 +0900

Overview

객체 생성과 관련된 패턴은 겹치는 영역이 있습니다. 프로토타입 패턴이나 추상 팩토리 패턴을 적용할 수 있는 경우가 있습니다.

추상 팩토리 패턴은 프로토타입 세트를 갖고 이를 복제하고 제품 객체를 반환할 수 있습니다.

그런 다음 디자이너의 재량에 따라 추상 팩토리 패턴, 빌더 패턴 또는 프로토타입 패턴으로 변경할 수 있습니다. 프로토타입은 서브클래싱이 필요하지 않습니다.
그러나 "초기화" 작업이 필요합니다. 팩토리 메소드 패턴은 서브클래싱이 필요하지만 "초기화" 작업은 필요하지 않습니다.

디자이너는 복합 패턴이나 데코레이터 패턴을 사용하는 무거운 디자인을 프로토타입으로 훨씬 더 잘 만들 수 있습니다.

원칙은 "런타임"에 다른 "객체"를 생성한다는 것입니다.
즉, 이 시점에서 복제되는 개체의 "실제 복사본"이 만들어집니다.

"실제 사본"이라는 용어는 새로 생성된 개체가 복제된 개체의 속성과 동일한 속성을 가짐을 의미합니다.

반면에 "new"를 사용하여 객체를 생성하는 경우 새로 생성된 객체의 속성은 초기 값을 갖습니다.

장점
객체를 생성하기 위해 별도의 객체 생성 클래스가 필요하지 않습니다. 개체의 각 부분을 결합하여 만든 형태에도 적용할 수 있습니다.

단점
생성하고자 하는 객체의 데이터 타입인 모든 클래스는 clone() 메소드를 구현해야 한다.

Structure

https://ko.wikipedia.org/wiki/%ED%94%84%EB%A1%9C%ED%86%A0%ED%83%80%EC%9E%85_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

import java.util.Hashtable;

interface Product extends Cloneable {
	public abstract void use(String s);

	public abstract Product createClone();
}

class Manager {
	private Hashtable showcase = new Hashtable();

	public void register(String name, Product proto) {
		showcase.put(name, proto);
	}

	public Product create(String protoname) {
		Product p = (Product) showcase.get(protoname);
		return p.createClone();
	}
}

class UnderlinePen implements Product {
	private char ulchar;

	public UnderlinePen(char ulchar) {
		this.ulchar = ulchar;
	}

	public void use(String s) {
		int length = s.getBytes().length;
		System.out.println("\"" + s + "\"");
		System.out.print(" ");
		for (int i = 0; i < length; i++) {
			System.out.print(ulchar);
		}
		System.out.println("");
	}

	public Product createClone() {
		Product p = null;
		try {
			p = (Product) clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return p;
	}
}

class MessageBox implements Product {
	private char decochar;

	public MessageBox(char decochar) {
		this.decochar = decochar;
	}

	public void use(String s) {
		int length = s.getBytes().length;
		for (int i = 0; i < length + 4; i++) {
			System.out.print(decochar);
		}
		System.out.println("");
		System.out.println(decochar + " " + s + " " + decochar);
		for (int i = 0; i < length + 4; i++) {
			System.out.print(decochar);
		}
		System.out.println("");
	}

	public Product createClone() {
		Product p = null;
		try {
			p = (Product) clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return p;
	}
}

public class MyPrototype {
	public static void main(String[] args) {
		// 준비
		Manager manager = new Manager();
		UnderlinePen upen = new UnderlinePen('~');
		MessageBox mbox = new MessageBox('*');
		MessageBox sbox = new MessageBox('/');

		UnderlinePen upen2 = new UnderlinePen('%');

		upen.use("Hello, world.");
		System.out.println();
		mbox.use("Hello, world.");
		System.out.println();
		sbox.use("Hello, world.");
		System.out.println();
		upen2.use("Hello, world.");
		System.out.println();

		manager.register("strong message", upen);
		manager.register("warning box", mbox);
		manager.register("slash box", sbox);

		// Prototype으로부터 복제 생성

		Product p1 = manager.create("strong message");
		p1.use("Hello, world.");
		System.out.println();

		Product p2 = manager.create("warning box");
		p2.use("Hello, world.");
		System.out.println();

		Product p3 = manager.create("slash box");
		p3.use("Hello, world.");
		System.out.println();

	}
}

Console Result

"Hello, world."
 ~~~~~~~~~~~~~

*****************
* Hello, world. *
*****************

/////////////////
/ Hello, world. /
/////////////////

"Hello, world."
 %%%%%%%%%%%%%

"Hello, world."
 ~~~~~~~~~~~~~

*****************
* Hello, world. *
*****************

/////////////////
/ Hello, world. /
/////////////////

Conclusion

N/A

[ENG][디자인패턴]Proxy 패턴 이론과 설명

CamelAct — Tue, 21 Jun 2022 12:11:21 +0900

Overview

프록시 패턴은 컴퓨터 프로그래밍의 소프트웨어 디자인 패턴 중 하나입니다.

일반적으로 프록시는 다른 것에 대한 인터페이스 역할을 하는 클래스입니다. 프록시는 모든 것에 대한 인터페이스 역할을 할 수 있습니다(예: 네트워크 연결, 메모리의 큰 개체, 파일 또는 복제할 수 없거나 수요가 많은 리소스).

프록시 패턴의 잘 알려진 예는 참조 카운트 스마트 포인터 개체입니다.

복잡한 객체의 복사본이 여러 개 존재해야 하는 상황에서 프록시 패턴을 플라이웨이트 패턴과 결합하여 애플리케이션의 메모리 사용량을 줄일 수 있습니다.

장점
전처리 및 후처리에 사용하기 쉽습니다. (B가 C에게 묻기 전에 다른 작업을 전처리할 수 있음)
특정 방법에 대한 보안은 양호합니다. (B가 C에게 요청한다는 사실은 A가 무슨 일이 일어나고 있는지 정확히 알기 어렵게 만든다)

불리
절차적 패턴을 사용하면 가독성이 떨어집니다. (A->B-C의 구조는 누군가 거쳐야 하는 구조입니다. 이런 경우가 많으면 가독성이 떨어질 수 있습니다.)

Structure

https://ko.wikipedia.org/wiki/%ED%94%84%EB%A1%9D%EC%8B%9C_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

import java.awt.Component;
import java.awt.Graphics;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Hashtable;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

class ImageComponent extends JComponent {
	private static final long serialVersionUID = 1L;
	private Icon icon;

	public ImageComponent(Icon icon) {
		this.icon = icon;
	}

	public void setIcon(Icon icon) {
		this.icon = icon;
	}

	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		int w = icon.getIconWidth();
		int h = icon.getIconHeight();
		int x = (800 - w)/2;
		int y = (600 - h)/2;
		icon.paintIcon(this, g, x, y);
	}
}

class ImageProxy implements Icon {
	volatile ImageIcon imageIcon;
	final URL imageURL;
	Thread retrievalThread;
	boolean retrieving = false;

	public ImageProxy(URL url) {
		imageURL = url;
	}

	@Override
	public int getIconWidth() {
		if (imageIcon != null) {
			return imageIcon.getIconWidth();
		} else {
			return 800;
		}
	}

	@Override
	public int getIconHeight() {
		if (imageIcon != null) {
			return imageIcon.getIconHeight();
		} else {
			return 600;
		}
	}

	synchronized void setImageIcon(ImageIcon imageIcon) {
		this.imageIcon = imageIcon;
	}

	@Override
	public void paintIcon(final Component c, Graphics g, int x, int y) {
		if (imageIcon != null) {
			imageIcon.paintIcon(c, g, x, y);
		} else {
			g.drawString("Loading CD cover, please wait...", x + 300, y + 190);
			if (!retrieving) {
				retrieving = true;

				retrievalThread = new Thread(new Runnable() {
					public void run() {
						try {
							setImageIcon(new ImageIcon(imageURL, "CD Cover"));
							c.repaint();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				});
				retrievalThread.start();
			}
		}
	}
}

public class MyProxy {

	ImageComponent imageComponent;
	JFrame frame = new JFrame("CD Cover Viewer");
	JMenuBar menuBar;
	JMenu menu;
	Hashtable<String, String> cds = new Hashtable<String, String>();

	public static void main(String[] args) throws Exception {
		new MyProxy();
	}

	public MyProxy() throws Exception{
		cds.put("Buddha Bar","http://images.amazon.com/images/P/B00009XBYK.01.LZZZZZZZ.jpg");
		cds.put("Ima","http://images.amazon.com/images/P/B000005IRM.01.LZZZZZZZ.jpg");
		cds.put("Karma","http://images.amazon.com/images/P/B000005DCB.01.LZZZZZZZ.gif");
		cds.put("MCMXC A.D.","http://images.amazon.com/images/P/B000002URV.01.LZZZZZZZ.jpg");
		cds.put("Northern Exposure","http://images.amazon.com/images/P/B000003SFN.01.LZZZZZZZ.jpg");
		cds.put("Selected Ambient Works, Vol. 2","http://images.amazon.com/images/P/B000002MNZ.01.LZZZZZZZ.jpg");

		URL initialURL = new URL((String)cds.get("Selected Ambient Works, Vol. 2"));
		menuBar = new JMenuBar();
		menu = new JMenu("Favorite CDs");
		menuBar.add(menu);
		frame.setJMenuBar(menuBar);

		for (Enumeration<String> e = cds.keys(); e.hasMoreElements();) {
			String name = (String)e.nextElement();
			JMenuItem menuItem = new JMenuItem(name);
			menu.add(menuItem); 
			menuItem.addActionListener(event -> {
				imageComponent.setIcon(new ImageProxy(getCDUrl(event.getActionCommand())));
				frame.repaint();
			});
		}

		// set up frame and menus

		Icon icon = new ImageProxy(initialURL);
		imageComponent = new ImageComponent(icon);
		frame.getContentPane().add(imageComponent);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(800,600);
		frame.setVisible(true);

	}

	URL getCDUrl(String name) {
		try {
			return new URL((String) cds.get(name));
		} catch (MalformedURLException e) {
			e.printStackTrace();
			return null;
		}
	}

}

Console Result

Additional Code Example

package com.example.design.pattern.core;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;

class NonOwnerInvocationHandler implements InvocationHandler {
	PersonBean person;

	public NonOwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {

		try {
			if (method.getName().startsWith("get")) {
				return method.invoke(person, args);
			} else if (method.getName().equals("setHotOrNotRating")) {
				return method.invoke(person, args);
			} else if (method.getName().startsWith("set")) {
				throw new IllegalAccessException();
			}
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return null;
	}
}

class OwnerInvocationHandler implements InvocationHandler {
	PersonBean person;

	public OwnerInvocationHandler(PersonBean person) {
		this.person = person;
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {

		try {
			if (method.getName().startsWith("get")) {
				return method.invoke(person, args);
			} else if (method.getName().equals("setHotOrNotRating")) {
				throw new IllegalAccessException();
			} else if (method.getName().startsWith("set")) {
				return method.invoke(person, args);
			}
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		return null;
	}
}

class PersonBeanImpl implements PersonBean {
	String name;
	String gender;
	String interests;
	int rating;
	int ratingCount = 0;

	public String getName() {
		return name;
	}

	public String getGender() {
		return gender;
	}

	public String getInterests() {
		return interests;
	}

	public int getHotOrNotRating() {
		if (ratingCount == 0)
			return 0;
		return (rating / ratingCount);
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public void setInterests(String interests) {
		this.interests = interests;
	}

	public void setHotOrNotRating(int rating) {
		this.rating += rating;
		ratingCount++;
	}
}

interface PersonBean {

	String getName();

	String getGender();

	String getInterests();

	int getHotOrNotRating();

	void setName(String name);

	void setGender(String gender);

	void setInterests(String interests);

	void setHotOrNotRating(int rating);

}

public class MyProxy {
	HashMap<String, PersonBean> datingDB = new HashMap<String, PersonBean>();

	public static void main(String[] args) {
		MyProxy test = new MyProxy();
		test.drive();
	}

	public MyProxy() {
		initializeDatabase();
	}

	public void drive() {
		PersonBean joe = getPersonFromDatabase("Joe Javabean");
		PersonBean ownerProxy = getOwnerProxy(joe);
		System.out.println("Name is " + ownerProxy.getName());
		ownerProxy.setInterests("bowling, Go");
		System.out.println("Interests set from owner proxy");
		try {
			ownerProxy.setHotOrNotRating(10);
		} catch (Exception e) {
			System.out.println("Can't set rating from owner proxy");
		}
		System.out.println("Rating is " + ownerProxy.getHotOrNotRating());

		PersonBean nonOwnerProxy = getNonOwnerProxy(joe);
		System.out.println("Name is " + nonOwnerProxy.getName());
		try {
			nonOwnerProxy.setInterests("bowling, Go");
		} catch (Exception e) {
			System.out.println("Can't set interests from non owner proxy");
		}
		nonOwnerProxy.setHotOrNotRating(3);
		System.out.println("Rating set from non owner proxy");
		System.out.println("Rating is " + nonOwnerProxy.getHotOrNotRating());
	}

	PersonBean getOwnerProxy(PersonBean person) {

		return (PersonBean) Proxy.newProxyInstance(person.getClass().getClassLoader(),
				person.getClass().getInterfaces(), new OwnerInvocationHandler(person));
	}

	PersonBean getNonOwnerProxy(PersonBean person) {

		return (PersonBean) Proxy.newProxyInstance(person.getClass().getClassLoader(),
				person.getClass().getInterfaces(), new NonOwnerInvocationHandler(person));
	}

	PersonBean getPersonFromDatabase(String name) {
		return (PersonBean) datingDB.get(name);
	}

	void initializeDatabase() {
		PersonBean joe = new PersonBeanImpl();
		joe.setName("Joe Javabean");
		joe.setInterests("cars, computers, music");
		joe.setHotOrNotRating(7);
		datingDB.put(joe.getName(), joe);

		PersonBean kelly = new PersonBeanImpl();
		kelly.setName("Kelly Klosure");
		kelly.setInterests("ebay, movies, music");
		kelly.setHotOrNotRating(6);
		datingDB.put(kelly.getName(), kelly);
	}
}

Console Result

Name is Joe Javabean
Interests set from owner proxy
Can't set rating from owner proxy
Rating is 7
Name is Joe Javabean
Can't set interests from non owner proxy
Rating set from non owner proxy
Rating is 5

Conclusion

N/A

[ENG][디자인패턴]Facade 패턴 이론과 설명

CamelAct — Mon, 20 Jun 2022 12:06:13 +0900

Overview

Facade 패턴은 새로운 서비스를 개발하는 것이므로 서브시스템을 사용하고자 할 때 이들을 함께 묶는 클래스를 생성한다. 다시 말해, 새로운 클래스가 동일한 레이어에 하위 시스템을 연결하면 시스템이 스파게티 코드처럼 엉키고 유지 관리가 어려워집니다.

장점
하위 시스템 간의 결합을 줄일 수 있습니다.
클라이언트의 관점에서 코드를 더 간결하게 만듭니다.

불리
레거시에서 레거시로, 레거시에서 레거시 등으로 인해 코드가 복잡해질 수 있습니다.

Structure

https://sbcode.net/typescript/facade/

Code Example

package  com.example.design.pattern;

class CdPlayer {
	String description;
	int currentTrack;
	Amplifier amplifier;
	String title;

	public CdPlayer(String description, Amplifier amplifier) {
		this.description = description;
		this.amplifier = amplifier;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void eject() {
		title = null;
		System.out.println(description + " eject");
	}

	public void play(String title) {
		this.title = title;
		currentTrack = 0;
		System.out.println(description + " playing \"" + title + "\"");
	}

	public void play(int track) {
		if (title == null) {
			System.out.println(description + " can't play track " + currentTrack + ", no cd inserted");
		} else {
			currentTrack = track;
			System.out.println(description + " playing track " + currentTrack);
		}
	}

	public void stop() {
		currentTrack = 0;
		System.out.println(description + " stopped");
	}

	public void pause() {
		System.out.println(description + " paused \"" + title + "\"");
	}

	public String toString() {
		return description;
	}
}

class DvdPlayer {
	String description;
	int currentTrack;
	Amplifier amplifier;
	String movie;

	public DvdPlayer(String description, Amplifier amplifier) {
		this.description = description;
		this.amplifier = amplifier;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void eject() {
		movie = null;
		System.out.println(description + " eject");
	}

	public void play(String movie) {
		this.movie = movie;
		currentTrack = 0;
		System.out.println(description + " playing \"" + movie + "\"");
	}

	public void play(int track) {
		if (movie == null) {
			System.out.println(description + " can't play track " + track + " no dvd inserted");
		} else {
			currentTrack = track;
			System.out.println(description + " playing track " + currentTrack + " of \"" + movie + "\"");
		}
	}

	public void stop() {
		currentTrack = 0;
		System.out.println(description + " stopped \"" + movie + "\"");
	}

	public void pause() {
		System.out.println(description + " paused \"" + movie + "\"");
	}

	public void setTwoChannelAudio() {
		System.out.println(description + " set two channel audio");
	}

	public void setSurroundAudio() {
		System.out.println(description + " set surround audio");
	}

	public String toString() {
		return description;
	}
}

class Tuner {
	String description;
	Amplifier amplifier;
	double frequency;

	public Tuner(String description, Amplifier amplifier) {
		this.description = description;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void setFrequency(double frequency) {
		System.out.println(description + " setting frequency to " + frequency);
		this.frequency = frequency;
	}

	public void setAm() {
		System.out.println(description + " setting AM mode");
	}

	public void setFm() {
		System.out.println(description + " setting FM mode");
	}

	public String toString() {
		return description;
	}
}

class Projector {
	String description;
	DvdPlayer dvdPlayer;

	public Projector(String description, DvdPlayer dvdPlayer) {
		this.description = description;
		this.dvdPlayer = dvdPlayer;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void wideScreenMode() {
		System.out.println(description + " in widescreen mode (16x9 aspect ratio)");
	}

	public void tvMode() {
		System.out.println(description + " in tv mode (4x3 aspect ratio)");
	}

	public String toString() {
		return description;
	}
}

class Amplifier {
	String description;
	Tuner tuner;
	DvdPlayer dvd;
	CdPlayer cd;

	public Amplifier(String description) {
		this.description = description;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void setStereoSound() {
		System.out.println(description + " stereo mode on");
	}

	public void setSurroundSound() {
		System.out.println(description + " surround sound on (5 speakers, 1 subwoofer)");
	}

	public void setVolume(int level) {
		System.out.println(description + " setting volume to " + level);
	}

	public void setTuner(Tuner tuner) {
		System.out.println(description + " setting tuner to " + dvd);
		this.tuner = tuner;
	}

	public void setDvd(DvdPlayer dvd) {
		System.out.println(description + " setting DVD player to " + dvd);
		this.dvd = dvd;
	}

	public void setCd(CdPlayer cd) {
		System.out.println(description + " setting CD player to " + cd);
		this.cd = cd;
	}

	public String toString() {
		return description;
	}
}

class Screen {
	String description;

	public Screen(String description) {
		this.description = description;
	}

	public void up() {
		System.out.println(description + " going up");
	}

	public void down() {
		System.out.println(description + " going down");
	}

	public String toString() {
		return description;
	}
}

class TheaterLights {
	String description;

	public TheaterLights(String description) {
		this.description = description;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void dim(int level) {
		System.out.println(description + " dimming to " + level + "%");
	}

	public String toString() {
		return description;
	}
}

class PopcornPopper {
	String description;

	public PopcornPopper(String description) {
		this.description = description;
	}

	public void on() {
		System.out.println(description + " on");
	}

	public void off() {
		System.out.println(description + " off");
	}

	public void pop() {
		System.out.println(description + " popping popcorn!");
	}

	public String toString() {
		return description;
	}
}

class HomeTheaterFacade {
	Amplifier amp;
	Tuner tuner;
	DvdPlayer dvd;
	CdPlayer cd;
	Projector projector;
	TheaterLights lights;
	Screen screen;
	PopcornPopper popper;

	public HomeTheaterFacade(Amplifier amp, Tuner tuner, DvdPlayer dvd, CdPlayer cd, Projector projector, Screen screen,
			TheaterLights lights, PopcornPopper popper) {

		this.amp = amp;
		this.tuner = tuner;
		this.dvd = dvd;
		this.cd = cd;
		this.projector = projector;
		this.screen = screen;
		this.lights = lights;
		this.popper = popper;
	}

	public void watchMovie(String movie) {
		System.out.println("Get ready to watch a movie...");
		popper.on();
		popper.pop();
		lights.dim(10);
		screen.down();
		projector.on();
		projector.wideScreenMode();
		amp.on();
		amp.setDvd(dvd);
		amp.setSurroundSound();
		amp.setVolume(5);
		dvd.on();
		dvd.play(movie);
	}

	public void endMovie() {
		System.out.println("Shutting movie theater down...");
		popper.off();
		lights.on();
		screen.up();
		projector.off();
		amp.off();
		dvd.stop();
		dvd.eject();
		dvd.off();
	}

	public void listenToCd(String cdTitle) {
		System.out.println("Get ready for an audiopile experence...");
		lights.on();
		amp.on();
		amp.setVolume(5);
		amp.setCd(cd);
		amp.setStereoSound();
		cd.on();
		cd.play(cdTitle);
	}

	public void endCd() {
		System.out.println("Shutting down CD...");
		amp.off();
		amp.setCd(cd);
		cd.eject();
		cd.off();
	}

	public void listenToRadio(double frequency) {
		System.out.println("Tuning in the airwaves...");
		tuner.on();
		tuner.setFrequency(frequency);
		amp.on();
		amp.setVolume(5);
		amp.setTuner(tuner);
	}

	public void endRadio() {
		System.out.println("Shutting down the tuner...");
		tuner.off();
		amp.off();
	}
}

public class MyFacade {
	public static void main(String[] args) {
		Amplifier amp = new Amplifier("Top-O-Line Amplifier");
		Tuner tuner = new Tuner("Top-O-Line AM/FM Tuner", amp);
		DvdPlayer dvd = new DvdPlayer("Top-O-Line DVD Player", amp);
		CdPlayer cd = new CdPlayer("Top-O-Line CD Player", amp);
		Projector projector = new Projector("Top-O-Line Projector", dvd);
		TheaterLights lights = new TheaterLights("Theater Ceiling Lights");
		Screen screen = new Screen("Theater Screen");
		PopcornPopper popper = new PopcornPopper("Popcorn Popper");

		HomeTheaterFacade homeTheater = new HomeTheaterFacade(amp, tuner, dvd, cd, projector, screen, lights, popper);

		homeTheater.watchMovie("Raiders of the Lost Ark");
		homeTheater.endMovie();
	}
}

Console Result

Get ready to watch a movie...
Popcorn Popper on
Popcorn Popper popping popcorn!
Theater Ceiling Lights dimming to 10%
Theater Screen going down
Top-O-Line Projector on
Top-O-Line Projector in widescreen mode (16x9 aspect ratio)
Top-O-Line Amplifier on
Top-O-Line Amplifier setting DVD player to Top-O-Line DVD Player
Top-O-Line Amplifier surround sound on (5 speakers, 1 subwoofer)
Top-O-Line Amplifier setting volume to 5
Top-O-Line DVD Player on
Top-O-Line DVD Player playing "Raiders of the Lost Ark"
Shutting movie theater down...
Popcorn Popper off
Theater Ceiling Lights on
Theater Screen going up
Top-O-Line Projector off
Top-O-Line Amplifier off
Top-O-Line DVD Player stopped "Raiders of the Lost Ark"
Top-O-Line DVD Player eject
Top-O-Line DVD Player off

Conclusion

N/A

[ENG][Algorithm]Insert Sort 이론과 예제

CamelAct — Sun, 19 Jun 2022 16:11:35 +0900

Overview

손안의 카드를 정렬하는 방법과 유사하다.
새로운 카드를 기존의 정렬된 카드 사이의 올바른 자리를 찾아 삽입한다.
새로 삽입될 카드의 수만큼 반복하게 되면 전체 카드가 정렬된다.
자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교 하여, 자신의 위치를 찾아 삽입함으로써 정렬을 완성하는 알고리즘
매 순서마다 해당 원소를 삽입할 수 있는 위치를 찾아 해당 위치에 넣는다.

장점
안정한 정렬 방법
레코드의 수가 적을 경우 알고리즘 자체가 매우 간단하므로 다른 복잡한 정렬 방법보다 유리할 수 있다.
대부분위 레코드가 이미 정렬되어 있는 경우에 매우 효율적일 수 있다.

단점
비교적 많은 레코드들의 이동을 포함한다.
레코드 수가 많고 레코드 크기가 클 경우에 적합하지 않다.

Usecase

- 오브젝트의 정렬이 필요할 때

- Best T(n) = O(n)
- Worst T(n) = O(n^2)

Structure

https://ko.wikipedia.org/wiki/%EC%82%BD%EC%9E%85_%EC%A0%95%EB%A0%AC

Code Example

package com.algorithm.basic;

public class MyInsertSort {
	void insertionSort(int[] input) {
		for (int i = 1; i < input.length; i++) {
			int temp = input[i]; 		// 7
			int j = i - 1; 				// 0

			while ((j >= 0) && (temp < input[j])) {		// j = 0 && 7 < 8
				input[j + 1] = input[j];
				j = j - 1;
			}
			input[j + 1] = temp;
		}
	}

	void printResult(int[] input) {
		int i;

		for (i = 0; i < input.length; ++i) {
			System.out.print(input[i] + " ");
		}
		System.out.println();
	}

	public static void main(String arg[]) throws Exception {
		MyInsertSort myInsertSort = new MyInsertSort();

		int[] input = { 8, 7, 9, 6, 0, 1, 2, 3, 5, 4 };

		myInsertSort.insertionSort(input);

		myInsertSort.printResult(input);
	}
}

Console Result

0 1 2 3 4 5 6 7 8 9

Conclusion

N/A

[ENG][디자인패턴]Command 패턴 이론과 설명

CamelAct — Sat, 18 Jun 2022 12:05:28 +0900

Overview

요청을 객체 형태로 캡슐화하여(실행할 함수를 캡슐화하여) 사용자가 요청한 메서드 이름, 매개변수 등의 정보를 나중에 저장, 로깅 또는 사용할 수 있도록 하는 패턴입니다. 요청에 필요한 정보를 취소합니다.
명령 패턴은 항상 명령, 수신자, 호출자 및 클라이언트의 네 가지 용어를 따릅니다.

장점
명령 패턴을 활용하여 요청 부분과 작업 부분을 분리함으로써 시스템의 결합 정도를 낮출 수 있으며, 각 객체가 수정되어도 다른 객체에는 영향을 미치지 않습니다.
클라이언트와 Invoker클래스 간의 종속성이 제거됩니다.

단점
수신자의 액션을 추가하면 액션에 대한 클래스를 생성해야 하므로 잡다한 클래스가 오히려 많이 추가되는 단점이 있습니다.

Structure

https://ko.wikipedia.org/wiki/%EC%BB%A4%EB%A7%A8%EB%93%9C_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

interface Command {
	public abstract void execute();
}

class Button {
	private Command theCommand;

	public Button(Command theCommand) {
		setCommand(theCommand);
	}

	public void setCommand(Command newCommand) {
		this.theCommand = newCommand;
	}

	public void pressed() {
		theCommand.execute();
	}
}

class Lamp {
	public void turnOn() {
		System.out.println("Lamp On");
	}
}

class LampOnCommand implements Command {
	private Lamp theLamp;

	public LampOnCommand(Lamp theLamp) {
		this.theLamp = theLamp;
	}

	public void execute() {
		theLamp.turnOn();
	}
}

class Alarm {
	public void start() {
		System.out.println("Alarming");
	}
}

class AlarmStartCommand implements Command {
	private Alarm theAlarm;

	public AlarmStartCommand(Alarm theAlarm) {
		this.theAlarm = theAlarm;
	}

	public void execute() {
		theAlarm.start();
	}
}

public class MyCommand {
	public static void main(String[] args) {
		Lamp lamp = new Lamp();
		Command lampOnCommand = new LampOnCommand(lamp);
		Alarm alarm = new Alarm();
		Command alarmStartCommand = new AlarmStartCommand(alarm);

		Button button1 = new Button(lampOnCommand); 
		button1.pressed();

		Button button2 = new Button(alarmStartCommand);
		button2.pressed(); 
		button2.setCommand(lampOnCommand);
		button2.pressed(); 
	}
}

Console Result

Lamp On
Alarming
Lamp On

Conclusion

N/A

[ENG][디자인패턴]Abstract Factory 패턴 이론과 설명

CamelAct — Fri, 17 Jun 2022 14:28:44 +0900

Overview

추상 팩토리 패턴은 실제 객체가 무엇인지 모른 채 객체를 생성하고 조작하는 데 도움이 될 수 있으므로 객체가 생성, 구성 또는 표현되는 방식에 관계없이 독립적으로 시스템을 생성하는 데 도움이 되기 때문에 사용됩니다.

장점
재사용성은 구체적인 클래스를 분리하여 개선할 수 있습니다.
List와 Iterator가 강하게 연결되어 있다는 점을 감안하면 제품의 일관성을 향상시킬 수 있습니다. (반복자는 List를 사용할 때 항상 사용할 수 있음)

불리
낮은 확장성. 예를 들어 List에서 다른 Iterator 인터페이스를 사용하려는 경우 상속받은 클래스인 ArrayList와 LinkedList를 모두 구현해야 합니다. 또는 ArrayList 에서 Iterator 인터페이스 이외의 인터페이스를 사용하는 것이 어려울 수 있습니다.

Structure

https://ko.wikipedia.org/wiki/%EC%B6%94%EC%83%81_%ED%8C%A9%ED%86%A0%EB%A6%AC_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern.core;

interface Dough {
	public String toString();
}

class ThickCrustDough implements Dough {
	public String toString() {
		return "ThickCrust style extra thick crust dough";
	}
}

class ThinCrustDough implements Dough {
	public String toString() {
		return "Thin Crust Dough";
	}
}

interface Pepperoni {
	public String toString();
}

class SlicedPepperoni implements Pepperoni {
	public String toString() {
		return "Sliced Pepperoni";
	}
}

interface PizzaIngredientFactory {
	public Dough createDough();
	public Pepperoni createPepperoni();
}

class NYPizzaIngredientFactory implements PizzaIngredientFactory {
	public Dough createDough() {
		return new ThinCrustDough();
	}

	public Pepperoni createPepperoni() {
		return new SlicedPepperoni();
	}
}

class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory {
	public Dough createDough() {
		return new ThickCrustDough();
	}

	public Pepperoni createPepperoni() {
		return new SlicedPepperoni();
	}
}

abstract class Pizza {
	String name;
	Dough dough;
	Pepperoni pepperoni;

	abstract void prepare();

	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}

	void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}

	void box() {
		System.out.println("Place pizza in official PizzaStore box");
	}

	void setName(String name) {
		this.name = name;
	}

	String getName() {
		return name;
	}

	public String toString() {
		StringBuffer result = new StringBuffer();
		result.append("---- " + name + " ----\n");
		if (dough != null) {
			result.append(dough);
			result.append("\n");
		}

		if (pepperoni != null) {
			result.append(pepperoni);
			result.append("\n");
		}
		return result.toString();
	}
}

class CheesePizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;

	public CheesePizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}

	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		pepperoni = ingredientFactory.createPepperoni();
	}
}

class PepperoniPizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;

	public PepperoniPizza(PizzaIngredientFactory ingredientFactory) {
		this.ingredientFactory = ingredientFactory;
	}

	void prepare() {
		System.out.println("Preparing " + name);
		dough = ingredientFactory.createDough();
		pepperoni = ingredientFactory.createPepperoni();
	}
}

abstract class PizzaStore {
	protected abstract Pizza createPizza(String item);

	public Pizza orderPizza(String type) {
		Pizza pizza = createPizza(type);
		System.out.println("--- Making a " + pizza.getName() + " ---");
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
}

class NYPizzaStore extends PizzaStore {
	protected Pizza createPizza(String item) {
		Pizza pizza = null;
		PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

		if (item.equals("cheese")) {
			pizza = new CheesePizza(ingredientFactory);
			pizza.setName("New York Style Cheese Pizza");
		} else if (item.equals("pepperoni")) {
			pizza = new PepperoniPizza(ingredientFactory);
			pizza.setName("New York Style Pepperoni Pizza");
		}
		return pizza;
	}
}

class ChicagoPizzaStore extends PizzaStore {
	protected Pizza createPizza(String item) {
		Pizza pizza = null;
		PizzaIngredientFactory ingredientFactory = new ChicagoPizzaIngredientFactory();

		if (item.equals("cheese")) {
			pizza = new CheesePizza(ingredientFactory);
			pizza.setName("Chicago Style Cheese Pizza");
		} else if (item.equals("pepperoni")) {

			pizza = new PepperoniPizza(ingredientFactory);
			pizza.setName("Chicago Style Pepperoni Pizza");

		}
		return pizza;
	}
}

public class MyAbstractFactory {
	public static void main(String[] args) {
		PizzaStore nyStore = new NYPizzaStore();
		PizzaStore chicagoStore = new ChicagoPizzaStore();

		Pizza pizza = nyStore.orderPizza("cheese");
		System.out.println("Ethan ordered a " + pizza + "\n");

		pizza = chicagoStore.orderPizza("cheese");
		System.out.println("Joel ordered a " + pizza + "\n");


		pizza = nyStore.orderPizza("pepperoni");
		System.out.println("Ethan ordered a " + pizza + "\n");

		pizza = chicagoStore.orderPizza("pepperoni");
		System.out.println("Joel ordered a " + pizza + "\n");
	}
}

Console Result

--- Making a New York Style Cheese Pizza ---
Preparing New York Style Cheese Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Cheese Pizza ----
Thin Crust Dough
Sliced Pepperoni


--- Making a Chicago Style Cheese Pizza ---
Preparing Chicago Style Cheese Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Joel ordered a ---- Chicago Style Cheese Pizza ----
ThickCrust style extra thick crust dough
Sliced Pepperoni


--- Making a New York Style Pepperoni Pizza ---
Preparing New York Style Pepperoni Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a ---- New York Style Pepperoni Pizza ----
Thin Crust Dough
Sliced Pepperoni


--- Making a Chicago Style Pepperoni Pizza ---
Preparing Chicago Style Pepperoni Pizza
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Joel ordered a ---- Chicago Style Pepperoni Pizza ----
ThickCrust style extra thick crust dough
Sliced Pepperoni

Conclusion

N/A

정규식 작성 및 확인

CamelAct — Tue, 14 Jun 2022 17:14:48 +0900

정규식 만들기

spring.aaa.bbb

등 application.properties에서 사용하는 키에 대한 포맷을 검사하는 정규식을 만들었습니다.

spring.으로 시작하며 특수문자는 허용하지 않아야합니다.

아래와 같이 만들 수 있었습니다.

^spring(\.[a-z0-9-]+)+$

하기 사이트에서 정규식을 만들고 테스트 해볼 수 있습니다.

https://regex101.com

regex101: build, test, and debug regex

Regular expression tester with syntax highlighting, explanation, cheat sheet for PHP/PCRE, Python, GO, JavaScript, Java, C#/.NET.

regex101.com

각 부분별 무엇을 의미하는지 설명이 잘 나옵니다.

[ENG][블로그에]프로그래스바 놓기

CamelAct — Mon, 13 Jun 2022 19:46:06 +0900

Overview

블로그에서 아래와 같은 상단 프로그래스바를 종종 보았을 것입니다.

이 프로그래스바를 어떻게 넣을 수 있는지 설명합니다.

Edit HTML

티스토리 블로그관리에서 스킨 편집 메뉴로 들어갑니다.

들어가면 오른쪽에 html 편집 버튼을 클릭합니다.

<body>와 </body> 사이에 하기 구문을 추가합니다.

<!-- progress-bar 영역 Start -->
<div class = "progress-container">
        <div class = "progress-bar" id = "indicator"></div>
</div>
<!-- progress-bar 영역 End -->

Edit CSS

html 편집 메뉴 안에서 상단의 CSS를 클릭합니다.

맨 아래에 하기 구문을 추가합니다.

/* 프로그래스바 컨테이너 디자인 */
.progress-container {
    position: fixed; /*상단 고정*/
    top: 0; /*페이지의 최상단에 붙어서 위치*/
    z-index: 1000; /*페이지의 다른 요소보다 가장 위에 나타나도록 설정*/
      width: 100%; 
      height: 8px; /* 높이 */
      background: #ccc; /* 기본 배경색 */
}
 
/* 프로그래스바 디자인 */
.progress-bar {
      height: 8px;  /* 높이 */
      background: #000000; /* 색상 */
      width: 0%;
}

[ENG][블로그에]스크롤에 따른 목차 하이라이트 만들기

CamelAct — Sun, 12 Jun 2022 21:32:19 +0900

Overview

목차 표시 설정을 이미 마쳤으며 글을 스크롤하면 해당 제목이 목차에 색이 반영되는 스크립트를 구현할 수 있다.

Create Script

하기와 같이 스크립트를 넣어준다. 기존에 이미 목차가 있다고 가정한다. 목차를 만드는 방법은

https://camelact.tistory.com/67

에서 확인할 수 있다.

<script>
$(document).ready(function() {
  $("#toc").toc({
 	  content: ".tt_article_useless_p_margin", 
	  headings: "h2,h3"
  });
});
	
	function checkPosition() {
    var findHeading = $('#content').find('h2,h3,h4');
		var scrollY = window.scrollY + 000;
		if(findHeading.length > 1) {
			for(var i = 0; i < findHeading.length; i++) {
				var findA = $('#toc').find('a');
				if(i < findHeading.length - 1) {
					if(findHeading.eq(i).offset().top < scrollY 
						 && findHeading.eq(i + 1).offset().top > scrollY) {
						findA.removeAttr('style');
						findA.eq(i).css('background-color', '#ccc');
						// findA.eq(i).css('border-left', '5px solid #666');
						break;
					}
				}
				else {
					if(findHeading.eq(i).offset().top < scrollY) {
						findA.removeAttr('style');
						findA.eq(i).css('background-color', '#ccc');
					//	findA.eq(i).css('border-left', '5px solid #666');
						break;
					}
				}
			}
		}
	}

	$(document).ready(function() {
		$(window).on('scroll', function() {
			checkPosition();
		});
	});
</script>

findA.eq(i).css... 부분에 기존에 사용하던 자신의 CSS 값을 넣으면 된다.

[ENG][블로그에]Google 검색 등록하기

CamelAct — Sat, 11 Jun 2022 19:15:59 +0900

구글 서치콘솔 등록

구글에서 서치콘솔이라고 검색을 한 후 들어갑니다.

속성검색 - 속성추가를 클릭합니다.

URL 접두어 란에 자신의 블로그 주소를 입력합니다.

소유권 확인

소유권 확인 페이지에서 HTML 태그를 선택하고 발생하는 <meta../> 구문을 복사합니다.

그 다음 자신의 블로그로 이동 후 블로그관리에서 스킨 편집 - html 편집으로 이동하여 head에 붙여넣기를 해 줍니다.

소유권이 확인됨 - 완료를 클릭하면 됩니다.

RSS 및 Sitemap 등록

Sitemap 메뉴에 들어가서 rss와 sitemap을 등록합니다.

자신의 블로그 주소/rss

자신의 블로그 주소/sitemap.xml을 입력 후 제출합니다.

[ENG][블로그에]Naver 검색 등록하기

CamelAct — Fri, 10 Jun 2022 19:15:40 +0900

네이버에 서치 어드바이저

네이버에서 서치 어드바이저를 검색하여 들어간 후 시작하기 탭에 들어갑니다. 미리 로그인을 완료합니다.

웹마스터 도구

안에 들어가서 자신의 블로그 주소를 등록합니다.

사이트 소유 확인

본인이 관리하고 있는 사이트가 맞는지 확인하는 작업이 있습니다.

HTML 태그를 선택하고 <meta .../> 부분을 전체 복사합니다.

복사된 구문을 자신의 티스토리 스킨 편집에 html 편집 부분에 넣어줍니다.

사이트 관리

위 절차가 마무리되면 다시 웹마스터 도구로 돌아와 사이트 관리 탭으로 이동합니다.

등록된 자신의 블로그 주소를 클릭합니다.

RSS 등록

위 이미지와 같이 요청 - RSS 제출에 자신의 블로그 주소/rss를 입력하고 등록합니다.

Sitemap 등록

위 이미지와 같이 요청 - 사이트맵 제출에 자신의 블로그 주소/sitemap.xml를 입력하고 등록합니다.

간단 체크

간단 체크 기능을 통해 정상 등록되었는지 확인할 수 있습니다.

[ENG][블로그에]번역기 붙이기

CamelAct — Thu, 9 Jun 2022 17:24:26 +0900

Overview

블로그 게시물 상단에 국기 모양의 아이콘을 넣어주고 클릭하면 번역된 글을 볼 수 있게 해 준다.

여러나라 방문자에게 유용할 수 있다.

Create Tag

하기 사이트에서 html Tag를 만들 수 있다.

https://gtranslate.io/

GTranslate - Website Translator: Translate Your Website

Here is the list: Afrikaans, Albanian, Amharic, Arabic, Armenian, Azerbaijani, Basque, Belarusian, Bengali, Bosnian, Bulgarian, Catalan, Cebuano, Chichewa, Chinese (Simplified), Chinese (Traditional), Corsican, Croatian, Czech, Danish, Dutch, English, Espe

gtranslate.io

GO GLOBAL을 클릭한다.

돈을 지불하지 않으려면 $0에서 DOWNLOAD를 클릭한다.

다른 유료 구독 서비스는 번역된 글로 검색까지 도와준다.

HTML 탭을 선택한 후 기호에 맞게 위젯을 설정한다.

이후 Widget code에 있는 스크립트를 복사하여 자신의 블로그의 원하는 위치에 붙여넣기 한다.

[ENG][디자인패턴]Composite 패턴 이론과 설명

CamelAct — Tue, 7 Jun 2022 18:05:18 +0900

Overview

복잡한 개체를 트리 구조로 구성하고 개별 개체인 것처럼 조작할 수 있는 구조적 디자인 패턴입니다.

장점
복잡한 트리 구조가 사용하기 더 편리합니다.
다형성 재귀를 유리하게 사용하십시오.
개방/폐쇄 원칙.
기존 코드를 중단하지 않고 애플리케이션에 새로운 요소 유형을 도입할 수 있습니다.
기존 코드는 이제 개체 트리에서 작동할 수 있습니다.
불리

기능이 상당히 다른 클래스에 공통 인터페이스를 제공하는 것은 어려울 수 있습니다.
특정 시나리오에서는 구성 요소 인터페이스를 과도하게 일반화하여 이해하기 어렵게 만들어야 합니다.

Structure

https://ko.wikipedia.org/wiki/%EC%BB%B4%ED%8F%AC%EC%A7%80%ED%8A%B8_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern.core;

import java.util.ArrayList;
import java.util.Iterator;

abstract class MenuComponent {
	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}

	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}

	public MenuComponent getChild(int index) {
		throw new UnsupportedOperationException();
	}

	public String getName() {
		throw new UnsupportedOperationException();
	}

	public String getDescription() {
		throw new UnsupportedOperationException();
	}

	public String show() {
		throw new UnsupportedOperationException();
	}
}

class MenuItem extends MenuComponent {
	private final String name;
	private final String description;

	public MenuItem(String name, String description) {
		this.name = name;
		this.description = description;
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getDescription() {
		return description;
	}

	@Override
	public String show() {
		return getName() + "," + getDescription();
	}
}

class Menu extends MenuComponent {
	private final ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
	private final String name;
	private final String description;

	public Menu(String name, String description) {
		this.name = name;
		this.description = description;
	}

	@Override
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}

	@Override
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}

	@Override
	public MenuComponent getChild(int index) {
		return (MenuComponent) menuComponents.get(index);
	}

	@Override
	public String getName() {
		return name;
	}

	@Override
	public String getDescription() {
		return description;
	}

	@Override
	public String show() {
		String menuDisplay = getMenuComponentInfo();
		Iterator iterator = menuComponents.iterator();
		while (iterator.hasNext()) {
			MenuComponent menuComponent = (MenuComponent) iterator.next();
			menuDisplay += "\n" + menuComponent.show();
		}
		return menuDisplay;
	}

	private String getMenuComponentInfo() {
		return getName() + " ~ " + getDescription();
	}
}

class Waitress {
	private final MenuComponent allMenus;

	public Waitress(MenuComponent allMenus) {
		this.allMenus = allMenus;
	}

	public String printMenu() {
		return allMenus.show();
	}
}

public class MyComposite {
	public static void main(String[] args) {
		MenuComponent pancakeHouseMenu = new Menu("PancakeHouseMenu", "description");
		MenuComponent dinnerMenu = new Menu("Diner Menu", "description");
		MenuComponent cafeMenu = new Menu("Cafe Menu", "description");

		MenuComponent allMenus = new Menu("All MENUS", "description");
		allMenus.add(pancakeHouseMenu);
		allMenus.add(dinnerMenu);
		allMenus.add(cafeMenu);

		MenuComponent dessertMenu = new Menu("Dessert Menu", "description");
		dinnerMenu.add(dessertMenu);

		pancakeHouseMenu.add(new MenuItem("K&B", "description"));
		pancakeHouseMenu.add(new MenuItem("Y&Z", "description"));

		Waitress waitress = new Waitress(allMenus);
		System.out.println(waitress.printMenu());
	}
}

Console Result

All MENUS ~ description
PancakeHouseMenu ~ description
K&B,description
Y&Z,description
Diner Menu ~ description
Dessert Menu ~ description
Cafe Menu ~ description

Conclusion

N/A

[ENG][디자인패턴]Adapter 패턴 이론과 설명

CamelAct — Mon, 6 Jun 2022 18:03:35 +0900

Overview

결국 하나의 인터페이스로 모든 것을 추상화하기 어렵기 때문에 어댑터 패턴을 사용합니다. 즉, 기존 라이브러리가 더 이상 실제 서비스와 호환되지 않아 다시 만들어야 하고 다른 부서에서도 이 라이브러리를 사용하고 있다고 가정해 보겠습니다. 따라서 이 라이브러리를 수정하면 다른 부서에 영향을 미칩니다. 이 경우 어댑터 패턴을 사용하여 기존 라이브러리를 건드리지 않고 새로운 기능을 추가할 수 있습니다.

특히 정책이 자주 변경되는 경우 지속적으로 라이브러리를 변경해야 합니까? 즉, 최대한 손대지 않고 구현할 수 있어야 합니다. 이 때문에 많은 사람이 개발해야 하는 오래된(?) 프레임워크나 프로그램에서 xxxAdapter라는 이름을 사용하여 기존 코드를 수정하지 않고 어댑터를 사용하는 예를 종종 볼 수 있습니다.

장점
어댑터 패턴의 주요 장점은 기존 코드를 변경할 필요가 없다는 것입니다.
기존 코드를 변경하지 않기 때문에 클래스 재사용성을 높일 수 있습니다.

불리
구성 요소의 클래스를 늘려야 하므로 복잡성이 증가할 수 있습니다.
Adapter 클래스의 경우 상속을 사용하기 때문에 유연하지 않다.
세미 네임드 객체 Adapter 의 경우 대부분의 코드를 다시 작성해야 하므로 효율적이지 않습니다.

Structure

https://velog.io/@kwj1270/Adapter-pattern

Code Example

package com.example.design.pattern.core;

interface Duck {
	void quack();
	void fly();
}

class MallardDuck implements Duck {

	@Override
	public void quack() {
		System.out.println("Quack quack...");
	}

	@Override
	public void fly() {
		System.out.println("Fly...");
	}
}

interface Turkey {
	void gobble();
	void fly();
}

class WildTurkey implements Turkey {

	@Override
	public void gobble() {
		System.out.println("Gobble gobble...");
	}

	@Override
	public void fly() {
		System.out.println("Short distance flight...");
	}
}

class TurkeyAdapter implements Duck {
	private final Turkey turkey;

	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}

	@Override
	public void quack() {
		turkey.gobble();
	}

	@Override
	public void fly() {
		for (int i = 0; i < 5; i++) {
			turkey.fly();
		}
	}
}

public class MyAdapter {
	public static void main(String[] args) {
		Duck duck = new MallardDuck();
		Turkey turkey = new WildTurkey();

		Duck turkeyAdapter = new TurkeyAdapter(turkey);
		System.out.println("----Turkey");
		turkey.gobble();
		turkey.fly();

		System.out.println("----Duck");
		testIt(duck);

		System.out.println("----Turkey Adapter");
		testIt(turkeyAdapter);
	}

	public static void testIt(Duck duck) {
		duck.quack();
		duck.fly();
	}
}

Console Result

----Turkey
Gobble gobble...
Short distance flight...
----Duck
Quack quack...
Fly...
----Turkey Adapter
Gobble gobble...
Short distance flight...
Short distance flight...
Short distance flight...
Short distance flight...
Short distance flight...

Conclusion

N/A

[ENG][디자인패턴]Template Method 패턴 이론과 설명

CamelAct — Sat, 4 Jun 2022 17:55:11 +0900

Overview

상속을 통해 슈퍼클래스의 기능을 확장하는 가장 대표적인 방법. 변하지 않는 기능은 슈퍼클래스에서 만들어지고 자주 변경되며, 확장할 기능은 서브클래스에서 만들어집니다.

추상 클래스인 AbstractClass는 실제로 실행을 위해 호출되는 public 메소드인 templateMethod로 정의되며, TemplateMethod에서 method1()과 method2()의 단계로 추상 메소드가 호출된다. 이러한 추상 메소드는 abstractClass를 상속받아 구현된 concreteClass에 정의되어 있습니다.

Structure

https://ko.wikipedia.org/wiki/%ED%85%9C%ED%94%8C%EB%A6%BF_%EB%A9%94%EC%86%8C%EB%93%9C_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

abstract class CaffeineBeverage {
	private String userInput;

	final void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		if (customerWantsCondiments()) {
			addCondiments();
		}
	}

	abstract void addCondiments();

	public void pourInCup() {
		System.out.println("Pouring into cup");
	}

	abstract void brew();

	public void boilWater() {
		System.out.println("Boiling water");
	}

	public boolean customerWantsCondiments() {
		String answer = getUserInput();
		if (answer.toLowerCase().startsWith("y"))
			return true;
		else
			return false;
	}

	private String getUserInput() {
		return userInput;
	}

	void setUserInput(String userInput) {
		this.userInput = userInput;
	}
}

class Coffee extends CaffeineBeverage {
	String userInput = "";

	@Override
	void addCondiments() {
		System.out.println("Adding Sugar and Milk");
	}

	@Override
	void brew() {
		System.out.println("Dripping Coffe through filter");
	}
}

class Tea extends CaffeineBeverage {
	String userInput = "";

	@Override
	void addCondiments() {
		System.out.println("Adding Lemon");
	}

	@Override
	void brew() {
		System.out.println("Steeping the tea");
	}
}

public class MyTemplateMethod {
	public static void main(String[] args) {
		CaffeineBeverage coffee = new Coffee();
		coffee.setUserInput("y");
		coffee.prepareRecipe();
		
		System.out.println("<< Next >>");
		
		CaffeineBeverage tea = new Tea();
		tea.setUserInput("n");
		tea.prepareRecipe();
	}
}

Console Result

Boiling water
Dripping Coffe through filter
Pouring into cup
Adding Sugar and Milk
<< Next >>
Boiling water
Steeping the tea
Pouring into cup

Conclusion

N/A

[ENG][디자인패턴]Strategy 패턴 이론과 설명

CamelAct — Fri, 3 Jun 2022 17:53:38 +0900

Overview

동작을 클래스로 캡슐화하여 동작을 동적으로 변경할 수 있는 패턴
동일한 문제를 해결하는 많은 알고리즘이 클래스로 캡슐화되어 필요할 때 이를 대체하므로 동일한 문제를 다른 알고리즘으로 해결할 수 있습니다.

즉, 전략을 쉽게 변경할 수 있는 디자인 패턴입니다.
목적을 달성하기 위해 일을 하는 방식, 비즈니스 규칙, 문제를 해결하기 위한 알고리즘 등

전략
   - 인터페이스나 추상 클래스를 통해 외부에서 같은 방식으로 알고리즘을 호출하는 방법을 지정합니다.

구체적인 전략
   - 전략 패턴에 명시된 알고리즘을 실제로 구현하는 클래스

문맥
   - 전략 패턴을 사용하는 역할을 합니다.
   - 필요에 따라 특정 전략을 변경할 수 있는 세터 방식('집약적 관계')을 제공합니다.

Structure

https://m.blog.naver.com/2feelus/220658663151

Code Example

package com.example.design.pattern;

abstract class Duck {
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;

	Duck() {
	}

	public abstract void display();

	public void perfomrFly() {
		flyBehavior.fly();
	}

	public void performQuack() {
		quackBehavior.quack();
	}

	public void swim() {
		System.out.println("All duck float, even decoys!");
	}

	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}

	public void setQuackBehavior(QuackBehavior quackBehavior) {
		this.quackBehavior = quackBehavior;
	}
}

interface FlyBehavior {
	public void fly();
}

class FlyWithWings implements FlyBehavior {
	@Override
	public void fly() {
		System.out.println("I'm Flying!!");
	}
}

class FlyNoWay implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("I can't fly");
	}
}

interface QuackBehavior {
	public void quack();
}

class Quack implements QuackBehavior {
	@Override
	public void quack() {
		System.out.println("Quack!!");
	}
}

class MuteQuack implements QuackBehavior {
	@Override
	public void quack() {
		System.out.println("<< Silence >>");

	}
}

class MallardDuck extends Duck {
	public MallardDuck() {
		flyBehavior = new FlyWithWings();
		quackBehavior = new Quack();
	}

	@Override
	public void display() {
		System.out.println("I'm a real Mallard Duck");

	}
}

public class MyStrategy {
	public static void main(String[] args) {
		Duck mallard = new MallardDuck();
		mallard.performQuack();
		mallard.perfomrFly();

		mallard.setFlyBehavior(new FlyNoWay());
		mallard.setQuackBehavior(new MuteQuack());
		
		mallard.performQuack();
		mallard.perfomrFly();
	}
}

Console Result

Quack!!
I'm Flying!!
<< Silence >>
I can't fly

Conclusion

N/A

[ENG][디자인패턴]State 패턴 이론과 설명

CamelAct — Thu, 2 Jun 2022 17:52:13 +0900

Overview

상태 디자인 패턴은 객체 내부의 상태에 따라 동작을 변경하기 위해 사용하는 디자인 패턴입니다.

장점
- 하나의 객체에 대해 여러 액션을 구현해야 하는 경우 상태 객체만 수정되므로 작업을 추가, 삭제 및 수정합니다.
- 상태 패턴을 사용하면 객체의 상태에 따라 조건문을 줄여 코드를 간결하고 가독성 있게 만듭니다.

불리
- 조건문을 대체하는 조건의 조건을 조건에 따라 증가시키면 관리할 클래스의 수가 증가합니다.

Structure

https://ko.wikipedia.org/wiki/%EC%83%81%ED%83%9C_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

interface State {
	public void insertQuarter();

	public void ejectQuarter();

	public void turnCrank();

	public void dispense();
}

class NoQuarterState implements State {

	GumballMachine gumballMachine;

	public NoQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	public void insertQuarter() {
		System.out.println("insertQuarter");
		gumballMachine.setState(gumballMachine.getHasQuarterState());
	}

	public void ejectQuarter() {
		System.out.println("ejectQuarter");
	}

	public void turnCrank() {
		System.out.println("turnCrank");
	}

	public void dispense() {
		System.out.println("dispense");
	}

	public String toString() {
		return "NoQuarterState";
	}
}

class SoldOutState implements State {
	private GumballMachine gumballMachine;

	public SoldOutState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	public void insertQuarter() {
		System.out.println("insertQuarter");
	}

	public void ejectQuarter() {
		System.out.println("ejectQuarter");
	}

	public void turnCrank() {
		System.out.println("turnCrank");
	}

	public void dispense() {
		System.out.println("dispense");
	}

	public String toString() {
		return "toString";
	}
}

class HasQuarterState implements State {

	private GumballMachine gumballMachine;

	public HasQuarterState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	public void insertQuarter() {
		System.out.println("insertQuarter");
	}

	public void ejectQuarter() {
		System.out.println("ejectQuarter");
		gumballMachine.setState(gumballMachine.getNoQuarterState());
	}

	public void turnCrank() {
		System.out.println("turnCrank");
		gumballMachine.setState(gumballMachine.getSoldState());
	}

	public void dispense() {
		System.out.println("dispense");
	}

	public String toString() {
		return "HasQuarterState";
	}
}

class SoldState implements State {
	private GumballMachine gumballMachine;

	public SoldState(GumballMachine gumballMachine) {
		this.gumballMachine = gumballMachine;
	}

	public void insertQuarter() {
		System.out.println("insertQuarter");
	}

	public void ejectQuarter() {
		System.out.println("ejectQuarter");
	}

	public void turnCrank() {
		System.out.println("turnCrank");
	}

	public void dispense() {
		gumballMachine.releaseBall();
		if (gumballMachine.getCount() > 0) {
			gumballMachine.setState(gumballMachine.getNoQuarterState());
		} else {
			System.out.println("Oops!! out of gumballs!!");
			gumballMachine.setState(gumballMachine.getSoldOutState());
		}
	}

	public String toString() {
		return "GumballMachine";
	}
}

class GumballMachine {
	State soldOutState;
	State noQuarterState;
	State hasQuarterState;
	State soldState;

	public State getSoldOutState() {
		return soldOutState;
	}

	public State getNoQuarterState() {
		return noQuarterState;
	}

	public State getHasQuarterState() {
		return hasQuarterState;
	}

	public State getSoldState() {
		return soldState;
	}

	State currentState = soldOutState;
	int count = 0;

	public int getCount() {
		return count;
	}

	public GumballMachine(int numberGumaballs) {
		soldOutState = new SoldOutState(this);
		noQuarterState = new NoQuarterState(this);
		hasQuarterState = new HasQuarterState(this);
		soldState = new SoldState(this);

		this.count = numberGumaballs;
		if (numberGumaballs > 0) {
			currentState = noQuarterState;
		}
	}

	public void insertQuarter() {
		currentState.insertQuarter();
	}

	public void ejectQuarter() {
		currentState.ejectQuarter();
	}

	public void turnCrank() {
		currentState.turnCrank();
	}

	public void dispense() {
		currentState.dispense();
	}

	void setState(State state) {
		this.currentState = state;
	}

	void releaseBall() {
		System.out.println("releaseBall");
		if (count != 0) {
			count = count - 1;
		}
	}

	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("\nMighty Gumball, Inc.");
		sb.append("\nJava-enabled Standing Gumball Model #2004");
		sb.append("\nInventory: " + count + " gumball");
		if (count != 1) {
			sb.append("s");
		}

		sb.append("\nMachine is " + currentState + "\n");
		return sb.toString();
	}
}

public class MyState {
	public static void main(String[] args) {
		GumballMachine gumballMachine = new GumballMachine(5);
		System.out.println(gumballMachine);

		gumballMachine.insertQuarter();
		gumballMachine.turnCrank();

		System.out.println(gumballMachine);

		gumballMachine.insertQuarter();
		gumballMachine.ejectQuarter();
		gumballMachine.turnCrank();
		gumballMachine.dispense();

		System.out.println(gumballMachine);
	}
}

Console Result

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 5 gumballs
Machine is NoQuarterState

insertQuarter
turnCrank

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 5 gumballs
Machine is GumballMachine

insertQuarter
ejectQuarter
turnCrank
releaseBall

Mighty Gumball, Inc.
Java-enabled Standing Gumball Model #2004
Inventory: 4 gumballs
Machine is NoQuarterState

Conclusion

N/A

[ENG][디자인패턴]Singleton 패턴 이론과 설명

CamelAct — Wed, 1 Jun 2022 17:40:22 +0900

Overview

전역 변수를 사용하지 않고 하나의 객체만 생성하고 생성된 객체를 어디서나 참조하는 패턴
하나의 인스턴스만 생성하는 역할을 하며 Getinstance 메서드는 모든 클라이언트에 동일한 인스턴스를 반환하는 것입니다.

다중 스레드에서 사용되는 유틸리티 클래스의 경우 모든 스레드에서 객체를 생성하지 않고 이미 만들어진 객체를 가져와서 사용하는 것이 메모리와 CPU에서 더 좋습니다.
Calendar.getInstance()에 대한 Java의 캘린더 클래스 개체를 사용하여 사용합니다.
시간대를 표현하기 위해 새로운 객체를 생성할 필요가 없기 때문입니다.

단, Calendar 클래스를 사용하기 위해서는 Client 프로그램에서 new Calendar()를 호출하지 않도록 주의한다.
이를 해결하는 방법은 생성자가 외부에서 호출되는 것을 방지하는 것입니다.
Calendar 클래스의 생성자를 private로 선언합니다.

문제는 여러 스레드에서 Printer 클래스를 사용할 때 하나 이상의 인스턴스가 생성된다는 것입니다.

경우에 따라 경쟁 조건이 생성됩니다.
메모리와 같은 동일한 자원을 사용하기 위해 2개 이상의 쓰레드를 사용하는 현상

Printer 인스턴스가 아직 생성되지 않은 경우 Sweep 1은 getPrinter 메서드의 if 문을 실행하여 인스턴스가 이미 생성되었는지 확인합니다. 현재 프린터 변수는 NULL입니다.

스레드 1이 생성자를 호출하면 스레드 2는 인스턴스를 만들기 전에 if 문을 실행하여 Printer 변수가 NULL인지 확인합니다. 현재 프라이머 변수는 NULL이므로 인스턴스를 생성하는 생성자를 호출하는 코드를 실행합니다.

스레드 1은 스레드 2와 마찬가지로 인스턴스를 생성하는 코드를 실행하고 결과적으로 프린터 클래스의 두 인스턴스가 생성됩니다.

Structure

https://ko.wikipedia.org/wiki/%EC%8B%B1%EA%B8%80%ED%84%B4_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

public class MySingleton {
	private volatile static MySingleton instance = new MySingleton();

	private MySingleton() {
	}

	public static MySingleton getInstance() {
		if (instance == null) {
					instance = new MySingleton();
		}
		
		return instance;
	}
}
// I didn't call at the start of the program, but there are issues allocated to memory.

package com.example.design.pattern;

public class MySingleton {
	private volatile static MySingleton instance = null;

	private MySingleton() {
	}

	public synchronized static MySingleton getInstance() {
		if (instance == null) {
					instance = new MySingleton();
		}
		
		return instance;
	}
}
// Synchronized on the method can be locked and slowly slow in multiple thread environments.

package com.example.design.pattern;

public class MySingleton {
	private volatile static MySingleton instance = null;

	private MySingleton() {
	}

	public static MySingleton getInstance() {
		if (instance == null) {
			synchronized (MySingleton.class) {
				if (instance == null) {
					instance = new MySingleton();
				}
			}
		}
		
		return instance;
	}
}
// NULL checks twice to solve the performance deterioration issues caused by LOCK.

Console Result

1234
1234

Conclusion

N/A

[ENG][디자인패턴]Observer 패턴 이론과 설명

CamelAct — Tue, 31 May 2022 16:40:04 +0900

Overview

Observer Pattern은 Observer의 목록, 즉 Observer의 목록을 객체에 등록하여 상태 변경이 있을 때마다 객체가 메소드 등을 통해 객체에게 직접 알리도록 하는 디자인 패턴입니다. . 주로 분산 이벤트 처리 시스템을 구현하는 데 사용됩니다. 발행/구독 모델이라고도 합니다.

아주 간단한 방법으로, 객체의 상태가 변경될 때 관련 객체에 알림을 보내는 디자인 패턴은 관찰자 패턴입니다.

예를 들어 기상 조건에 따라 작동해야 하는 여러 기계가 있다고 가정합니다.
기상청에서 기상자료를 구독 중이고 날씨가 업데이트되면 이를 반영하여 표시를 변경합니다.
피험자는 날씨 데이터에 입력되어 여행하고 날씨 정보를 전달합니다.

장점
변경 사항이 있어도 처리할 수 있는 유연한 객체 지향 시스템을 구축할 수 있습니다.
객체 간의 상호 의존성을 최소화할 수 있기 때문입니다. 느슨하게 결합되어 있기 때문입니다.
개방/폐쇄 원칙(개방 폐쇄 원칙)을 지킬 수 있습니다. (Open Closed Principles: Open in Expansion, 그리고 변경 사항은 반드시 닫아야 합니다.)

불리
Observer의 알림 순서를 보장할 수 없습니다.
Observer와 Subject의 관계가 잘 정의되어 있지 않으면 원하지 않는 동작이 발생할 수 있습니다.

Structure

https://ko.wikipedia.org/wiki/%EC%98%B5%EC%84%9C%EB%B2%84_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

import java.util.ArrayList;

interface Subject {
	public void registerObserver(Observer o);

	public void removeObserver(Observer o);

	public void notifyObservers();
}

interface Observer {
	public void update(float temperature, float humidity, float pressure);
}

interface DisplayElement {
	public void display();
}

class WeatherData implements Subject {
	private ArrayList<Observer> observers;
	private float temperature;
	private float humidity;
	private float pressure;

	public WeatherData() {
		observers = new ArrayList<Observer>();
	}

	@Override
	public void registerObserver(Observer o) {
		observers.add(o);

	}

	@Override
	public void removeObserver(Observer o) {
		int i = observers.indexOf(o);
		if (i >= 0)
			observers.remove(i);
	}

	@Override
	public void notifyObservers() {
		for (int i = 0; i < observers.size(); i++) {
			Observer o = observers.get(i);
			o.update(temperature, humidity, pressure);
		}
	}

	public void measurementsChanged() {
		notifyObservers();
	}

	public void setMeasurements(float temperature, float humidity, float pressure) {
		this.temperature = temperature;
		this.humidity = humidity;
		this.pressure = pressure;
		measurementsChanged();
	}
}

class CurrentConditionDisplay implements Observer, DisplayElement {
	private float temperature;
	private float humidity;
	private Subject weatherData;

	public CurrentConditionDisplay(Subject weatherData) {
		this.weatherData = weatherData;
		weatherData.registerObserver(this);
	}

	@Override
	public void display() {
		System.out.println("CurrentConditionDisplay conditions : " + temperature + ", " + humidity);

	}

	@Override
	public void update(float temperature, float humidity, float pressure) {
		this.temperature = temperature;
		this.humidity = humidity;
		display();
	}
}

class StatisticsDisplay implements Observer, DisplayElement {
	private float temperature;
	private float humidity;
	private Subject weatherData;

	public StatisticsDisplay(Subject weatherData) {
		this.weatherData = weatherData;
		weatherData.registerObserver(this);
	}

	@Override
	public void display() {
		System.out.println("StatisticsDisplay conditions : " + temperature + ", " + humidity);

	}

	@Override
	public void update(float temperature, float humidity, float pressure) {
		this.temperature = temperature;
		this.humidity = humidity;
		display();
	}
}

public class MyObserver {
	public static void main(String[] args) {
		WeatherData weatherData = new WeatherData();

		CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherData);
		StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);

		weatherData.setMeasurements(80, 65, 30.f);
	}
}

Console Result

CurrentConditionDisplay conditions : 80.0, 65.0
StatisticsDisplay conditions : 80.0, 65.0

Conclusion

N/A

[ENG][디자인패턴]MVC 패턴 이론과 설명

CamelAct — Mon, 30 May 2022 11:53:59 +0900

Overview

MVC는 Model, View, Controller의 약자입니다. 하나의 애플리케이션과 프로젝트를 구성할 때 해당 구성요소를 세 가지 역할로 구분하는 패턴입니다.

위와 같이 사용자가 컨트롤러를 조작할 때 컨트롤러는 Model을 통해 데이터를 가져와 해당 정보를 기반으로 시각적 표현을 담당하는 View를 제어합니다. 하나의 논리를 설명하기 위해 만든 그림이며, MVC 패턴의 구조는 다음과 같습니다.

모델
  - 수정하려는 모든 데이터가 있어야 합니다.
  - 뷰나 컨트롤러에 대한 정보가 없어야 합니다.
  - 변경 사항이 발생하면 변경 통지 처리 방법을 구현해야 합니다.

보다
  - 모델 정보를 따로 저장하지 마세요.
  - 모델이나 컨트롤러 등 다른 구성요소를 알면 안 됩니다.
  - 변경사항이 발생한 경우 변경통지 처리 방법을 구현해야 합니다.

제어 장치
  - 모델이나 뷰에 대해 알고 있어야 합니다.
  - 모델 또는 뷰의 변경 사항을 모니터링해야 합니다.

서로 분리되어 각자의 역할에 집중하고 애플리케이션을 생성하면 유지보수의 문제, 애플리케이션의 확장성, 유연성이 증가하고 중복 코딩의 문제도 사라질 것입니다. 이것이 MVC 패턴입니다.

장점
  - 유연하고 확장이 용이함 - 설계자와 개발자 간의 손쉬운 협업 - 유지보수 비용을 절감합니다.

불리
  - 기본 기능에 대한 클래스가 많기 때문에 복잡할 수 있습니다.
  - Model과 View의 완벽한 분리가 어렵다.

Structure

https://ko.wikipedia.org/wiki/%EB%AA%A8%EB%8D%B8-%EB%B7%B0-%EC%BB%A8%ED%8A%B8%EB%A1%A4%EB%9F%AC

Code Example

package com.example.design.pattern;

class StudentModel {
	private String rollNo;
	private String name;

	public String getRollNo() {
		return rollNo;
	}

	public void setRollNo(String rollNo) {
		this.rollNo = rollNo;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

class StudentView {
	public void printStudentDetails(String studentName, String studentRollNo) {
		System.out.println("Student: ");
		System.out.println("Name: " + studentName);
		System.out.println("Roll No: " + studentRollNo);
	}
}

class StudentController {
	private StudentModel model;
	private StudentView view;

	public StudentController(StudentModel model, StudentView view) {
		this.model = model;
		this.view = view;
	}

	public void setStudentName(String name) {
		model.setName(name);
	}

	public String getStudentName() {
		return model.getName();
	}

	public void setStudentRollNo(String rollNo) {
		model.setRollNo(rollNo);
	}

	public String getStudentRollNo() {
		return model.getRollNo();
	}

	public void updateView() {
		view.printStudentDetails(model.getName(), model.getRollNo());
	}
}

public class MyMVC {
	public static void main(String[] args) {
		StudentModel model = retriveStudentFromDatabase();

		StudentView view = new StudentView();

		StudentController controller = new StudentController(model, view);

		controller.updateView();
		controller.setStudentName("John");
		controller.updateView();
	}

	private static StudentModel retriveStudentFromDatabase() {
		StudentModel student = new StudentModel();
		student.setName("Robert");
		student.setRollNo("10");
		return student;
	}
}

Console Result

Student: 
Name: Robert
Roll No: 10
Student: 
Name: John
Roll No: 10

Conclusion

N/A

[ENG][디자인패턴]Mediator 패턴 이론과 설명

CamelAct — Fri, 27 May 2022 18:23:59 +0900

Overview

GOF의 정의에 따르면 mediator 패턴은 완전히 다른 객체 간의 통신이 매우 복잡한 경우 mediator를 통해 객체 간의 통신을 캡슐화하는 방법입니다.
다소 복잡하게 들릴 수 있지만 간단히 말해서 두 객체는 직접 연결되어 있는 것이 아니라 세 번째 객체를 통해 느슨하게 연결되어 있습니다.

예를 들어 워드 프로세스 프로그램을 선택할 수 있습니다. 텍스트에 영향을 주는 여러 패널이 있습니다.
서식 패널은 텍스트의 텍스트를 수정하고 그림 패널은 텍스트에 그림을 삽입합니다.
두 패널은 다르지만 하나의 문서에 영향을 줄 수 있습니다.
이 경우 패턴은 한 패널에서 이벤트가 발생하면 문서를 변경하고 다른 패널을 돕는 패턴입니다.

장점:
효율적인 리소스 관리(리소스 풀 등)가 가능합니다.
객체 간의 통신을 위해 서로 직접 참조할 필요가 없습니다.
중재자 구현 클래스는 나중에 더 효율적인 클래스로 변경할 수 있습니다.

불리:
객체 간의 통신 로직이 복잡해지거나 객체의 형태가 자주 바뀌면 유지 및 관리가 어렵습니다.

Structure

https://always-intern.tistory.com/5

Code Example

package com.example.design.pattern;

import java.util.ArrayList;
import java.util.List;

interface IDestination {
	public void receiveEvent(String from, String event);
}

class Display implements IDestination {
	@Override
	public void receiveEvent(String from, String event) {
		System.out.println("Display : from " + from + " event : " + event);
	}
}

class Log implements IDestination {
	@Override
	public void receiveEvent(String from, String event) {
		System.out.println("Log : from " + from + " event : " + event);
	}
}

/////////////////////////////////////////////////////////////////////////
interface ISource {
	public void setMediator(Mediator mediator);

	public void eventOccured(String event);
}

class TcpComm implements ISource {
	Mediator mediator;

	@Override
	public void setMediator(Mediator mediator) {
		this.mediator = mediator;
	}

	@Override
	public void eventOccured(String event) {
		System.out.println("TcpComm event Occured");
		mediator.onEvent("TCP comm", event);
	}
}

class SystemSignal implements ISource {
	Mediator mediator;

	@Override
	public void setMediator(Mediator mediator) {
		this.mediator = mediator;
	}

	@Override
	public void eventOccured(String event) {
		System.out.println("SystemSignal event Occured");
		mediator.onEvent("System", event);
	}
}

class Mediator {
	List<IDestination> list = new ArrayList<IDestination>();

	public void addDestination(IDestination destination) {
		list.add(destination);
	}

	public void onEvent(String from, String event) {
		for (IDestination each : list) {
			each.receiveEvent(from, event);
		}
	}
}

public class MyMediator {
	public static void main(String[] args) {
		Mediator mediator = new Mediator();
		
		ISource tcp = new TcpComm();
		tcp.setMediator(mediator);
		
		ISource system = new SystemSignal();
		system.setMediator(mediator);
		
		mediator.addDestination(new Display());
		mediator.addDestination(new Log());
		
		tcp.eventOccured("connected");
		tcp.eventOccured("disconnected");
		
		system.eventOccured("key input");
		system.eventOccured("mouse input");

	}
}

Console Result

TcpComm event Occured
Display : from TCP comm event : connected
Log : from TCP comm event : connected
TcpComm event Occured
Display : from TCP comm event : disconnected
Log : from TCP comm event : disconnected
SystemSignal event Occured
Display : from System event : key input
Log : from System event : key input
SystemSignal event Occured
Display : from System event : mouse input
Log : from System event : mouse input

Conclusion

N/A

[ENG][디자인패턴]Iterator 패턴 이론과 설명

CamelAct — Thu, 26 May 2022 17:35:05 +0900

Overview

행동 패턴, 컬렉션 메서드를 노출하지 않고 해당 집합의 모든 항목에 액세스할 수 있는 방법을 제공하는 패턴
Iterator Pattern의 사용은 그 안의 아이템에서 할 수 있지만, 반복할 수 있습니다.

반복자
집계의 요소를 순서대로 검색하는 인터페이스 정의

A가 List 형식이고 B가 Array라고 가정합니다.
이때 Iterator 패턴을 사용하면 하나의 인터페이스를 사용하여 두 집합을 검색할 수 있습니다.

각 집합을 구성하는 클래스는 반복자가 있는 인터페이스를 상속합니다.
hasNext()는 다음 항목이 있는지 확인하는 메서드입니다.
next()를 통해 현재 항목을 얻을 수 있습니다.

Structure

https://ko.wikipedia.org/wiki/%EB%B0%98%EB%B3%B5%EC%9E%90_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

import java.util.ArrayList;

interface Iterator {
	boolean hasNext();
	Object next();
	void remove();
}

class MenuItem {
	String name;
	String description;
	boolean vegetarian;
	double price;

	public MenuItem(String name, String description, boolean vegetarian, double price) {
		super();
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}

	public String getName() {
		return this.name;
	}
}

class DinnerMenuIterator implements Iterator {
	MenuItem[] menuItems;
	int position = 0;

	public DinnerMenuIterator(MenuItem[] menuItems) {
		this.menuItems = menuItems;
	}

	@Override
	public boolean hasNext() {
		if (position >= menuItems.length || menuItems[position] == null)
			return false;
		else
			return true;
	}

	@Override
	public Object next() {
		MenuItem menuItem = menuItems[position];
		position++;
		return menuItem;
	}

	@Override
	public void remove() {
		if (position <= 0) {
			throw new IllegalStateException("You can't remove blah blah");
		}
		menuItems[position] = null;
	}
}

interface Menu {
	public Iterator createIterator();
}

class DinnerMenu implements Menu {
	MenuItem[] menuItems = new MenuItem[100];

	public MenuItem[] getMenuItmes() {
		return menuItems;
	}

	@Override
	public Iterator createIterator() {
		return new DinnerMenuIterator(menuItems);
	}

	public void addItem(MenuItem menuItem) {
		for (int i = 0; i < menuItems.length; i++) {
			if (menuItems[i] == null) {
				menuItems[i] = menuItem;
				break;
			}
		}

	}
}

class PancakeHouseMenuIterator implements Iterator {
	ArrayList<MenuItem> menuItems;
	int position = 0;

	public PancakeHouseMenuIterator(ArrayList<MenuItem> menuItems) {
		this.menuItems = menuItems;
	}

	@Override
	public boolean hasNext() {
		if (position >= menuItems.size())
			return false;
		else
			return true;
	}

	@Override
	public Object next() {
		MenuItem menuItem = menuItems.get(position);
		position++;
		return menuItem;
	}

	@Override
	public void remove() {
		if (position <= 0) {
			throw new IllegalStateException("You can't remove blah blah");
		}
		menuItems.remove(position);
	}
}

class PancakeHouseMenu implements Menu {
	ArrayList<MenuItem> menuItems = new ArrayList<>();

	public ArrayList<MenuItem> getMenuItmes() {
		return menuItems;
	}

	@Override
	public Iterator createIterator() {
		return new PancakeHouseMenuIterator(menuItems);
	}

	public void addItem(MenuItem menuItem) {
		menuItems.add(menuItem);
	}
}

class Waitress {
	Menu pancakeHouseMenu;
	Menu dinnerMenu;

	public Waitress(Menu pancakeHouseMenu, Menu dinnerMenu) {
		this.pancakeHouseMenu = pancakeHouseMenu;
		this.dinnerMenu = dinnerMenu;
	}

	public void printMenu() {
		Iterator pancakeHouseMenuIterator = pancakeHouseMenu.createIterator();
		Iterator dinnerMenuIterator = dinnerMenu.createIterator();

		printMenu(pancakeHouseMenuIterator);
		printMenu(dinnerMenuIterator);
	}

	private void printMenu(Iterator iterator) {
		while (iterator.hasNext()) {
			MenuItem menuItem = (MenuItem) iterator.next();
			System.out.println(menuItem.getName());
		}
	}
}

public class MyIterator {
	public static void main(String[] args) {
		PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
		pancakeHouseMenu.addItem(new MenuItem("pancake1", "pancake", true, 1));
		pancakeHouseMenu.addItem(new MenuItem("pancake2", "pancake", true, 1));

		DinnerMenu dinnerMenu = new DinnerMenu();
		dinnerMenu.addItem(new MenuItem("dinner1", "dinner", false, 2));
		dinnerMenu.addItem(new MenuItem("dinner2", "dinner", false, 2));
		
		Waitress waitress = new Waitress(pancakeHouseMenu, dinnerMenu);
		waitress.printMenu();
	}

}

Console Result

pancake1
pancake2
dinner1
dinner2

Conclusion

N/A

[ENG][디자인패턴]Factory Method 패턴 이론과 설명

CamelAct — Thu, 26 May 2022 16:43:01 +0900

Overview

Factory Method 패턴은 가장 널리 알려진 디자인 패턴 중 하나입니다.
객체를 반복적으로 생성해야 하며, 약간의 차이가 필요한 경우 Factory Method 패턴을 사용합니다.

Factory Method 패턴은 창의적인 패턴 중 하나입니다.
1. 생성 패턴은 인스턴스 생성 절차를 추상화한 패턴이다.
2. 생성 패턴에 속하는 패턴은 객체를 생성하고 합성하는 방법이나 객체의 표현을 시스템과 분리한다. 상속보다 복잡한 방법을 사용하는 방향으로 시스템이 발전함에 따라 생성 패턴이 더욱 중요해지고 있습니다.

생성 패턴에는 두 가지 중요한 문제가 있습니다.

Factory Method 패턴이란?
Factory Method 패턴은 객체를 생성하기 위한 인터페이스를 미리 정의하지만 인스턴스 생성에 대한 클래스의 결정은 서브클래스 측에서 결정하는 패턴입니다. 여러 하위 클래스가 있는 슈퍼 클래스가 있는 경우 들어오는 인수에 따라 하나의 자식 클래스 인스턴스를 반환합니다.
Factory Method 패턴은 클래스의 인스턴스를 서브클래스로 생성하는 시간을 지연시킵니다.

사용성
클래스가 생성해야 하는 객체의 클래스를 예측할 수 없는 경우
당신의 서브클래스가 생성될 객체를 기술하는 책임을 지정하기를 원할 때

Factory Method 패턴의 장점
Factory Method 패턴은 클라이언트 코드에서 서브클래스의 인스턴스를 제거하여 서로의 종속성을 낮추고 본드를 느슨하게 하며 확장을 쉽게 만듭니다.

Factory Method 패턴은 클라이언트와 구현 객체 간의 추상화를 제공합니다.

Factory Method 패턴의 단점
생성할 새 개체가 증가할 때마다 Factory 클래스에 추가해야 하기 때문에 더 많은 클래스가 있습니다.

Structure

https://ko.wikipedia.org/wiki/%ED%8C%A9%ED%86%A0%EB%A6%AC_%EB%A9%94%EC%84%9C%EB%93%9C_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

import java.util.ArrayList;

abstract class Pizza {
	String name;
	String dough;
	String sauce;
	ArrayList<String> toppings = new ArrayList<String>();

	void prepare() {
		System.out.println("Preparing " + name);
		System.out.println("Tossing dough...");
		System.out.println("Adding sauce...");
		System.out.println("Adding toppings: ");
		for (int i = 0; i < toppings.size(); i++) {
			System.out.println("   " + toppings.get(i));
		}
	}

	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}

	void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}

	void box() {
		System.out.println("Place pizza in official PizzaStore box");
	}

	public String getName() {
		return name;
	}

	public String toString() {
		StringBuffer display = new StringBuffer();
		display.append("---- " + name + " ----\n");
		display.append(dough + "\n");
		display.append(sauce + "\n");
		for (int i = 0; i < toppings.size(); i++) {
			display.append((String) toppings.get(i) + "\n");
		}
		return display.toString();
	}
}

class NYStyleCheesePizza extends Pizza {
	public NYStyleCheesePizza() {
		name = "NYStyleCheesePizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		toppings.add("Grated Reggiano Cheese");
	}
}

class NYStylePepperoniPizza extends Pizza {
	public NYStylePepperoniPizza() {
		name = "NYStylePepperoniPizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		toppings.add("Grated Reggiano Cheese");
	}
}

class ChicagoStyleCheesePizza extends Pizza {
	public ChicagoStyleCheesePizza() {
		name = "ChicagoStyleCheesePizza";
		dough = "Extra Thick Crust Dough";
		sauce = "Plum Tomato Sauce";
		toppings.add("Shredded Mozzarella Cheese");
	}

	void cut() {
		System.out.println("Cutting the pizza into square slices");
	}
}

class ChicagoStylePepperoniPizza extends Pizza {
	public ChicagoStylePepperoniPizza() {
		name = "ChicagoStylePepperoniPizza";
		dough = "Extra Thick Crust Dough";
		sauce = "Plum Tomato Sauce";
		toppings.add("Shredded Mozzarella Cheese");
	}

	void cut() {
		System.out.println("Cutting the pizza into square slices");
	}
}

abstract class PizzaStore {
	public Pizza orderPizza(String type) {
		Pizza pizza;

		pizza = createPizza(type); // back to a method call

		pizza.prepare(); // complete methods
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}

	abstract Pizza createPizza(String type);
}

class NYStylePizzaStore extends PizzaStore {
	public Pizza createPizza(String type) {
		Pizza pizza = null;

		if (type.equals("cheese")) {
			pizza = new NYStyleCheesePizza();
		} else if (type.equals("pepperoni")) {
			pizza = new NYStylePepperoniPizza();
		}

		return pizza;
	}
}

class ChicagoStylePizzaStore extends PizzaStore {
	public Pizza createPizza(String type) {
		Pizza pizza = null;

		if (type.equals("cheese")) {
			pizza = new ChicagoStyleCheesePizza();
		} else if (type.equals("pepperoni")) {
			pizza = new ChicagoStylePepperoniPizza();
		} 
		
		return pizza;
	}
}

public class MyFactory {
	public static void main(String[] args) {
		PizzaStore nyStore = new NYStylePizzaStore();
		PizzaStore chicagoStore = new ChicagoStylePizzaStore();

		Pizza pizza = nyStore.orderPizza("cheese");
		System.out.println("Ethan ordered a " + pizza.getName() + "\n");

		pizza = chicagoStore.orderPizza("cheese");
		System.out.println("Ethan ordered a " + pizza.getName() + "\n");

		pizza = nyStore.orderPizza("pepperoni");
		System.out.println("Ethan ordered a " + pizza.getName() + "\n");

		pizza = chicagoStore.orderPizza("pepperoni");
		System.out.println("Ethan ordered a " + pizza.getName() + "\n");
	}
}

Console Result

Preparing NYStyleCheesePizza
Tossing dough...
Adding sauce...
Adding toppings: 
   Grated Reggiano Cheese
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a NYStyleCheesePizza

Preparing ChicagoStyleCheesePizza
Tossing dough...
Adding sauce...
Adding toppings: 
   Shredded Mozzarella Cheese
Bake for 25 minutes at 350
Cutting the pizza into square slices
Place pizza in official PizzaStore box
Ethan ordered a ChicagoStyleCheesePizza

Preparing NYStylePepperoniPizza
Tossing dough...
Adding sauce...
Adding toppings: 
   Grated Reggiano Cheese
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a NYStylePepperoniPizza

Preparing ChicagoStylePepperoniPizza
Tossing dough...
Adding sauce...
Adding toppings: 
   Shredded Mozzarella Cheese
Bake for 25 minutes at 350
Cutting the pizza into square slices
Place pizza in official PizzaStore box
Ethan ordered a ChicagoStylePepperoniPizza

Conclusion

N/A

[ENG][Math]Arithmetic calculator including parentheses

CamelAct — Thu, 26 May 2022 14:25:17 +0900

Overview

There are many calculator programs on the Internet.
However, most of them do not work well or parentheses are not possible.
The program introduced from now on is a calculator that can be parenthesized.

Change the formula that a person entered into a rear table.
It is taken out of the Stack and switched back to the mid -term mark, and the actual calculation is performed between them.

If you use it, you can add the function you want.
For example, it is easy to add SIN (1), SQRT (1), etc.
If the molecule is divided into zero, the error is done.

Code Example

package com.example.test;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CamelActCalculator {
	static Pattern minusPattern = Pattern.compile("[0-9]{1}[-]{1}[0-9]{1}");
	static Pattern pattern = Pattern.compile("[-]?[0-9]*\\.?[0-9]+|\\(|\\)|\\+|-|\\*|/|(abs)|(log10)|(if)|,|<=|>=|<|>|=|(and)|(or)");

	private static Map<String, Integer> priorityMap = new HashMap<String, Integer>();
	static {
		priorityMap.put("=", 1);
		priorityMap.put("<", 1);
		priorityMap.put(">", 1);
		priorityMap.put("<=", 1);
		priorityMap.put(">=", 1);
		priorityMap.put("and", 1);
		priorityMap.put("or", 1);
		priorityMap.put("+", 2);
		priorityMap.put("-", 2);
		priorityMap.put("*", 3);
		priorityMap.put("/", 3);
		priorityMap.put("(", 0);
	}
	
	public static void main(String[] args) {
		System.out.println(getCalculatedValue("30+20-21"));
		System.out.println(getCalculatedValue("-30+20-21"));
		System.out.println(getCalculatedValue("-30+(-30)"));
		System.out.println(getCalculatedValue("2.0*abs(-30-(-20*2))+20"));
		System.out.println(getCalculatedValue("2*abs(-30-abs(-20*2))+20"));
		System.out.println(getCalculatedValue("2*abs(-30-log10(20*2))+20"));
		System.out.println(getCalculatedValue("if(10<20,1,2)"));
		System.out.println(getCalculatedValue("if(10<20,if(11<22,1,2),3)"));
		System.out.println(getCalculatedValue("if(10+12+abs(20+3-2)<20,1,2)"));
		System.out.println(getCalculatedValue("if((1=0)&(2=0),0,1)"));
		System.out.println(getCalculatedValue("if((((1+3=0)and(30+2)))or(2=0),0,1)"));
		System.out.println(getCalculatedValue("if((1<=0)&(2=0),0,1)"));
		System.out.println(getCalculatedValue("if((1=0)and(2=0)and(3=0),0,if((1=0)or(2=0)or(3=0),100,100-(4/5)*(6/7)*(8/9)*100))"));
		System.out.println(getCalculatedValue("-50/-25"));
		System.out.println(getCalculatedValue("-50/0"));
	}
	
	public static double getCalculatedValue(String param) {
		if(param.contains("NaN")) {
			return Double.NaN;
		}
		
		Matcher m = minusPattern.matcher(param);
		while (m.find()) { 	// 30-20 to 30+-20		but cannot allow 30-(20) to 30+-(20) or -30+20 to +-30+20 or 30-abs(20) to 30+-abs(20)
			String word = m.group();
			String replace = word.charAt(0) + "+-" + word.charAt(2);
			param = param.replace(word, replace);
		}
		
		 Queue<String> infixQue = new LinkedList<String>();
		
		m = pattern.matcher(param);
		while (m.find()) {
			String word = m.group();
			
			if(word.equals("abs") || word.equals("log10")) {
				word = operSpecial(word, m, word.charAt(0)) ;
			} else 	if(word.equals("if")) {
				word = operIf(word, m);
			}
			
			infixQue.add(word);
		}
		
		double num = transformPostfix(infixQue);
		if(Double.isNaN(num)) { // can not divide 0
			System.out.println(Double.NaN + " convert to 0");
			return 0;
		}
		return num;
	}
	
	public static String operIf(String word, Matcher m) {
		Queue<String> conditionQue = new LinkedList<String>();
		Queue<String> trueQue = new LinkedList<String>();
		Queue<String> falseQue = new LinkedList<String>();
		Queue<String> refQue = conditionQue;
		
		int count = 0;
		int que = 0;
		while (m.find()) {
			word = m.group();
			
			if(word.equals("abs") || word.equals("log10")) {
				word = operSpecial(word, m, word.charAt(0)) ;
			} else 	if(word.equals("if")) {
				word = operIf(word, m);
			} else if(word.equals(",") && que == 0) {
				que++;
				refQue = trueQue;
				continue;
			} else if(word.equals(",") && que == 1) {
				que++;
				refQue = falseQue;
				continue;
			} else {
				if (word.equals("(")) {
					count++;
					if (count == 1)
						continue;
				}
				if (word.equals(")")) {
					count--;
					if (count == 0)
						break;
				}
			}
			
			refQue.add(word);
		}
		
		double num = 0f;
		if(transformPostfix(conditionQue) > 0) {
			num = transformPostfix(trueQue);
		} else {
			num = transformPostfix(falseQue);
		}
		
		return num + "";
	}
	
	public static String operSpecial(String word, Matcher m, char c) {
		Queue<String> subInfixQue = new LinkedList<String>();
		int count = 0;
		while (m.find()) {
			word = m.group();
			
			if(word.equals("abs") || word.equals("log10")) {
				word = operSpecial(word, m, word.charAt(0)) ;
			} else 	if(word.equals("if")) {
				word = operIf(word, m);
			} else {
				if (word.equals("(")) {
					count++;
					if (count == 1)
						continue;
				}
				if (word.equals(")")) {
					count--;
					if (count == 0)
						break;
				}
			}
			
			subInfixQue.add(word);
		}

		double num = transformPostfix(subInfixQue);
		
		switch (c) {
		case 'a':
			word = Math.abs(num) + "";
			break;
		case 'l':
			word = Math.log10(num) + "";
			break;
		default:
			word = Math.abs(num) + "";
			break;
		}
		
		return word;
	}

	public static double transformPostfix(Queue<String> param) {
		Stack<String> infixStack = new Stack<String>();
		Queue<String> postfixQue = new LinkedList<String>();
		
		for(String word : param) {
			if (word.equals("(")) {
				infixStack.push(word);
			} else if (priorityMap.containsKey(word)) {
				while (true) {
					if (infixStack.isEmpty() || priorityMap.get(infixStack.peek()) < priorityMap.get(word)) {
						infixStack.push(word);
						break;
					} else {
						String popStr = infixStack.pop();
						postfixQue.add(popStr);
					}
				}
			} else if (word.equals(")")) {
				while (true) {
					String popStr = infixStack.pop();
					if (popStr.equals("(")) {
						break;
					} else {
						postfixQue.add(popStr);
					}
				}
			} else {
				postfixQue.add(word);
			}
		}

		while (infixStack.isEmpty() == false) {
			String popStr = infixStack.pop();
			postfixQue.add(popStr);
		}
		
		double num = calculatePostfix(postfixQue);
		return num;
	}

	public static double calculatePostfix(Queue<String> param) {
		Stack<Double> postfixStack = new Stack<Double>();
		
		double firstVal;
		double secondVal;

		while (param.isEmpty() == false) {
			String word = param.remove();

			if (priorityMap.containsKey(word)) {
				secondVal = postfixStack.pop();
				firstVal = postfixStack.pop();

				switch (word) {
				case "+":
					postfixStack.push(firstVal + secondVal);
					break;
				case "-":
					postfixStack.push(firstVal - secondVal);
					break;
				case "*":
					postfixStack.push(firstVal * secondVal);
					break;
				case "/":
					postfixStack.push(firstVal / secondVal);
					break;
				case "and":
					if(firstVal > 0 && secondVal > 0) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case "or":
					if(firstVal > 0 || secondVal > 0) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case "=":
					if(firstVal == secondVal) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case "<":
					if(firstVal < secondVal) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case ">":
					if(firstVal > secondVal) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case "<=":
					if(firstVal <= secondVal) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				case ">=":
					if(firstVal >= secondVal) {
						postfixStack.push(1.);
					} else {
						postfixStack.push(0.);
					}
					break;
				default:
					break;
				}

			} else {
				postfixStack.push(Double.valueOf(word));
			}
		}
		return postfixStack.pop();
	}
}

Console Result

29.0
-31.0
-60.0
40.0
160.0
83.20411998265593
1.0
1.0
2.0
1.0
1.0
1.0
39.04761904761905
2.0
-Infinity

Conclusion

N/A

[ENG][블로그에]목차 만들기

CamelAct — Wed, 25 May 2022 18:40:39 +0900

Overview

블로그에 위와같이 글에 목차를 따로두어 클릭하면 책갈피 기능이 수행되는 것을 경험할 수 있다.

Understanding the title h tag

H 태그를 사용하여 Tistori 또는 자신의 블로그 게시물에 자동으로 콘텐츠를 만듭니다. 웹사이트에서 제목은 H 태그를 사용합니다. H1이 가장 중요한 제목이며 숫자가 클수록 중요도가 낮아집니다.
H1 태그는 현재 웹사이트에서만 사용해야 합니다. 블로그 제목을 H1 태그로 사용하는 것을 권장합니다. 본문에서는 H2 태그를 순서대로 사용하는 것을 권장합니다.

jQuery toc plugin upload

자바스크립트 프레임워크인 Jquarie를 사용하여 Tistory 목차를 생성할 수 있습니다. Jquarie는 JavaScript를 사용하기 쉽게 해주는 언어입니다. 다음 파일을 다운로드합니다.

jquery.toc.min.js

0.00MB

Click 관리자 메뉴에서 꾸미기 > 스킨 편집 > html 편집 > 파일업로드 in order.
Click the 'Add' button below.

Put automatic table of contents script

Click 관리자 메뉴에서 스킨 편집 > html 편집 in order.

You can paste the script at the bottom of the body tag.

<script src="./images/jquery.toc.min.js"></script>
<script>
  $(document).ready(function() {
  $("#toc").toc({content: "tt_article_useless_p_margin", headings: "h2,h3"});
});
</script>

Automatic table of contents css decorating

And I will decorate the contents of the table of contents. Click 관리자 메뉴에서 꾸미기 > 스킨 편집 > html 편집 > CSS 탭 in order.
And put the bottom CSS code. FONT-SIZES is font size and color is font color. Add the size and color you want.

.book-toc {
    position: relative;
    width: fit-content;
    border: 0px solid #b0d197;
    padding: 10px 20px 10px 15px;
	  background-color: #fafafa; 
	  color: #333;
    z-index: 1;
}
.book-toc:after {
    content: "";
    position: absolute;
    width: 100%;
    height: 100%;
    top: 0;
    left: 0;
	  background-color: #fafafa; 
	  color: #333;
    z-index: -1;
    opacity: 0.1;
}
.book-toc p {
 	  font-size: 15px; 
	  padding: 7px 10px 5px; 
	  margin: 0 0 10px; 
	  border-left: 5px solid #666; 
	  background-color: #fafafa; color: #333;
}
#toc * {
    font-size: 20px;
    color: #000 !important;
}
#toc {
    margin-bottom: 0;
}
#toc a:hover {
    color: #000;
}
#toc ul {
    margin-top: 5px;
    margin-bottom: 0px;
}
#toc > li {
    padding-left: 0;
    text-indent: 0;
    margin-bottom: 10px;
	  list-style-type: none;
}

#toc > li > a { 
 	  font-size: 15px; 
	  padding: 7px 10px 5px; 
	  margin: 0 0 10px; 
	  border-left: 5px solid #666; 
	  background-color: #fafafa; 
	  color: #333;
}

#toc > li > ul {
    padding-left: 20px;
    margin-top: 0;
    margin-bottom: 0;
}
#toc > li > ul > li {
    font-size: 0.87em;
    padding-left: 0;
    text-indent: 0;
    margin-bottom: 0;
    margin-top: 5px;
}
#toc > li > ul > li > a {
    font-size: 1em;
    text-decoration:none;
}
#toc > li > ul > li > ul {
    padding-left: 10px;
    margin-top: 0;
    margin-bottom: 0;
}
#toc > li > ul > li > ul > li {
    font-size: 0.87em;
	  list-style-type: none;
    padding-left: 0;
    text-indent: 0;
    margin-bottom: 0;
    margin-top: 3px;
}
#toc > li > ul > li > ul > li > a {
    font-size: 0.875em;
    text-decoration:none;
}

[ENG][디자인패턴]Decorator 패턴 이론과 설명

CamelAct — Wed, 25 May 2022 13:55:45 +0900

Overview

데코레이터 패턴은 음료에 시럽을 첨가하는 것과 같습니다.
한 음료에 시럽을 첨가하여 다른 음료를 만들 수 있습니다.

장점
1. 기존 코드를 수정하지 않고 데코레이터 패턴을 통해 행동을 확장할 수 있습니다.
2. 구성 및 위임을 통해 실행하면서 새 작업을 추가할 수 있습니다.

불리
1. 무의미한 대상을 너무 많이 추가할 수 있습니다.
2. 데코레이터가 너무 많으면 코드가 필요 이상으로 복잡해질 수 있습니다.

다음과 같은 상황에서 데코레이터 패턴을 사용하는 것이 좋습니다.
1. 클래스의 요소를 계속 수정하면서 사용할 구조체가 필요한 경우
2. 다양한 요소를 조합하여 사용하는 클래스 구조인 경우

Structure

https://dailyheumsi.tistory.com/198

Code Example

package com.example.design.pattern;

abstract class Beverage {
	protected String description = "Unknown Beverage";

	public String getDescription() {
		return description;
	}

	public abstract double cost();
}

class Espresso extends Beverage {
	public Espresso() {
		this.description = "Espresso";
	}

	@Override
	public double cost() {
		return 1;
	}
}

class HouseBlend extends Beverage {
	public HouseBlend() {
		this.description = "House Blend";
	}

	@Override
	public double cost() {
		return 1.5;
	}
}

abstract class CondimentDecorator extends Beverage {
	public abstract String getDescription();
}

class Mocha extends CondimentDecorator {
	private final Beverage beverage;

	public Mocha(Beverage beverage) {
		this.beverage = beverage;
	}

	@Override
	public double cost() {
		return 0.20 + beverage.cost();
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", Mocha";
	}
}

class Whip extends CondimentDecorator {
	private final Beverage beverage;

	public Whip(Beverage beverage) {
		this.beverage = beverage;
	}

	@Override
	public double cost() {
		return 0.15 + beverage.cost();
	}

	@Override
	public String getDescription() {
		return beverage.getDescription() + ", Whip";
	}
}

public class MyDecorator {
	public static void main(String[] args) {
		Beverage b = new Mocha(new Mocha(new Whip(new HouseBlend())));
		System.out.println(b.getDescription());
		System.out.println(b.cost());
	}
}

Console Result

House Blend, Whip, Mocha, Mocha
2.05

Additional Code Example

You can use Decorator Pattern to create arithmetic calculators.

package com.example.test;

abstract class Base {
	protected float result = 0;

	public float calc() {
		return result;
	}
}

class Number extends Base {
	public Number(float n) {
		this.result = n;
	}
}

abstract class CondimentDecorator extends Base {
	public abstract float calc();
}

class Plus extends CondimentDecorator {
	final Base base1;
	final Base base2;

	public Plus(Base base1, Base base2) {
		this.base1 = base1;
		this.base2 = base2;
	}

	@Override
	public float calc() {
		return base1.calc() + base2.calc();
	}
}

class Minus extends Plus {
	public Minus(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() - base2.calc();
	}
}

class Multipl extends Plus {
	public Multipl(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() * base2.calc();
	}
}

class Division extends Plus {
	public Division(Base base1, Base base2) {
		super(base1, base2);
	}

	@Override
	public float calc() {
		return base1.calc() / base2.calc();
	}
}

public class MyDecorator {
	public static void main(String[] args) {
		Base a = new Number(3);
		System.out.println(a.calc());
		
		Base b = new Plus(new Number(2), new Number(5));
		System.out.println(b.calc());
		// 		( ( 4 + 2 ) * ( 8 - 1 ) ) / 2
		Base c = new Division(new Multipl(new Plus(new Number(4), new Number(2)), new Minus(new Number(8), new Number(1))), new Number(2));
		System.out.println(c.calc());
	}
}

Console Result

3.0
7.0
21.0

Conclusion

N/A

[ENG][디자인패턴]Builder 패턴 이론과 설명

CamelAct — Tue, 24 May 2022 16:08:17 +0900

Overview

빌더 패턴은 공장에서 만드는 것보다 쉽습니다.
미리 디자인북을 가져오세요.
모든 비행기는 같은 영역으로 나눌 수 있습니다.
Wings, PowerPlant, Avionics, Seats 등
구성 요소는 평면과 다르지만 사이트는 동일합니다.
비행기가 공장에 들어오면 디자인에 따라 다른 붐이 들어옵니다.
다른 부품들로 구성되어 최종적으로 조립과정을 거쳐 완성됩니다.

장점
1. 필요한 데이터만 설정할 수 있습니다.
2. 유연성을 확보할 수 있다.
3. 가독성을 높일 수 있습니다.
4. 불변성을 확보할 수 있다.

Structure

https://ko.wikipedia.org/wiki/%EB%B9%8C%EB%8D%94_%ED%8C%A8%ED%84%B4

Code Example

package com.example.design.pattern;

class AirplaneProduct {
	private String type;
	private float wingspan;
	private String powerplant;
	private int crewSeats;
	private int passengerSeats;
	private String avionics;
	private String customer;

	AirplaneProduct(String customer, String type) {
		this.customer = customer;
		this.type = type;
	}

	public void setWingspan(float wingspan) {
		this.wingspan = wingspan;
	}

	public void setPowerplant(String powerplant) {
		this.powerplant = powerplant;
	}

	public void setAvionics(String avionics) {
		this.avionics = avionics;
	}

	public void setNumberSeats(int crewSeats, int passengerSeats) {
		this.crewSeats = crewSeats;
		this.passengerSeats = passengerSeats;
	}

	public String getCustomer() {
		return customer;
	}

	public String getType() {
		return type;
	}
}

abstract class AirplaneBuilder {
	protected AirplaneProduct airplane;
	protected String customer;
	protected String type;

	public AirplaneProduct getAirplane() {
		return airplane;
	}

	public void createNewAirplane() {
		airplane = new AirplaneProduct(customer, type);
	}

	public abstract void buildWings();

	public abstract void buildPowerplant();

	public abstract void buildAvionics();

	public abstract void buildSeats();
}

class CropDuster extends AirplaneBuilder {
	CropDuster(String customer) {
		super.customer = customer;
		super.type = "Crop Duster v3.4";
	}

	public void buildWings() {
		airplane.setWingspan(9f);
	}

	public void buildPowerplant() {
		airplane.setPowerplant("single piston");
	}

	public void buildAvionics() {
	}

	public void buildSeats() {
		airplane.setNumberSeats(1, 1);
	}
}

class FighterJet extends AirplaneBuilder {
	FighterJet(String customer) {
		super.customer = customer;
		super.type = "F-35 Lightning II";
	}

	public void buildWings() {
		airplane.setWingspan(35.0f);
	}

	public void buildPowerplant() {
		airplane.setPowerplant("dual thrust vectoring");
	}

	public void buildAvionics() {
		airplane.setAvionics("military");
	}

	public void buildSeats() {
		airplane.setNumberSeats(1, 0);
	}
}

class AerospaceEngineerDirector {
	private AirplaneBuilder airplaneBuilder;

	public void setAirplaneBuilder(AirplaneBuilder ab) {
		airplaneBuilder = ab;
	}

	public AirplaneProduct getAirplane() {
		return airplaneBuilder.getAirplane();
	}

	public void constructAirplane() {
		airplaneBuilder.createNewAirplane();
		airplaneBuilder.buildWings();
		airplaneBuilder.buildPowerplant();
		airplaneBuilder.buildAvionics();
		airplaneBuilder.buildSeats();
	}
}

public class MyBuilder {
	public static void main(String[] args) {
		AerospaceEngineerDirector aero = new AerospaceEngineerDirector();
		// instantiate each concrete builder (take orders)
		AirplaneBuilder crop = new CropDuster("Farmer Joe");
		AirplaneBuilder fighter = new FighterJet("The Navy");

		aero.setAirplaneBuilder(crop);
		aero.constructAirplane();
		AirplaneProduct completedCropDuster = aero.getAirplane();

		System.out.println(completedCropDuster.getType() + " is completed and ready for delivery to "
				+ completedCropDuster.getCustomer());

	}
}

Console Result

Crop Duster v3.4 is completed and ready for delivery to Farmer Joe

Conclusion

Builder pattern is provided as a lombok plugin, so it is easy to use.

Import lombok.builder;
...
@Builder (BuilderMethodName = "Newbuilder", setterPrefix = "set")
Public Class Node IMPLEETS Serializable {
...
Node.newbuilder (). Build ();
...

[ENG][디자인패턴]Bridge 패턴 이론과 설명

CamelAct — Tue, 24 May 2022 14:42:10 +0900

Overview

다리, 즉 연결하는 패턴입니다.
같은 개체에서 다른 작업을 수행해야 합니다.

예를 들어 원이 있고 하나는 빨간색이고 하나는 녹색입니다.
원에 대한 고유 정보를 수신하고 추가 색상 정보를 추가합니다.
수신한 색상 정보를 사용하여 다른 색상을 호출할 수 있습니다.
그린 소스, 레드 소스 등의 클래스를 생성한 경우 해당 서클에 대한 고유 정보가 중복되어 클래스마다 색상이 증가하여 관리에 어려움이 있습니다.

장점
구현하고자 하는 인터페이스와 완전히 결합되어 있지 않기 때문에 구현과 추상화된 부분을 분리할 수 있다.
추상 및 실제 구현을 확장할 수 있습니다.
추상 부분을 구현하는 상속 클래스를 변경해도 클라이언트 측에 영향을 미치지 않습니다.

불리
디자인이 복잡해집니다.

Structure

https://ko.wikipedia.org/wiki/%EB%B8%8C%EB%A6%AC%EC%A7%80_%ED%8C%A8%ED%84%B4

Console Result

package com.example.design.pattern;

interface DrawAPI {
	public void drawCircle(int radius, int x, int y);
}

class RedCircle implements DrawAPI {
	@Override
	public void drawCircle(int radius, int x, int y) {
		System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", " + y + "]");
	}
}

class GreenCircle implements DrawAPI {
	@Override
	public void drawCircle(int radius, int x, int y) {
		System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", " + y + "]");
	}
}

abstract class Shape {
	protected DrawAPI drawAPI;

	protected Shape(DrawAPI drawAPI) {
		this.drawAPI = drawAPI;
	}

	public abstract void draw();
}

class Circle extends Shape {
	private int x, y, radius;

	public Circle(int x, int y, int radius, DrawAPI drawAPI) {
		super(drawAPI);
		this.x = x;
		this.y = y;
		this.radius = radius;
	}

	public void draw() {
		drawAPI.drawCircle(radius, x, y);
	}
}

class MyBridge {
	public static void main(String[] args) {
		Shape redCircle = new Circle(100, 100, 10, new RedCircle());
		Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());

		redCircle.draw();
		greenCircle.draw();
	}
}

Console Result

Drawing Circle[ color: red, radius: 10, x: 100, 100]
Drawing Circle[ color: green, radius: 10, x: 100, 100]

Conclusion

N/A