공부하고 정리한 내용을 깃에 올리기 위해 push를 진행했다. commit까지만 진행되고 push 단계에서 제목과 같은 오류가 생겼다.

구글링을 해보니 ssh키를 만들어야 한다고 했다.

ssh key 만들기

터미널에서 먼저 ssh키가 있는지 검색

$ cat ~/.ssh/id_rsa.pub

아래와 같이 나왔다면 ssh키를 생성해주면 된다.

$ ssh-keygen

다른 블로그에서는 id_rsa로 나온다고 했지만 나는 id_ed25519 이렇게 나왔다. 다른이름이면 오류가 날수 있다고 했지만 그냥 이대로 진행했다.

엔터를 누르고 진행해준다.

.ssh 폴더로 이동 후

cat id_ed25519.pub

위 코드를 입력 후 ssh로 시작하는 키를 복사해준다.

github에서 key 저장

오른쪽 상단의 프로필 이미지를 클릭 후 드롭다운박스에서 settings를 클릭해 준다.

ssh and gpg keys 메뉴를 클릭해 준다.

new ssh key를 클릭 후 (title은 아무 말이 나 적어도 무방)

key안에 복사한 key를 붙여넣기 해주고 add ssh key 버튼을 클릭하면 끝이다.

이후엔 정상적으로 push 가 진행되었다.

ssh key를 이용하면 git비밀번호 입력없이 commit과 push가 진행된다.

1. AWS 인스턴스에서

1) 먼저 인스턴스를 열고 파일을 넣을 폴더를 만들어준다.

$ mkdir pdf

2) 파일을 복사해서 넣을 경로를 찾아 복사한다.

$ pwd

아래 경로를 복사해준다.

2. pdf 파일 복사해서 서버 디렉토리에 넣기(2가지 방법)

1) filezilla에서 ssh로 접속해 파일 넣기

파일질라를 설치해준다.

상단 왼쪽의 아이콘을 클릭후 site Manager(사이트관리자)에서 왼쪽 아래 new site를 클릭하고 오른쪽에 표시된 부분에 아래와 같이 정보를 입력하고 확인을 눌러준다.

Protocol : SFTP - SSH File Transfer Protocol Host : AWS 해당 인스턴스 퍼블릭 IPv4 DNS Logon Type : Key file User : ubuntu(인스턴스 생성시 선택한 os) Key file : 인스턴스 생성시 다운로드된 ppk 키파일

2) 인스턴스를 생성할 때 자동으로 다운 밨았던 키파일(.pem or .ppk)이 있는 디렉토리에서 터미널을 열어 명령 프롬프트로 파일 넣기

$ scp -i <~/경로/key-pair.pem> <경로/파일명> <운영체제사용자이름>@<퍼블릭 ip 주소>:<파일을 복사해서 넣을 폴더>

• <~/경로/key-pair.pem> : 키 파일의 절대 경로

• <경로/파일명> : 전송하려는 파일의 경로
• <운영체제사용자이름> : AWS에서 사용중인 운영체제에 따라 이름이 다름

       Amazon Linux - ec2-user
     Ubuntu - ubuntu
     RHEL - ec2-user
     CentOS - centos

• <퍼블릭ip주소> : 해당 인스턴스에서 찾을 수 있음
• <파일을 복사해서 넣을 폴더> : EC2에서 파일을 저장할 디렉토리

만약 오류가 난다면 참고(EC2 서버에서 SSH로 접속) 디렉토리 권한 설정: EC2 사용자가 디렉토리에 쓰기 권한을 가지도록 설정

 $ sudo chown ec2-user:ec2-user 디렉토리명*

마무리

url : 인스턴스퍼블릭 IPv4 주소/8080/pdf(톰캣의 webapps에서 만든 디렉토리)/portfolio.pdf(파일명)

url로 접속하면 서버에 올린 포트폴리오가 확인된다.

1. war 파일 Export하기

원하는 프로젝트클릭하고 마우스 우클릭 Export 선택 browser를 클릭하고 파일을 저장할 디렉토리를 선택한다. finish를 선택하고 선택한 디렉토리로 가면 war 파일이 생성된걸 확인 할 수 있다.

2. AWS EC2에서 인스턴스 생성 및 기타 설정하기

2-1. 인스턴스 생성

서울리전으로 선택 데이터 서버가 존재하는 지역을 말하는데 지리적으로 가까운 리적을 선택하는게 유리하다. 다른 지역의 리전이 선택 되어 있으면 생성했던 인스턴스가 보이지 않는다 그럴땐 리전을 확인해 보면 된다. 검색창에 EC2를 검색 후 클릭해준다. 인스턴스 시작을 클릭해준다. 서버이름, os를 선택해준다. Ubuntu를 선택한 이유는 다른 os에 비해 가볍다는 이야기를 들었다! 인스턴스유형은 그대로 설정해준다. 새로운 키페어를 생성해준다. 키페어는 생성하면 키페어 파일이 다운로드 되는데 잃어버리지 말고 잘 보관해 둬야한다!!! 키페어 이름을 적고 키 페어 유형은 그대로 선택해준다. 프라이빗 키 파일 형식은 .pem을 선택한다.(PuTTY를 사용한다면 .ppk) 다음은 보안그룹이다. 기본적으로 '다음에서 SSH 트레픽 허용'이 체크되어 있다. 체크를 해제 해준다. 편집을 클릭해서 보안그룹을 추가해도 되지만 일단 이과정 에서는 넘어가고 추후 추가해줄 예정이다. 스토리지는 30으로 바꿔준다.(최대 용량 30) 모든설정이 끝나고 인스턴스 시작을 눌러준다. 왼쪽 메뉴바에서 인스턴스를 클릭하면 생성된 인스턴스 목록이 보여진다. 인스턴스를 사용하지 않을 때는 꼭 인스턴스 상태를 중지로 바꿔줘야 한다!!

2-2. 탄력적 IP 등록

주의!! 탄력적 IP를 사용하면 과금됩니다. 탄력적 IP없이 사용해도 무방합니다. 왼쪽의 메뉴바에서 탄력적 IP를 클릭하고 오른쪽 상단에서 탄력적 IP주소 할당을 클릭한다. 기본값으로 할당받아주면 된다. 할당을 클릭 생성한 탄력적 IP 주소를 선택하고 작업에서 탄력적 IP 주소 연결을 클릭한다. 생성한 인스턴스를 클릭 후 연결을 클릭하면 된다.

2-3. 보안그룹 설정

인스턴스 목록에서 내가 사용하기위해 생성한 인스턴스ID를 클릭한다. 아래 목록에서 보안을 선택 보안그룹 이름을 선택 인바운드 규칙 편집 -> 규칙추가 클릭 규칙 추가 버튼을 클릭해서 화면과 같이 만들어 준다 ssh는 내IP만 허용하도록 해준다.(소스가 IPv4라면 0.0.0.0/0 | IPv6라면 ::/0)

3. Ubuntu로 접속해 java와 Tomcat 설치하기

3-1. Ubuntu 접속

연결을 클릭해준다. 처음 연결 후 이런 화면이 나와 너무 당황 스러웠다. 뭔가 잘 못 한줄 알고 계속 삭제하고 새로 만들고를 반복 ㅜㅜ

해결책을 찾았다! 아래 참고한 블로그 링크이다 이대로 따라하면 해결된다! [참고] https://dohyeon.tistory.com/97

정상적으로 접속 되었다!

3-2. java 설치

$ sudo apt-get update

$ sudo apt-get install openjdk-11-jdk

jdk 11버전으로 프로젝트를 진행했기 때문에 11로 설치해준다.

설치전 업데이트를 진행 해준다.(이미 설치가 되었기 때문에 이미지는 생략)

$ java -version

설치 된것을 확인 할 수 있다.

$ update-alternatives --list java

설치된 경로를 먼저 찾아준다.

bin/java를 제외한 부분을 복사해준다.

$ vim ~/.bashrc

bashrc 파일을 열고 i를 입력하면 편집이 가능하다.

$ export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
$ export PATH=${PATH}:${JAVA_HOME}/bin

환경변수를 등록해준다.(등록 후 나올때는 :wq(저장 후 종료)입력)

$ source ~/.bashrc

환경변수 설정 적용

$ echo $JAVA_HOME

환경변수 확인

3-3. Tomcat 설치

https://tomcat.apache.org/download-90.cgi 위 링크로 들어가서 ( tomcat 9로 프로젝트 개발 진행함 )

tar.gz 를 오른쪽 마우스 클릭 후 링크 복사 해준다.

$ wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.98/bin/apache-tomcat-9.0.98.tar.gz

톰캣을 다운받는다.

$ ls

다운로드가 완료되면 파일을 확인해본다.

$ tar -zvxf apache-tomcat-9.0.69.tar.gz

압축을 풀어준다. 파란색은 압축 해제된 파일, 빨간색을 톰캣을 다운받고난 직후 압축파일이다.

3-4. 방화벽 설정

$ sudo ufw allow from any to any port 8080 proto tcp

외부에서 8080 포트 접근 허용을 위해 방화벽 포트를 열어 준다.

4. FileZilla 사용해서 war 파일 AWS 서버로 배포

파일질라를 설치해준다.

3-1. FTP 연결

상단 왼쪽의 아이콘을 클릭후 site Manager(사이트관리자)에서 왼쪽 아래 new site를 클릭하고 오른쪽에 표시된 부분에 아래와 같이 정보를 입력하고 확인을 눌러준다.

Protocol : SFTP - SSH File Transfer Protocol Host : AWS 해당 인스턴스 퍼블릭 IPv4 DNS Logon Type : Key file User : ubuntu(인스턴스 생성시 선택한 os) Key file : 인스턴스 생성시 다운로드된 ppk 키파일

3-2. war 파일 배포

filezilla에서 왼쪽이 내 컴퓨터이고 오른쪽이 aws에서 만든 인스턴스의 디렉토리 이다. 왼쪽에서 생성했던 war파일을 찾아 오른쪽에서 home/ubuntu/apache-tomcat-9.0.98/webapps 경로에 파일을 넣어주고 새로고침을 진행한다.

그럼 war파일과 같은이름의 폴더가 생성 된 것이 확인된다.

3-3. 톰캣 실행

$ cd apache-tomcat-9.0.98/bin

apache-tomcat-9.0.98/bin 에서 톰캣 실행

$ ./startup.sh

톰캣 실행

$ ./shutdown.sh 

톰캣 종료

tomcat을 실행 후 퍼블릭 IPv4 DNS 로 접속하면 화면이 뜨는 것을 확인할 수 있다.

참고한 사이트

- [AWS] 스프링부트(Spring Boot) AWS EC2 war 배포하기 (1) - 인스턴스 생성 및 설정

-[AWS] 스프링부트(Spring Boot) AWS EC2 war 배포하기 (2) - PuTTY를 이용한 Ubuntu java , tomcat 설치

[AWS] 스프링부트(Spring Boot) AWS EC2 war 배포하기 (3) - FileZilla를 이용한 Spring Boot war 파일 배포

set process working directory to '/Users/s2ong/DevData/inteliJData/VocaLab/Spring/www': could not setcwd() (errno 2: No such file or directory)

(의존성으로 인한 jsp를 찾지못하는 오류가 났던)프로젝트를 삭제하고 새로 생성하면서 Gradle이 이전 프로젝트의 경로를 참조해 빌드에 실패했다.

깃에서 프로젝트를 받아오면서 이전 프로젝트의 폴더를 잠시 남겨두면서 꼬인 것으로 추정된다.

해결

1. Gradle 캐시와 데몬 삭제

Gradle의 캐시와 데몬을 삭제하여 이전 프로젝트 경로와 관련된 잔여 데이터를 제거했다.

 $  rm -rf ~/.gradle/caches/
 $  rm -rf ~/.gradle/daemon/

2. git에서 .idea 폴더를 삭제

main branch 와 내가 사용중인 branch 에서 .idea폴더를 삭제했다. .idea폴더는 IntelliJ 프로젝트 설정을 담고있어 main branch를 새로 pull하면 또다시 삭제한 프로젝트의 경로를 참조했기 때문이다.

3. (MacOS) IntelliJ 완전 삭제 후 재설치

JetBrains 폴더들을 모두 삭제해준다.

$  rm -rf ~/Library/Application\ Support/JetBrains
$  rm -rf ~/Library/Caches/JetBrains
$  rm -rf ~/Library/Preferences/JetBrains
$  rm -rf ~/Library/Logs/JetBrains

삭제 후 새로 설치한다.

4. gradlew을 새로 빌드해준다.

$  ./gradlew clean build

오류 메시지

There was an unexpected error (type=Not Found, status=404). JSP file [/WEB-INF/main.jsp] not found

팀 프로젝트를 진행하던 중, 모든 팀원에게서 .jsp 파일을 찾을 수 없다는 404 오류가 발생했다. build.gradle과 application.properties를 아무리 확인해도 문제가 해결되지 않았으며, 디렉토리 이름의 오타 여부와 Controller에서의 경로 설정 또한 점검해 보았지만 원인을 찾을 수 없었다.

해결 방안

위와 같은 오류를 겪었다면 아래 사항을 우선적으로 확인하기를 권장한다

• JSP 관련 의존성 추가 여부
• 파일 디렉토리 이름 및 경로 설정

1. build.gradle - JSP 의존성 추가

implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
implementation 'jakarta.servlet:jakarta.servlet-api'
implementation 'jakarta.servlet.jsp.jstl:jakarta.servlet.jsp.jstl-api'
implementation 'org.glassfish.web:jakarta.servlet.jsp.jstl'

2. application.properties - Controller return 설정

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

• 디렉토리 구조 src/main/webapp/WEB-INF/(여기서부턴 디렉토리명마다 다름)views/

2.MainController

@Controller
public class MainController {

    @GetMapping("/")
    public String main() {
        return "main/main"; // properties에서 views폴더까지 설정
    }
}

문제의 원인

해결 과정 중, 새로운 프로젝트를 생성하며 문제의 원인을 발견했다. 프로젝트 생성 시 의존성에 Spring Security와 OAuth2 Client를 추가한 것이 원인이였다.

이 두 의존성을 추가하면 메인 페이지 이전에 로그인 화면으로 리다이렉션되는 기본 동작이 추가된다. build.gradle에서 이 의존성들을 삭제한 상태로 개발을 진행하려다 보니 경로에서 문제가 발생한 것으로 보였다.

해결

새로운 프로젝트를 생성하면서 해당 의존성을 배제한 상태로 설정한 결과, 더 이상 오류는 발생하지 않았다. 이와 같은 문제를 겪었다면 의존성 추가 여부와 경로 설정을 점검하는 것이 우선이다.

새로운 오류 발생 근데 오류 메세지는 같음 주의!!

위 오류를 해결하고 새로운 프로젝트를 생성 후 개발을 시작하려는 찰나 또 같은 jsp루트와 파일을 또다시 찾지 못하는 오류가 발생했다. intelliJ에서 실행하면서 생기는 오류같았다.(차라리 console에서 오류의 원인이라도 찾을 수 있으면...ㅜㅜ) 구글링으로 해결법을 찾았다!!

참고한 블로그 https://milenote.tistory.com/176

해결

intelliJ 상단 오른쪽에서 아래화살표를 누르고 Edit Configurations를 클릭해준다.

Spring Boot 아래에서 프로젝트명Application을 눌러준다. 여기서 Working directory에 $MODULE_WORKING_DIR$을 넣어주고 OK를 클릭하면 끝이다.

⚠️ 만약 Working directory를 찾을 수 없으면 Modify options에서 찾을 수 있다.

챗 GPT에게 마이그레이션 방법을 물어보기로 했다.

기존 프로젝트는 삭제 후 새로 만들면서 myBatis Framework를 추가하지 않아서 나는 오류가 있어 기존 dependencie에 myBatis만 더 추가해 주었다.

1. pom.xml → build.gradle / pom.properties → application.properties

1) 방법은 마이그레션 1 에서와 동일하다. 일단 SpringBoot version 과 dependency-management는 최신버전으로 설정해 주었다.

2) pom.properties 파일의 내용을 application.properties에 통합해준다.

<pom.properties>

#Generated by Maven Integration for Eclipse
#Fri Jan 12 16:34:16 KST 2024
m2e.projectLocation=C\:\\Users\\ITWILL\\git\\Table_zzimkong\\Table_zzimkong
m2e.projectName=Table_zzimkong
groupId=com.table
artifactId=zzimkong
version=1.0.0-BUILD-SNAPSHOT

<application.properties>

# Application Configuration
    spring.application.name=Table_zzimkong
# Maven Project Information
    project.groupId=com.table
    project.artifactId=zzimkong
    project.version=1.0.0-SNAPSHOT
# Project Path (MacOS)
    project.location=/Users/ITWILL/git/Table_zzimkong/Table_zzimkong

• 여기서 모두 추가하면 안된다!! Maven 방식에서 gradle 방식으로 변환중이기 때문이다. Maven Project Information,Project Path 이두부분은 제거해준다.

  # Application Configuration
    spring.application.name=Table_zzimkong

• 결과적으로 Application Configuration 한가지만 추가해주면 된다.

  group = 'com.table'
  version = '1.0.0-SNAPSHOT'

• group 과 version은 build.gradle에 위의 방식으로 이미 추가되어 있다.

2. mybatis-config.xml → 파일 그대로 사용 / application.properties

1) mybatis-config.xml 파일은 그대로 사용 가능하다.

• *경로 : src/main/resources/mybatis-config.xml *

2) application.properties(application.yml)에서 myBatis 경로를 추가해준다.

mybatis.config-location=classpath:/mybatis-config.xml

<br>

# 3. log4j.xml → log4j2.xml / log4jdbc.log4j2.properties → build.gradle,application.properties
### 1) log4j.xml파일을 log4j2.xml에 맞게 변환해준다.

>**<log4j.xml\>**
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <!-- Appenders -->
    <appender name="console" class="org.apache.log4j.ConsoleAppender">
        <param name="Target" value="System.out" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p: %c - %m%n" />
        </layout>
    </appender>
    <!-- Application Loggers -->
    <logger name="com.table.zzimkong">
        <level value="info" />
    </logger>
    <!-- 3rdparty Loggers -->
    <logger name="org.springframework.core">
        <level value="info" />
    </logger>
    <logger name="org.springframework.beans">
        <level value="info" />
    </logger>
    <logger name="org.springframework.context">
        <level value="info" />
    </logger>
    <logger name="org.springframework.web">
        <level value="info" />
    </logger>
    <!-- 이 부분부터 항목 추가 -->
    <!-- SQL Logger 추가 -->
    <!-- 1. jdbc.sqlonly : SQL 쿼리 문장에 대한 로그(전달인자 포함한 문장 표시) -->
    <logger name="jdbc.sqlonly" additivity="false">
        <level value="info" />
        <appender-ref ref="console" />
    </logger>
    <!-- 2. jdbc.sqltiming : SQL 문장과 실행에 소요된 시간(밀리초)에 대한 로그 -->
    <logger name="jdbc.sqltiming" additivity="false">
        <level value="info" />
        <appender-ref ref="console" />
    </logger>
    <!-- 3. jdbc.audit : JDBC 호출 정보에 대한 로그(ResultSet 결과값 제외) => 내용 많음 -->
<!--     <logger name="jdbc.audit" additivity="false"> -->
<!--         <level value="info" /> -->
<!--         <appender-ref ref="console" /> -->
<!--     </logger> -->
    <!-- 4. jdbc.result : ResultSet 객체 내용을 포함한 JDBC 호출 정보에 대한 로그 => 내용 많음 -->
<!--     <logger name="jdbc.result" additivity="false"> -->
<!--         <level value="info" /> -->
<!--         <appender-ref ref="console" /> -->
<!--     </logger> -->    
    <!-- 5. jdbc.resultsettable : SELECT 실행 결과(데이터 테이블 = ResultSet 객체 내용) 에 대한 로그 -->
    <logger name="jdbc.resultsettable" additivity="false">
        <level value="info" />
        <appender-ref ref="console" />
    </logger>
    <!-- 여기까지 항목 추가 -->
    <!-- Root Logger -->
    <root>
        <priority value="warn" />
        <appender-ref ref="console" />
    </root>    
</log4j:configuration>

<log4j2.xml>

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <!-- Appenders -->
    <Appenders>
        <!-- Console Appender -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%-5p: %c - %m%n" />
        </Console>
    </Appenders>
    <!-- Loggers -->
    <Loggers>
        <!-- Application Loggers -->
        <Logger name="com.table.zzimkong" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <!-- 3rd Party Loggers -->
        <Logger name="org.springframework.core" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <Logger name="org.springframework.beans" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <Logger name="org.springframework.context" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <Logger name="org.springframework.web" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <!-- SQL Loggers -->
        <!-- 1. jdbc.sqlonly : SQL 쿼리 문장에 대한 로그(전달인자 포함한 문장 표시) -->
        <Logger name="jdbc.sqlonly" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <!-- 2. jdbc.sqltiming : SQL 문장과 실행에 소요된 시간(밀리초)에 대한 로그 -->
        <Logger name="jdbc.sqltiming" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <!-- 3. jdbc.audit : JDBC 호출 정보에 대한 로그(ResultSet 결과값 제외) => 내용 많음 -->
        <!--
        <Logger name="jdbc.audit" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <Logger name="jdbc.result" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        -->
        <!-- 5. jdbc.resultsettable : SELECT 실행 결과(데이터 테이블 = ResultSet 객체 내용) 에 대한 로그 -->
        <Logger name="jdbc.resultsettable" level="info" additivity="false">
            <AppenderRef ref="Console" />
        </Logger>
        <!-- 여기까지 항목 추가 -->
        <!-- Root Logger -->
        <Root level="warn">
            <AppenderRef ref="Console" />
        </Root>
    </Loggers>
</Configuration>

2) log4jdbc.log4j2.properties 파일의 dependence를 build.gradle에 추가해준다.

implementation 'org.bgee.log4jdbc-log4j2:log4jdbc-log4j2-jdbc4.1:1.16'

3)log4jdbc.log4j2.properties 파일의 내용을 application.properties 에 통합해준다.

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
logging.level.net.sf.log4jdbc=DEBUG

4. web.xml / root-context.xml / servlet-context.xml → application.properties 추가

Spring Boot에서 기본적으로 제공되어 제거가 가능한 요소들은 추가하지 않았다.

1) web.xml

<web.xml>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="Http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
    <context-param> <!-- spring의 루트 애플리케이션 컨텍스트를 지정 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/root-context.xml</param-value>
    </context-param>    
    <!-- Creates the Spring Container shared by all Servlets and Filters -->
    <listener><!--  루트 컨텍스트를 로드 -->
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- Processes application requests -->
    <!-- Spring MVC의 DispatcherServlet을 설정하고, 해당 서블릿이 사용할 컨텍스트 파일 경로를 지정 -->
    <servlet><!--  서블릿 이름(appServlet)과 서블릿 초기화 파라미터를 정의 -->
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>        
    <servlet-mapping><!-- DispatcherServlet이 처리할 URL 패턴(/)을 지정 -->
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- POST 방식 파라미터에 대한 한글 등의 인코딩 처리를 위한 필터 설정 -->
    <!-- CharacterEncodingFilter를 통해 POST 요청 시 UTF-8로 인코딩 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>    
    <!-- 필터가 모든 요청(/*)에 대해 동작하도록 설정 -->
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

• Root Spring Container
  • context-param : Spring의 루트 애플리케이션 컨텍스트를 지정
  • listener : ContextLoaderListener를 통해 루트 컨텍스트를 로드
• DispatcherServlet
  • Spring MVC의 DispatcherServlet을 설정하고, 해당 서블릿이 사용할 컨텍스트 파일 경로를 지정합니다.
  • servlet : 서블릿 이름(appServlet)과 서블릿 초기화 파라미터를 정의
  • servlet-mapping : DispatcherServlet이 처리할 URL 패턴(/)을 지정
• CharacterEncodingFilter
  • filter : CharacterEncodingFilter를 통해 POST 요청 시 UTF-8로 인코딩
  • filter-mapping : 필터가 모든 요청(/*)에 대해 동작하도록 설정

<application.properties>

# CharacterEncodingFilter
spring.web.encoding.charset=UTF-8
spring.web.encoding.enabled=true
spring.web.encoding.force=true

• Root Spring Container
  • UTF-8인코딩 설정 추가해줌
• DispatcherServlet / CharacterEncodingFilter
  • DispatcherServlet : 자동으로 설정해줌
  • CharacterEncodingFilter : 기본적으로 지원함

2) root-context.xml

<root-context.xml>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    <!-- Root Context: defines shared resources visible to all other web components -->
    <!-- HikariCP 라이브러리 사용을 위한 설정(커넥션풀 설정) -->
    <!-- 1. HikariCP 를 활용한 DB 접속 정보 설정 위해 HikariConfig 객체 설정(JDBC 기본 설정) -->
    <!-- com.zaxxer.hikari 패키지의 HikariConfig 클래스 지정 및 속성 설정 -->
    <!-- <bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig"> -->
    <!-- <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property> -->
    <!-- <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/study_spring5"></property> -->
    <!-- <property name="username" value="root"></property> -->
    <!-- <property name="password" value="1234"></property> -->
    <!-- </bean> -->
    <!-- SQL 로그를 위한 log4jdbc 라이브러리 관련 DBCP 정보 변경(driverClassName, jdbcUrl 속성만 
        변경) -->
    <bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
        <property name="driverClassName"
            value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy"></property>
        <property name="jdbcUrl"
            value="jdbc:log4jdbc:mysql://itwillbs.com:3306/c5d2308t2"></property>
        <property name="username" value="c5d2308t2"></property>
        <property name="password" value="1234"></property>
    </bean>
    <!-- 2. HikariCP 를 통해 커넥션을 관리하는 DataSource 객체(HikariDataSource) 설정 -->
    <!-- 생성자 파라미터(<constructor-arg ref="">)로 1번에서 생성한 HikariConfig 객체 전달 -->
    <!-- 주의! 1단계에서 입력한 정보가 일치하지 않을 경우 서버 실행 시점에 현재 단계에서 예외 발생 -->
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
        <constructor-arg ref="hikariConfig"></constructor-arg>
    </bean>
    <!-- 3. Connection 객체 생성, 쿼리 전달 및 결과 리턴 등의 작업을 수행할 SQLSessionFactory 객체 
        설정 -->
    <!-- MyBatis - Spring 연결을 담당하며, 내부적으로 SQLSession 객체를 통해 작업 수행 -->
    <!-- 주의! 1) 이전에 이미 DataSource 객체 설정이 완료되어 있어야 함 2) <bean> 태그의 id 값, class 
        값은 고정 3) <property> 태그의 name 속성의 dataSource, configLocation, mapperLocations 
        이름 고정 4) dataSource 속성의 ref 속성값은 2번에서 설정한 id 속성값 사용 5) configLocation, mapperLocations 
        속성(항목)에 지정된 각각의 파일(xml)이 실제 위치에 생성되어 있어야 함 (설정 항목 중 classpath 가 가리키는 기본 위치 
        : src/main/resources 패키지) -->
    <bean id="sqlSessionFactory"
        class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation"
            value="classpath:/mybatis-config.xml"></property>
        <property name="mapperLocations"
            value="classpath:/com/table/zzimkong/mapper/*Mapper.xml"></property>
    </bean>
    <!-- >>>>>>>>>>>>>>>>>>>>> 트랜잭션 설정 추가 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -->
    <!-- 내부 property 태그에 2번에서 설정한 datasource 객체지정 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--  tx:anotation-driven 태그를 통해 생성한 트랜잭션 관리 객체 지정 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 4. MyBatis 연동에 사용될 객체(클래스)들의 패키지 위치 지정(기본 루트 패키지 지정) -->
    <mybatis-spring:scan
        base-package="com.table.zzimkong" />
</beans>

<application.properties>

# HikariConfig
spring.datasource.driver-class-name=net.sf.log4jdbc.sql.jdbcapi.DriverSpy
spring.datasource.url=jdbc:log4jdbc:mysql://itwillbs.com:3306/c5d2308t2
spring.datasource.username=c5d2308t2
spring.datasource.password=1234
# DataSource
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
# SqlSessionFactory Bean
mybatis.config-location=classpath:/mybatis-config.xml
mybatis.mapper-locations=classpath:/com/table/zzimkong/mapper/*Mapper.xml

• Transaction Manager
  • SpringBoot에서 기본적으로 제공된다.

3) servlet-context.xml

<servlet-context.xml>

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    <!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->    
    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />
    <tx:annotation-driven/>
    <!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
    <resources mapping="/resources/**" location="/resources/" />
    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>
        <!-- 폼에 파일 업로드 위해서 설정하면 그거 자동을 처리해주는놈 아이디값은 약속된거 써야됨-->
    <beans:bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <beans:property name="maxUploadSize" value="10485760"></beans:property>
        <beans:property name="defaultEncoding" value="UTF-8"></beans:property>
    </beans:bean>
    <context:component-scan base-package="com.table.zzimkong" />
</beans:beans>

<application.properties>

# View Resolver
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
# Multipart Resolver
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.default-encoding=UTF-8

• Annotation-driven / tx:annotation-driven
  • SpringBoot에서 자동으로 활성화 된다.
• resources mapping
  • SpringBoot에서 기본적으로 제공 된다.
• context:component-scan
  • @SpringBootApplication을 통해 자동으로 처리된다.

기본적인 설정파일은 모두 수정되었다. refresh gradle project를 실행해보면 오류는 생기지 않는다. 다음은 boot Dashboar에서 실행했을 때 생기는 오류를 수정해볼 생각이다.

1. 프로젝트 생성하고 파일 옮기기

Spring Framework는 git을 이용해 협업하여 프로젝트를 만들었지만 새로 배운 기능을 추가해 더 완성도를 높이고 싶어 팀장의 리포지토리에서 파일을 다운받아 사용했다. 혹시나 모를 오류에서 원본을 보호하려는 마음도 있다. SpringBoot로 마이그레이션에 성공한다면 새로운 리포지토리로 만들어 기능을 추가할 예정이다.

1. Spring Starter Project로 프로젝트를 생성해준다.

• Spring Framework에서 사용했던 의존성과 내가 새로 추가할 기능의 의존성을 선택해준다.
• 여기에 없는건 일단 Spring Framework의 pom.xml파일에서 찾아서 따로 추가해줄 예정이다.

2. 의존성 추가해주기

Spring Framework의 pom.xml파일에서 따로 추가해준 dependency만 SpringBoot의 build.gradle에 맞게 변환해 추가하는 작업이다.

Spring의 pom.xml 파일에서 dependency태그 안에서 artifactId태그의 내용을 복사해준다.

Maven Repository에서 복사한 내용을 검색해준다.

dependency 태그아래에서 해당 버전을 확인하고 MVN repository에서 해당 버전을 클릭해준다.

• 사용한 Spring Framework 버전은 5.3.31 이다.

해당 버전으로 들어가면 maven 코드와 gradle 코드를 확인 할 수 있다. gradle 코드를 복사해준다.(저는 short를 사용했습니다.)

• gradle코드

• maven코드

해당 코드를 SpringBoot build.gradle파일에 붙여넣어 준다.

• 여기선 내가 원하는 코드는 SpringBoot의 코드이고 Spring Framework의 코드를 가지고 왔기때문에 일단 주석처리해주었다.
• 혹시나 SpringBoot의 프로젝트 생성시 추가했던 dependency와 중복을 염려해 확인해본 결과 Spring web 과 Spring websocket 두가지가 context에 포함되어 있었다.
• SpringBoot 프로젝트로 마이그레이션이 목표이기에 Spring Framework의 dependency를 주석처리 해주었다.

이런식으로 중복을 확인해주면서 pom.xml에서 따로 추가해준 dependency를 build.gradle파일에 모두 추가해주었다.

중간에 오류가 너무 많이 나서 다른 방법으로 새로 시도해보기로 했다.

해당 프로젝트를 실행하면서 오류 전 경고가 떴었다.

비교적 크기가 작은 11c를 도커로 사용 중이였다. springBoot에서 properties를 추가, 수정도 해보았지만 다른 버전들과의 충돌로 가장 간단하게 Oracle을 21버전으로 새로 설치하기로 했다.

처음엔 docker Hub에서 이미지를 받았지만 계정 로그인에서 계속 문제가 생겨 참고하게된 블로그이다.

참고한 블로그 : https://taisou.tistory.com/898

$ docker pull container-registry.oracle.com/database/express:latest

![](https://velog.velcdn.com/images/comete_yoon/post/8160254f-bd0a-49da-95cd-c813f22f9d64/image.png)
- Oracle공식 레포지터리에서 최신 이미지를 받았다.


>```
$ docker run -d --name oracle21 --restart=unless-stopped -p 1521:1521 -e ORACLE_PWD=1234 container-registry.oracle.com/database/express:latest

• run : 컨테이너 실행(없으면 생성 후 실행)
• -d : 컨테이너를 백그라운드(데몬) 모드로 실행
• --name : 컨테이너명
• --restart=unless-stopped : 컨테이너가 중지되거나 Docker 데몬이 재시작되더라도 컨테이너를 다시 시작할 수 있게 해준다.
• -p 1521:1521 : 호스트의 포트 1521을 컨테이너의 포트 1521에 매핑한다. Oracle 데이터베이스의 기본 포트가 1521이므로, 이 설정을 통해 호스트 시스템에서 Oracle 데이터베이스에 접근할 수 있다.
  • -e ORACLE_PASSWORD=비밀번호: 환경 변수를 설정합니다. 여기서는 Oracle 데이터베이스의 관리자 비밀번호를 사용자가 입력한 비밀번호로 설정한다.

설치는 여기서 끝났다. 다음은 터미널에서 오라클에 접속하는 방법이다.

$ docker exec -it 컨데이너id(3자리) bash

$ docker sqlplus

![](https://velog.velcdn.com/images/comete_yoon/post/3e50d959-d416-4449-8290-150735dfc25f/image.png)![](https://velog.velcdn.com/images/comete_yoon/post/992eaebf-2dbf-4ac1-b6ec-abae954a69cb/image.png)
- 접속 후 id로 system과 처음 컨테이너 생성시 입력했던 password를 입력하면 된다.(password는 입력해도 보이지 않는다.)

오라클 설치는 여기서 끝났다. 
Docker 로 새로 오라클을 설치했고 11버전의 오라클은 컨테이너 접속이 정지되었기 때문에 사용할 수 없다. 지금은 새로운 21버전의 오라클의 컨테이너가 실행중인 상황이다. 
이때 스프링에서 프로젝트를 실행하면 프로젝트와 연결된 DB가 없기 때문에 오류가 생긴다. (properties에 저장된 DB의 username,password가 모두 틀렸다고 오류가 난다.)
오라클에 접속하여 해당 데이터를 다시 만들어주고(프로젝트에서 설정해준 username과 password를 똑같이 설정해야 한다.) 실행하면 된다.

springBoot프로젝트를 실행해보면 정상적으로 실행되는 것을 확인할 수 있다!!!!
![](https://velog.velcdn.com/images/comete_yoon/post/1e3b5c68-5325-42e3-bb75-4646034fcfb3/image.png)

1). 배열을 생성하고 정렬을 사용하여 로또번호 생성

package lotto;

import java.util.Arrays;
import java.util.Random;

public class QuLottoArray {

    public static void main(String[] args) {

        // 배열생성
        int[] lottoNum = new int[6];

        Random ran = new Random();

        // 난수생성 후 배열에 넣기
        for(int i=0; i<6;) {

            int num = ran.nextInt(45) + 1;

            // 중복을 확인하는 메서드 호출
            if(!isDuplicate(num, lottoNum)) {
                lottoNum[i] = num;
                i++;
            }

        }

        // 배열 오름차순 정렬
        Arrays.sort(lottoNum);


        // 로또 번호 출력
        System.out.print("로또 번호 : ");
        for(int num : lottoNum) {
            System.out.print(num + " ");
        }

    }//main

    // 중복을 확인하는 메서드
    private static boolean isDuplicate(int num, int[] lottoNum) {
        for(int i : lottoNum) {
            if(i == num) {
                return true;                
            }
        }
        return false;

    }// 듀플메서드


}//class

2). TreeSet<>을 이용하여 로또번호 생성

package lotto;

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class QuLottoCollection {

    public static void main(String[] args) {

        Random ran = new Random();

        Set<Integer> lottoNum = new TreeSet<>();


        for(int i=0; lottoNum.size()<6; i++) {
            //난수 생성
            int num = ran.nextInt(45) + 1;
            //set에 난수 추가
            lottoNum.add(num);
        }

        // 로또 번호 출력
        System.out.print("로또번호 : ");
        System.out.print(lottoNum);

    }

}

3). java 파일을 도커이미지로 만들기

폴더를 생성하고 자바파일과 Dockerfile을 생성하여 도커에 이미지를 빌드해주었다. 이 과정도 시행착오가 많았는데 spring boot로 도커 이미지를 생성을 연습해보다 매번 자바파일만으로 아마존 서버에서 컴파일 해야한다고 생각하니 어떻게 jdk를 파일과 함께 이미지로 빌드하는가의 고민이 있었다.

처음에는 Dockerfile을 만들때 java파일을 복제하면서 jdk를 같이 빌드 해주었다.

FROM openjdk:17-jdk

COPY *.java /Lotto_docker/

ENTRYPOINT ["/bin/bash", "-c", "sleep 500"]

Docker Hub에서 내가 push한 이미지를 아마존 서버로 pull하면 되었다. 또다른 방법으로는 AWS 사이트에서 IAM을 생성하고 ECR에서 프라이빗 리포지토리를 생성해서 AWS ECR에 push 하고 아마존 인스턴스에서 우분투를 켜고 pull하면 자바파일이 아마존 서버 이미지에 복제되었다.

4). AWS EC2에 올려 컴파일 하기

아마존 서버에서 pull한 도커이미지 폴더에서 java 컴파일을 시도 했지만 성공하지 못했고 결국 아마존 우분투 서버에 jdk 17을 설치하고 java파일을 서버로 복사하기로 했다.

jdk를 설치하는 명령어이다.

$ sudo apt update
$ sudo apt install openjdk-버전-jdk
$ sudo java -version

4-1). 인스턴스를 생성할 때 자동으로 다운 밨았던 키파일(.pem)이 있는 디렉토리에서 터미널을 열고 명령어를 입력한다.

$ scp -i <~/경로/key-pair.pem> <경로/파일명> <운영체제사용자이름>@<퍼블릭 ip 주소>:<파일을 복사해서 넣을 폴더>

• <~/경로/key-pair.pem> : 키 파일의 절대 경로

• <경로/파일명> : 전송하려는 파일의 경로
• <운영체제사용자이름> : AWS에서 사용중인 운영체제에 따라 이름이 다름

       Amazon Linux - ec2-user
     Ubuntu - ubuntu
     RHEL - ec2-user
     CentOS - centos

• <퍼블릭ip주소> : 해당 인스턴스에서 찾을 수 있음
• <파일을 복사해서 넣을 폴더> : EC2에서 파일을 저장할 디렉토리

만약 오류가 난다면 참고(EC2 서버에서 SSH로 접속) 디렉토리 권한 설정: EC2 사용자가 디렉토리에 쓰기 권한을 가지도록 설정

 $ sudo chown ec2-user:ec2-user 디렉토리명*

4-2).EC2 서버에서 파일이 생성된것을 확인 후 java 컴파일하기.

먼저, 해당 파일의 디렉토리에서 컴파일을 실행한다.

$ javac 파일명.java

$ ls

목록을 불러오면 같은 파일명의 .class 파일이 생성된것을 확인할 수 있다.

두번째 생성된 .class 파일을 실행시킨다.

$ java 파일명

앞 명령어는 javac가 아니고 java이다. .class 확장자는 입력하지 않는다.

또다시 에러...........

여기서 정말 힘들었다.. 파일이 실행되지 않고 계속 오류가 났다. 그러다 알게된사실은 java파일에 pakage 선언으로 인한 오류였다. 패키지 선언이 포함되어 있다면 파일을 디렉토리 경로에 따라 저장해야한다.

디렉토리명을 붙이고 다시 시도해봤다.

결과는 성공!!!!

$ javac 패키지명(디렉토리명)/파일명.java

$ java 패키지명(디렉토리명)/파일명

이렇게 블로그에 올리고 나니 과정이 굉장히 짧아 보이지만 도커 이미지도 몇번을 만들었다 지우고 AWS EC2 서버의 인스턴스도 새로 다시 생성했어야 했다.. 결국 돌아돌아 파일을 전송해 해결했고 자바파일을 실행하는데도 고난이... 다음번엔 과거에 스프링 프레임워크로 진행했던 팀프로젝트를 스프링부트로 바꿔볼 예정이다.

(2) Object 배열

package lang.object.poly;

public class ObjectPolyExamle2_1 {

    public static void main(String[] args) {
        Dog dog = new Dog();
        Car car = new Car();
        Object object = new Object();

        Object[] objects = {dog, car, object};

        size(objects);
    }

    private static void size(Object[] objects) {
        System.out.println("전달된 객체의 수는: " + objects.length);
    }
}

• Object 타입을 사용하여 모든 객체를 담을 수 있는 배열을 만들 수 있다.
• size메서드에서 매개변수가 Object타입이기 때문에 모든 객체를 매개변수로 전달 가능하다.

2. Object

모든 클래스가 Object클래스를 상속받는 이유

• 필수적인 기능을 공통된 이름으로 사용하기위함.
• 객체를 생성할 때 마다 필수적인 기능의 메서드를 반복해 정의할 필요가 없어짐.

(1) Object 다형성의 장단점

• 모든클래스의 부모클래스(슈퍼클래스)이므로 모든 객체를 참조할 수 있다.
• 메서드의 매개변수에 Object타입을 사용하면 어떤 객체든지 인자로 전달 할 수있는 장점이 있다.
• Object를 통해 전달 받은 객체를 호출할때 Object가 가장 상위에 있는 부모이기 때문에 각 객체에 맞는 다운캐스팅 과정이 필요하다.

package lang.object.poly;

class Car {
    public void move() {
     System.out.println("자동차");
    } 
}

package lang.object.poly;

class Dog {
    public void sound() {
     System.out.println("멍멍");
    } 
}

package lang.object.poly;

public class ObjectPolyExample1 {

 Public static void main(String[] args) {
     Dog dog = new Dog();
    Car car = new Car();
    //Object dog = new Dog(); 로 변경가능
    //Object car = new Car(); 로 변경가능
    // => 부모는 자식을 담을 수 있기때문.

    action(dog);
    action(car);
 }

 public static void action(Object obj) {
  //obj.sound(); ->컴파일오류, Object에는 sound()가 없다.
  //obj.move(); ->컴파일오류, Object에는 move()가 없다.

  //객체에 맞는 다운캐스팅이 필요하다.
  if (odj instanceof Dog dog) {
       dog.sound();
  } else if (odj instanceof Car car) {
    car.move();
  }
 }
}

실행결과

멍멍 자동차

다운캐스팅 복습

• 자식클래스의 레퍼런스가 부모클래스의 인스턴스를 참조하는 것
• 부모클래스의 인스턴스를 자식클래스 타입으로 형변환하는 것
• 참조 가능한 영역이 확대됨
• 자동 형변환이 일어나지 않음 = 명시적(강제) 형변환 필요
• 강제 형변환을 통해 구문 오류가 해결되더라도 실제 실행 시점에서 오류(실행 오류)가 발생하게 됨 => 존재하지 않는 영역의 참조 위험성 때문
• 무조건 다운캐스팅이 성립하는 것이 아니라 반드시 자식객체가 부모타입으로 자동 변환하면 부모타입에 선언된 필드와 메소드만 사용 가능하다는 제약이 있다.