개발하는 도치

[Python] Data Model 만들기 (3) - Data Model

허도치 — Wed, 20 Jan 2021 22:36:29 +0900

2021/01/19 - [Back-end/Python] - [Python] Data Model 만들기 (1) - BaseField

2021/01/19 - [Back-end/Python] - [Python] Data Model 만들기 (2) - Data Type Field

이전 포스트에서 StringField, IntegerField, DatetimeField를 구현하였다. 이 Data Type Field 들의 유효성검사를 좀 더 보완해서 사용하면 더 좋겠지만, 우선은 Data Schema를 먼저 만들어 볼 계획이다. Schema는 Database에서 자료의 구조를 나타내는데, 이를 모방하여 Python Object로 구현해보려고 한다.

1. 에러 핸들러

1-1. ValidateError

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# errors.py
 
class ValidateError(Exception):
  def __init__(self, messages, code=400):
    super(ValidateError, self).__init__()
    self.messages = messages
    self.code = code
    
  def getMessages(self):
    return self.messages
  
  def __str__(self):
    return '[{code}] {messages}'.format(code=self.code, messages=self.messages)
 
Colored by Color Scripter

cs

2. Model 객체

2-1. BaseModel 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

# models.py
 
from fields import BaseField, StringField, IntegerField, DatetimeField
from errors import ValidateError
 
 
class BaseModel(object):
 
  def __init__(self, data=None):
    if data is not None:
      self.dump(data)
  
  def getField(self, field_name, field_type=None):
    '''
    특정 필드 조회
    * BaseField 타입의 필드를 조회하기위한 함수
    '''
    if hasattr(self, field_name):
      attr = getattr(self, field_name)
      if field_type is None:
        return attr
      elif isinstance(attr, field_type):
        return attr
      
      raise TypeError("Expected data type '%s', but '%s'." %( field_type.__name__, attr.__class__.__name__ ))
    raise ValueError("'%s' is not defined field." % ( field_name ))
 
  def getFields(self):
    '''
    필드 목록 조회
    * BaseField 타입의 필드 목록을 조회하기위한 함수
    '''
    fields = list()
    for field_name in dir(self):
      try:
        field_value = self.getField(field_name, BaseField)
        if not callable(field_value) and not field_name.startswith("_"):
          fields.append((field_name, field_value))
      except:
        pass
    return fields
  
  def __mapp(self, datas, validate=True):
    '''
    데이터 매핑
    * 각 필드에 데이터를 매핑하는 함수
    * 옵션에 따라 유효성검사를 실시
    '''
    data = dict()
    errors = dict()
 
    # 입력값 매핑
    for field_name, value in datas.items():
      try:
        field_class = self.getField(field_name, BaseField)
        field_class.setValue(value, validate=validate)
        data[field_name] = field_class.getValue()
        
      except Exception as e:
        errors[field_name] = str(e)
        
    # 기본값 매핑
    for field_name, field_class in self.getFields():
      # 입력값 매핑을 시도한 필드는 제외
      if field_name in datas:
        continue
      
      try:
        default = field_class.getOption("default", None)
        
        # 기본값이 문자열이면 현재 객체에 정의된 메소드 중 이름이 일치하는 메소드 조회
        if isinstance(default, str) and hasattr(self, default):
          default = getattr(self, default)
          
        # 기본값이 메소드면 실행한 결과값을 저장하고 아니면 그냥 저장
        value = default if not callable(default) else default(field_name)
        
        # 필드에 저장된 데이터 
        field_class.setValue(value, validate=validate)
        data[field_name] = field_class.getValue()
        
      except Exception as e:
        errors[field_name] = str(e)
    
    # 값매핑 결과 반환
    return ( data, errors )
  
  def dump(self, data=None):
    '''
    단일 데이터 Dumping
    * 입력받은 데이터를 각 필드에 매핑
    * @data:Optional[Dict]
      - data가 None이면 dump 데이터로 처리(dump가 먼저 실행되어야함)
    '''
    __data = data if data is not None else self.__dump_data
    dumped, errors = self.__mapp(__data, validate=False)
    
    self.__dump_data = dumped
    self.__errors = errors
    
    return dumped
 
  def load(self, data=None):
    '''
    단일 데이터 Loading
    * 입력받은 데이터를 각 필드에 매핑
    * 유효성검사 실시, 유효하지 않은 필드는 ValidateError를 발생시켜 반환
    * @data:Optional[Dict]
      - data가 None이면 dump 데이터로 처리(dump가 먼저 실행되어야함)
    '''
    __data = data if data is not None else self.__dump_data
      
    loaded, errors = self.__mapp(__data, validate=True)
    
    self.__load_data = loaded
    self.__errors = errors
    
    if len(errors) > 0:
      raise ValidateError(errors)
      
    return loaded
    
  def __str__(self):
    return str(self.__data)
    
  def __repr__(self):
    return "<models.{self.__class__.__name__}>".format(self=self)
 
Colored by Color Scripter

cs

2-2. UserModel 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# models.py
'''
    BaseModel 밑에 이어서 작성
'''
from uuid import uuid4
from datetime import datetime
 
 
class UserModel(BaseModel):
  id = StringField(required=True, maxlength=50, default=lambda info: str(uuid4()))
  name = StringField(maxlength=10)
  role = StringField(required=True, default="user")
  age = IntegerField(required=True, min=0, max=200)
  hire_date = DatetimeField(required=True, format="%Y%m%d%H%M%S", default="getNowDate")
 
  def getNowDate(self, name):
    '''
        현재 시간을 반환
    '''
    return datetime.now()
 
Colored by Color Scripter

cs

2-3. UserModel 객체 테스트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# test.models.py
from pprint import pprint
 
from models import UserModel
from errors import ValidateError
 
class TestUserModel(object):
  def __init__(self):
    print("UserModel 테스트")
    print("="*40)
    for attrname in dir(self):
      testcase = getattr(self, attrname)
      if attrname.startswith("test") and callable(testcase):
        print("="*40)
        print( testcase.__doc__ )
        print("="*40)
        try:
          testcase()
        except Exception as e:
          print("Error: "+str(e))
        print("")
        print("="*40)
        
  def test_case_1(self):
    '''
    데이터 매핑 방법
    '''
    user = UserModel(dict(
      name="Dumpping_1",
      age=10,
      hire_date="20210120"
    ))
    data = user.dump(dict(
      id="admin",
      name="Dumpping_2",
      age=100,
      hire_date="20210120"
    ))
        
  def test_case_2(self):
    '''
    데이터 단일 Dumping 정상 / 단일 Loading 오류
    '''
    user = UserModel(dict(
      name="Dochi",
      age=1004,
      hire_date="20210120"
    ))
    print("==== Dump Result")
    dump_data = user.dump()
    pprint( dump_data, indent=2 )
    print("")
    
    try:
      print("==== Load Result")
      load_data = user.load()
      pprint( load_data, indent=2 )
    
    except ValidateError as e:
      pprint( e.getMessages(), indent=2 )
      
  def test_case_3(self):
    '''
    데이터 단일 Dumping 정상 / 단일 Loading 정상
    '''
    user = UserModel(dict(
      name="Dochi",
      age=109,
      hire_date="20210120123456"
    ))
    print("==== Dump Result")
    dump_data = user.dump()
    pprint( dump_data, indent=2 )
    print("")
    
    try:
      print("==== Load Result")
      load_data = user.load()
      pprint( load_data, indent=2 )
    
    except ValidateError as e:
      pprint( e.getMessages(), indent=2 )
 
# 테스트실행
TestUserModel()
Colored by Color Scripter

cs

2-4. UserModel 객체 테스트 결과

마치며

- BaseModel에서 __mapp 함수가 조금 복잡하게 보일 수 있지만, 단순하게 설명하자면 입력받은 데이터를 UserModel에 정의된 필드(id, name, age, role, hire_date)에 매핑을 하는 것이다. 또한, dump와 load로 구분한 이유는 dump는 단순히 구조화된 Object에 데이터를 저장하기 위한 용도이며, load는 데이터 저장과 더불어 Database에 저장하는 등 전처리 작업에 필요한 유효성검사를 처리하는 용도이다.

- 이번 예제에서는 단순하게 UserModel만 구현하였는데, 게시판 글을 저장하는 BoardModel이나 검색조건을 저장하는 SearchModel 등 다양하게 활용이 가능하며, 나중에는 Database Connector를 붙여서 ORM을 구현할 수도 있다.

- 다만, 이번에 만든 BaseModel 객체는 단일 데이터만 저장할 수 있기 때문에 리스트형 데이터를 저장할 수 있는 객체를 추가로 만들거나 이번에 만든 BaseModel을 확장할 필요가 있다.

[Python] Data Model 만들기 (2) - Data Type Field

허도치 — Tue, 19 Jan 2021 22:46:26 +0900

지난 포스트에서는 간단한 매소드만 구현되어 있는 최상위 클래스인 BaseField를 구현하고 테스트를 해보았다. 이번 포스트에서는 BaseField를 상속받는 문자열 타입의 StringField, 정수형 타입의 IntegerField, 날짜형 타입의 DatetimeField를 만들어보도록 하겠다.

1. 문자열 타입 객체

1-1. StringField 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# fields.py
"""
BaseField 밑에 이어서 작성
"""
 
class StringField(BaseField):
  def __init__(self, maxlength=None, **kwargs):
    super(StringField, self).__init__(str, **kwargs)
    
    # 유효성검사 옵션값
    self.__maxlength = maxlength
  
  # Overriding: 유효성검사
  def validate(self, value=None):
    exists = value is not None
    value = value if exists else self.getValue()
    length = len(value) if exists else 0
 
    
    # 유효성검사: 필수값
    if bool(self.required) and not exists:
      raise ValueError("This value was Required, but it is None.")
    
    # 유효성검사: 최대길이
    if bool(self.__maxlength) and exists and length > self.__maxlength:
      raise ValueError("Expected value length %d, but %d." % ( self.__maxlength, length ))
 
Colored by Color Scripter

cs

1-2. StringField 객체 테스트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# test.fields.py
"""
TestBaseField 밑에 이어서 작성
"""
 
from fields import StringField
 
class TestStringfield(object):
  
  # 문자열 필드
  field = StringField(required=True, maxlength=10)
  
  def __init__(self):
    print("Stringfield 테스트")
    print("="*30)
    for attrname in dir(self):
      testcase = getattr(self, attrname)
      if attrname.startswith("test") and callable(testcase):
        print("=========", attrname, "========")
        try:
          testcase()
        except Exception as e:
          print("Error: "+str(e))
        print("="*30)
        
  def test_case_1(self):
    print("문자열 필수값 오류 확인")
    print("Input: None")
    self.field.setValue(None)
    print("Value: "+str(self.field.getValue()))
      
  def test_case_2(self):
    print("문자열 타입 오류 확인")
    print("Input: 1234")
    self.field.setValue(1234)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_3(self):
    print("문자열 최대길이 오류 확인")
    print("Input: '1234567890#'")
    self.field.setValue('1234567890#')
    print("Value: "+str(self.field.getValue()))
  
  def test_case_4(self):
    print("문자열 정상")
    print("Input: 'Hello!!'")
    self.field.setValue("Hello!!")
    print("Value: "+str(self.field.getValue()))
 
# 테스트 실행
TestStringfield()
 
Colored by Color Scripter

cs

1-3. StringField 객체 테스트 결과

2. 정수형 타입 객체

2-1. IntegerField 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# fields.py
"""
StringField 밑에 이어서 작성
"""
 
class IntegerField(BaseField):
  def __init__(self, min=None, max=None, **kwargs):
    super(IntegerField, self).__init__(int, **kwargs)
 
    # 유효성검사 옵션값
    self.__min = min
    self.__max = max
  
  # Overriding: 유효성검사
  def validate(self, value=None):
    exists = value is not None
    value = value if exists else self.getValue()
 
    
    # 유효성검사: 최솟값
    if bool(self.__min) and exists and value < self.__min:
      raise ValueError("Expected minimum %d, but %d." % ( self.__min, value ))
 
    # 유효성검사: 최댓값
    if bool(self.__max) and exists and value > self.__max:
      raise ValueError("Expected maximum %d, but %d." % ( self.__max, value ))
 
Colored by Color Scripter

cs

2-2. IntegerField 객체 테스트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# test.fields.py
"""
TestStringField 밑에 이어서 작성
"""
 
from fields import IntegerField
 
 
class TestIntegerField(object):
  
  # 정수형 필드
  field = IntegerField(required=True, min=10, max=100)
  
  def __init__(self):
    print("IntegerField 테스트")
    print("="*30)
    for attrname in dir(self):
      testcase = getattr(self, attrname)
      if attrname.startswith("test") and callable(testcase):
        print("=========", attrname, "========")
        try:
          testcase()
        except Exception as e:
          print("Error: "+str(e))
        print("="*30)
        
  def test_case_1(self):
    print("정수형 필수값 오류 확인")
    print("Input: None")
    self.field.setValue(None)
    print("Value: "+str(self.field.getValue()))
      
  def test_case_2(self):
    print("정수형 타입 오류 확인")
    print("Input: '100'")
    self.field.setValue('100')
    print("Value: "+str(self.field.getValue()))
  
  def test_case_3(self):
    print("정수형 최솟값 오류 확인")
    print("Input: 3")
    self.field.setValue(3)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_4(self):
    print("정수형 최댓값 오류 확인")
    print("Input: 999")
    self.field.setValue(999)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_4(self):
    print("정수형 정상")
    print("Input: 100")
    self.field.setValue(100)
    print("Value: "+str(self.field.getValue()))
 
# 테스트 실행
TestIntegerField()
 
Colored by Color Scripter

cs

2-3. IntegerField 객체 테스트 결과

3. 날짜형 타입 객체

3-1. DatetimeField 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

# fields.py
"""
IntegerField 밑에 이어서 작성
"""
 
from datetime import datetime, timedelta
 
class DatetimeField(BaseField):
  def __init__(self, format="%Y-%m-%d %H:%M:%S", min=None, max=None, *args, **kwargs):
    super(DatetimeField, self).__init__(datetime, *args, **kwargs)
 
    self.__value = None
    self.__format = format
    self.__min = None
    self.__max = None
 
    # 제한시간 설정: 최소
    if min is not None:
      if min == 'now':
        self.__min = datetime.now()
      elif isinstance(min, str):
        self.__min = datetime.strptime(min, format)
      else:
        self.__min = min
 
    # 제한시간 설정: 최대
    if max is not None:
      if max == 'now':
        self.__max = datetime.now()
      elif isinstance(max, str):
        self.__max = datetime.strptime(max, format)
      else:
        self.__max = max
 
  # 값 설정
  def setValue(self, value, format=None, validate=True):
    self.__value = None
 
    # 유효성검사: 문자열 포맷 확인
    if isinstance(value, str):
      value = datetime.strptime(value, format or self.__format)
 
    if validate:
      # 유효성검사
      self.validate(value)
    
    self.__value = value
 
  # 값 반환, datetime
  def getValue(self, format=None):
    return self.__value
 
  # Overriding: 유효성검사
  def validate(self, value=None):
    exists = value is not None
    value = value if exists else self.getValue()
 
    # 유효성검사: 타입체크
    if exists and not isinstance(value, self.type):
      raise TypeError("Expected data type '%s', but '%s'." %( self.type.__name__, value.__class__.__name__ ))
 
    # 유효성검사: 필수값
    if bool(self.required) and not exists:
      raise ValueError("This value was Required, but it is None.")
    
    # 유효성검사: 최소시간
    if bool(self.__min) and exists:
      
      # 최소시간 데이터 형변환
      min = None
      if isinstance(self.__min, timedelta):
        min = datetime.now()+self.__min
      else:
        min = self.__min
 
      if value < min:
        raise ValueError("Expected datetime less than (%s), but %s." % ( min, value ))
 
    # 유효성검사: 최대시간
    if bool(self.__max) and exists:
      
      # 최대시간 데이터 형변환
      max = None
      if isinstance(self.__max, timedelta):
        max = datetime.now()+self.__max
      else:
        max = max
  
      if value > max:
        raise ValueError("Expected datetime greater than (%s), but %s." % ( max, value ))
 
Colored by Color Scripter

cs

3-2. DatetimeField 객체 테스트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

# test.fields.py
"""
TestIntegerField 밑에 이어서 작성
"""
 
from fields import DatetimeField
from datetime import datetime, timedelta
 
 
class TestDatetimeField(object):
  
  # 날짜형 필드
  field = DatetimeField(required=True, format="%Y-%m-%d %H:%M:%S", min='now', max=timedelta(hours=1))
  
  def __init__(self):
    print("DatetimeField 테스트")
    print("="*30)
    for attrname in dir(self):
      testcase = getattr(self, attrname)
      if attrname.startswith("test") and callable(testcase):
        print("=========", attrname, "========")
        try:
          testcase()
        except Exception as e:
          print("Error: "+str(e))
        print("="*30)
        
  def test_case_1(self):
    print("날짜형 필수값 오류 확인")
    print("Input: None")
    self.field.setValue(None)
    print("Value: "+str(self.field.getValue()))
      
  def test_case_2(self):
    print("날짜형 포맷 오류 확인")
    print("Input: '2021/01/19 23:59:59'")
    self.field.setValue('2021/01/19 23:59:59')
    print("Value: "+str(self.field.getValue()))
      
  def test_case_3(self):
    print("날짜형 타입 오류 확인")
    print("Input: 1000")
    self.field.setValue(1000)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_4(self):
    value = datetime.now() - timedelta(minutes=5)
    print("날짜형 최소시간 오류 확인")
    print("Input: %s (현재시간 - 5분)" %( value ))
    self.field.setValue(value)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_5(self):
    value = datetime.now() + timedelta(hours=2)
    print("날짜형 최댓값 오류 확인")
    print("Input: %s (현재시간 + 2시간)" %( value ))
    self.field.setValue(value)
    print("Value: "+str(self.field.getValue()))
  
  def test_case_6(self):
    value = datetime.now() + timedelta(minutes=30)
    print("날짜형 정상")
    print("Input: %s (현재시간 + 30분)" %( value ))
    self.field.setValue(value)
    print("Value: "+str(self.field.getValue()))
 
# 테스트 실행
TestDatetimeField()
 
Colored by Color Scripter

cs

3-3. DatetimeField 객체 테스트 결과

마치며

- 이것으로 StringField, IntegerField, DatetimeField를 모두 구현해보았다. 문자열과 정수형은 딱히 어려운 부분이 없었는데, 날짜형은 계산과 데이터 형변환이 필요한 부분이 좀 있어서 복잡해지긴 했지만, 그래도 잘 돌아간다.

- 다음 포스트에서는 지금까지 만든 데이터 타입 객체들을 이용한 데이터 모델을 만들어 보도록 하겠다.

[Python] Data Model 만들기 (1) - BaseField

허도치 — Tue, 19 Jan 2021 17:28:00 +0900

  개인적으로 웹 개발을 하다보면 입력 화면이 가장 손이 많이 가는 것 같다. 왜냐하면, 화면에서 입력한 값을 프론트단에서 1차로 유효성검사를 하고 백단에서 2차로 유효성검사를 하고 DB에 입력하는 경우 데이터 타입과 포맷도 맞추어야 하기 때문이다. 그래서, 백단에서 단계를 좀 간소화시킬 수 없을까 고민하다가 데이터 객체를 정의하고 이 객체를 생성할 때, 유효성검사와 데이터 변환을 처리하는 모듈을 구현해보기로 하였다. 이미 marshmallow라는 좋은 라이브러리가 있지만, 직접 만들어보는걸 좋아하기 때문에 완벽하진 않지만 이번에도 직접 구현해 볼 계획이다.

  이번 포스트에서 구현할 것은 크게 두가지이다.

  첫번째는 데이터 타입 객체이다. 문자열, 정수형, 날짜형과 같은 Python 데이터 타입이지만 유효성검사와 데이터 변환을 위한 기능이 추가된 객체이다.
  두번째는 데이터 모델 객체이다. VO(Value Object)이며, 여러 속성들로 구성된 하나의 의미있는 객체이다. 각 속성은 앞서 생성한 데이터 타입 객체로 정의한다.

1. 데이터 타입 객체

1-1. BaseField 객체 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# fields.py
class BaseField(object):
  def __init__(
      self,
      valtype,
      required=False,
      **kwargs):
 
    self.__value = None
    self.__type = valtype
    self.__required = required
    self.__options = dict(kwargs)
  
  # 값 설정
  def setValue(self, value, validate=True):
    self.__value = None
    
    if validate:
      # 유효성검사: 필수값
      if value is None and self.required:
        raise ValueError("This value was Required, but it is None.")
      
      # 유효성검사: 데이터 타입
      if value is not None and not isinstance(value, self.__type):
        raise TypeError("Expected data type '%s', but '%s'." %( self.__type.__name__, value.__class__.__name__ ))
      
      # 유효성검사
      self.validate(value)
    
    self.__value = value
    
  def getValue(self):
    return self.__value
 
  def getOption(self, optkey, defaultvalue=None):
    return self.__options.get(optkey, defaultvalue)
    
  @property  
  def type(self):
    return self.__type
 
  @property
  def required(self):
    return self.__required
  
  # Override
  def validate(self, value=None):
    pass
  
  def __str__(self):
    return str(self.__value)
 
Colored by Color Scripter

cs

1-2. BaseField 객체 테스트

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# test.fields.py
from fields import BaseField
from datetime import datetime
    
# BaseField 테스트
class TestBaseField(object):
  
  #문자열 필드
  string_field = BaseField(str, required=True)
  
  #숫자형 필드
  integer_field = BaseField(int, required=True)
  
  #날짜형 필드
  datetime_field = BaseField(datetime, required=True)
  
  def __init__(self):
    print("BaseField 테스트")
    print("="*30)
    for attrname in dir(self):
      testcase = getattr(self, attrname)
      if attrname.startswith("test") and callable(testcase):
        print("=========", attrname, "========")
        try:
          testcase()
        except Exception as e:
          print("Error: "+str(e))
        print("="*30)
        
  def test_case_1(self):
    print("문자열 필수값 오류 확인")
    print("Input: None")
    self.string_field.setValue(None)
    print("Value: "+str(self.string_field.getValue()))
      
  def test_case_2(self):
    print("문자열 타입 오류 확인")
    print("Input: 1234")
    self.string_field.setValue(1234)
    print("Value: "+str(self.string_field.getValue()))
  
  def test_case_3(self):
    print("문자열 정상")
    print("Input: 'Hello!!'")
    self.string_field.setValue("Hello!!")
    print("Value: "+str(self.string_field.getValue()))
        
  def test_case_4(self):
    print("정수형 필수값 오류 확인")
    print("Input: None")
    self.integer_field.setValue(None)
    print("Value: "+str(self.integer_field.getValue()))
      
  def test_case_5(self):
    print("정수형 타입 오류 확인")
    print("Input: '1234'")
    self.integer_field.setValue('1234')
    print("Value: "+str(self.integer_field.getValue()))
  
  def test_case_6(self):
    print("정수형 정상")
    print("Input: 1234")
    self.integer_field.setValue(1234)
    print("Value: "+str(self.integer_field.getValue()))
        
  def test_case_7(self):
    print("날짜형 필수값 오류 확인")
    print("Input: None")
    self.datetime_field.setValue(None)
    print("Value: "+str(self.datetime_field.getValue()))
      
  def test_case_8(self):
    print("날짜형 타입 오류 확인")
    print("Input: '20200101'")
    self.datetime_field.setValue('20200101')
    print("Value: "+str(self.datetime_field.getValue()))
  
  def test_case_9(self):
    print("날짜형 정상")
    print("Input: %s" %(datetime.now()))
    self.datetime_field.setValue(datetime.now())
    print("Value: "+str(self.datetime_field.getValue()))
      
# 테스트 실행
TestBaseField()
Colored by Color Scripter

cs

1-3. BaseField 테스트 결과

마치며

- 지금까지 BaseField 객체를 생성하고 테스트 해보았다. 다음 포스트에서는 이 BaseField를 상속받은 StringField, IntegerField, DatetimeField 객체를 생성하고 각 데이터 타입에 알맞는 유효성검사를 추가해보도록 하겠다.

[Webpack4] 무작정 시작하기 (1) - Webpack이란?

허도치 — Wed, 18 Nov 2020 11:04:47 +0900

Webpack이란?

javascript 모듈(Module) 번들러(Bundler)

Webpack은 JS 파일 뿐만 아니라, CSS, HTML, Image 등을 모듈로 로드해서 사용할 수 있다. 또한, 코드를 압축, 최적화 하는 기능들을 제공하며, 번들링된 파일이 너무 무거워질 경우 다시 여러 개의 파일로 나눌 수 있는 코드 스플리팅(Code Spliting) 기능도 제공한다.

핵심 개념으로는 Mode, Entry, Output, Loader, Plugin가 있으며, 추가로 Optimization이 있다.

모듈(Module)이란?

모듈은 프로그램을 구성하는 요소 중 하나이며 관련된 데이터와 함수들이 묶여서 모듈을 형성하고, 주로 파일 단위로 관리된다.

예를 들어, 팝업은 isOpen이라는 상태 데이터와 open, close, destroy와 같은 함수를 가진 하나의 모듈이며, 로그인은 logedIn이라는 상태 데이터와 doLogin, checkValidation과 같은 함수를 가진 모듈이다. 이 두 모듈은 각각의 Javascript 파일에 작성된다.

이렇게 모듈화된 프로그래밍은 유지보수가 쉬워지는 장점이 있다.

번들러(Bundler)란?

번들러는 모듈별로 나누어진 파일을 특정 단위로 묶어서 요청에 대한 응답으로 전달할 수 있는 환경을 만들어주는 역할을 한다. 모듈 또는 외부 라이브러리 간의 의존성을 쉽게 관리할 수 있다.

예를 들어, A, B, C, ..., Z 라는 모듈들이 있을 때, 이를 알파벳이라는 하나의 번들로 묶을 수 있다. 만약, A가 a라는 라이브러리를 사용하고 있다면, a라는 라이브러리도 함께 번들링된다.

번들링된 파일을 열어보면 A, B, C, ..., Z와 a가 모두 포함된 내용이 압축되어있다.

번들링을 하는 이유

웹페이지에서 모듈을 사용하려면 해당 모듈과 모듈에서 사용되는 라이브러리들을 로드해야하는데, 선후 관계를 따져서 순서대로 로드해야 한다. 몇 개의 모듈을 사용한다면 <script> 태그를 이용하여 간단하게 로드 할 수 있겠지만, 만약, 수십, 수백 개의 모듈을 사용해야 한다면 매우 복잡해질 것이다. 또한, 이렇게 많은 양의 파일을 한번에 로드 할 경우 네트워크의 병목현상이 발생할 수 있다. 병목현상은 하나의 Javascript 파일에 최대한 많은 내용을 작성하면 해결 할 수 있지만, 유지보수와 가독성이 떨어진다.

이 때, 번들링된 파일을 로드하면 위와 같은 문제들을 해결 할 수 있다. 모듈을 번들링하는 과정에서 모듈이나 외부 라이브러리의 의존성들을 로드하기 때문에 선후 관계를 따질 필요 없으며, 여러 파일로 작성된 모듈들을 특정 단위로 묶어서 하나의 파일로 만들기 때문에 병목현상도 예방 할 수 있다.

핵심개념

Mode

배포 환경 설정

mode는 development와 production, none을 선택할 수 있다. 기본값은 production이며, 이는 배포용이고 최적화가 자동으로 적용된다. devlopment는 개발용이며 webpack dev server를 사용할 수 있다.

1
2
3
4
5
6
7

// Usage
mode: <string> // development, production, none
 
// Example
module.exports = {
  mode: 'development',
}
Colored by Color Scripter

cs

Entry

번들링 시작 모듈의 경로 설정

Entry는 내부적으로 종속성에 대한 그래프를 작성하기위한 시작 모듈을 설정하는 것으로 해당 모듈이 의존하는 모든 모듈과 라이브러리를 파악한다.

Entry를 작성하는 방법에는 Single과 Multiple Entry 두가지가 있다. Single Entry는 지정한 Entry Point들을 한개의 번들로 만드는 것이며, Multiple Entry는 이름(name)과 콘텐츠 해시(contentHash) 가진 여러개의 번들로 만들 수 있다. 이름과 콘텐츠 해시는 Output에서 사용된다.

4버전 이전에는 Entry에 bootstrap, react와 같은 vendor를 별도의 Entry Point로 추가하고 CommonsChunkPlugin을 사용하여 번들링하는 것이 일반적이었느나, 4버전 이후에는 권장하지 않는다. 대신, optimization.splitChunks을 통해 app과 vendor를 분리하는 것을 권장한다.

1
2
3
4
5
6
7
8
9

// Single Entry (Shorthand) Syntax
 
// Usage
entry: <String> | [<String>]
 
// Example
module.exports = {
  entry: './path/to/my/entry/file.js'
}
Colored by Color Scripter

cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Multiple Entry (Object) Syntax
 
// Usage
entry: {
  '<entryChunkName>': <String>| [<String>]
}
 
// Example
module.exports = {
  entry: {
    pageOne: './src/pageOne/index.js',
    pageTwo: './src/pageTwo/index.js',
    pageThree: './src/pageThree/index.js'
  }
}
Colored by Color Scripter

cs

Output

번들링 결과 출력 설정

의미 그대로 번들링된 결과를 출력할 파일명과 경로을 설정할 수 있다. 기본 경로는 **'./dist'**이며, 해당 경로에 지정한 파일명으로 번들 파일이 생성된다. 만약, Multiple Entry로 설정되어있다면 Entry에서 설정한 이름으로 출력 파일명을 동적으로 할당할 수 있으며, 콘텐츠 해시를 파일명에 추가하여 파일명 중복을 방지할 수 있다.

또한, publicPath 옵션을 사용할 수 있는데, 브라우저에서 참조될때 출력 파일의 공용 URL 주소로 사용된다. 다른 도메인이나 CDN에서 일부 또는 모든 출력 파일을 호스팅하려는 경우 사용할 수 있으며, Webpack Dev Server에서는 출력파일의 URL 경로로 사용된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// Usage
output: {
  filename: <String>,
  path: <String>,
  publicPath: <String>
}
 
// Example
// Single Entry Points
module.exports = {
  entry: './path/to/my/entry/file.js',
  output: {
    filename: 'my-first-webpack.bundle.js',
    path: __dirname + '/dist',
    publicPath: '/public/',
  }
};
 
 
// Example
// Multiple Entry Points
module.exports = {
  entry: {
    app: './src/app.js',
    search: './src/search.js'
  },
  output: {
    filename: '[name].js',
    path: __dirname + '/dist',
    publicPath: '/public/',
  }
};
// output -> [ ./dist/app.js, ./dist/search.js ]
 
 
// Example
// CDN for assest 
module.exports = {
  //...
  output: {
    path: '/home/proj/cdn/assets/[hash]',
    publicPath: 'https://cdn.example.com/assets/[hash]/'
  }
};
Colored by Color Scripter

cs

Loaders

다양한 유형의 파일을 모듈화

기본적으로 Webpack은 Javascript와 JSON 파일만 처리할 수 있다. Loader는 Webpack이 다른 유형의 파일을 처리하고 이를 응용 프로그램이 소비하고 종속성 그래프에 추가 할 수있는 유효한 모듈로 변환하는 기능을 한다. 예를들어, CSS 파일을 Loader로 모듈화하여 Javascript 내에서 로드하여 사용할 수 있다.

Loader는 **'test'**와 **'use'**라는 주요 옵션이 있다. test는 정규표현식으로 작성되며, 변환할 대상을 식별하는데 사용되고, use는 변환하는데 사용되는 Loader를 지정한다. Webpack이 컴파일하면서 Javascript 내에 require 또는 import로 로드된 파일을 식별하여 번들링되기 전에 변환을 수행한다. 또한, use에 Loader를 여러개 지정할 수 있는데, 이는 아래에서 위로 우선순위를 갖는다.

구버전의 브라우저에서는 최신 Javascript 문법(const, let, arrow function 등)을 지원하지 않을 수 있다. 이 때, babel-loader를 사용하면 최신 문법으로 작성된 Javascript를 모든 브라우저에서 해석할 수 있도록 변환할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// Usage
module: {
  rules: [
    { 
          test: <RegularExpression>, 
            use: <String>
        }
  ]
}
 
 
// Install Loaders
// for css
npm install --save-dev css-loader style-loader sass-loader
 
// for babel
npm install --save-dev babel-loader @babel/core @babel/preset-env
 
 
// Example
// webpack.config.js
module.exports = {
  module: {
    rules: [
      { // .css로 끝나는 파일은 'css-loader'로 모듈화
                test: /\.css$/, 
                use: [
                    { loader: 'style-loader' },
                    {
                        loader: 'css-loader', 
            options: {
              modules: true
            }
          },
          { loader: 'sass-loader' },
                ]
            },
            { 
                test: /\.js$/,
                exclude: /node_modules/, 
                loader: "babel-loader"
            }
    ]
  }
};
 
// Example
// .babelrc
{
  "presets": ["@babel/preset-env"]
}
Colored by Color Scripter

cs

Plugins

다양한 Webpack 빌드 프로세스 설정

Webpack으로 빌드를 할 때 사용할 수 있는 추가적인 기능들을 제공하여, 다양한 방법의 빌드 환경을 구성할 수 있다. Webpack 패키지에 포함된 내장 플러그인 외에 추가로 필요한 기능은 외부 플러그인을 받아서 사용할 수 있다.

플러그인에 따라 사용법이 다르기 때문에 사용법과 예제는 다른 포스트에서 다루어 보도록 하겠다.

내장플러그인 목록

Internal webpack plugins | webpack

webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.

webpack.js.org

외부플러그인 목록

Plugins | webpack

webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.

webpack.js.org

Optimization

빌드 최적화 설정

번들 파일은 여러 모듈들이 한 개의 파일에 작성된 것으로 크기가 매우 크다. optimization은 이러한 번들 파일의 크기를 최대한 줄이거나 분할하는 등의 최적화 작업을 하는 역할을 한다.

minimize 옵션은 Javascript의 크기를 축소 시키는 옵션으로 jquery.min.js처럼 공백과 네이밍을 최소화시킨다. production 모드에서는 기본값으로 true이다.

최적화 옵션 목록

Optimization | webpack

webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.

webpack.js.org

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Example
module.exports = {                           
    ...
    optimization: {
    splitChunks: {
      chunks: 'async',
      minSize: 30000,
      maxSize: 0,
      minChunks: 1,
      maxAsyncRequests: 6,
      maxInitialRequests: 4,
      automaticNameDelimiter: '~',
      cacheGroups: {
        defaultVendors: {
          test: /[\\/]node_modules[\\/]/,
          priority: -10
        },
        default: {
          minChunks: 2,
          priority: -20,
          reuseExistingChunk: true
        }
      }
    },
    minimize: true,
  }
    ...
};
Colored by Color Scripter

cs

예제

install loader

1

npm install --save-dev babel-loader

cs

webpack.config.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

const webpack = require("webpack");
const path = require("path");
 
module.exports = {
  mode: "development",
  entry: {
    app: [
      path.join(__dirname, "../js/index.js"),
    ]
  },
  output: {
    filename: "[name].bundle.js",
    path: path.join(__dirname, "../dist"),
    publicPath: "/public/",
  },
  plugins: [
    new webpack.ProgressPlugin((percentage, message, ...args)=>{
      console.info(Math.trunc(percentage*100), "%", message, ...args);
    }),
  ],
  module: { // loaders
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        loader: "babel-loader"
      }
    ]
  },
  optimization: {
    splitChunks: {
      chunks: 'async',
      minSize: 30000,
      maxSize: 0,
      minChunks: 1,
      maxAsyncRequests: 6,
      maxInitialRequests: 4,
      automaticNameDelimiter: '~',
      cacheGroups: {
        defaultVendors: {
          test: /[\\/]node_modules[\\/]/,
          priority: -10
        },
        default: {
          minChunks: 2,
          priority: -20,
          reuseExistingChunk: true
        }
      }
    },
  },
}
 
Colored by Color Scripter

cs

[JAVA] Mapper를 만들어보자 (2) - PreparedStatement

허도치 — Wed, 18 Nov 2020 01:02:01 +0900

2020/11/18 - [Back-end/JAVA] - [JAVA] Mapper를 만들어보자 (1) - XML읽기

서론

이전 시간에 XML파일에서 특정 SQL을 읽어오는 클래스를 작성해보았다. 일반적인 경우 읽어온 SQL을 그대로 사용하면 되지만, PreparedStatement를 사용하려면 변수를 입력받고 치환해주는 과정이 필요하다. 그래서, 이번 포스트에서는 SQL에 작성된 #{변수명}, ${변수명} 을 치환하는 방법에 대해서 다루어 보려고 한다.

참조

1. DBManager.java

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

소스코드

1. MapperService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

package com.dochi.db.ex.maaper;
 
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import org.jdom.Document;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
 
import com.dochi.quartz.crawl_db.db.DBManager;
 
// 변환된 SQL과 DATA를 저장할 클래스
class SQLInfo {
    private String sql = null;
    private List<Object> data = null;
    
    public SQLInfo(String sql, List<Object> data) {
        this.sql = sql;
        this.data = data;
    }
    public String getSql() {
        return sql;
    }
    public void setSql(String sql) {
        this.sql = sql;
    }
    public List<Object> getData() {
        return data;
    }
    public void setData(List<Object> data) {
        this.data = data;
    }
}
 
public class MapperService extends DBManager {
    
    // 상수설정
    //   - Mapper 파일명
    private final String XML_FILE_NAME = "src/main/java/com/dochi/db/ex/maaper/MyMapper.xml";
 
    // 변수설정
    //   - Mapper 변수
    private SAXBuilder builder = new SAXBuilder();
    private Document document = null;
    private Mapper root = null;
    
    // 생성자
    //   - Mapper 객체 생성
    public MapperService() {
        try {
            
            document = builder.build(XML_FILE_NAME);
            root = new Mapper(document.getRootElement());
            
        } catch (JDOMException | IOException e) {
            e.printStackTrace();
        }
    }
    
    // 특정 키워드를 찾아서 PreparedStatement로 변환해주는 함수
    //   - ${변수명} => Integer 
    //   - #{변수명} => String
    public SQLInfo parsing(String sql, Map<String, Object> paramMap) {
        List<Object> data = new ArrayList<Object>();
        
        // 나중에 패턴이 더 추가될 수도 있으므로 List에 담았음
        List<Pattern> patterns = new ArrayList<Pattern>();
        patterns.add(Pattern.compile("((#|\\$)\\{([a-zA-Z_0-9]+)\\})", Pattern.DOTALL));
        
        Iterator<Pattern> iter = patterns.iterator();
        Matcher matcher = null;
        
        while( iter.hasNext() ) {
            matcher = iter.next().matcher(sql);
            
            while( matcher.find() ) {
                String type = matcher.group(2);
                String source = matcher.group(1);
                String targetKey = matcher.group(3);
                
                if( paramMap.containsKey(targetKey) ) {
                    // SQL에서 탐색된 변수는 '?'로 치환
                    sql = sql.replace(source, "?");
                    
                    data.add(paramMap.get(targetKey));
                }
            }
        }
        
        return new SQLInfo(sql, data);
    }
    
    // 현재일시를 조회하는 함수
    public Map<String, Object> selectDateTime(Map<String, Object> paramMap) {
        // 상수설정
        //   - 현재 실행중인 함수의 이름을 저장한 변수
        final String METHOD_NAME = Thread.currentThread().getStackTrace()[1].getMethodName();
        
        //   - XML에서 현재 함수명의 SQL을 조회하여 저장하 변수
        final String SQL = this.root.getSQL(METHOD_NAME);
 
        System.out.println( "==== Before SQL" );
        System.out.println( SQL );
        
        // 변수설정
        //   - PreparedStatement SQL로 치환
        SQLInfo info = parsing(SQL, paramMap);
        
        System.out.println( "==== After SQL" );
        System.out.println( info.getSql() );
        System.out.println( info.getData() );
        
        // 나중에 SQL이 실행된 결과를 반환
        return null;
    }
 
    // 현재일자를 조회하는 함수
    public Map<String, Object> selectDate(Map<String, Object> paramMap) {
        // 상수설정
        //   - 현재 실행중인 함수의 이름을 저장한 변수
        final String METHOD_NAME = Thread.currentThread().getStackTrace()[1].getMethodName();
        
        //   - XML에서 현재 함수명의 SQL을 조회하여 저장하 변수
        final String SQL = this.root.getSQL(METHOD_NAME);
 
        System.out.println( "==== Before SQL" );
        System.out.println( SQL );
        
        // 변수설정
        //   - PreparedStatement SQL로 치환
        SQLInfo info = parsing(SQL, paramMap);
        
        System.out.println( "==== After SQL" );
        System.out.println( info.getSql() );
        System.out.println( info.getData() );
        
        // 나중에 SQL이 실행된 결과를 반환
        return null;
    }
    
    public static void main(String[] args) {
        MapperService service = new MapperService();
        
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("testValue", 10);
        
        service.selectDateTime(paramMap);
    }
}
Colored by Color Scripter

cs

실행결과

[ MapperService 실행 결과 ]

마치며

지금까지 XML파일에서 SQL을 읽어 PreparedStatement SQL로 변환시켜보았다. 생각보다 간단하게 구현할 수 있었다. 다음 포스트에서는 SQLite와 연결해서 실제로 사용해보도록 하겠다.

[JAVA] Mapper를 만들어보자 (1) - XML읽기

허도치 — Wed, 18 Nov 2020 00:40:47 +0900

서론

SQLite를 이용해서 DB를 다루다가 String에 SQL을 작성하는 것이 좀 불편했다. 그래서, mybatis나 ibatis처럼 XML 파일에 SQL을 작성하고 이를 읽어서 사용하고 싶어졌다. 그래서, 이번 포스트에서는 XML파일에 작성된 SQL을 읽어오는 방법에 대해서 다루어 보도록 하겠다.

개발환경

1. JAVA 버전

- jdk-11.0.9

2. POM.xml

1
2
3
4
5

<dependency>
  <groupId>jdom</groupId>
  <artifactId>jdom</artifactId>
  <version>1.0</version>
</dependency>

cs

소스코드

1. MyMapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?xml version="1.0" encoding="UTF-8"?>
<mapper>
 
  <sql id="selectDateTime">
    SELECT strftime('%Y-%m-%d %H:%M:%S', datetime('now')) AS DATE_TIME
         , #{testValue} AS TEST_VALUE 
  </sql>
  
  <sql id="selectDate">
    SELECT strftime('%Y-%m-%d', datetime('now')) AS DATE_TIME
         , #{testValue} AS TEST_VALUE_A 
         , ${testValue} AS TEST_VALUE_B
  </sql>
  
</mapper>
Colored by Color Scripter

cs

2. Mapper.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

package com.dochi.db.ex.maaper;
 
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
 
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
 
public class Mapper {
    // 변수 설정
    //   - XML Child 객체 변수
    private Element element = null;
    
    // 생성자
    //   - Element를 저장
    public Mapper(Element element) {
        this.element = element;
    }
    
    // XML 탐색기
    //   - id가 'attrValue'인 sql 조회
    public String getSQL(String attrValue) {
        return getChild("sql", "id", attrValue).getText();
    }
    
    //   - 속성명, 속성값으로 Child 탐색
    public Mapper getChild(String attrName, String attrValue) {
        return getChild(null, attrName, attrValue);
    }
 
    //   - 이름, 속성명, 속성값으로 Child 탐색
    public Mapper getChild(String name, String attrName, String attrValue) {
        List<?> children = null;
        
        if( name != null ) {
            children = this.element.getChildren(name);
        } else {
            children = this.element.getChildren();
        }
        
        Iterator<?> iter = children.iterator();
        while(iter.hasNext()) {
            Element element = (Element) iter.next(); 
            String elementAttrValue = element.getAttributeValue(attrName);
            
            if( elementAttrValue != null && elementAttrValue.equalsIgnoreCase(attrValue) ) {
                return new Mapper(element);
            }
        }
        
        return null;
    }
    
    public String getText() {
        return this.element.getText();
    }
    public List<?> getChildren() {
        return this.element.getChildren();
    }
    public List<?> getChildren(String name) {
        return this.element.getChildren(name);
    }
    public String getAttributeValue(String attrName) {
        return this.element.getAttributeValue(attrName);
    }
    public String getAttributeValue(String attrName, String defaultValue) {
        return this.element.getAttributeValue(attrName, defaultValue);
    }
    
    public static void main(String[] args) throws JDOMException, IOException {
 
        // 상수설정
        //   - Mapper 파일명
        final String XML_FILE_NAME = "src/main/java/com/dochi/db/ex/maaper/MyMapper.xml";
 
        // 변수설정
        //   - XML 변수
        SAXBuilder builder = new SAXBuilder();
        Document document = builder.build(XML_FILE_NAME);
        Element rootElement = document.getRootElement();
        
        //   - Mapper 객체 변수
        Mapper mapper = new Mapper(rootElement);
        
        //   - SQL 탐색
        String sql = mapper.getSQL("selectDateTime");
        
        System.out.println( sql );
    }
}
Colored by Color Scripter

cs

실행결과

[ XML에서 'selectDateTime' SQL을 조회 ]

마치며

이렇게 아주 간단하게(?) XML 파일에서 특정 SQL을 읽어오는 Mapper 클래스를 만들어 보았다. SQL을 살펴보면 '#{testValue}'가 눈에 들어올 것이다. 이 부분은 mybatis나 ibatis처럼 변수를 받아서 치환하려고 미리 넣어둔 것이다.

다음 포스트에서 이 부분에 대해서 다루어 보도록 하겠다.

[JAVA] 영화 박스오피스 오픈 API (2) - 요청 및 응답

허도치 — Tue, 17 Nov 2020 00:36:41 +0900

2020/11/16 - [Back-end/JAVA] - [JAVA] 영화 박스오피스 오픈 API (1) - 사전준비

서론

지난 시간에는 영화진흥위원회 오픈API를 사용할 준비를 하였고, 이번 포스트에서는 실제 JAVA 소스를 작성하여 데이터를 수집해 볼 계획이다.

개발환경

1. JAVA 버전

- jdk-11.0.5

2. POM.xml

1
2
3
4
5

<dependency>
  <groupId>org.json</groupId>
  <artifactId>json</artifactId>
  <version>20200518</version>
</dependency>

cs

소스코드

1. MovieAPI.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
 
import org.json.JSONArray;
import org.json.JSONObject;
 
public class MovieAPI {
 
    // 상수 설정
    //   - 요청(Request) 요청 변수
    private final String REQUEST_URL = "http://www.kobis.or.kr/kobisopenapi/webservice/rest/boxoffice/searchDailyBoxOfficeList.json";
    private final String AUTH_KEY = "발급받은 인증키 입력";
 
    //   - 일자 포맷
    private final SimpleDateFormat DATE_FMT = new SimpleDateFormat("yyyyMMdd");
 
    // Map -> QueryString
    public String makeQueryString(Map<String, String> paramMap) {
        final StringBuilder sb = new StringBuilder();
 
        paramMap.entrySet().forEach(( entry )->{
            if( sb.length() > 0 ) {
                sb.append('&');
            }
            sb.append(entry.getKey()).append('=').append(entry.getValue());
        });
 
        return sb.toString();
    }
 
    // API요청
    public void requestAPI() {
        // 변수설정
        //   - 하루전 닐찌
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date());
        cal.add(Calendar.DATE, -1);
 
        // 변수 설정
        //   - 요청(Request) 인터페이스 Map
        //   - 어제자 다양성 한국영화 10개 조회
        Map<String, String> paramMap = new HashMap<String, String>();
        paramMap.put("key"          , AUTH_KEY);                        // 발급받은 인증키
        paramMap.put("targetDt"     , DATE_FMT.format(cal.getTime()));  // 조회하고자 하는 날짜
        paramMap.put("itemPerPage"  , "10");                            // 결과 ROW 의 개수( 최대 10개 )
        paramMap.put("multiMovieYn" , "Y");                             // Y:다양성 영화, N:상업영화, Default:전체
        paramMap.put("repNationCd"  , "K");                             // K:한국영화, F:외국영화, Default:전체
 
        try {
            // Request URL 연결 객체 생성
            URL requestURL = new URL(REQUEST_URL+"?"+makeQueryString(paramMap));
            HttpURLConnection conn = (HttpURLConnection) requestURL.openConnection();
 
            // GET 방식으로 요청
            conn.setRequestMethod("GET");
            conn.setDoInput(true);
 
            // 응답(Response) 구조 작성
            //   - Stream -> JSONObject
            BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String readline = null;
            StringBuffer response = new StringBuffer();
            while ((readline = br.readLine()) != null) {
                response.append(readline);
            }
 
            // JSON 객체로  변환
            JSONObject responseBody = new JSONObject(response.toString());
 
            // 데이터 추출
            JSONObject boxOfficeResult = responseBody.getJSONObject("boxOfficeResult");
 
            // 박스오피스 주제 출력
            String boxofficeType = boxOfficeResult.getString("boxofficeType");
            System.out.println(boxofficeType);
 
            // 박스오피스 목록 출력
            JSONArray dailyBoxOfficeList = boxOfficeResult.getJSONArray("dailyBoxOfficeList");
            Iterator<Object> iter = dailyBoxOfficeList.iterator();
            while(iter.hasNext()) {
                JSONObject boxOffice = (JSONObject) iter.next();
                System.out.printf("  %s - %s\n", boxOffice.get("rnum"), boxOffice.get("movieNm"));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void main(String[] args) {
        // API 객체 생성
        MovieAPI api = new MovieAPI();
 
        // API 요청
        api.requestAPI();
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 다양성 한국영화 10개 조회 ]

[ 다양성 외국영화 10개 조회 ]

마치며

이것으로 영화 박스오피스를 조회하는 API 연계 앱을 만들어보았다. 영화진흥위원회 오픈API를 살펴보면 박스오피스 외에도 다양한 API들을 제공하고 있으니, 연습삼아서 사용해보길 바란다.

영화진흥위원회 오픈API 뿐만 아니라 공공데이터 포털을 찾아보면 코로나19 감염 현황에 관련된 오픈API도 있으니 한번 다루어보도록 하자.

www.data.go.kr/tcs/dss/selectApiDataDetailView.do?publicDataPk=15043376

공공데이터 포털

국가에서 보유하고 있는 다양한 데이터를『공공데이터의 제공 및 이용 활성화에 관한 법률(제11956호)』에 따라 개방하여 국민들이 보다 쉽고 용이하게 공유•활용할 수 있도록 공공데이터(Datase

www.data.go.kr

[JAVA] 영화 박스오피스 오픈 API (1) - 준비

허도치 — Mon, 16 Nov 2020 22:19:32 +0900

서론

이번 포스트에서는 영화진흥위원회(KOFIC)에서 제공하는 OPEN API를 이용하여 영화 박스오피스 데이터를 수집하는 인터페이스를 구축해볼 계획이다. 아주 간단하지만 재밌는 예제이고 유용하게 사용할 수 있다고 생각한다.

영화진흥위원회 오픈API

1. 홈페이지 소개

- 영화진흥위원회 영화관입장권통합전산망에서 제공하는 오픈API 서비스.

- 아래와 같은 데이터를 제공함

박스오피스 - 일일박스오피스, 주간/주말 박스오피스
영화정보 - 영화목록, 영화상세정보
영화사정보 - 영화사목록, 영화사상세정보
영화인정보 - 영화인목록, 영화인상세정보

- 회원제 서비스이기 때문에 회원가입 후 이용할 수 있음.

- www.kobis.or.kr/kobisopenapi/homepg/main/main.do

영화진흥위원회 오픈API

www.kobis.or.kr

2. 회원가입

[ 이용약관 확인 후 '회원 가입 진행' ]

[ 개인정보 입력 후 '가입' ]

[ 가입확인하기! ]

[ '회원 인증 처리하러 가기' 버튼을 클릭하면 완료! ]

3. 키발급 하기

[ 키 발급/관리 탭으로 이동 ]

[ '키 발급받기' 버튼 클릭 ]

[ '사용 목적', '관리명' 입력 후 '키 발급' 클릭 ]

[ 키 발급 완료! ]

4. 박스오피스 API 정보

- 요청URL

http://www.kobis.or.kr/kobisopenapi/webservice/rest/boxoffice/searchDailyBoxOfficeList..json

- 요청(Request) 인터페이스

요청변수	값	설명
key	문자열(필수)	발급받은키 값을 입력합니다.
targetDt	문자열(필수)	조회하고자 하는 날짜를 yyyymmdd 형식으로 입력합니다.
itemPerPage	문자열	결과 ROW 의 개수를 지정합니다.(default : “10”, 최대 : “10“)
multiMovieYn	문자열	다양성 영화/상업영화를 구분지어 조회할 수 있습니다. “Y” : 다양성 영화 “N” : 상업영화 (default : 전체)
repNationCd	문자열	한국/외국 영화별로 조회할 수 있습니다. “K: : 한국영화 “F” : 외국영화 (default : 전체)
wideAreaCd	문자열	상영지역별로 조회할 수 있으며, 지역코드는 공통코드 조회 서비스에서 “0105000000” 로서 조회된 지역코드입니다. (default : 전체)

- 응답(Response) 구조

응답 필드	값	설명
boxofficeType	문자열	박스오피스 종류를 출력합니다.
showRange	문자열	박스오피스 조회 일자를 출력합니다.
rnum	문자열	순번을 출력합니다.
rank	문자열	해당일자의 박스오피스 순위를 출력합니다.
rankInten	문자열	전일대비 순위의 증감분을 출력합니다.
rankOldAndNew	문자열	랭킹에 신규진입여부를 출력합니다. “OLD” : 기존 , “NEW” : 신규
movieCd	문자열	영화의 대표코드를 출력합니다.
movieNm	문자열	영화명(국문)을 출력합니다.
openDt	문자열	영화의 개봉일을 출력합니다.
salesAmt	문자열	해당일의 매출액을 출력합니다.
salesShare	문자열	해당일자 상영작의 매출총액 대비 해당 영화의 매출비율을 출력합니다.
salesInten	문자열	전일 대비 매출액 증감분을 출력합니다.
salesChange	문자열	전일 대비 매출액 증감 비율을 출력합니다.
salesAcc	문자열	누적매출액을 출력합니다.
audiCnt	문자열	해당일의 관객수를 출력합니다.
audiInten	문자열	전일 대비 관객수 증감분을 출력합니다.
audiChange	문자열	전일 대비 관객수 증감 비율을 출력합니다.
audiAcc	문자열	누적관객수를 출력합니다.
scrnCnt	문자열	해당일자에 상영한 스크린수를 출력합니다.
showCnt	문자열	해당일자에 상영된 횟수를 출력합니다.

5. 예시URL

http://www.kobis.or.kr/kobisopenapi/webservice/rest/boxoffice/searchDailyBoxOfficeList.json?key=430156241533f1d058c603178cc3ca0e&targetDt=20120101

[ 예시 데이터 ]

- URL의 파라미터를 확인해보면, [ key=430156241533f1d058c603178cc3ca0e&targetDt=20120101 ] 요청 인터페이스 목록에 있는 key와 targetDt 가 사용된 것을 확인할 수 있음.

- 추가로 itemPerPage, multiMovieYn, repNationCd, wideAreaCd 를 적용해보면 다양한 결과를 확인 할 수 있음.

마치며

지금까지 영화진흥위원회 오픈API를 사용하기위해 회원가입을 하고 API 연계를 위한 인증키를 발급 받았다. 그리고, 박스오피스 정보를 요청할 때 필요한 정보와 응답받을 수 있는 데이터들도 확인해보았다. 다음 포스트에서는 JAVA 소스를 통해 데이터를 수집해보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 끝 - MariaDB

허도치 — Sun, 15 Nov 2020 17:36:19 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (4) - SELECT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (5) - UPDATE

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (6) - DELETE

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (7) - 다중 INSERT

서론

이번 포스트에서는 앞서 예고했던 것처럼 지금까지 만든 SQLite 예제를 살짝 수정하여 MariaDB에 접속할 수 있도록 만들어 보도록 하겠다.

이 예제를 따라하려면 MariaDB가 셋팅되어 있어야 한다.

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (1) - 설치 및 실행

[MariaDB] 무작정 시작하기 (1) - 설치 및 실행

시작하기전에... 지금까지 RDBMS는 Oracle, DB2를 써왔는데 볼륨자체가 크다보니까 집에서 간단하게 프로젝트를 만들때는 사용하기가 조금 부담스러웠다. 그래서, NoSQL인 MongoDB를 주로 이용했는데, RD

heodolf.tistory.com

소스코드

1. DBManager.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class DBManager {
 
    // 상수 설정
    //   - JDBC Driver 변수
    private static final String DEFAULT_JDBC_DRIVER = "org.sqlite.JDBC";
    private static final String SQLITE_JDBC_DRIVER = "org.sqlite.JDBC";
    private static final String MARIADB_JDBC_DRIVER = "org.mariadb.jdbc.Driver";
    
    //   - Database URL 변수
    private static final String DEFAULT_DB_URL = "jdbc:sqlite::memory";
 
    //   - Database 옵션 변수
    private static final boolean OPT_AUTO_COMMIT = false;
    private static final int OPT_VALID_TIMEOUT = 500;
 
    // 변수 설정
    //   - Database 접속 정보 변수
    private Connection conn = null;
    private String driver = null;
    private String url = null;
    private String username = null;
    private String password = null;
 
    // 생성자
    public DBManager(){
        this(DEFAULT_DB_URL);
    }
    public DBManager(String url) {
        this(url, null, null);
    }
    public DBManager(String url, String username, String password) {
        // JDBC Driver 설정
        //   - Database 이름 가져오기
        final String DB_NAME = url.split(":")[1];
        
        //   - Database에 따른 Driver 매핑
        if( "mariadb".equalsIgnoreCase(DB_NAME) ) {
            this.driver = MARIADB_JDBC_DRIVER;
        } else if ( "sqlite".equalsIgnoreCase(DB_NAME) ) {
            this.driver = SQLITE_JDBC_DRIVER;
        } else {
            this.driver = DEFAULT_JDBC_DRIVER;
        }
        this.url = url;
        this.username = username;
        this.password = password;
    }
 
    // DB 연결 함수
    public Connection createConnection() {
        try {
            // JDBC Driver Class 로드
            Class.forName(this.driver);
 
            // DB 연결 객체 생성
            this.conn = DriverManager.getConnection(this.url, this.username, this.password);
 
            // 옵션 설정
            //   - 자동 커밋
            this.conn.setAutoCommit(OPT_AUTO_COMMIT);
 
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
 
        return this.conn;
    }
 
    // DB 연결 종료 함수
    public void closeConnection() {
        try {
            if( this.conn != null ) {
                this.conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            this.conn = null;
        }
    }
 
    // DB 재연결 함수
    public Connection ensureConnection() {
        try {
            if( this.conn == null || this.conn.isValid(OPT_VALID_TIMEOUT) ) {
                closeConnection();      // 연결 종료
                createConnection();     // 연결
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
 
        return this.conn;
    }
 
    // DB 연결 객체 가져오기
    public Connection getConnection() {
        return this.conn;
    }
}
 
Colored by Color Scripter

cs

2. DDLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class DDLService extends DBManager {
    // 생성자
    public DDLService() {
        
    }
    public DDLService(String url) {
        this(url, null, null);
    }
    public DDLService(String url, String username, String password) {
        super(url, username, password);
    }
 
    // SQL 실행 함수
    public ResultType executeSQL(final String SQL) throws SQLException {
        // 변수설정
        //   - Database 변수
        Connection conn = null;
        Statement stmt = null;
 
        //   - 결과 변수
        ResultType result = ResultType.FAILURE;
 
        try {
            // Database 연결
            conn = ensureConnection();
 
            // Statement 객체  생성
            stmt = conn.createStatement();
 
            // SQL 실행
            stmt.execute(SQL);
 
            // 트랜잭션 COMMIT
            conn.commit();
 
            // 성공
            result = ResultType.SUCCESS;
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
 
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
            // 오류
            result = ResultType.FAILURE;
 
        } finally {
            // Statement 종료
            if( stmt != null ) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        return result;
    }
 
    // 테이블 조회 함수
    public boolean checkTable(String tableName) throws SQLException {
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        DatabaseMetaData meta = conn.getMetaData();
 
        // 테이블 목록 조회
        ResultSet tables = meta.getTables(null, null, tableName, null);
 
        // 테이블 생성 확인
        return ( tables.next() ? tables.getRow() != 0 : false );
    }
 
    // 테이블 생성 함수
    public ResultType createTable(String tableName, final String SQL) throws SQLException {
        // 테이블 확인
        if( checkTable(tableName) ) {
            return ResultType.WARNING;
        }
 
        // SQL 실행 및 반환
        return executeSQL(SQL);
    }
 
    // 테이블 삭제 함수
    public ResultType dropTable(String tableName) throws SQLException {
        // 테이블 확인
        if( !checkTable(tableName) ) {
            return ResultType.WARNING;
        }
 
        // SQL 실행 및 반환
        return executeSQL("DROP TABLE IF EXISTS "+tableName);
    }
 
    // 결과 코드 정의
    public enum ResultType {
        SUCCESS(1),     // 성공
        WARNING(0),     // 경고
        FAILURE(-1);    // 실패
 
        // 코드 변수
        private int code = 0;
 
        // 코드값 설정
        private ResultType(int code){
            this.code = code;
        }
 
        // 코드값 가져오기
        public int getCode() {
            return this.code;
        }
    }
}
 
Colored by Color Scripter

cs

3. DMLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
public class DMLService extends DBManager {
    
    // 상수 설정
    //   - DateFormat 설정
    private static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    //   - Batch건수 설정
    //     * 100건마다 적재 시도
    private static final int OPT_BATCH_SIZE = 100;
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        this(url, null, null);
    }
    public DMLService(String url, String username, String password) {
        super(url, username, password);
    }
    
    // 다중 데이터 삽입 함수
    public int insertBlogArticle(List<Map<String, Object>> dataMapList) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
            
            // 입력받은 데이터를 Batch 처리
            for(int i = 0; i < dataMapList.size(); i++ ) {
                // 입력 데이터 객체
                Map<String, Object> dataMap = dataMapList.get(i);
                
                // 입력 데이터 매핑
                pstmt.setObject(1, dataMap.get("BLOG_ID"));
                pstmt.setObject(2, dataMap.get("CATE_ID"));
                pstmt.setObject(3, dataMap.get("ATCL_ID"));
                pstmt.setObject(4, dataMap.get("URL"));
                pstmt.setObject(5, dataMap.get("TITLE"));
                pstmt.setObject(6, dataMap.get("WORK_YN"));
                pstmt.setObject(7, DATETIME_FMT.format(new Date()));
                
                // Batch에 추가
                pstmt.addBatch();
                
                System.out.println("insert: "+ dataMap.toString());
                
                // Batch 실행
                if( i % OPT_BATCH_SIZE == 0 ) {
                    inserted += pstmt.executeBatch().length;
                }
            }
 
            // Batch 실행
            inserted += pstmt.executeBatch().length;
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Connection 종료
                closeConnection();
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // SQL 실행
            pstmt.executeUpdate();
 
            // 입력 건수 조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Connection 종료
                closeConnection();
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
 
    // 데이터 수정 함수
    public int updateBlogArticle(Map<String, Object> dataMap, Map<String, Object> updateMap) throws SQLException {
        // 상수 설정
        //   - 수정할 컬럼을 동적으로 작성하기 위한 SQL 변수
        final StringBuilder sqlBuilder = new StringBuilder();
        //   - PreparedStatement 객체에 데이터를 매핑할 순서를 저장할 변수
        final List<String> updateSeq = new ArrayList<String>();
 
        // 수정일자 추가
        updateMap.put("UPD_DTTM", DATETIME_FMT.format(new Date()));
        
        // 동적 SQL 작성
        sqlBuilder.append("UPDATE CW_BLOG_ATCL_LIST \n");
        sqlBuilder.append("SET ");
        sqlBuilder.append(
            // 수정할 Data를 조회하여 동적 SQL 작성
            updateMap.keySet().stream().reduce("", (prev, current)->{
                // 데이터를 매핑할 순서를 저장
                updateSeq.add(current);
                
                current = current + " = ? ";
                if( !"".equals(prev) ) {
                    prev = prev+", ";
                }
                
                return prev+current+"\n";
            })
        );
        sqlBuilder.append("WHERE 1=1 \n");
        sqlBuilder.append("  AND BLOG_ID = ? \n");
        sqlBuilder.append("  AND CATE_ID = ? \n");
        sqlBuilder.append("  AND ATCL_ID = ? \n");
 
        //   - 최종 SQL
        final String SQL = sqlBuilder.toString();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 수정 결과 변수
        int updated = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
 
            // 수정할 데이터 매핑
            int updateSize = updateSeq.size();
            for(int i=1; i<=updateSize; i++ ) {
                pstmt.setObject(i, updateMap.get(updateSeq.get(i-1)));
            }
 
            // 수정할 데이터 조건 매핑
            pstmt.setObject(updateSize+1, dataMap.get("BLOG_ID"));
            pstmt.setObject(updateSize+2, dataMap.get("CATE_ID"));
            pstmt.setObject(updateSize+3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
    
            // 수정 건수 조회
            updated = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            updated = -1;
            
            // 트랜잭션 ROLLBACK
            conn.rollback();
 
        } finally  {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Connection 종료
                closeConnection();
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 수정된 데이터 건수
        return updated;
    }
 
    // 데이터 삭제 함수
    public int deleteBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "DELETE FROM CW_BLOG_ATCL_LIST  "+"\n"
                         + " WHERE 1=1                     "+"\n"
                         + "   AND BLOG_ID = ?             "+"\n"
                         + "   AND CATE_ID = ?             "+"\n"
                         + "   AND ATCL_ID = ?             "+"\n"
                         ;
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 삭제 결과 변수
        int deleted = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(sql);
 
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
            
            // 데이터 삭제 건수
            deleted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            deleted = -1;
 
            // 트랜잭션 ROLLBACK
            conn.commit();
 
        } finally  {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Connection 종료
                closeConnection();
                
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 삭제된 데이터 건수
        return deleted;
    }
}
 
Colored by Color Scripter
cs

4. DQLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
public class DQLService extends DBManager {
    
    // 생성자
    public DQLService() {
        
    }
    public DQLService(String url) {
        this(url, null, null);
    }
    public DQLService(String url, String username, String password) {
        super(url, username, password);
    }
 
    // 데이터 조회 함수
    public List<Map<String, Object>> selectBlogArticleList(Map<String, Object> dataMap){
        // 상수설정
        //   - SQL
        final String SQL = "SELECT T1.BLOG_ID           "+"\n"
                         + "     , T1.CATE_ID           "+"\n"
                         + "     , T1.ATCL_ID           "+"\n"
                         + "     , T1.TITLE             "+"\n"
                         + "     , T1.URL               "+"\n"
                         + "     , T1.WORK_YN           "+"\n"
                         + "     , T1.REG_DTTM          "+"\n"
                         + "     , T1.UPD_DTTM          "+"\n"
                         + "  FROM CW_BLOG_ATCL_LIST T1 "+"\n"
                         + " WHERE 1=1                  "+"\n"
                         + "   AND T1.BLOG_ID = ?       "+"\n"
                         + "   AND T1.CATE_ID = ?       "+"\n"
                         ;
        
        //   - 조회 결과 변수
        final Set<String> columnNames = new HashSet<String>();        
        final List<Map<String, Object>> selected = new ArrayList<Map<String, Object>>();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
        ResultSetMetaData meta = null;
        
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
            
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            
            // 데이터 조회
            ResultSet rs = pstmt.executeQuery();
            
            // 조회된 데이터의 컬럼명 저장
            meta = pstmt.getMetaData();
            for(int i=1; i<=meta.getColumnCount(); i++) {
                columnNames.add(meta.getColumnName(i));
            }
            
            // ResultSet -> List<Map> 객체
            Map<String, Object> resultMap = null;
            
            while(rs.next()) {
                resultMap = new HashMap<String, Object>();
                
                for(String column : columnNames) {
                    resultMap.put(column, rs.getObject(column));
                }
                
                if( resultMap != null ) {
                    selected.add(resultMap);
                }
            }
            
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
        } finally  {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Database 연결 종료
                closeConnection();
                
            } catch ( SQLException e ) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 조회된 데이터 리스트
        return selected;
    }
 
    // 조회 결과 출력 함수
    public void printMapList(List<Map<String, Object>> mapList) {
        if( mapList.size() == 0 ) {
            System.out.println("조회된 데이터가 없습니다.");
            return;
        }
        
        // 상세 데이터 출력
        System.out.println(String.format("데이터 조회 결과: %d건", mapList.size()));
        
        for(int i = 1; i <= mapList.size(); i++) {
            Map<String, Object> map = mapList.get(i-1);
            
            StringBuilder sb = new StringBuilder();
            
            sb.append(i);
            sb.append(": {");
            map.entrySet().forEach(( entry )->{
                sb.append('"')
                    .append(entry.getKey())
                    .append("\": \"")
                    .append(entry.getValue())
                    .append("\", ");
            });
            sb.append("}");
            
            System.out.println(sb.toString());
        }
    }
}
 
Colored by Color Scripter

cs

5. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:mariadb://localhost:3306/DOCHI", "dochi", "dochi");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:mariadb://localhost:3306/DOCHI", "dochi", "dochi");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:mariadb://localhost:3306/DOCHI", "dochi", "dochi");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     VARCHAR(100)   NOT NULL,           "+"\n"
                         + "  CATE_ID     VARCHAR(50)    NOT NULL,           "+"\n"
                         + "  ATCL_ID     VARCHAR(50)    NOT NULL,           "+"\n"
                         + "  URL         VARCHAR(500)   NOT NULL,           "+"\n"
                         + "  TITLE       VARCHAR(500),                      "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    VARCHAR(14),                       "+"\n"
                         + "  UPD_DTTM    VARCHAR(14),                       "+"\n"
                         + "  PRIMARY KEY (BLOG_ID, CATE_ID, ATCL_ID)       )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 다중 데이터 입력 함수
    public void insertList() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        final List<Map<String, Object>> dataMapList = new ArrayList<Map<String, Object>>();
        
        final Map<String, Object> dataMap1 = new HashMap<String, Object>();
        dataMap1.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap1.put("CATE_ID"   , "/");
        dataMap1.put("ATCL_ID"   , "0");
        dataMap1.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap1.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap1.put("WORK_YN"   , 0);
        dataMapList.add(dataMap1);
 
        final Map<String, Object> dataMap2 = new HashMap<String, Object>();
        dataMap2.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap2.put("CATE_ID"   , "/");
        dataMap2.put("ATCL_ID"   , "1");
        dataMap2.put("URL"       , "https://heodolf.tistory.com/135");
        dataMap2.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (2) - Listener");
        dataMap2.put("WORK_YN"   , 0);
        dataMapList.add(dataMap2);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMapList);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }
    
    // 데이터 수정 함수
    public void update() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        //   - 수정할 데이터
        final Map<String, Object> updateMap = new HashMap<String, Object>();
        updateMap.put("WORK_YN"    , 1);
        updateMap.put("TITLE"    , "원하는 컬럼을 마음대로 수정!");
 
        // 수정 결과 출력
        int updated = DML.updateBlogArticle(dataMap, updateMap);
        if( updated >= 0 ) {
            System.out.println(String.format("데이터 수정 성공: %d건", updated));
        } else {
            System.out.println("데이터 수정 실패");
        }
    }
 
    // 데이터 삭제 함수
    public void delete() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        // 데이터 삭제
        int deleted = DML.deleteBlogArticle(dataMap);
        if( deleted >= 0 ) {
            System.out.println(String.format("데이터 삭제 성공: %d건", deleted));
        } else {
            System.out.println("데이터 삭제 실패");
        }
    }
 
    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();       // 테이블 삭제
        db.createTable();   // 테이블 생성
        
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
        
        db.update();        // 데이터 수정
        db.select();        // 데이터 조회
        
        db.delete();        // 데이터 삭제
        db.select();        // 데이터 조회
        
        db.insertList();    // 다중 데이터 입력
        db.select();        // 데이터 조회
    }
}
 
Colored by Color Scripter

cs

실행결과

[ MariaDB로 접속하여 실행한 결과 ]

마치며

이것으로 SQLite에 접속하여 처리하던 소스를 MariaDB로 변경해보았다. 아주 간단하지 않은가? SQLite는 유저가 필요없어서 처음부터 username과 password를 저장하는 변수를 만들지 않았기 때문에 이를 설정하는 생성자가 추가됨에 따라 DDL, DML, DQL Service 객체에는 이에따른 생성자를 추가해줬을 뿐이다.

그리고, SQLite와 MariaDB의 데이터타입이 다르기 때문에 테이블을 생성할 때, 데이터타입을 변경했다. 처음에는 간단하게 사용하려고 만들었는데 이렇게까지 쓰이게될 줄은 몰랐다. 앞으로 좀 더 보완시켜서 지금 만들고 있는 엔진에 사용해보도록 해야겠다.

[JAVA] SQLite 무작정 시작하기 (7) - 다중 INSERT

허도치 — Sun, 15 Nov 2020 17:19:30 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (4) - SELECT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (5) - UPDATE

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (6) - DELETE

서론

이전에 만들었던 INSERT는 단일 데이터를 입력하는 기능이었는데, 데이터를 입력할 때는 다중으로 입력하는 경우가 많다. 그래서, 이번 포스트에서는 데이터를 다중으로 입력하는 방법에 대해서 다루어볼 계획이다.

소스코드

1. DMLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
public class DMLService extends SQLiteManager {
    
    // 상수 설정
    //   - DateFormat 설정
    private static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    //   - Batch건수 설정
    //     * 100건마다 적재 시도
    private static final int OPT_BATCH_SIZE = 100;
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        super(url);
    }
    
    // 다중 데이터 삽입 함수
    public int insertBlogArticle(List<Map<String, Object>> dataMapList) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
            
            // 입력받은 데이터를 Batch 처리
            for(int i = 0; i < dataMapList.size(); i++ ) {
                // 입력 데이터 객체
                Map<String, Object> dataMap = dataMapList.get(i);
                
                // 입력 데이터 매핑
                pstmt.setObject(1, dataMap.get("BLOG_ID"));
                pstmt.setObject(2, dataMap.get("CATE_ID"));
                pstmt.setObject(3, dataMap.get("ATCL_ID"));
                pstmt.setObject(4, dataMap.get("URL"));
                pstmt.setObject(5, dataMap.get("TITLE"));
                pstmt.setObject(6, dataMap.get("WORK_YN"));
                pstmt.setObject(7, DATETIME_FMT.format(new Date()));
                
                // Batch에 추가
                pstmt.addBatch();
                
                // Batch 실행
                if( i % OPT_BATCH_SIZE == 0 ) {
                    inserted += pstmt.executeBatch().length;
                }
            }
 
            // 입력 건수 조회
            inserted += pstmt.executeBatch().length;
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // SQL 실행
            pstmt.executeUpdate();
 
            // 입력 건수 조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
 
    // 데이터 수정 함수
    public int updateBlogArticle(Map<String, Object> dataMap, Map<String, Object> updateMap) throws SQLException {
        // 상수 설정
        //   - 수정할 컬럼을 동적으로 작성하기 위한 SQL 변수
        final StringBuilder sqlBuilder = new StringBuilder();
        //   - PreparedStatement 객체에 데이터를 매핑할 순서를 저장할 변수
        final List<String> updateSeq = new ArrayList<String>();
 
        // 수정일자 추가
        updateMap.put("UPD_DTTM", DATETIME_FMT.format(new Date()));
        
        // 동적 SQL 작성
        sqlBuilder.append("UPDATE CW_BLOG_ATCL_LIST \n");
        sqlBuilder.append("SET ");
        sqlBuilder.append(
            // 수정할 Data를 조회하여 동적 SQL 작성
            updateMap.keySet().stream().reduce("", (prev, current)->{
                // 데이터를 매핑할 순서를 저장
                updateSeq.add(current);
                
                current = current + " = ? ";
                if( !"".equals(prev) ) {
                    prev = prev+", ";
                }
                
                return prev+current+"\n";
            })
        );
        sqlBuilder.append("WHERE 1=1 \n");
        sqlBuilder.append("  AND BLOG_ID = ? \n");
        sqlBuilder.append("  AND CATE_ID = ? \n");
        sqlBuilder.append("  AND ATCL_ID = ? \n");
 
        //   - 최종 SQL
        final String SQL = sqlBuilder.toString();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 수정 결과 변수
        int updated = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
 
            // 수정할 데이터 매핑
            int updateSize = updateSeq.size();
            for(int i=1; i<=updateSize; i++ ) {
                pstmt.setObject(i, updateMap.get(updateSeq.get(i-1)));
            }
 
            // 수정할 데이터 조건 매핑
            pstmt.setObject(updateSize+1, dataMap.get("BLOG_ID"));
            pstmt.setObject(updateSize+2, dataMap.get("CATE_ID"));
            pstmt.setObject(updateSize+3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
    
            // 수정 건수 조회
            updated = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            updated = -1;
            
            // 트랜잭션 ROLLBACK
            conn.rollback();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 수정된 데이터 건수
        return updated;
    }
 
    // 데이터 삭제 함수
    public int deleteBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "DELETE FROM CW_BLOG_ATCL_LIST  "+"\n"
                         + " WHERE 1=1                     "+"\n"
                         + "   AND BLOG_ID = ?             "+"\n"
                         + "   AND CATE_ID = ?             "+"\n"
                         + "   AND ATCL_ID = ?             "+"\n"
                         ;
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 삭제 결과 변수
        int deleted = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(sql);
 
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
            
            // 데이터 삭제 건수
            deleted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            deleted = -1;
 
            // 트랜잭션 ROLLBACK
            conn.commit();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 삭제된 데이터 건수
        return deleted;
    }
}



 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY (BLOG_ID, CATE_ID, ATCL_ID)       )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 다중 데이터 입력 함수
    public void insertList() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        final List<Map<String, Object>> dataMapList = new ArrayList<Map<String, Object>>();
        
        final Map<String, Object> dataMap1 = new HashMap<String, Object>();
        dataMap1.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap1.put("CATE_ID"   , "/");
        dataMap1.put("ATCL_ID"   , "0");
        dataMap1.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap1.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap1.put("WORK_YN"   , 0);
        dataMapList.add(dataMap1);
 
        final Map<String, Object> dataMap2 = new HashMap<String, Object>();
        dataMap2.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap2.put("CATE_ID"   , "/");
        dataMap2.put("ATCL_ID"   , "1");
        dataMap2.put("URL"       , "https://heodolf.tistory.com/135");
        dataMap2.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (2) - Listener");
        dataMap2.put("WORK_YN"   , 0);
        dataMapList.add(dataMap2);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMapList);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }
    
    // 데이터 수정 함수
    public void update() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        //   - 수정할 데이터
        final Map<String, Object> updateMap = new HashMap<String, Object>();
        updateMap.put("WORK_YN"    , 1);
        updateMap.put("TITLE"    , "원하는 컬럼을 마음대로 수정!");
 
        // 수정 결과 출력
        int updated = DML.updateBlogArticle(dataMap, updateMap);
        if( updated >= 0 ) {
            System.out.println(String.format("데이터 수정 성공: %d건", updated));
        } else {
            System.out.println("데이터 수정 실패");
        }
    }
 
    // 데이터 삭제 함수
    public void delete() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        // 데이터 삭제
        int deleted = DML.deleteBlogArticle(dataMap);
        if( deleted >= 0 ) {
            System.out.println(String.format("데이터 삭제 성공: %d건", deleted));
        } else {
            System.out.println("데이터 삭제 실패");
        }
    }
 
    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();       // 테이블 삭제
        db.createTable();   // 테이블 생성
        
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
        
        db.update();        // 데이터 수정
        db.select();        // 데이터 조회
        
        db.delete();        // 데이터 삭제
        db.select();        // 데이터 조회
        
        db.insertList();    // 다중 데이터 입력
        db.select();        // 데이터 조회
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 다중 데이터 삽입 실행 결과 ]

마치며

이것으로 간단하게 다중 INSERT를 구현해보았으며, 이것으로 SQLite 사용법을 모두 정리해보았다. 사실 SQLite라기 보다는 java.sql 객체를 이용한 SQLite 사용법이 더 정확하다고 할 수 있다. 왜냐하면, 이렇게 구현한 소스에서 접속 정보나 테이블 생성 정보만 바꾸면, MySQL, MariaDB, Oracle 등에도 적용할 수 있기 때문이다.

다음 포스트에서 지금까지 만든 소스를 MariaDB로 바꿔서 실행해 보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 (6) - DELETE

허도치 — Sun, 15 Nov 2020 15:48:44 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (4) - SELECT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (5) - UPDATE

서론

자 이번에는 CRUD(Create Read Update Delete)의 마지막인 DELETE를 구해보도록 하겠다.

소스코드

1. DMLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
public class DMLService extends SQLiteManager {
    
    // 상수 설정
    //   - DateFormat 설정
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        super(url);
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // SQL 실행
            pstmt.executeUpdate();
 
            // 입력 건수 조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
 
    // 데이터 수정 함수
    public int updateBlogArticle(Map<String, Object> dataMap, Map<String, Object> updateMap) throws SQLException {
        // 상수 설정
        //   - 수정할 컬럼을 동적으로 작성하기 위한 SQL 변수
        final StringBuilder sqlBuilder = new StringBuilder();
        //   - PreparedStatement 객체에 데이터를 매핑할 순서를 저장할 변수
        final List<String> updateSeq = new ArrayList<String>();
 
        // 수정일자 추가
        updateMap.put("UPD_DTTM", DATETIME_FMT.format(new Date()));
        
        // 동적 SQL 작성
        sqlBuilder.append("UPDATE CW_BLOG_ATCL_LIST \n");
        sqlBuilder.append("SET ");
        sqlBuilder.append(
            // 수정할 Data를 조회하여 동적 SQL 작성
            updateMap.keySet().stream().reduce("", (prev, current)->{
                // 데이터를 매핑할 순서를 저장
                updateSeq.add(current);
                
                current = current + " = ? ";
                if( !"".equals(prev) ) {
                    prev = prev+", ";
                }
                
                return prev+current+"\n";
            })
        );
        sqlBuilder.append("WHERE 1=1 \n");
        sqlBuilder.append("  AND BLOG_ID = ? \n");
        sqlBuilder.append("  AND CATE_ID = ? \n");
        sqlBuilder.append("  AND ATCL_ID = ? \n");
 
        //   - 최종 SQL
        final String SQL = sqlBuilder.toString();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 수정 결과 변수
        int updated = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
 
            // 수정할 데이터 매핑
            int updateSize = updateSeq.size();
            for(int i=1; i<=updateSize; i++ ) {
                pstmt.setObject(i, updateMap.get(updateSeq.get(i-1)));
            }
 
            // 수정할 데이터 조건 매핑
            pstmt.setObject(updateSize+1, dataMap.get("BLOG_ID"));
            pstmt.setObject(updateSize+2, dataMap.get("CATE_ID"));
            pstmt.setObject(updateSize+3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
    
            // 수정 건수 조회
            updated = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            updated = -1;
            
            // 트랜잭션 ROLLBACK
            conn.rollback();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 수정된 데이터 건수
        return updated;
    }
 
    // 데이터 삭제 함수
    public int deleteBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "DELETE FROM CW_BLOG_ATCL_LIST  "+"\n"
                         + " WHERE 1=1                     "+"\n"
                         + "   AND BLOG_ID = ?             "+"\n"
                         + "   AND CATE_ID = ?             "+"\n"
                         + "   AND ATCL_ID = ?             "+"\n"
                         ;
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 삭제 결과 변수
        int deleted = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(sql);
 
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
            
            // 데이터 삭제 건수
            deleted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            deleted = -1;
 
            // 트랜잭션 ROLLBACK
            conn.commit();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 삭제된 데이터 건수
        return deleted;
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY(BLOG_ID, CATE_ID, ATCL_ID)        )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }
    
    // 데이터 수정 함수
    public void update() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        //   - 수정할 데이터
        final Map<String, Object> updateMap = new HashMap<String, Object>();
        updateMap.put("WORK_YN"    , 1);
        updateMap.put("TITLE"    , "원하는 컬럼을 마음대로 수정!");
 
        // 수정 결과 출력
        int updated = DML.updateBlogArticle(dataMap, updateMap);
        if( updated >= 0 ) {
            System.out.println(String.format("데이터 수정 성공: %d건", updated));
        } else {
            System.out.println("데이터 수정 실패");
        }
    }
 
    // 데이터 삭제 함수
    public void delete() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        // 데이터 삭제
        int deleted = DML.deleteBlogArticle(dataMap);
        if( deleted >= 0 ) {
            System.out.println(String.format("데이터 삭제 성공: %d건", deleted));
        } else {
            System.out.println("데이터 삭제 실패");
        }
    }


    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();       // 테이블 삭제
        db.createTable();   // 테이블 생성
        
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
        
        db.update();        // 데이터 수정
        db.select();        // 데이터 조회
        
        db.delete();        // 데이터 삭제
        db.select();        // 데이터 조회
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 데이터 삭제 실행 결과 ]

마치며

이번 포스트를 마지막으로 SQLite로 데이터베이스와 테이블을 생성하고, CRUD를 구현해보았다. 소스가 점점 길어져서 추가한 부분만 따로 작성할까 했는데, 역시 소스가 통째로 있어야 실제로 필요할 때 바로 적용해 볼 수 있고 전체 흐름을 파악하는데 더 좋을것 같아서 이전 소스들과 함께 작성하였다.

다음 포스트에서는 SQLite의 마지막 포스트로써 데이터를 삽입할 때, 여러개를 한번에 입력하는 방법에 대해서 다루어 보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 (5) - UPDATE

허도치 — Sun, 15 Nov 2020 15:29:27 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (4) - SELECT

서론

지금까지 데이터베이스와 테이블을 생성하고, 데이터를 입력하고 조회까지 해보았다. 여기까지만 있어도 사실 원래 목표했던 크롤러 스케줄러에 충분히 적용이 가능하지만, 확장성을 위해 데이터의 수정과 삭제까지 구현을 해보려고 한다. 그래서, 이번 포스트에서는 지난 포스트에 이어서 데이터를 수정하는 UPDATE를 구현해보려고 한다.

소스코드

1. DMLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
public class DMLService extends SQLiteManager {
    
    // 상수 설정
    //   - DateFormat 설정
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        super(url);
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // 쿼리 실행
            pstmt.executeUpdate();
 
            // 입력건수 조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
            
            // 오류
            inserted = -1;
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
 
    // 데이터 수정 함수
    public int updateBlogArticle(Map<String, Object> dataMap, Map<String, Object> updateMap) throws SQLException {
        // 상수 설정
        //   - 수정할 컬럼을 동적으로 작성하기 위한 SQL 변수
        final StringBuilder sqlBuilder = new StringBuilder();
        //   - PreparedStatement 객체에 데이터를 매핑할 순서를 저장할 변수
        final List<String> updateSeq = new ArrayList<String>();
 
        // 수정일자 추가
        updateMap.put("UPD_DTTM", DATETIME_FMT.format(new Date()));
        
        // 동적 SQL 작성
        sqlBuilder.append("UPDATE CW_BLOG_ATCL_LIST \n");
        sqlBuilder.append("SET ");
        sqlBuilder.append(
            // 수정할 Data를 조회하여 동적 SQL 작성
            updateMap.keySet().stream().reduce("", (prev, current)->{
                // 데이터를 매핑할 순서를 저장
                updateSeq.add(current);
                
                current = current + " = ? ";
                if( !"".equals(prev) ) {
                    prev = prev+", ";
                }
                
                return prev+current+"\n";
            })
        );
        sqlBuilder.append("WHERE 1=1 \n");
        sqlBuilder.append("  AND BLOG_ID = ? \n");
        sqlBuilder.append("  AND CATE_ID = ? \n");
        sqlBuilder.append("  AND ATCL_ID = ? \n");
 
        //   - 최종 SQL
        final String SQL = sqlBuilder.toString();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 수정 결과 변수
        int updated = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
 
            // 수정할 데이터 매핑
            int updateSize = updateSeq.size();
            for(int i=1; i<=updateSize; i++ ) {
                pstmt.setObject(i, updateMap.get(updateSeq.get(i-1)));
            }
 
            // 수정할 데이터 조건 매핑
            pstmt.setObject(updateSize+1, dataMap.get("BLOG_ID"));
            pstmt.setObject(updateSize+2, dataMap.get("CATE_ID"));
            pstmt.setObject(updateSize+3, dataMap.get("ATCL_ID"));
 
            // 쿼리 실행
            pstmt.executeUpdate();
    
            // 수정 건수 조회
            updated = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            updated = -1;
            
            // 트랜잭션 ROLLBACK
            conn.rollback();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 수정된 데이터 건수
        return updated;
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY(BLOG_ID, CATE_ID, ATCL_ID)        )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }
    
    // 데이터 수정 함수
    public void update() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        //   - 수정할 데이터
        final Map<String, Object> updateMap = new HashMap<String, Object>();
        updateMap.put("WORK_YN"    , 1);
        updateMap.put("TITLE"    , "원하는 컬럼을 마음대로 수정!");
 
        // 수정 결과 출력
        int updated = DML.updateBlogArticle(dataMap, updateMap);
        if( updated >= 0 ) {
            System.out.println(String.format("데이터 수정 성공: %d건", updated));
        } else {
            System.out.println("데이터 수정 실패");
        }
    }


    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();       // 테이블 삭제
        db.createTable();   // 테이블 생성
        
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
        
        db.update();        // 데이터 수정
        db.select();        // 데이터 조회
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 데이터 수정 실행 결과 ]

- UPD_DTTM이 "null"에서 "20201115152304" 로 수정됨.

- WORK_YN이 "0"에서 "1"로 수정됨.

마치며

이번 포스트에서는 데이터를 수정하는 방법을 다루어보았는데, 동적 SQL로 만들다 보니 다소 복잡해 보일 수 있다. 하지만, 그냥 쭉 살펴보면 Map을 Key, Value로 분해해서 SET에 들어갈 문장을 만들어 준것이다. 이 부분이 복잡하다면, 수정할 컬럼을 미리 정의해놓고 필요한 값만 입력받아서 사용하는 것도 방법이다.

[JAVA] SQLite 무작정 시작하기 (4) - SELECT

허도치 — Sun, 15 Nov 2020 14:51:25 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

서론

이전 포스트에서 데이터를 테이블에 입력하였는데, 실제 데이터가 들어가 있는지 확인해보진 않았다. 그래서, 이번 포스트에서는 실제 적재되어 있는 데이터를 조회하여 출력하는 방법에 대해서 다루어 보도록 하겠다.

소스코드

1. DQLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
public class DQLService extends SQLiteManager {
    
    // 생성자
    public DQLService() {
        
    }
    public DQLService(String url) {
        super(url);
    }
 
    // 데이터 조회 함수
    public List<Map<String, Object>> selectBlogArticleList(Map<String, Object> dataMap){
        // 상수설정
        //   - SQL
        final String SQL = "SELECT T1.BLOG_ID           "+"\n"
                         + "     , T1.CATE_ID           "+"\n"
                         + "     , T1.ATCL_ID           "+"\n"
                         + "     , T1.TITLE             "+"\n"
                         + "     , T1.URL               "+"\n"
                         + "     , T1.WORK_YN           "+"\n"
                         + "     , T1.REG_DTTM          "+"\n"
                         + "     , T1.UPD_DTTM          "+"\n"
                         + "  FROM CW_BLOG_ATCL_LIST T1 "+"\n"
                         + " WHERE 1=1                  "+"\n"
                         + "   AND T1.BLOG_ID = ?       "+"\n"
                         + "   AND T1.CATE_ID = ?       "+"\n"
                         ;
        
        //   - 조회 결과 변수
        final Set<String> columnNames = new HashSet<String>();        
        final List<Map<String, Object>> selected = new ArrayList<Map<String, Object>>();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
        ResultSetMetaData meta = null;
        
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
            
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            
            // 데이터 조회
            ResultSet rs = pstmt.executeQuery();
            
            // 조회된 데이터의 컬럼명 저장
            meta = pstmt.getMetaData();
            for(int i=1; i<=meta.getColumnCount(); i++) {
                columnNames.add(meta.getColumnName(i));
            }
            
            // ResultSet -> List<Map> 객체
            Map<String, Object> resultMap = null;
            
            while(rs.next()) {
                resultMap = new HashMap<String, Object>();
                
                for(String column : columnNames) {
                    resultMap.put(column, rs.getObject(column));
                }
                
                if( resultMap != null ) {
                    selected.add(resultMap);
                }
            }
            
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
        } finally  {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Database 연결 종료
                closeConnection();
                
            } catch ( SQLException e ) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 조회된 데이터 리스트
        return selected;
    }
 
    // 조회 결과 출력 함수
    public void printMapList(List<Map<String, Object>> mapList) {
        if( mapList.size() == 0 ) {
            System.out.println("조회된 데이터가 없습니다.");
            return;
        }
        
        // 상세 데이터 출력
        System.out.println(String.format("데이터 조회 결과: %d건", mapList.size()));
        
        for(int i = 1; i <= mapList.size(); i++) {
            Map<String, Object> map = mapList.get(i-1);
            
            StringBuilder sb = new StringBuilder();
            
            sb.append(i);
            sb.append(": {");
            map.entrySet().forEach(( entry )->{
                sb.append('"')
                    .append(entry.getKey())
                    .append("\": \"")
                    .append(entry.getValue())
                    .append("\", ");
            });
            sb.append("}");
            
            System.out.println(sb.toString());
        }
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY(BLOG_ID, CATE_ID, ATCL_ID)        )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }


    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();     // 테이블 삭제
        db.createTable();   // 테이블 생성
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
    }
}
 
Colored by Color Scripter

cs

실행결과

마치며

이렇게 데이터를 입력하고 조회까지 만들어보니 어느정도 Database의 구색이 갖춰진것 같다. 하지만, 아직 우리에겐 UPDATE와 DELETE가 남아있다. 다음 포스트에서 하나 하나 다뤄보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 (3) - INSERT

허도치 — Sun, 15 Nov 2020 14:34:22 +0900

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

서론

이전 포스트에서 테이블을 생성하고 삭제하는 방법에 대해서 알아보았다. 이번 포스트에서는 데이터를 생성하는 방법에 대해서 알아보도록 하겠다.

소스코드

1. DMLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
 
public class DMLService extends SQLiteManager {
    
    // 상수 설정
    //   - DateFormat 설정
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        super(url);
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // 쿼리 실행
            pstmt.executeUpdate();
 
            // 입력건수  조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
            
            // 오류
            inserted = -1;
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY (BLOG_ID, CATE_ID, ATCL_ID)       )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
 
    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();     // 테이블 삭제
        db.createTable();   // 테이블 생성
        db.insert();        // 데이터 입력
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 데이터 입력 결과 ]

마치며

여기까지 간단하게 데이터를 입력하는 방법에 대해서 다루어보았다. 다음 포스트에서는 입력된 데이터를 조회하는 방법에 대해서 다루어 보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

허도치 — Sun, 15 Nov 2020 01:50:52 +0900

이전글 목록

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

서론

이전 포스트에서는 SQLite에 대해서 간단하게 알아보고 DATABASE에 접속/해제하는 방법을 다루어 보았다. 이번 포스트에서는 실제 데이터를 저장할 테이브를 생성하고 삭제하는 방법에 대해서 다루어 볼 계획이다.

데이터베이스 인코딩 (UTF-8, UTF-16BE 또는 UTF-16LE)을 사용하여 저장

SQLite 데이터타입

데이터타입	설명
NULL	NULL 값
INTEGER	부호가 있는 정수, 값의 크기에 따라 1, 2, 3, 4, 6 또는 8 바이트로 저장
REAL	부동 소수점 숫자, 8 바이트로 저장
TEXT	텍스트 문자열, 데이터베이스 인코딩 (UTF-8, UTF-16BE 또는 UTF-16LE)을 사용하여 저장
BLOB (Binary Large OBject)	입력된 데이터를 그대로 저장

소스코드

1. DDLService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class DDLService extends SQLiteManager {
    // 생성자
    public DDLService() {
    }
    public DDLService(String url) {
        super(url);
    }
 
    // SQL 실행 함수
    public ResultType executeSQL(final String SQL) throws SQLException {
        // 변수설정
        //   - Database 변수
        Connection conn = null;
        Statement stmt = null;
 
        //   - 결과 변수
        ResultType result = ResultType.FAILURE;
 
        try {
            // Database 연결
            conn = ensureConnection();
 
            // Statement 객체  생성
            stmt = conn.createStatement();
 
            // SQL 실행
            stmt.execute(SQL);
 
            // 트랜잭션 COMMIT
            conn.commit();
 
            // 성공
            result = ResultType.SUCCESS;
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
 
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
            // 오류
            result = ResultType.FAILURE;
 
        } finally {
            // Statement 종료
            if( stmt != null ) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        return result;
    }
 
    // 테이블 조회 함수
    public boolean checkTable(String tableName) throws SQLException {
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        DatabaseMetaData meta = conn.getMetaData();
 
        // 테이블 목록 조회
        ResultSet tables = meta.getTables(null, null, tableName, null);
 
        // 테이블 생성 확인
        return ( tables.next() ? tables.getRow() != 0 : false );
    }
 
    // 테이블 생성 함수
    public ResultType createTable(String tableName, final String SQL) throws SQLException {
        // 테이블 확인
        if( checkTable(tableName) ) {
            return ResultType.WARNING;
        }
 
        // SQL 실행 및 반환
        return executeSQL(SQL);
    }
 
    // 테이블 삭제 함수
    public ResultType dropTable(String tableName) throws SQLException {
        // 테이블 확인
        if( !checkTable(tableName) ) {
            return ResultType.WARNING;
        }
 
        // SQL 실행 및 반환
        return executeSQL("DROP TABLE IF EXISTS "+tableName);
    }
 
    // 결과 코드 정의
    public enum ResultType {
        SUCCESS(1),     // 성공
        WARNING(0),     // 경고
        FAILURE(-1);    // 실패
 
        // 코드 변수
        private int code = 0;
 
        // 코드값 설정
        private ResultType(int code){
            this.code = code;
        }
 
        // 코드값 가져오기
        public int getCode() {
            return this.code;
        }
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package com.dochi.db.ex;
 
import java.sql.SQLException;
 
import com.dochi.db.ex.DDLService;
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        //
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY (BLOG_ID, CATE_ID, ARTCL_ID)      )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();     // 테이블 삭제
        db.createTable();   // 테이블 생성
        db.createTable();   // 테이블 생성
        db.dropTable();     // 테이블 삭제
    }
}
 
Colored by Color Scripter

cs

실행결과

[ 테이블 생성/삭제 실행 로그 ]

마치며

이렇게 테이블을 생성해보았다. 나중에 Crawler에서 사용하기위해 예제에서 아예 테이블 구조도 잡아서 만들어봤다. 다음 포스트에서는 CRUD(Create Read Update Delete)에 대해서 다루어 보려고 한다. 소스를 한번에 다 다루게되면 포스트가 너무 길어질것 같으니 각각 하나씩 포스팅 해보도록 하겠다.

[JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

허도치 — Sun, 15 Nov 2020 01:22:55 +0900

서론

이번에 Quartz로 Crawler 스케줄러를 만들면서 수집한 데이터를 저장하고 이력을 관리하기위한 저장소가 필요했다. Oracle, MariaDB, MongoDB 등 다양한 선택지가 있었지만, 필요할 때마다 서버를 실행해야하는 번거로움이 있었다. 그래서, Serverless의 SQLite를 써보기로 하였다.

SQLite란?

경량 RDBMS 라이브러리이며, 별도로 설치할 필요가 없고 프로그램 내에 자체포함되어 서버가 필요한 MySQL, PostgreSQL와는 달리 서버가 필요 없다. 또한, 기본적으로는 DB가 파일로 생성되지만, DB를 메모리에 생성하여 작업을 매우 빠르게 처리할 수 있다.

개발환경

1. JAVA 버전

- jdk-11.0.5

2. pom.xml

1
2
3
4
5
6
7

<!-- JDBC Drivers -->
<dependency>
  <groupId>org.xerial</groupId>
  <artifactId>sqlite-jdbc</artifactId>
  <version>3.27.2.1</version>
</dependency>
<!-- JDBC Drivers -->

cs

소스코드

1. SQLiteManager.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
 
public class SQLiteManager {
 
    // 상수 설정
    //   - Database 변수
    private static final String SQLITE_JDBC_DRIVER = "org.sqlite.JDBC";
    private static final String SQLITE_FILE_DB_URL = "jdbc:sqlite:quartz.db";
    private static final String SQLITE_MEMORY_DB_URL = "jdbc:sqlite::memory";
 
    //  - Database 옵션 변수
    private static final boolean OPT_AUTO_COMMIT = false;
    private static final int OPT_VALID_TIMEOUT = 500;
 
    // 변수 설정
    //   - Database 접속 정보 변수
    private Connection conn = null;
    private String driver = null;
    private String url = null;
 
    // 생성자
    public SQLiteManager(){
        this(SQLITE_FILE_DB_URL);
    }
    public SQLiteManager(String url) {
        // JDBC Driver 설정
        this.driver = SQLITE_JDBC_DRIVER;
        this.url = url;
    }
 
    // DB 연결 함수
    public Connection createConnection() {
        try {
            // JDBC Driver Class 로드
            Class.forName(this.driver);
 
            // DB 연결 객체 생성
            this.conn = DriverManager.getConnection(this.url);
 
            // 로그 출력
            System.out.println("CONNECTED");
 
            // 옵션 설정
            //   - 자동 커밋
            this.conn.setAutoCommit(OPT_AUTO_COMMIT);
 
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
 
        return this.conn;
    }
 
    // DB 연결 종료 함수
    public void closeConnection() {
        try {
            if( this.conn != null ) {
                this.conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            this.conn = null;
 
            // 로그 출력
            System.out.println("CLOSED");
        }
    }
 
    // DB 재연결 함수
    public Connection ensureConnection() {
        try {
            if( this.conn == null || this.conn.isValid(OPT_VALID_TIMEOUT) ) {
                closeConnection();      // 연결 종료
                createConnection();     // 연결
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
 
        return this.conn;
    }
 
    // DB 연결 객체 가져오기
    public Connection getConnection() {
        return this.conn;
    }
}
 
Colored by Color Scripter

cs

2. App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.dochi.db.ex;
 
import java.sql.SQLException;
 
import com.dochi.db.ex.DDLService;
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    public static void main(String[] args) throws SQLException {
        SQLiteManager manager = new SQLiteManager();
 
        manager.createConnection();     // 연결
        manager.closeConnection();      // 연결 해제
        manager.ensureConnection();     // 재연결
    }
}
 
Colored by Color Scripter

cs

실행결과

[ DATABASE 파일 생성 확인 ]

[ SQLite 접속 로그 ]

마치며

확실히 다른 RDBMS를 쓸 때보다 가볍고, 사용하기 편했다. 앞으로는 간단하게 DB를 써야할 일이 있으면 SQLite를 사용해봐야겠다. 다음 포스트에서는 테이블을 생성하고 삭제하는 방법에 대해서 알아보도록 하겠다.

[JAVA] Quartz 스케줄러 만들기 (5) - Crawler Job

허도치 — Thu, 12 Nov 2020 00:43:06 +0900

서론

이번 포스트에서는 드디어 스케줄러에 Crawler를 적용해보려고 한다. 기존 예제들은 주로 스케줄러를 설정했었다면, 이번 시간에는 실제 스케줄에 맞춰서 실제 실행되는 작업을 구현할 계획이다. 예제니까 간단하게 현재 블로그의 전체 글목록을 조회하는 Crawler를 만들 계획이며, Jsoup 라이브러리를 이용하려고 한다.

개발환경

- jdk-11.0.5
- quartz-2.3.2

- jsoup-1.11.3

<!-- Scheduler -->
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.3.2</version>
</dependency>
<!-- Scheduler -->

<!-- Crawler -->
<dependency>
  <groupId>org.jsoup</groupId>
  <artifactId>jsoup</artifactId>
  <version>1.11.3</version>
</dependency>
<!-- Crawler -->

<!-- Logging -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
</dependency>
<!-- Logging -->

소스코드

1. CrawlerJob.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

package com.dochi.quartz.crawl;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
 
import com.dochi.quartz.step.JobLauncher;
 
 
public class CrawlerJob implements InterruptableJob {
 
    private Thread currentThread = null;
    private final String URL = "https://heodolf.tistory.com/";
 
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 현재 Thread 저장
        this.currentThread = Thread.currentThread();
 
        System.out.println(String.format("[%s][%s][%s] START"
                , JobLauncher.TIMESTAMP_FMT.format(new Date())
                , this.getClass().getName()
                , context.getJobDetail().getKey().getName()));
 
        // 페이지 정보 수집
        int startPage = 1;
        int endPage = getEndPage();
 
        // 페이지별로 글목록 수집
        List<Map<String, String>> postList = new ArrayList<Map<String, String>>();
        for(int page=endPage; page>=startPage; page--) {
            postList.addAll(getAritcleList(URL+"?page="+page));
        }
 
        System.out.println(String.format("[%s][%s] - 조회 완료 ( %d건 )"
                , JobLauncher.TIMESTAMP_FMT.format(new Date())
                , this.getClass().getName()
                , postList.size()));
        System.out.println(String.format("[%s][%s][%s] END"
                , JobLauncher.TIMESTAMP_FMT.format(new Date())
                , this.getClass().getName()
                , context.getJobDetail().getKey().getName()));
    }
 
    @Override
    public void interrupt() throws UnableToInterruptJobException {
        // interrupt 설정
        //   - 강제종료
        if( this.currentThread != null ) {
            this.currentThread.interrupt();
        }
    }
 
    // 마지막 페이지를 가지고 오는 함수
    private int getEndPage() {
 
        int lastPage = 1;
 
        try {
            // 크롤링
            Document document = Jsoup.connect(URL).get();
 
            // 마지막 페이지를 가진 Element 탐색
            Element element = document.select(".pagination > a[href]:not([class])").last();
 
            // 마지막 페이지 파싱
            lastPage = Integer.valueOf(element.attr("href").split("=")[1]);
 
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        return lastPage;
    }
 
    // 글목록을 가지고 오는 함수
    private List<Map<String, String>> getAritcleList(String url) {
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
 
        try {
            // 크롤링
            Document document = Jsoup.connect(url).get();
 
            // 마지막 페이지를 가진 Element 탐색
            Elements elements = document.select("div.post-item");
 
            // 글목록 파싱
            elements.forEach((element)->{
                Map<String, String> postMap = new HashMap<String, String>();
 
                // Element 탐색
                Element child = element.selectFirst("a[href]");
 
                // 데이터 추출
                String postId = child.attr("href");
                String title = child.selectFirst("span.title").text();
                String meta = child.selectFirst("span.meta").text();
 
                if( postId.startsWith("/") ) {
                    postId = postId.substring(1, postId.length());
                }
 
                // 데이터 저장
                postMap.put("url", URL+postId);
                postMap.put("title", title);
                postMap.put("meta", meta);
 
                // 리스트에 추가
                list.add(postMap);
 
                System.out.println(postMap.toString());
            });
 
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        return list;
    }
}
 
Colored by Color Scripter

cs

2. JobLauncher.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

package com.dochi.quartz.crawl;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Set;
 
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.UnableToInterruptJobException;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
 
public class JobLauncher {
 
    // 상수 설정
    //   - Prefix 설정
    public static final String PREFIX_STEP_JOB_NAME = "job_";
    public static final String PREFIX_STEP_TRIGGER_NAME = "trigger_";
    public static final String PREFIX_NEXT_STEP_JOB_NAME = "step_job_";
    public static final String PREFIX_NEXT_STEP_TRIGGER_NAME = "step_trigger_";
 
    //   - DateFormat 설정
    public static final SimpleDateFormat TIMESTAMP_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    //   - JobDataMap에서 사용할 Key 정의
    public static final String MAIN_STEP_JOB_NAME = "mainStepJobName";
    public static final String NEXT_STEP_CLASS_NAME = "nextStepClassName";
    public static final String NEXT_STEP_JOB_NAME = "nextStepJobName";
 
    // Scheduler 객체 생성
    private static SchedulerFactory factory = null;
    private static Scheduler scheduler = null;
 
    // Main 함수
    public static void main(String[] args) throws SchedulerException {
        // Scheduler 실행
        start();
 
        // Schedule 등록
        addSchedule("CrawlerJob");
 
        try {
            System.out.println("아무키나 입력하면 종료됩니다...");
            System.in.read();
 
            // Scheduler 롱료
            stop();
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    // Scheduler 실행 함수
    public static void start() throws SchedulerException {
        // Scheduler 객체 정의
        factory = new StdSchedulerFactory();
        scheduler = factory.getScheduler();
 
        // Scheduler 실행
        scheduler.start();
    }
 
    // Scheduler 종료 함수
    public static void stop() throws SchedulerException {
        try {
            System.out.println("스케줄러가 종료됩니다...");
 
            // Job Key 목록
            Set<JobKey> allJobKeys = scheduler.getJobKeys(GroupMatcher.anyGroup());
 
            // Job 강제 중단
            allJobKeys.forEach((jobKey)->{
                try {
                    scheduler.interrupt(jobKey);
                } catch (UnableToInterruptJobException e) {
                    e.printStackTrace();
                }
            });
 
            // Scheduler 중단
            //   - true : 모든 Job이  완료될 때까지 대기 후 종료
            //   - false: 즉시 종료
            scheduler.shutdown(true);
 
            System.out.println("스케줄러가 종료되었습니다.");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
 
    // Schedule 등록 함수
    public static void addSchedule(String name) throws SchedulerException {
        // JobDetail 설정
        JobDetail jobDetail = JobBuilder.newJob(CrawlerJob.class)
                                .withIdentity(PREFIX_STEP_JOB_NAME+name)
                                .build();
 
        // Schedule 생성
        //   - 5분마다 반복, 최대 3회
        SimpleScheduleBuilder schedule = SimpleScheduleBuilder.simpleSchedule()
                                            .withRepeatCount(3)
                                            .withIntervalInMinutes(5);
 
        // Trigger 설정
        Trigger trigger = TriggerBuilder.newTrigger()
                              .withIdentity(PREFIX_STEP_TRIGGER_NAME+name)
                              .withSchedule(schedule)
                              .forJob(jobDetail)
                              .build();
 
        // Schedule 등록
        scheduler.scheduleJob(jobDetail, trigger);
    }
}
 
Colored by Color Scripter

cs

실행결과

- 현재 블로그에 노출되는 모든 글의 제목, 작성일, URL을 수집

- 5분마다 2번 반복

마치며

드디어 크롤러를 스케줄에 따라 자동으로 수집하도록 설정하였다. 예제는 간단하게 만드느라 단순히 글 목록을 수집하고 출력하는 기능만 구현하였지만, 실사용하려면 저장소에 데이터를 보관하고 같은 데이터를 다시 수집하지 않도록해주는 설정이 필요할 것이다.

[JAVA] Quartz 스케줄러 만들기 (4) - Step By Step

허도치 — Wed, 11 Nov 2020 17:59:14 +0900

서론

지난 포스트에서 Scheduler에 Listener를 적용했었는데, 로그를 출력하는것 외에는 활용하지 못했었다. 그러다가, Spring Batch의 Step처럼 하나의 작업이 끝나면 설정된 다음 작업으로 이어질 수 있도록 연결해보면 좋을것 같다는 생각이들었다.

그래서, 이번 포스트에서는 JobListener를 이용하여 Job을 순차적으로 실행시켜 보도록하겠다.

개발환경

- jdk-11.0.5
- quartz-2.3.2

<!-- Scheduler -->
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.3.2</version>
</dependency>
<!-- Scheduler -->
<!-- Logging -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
</dependency>
<!-- Logging -->

소스코드

1. MainJob.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package com.dochi.quartz.step;
 
import java.util.Date;
 
import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
 
 
public class MainJob implements InterruptableJob {
    
    private Thread currentThread = null;
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        String jobName = context.getJobDetail().getKey().getName();
        
        System.out.println(String.format("[%s][%s][%s] START", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
        
        // 현재 Thread 저장
        this.currentThread = Thread.currentThread();
        
        try {
            // 강제로 종료를 지연시키기
            for(int i=1; i<=5; i++) {
                System.out.println(String.format("[%s][%s][%s] 작업중...", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
                Thread.sleep(1*1000L);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("[%s][%s][%s] END", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
    }
 
    @Override
    public void interrupt() throws UnableToInterruptJobException {
        // interrupt 설정
        //   - 강제종료
        if( this.currentThread != null ) {
            this.currentThread.interrupt();
        }
    }
}
 
Colored by Color Scripter

cs

2. SubJob.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package com.dochi.quartz.step;
 
import java.util.Date;
 
import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
 
 
public class SubJob implements InterruptableJob {
    
    private Thread currentThread = null;
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        String jobName = context.getJobDetail().getKey().getName();
        
        System.out.println(String.format("[%s][%s][%s] START", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
        
        // 현재 Thread 저장
        this.currentThread = Thread.currentThread();
        
        try {
            // 강제로 종료를 지연시키기
            for(int i=1; i<=5; i++) {
                System.out.println(String.format("[%s][%s][%s] 작업중...", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
                Thread.sleep(1*1000L);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("[%s][%s][%s] END", JobLauncher.TIMESTAMP_FMT.format(new Date()), this.getClass().getName(), jobName));
    }
 
    @Override
    public void interrupt() throws UnableToInterruptJobException {
        // interrupt 설정
        //   - 강제종료
        if( this.currentThread != null ) {
            this.currentThread.interrupt();
        }
    }
}
 
Colored by Color Scripter

cs

3. JobStepListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

package com.dochi.quartz.step;
 
import java.util.Date;
import java.util.UUID;
 
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
 
 
public class JobStepListener implements JobListener {
    
    @Override
    public String getName() {
        return this.getClass().getName();
    }
 
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][jobToBeExecuted]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][jobExecutionVetoed]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        System.out.println(String.format("[%s][%s][jobWasExecuted] START", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
        
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        try {
            // JobDataMapp에 Next Step이 등록된 경우 스케줄 생성
            if( jobDataMap.containsKey(JobLauncher.NEXT_STEP_CLASS_NAME) ) {
                System.out.println("Add next step schedule...");
                addNextStepSchedule(context);
            }
        } catch (ClassNotFoundException | SchedulerException e) {
            e.printStackTrace();
        }
        
        System.out.println(String.format("[%s][%s][jobWasExecuted] END", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
    
    // Next Step Schedule 등록 함수
    private void addNextStepSchedule(JobExecutionContext context) throws SchedulerException, ClassNotFoundException {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        
        String mainStepJobName = context.getJobDetail().getKey().getName();
        String nextStepClassName = jobDataMap.getString(JobLauncher.NEXT_STEP_CLASS_NAME);
        String nextStepJobName = jobDataMap.getString(JobLauncher.NEXT_STEP_JOB_NAME);
        
        if( nextStepJobName == null ) {
            // 이름이 없는 경우
            //   - 중복 방지를 위해 UUID 생성
            nextStepJobName = UUID.randomUUID().toString();
        }
        
        // Next Step Class
        //   - 문자열로 Class 탐색
        Class<?> jobClass = Class.forName(nextStepClassName);
        
        // JobDetail 생성
        //   - NextStep에 MainStepName을 전달
        JobDetail jobDetail = JobBuilder.newJob((Class<? extends Job>)jobClass)
                                .withIdentity(JobLauncher.PREFIX_NEXT_STEP_JOB_NAME+nextStepJobName)
                                .usingJobData(JobLauncher.MAIN_STEP_JOB_NAME, mainStepJobName)
                                .build();
        
        // Trigger 생성
        //   - 바로 실행
        Trigger trigger = TriggerBuilder.newTrigger()
                              .withIdentity(JobLauncher.PREFIX_NEXT_STEP_TRIGGER_NAME+nextStepJobName)
                              .startNow()
                              .forJob(jobDetail)
                              .build();
        
        // 스케줄 등록
        context.getScheduler().scheduleJob(jobDetail, trigger);
    }
}
 
Colored by Color Scripter

cs

4. JobLauncher.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

package com.dochi.quartz.step;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Set;
 
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.UnableToInterruptJobException;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
 
public class JobLauncher {
    
    // 상수 설정
    //   - Prefix 설정
    public static final String PREFIX_STEP_JOB_NAME = "job_";
    public static final String PREFIX_STEP_TRIGGER_NAME = "trigger_";
    public static final String PREFIX_NEXT_STEP_JOB_NAME = "step_job_";
    public static final String PREFIX_NEXT_STEP_TRIGGER_NAME = "step_trigger_";
    
    //   - DateFormat 설정
    public static final SimpleDateFormat TIMESTAMP_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    //   - JobDataMap에서 사용할 Key 정의
    public static final String MAIN_STEP_JOB_NAME = "mainStepJobName";
    public static final String NEXT_STEP_CLASS_NAME = "nextStepClassName";
    public static final String NEXT_STEP_JOB_NAME = "nextStepJobName";
 
    // Scheduler 객체 생성
    private static SchedulerFactory factory = null;
    private static Scheduler scheduler = null;
    
    // Main 함수
    public static void main(String[] args) throws SchedulerException {
        // Scheduler 실행
        start();
        
        // Schedule 등록
        addSchedule("MainJob");
 
        try {
            System.out.println("아무키나 입력하면 종료됩니다...");
            System.in.read();
 
            // Scheduler 롱료
            stop();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // Scheduler 실행 함수
    public static void start() throws SchedulerException {
        // Scheduler 객체 정의
        factory = new StdSchedulerFactory();
        scheduler = factory.getScheduler();
        
        // Listener 설정
        scheduler.getListenerManager().addJobListener(new JobStepListener());
        
        // Scheduler 실행
        scheduler.start();
    }
    
    // Scheduler 종료 함수
    public static void stop() throws SchedulerException {
        try {
            System.out.println("스케줄러가 종료됩니다...");
            
            // Job Key 목록
            Set<JobKey> allJobKeys = scheduler.getJobKeys(GroupMatcher.anyGroup());
            
            // Job 강제 중단
            allJobKeys.forEach((jobKey)->{
                try {
                    scheduler.interrupt(jobKey);
                } catch (UnableToInterruptJobException e) {
                    e.printStackTrace();
                }
            });
            
            // Scheduler 중단
            //   - true : 모든 Job이  완료될 때까지 대기 후 종료
            //   - false: 즉시 종료
            scheduler.shutdown(true);
 
            System.out.println("스케줄러가 종료되었습니다.");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    // Schedule 등록 함수
    public static void addSchedule(String name) throws SchedulerException {
        // JobDataMap 설정
        //   - Step으로 실행시킬 Job Class 이름 설정
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put(NEXT_STEP_CLASS_NAME, "com.dochi.quartz.step.SubJob");
        
        // JobDetail 설정
        JobDetail jobDetail = JobBuilder.newJob(MainJob.class)
                                .withIdentity(PREFIX_STEP_JOB_NAME+name)
                                .setJobData(jobDataMap)
                                .build();
        
        // Trigger 설정
        Trigger trigger = TriggerBuilder.newTrigger()
                              .withIdentity(PREFIX_STEP_TRIGGER_NAME+name)
                              .startNow()
                              .forJob(jobDetail)
                              .build();
        
        // Schedule 등록
        scheduler.scheduleJob(jobDetail, trigger);
    }
}
 
Colored by Color Scripter

cs

실행결과

- MainJob이 완료된 후 SubJob이 수행되는 것을 확인할 수 있음.

마치며

지금까지 JobListener를 통해 Step By Step으로 Job을 수행하는 방법에 대해서 알아보았다. 나중에 Crawler를 적용하였을 때, MainJob은 글목록에서 URL을 파싱하고, SubJob은 상세내용을 다시 크롤링하는 구조로 만들면 좋을것 같다.

[JAVA] Quartz 스케줄러 만들기 (3) - Job 강제 종료

허도치 — Wed, 11 Nov 2020 16:44:21 +0900

서론

  지난 포스트에서는 Listener를 적용해보았다. 어떤 순서로 돌아가는지, 오류가 발생했을 때는 어떻게 되는지 궁금해서 수행중인 Job을 강제로 중단시키거나 오류를 발생시키고 싶어졌다.

  그러나, Quartz에서 스케줄을 종료할 때 Scheduler.shutdown() 함수를 사용하는데, 이 함수는 Trigger를 종료시키는 명령으로써 이미 수행중인 Job에는 영향을 주지않는다. 따라서, 이미 진행되고 있는 Job은 멈출 수 없으므로 별도의 기능을 구현해야한다.

  그래서 이번 포스트에서는 Job을 강제로 중단시키기는 방법에 대해서 다루어보려고한다.

개발환경

- jdk-11.0.5
- quartz-2.3.2

<!-- Scheduler -->
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.3.2</version>
</dependency>
<!-- Scheduler -->
<!-- Logging -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.25</version>
</dependency>
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
</dependency>
<!-- Logging -->

소스코드

1. MainJob.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package com.dochi.quartz.interrupt;
 
import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
 
 
public class MainJob implements InterruptableJob {
    
    private Thread currentThread = null;
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 현재 Thread 저장
        this.currentThread = Thread.currentThread();
        
        String jobName = context.getJobDetail().getKey().getName();
        
        System.out.println(String.format("[%s][%s] Running...", this.getClass().getName(), jobName));
        try {
            // 강제로 종료를 지연시키기
            Thread.sleep(5*1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(String.format("[%s][%s] Finish!!!", this.getClass().getName(), jobName));
    }
 
    @Override
    public void interrupt() throws UnableToInterruptJobException {
        // interrupt 설정
        //   - 강제종료
        if( this.currentThread != null ) {
            this.currentThread.interrupt();
        }
    }
}
 
Colored by Color Scripter

cs

2. TriggerLogListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package com.dochi.quartz.interrupt;
 
import java.util.Date;
 
import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.Trigger.CompletedExecutionInstruction;
import org.quartz.TriggerListener;
 
public class TriggerLogListener implements TriggerListener {
 
    @Override
    public String getName() {
        return this.getClass().getName();
    }
 
    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][triggerFired]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][vetoJobExecution]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
        return false;
    }
 
    @Override
    public void triggerMisfired(Trigger trigger) {
        System.out.println(String.format("[%s][%s][triggerMisfired]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context,
            CompletedExecutionInstruction triggerInstructionCode) {
        System.out.println(String.format("[%s][%s][triggerComplete]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
}
 
Colored by Color Scripter

cs

3. JobLogListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.dochi.quartz.interrupt;
 
import java.util.Date;
 
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
 
public class JobLogListener implements JobListener {
    
    @Override
    public String getName() {
        return this.getClass().getName();
    }
 
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][triggerComplete]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        System.out.println(String.format("[%s][%s][jobExecutionVetoed]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        System.out.println(String.format("[%s][%s][jobWasExecuted]", JobLauncher.TIMESTAMP_FMT.format(new Date()), getName()));
    }
 
}
 
Colored by Color Scripter

cs

4. JobLauncher.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

package com.dochi.quartz.interrupt;
 
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Set;
 
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.UnableToInterruptJobException;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
 
public class JobLauncher {
    
    // 상수 설정
    //   - Prefix 설정
    public static final String PREFIX_STEP_JOB_NAME = "job_";
    public static final String PREFIX_STEP_TRIGGER_NAME = "trigger_";
    public static final String PREFIX_NEXT_STEP_JOB_NAME = "step_job_";
    public static final String PREFIX_NEXT_STEP_TRIGGER_NAME = "step_trigger_";
    
    //   - DateFormat 설정
    public static final SimpleDateFormat TIMESTAMP_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    // Scheduler 객체 생성
    private static SchedulerFactory factory = null;
    private static Scheduler scheduler = null;
    
    // Main 함수
    public static void main(String[] args) throws SchedulerException {
        // Scheduler 실행
        start();
        
        // Schedule 등록
        addSchedule("MainJob");
        addSchedule("MainJob2");
 
        try {
            System.out.println("아무키나 입력하면 종료됩니다...");
            System.in.read();
 
            // Scheduler 롱료
            stop();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    // Scheduler 실행 함수
    public static void start() throws SchedulerException {
        // Scheduler 객체 정의
        factory = new StdSchedulerFactory();
        scheduler = factory.getScheduler();
        
        // Listener 설정
        scheduler.getListenerManager().addJobListener(new JobLogListener());
        scheduler.getListenerManager().addTriggerListener(new TriggerLogListener());
        
        // Scheduler 실행
        scheduler.start();
    }
    
    // Scheduler 종료 함수
    public static void stop() throws SchedulerException {
        try {
            System.out.println("스케줄러가 종료됩니다...");
            
            // Job Key 목록
            Set<JobKey> allJobKeys = scheduler.getJobKeys(GroupMatcher.anyGroup());
            
            // Job 강제 중단
            allJobKeys.forEach((jobKey)->{
                try {
                    scheduler.interrupt(jobKey);
                } catch (UnableToInterruptJobException e) {
                    e.printStackTrace();
                }
            });
            
            // Scheduler 중단
            //   - true : 모든 Job이  완료될 때까지 대기 후 종료
            //   - false: 즉시 종료
            scheduler.shutdown(true);
 
            System.out.println("스케줄러가 종료되었습니다.");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    // Schedule 등록 함수
    public static void addSchedule(String name) throws SchedulerException {
        // JobDetail 설정
        JobDetail jobDetail = JobBuilder.newJob(MainJob.class)
                                .withIdentity(PREFIX_STEP_JOB_NAME+name)
                                .build();
        
        // Simple Schedule 생성
        //   - 3초마다 실행, 최대 5회
        SimpleScheduleBuilder schedule = SimpleScheduleBuilder.simpleSchedule()
                                            .withIntervalInSeconds(3)
                                            .withRepeatCount(5);
        
        // Trigger 설정
        Trigger trigger = TriggerBuilder.newTrigger()
                              .withIdentity(PREFIX_STEP_TRIGGER_NAME+name)
                              .withSchedule(schedule)
                              .forJob(jobDetail)
                              .build();
        
        // Schedule 등록
        scheduler.scheduleJob(jobDetail, trigger);
    }
}
 
Colored by Color Scripter

cs

실행결과

- JobLauncher를 실행시키고, Console에서 아무키나 입력하면 Scheduler가 중단됨.

- 이미 Job이 실행중이라면 위와같이 InterInterruptedException이 발생함.

마치며

지금까지 Job을 강제로 중단하는 방법에 대해서 다루어보았다. Listener를 좀 더 알아보기위해서 만들었는데, 나중에 Crawler를 적용했을 때 요청이 오래걸리거나 잘못요청했을 때 중단하는 기능으로 활용하면 매우 좋을것 같다. 다음 포스트에서는 Listener를 활용한 예제를 다루어보도록 하겠다.

[JAVA] Quartz 스케줄러 만들기 (2) - Listener

허도치 — Tue, 10 Nov 2020 00:31:17 +0900

서론

이전 포스트에서는 간단하게 Quartz를 이용한 스케줄러를 만들고 실행해보았다. 이번 포스트에서는 Listener에 대해서 알아볼 계획이다. Listener는 주로 프로세스의 실행, 종료, 중단 등의 라이프사이클에 따라 로그를 출력하거나 추가 로직을 작성할 수 있는 객체인데, 굳이 설정하지 않아도 실행하는데 문제가 되지는 않는다.

Quartz에서는 ScheduleListener, TriggerListener, JobListener 이렇게 총 3가지가 있는데, ScheduleListener는 너무 세분화되어 있어서 생략하고, Trigger와 Job Listener에 대해서 다루어 보려고 한다.

개발환경

- jdk-11.0.5
- quartz-2.3.2

<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.3.2</version>
</dependency>

소스코드

1. MyTriggerListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.Trigger.CompletedExecutionInstruction;
import org.quartz.TriggerListener;
 
public class MyTriggerListener implements TriggerListener {
 
    public static final String EXECUTION_COUNT = "EXECUTION_COUNT";
    
    public String getName() {
        return MyTriggerListener.class.getName();
    }
    
    /**
     * Trigger가 실행된 상태
     * 리스너 중에서 가장 먼저 실행됨
     */
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        System.out.println(String.format("\n[%-18s][%s]", "triggerFired", trigger.getKey().toString()));
    }
 
    /**
     * Trigger 중단 여부를 확인하는 메소드
     * Job을 수행하기 전 상태
     * 
     * 반환값이 false인 경우, Job 수행
     * 반환값이 true인 경우, Job을 수행하지않고 'SchedulerListtener.jobExecutionVetoed'로 넘어감
     * 
     * Job 실행횟수가 3회이상이면 작업중단
     */
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        JobDataMap map = context.getJobDetail().getJobDataMap();
        int executeCount = -1;
        if (map.containsKey(EXECUTION_COUNT)) {
            executeCount = map.getInt(EXECUTION_COUNT);
        }
        System.out.println(String.format("[%-18s][%s]", "vetoJobExecution", trigger.getKey().toString()));
        
        return executeCount >= 3;
    }
 
    /**
     * Trigger가 중단된 상태
     */
    public void triggerMisfired(Trigger trigger) {
        System.out.println(String.format("[%-18s][%s]", "triggerMisfired", trigger.getKey().toString()));
    }
 
    /**
     * Trigger가 완료된 상태
     */
    public void triggerComplete(Trigger trigger, JobExecutionContext context, CompletedExecutionInstruction triggerInstructionCode) {
        System.out.println(String.format("[%-18s][%s]", "triggerComplete", trigger.getKey().toString()));
    }
}
Colored by Color Scripter

cs

2. MyJobListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
 
public class MyJobListener implements JobListener{
 
    @Override
    public String getName() {
        return MyJobListener.class.getName();
    }
 
    /**
     * Job이 수행되기 전 상태
     *   - TriggerListener.vetoJobExecution == false
     */
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        System.out.println(String.format("[%-18s][%s] 작업시작", "jobToBeExecuted", context.getJobDetail().getKey().toString()));
    }
 
    /**
     * Job이 중단된 상태
     *   - TriggerListener.vetoJobExecution == true
     */
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        System.out.println(String.format("[%-18s][%s] 작업중단", "jobExecutionVetoed", context.getJobDetail().getKey().toString()));
    }
 
    /**
     * Job 수행이 완료된 상태
     */
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        System.out.println(String.format("[%-18s][%s] 작업완료", "jobWasExecuted", context.getJobDetail().getKey().toString()));
    }
}
 
Colored by Color Scripter

cs

3. SampleJobExecutor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

import java.text.SimpleDateFormat;
import java.util.Date;
 
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.ListenerManager;
import org.quartz.PersistJobDataAfterExecution;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
 
/**
 * Quartz StatefulJob
 *   - Job이 실행중인 경우, 실행된 Job이 완료된 후에 다음 Job을 수행
 */
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class SampleJobExecutor implements Job {
    
    private static final SimpleDateFormat TIMESTAMP_FMT = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSSS");
    public static final String EXECUTION_COUNT = "EXECUTION_COUNT";
    
    @Override
    public void execute(JobExecutionContext ctx) throws JobExecutionException {
        JobDataMap map = ctx.getJobDetail().getJobDataMap();
        String currentDate = TIMESTAMP_FMT.format(new Date());
        String message = map.getString("message");
 
        int executeCount = 0;
        if (map.containsKey(EXECUTION_COUNT)) {
            executeCount = map.getInt(EXECUTION_COUNT);
        }
        executeCount += 1;
        map.put(EXECUTION_COUNT, executeCount);
        
        System.out.println(String.format("[%-18s][%d][%s] %s", "execute", executeCount, currentDate, message ));
    }
}
 
/**
 * Quartz Scheduler 실행
 */
class JobLuacher {
    public static void main(String[] args) {
        try {
            // Scheduler 생성
            SchedulerFactory factory = new StdSchedulerFactory();
            Scheduler scheduler = factory.getScheduler();
            
            // Listener 설정
            ListenerManager listenrManager = scheduler.getListenerManager(); 
            listenrManager.addJobListener(new MyJobListener());
            listenrManager.addTriggerListener(new MyTriggerListener());
            
            // Scheduler 실행
            scheduler.start();
 
            // JOB Executor Class
            Class<? extends Job> jobClass = SampleJobExecutor.class;
            
            // JOB Data 객체 생성
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message", "Hello, Quartz!!!");
            jobDataMap.put(SampleJobExecutor.EXECUTION_COUNT, 0);
 
            // JOB 생성
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                                    .withIdentity("job_name", "job_group")
                                    .setJobData(jobDataMap)
                                    .build();
            
            // SimpleTrigger 생성
            // 5초마다 반복하며, 최대 10회 실행
            SimpleScheduleBuilder simpleSch = SimpleScheduleBuilder.simpleSchedule()
                                                .withRepeatCount(10)
                                                .withIntervalInSeconds(5);
            SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                                            .withIdentity("simple_trigger", "simple_trigger_group")
                                            .withSchedule(simpleSch)
                                            .forJob(jobDetail)
                                            .build();
 
            // Schedule 등록
            scheduler.scheduleJob(jobDetail, simpleTrigger);
 
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}
Colored by Color Scripter

cs

실행결과

- Job이 3회 이상 수행되면 '작업중단'이 되는 것을 확인 할 수 있음.

마치며

지금까지 Quartz Scheduler에 Listener를 달아보았다. 아직까지는 로그를 남기는 용도로만 사용하고 있는데 어떻게 활용해볼지 고민중이다. 사실 Quartzs는 크롤러를 주기적으로 실행할 목적으로 만들기었기 때문에 Listener까지는 필요가 없었지만, StatefulJob을 알아보던 중에 로그를 출력해가며 어떻게 돌아가는지 파악하려고 적용해봤다.

[JAVA] Quartz 스케줄러 만들기 (1) - 실행

허도치 — Mon, 9 Nov 2020 17:11:07 +0900

서론

예전에 커뮤니티 사이트에서 글목록을 수집하고 DB에 저장하는 크롤러를 만든적이 있었다. 이 때, 주기적으로 실행하기 위해서 crontab이나 Windows 작업 스케줄러를 사용했다. 이 두개의 스케줄러는 사용하기는 편하지만 프로그램과 스케줄을 별도로 관리해야하기 때문에 관리포인트가 늘어나는 단점이 있다.

그래서, 이번에는 스케줄러를 직접 만들어보려고 하는데 Spring Batch는 써본적이 있기 때문에 이번에는 Quartz로 만들어 보려고 한다.

개발환경

- jdk-11.0.5

- quartz-2.3.2

<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.3.2</version>
</dependency>

Quartz란?

- Java Scheduling 라이브러리.
- 일련의 작업들을 단발성, 주기성으로 실행할 수 있음.

구성요소

1. JOB

- 실제 작업을 수행하는 객체

- org.quartz.Job 인터페이스를 상속받아 execute 메소드에 수행 로직을 구현

- 같은 그룹에는 동일한 이름을 가진 Job을 생성할 수 없음

2. Trigger

- Job을 수행하기위한 조건(스케줄)을 정의한 객체
- 특정시간, 횟수, 반복주기 등을 설정할 수 있음

* 특정시간 및 횟수: SimpleTrigger

* 주기적으로 반복: CronTrigger

- 같은 그룹에는 동일한 이름을 가진 Job을 생성할 수 없음
- Job : Trigger = 1 : N

3. Listener

- 작업의 시작, 중간, 끝, 에러를 처리할 수 있는 객체

- ScheduleListener와 TriggerListener

소스코드

1. SampleJobExecutor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
 
import org.quartz.CronExpression;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
 
import sch.listeners.MyScheduleListener;
import sch.listeners.MyTriggerListener;
 
/**
 * Quartz Job
 */
public class SampleJobExecutor implements Job {
    
    private static final SimpleDateFormat TIMESTAMP_FMT = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss.SSSS"); 
    
    @Override
    public void execute(JobExecutionContext ctx) throws JobExecutionException {
        JobDataMap jobDataMap = ctx.getJobDetail().getJobDataMap();
        
        String currentDate = TIMESTAMP_FMT.format(new Date());
        String triggerKey = ctx.getTrigger().getKey().toString();
        String message = jobDataMap.getString("message");
        
        System.out.println(String.format("[%s][%s] %s", currentDate, triggerKey, message ));
    }
}
 
/**
 * Quartz Scheduler 실행
 */
class JobLuacher {
    public static void main(String[] args) {
        try {
            
            // Scheduler 생성
            SchedulerFactory factory = new StdSchedulerFactory();
            Scheduler scheduler = factory.getScheduler();
            
            scheduler.getListenerManager().addJobListener(new MyScheduleListener());
            scheduler.getListenerManager().addTriggerListener(new MyTriggerListener());
            
            // Scheduler 실행
            scheduler.start();
            
            // JOB Data 객체 생성
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message", "Hello, Quartz!!!");
            
            // JOB Executor Class
            Class<? extends Job> jobClass = SampleJobExecutor.class;
 
            // JOB 생성
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                                    .withIdentity("job_name", "job_group")
                                    .setJobData(jobDataMap)
                                    .build();
            
            // SimpleTrigger 생성
            // 4초마다 반복하며, 최대 5회 실행
            SimpleScheduleBuilder simpleSch = SimpleScheduleBuilder.repeatSecondlyForTotalCount(5, 4);
            SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                                            .withIdentity("simple_trigger", "simple_trigger_group")
                                            .withSchedule(simpleSch)
                                            .forJob(jobDetail)
                                            .build();
 
            // CronTrigger 생성
            // 15초주기로 반복( 0, 15, 30, 45 )
            CronScheduleBuilder cronSch = CronScheduleBuilder.cronSchedule(new CronExpression("0/15 * * * * ?"));
            CronTrigger cronTrigger = (CronTrigger) TriggerBuilder.newTrigger()
                                        .withIdentity("cron_trigger", "cron_trigger_group")
                                        .withSchedule(cronSch)
                                        .forJob(jobDetail)
                                        .build();
            
            // JobDtail : Trigger = 1 : N 설정
            Set<Trigger> triggerSet = new HashSet<Trigger>();
            triggerSet.add(simpleTrigger);
            triggerSet.add(cronTrigger);
 
            // Schedule 등록
            scheduler.scheduleJob(jobDetail, triggerSet, false);
            
        } catch (ParseException | SchedulerException e) {
            e.printStackTrace();
        }
    }
}
Colored by Color Scripter

cs

실행결과

마치며

이것으로 간단하게 Quartz로 스케줄러를 만들고 실행하는 방법에 대해서 알아보았다. 만들어보니 Spring Batch보다 훨씬 간단했다. 다만, 스케줄을 Annotation으로 등록할 수 있는 Spring Batch와는 다르게 Trigger 객체를 생성해야하는 번거로움이 있다. 그래도, Quartz가 좀 더 직관적이라 마음에 든다.

[JAVA] 간단한 HTTP 서버 구축하기

허도치 — Thu, 5 Nov 2020 16:41:40 +0900

서론

요즘 Java로 파일 읽기/쓰기 기능을 구현하다가 실제 웹에서도 원하는대로 로그 파일을 읽어올 수 있을까  최근에 Java를 이용해서 파일을 읽고 쓰는 기능들을 구현해보았다. 이 기능들을 어디서 활용할 수 있을까 고민하다가 웹에서 로그를 조회하는 용도로 쓰면 좋을것 같았다. 이전에는 Python이나 Node를 이용해서 웹서버를 구현했었는데, Java에 손을 댔기 때문에 이번에는 Java 기본 모듈들을 이용하여 간단한 웹서버를 구현해보려고 한다.

  * jdk-11.0.5를 기준으로 작성되었음

소스코드

1. HttpServerManager.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.sun.net.httpserver.Headers;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
 
/**
 * Main Class
 */
public class HttpServerManager {
    private final String DEFAULT_HOSTNAME = "0.0.0.0";
    private final int DEFAULT_PORT = 8080;
    private final int DEFAULT_BACKLOG = 0;
    private HttpServer server = null;
    
    /**
     * 생성자
     */
    public HttpServerManager() throws IOException {
        createServer(DEFAULT_HOSTNAME, DEFAULT_PORT);
    }
    public HttpServerManager(int port) throws IOException {
        createServer(DEFAULT_HOSTNAME, port);
    }
    public HttpServerManager(String host, int port) throws IOException {
        createServer(host, port);
    }
    
    /**
     * 서버 생성
     */
    private void createServer(String host, int port) throws IOException {
        // HTTP Server 생성
        this.server = HttpServer.create(new InetSocketAddress(host, port), DEFAULT_BACKLOG);
        // HTTP Server Context 설정
        server.createContext("/", new RootHandler());
    }
    
    /**
     * 서버 실행
     */
    public void start() {
        server.start();
    }
    
    /**
     * 서버 중지
     */
    public void stop(int delay) {
        server.stop(delay);
    }
    
    public static void main(String[] args) {
        
        HttpServerManager httpServerManager = null;
        
        try {
            // 시작 로그
            System.out.println(
                String.format(
                    "[%s][HTTP SERVER][START]",
                    new SimpleDateFormat("yyyy-MM-dd H:mm:ss").format(new Date())
                )
            );
            
            // 서버 생성
            httpServerManager = new HttpServerManager("localhost", 3000);
            httpServerManager.start();
            // Shutdown Hook
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                @Override
                public void run() {
                    // 종료 로그
                    System.out.println(
                        String.format(
                            "[%s][HTTP SERVER][STOP]",
                            new SimpleDateFormat("yyyy-MM-dd H:mm:ss").format(new Date())
                        )
                    );
                }
            }));
            
            // Enter를 입력하면 종료
            System.out.print("Please press 'Enter' to stop the server.");
            System.in.read();
            
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            // 종료
            // 0초 대기후  종료
            httpServerManager.stop(0);
        }
    }
 
    /**
     * Sub Class
     */
    class RootHandler implements HttpHandler {    
        
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            
            // Initialize Response Body
            OutputStream respBody = exchange.getResponseBody();
            
            try {
                // Write Response Body
                StringBuilder sb = new StringBuilder();
                sb.append("<!DOCTYPE html>");
                sb.append("<html>");
                sb.append("   <head>");
                sb.append("       <meta charset=\"UTF-8\">");
                sb.append("       <meta name=\"author\" content=\"Dochi\">");
                sb.append("       <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">");
                sb.append("       <title>Example</title>");
                sb.append("   </head>");
                sb.append("   <body>");
                sb.append("       <h5>Hello, HttpServer!!!</h5>");
                sb.append("       <span>Method: "+(exchange.getRequestMethod())+"</span></br>");
                sb.append("       <span>URI: "+(exchange.getRequestURI())+"</span></br>");
                sb.append("       <span>PATH: "+(exchange.getRequestURI().getPath())+"</span></br>");
                sb.append("       <span>QueryString: "+(exchange.getRequestURI().getQuery())+"</span></br>");
                sb.append("   </body>");
                sb.append("</html>");
                
                // Encoding to UTF-8
                ByteBuffer bb = Charset.forName("UTF-8").encode(sb.toString());
                int contentLength = bb.limit();
                byte[] content = new byte[contentLength];
                bb.get(content, 0, contentLength);
                
                // Set Response Headers
                Headers headers = exchange.getResponseHeaders();
                headers.add("Content-Type", "text/html;charset=UTF-8");
                headers.add("Content-Length", String.valueOf(contentLength));
                
                // Send Response Headers
                exchange.sendResponseHeaders(200, contentLength);
                
                respBody.write(content);
                
                // Close Stream
                // 반드시, Response Header를 보낸 후에 닫아야함
                respBody.close();
                
            } catch ( IOException e ) {
                e.printStackTrace();
                
                if( respBody != null ) {
                    respBody.close();
                }
            } finally {
                exchange.close();
            }
        }
    }
}
 
Colored by Color Scripter
cs

2. 실행결과

[ HttpServerManager 실행 로그 ]

[ HttpServerManager 종료 로그 ]

3. 접속결과

[ http://localhost:3000 ] 접속결과

[ http://localhost:3000/test ] 접속결과

[ http://localhost:3000/test?username=dochi ] 접속결과

마치며

  이렇게 HttpServer 모듈을 이용하여 웹서버를 만들면서 Python과 Node에 비해 코드량이 상당히 많다는 것과 프레임워크가 상당히 편하다는 것을 느꼈다. 이번 예제에서는 간단하게 화면을 그리기위해 Method나 접근 경로에 따른 별도 로직은 구현하지 않았는데, 어떻게 구현해야할지 벌써부터 막막하다.

  화면을 그려주기위해 HTML을 문자열로 한땀 한땀 작성해서 Response를 보냈는데 화면이 그려지지 않는다면, Response Header에 'Content-Type'을 확인해봐야한다. 일반 텍스트나 js, css 등을 보낼 때는 'text/plain'으로 설정하고, HTML을 보낼 때는 'text/html'로 설정해야한다. 만약, JSON을 보내고싶다면? 'application/json'으로 설정하면된다. 그리고, HTML이나 JSON을 굳이 문자열로 작성할 필요없이 classpath에 저장된 HTML 파일을 Stream으로 가지고오면 좀 더 편하게 처리할 수 있다.

[JAVA] 파일 분할 - 용량 단위, 아래에서 위로 ↑

허도치 — Thu, 22 Oct 2020 14:06:12 +0900

서론

지난 포스트에서 파일을 위에서 아래로 읽어가며 분할하는 방법을 알아보았다. 이번 포스트에서는 반대로 아래에서 위로 올라가며 파일을 분할하는 방법을 다루어보려고 한다. 위에서 아래로 읽어서 분할하는 방식은 과거 데이터를 읽을 때는 좋겠지만 과거보다는 최신일자의 데이터를 확인하는 경우가 일상다반사이기 때문에 이번에 다루는 내용이 좀 더 활용도가 높다고 생각한다.

소스코드

1. FileUtils.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
 
public class FileUtils {
    
    /* Singleton */
    public static FileUtils instance = new FileUtils();
    
    /* 생성자1 */
    public static FileUtils getInstance() {
        if( instance != null ) {
            return instance;
        }
        return new FileUtils();
    }
    
    /**
     * 저장용량 단위별 처리량을 반환
     * @param unit  저장 용량 단위
     * @return      저장 용량 단위별 처리량
     */
    private static int getUnitCapacity(String unit) {
        if( unit == null ) { return 1; }
        unit = unit.toUpperCase();
        
        Map<String, Integer> units = new HashMap<String, Integer>();
        units.put("B", 1);
        units.put("K", 1024);
        units.put("M", 1024*1024);
        units.put("G", 1024*1024*1024);
        
        return units.get(unit);
    }
    
    /**
     * 파일 저장
     * @param filename  저장할 파일명(경로가 없을 경우 현재 경로에 저장)
     * @param text      파일에 저장할 내용
     * @param append    이어쓰기 모드여부. true: 이어쓰기, false: 다시쓰기
     * @param encoding  인코딩
     * @return          파일이 저장된 경로를 반환
     */
    public static String saveFile(String filename, String text, boolean append, Charset encoding) {
        OutputStreamWriter writer = null;
        File outfile = null;
        FileOutputStream outfile_stream = null;
        String savePath = null;
        
        try {
            outfile = new File(filename);
            outfile_stream = new FileOutputStream(outfile, append);
            
            writer = new OutputStreamWriter(outfile_stream, encoding);
            writer.write(text);
            writer.close();
            
            savePath = outfile.getAbsolutePath();
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if( writer != null ) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        return savePath;    
    }
 
    /**
     * 파일 내용을 byte[]로 받으며, 내용은 UTF8로 저장
     */
    public static String saveFileUTF8(String filename, byte[] text, boolean append) {
        return  saveFile(filename, new String(text), append, StandardCharsets.UTF_8);
    }
    /**
     * 파일 내용을 String로 받으며, 내용은 UTF8로 저장 
     */
    public static String saveFileUTF8(String filename, String text, boolean append) {
        return  saveFile(filename, text, append, StandardCharsets.UTF_8);
    }
    
    /**
     * 파일을 아래에서 위로 읽음
     * @param file            읽어드릴 파일 객체
     * @param size            출력할 사이즈
     * @param unit            B: 바이트(8Bit), K: 킬로바이트(1024B), M: 메가파이트(1024KB)
     * @param split_cnt        분할 파일 최대 개수
     * @return                마지막으로 조회된 데이터
     */
    public static byte[] splitFileReverse(File file, int size, String unit, int split_cnt) {
        final String PREFIX_DIR = "";
        final String PREFIX_FILENAME = "splited_r";
        final String PREFIX_EXT = "log";
 
        RandomAccessFile reader = null;
        byte[] buffer = null;
        
        try {
            // Read file
            reader = new RandomAccessFile(file, "r");
            
            // Variables
            int interval = size * getUnitCapacity(unit);
            long EOF = reader.length();
            int spos = (int)EOF;
            int epos = (int)EOF;
 
            String filename = null;
            String savepath = null;
 
            //파일명 역순처리
            float gab = (float)EOF/interval;
            float mok = (int) gab;
            float nmg = gab - mok;
            if( nmg > 0 ) {
                mok += 1;
            }
            int count = (int)mok+1;
            
            do {
                // Set Position
                epos = spos;
                spos = spos - interval;
                count -= 1;
                
                // BreakPoint
                if( spos <= 0 && epos <= 0 ) {
                    break;
                }
                if( spos < 0 ) {
                    spos = 0;
                }
                
                // 커서 이동
                reader.seek(spos);
                
                // Read Text
                buffer = new byte[epos-spos];
                reader.readFully(buffer);
 
                // Create New Flie
                filename = PREFIX_DIR+PREFIX_FILENAME+"_"+count+"."+PREFIX_EXT;
                savepath = saveFileUTF8(filename, buffer, false);
                
                // 파일 저장경로
                System.out.printf("savepath: %s, size: %d\n", savepath, buffer.length);
                
                // 파일 최대건수
                if( split_cnt != 0 && count >= split_cnt ) {
                    break;
                }
            } while( spos > 0 );
            
        } catch ( Exception e ) {
            e.printStackTrace();
        } finally {
            try {
                if( reader != null ) {
                    reader.close();
                    reader = null;
                }
            } catch ( Exception e ) {
                e.printStackTrace();
            }
        }
        
        // 마지막에 읽은 부분만 반환
        return buffer;
    }
 
    public static void main(String[] args) {
        // TODO: arguments로 받아서 처리
        String filepath = "C:\\logs\\20201021_stdout.log";
    
        // 파일 객체 생성
        File file = new File(filepath);
        
        // 100MB 단위로 모두 분할
        FileUtils.splitFileReverse(file, 100, "M", 0);
    }
}
 
Colored by Color Scripter

cs

대분류

이전에 작성했던 소스코드랑 크게 다르지 않다. 다만, 중간에 파일을 읽을 커서의 위치를 역방향으로 계산했을 뿐이다. 이래서 RandomAccessFile이 다루기 편하다.

[JAVA] 파일 분할 - 용량 단위, 위에서 아래로 ↓

허도치 — Thu, 22 Oct 2020 13:57:39 +0900

서론

프로그램을 구동하다보면 로그가 쌓이기 마련이다. 일반적이라면 일정주기나 용량별로 파일을 분할하고 압축을 하지만, 로그가 많이 쌓이지 않는 프로그램이라면 한개의 파일로 관리할지도 모른다. 한개의 파일로 관리하면 백업하기도 편하다. 하지만, 어떠한 이유로 갑작스럽게 로그가 많이 쌓이게 되면 어떻게 될까? 당연히 용량이 급격하게 늘어날 것이다.

최근 겪었던 상황이 딱 이러했다. 새로운 기능을 추가하였는데, 해당 기능에서 RAW 데이터를 로그에 저장하면서 파일 용량이 600MB를 넘어갔다. 처음에 원인을 몰랐을 때, 로그파일을 열어봐야하는데 메모장이나 노트패드로는 열리지 않아서 난감했다. 결국, 서브라임으로 열긴했는데 이 마저도 너무 느려서 답답했다.

그래서, 파일을 용량 단위로 분할 해주는 기능을 JAVA로 구현해보았다.

소스코드

1. FileUtils.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
 
public class FileUtils {
    
    /* Singleton */
    public static FileUtils instance = new FileUtils();
    
    /* 생성자1 */
    public static FileUtils getInstance() {
        if( instance != null ) {
            return instance;
        }
        return new FileUtils();
    }
    
    /**
     * 저장용량 단위별 처리량을 반환
     * @param unit  저장 용량 단위
     * @return      저장 용량 단위별 처리량
     */
    private static int getUnitCapacity(String unit) {
        if( unit == null ) { return 1; }
        unit = unit.toUpperCase();
        
        Map<String, Integer> units = new HashMap<String, Integer>();
        units.put("B", 1);
        units.put("K", 1024);
        units.put("M", 1024*1024);
        units.put("G", 1024*1024*1024);
        
        return units.get(unit);
    }
    
    /**
     * 파일 저장
     * @param filename  저장할 파일명(경로가 없을 경우 현재 경로에 저장)
     * @param text      파일에 저장할 내용
     * @param append    이어쓰기 모드여부. true: 이어쓰기, false: 다시쓰기
     * @param encoding  인코딩
     * @return          파일이 저장된 경로를 반환
     */
    public static String saveFile(String filename, String text, boolean append, Charset encoding) {
        OutputStreamWriter writer = null;
        File outfile = null;
        FileOutputStream outfile_stream = null;
        String savePath = null;
        
        try {
            outfile = new File(filename);
            outfile_stream = new FileOutputStream(outfile, append);
            
            writer = new OutputStreamWriter(outfile_stream, encoding);
            writer.write(text);
            writer.close();
            
            savePath = outfile.getAbsolutePath();
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if( writer != null ) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        return savePath;    
    }
 
    /**
     * 파일 내용을 byte[]로 받으며, 내용은 UTF8로 저장
     */
    public static String saveFileUTF8(String filename, byte[] text, boolean append) {
        return  saveFile(filename, new String(text), append, StandardCharsets.UTF_8);
    }
    /**
     * 파일 내용을 String로 받으며, 내용은 UTF8로 저장 
     */
    public static String saveFileUTF8(String filename, String text, boolean append) {
        return  saveFile(filename, text, append, StandardCharsets.UTF_8);
    }
    
    /**
     * 파일을 위에서 아래로 읽음
     * @param file             읽어드릴 파일 객체
     * @param size             출력할 사이즈
     * @param unit             B: 바이트(8Bit), K: 킬로바이트(1024B), M: 메가파이트(1024KB)
     * @param split_cnt        분할 파일 최대 개수
     * @return                 마지막으로 조회된 데이터
     */
    public static void splitFile(File file, int size, String unit, int max) {
        // 
        final String PREFIX_FILE_DIR = "";
        final String PREFIX_FILE_FILENAME = "splited";
        final String PREFIX_FILE_EXT = "log";
        
        RandomAccessFile reader = null;
        byte[] buffer = null;
        
        try {
            // Read file
            reader = new RandomAccessFile(file, "r");
 
            // Variables
            int interval = size * getUnitCapacity(unit);
            long EOF = reader.length();
            int spos = 0;
            int epos = 0;
            int count = 0;
 
            String filename = null;
            String savepath = null;
            
            do {
                // Set Position
                spos = epos;
                epos += interval;
                count += 1;
                
                // Break Point
                if( epos > EOF ) {
                    epos = (int)EOF;
                }
                
                // 시작지점 커서 이동
                reader.seek(spos);
                
                buffer = new byte[epos-spos];
                reader.readFully(buffer);
 
                // Create New Flie
                filename = PREFIX_FILE_DIR+PREFIX_FILE_FILENAME+"_"+count+"."+PREFIX_FILE_EXT;
                savepath = saveFileUTF8(filename, buffer, false);
                
                // 파일 저장경로
                System.out.printf("savepath: %s, size: %d\n", savepath, buffer.length);
                
                // 파일최대건수
                if( max != 0 && count >= max ) {
                    break;
                }
            } while( epos < EOF );
            
        } catch ( Exception e ) {
            e.printStackTrace();
        } finally {
            try {
                if( reader != null ) {
                    reader.close();
                    reader = null;
                }
            } catch ( Exception e ) { }
        }
    }
 
    public static void main(String[] args) {
        // TODO: arguments로 받아서 처리
        String filepath = "C:\\logs\\20201021_stdout.log";
    
        // 파일 객체 생성
        File file = new File(filepath);
        
        // 100MB 단위로 모두 분할
        FileUtils.splitFile(file, 100, "M", 0);
    }
}
 
Colored by Color Scripter

cs

마치며

이번에 RandomAccessFile 클래스를 이용했는데, 읽는 속도는 느리긴하지만 파일을 맘대로 컨트롤하기 편해서 사용해보았다. 그리고, 지금은 위에서 아래로(오름차순) 파일을 읽어서 잘랐는데, 다음에는 아래에서 위로(내림차순) 읽어가면서 파일을 잘라볼 예정이다.

과거의 데이터가 필요할 때는 이번에 만든 기능을 사용하고, 최신 데이터가 필요한 경우에는 다음 포스트에 다루는 기능을 활용하도록 하자.

[MariaDB] 무작정 시작하기 (4) - TABLE 생성 및 CRUD

허도치 — Fri, 7 Aug 2020 12:51:40 +0900

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (1) - 설치 및 실행

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (2) - DATABASE 명령어

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (3) - 유저 및 권한 관리

시작하기전에

이제 MariaDB를 사용할 준비를 맞쳤으니 실제 TABLE을 생성하고 데이터를 CRUD(입력, 조회, 수정, 삭제)를 처리해보도록 하겠다. 이번 포스트에서 생성할 테이블을 Oracle의 예제인 scott/tiger의 테이블을 사용할 것이다.

ToDo

- root 계정으로 'SCOTT' DATABASE를 생성하고 dochi 계정에 권한 부여.

- dochi 계정으로 TABLE 생성 및 DATA 입력하고 데이터 조회.

1. SCOTT DATABASE 생성

1-1. ROOT 계정으로 접속

1

"C:\Program Files\MariaDB 10.5\bin\mysql.exe" -uroot -p

cs

1-2. DATABASE 생성 및 권한 부여

-- DATABASE 생성
CREATE DATABASE SCOTT;

-- dochi 계정에 권한 부여
-- CREATE: TABLE 생성
-- ALTER: TABLE 변경
-- SELECT: DATA 조회
-- INSERT: DATA 입력
-- UPDATE: DATA 수정
-- DELETE: DATA 삭제
GRANT CREATE, ALTER, SELECT, INSERT, UPDATE, DELETE ON SCOTT.* TO 'dochi'@'localhost';

-- 권한 조회
SHOW GRANTS FOR 'dochi'@'localhost';

-- 권한적용
FLUSH PRIVILEGES;

1-3. 실행결과

2. 접속 USER 변경

2-1. USER 계정으로 접속

1

"C:\Program Files\MariaDB 10.5\bin\mysql.exe" -udochi -p

cs

2-2. DATABASE 조회 및 사용

-- DATABASE 조회
SHOW DATABASES;

-- 'SCOTT' DATABASE로 변경
USE SCOTT;

-- TABLE 조회
SHOW TABLES;

2-3. 실행 결과

3. TABLE 생성

3-1. TABLE 생성

CREATE TABLE EMP(
   EMPNO      INTEGER NOT NULL,
   ENAME       VARCHAR(10),
   JOB        VARCHAR(9),
   MGR        INTEGER,
   HIREDATE   VARCHAR(12),
   SAL        DECIMAL(7, 2),
   COMM       DECIMAL(7, 2),
   DEPTNO     INTEGER
);
 
CREATE TABLE DEPT(
   DEPTNO     INTEGER NOT NULL,
   DNAME      VARCHAR(14),
   LOCATION   VARCHAR(13)
);

CREATE TABLE SALGRADE(
   GRADE      INTEGER NOT NULL,
   LOSAL      INTEGER NOT NULL,
   HISAL      INTEGER NOT NULL
);

CREATE TABLE BONUS (
   ENAME      VARCHAR(10) NOT NULL,
   JOB        VARCHAR(9) NOT NULL,
   SAL        DECIMAL(7, 2),
   COMM       DECIMAL(7, 2)
);

3-2. PK 생성

ALTER TABLE EMP 
   ADD CONSTRAINT EMP_PK
   PRIMARY KEY (EMPNO);

ALTER TABLE DEPT
   ADD CONSTRAINT DEPT_PK
   PRIMARY KEY (DEPTNO);

ALTER TABLE SALGRADE
   ADD CONSTRAINT SALGRADE_PK
   PRIMARY KEY (GRADE);

ALTER TABLE BONUS
   ADD CONSTRAINT BONUS_PK
   PRIMARY KEY (ENAME, JOB);

ALTER TABLE EMP
   ADD CONSTRAINT DEPT
   FOREIGN KEY (DEPTNO)
   REFERENCES DEPT (DEPTNO);

ALTER TABLE EMP
   ADD CONSTRAINT MGR
   FOREIGN KEY (MGR)
   REFERENCES EMP (EMPNO);

3-3. DATA 추가

INSERT INTO DEPT VALUES
  (10, 'ACCOUNTING', 'NEW YORK'),
  (20, 'RESEARCH',   'DALLAS'),
  (30, 'SALES',      'CHICAGO'),
  (40, 'OPERATIONS', 'BOSTON');
 
INSERT INTO EMP VALUES
  (7839, 'KING',   'PRESIDENT', NULL, '1981-11-17', 5000, NULL, 10),
  (7566, 'JONES',  'MANAGER',   7839, '1981-04-02', 2975, NULL, 20),
  (7788, 'SCOTT',  'ANALYST',   7566, '1982-12-09', 3000, NULL, 20),
  (7876, 'ADAMS',  'CLERK',     7788, '1983-01-12', 1100, NULL, 20),
  (7902, 'FORD',   'ANALYST',   7566, '1981-12-03', 3000, NULL, 20),
  (7369, 'SMITH',  'CLERK',     7902, '1980-12-17',  800, NULL, 20),
  (7698, 'BLAKE',  'MANAGER',   7839, '1981-05-01', 2850, NULL, 30),
  (7499, 'ALLEN',  'SALESMAN',  7698, '1981-02-20', 1600,  300, 30),
  (7521, 'WARD',   'SALESMAN',  7698, '1981-02-22', 1250,  500, 30),
  (7654, 'MARTIN', 'SALESMAN',  7698, '1981-09-28', 1250, 1400, 30),
  (7844, 'TURNER', 'SALESMAN',  7698, '1981-09-08', 1500,    0, 30),
  (7900, 'JAMES',  'CLERK',     7698, '1981-12-03',  950, NULL, 30),
  (7782, 'CLARK',  'MANAGER',   7839, '1981-06-09', 2450, NULL, 10),
  (7934, 'MILLER', 'CLERK',     7782, '1982-01-23', 1300, NULL, 10);
 
INSERT INTO SALGRADE VALUES
  (1,  700, 1200),
  (2, 1201, 1400),
  (3, 1401, 2000),
  (4, 2001, 3000),
  (5, 3001, 9999);
  
COMMIT;

3-4. TABLE 생성 확인

4. 데이터 조회 예제

4-1. MANAGER의 모든 정보를 출력하시오.

-- 1. 업무가 'MANAGER'인 사원의 모든 정보를 출력하시오.
SELECT *
  FROM SCOTT.EMP T1
 WHERE 1=1
   AND T1.JOB = 'MANAGER'
;

4-2. MANAGER의 사번이 7698인 사원의 사번과 이름을 출력하시오.

-- 2. MANAGER의 사번이 7698인 사원의 사번과 이름을 출력하시오.
SELECT T1.EMPNO
     , T1.ENAME
  FROM SCOTT.EMP T1
 WHERE 1=1
   AND T1.MGR = 7698
;

4-3. MANAGER의 이름이 'KING'인 사원의 사번과 이름을 출력하시오.

-- 3. MANAGER의 이름이 'KING'인 사원의 사번과 이름을 출력하시오.
SELECT T1.EMPNO
     , T1.ENAME
  FROM SCOTT.EMP T1
 WHERE 1=1
   AND T1.MGR = (
       SELECT E1.EMPNO
         FROM SCOTT.EMP E1
        WHERE 1=1
          AND E1.ENAME = 'KING'
       )
;

4-4. MANAGER들의 사번, 이름, 부서번호, 부서명을 출력하시오.

-- 4. MANAGER들의 사번, 이름, 부서번호, 부서명을 출력하시오.
SELECT T1.EMPNO
     , T1.ENAME
     , T1.DEPTNO
     , T2.DNAME
  FROM SCOTT.EMP T1
 INNER JOIN SCOTT.DEPT T2
    ON T2.DEPTNO = T1.DEPTNO
 WHERE 1=1
   AND T1.JOB = 'MANAGER'
;

4-5. 각 부서의 부서번호, 부서명, 사원수, 평균 연봉을 출력하시오.(단, KING은 제외)

-- 5. 각 부서의 부서번호, 부서명, 사원수, 평균 연봉을 출력하시오.( 단, KING은 제외 )
SELECT T1.DEPTNO
     , MAX(T1.DNAME) AS DNAME
     , COUNT(1) AS EMP_CNT
     , AVG(T2.SAL) AS AVG_SAL
  FROM SCOTT.DEPT T1
 INNER JOIN SCOTT.EMP T2
    ON T2.DEPTNO = T1.DEPTNO
 WHERE 1=1
   AND T2.ENAME != 'KING'
 GROUP BY T1.DEPTNO
;

4-6. SALES부서의 평균 연봉을 구하시오. (단, 최대, 최소 연봉은 제외)

-- 6. SALES부서의 평균 연봉을 구하시오. ( 단, 최대, 최소 연봉은 제외 )
WITH SALES_EMP_OBJ AS (
	SELECT T1.DEPTNO
         , T2.EMPNO
         , T2.SAL
         , ROW_NUMBER() OVER( PARTITION BY T1.DEPTNO ORDER BY T2.SAL DESC ) AS MAX_SAL
         , ROW_NUMBER() OVER( PARTITION BY T1.DEPTNO ORDER BY T2.SAL ASC ) AS MIN_SAL
      FROM SCOTT.DEPT T1
     INNER JOIN SCOTT.EMP T2
        ON T2.DEPTNO = T1.DEPTNO
     WHERE 1=1
       AND T1.DNAME = 'SALES'
)
SELECT AVG(T1.SAL) AS SALSE_AVG_SAL
  FROM SALES_EMP_OBJ T1
 WHERE 1=1
   AND 1 NOT IN ( T1.MAX_SAL, T1.MIN_SAL )
;

마치며

- 지금까지 MariaDB를 설치하고 DATABASE, USER, TABLE을 생성하고 데이터 입력과 조회까지 기본적인 것들은 모두 다루어보았다. 사실상 문법은 ANSI를 사용하기 때문에 RDBMS를 접해본 사람이라면 쉽게 익숙해질 수 있을 것이다. 특히, MySQL이랑은 같은 소스로 만들어졌기 때문에 사용법은 동일하다고 볼 수 있다.

- 예전에 Oracle에서 반복 순환 WITH절을 구현했었는데, MariaDB에서는 'WITH RECURSIVE'로 작성을 해야하는것 같다. 이 부분에 대해서는 조금 더 다루어보고 정리를 할 필요가 있을것 같다.

- 이제 MariaDB랑도 친해졌으니 MongoDB를 걷어내고 MariaDB로 전환을 해봐야겠다.

[MariaDB] 무작정 시작하기 (3) - 유저 및 권한 관리

허도치 — Fri, 7 Aug 2020 12:50:35 +0900

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (1) - 설치 및 실행

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (2) - DATABASE 명령어

시작하기전에

지난 시간에는 DATABASE를 생성했는데, 아직까지 이 DATABASE를 사용할 수 있는 USER는 root 밖에 없다. root를 실제로 사용하는 것은 보안에 매우 취약한 일이기 때문에 USER를 생성해서 사용하는 것이 바람직하다. 그래서, 이번 포스트에서는 '모든 권한'을 가진 사용자를 생성하는 방법에 대해서 알아보도록 하겠다.

1. USER 목록 조회

1-1. SQL

USE MYSQL;

SELECT HOST
     , USER
     , PASSWORD
  FROM USER;

또는

SELECT HOST
     , USER
     , PASSWORD
  FROM MYSQL.USER;

1-2. 조회 결과

2. USER 생성

2-1. 사용법

-- 이미 생성된 계정일 경우 오류 발생
CREATE USER '<USER명>'@'<HOST>'
IDENTIFIED BY '<PASSWORD>';

-- 이미 생성된 계정일 경우, 수정
CREATE OR REPLACE USER '<USER명>'@'<HOST>'
IDENTIFIED BY '<PASSWORD>';

-- 이미 생성된 계정일 경우, 생성하지 않음
CREATE IF NOT EXISTS USER '<USER명>'@'<HOST>'
IDENTIFIED BY '<PASSWORD>';

- 이외에 세부 옵션을 사용하고자 한다면 공식 문서를 참조.

2-2. 예제

-- 로컬에서만 접속 가능한 계정.
CREATE OR REPLACE USER 'dochi'@'localhost' IDENTIFIED BY 'dochi';

-- 외부에서 접속 가능한 계정.
CREATE OR REPLACE USER 'dochi'@'%' IDENTIFIED BY 'dochi';

2-3. 실행 결과

3. 유저 삭제

3-1. 사용법

DROP USER '<USER명>'@'<HOST>';

3-2. 예제

DROP USER 'dochi'@'localhost';
DROP USER 'dochi'@'%';

3-3. 실행결과

4. 권한 조회

4-1. 사용법

SHOW GRANTS [FOR '<USER명>'@'<HOST>'];

- 현재 접속한 USER의 권한 목록을 출력.

- FOR~: 특정 USER의 권한 목록을 출력.

4-2. 예제

SHOW GRANTS FOR 'dochi'@'localhost';
SHOW GRANTS FOR 'dochi'@'%';

4-3. 실행결과

5. 권한부여

5-1. 사용법

GRANT [<권한목록>,] ON <DATABASE명>.<TABLE명> TO '<USER명>'@'<HOST>';

- 이외에 세부 옵션은 공식 문서를 참조.

5-2. 예제

-- 권한 부여
GRANT ALL PRIVILEGES ON DOCHI_DEV.* TO 'dochi'@'localhost';
GRANT ALL PRIVILEGES ON DOCHI_DEV.* TO 'dochi'@'%';
-- 권한 적용
FLUSH PRIVILEGES;

5-3. 실행결과

6. 권한 해제

6-1. 사용법

REVOKE [<권한목록>,] ON <DATABASE명>.<TABLE명> FROM '<USER명>'@'<HOST>';

6-2. 예제

-- 권한 해제
REVOKE ALL PRIVILEGES ON DOCHI_DEV.* FROM 'dochi'@'localhost';
REVOKE ALL PRIVILEGES ON DOCHI_DEV.* FROM 'dochi'@'%';

-- 권한 적용
FLUSH PRIVILEGES;

6-3. 실행결과

마치며

- 여기까지 MariaDB에서 DATABASE를 생성하고 USER를 생성하는 방법을 알아보았다. 이제부터는 생성된 USER로 접속하여 TABLE을 생성하면 MariaDB를 사용할 준비가 완료된다.

- 다음 포스트에서는 TABLE을 생성하고 데이터를 CRUD하는 방법에 대해서 알아보도록 하자.

[MariaDB] 무작정 시작하기 (2) - DATABASE 명령어

허도치 — Fri, 7 Aug 2020 10:25:17 +0900

2020/08/07 - [DATABASE/MariaDB] - [MariaDB] 무작정 시작하기 (1) - 설치 및 실행

시작하기전에

지난 포스트에서 MariaDB를 설치했으니, 이제 직접 사용해보도록 하자.

MariaDB는 Database이다. 사용하려면 당연히 'DATABASE'가 있어야 한다. 처음 설치하면 'test', 'mysql' 등 기본 DATABASE가 설치되어 있는데, 사용자가 새로운 DATABASE를 직접 추가하거나 삭제할 수 있다. 그래서, 이번 포스트에서는 DATABASE를 조회, 생성, 삭제하고 사용하는 방법에 대해서 알아보도록 하겠다.

1. DATABASE 조회

1-1. 사용법

SHOW DATABASES;

1-2. 실행 결과

2. DATABASE 생성

2-1. 사용법

CREATE DATABASE [IF NOT EXISTS] <DATABASE명>;

- IF NOT EXISTS: DATABASE가 생성되어 있는 경우, 생성되지 않고 경고로 알려줌.

2-2. 예제

CREATE DATABASE DEV_DOCHI;

2-3. 실행 결과

3. DATABASE 사용

3-1. 사용법

USE <DATABASE명>;

3-2. 예제

USE DEV_DOCHI;

3-3. 실행결과

4. DATABASE 삭제

4-1. 사용법

DROP DATABASE <DATABASE명>;

4-2. 예제

DROP DATABASE DEV_DOCHI;

4-3. 실행결과

마치며

- DATABASE를 조작하는 방법은 이것으로 끝이다. DATABASE는 한번 생성해두면 조작할 일이 거의 없기 때문에 'USE' 명령을 가장 많이 사용하게 될 것이다.

- 지금까지 ROOT 계정으로 접속해서 조작해봤는데, 다음 포스트에서는 새로운 USER를 등록해서 사용해보자.

[MariaDB] 무작정 시작하기 (1) - 설치 및 실행

허도치 — Fri, 7 Aug 2020 09:58:20 +0900

시작하기전에...

지금까지 RDBMS는 Oracle, DB2를 써왔는데 볼륨자체가 크다보니까 집에서 간단하게 프로젝트를 만들때는 사용하기가 조금 부담스러웠다. 그래서, NoSQL인 MongoDB를 주로 이용했는데, RDBMS만 사용해서인지 데이터를 조회하는 문법도 자꾸 헷갈려서 사용할 때마다 구글에 검색해서 사용했다. 그러다가, 이번에 MariaDB를 사용하게 될 일이 생겨서 미리 익숙해질겸 설치를 해보려고 한다.

- 작성일기준 최신버전: MariaDB 10.5

- 설치 OS: Windows10

1. 설치하기

1-1. 공식홈페이지 접속

- MariaDB Server Download

MariaDB Server Download

Test Drive MariaDB Server Today. MariaDB Server, with its continual open source innovation, is a modern relational database that business can count on – with features you can’t find in MySQL or Postgres. In fact, MariaDB Server 10.5 is the leading open

go.mariadb.com

1-2. 정보를 입력하고 Download 클릭

1-3. Installer Download

- 설치하고자하는 OS에 맞춰서 Installer를 받는다.

1-4. 설치

[ 설치 시작 ]

[ 라이센스 동의 ]

[ 기본 설정으로 진행 ]

[ root 계정의 비밀번호를 입력하고 'UTF8' 옵션을 체크 ]

[ 기본설정으로 진행 ]

[ 설치 진행 ]

[ 설치 완료 ]

2. 접속하기

2-1. 명령프롬프트 실행

- [ Windows 키 ] + [ R ] -> "cmd" 입력 -> [ Enter ]

- [ 시작 ] - [ 검색 ] - "cmd" 입력 -> [ 명령프롬프트 실행 ]

2-2. 명령어 입력

1
2
3
4
5

rem MariaDB 홈 변수 설정
SET MARIADB_HOME="C:\Program Files\MariaDB 10.5"
 
rem MariaDB 기본 설정으로 실행, root 계정
%MARIADB_HOME%\bin\mysql.exe --defaults-file=%MARIADB_HOME%\data\my.ini -uroot -p

cs

2-3. 실행 확인

[ 실행 결과 ]

- 명령어를 실행하면 패스워드를 입력할 수 있는데, 설치할 때 입력했던 root 계정의 패스워드를 입력하면 접속 완료.

마치며

- MariaDB가 확실히 Oracle이나 DB2보다 볼륨자체가 작아서 그런지 설치도 빠르고 시스템에 부담도 덜 가는것 같다. 앞으로 계속 사용해보면서 성능은 잘 나오는지, 안정적인지 체감해봐야겠다.

- 다음 포스트에서는 DATABASE 명령어에 대해서 알아보도록 하자.

[Python] Flask & Socket.io를 이용한 채팅

허도치 — Mon, 3 Aug 2020 23:34:59 +0900

서론

최근에 깃허브를 둘러보다가 Javascript를 공부하면서 Express.js와 Socket.io로 구현했던 간단한 채팅 예제를 발견했다. 예전과 비교해서 얼마나 레벨업이 되었는지 확인할겸 새로운 채팅 앱을 만들어보려고 한다. 다만, 이번에는 웹 어플리케이션 서버를 Express.js 대신 Python의 Flask를 사용할 계획이다.

1. 프로젝트 구성

1-1. 프로젝트 폴더 생성

1
2
3

mkdir flask-chat-simple
 
cd flask-chat-simple

cs

1-2. 파일 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

### For Windows
 
# Environment Variables File
type NUL > .env
 
# Web Application File
type NUL > app.py
 
# Socket Namespaces File
type NUL > namespaces.py
 
# Client Directory
mkdir src
 
# Client Files
type NUL > src/index.html
type NUL > src/index.css
type NUL > src/index.js

cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

### For Linux/OSX
 
# Environment Variables File
touch .env
 
# Web Application File
touch app.py
 
# Socket Namespaces File
touch namespaces.py
 
# Client Directory
mkdir src
 
# Client Files
touch src/index.html
touch src/index.css
touch src/index.js

cs

1-3. 가상환경 생성

1
2
3
4
5
6
7
8
9

# Create virtual ENV.
virtualenv .venv
 
# Activate virtual ENV.
### for Windows
".venv/Scripts/activate"
 
### for Linux/OSX
. .venv/bin/activate

cs

1-4. 라이브러리 설치

1

pip install flask python-socketio python-dotenv

cs

2. 환경변수 설정

flask-chat-simple/.env

1
2

FLASK_MODE=development
FLASK_DEBUG=1

cs

3. Server: Flask Application 생성

flask-chat-simple/app.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import os
import dotenv
  
from flask import Flask, url_for, render_template
from socketio import Server, WSGIApp
from namespaces import ChatNamespace
 
# Set Constant Variables
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
STATIC_FOLDER = os.path.join(ROOT_PATH, "src")
TEMPLATE_FOLDER = STATIC_FOLDER
 
# Create Flask Application
app = Flask(
  __name__,
  static_url_path="/static/",
  static_folder=STATIC_FOLDER,
  template_folder=TEMPLATE_FOLDER
)
 
# For reload changed static file.
def dated_url_for(endpoint, **values):
  if endpoint == 'static':
    filename = values.get('filename', None)
    if filename:
      file_path = os.path.join(app.static_folder, filename)
      values['q'] = int(os.stat(file_path).st_mtime)
  return url_for(endpoint, **values)
 
@app.context_processor
def override_url_for():
  return dict(url_for=dated_url_for)
 
@app.route('/', methods=["GET", "POST"])
def index():
  return render_template("index.html")
 
# Create SocketIO Server
sio = Server(
  async_mode="threading",
  logger=app.logger,
  engineio_logger=app.logger
)
sio.register_namespace(ChatNamespace(sio, '/chat'))
 
# Set SocketIO WSGI Application
app.wsgi_app = WSGIApp(sio, app.wsgi_app)
 
if __name__ == "__main__":
  dotenv.load_dotenv(dotenv_path=".env")
  
  app.run(host="localhost", port=3000, threaded=True)

cs

1. [ 22-32 ln ] - Static 파일 Reload 설정.

- 정적 파일은 내용이 수정되어도 Server를 재실행하지 않으면 반영되지 않음.

- 따라서, 정적 파일을 요청할 때마다 파일의 수정일자를 QueryString으로 붙여서 다시 load되도록 설정.

2. [ 39-43 ln ] - Socketio Server 객체 생성.

- [ 40 ln ] - async_mode는 engineio.Server 설정 옵션으로 비동기 처리를 위한 모드 옵션. eventlet이 기본설정이며, gevent, gevent_uwsgi, threading을 사용할 수 있음. 예제에서는 간단하게 사용가능한 threading을 적용.

3. [ 44 ln ] - Socketio Server Namespace 설정.

- Namespace를 설정하는 방법은 크게 두가지가 있음.

- 첫째, 데코레이터를 사용하는 방법, @sio.on("이벤트명", namespace="/chat")

- 둘째, socketio.Namespace 클래스를 생성하는 방법.

- 첫번째 방법을 사용하는게 편하긴하지만 객체지향적으로 작성하는 편이 좀 더 깔끔하기 때문에 예제에서는 두번째 방법을 사용.

4. [ 47 ln ] - Socket Server를 WSGI로 변환.

- Flask, Django로 구현된 WSGI와 통합할 수도 있음.

- 이번예제에서는 Flask를 사용하므로, Flask WSGI와 Socket Server를 통합.

5. [ 52 ln ] - threaded 옵션 설정.

- async_mode="threading"을 사용하려면, 서버가 Thread를 처리할 수 있어야 하므로 Threaded 옵션 설정.

4. Server: Socket Namespace 생성

flask-chat-simple/namespaces.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from socketio import Namespace
from urllib.parse import urlsplit, parse_qsl 
 
class ChatNamespace(Namespace):
  def __init__(self, sio, namespace, *args, **kwargs):
    super(Namespace, self).__init__(namespace)
    
    self.sio = sio
    self.logger = sio.logger
 
  def on_connect(self, sid, env):
    params = dict(parse_qsl(urlsplit(env["QUERY_STRING"]).path))
    
    self.sio.logger.info(f'{ sid } [SOCKET][CONNECT]')    
    self.sio.logger.info(f'{ sid } [SOCKET][CONNECT][PARAMS] { params }')
    
  def on_message(self, sid, data):
    self.sio.logger.info(f'{ sid } [SOCKET][MESSAGE] { data }')
    
    self.emit("receive_message", data)
  
  def on_disconnect(self, sid):
    self.sio.logger.info(f'{ sid } [SOCKET][DISCONNECT]')
 
Colored by Color Scripter

cs

1. [ 5~9 ln ] - ChatNamespace 생성자 설정.

- socketio.Namespace 클래스는 첫번째 인자로 namespace path를 받는데, sio(socketio.Server)객체를 받을 수 있도록 확장.

- sio는 session을 처리할 때, 필요한데 이번 예제에서는 다루지 않음.

2. [ 11-15 ln ] - "connect" Event를 처리하는 Event Handler.

- Socket Server에 접속하면 내부적으로 "connect" Event를 발생시키는데, 이를 Server와 Client에 정의된 "connect" Event Handler를 통해 Event을 받아서 처리함.

- [ 12 ln ] - Socket Client에서 데이터와 함께 접속을 시도하려면 URI에 QueryString으로 데이터를 붙여야함.

예) io("http://localhost:3000/chat?username=dochi")

3. [ 17-20 ln ] - "message" emit Event를 처리하는 Event Handler.

- Client로부터 "message" Events를 받아서 Namespace에 접속한 모든 Client에게 "receive_message" Event를 보냄.

4. [ 22-23 ln ] - "disconnect" Event를 처리하는 Event Handler.

5. Client: HTML 생성

flask-chat-simple/src/index.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

html<!DOCTYPE html>
<html lang="ko">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Socket App</title>
    <link href="{{ url_for('static', filename='index.css') }}" rel="stylesheet">
    <script src="https://unpkg.com/babel-standalone@6.26.0/babel.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/7.10.4/polyfill.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js" integrity="sha256-yr4fRk/GU1ehYJPAs8P4JlTgu0Hdsp4ZKrx8bDEDC3I=" crossorigin="anonymous"></script>
  </head>
  <body>
    <div id="root">
      <div class="chat-container">
        <div class="scroll-wrapper">
          <ul class="chat-msg-list"></ul>
        </div>
        <div class="chat-msg-controller">
          <form id="message_form">
            <input type="text" name="message" placeholder="message">
            <button type="submit">send</button>
          </form>
        </div>
      </div>
    </div>
    <script src="{{ url_for('static', filename='index.js') }}"></script>
  </body>
</html>
Colored by Color Scripter

cs

1. [ 7, 26 ln ] - Flask의 탬플릿인 Jinja2의 문법.

2. [ 8-10 ln ] - CDN 설정.

- [ 8-9 ln ] - 최신 Javascript 문법을 사용하기위한 Babel CDN 설정.

- [ [ 10 ln ] - Socket.io CDN 설정.

3 [ 13~25 ln ] - 채팅을 위한 Element 설정.

6. Client: Socket Client 생성

flask-chat-simple/src/index.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// Create Socket Instance
const socket = io("http://localhost:3000/chat?username=Dochi");
 
// On Event, Wait for 'connect' emit.
socket.on("connect", ()=>{
  console.log("[connect]");
});
 
// On Event, Wait for 'disconnect' emit.
socket.on("disconnect", ()=>{
  console.log("[disconnect]");
});
 
// On Event, Wait for 'receive_message' emit.
socket.on("receive_message", ({ username, message })=>{
  const text = [username, message].join(":");
  
  const div_wrapper = document.querySelector(".chat-container > .scroll-wrapper");
  const ul_msg_list = div_wrapper.querySelector(".chat-msg-list");
  const li_msg_item = ul_msg_list.appendChild(document.createElement("li"));
  
  li_msg_item.appendChild(document.createTextNode(text));
  
  document.querySelector(".scroll-wrapper").scrollTop = div_wrapper.scrollHeight;
});
 
// Emit Event, Emit message data.
const send_message = ( data )=>{
  socket.emit("message", data);
}
 
// Find Message Form Element
const message_form = document.getElementById("message_form");
 
// Send Message Handler
const handle_send_message = ( event )=>{
  event.preventDefault();
    
  // Get Input Message
  const input_message = event.target.querySelector('input[name="message"]');
  const text_message = input_message.value;
 
  // Send Message Data
  send_message({
    username: "Dochi",
    message: text_message
  });
 
  // Initialize
  input_message.value = "";
}
message_form.addEventListener("submit", handle_send_message, false);

cs

1. [ 2 ln ] - Socket Client 객체 생성.

- usage: io( URI, [options] )

- 자세한 설정 옵션은 socket.io 공식 문서를 참조.

2. [ 5-25 ln ] - Event Handler 설정.

- connect, disconnect는 접속, 접속해제시 발생되는 Event를 처리.

- [ 15-25 ln ] - message 데이터를 받아서 Element를 생성하고 화면에 렌더링하는 Event Handler.

3. [ 28-30 ln ] - Event Emitter 설정.

- Socket Server로 "message" Event를 보내는 Emitter.

4. [ 33-52 ln ] - Form에 입력된 message를 처리하는 로직.

- 입력된 message를 Emitter로 Server에 전송.

7. Client: CSS 생성

flask-chat-simple/src/index.css

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

html, body { 
  padding: 0;
  margin: 0;
  height: 100%;
  width: 100%
}
.chat-container {
  position: relative; 
  height: 350px;
  padding: 2px;
}
.scroll-wrapper { 
  position: relative; 
  height: 100%; 
  box-sizing: border-box; 
  border: 1px solid darkgrey;
  overflow-y: scroll;
}
.chat-msg-list { 
  position: absolute; 
  bottom: 0; 
  margin: 0;
  list-style: none; 
  padding: 1px; 
  width: 100%; 
  max-height: 100%; 
  box-sizing: border-box; 
}
.chat-msg-item { 
  padding: 3px 3px; 
  overflow-wrap: break-word;
}

cs

 
 
 

8. 실행

python app.py

9. 실행 결과

마치며

이렇게 간단한게 Flask와 Socket.io로 채팅을 구현해보았다. 확실히 처음 만들어봤을 때에 비해서 라이브러리에 대한 이해도가 높아서인지 뚝딱 만들어낼 수 있었다. 지금은 웹 브라우저를 통해 채팅할 수 있도록 구현하였는데, 추후에 PyQt5를 이용하여 웹과 응용프로그램에서 채팅을 할 수 있도록 구현해봐야겠다.

[React] Layout을 구성해보자

허도치 — Sun, 26 Jul 2020 23:22:14 +0900

서론

블로그나 쇼핑몰 등 기본적인 웹사이트를 구성할 때 Header, Section, Footer, SideBar와 같은 기본요소를 가지게 된다. 메뉴를 클릭하여 페이지가 변경되면 Header, Footer, SideBar는 항상 같은 내용을 유지하며, Section의 내용만 변경되게 된다. 이번 포스트에서는 React를 이용하여 기본요소를 가지며, Section만 변경되도록 Layout을 구성해볼 계획이다.