[비트캠프] 72일차(15주차4일) - Mybatis(톰캣 서버)

 

DAO 구현체

 

DAO 구현체를 Proxy 객체가 생성했다.

Handler 에서 DAO 구현체 사용해서 insert() 하면 InvocationHandler 구현체의 invoke() 실행한다. 매개변수에 객체 정보, 메서드 정보, 파라미터 정보 전달되고 결과 리턴된다.

 

 

 

DAO 구현체와 InvocationHandler

 

각 Dao 구현체가 각 InvocationHandler 구현체를 사용한다.

 

 

각 Dao 구현체가 같은 InvocationHandler 구현체를 사용한다.

 

 

 

44. Application Server에 웹기술 적용

 

기존

Local 의 ClientApp 에서 Application Server 의 ServerApp 으로 요청(통신)한다. 여기서 DBMS 의 MariaDB 로 요청(통신)하고 응답 받아 전달한다.

 

변경

Local 의 Web Browser 에서 Application Server 의 Web Server 로 요청(HTTP)한다. 여기서 Application Server 로 위임하고 여기서 App. 을 call 해서 리턴 받아 응답한다. 기존 ServerApp 을 둘로 나눈 것이 Web Server 와 Application Server 이다.

 

Local 의 Client app.을 개발할 필요가 없다.

Application Server 의 Server app 개발 불필요하다. 통신 프로그래밍X, 멀티스레딩X, 프로토콜X

DBMS 의 Client 요청을 처리하는 app. 만 개발하면 된다.

 

### 44. Web Application Server 구조로 전환하기
- 웹 기술 도입  - 웹 기술을 도입하여 애플리케이션 서버를 구현하는 방법

 

package bitcamp.util;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import bitcamp.myapp.dao.BoardDao;

public class DaoGenerator implements InvocationHandler {

  SqlSessionFactory sqlSessionFactory;

  public DaoGenerator(SqlSessionFactory sqlSessionFactory) {
    this.sqlSessionFactory = sqlSessionFactory;
  }

  @SuppressWarnings("unchecked")
  public <T> T getObject(Class<T> classInfo) {
    String className = classInfo.getName();

    return (T) Proxy.newProxyInstance(
        getClass().getClassLoader(), // 현재 클래스의 로딩을 담당한 관리자: 즉 클래스 로딩 관리자
        new Class[] {classInfo}, // 클래스가 구현해야 할 인터페이스 정보 목록
        this // InvocationHandler 객체
        );
  }

  // 자동 생성된 프록시 객체에 대해 메서드를 호출하면
  // 실제 InvocationHandler의 invoke()가 호출된다.

  // 프록시 객체에 대해 메서드를 호출하면 이 메서드가 실행된다.
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    SqlSession sqlSession = sqlSessionFactory.openSession();

    String daoName = proxy.getClass().getInterfaces()[0].getSimpleName();
    String methodName = method.getName();
    String sqlStatementName = String.format("%s.%s", daoName, methodName);
    System.out.printf("%s.%s() 호출!\n", daoName, methodName);
    Class<?> returnType = method.getReturnType();

    if (returnType == int.class || returnType == void.class) {
      return args == null ? sqlSession.insert(sqlStatementName) :
        sqlSession.insert(sqlStatementName, args[0]);
    } else if (returnType == List.class) {
      return args == null ? sqlSession.selectList(sqlStatementName) :
        sqlSession.selectList(sqlStatementName, args[0]);
    } else {
      return args == null ? sqlSession.selectOne(sqlStatementName) :
        sqlSession.selectOne(sqlStatementName, args[0]);
    }
  }


  public static void main(String[] args) throws Exception {

    BitcampSqlSessionFactory sqlSessionFactory = new BitcampSqlSessionFactory(
        new SqlSessionFactoryBuilder().build(
            Resources.getResourceAsStream("bitcamp/myapp/config/mybatis-config.xml")));

    DaoGenerator generator = new DaoGenerator(sqlSessionFactory);
    BoardDao dao = generator.getObject(BoardDao.class);

    //    Board b = new Board();
    //    b.setTitle("테스트1");
    //    b.setContent("테스트내용1");
    //    b.setPassword("1111");
    //    dao.insert(b);

    //    List<Board> list = dao.findAll();
    //    for (Board b : list) {
    //      System.out.println(b);
    //    }

    //    Board b = new Board();
    //    b.setNo(17);
    //    b.setTitle("테스트1xxx");
    //    b.setContent("테스트내용1xxxx");
    //    b.setPassword("1111");
    //    dao.update(b);

    //    dao.delete(17);
    //
    //    List<Board> list = dao.findAll();
    //    for (Board b : list) {
    //      System.out.println(b);
    //    }
    //    System.out.println(dao.findByNo(17));
  }

}

 

public class ServerApp {

  StudentHandler studentHandler;
  TeacherHandler teacherHandler;
  BoardHandler boardHandler;
  HelloHandler helloHandler = new HelloHandler();

  public static void main(String[] args) {
    try {
      new ServerApp().execute(8888);
    } catch (Exception e) {
      System.out.println("서버 실행 오류!");
      e.printStackTrace();
    }
  }

  public ServerApp() throws Exception{

    // Mybatis API 사용 준비
    // 1) Mybatis 설정 파일 준비
    //    => resources/bitcamp/myapp/config/mybatis-config.xml

    // 2) SQL Mapper 파일 준비
    //    => resources/bitcamp/myapp/mapper/BoardMapper.xml

    // 3) Mybatis 설정 파일을 읽을 때 사용할 입력 스트림 객체 준비
    InputStream mybatisConfigInputStream = Resources.getResourceAsStream(
        "bitcamp/myapp/config/mybatis-config.xml");

    // 4) SqlSessionFactoryBuilder 객체 준비
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

    // 5) builder를 이용하여 SqlSessionFactory 객체 생성
    // 6) 오리지널 SqlSessionFactory에 트랜잭션 보조 기능이 덧붙여진 프록시 객체를 준비한다.
    BitcampSqlSessionFactory sqlSessionFactory = new BitcampSqlSessionFactory(
        builder.build(mybatisConfigInputStream));

    // 7) BitcampSqlSessionFactory객체를 이용하여 트랜잭션을 다루는 객체를 준비한다.
    TransactionManager txManager = new TransactionManager(sqlSessionFactory);

    // DAO 구현체 생성기 준비
    DaoGenerator daoGenerator = new DaoGenerator(sqlSessionFactory);

    // DAO 제너레이터를 이용한 DAO 구현체 생성
    BoardDao boardDao = daoGenerator.getObject(BoardDao.class);
    MemberDao memberDao = daoGenerator.getObject(MemberDao.class);
    StudentDao studentDao = daoGenerator.getObject(StudentDao.class);
    TeacherDao teacherDao = daoGenerator.getObject(TeacherDao.class);

    this.studentHandler = new StudentHandler("학생", txManager, memberDao, studentDao);
    this.teacherHandler = new TeacherHandler("강사", txManager, memberDao, teacherDao);
    this.boardHandler = new BoardHandler("게시판", boardDao);
  }

 

 

 

Web Application Architecture

 

Web Browser 에서 요청(HTTP)을 Web Server 로 하면 위임을 Application Server 로 한다. 여기서 App 을 call 하고 DBMS 와 통신하여 응답을 전달한다.

 

 

 

Application Server Architecture : Servlet 기술

 

사용자가 Web Browser 로 입력하면 여기서 Web Server 로 요청한다. 여기서 App 을 call 하고 여기서 DBMS 와 통신한다. App 이 return 을 Web Server 로 하고 여기서 응답을 Web Browser 로 하면 여기서 사용자에게 출력한다.

 

Web Browser, Web Server 를 묶어서 Web 기술이라 한다. UI 생성 => HTML, CSS, JavaScript (표준기술)

 

App 은 Java, C#, ASP.NET (VBScript), Python, Perl, PHP, ... 무엇으로 작성해도 된다.

Java 언어를 웹기술과 결합해서 Application Server 를 쉽게 구축할 수 있도록 도와주는 기술이 "Servlet" 기술이다.

 

 

App 을 둘로 나눠 Application 관리자, App. 이 된다.

Application 관리자가 App. 을 call 하고 결과를 return 받는다.

Application 관리자는

- App. 생성 → 실행 → 소멸 관리

- 공유 자원 관리

- Web server 와의 연동 담당 : App 개발자가 Web server 로 부터 데이터를 받고 웹 서버에게 결과 데이터를 보내는 것은 관리할 필요가 없도록 대신 처리한다.

 

 

Web Application Architecture : Servlet / JSP

 

Web Browser 에서 요청(HTTP) 보내면 Web Server 가 Servlet Container 에 위임한다. 여기서 Servlet JSP 를 call 하고 DBMS 와 통신한다.

나중에 Web Server 와 Servlet Container 를 Tomcat Server 로 갈아끼운다.

 

Web Application(예: 인사관리시스템) 은 Servlet(예: 사원등록, 퇴사처리)들과 JSP(예: 사원 목록 조회)들로 이루어진다.

 

Servlet Container(Application 관리자) :

- 서블릿 객체 생성 → 실행 → 소멸을 관리

- DB 커넥션 등 공유자원 관리

* 서블릿 (Servlet = Server Application + let(작은 것을 의미하는 접미사))

- 서버 애플리케이션의 작은 기능

 

Servlet JSP(App.) : 작은 기능을 수행하는 서버 App. 조각

 

 

 

톰캣 서버 설치

 

tomcat.apache.org > Tomcat 9 > Binary Distributions Core: zip 및 Source Code zip 다운로드

 

~(사용자 홈) 에 server 폴더 만들고 아래 압축 파일 압축 푼 폴더 넣는다.

apache-tomcat-9.0.71.zip

apache-tomcat-9.0.71-src.zip

~/server/tomcat 서버 디렉토리/

bin/  ← 톰캣 서버를 구동시키는 쉘스크립트와 실행 파일이 들어있다.

conf/  ← 톰캣 서버 실행 파일들

lib/  ← .jar 자바 라이브러리 파일들. 톰캣 서버는 자바로 만든 프로그램이다.
           (톰캣서버를 실행하는데 필요한 자바 라이브러리)

logs/  ← 톰캣 서버가 실행하는 동안 시스템 상태를 출력할 로그 파일들

temp/  ← 톰캣 서버가 실행할 때 사용하는 임시 작업 폴더

☆webapps/  ← 톰캣 서버가 실행시킬 web app 들

work/  ← 톰캣 서버가 생성한 변환 파일들

 

 

 

서블릿/JSP 기술 규격

 

자바 서블릿/JSP 기술 규격으로

Tomcat Server 를 구현했고

서블릿을 작성 했다. 이는 Tomcat Server 가 call 한다.

 

Tomcat Server (application 관리)

개발자는 서버를 만들 때 Servlet/JSP 규격에 맞춰 개발해야 한다.

→ Servlet/JSP 규격에 맞춰 작성한 App. 을 실행할 수 있다.

 

서블릿 (app.)

개발자는 Web app. 을 개발할 때 Servlet/JSP 기술 규격에 맞춰 작성해야 한다.

→ Servlet/JSP 규격에 맞춰 개발한 서버에서 실행할 수 있다.

웹애플리케이션 개발자는 서블릿을 만드는 사람이다.

 

서블릿/JSP 규격에 따라 만든 서버 → Servlet/JSP Implementor → "Servlet Container"

→ 제품들:

Tomcat (무) : 가장 많이 씀

Racin (유)

Jetty (유/무)

Undertow (무) : 요즘 뜸

 

WebLogic (유)

WebSphere (무)

JBoss (유/무)

GlassFis (무)

Geronimo (무)

JEUS (유) - 국산. 공공시장 50% 차지

 

 

 

서버 실행

 

windows

apache-tomcat-9.0.71\bin 에서 아래 더블클릭한다.

실행 : startup.bat

종료 : shutdown.bat

 

 

macOS

server/apache-tomcat-9.0.71/bin> $ chmod755*.sh  # 권한 변경. 소유자 7, 다른 사용자 5, 손님 5

server/apache-tomcat-9.0.71/bin> $ ./start.sh  # 실행

server/apache-tomcat-9.0.71/bin> $ ./shutdown.sh  # 종료

 

 

 

Servlet App. 만들기

 

Archive : 묶음 파일

JAR  (Java Archive 파일)

WAR (Web Archive 파일)

EAR (Enterprise Application Archive 파일)

 

① 프로젝트를 Servlet/JSP 웹프로젝트로 전환

 

1) Servlet API 라이브러리 추가 → build.gradle

central.sonatype.com 에서 javax.servlet servlet-api 검색해서 4.0.1 코드 복사한다.

 

app-server 의 build.gradle 에 붙인다.

dependencies {

    // Servlet API 라이브러리
    // - 이 라이브러리는 개발하는 동안만 사용한다.
    //   즉 컴파일하거나 빌드할 때만 사용한다.
    // - 배포 파일에는 이 라이브러리를 제외시킨다.
    //   왜? 서블릿 컨테이너에 포함되어 있기 때문이다.
    providedCompile 'javax.servlet:javax.servlet-api:4.0.1'

 

 

2) 웹프로젝트 표준 디렉토리 구조로 전환

- 관련 디렉토리 생성

src/main 에 webapp 폴더 만든다. 전 세계 공통이다.

 

 

3) gradle plug-in 추가 : 'war', 'eclipse-wtp'

→ 웹애플리케이션 관련 Gradle 명령을 사용할 수 있다.

myapp-server/build.gradle 아래 처럼 수정한다.

plugins {
    id 'war'  // 웹 애플리케이션 관련 명령을 사용할 수 있다.
    id 'eclipse-wtp'  // 'eclipse' 플러그인이 자동 포함됨
}

 

 

4) eclipse 웹프로젝트 속성 설정

myapp-server/build.gradle 아래 코드 추가한다. (eomcs-java\eomcs-servlet\app\build.gradle 참고)

- war

- eclipse.wtp

// 웹 애플리케이션 배포 파일(.war)을 만들 때 사용할 기본 파일 이름을 설정한다.
// 이 이름은 웹 애플리케이션 context root 경로로도 사용된다.
war {
    archiveBaseName = "web"
}

eclipse {
    
    // 자바 웹 개발 도구에서 사용할 값을 설정한다.
    wtp {
        facet {
            //you can add some extra wtp facets or update existing ones; mandatory keys: 'name', 'version':
            facet name: 'jst.java', version: '17'
        }
        component {
            //you can configure the context path:
            //contextPath = '/web'

            //you can configure the deployName:
            //deployName = 'web'
        }
    }
}

아래 코드는 application 플러그인을 위한 설정이므로 삭제한다.

application {
    mainClass = 'bitcamp.myapp.ServerApp'
}

 

 

5) gradle cleanEclipse 실행 → gradle eclipse 실행

gradle 설정 재적용 한다.

 

 

6) 빌드 및 배포 테스트

gradle build 실행하면 app-server\build\libs 에 web.war 생성된다. (상세주소: \app-server\build\libs)

이 파일을 톰캣서버/webapps 에 복사 붙여넣기 한다. (상세주소: C:\Users\bitcamp\server\apache-tomcat-9.0.71\webapps)

10초 정도 대기하면 web 폴더 생성된다.

톰캣 서버 재실행 한다.

 

http://localhost:8080/web/index.html 접속시 페이지 나온다.

.

 

 

 

gradle build

 

build.gradle 의 plugins 에 id 'application' 라고 하고 gradle build 하면 Java Application Project → .jar 가 만들어진다.

  web > META-INF 폴더에 Application 부가정보가 들어있다.

build.gradle 의 plugins 에 id 'war' 라고 하고 gradle build 하면 Web Application Project → .war 가 만들어진다.

 

 

 

② 서블릿 앱 만들기

 

Web Browser 에서 Web Server 거쳐 요청을 Servlet Container 에 한다. Servlet Container 는 client 요청이 들어오면 Servlet 규칙에 따라 메서드를 호출한다.

 

Servlet Container (caller)로 HelloServlet (callee)을 call 한다.

 

《interface》Servlet 를 구현한 HelloServlet 에 다음과 같은 메서드가 있다. -- 외울것

init() { - }  ← 서블릿 객체 생성 후 즉시 : 작업에 필요한 준비. 1번 실행

service() { - }  ← 클라이언트 요청 마다 : 클라이언트의 요청 작업 수행 n번 실행

destroy() { - }  ← 웹 앱 종료할 때 : 사용한 자원 해제. 1번 실행

→ 위 셋을 서블릿 lifecycle 메서드라 한다.

getServletInfo() { - }  ← 서블릿의 간단한 설명 : 관리 기능에서 사용. n번 실행

getServletConfig() { - }  ← 서블릿 설정 정보 리턴 : 작업 중에 필요하면 사용. n번 실

 

 

myapp 에 servlet 패키지 생성 후 HelloServlet.java 생성한다.

package bitcamp.myapp.servlet;

import java.io.IOException;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;

// 이 클래스를 서블릿 컨테이너에 등록한다.
// 클라이언트에서 /hello URL로 요청을 했을 때 이 클래스를 실행한다.
@WebServlet("/hello")
public class HelloServlet implements Servlet {

  ServletConfig config;

  @Override
  public void init(ServletConfig config) throws ServletException {
    System.out.println("HelloServlet.init() 호출됨!");
    this.config = config;
  }

  @Override
  public void service(ServletRequest req, ServletResponse res)
      throws ServletException, IOException {
    System.out.println("HelloServlet.service() 호출됨!");
  }

  @Override
  public void destroy() {
    System.out.println("HelloServlet.destroy() 호출됨!");
  }

  @Override
  public String getServletInfo() {
    return "HelloServlet !!!";
  }

  @Override
  public ServletConfig getServletConfig() {
    return this.config;
  }
}

 

톰캣서버/webapps 가 루트주소가 된다. (상세주소: C:\Users\bitcamp\server\apache-tomcat-9.0.71\webapps)

 

 

 

서블릿 실행 요청과 메서드 호출 과정

 

Web Browser 에 http://localhost:8080/web/hello 입력하는데 이는 다음과 같다.

web : web app. 이름 = context root 

hello : 서블릿 경로(path)

 

Servlet Container 에서 HelloServlet 에 대해

① 객체 생성 (해당 서블릿을 처음 요청할때)

② init() 호출 (해당 서블릿을 처음 요청할때)

③ service() 호출

 

 

 

Eclipse IDE 와 Tomcat 서버 연동하기

 

① Eclipse IDE preferences 에 Tomcat 서버 경로 설정

Eclipse IDE 에서 Tomcat 서버를 실행할 수 있도록 서버가 설치된 경로를 알려 준다.

window > show view > servers 에서 Add and Remove 선택해서 서버 추가하거나 삭제한다.

 

톰캣 설정 상세 정보는 아래 참고한다.

eomcs-docs\devtool-userguide\eclipse-tomcat-webapp-settings.md

# 이클립스 + 톰캣 + 웹앱 설정

## 이클립스에 톰캣서버가 설치된 경로를 등록한다.
- "이클립스 환경설정 > Server > 런타임 환경" 선택
- 톰캣 서버 경로를 등록한다.
```
톰캣 서버 설치 경로:
c:/Users/사용자명/server/apache-tomcat-9.0.7 
```

## 웹앱 테스트로 사용할 서버 테스트 환경을 구축한다.
- 이클립스 "Servers" 뷰 > 컨텍스트 메뉴의 "new" > "Server" 선택
- 등록된 톰캣의 테스트 환경을 추가한다.
- 서버 테스트 환경의 설정 파일을 관리할 프로젝트가 생긴다.
- 톰캣 서버의 conf 폴더에 있는 설정 파일(*.xml)을 복사하여
  Servers 프로젝트/[테스트환경이름]-config/ 폴더에 복사한다. 
```
서버 테스트 환경 프로젝트:
c:/workspace/Servers/[테스트환경]-config/*.xml

```

## 웹 프로젝트를 생성한다. 
- 이클립스에서 "Dynamic Web Project"를 생성한다.
```
자바 웹 프로젝트 구조:
c:/workspace/[웹프로젝트명]
    /src            <= 자바 소스
    /WebContent     <= JSP, HTML, CSS, JavaScript, GIF, JPEG 등 웹 관련 파일 
        /WEB-INF
            /lib     <= 의존 라이브러리 
            web.xml  <= 배치에 관한 사항을 등록  
    /build/classes   <= 컴파일한 자바 클래스 파일  
    .project         <= 이클립스 프로젝트 설정 파일
    .classpath       <= 소스 파일 경로 및 의존 라이브러리 경로 정보
    /.settings/      <= 이클립스 프로젝트와 관련된 설정 파일
```

## 웹 프로젝트를 테스트 서버에 배치한다.
- 웹 프로젝트를 톰캣 서버에서 실행할 수 있도록 배치한다.
-
```
테스트 서버의 작업 폴더:
c:/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0
    /conf     <= 서버 테스트 환경 프로젝트에서 설정 파일을 복사해온다.
                 (c:/workspace/Servers/[테스트환경]-config/*.xml)
    /logs     <= 서버를 실행하는 동안 작업 내용을 기록
    /temp     <= 실행하는 동안 임시 파일을 생성, 삭제하는 폴더
    /webapps  <= 사용하지 않는다.
    /work     <= JSP를 실행할 때, 자동 생성된 자바 소스 파일과 클래스 파일
    /wtpwebapps <= 실제 웹 애플리케이션이 배치되는 폴더
이 폴더는 이클립스의 "Servers" 뷰에서 서버 테스트 환경을 지울 때 함께 제거된다.
주의! 
이 폴더에 내용을 직접 변경하지 말라.
```

## 배치 폴더 규격 
- 자바 웹 애플리케이션을 배치할 때 반드시 다음 구조로 배치해야 한다.
```
웹 애플리케이션 폴더 구조:
wtpwebapps/[웹애플리케이션 폴더]
    /hello     <= 하위 폴더를 생성한다.
    hello.html <= HTML, CSS, JavaScript, GIF, JPEG 등 정적 자원을 저장한다.
    hello.jsp  <= JSP 파일을 둔다.
    /WEB-INF   <= 웹 애플리케이션과 관련된 설정 파일을 두는 폴더.
        /classes    <= 컴파일된 자바 클래스 파일(.class)을 둔다.
                       실행하는 동안 사용할 설정파일을 둘 수도 있다.
                       예) .properties, .xml, .txt 등 
        /lib        <= 의존 라이브러리 파일(.jar)을 둔다.   
        web.xml     <= 웹 애플리케이션의 배치 정보를 담고 있는 파일.

 

eomcs-docs\devtool-userguide\tomcat-settings.md

# 톰캣 설치 및 설정

## 톰캣 서버 설치

- tomcat.apache.org 사이트에서 zip 파일을 내려 받는다.
- 특정 폴더에 압축을 푼다.
- 설치형이 아니다.
- Java로 만들었기 때문에 JRE 또는 JDK가 설치되어 있어야 한다.

## 톰캣 서버 설정

### 서버 포트 번호 변경

- $TOMCAT_HOME/conf/server.xml 변경
  - Connector 태그의 port 값을 8080에서 원하는 값으로 변경한다.
  - 예) Connector port="9999"...
  
## tomcat 관리자 아이디 등록하기

- $TOMCAT_HOME/conf/tomcat-users.xml 파일에 role 및 user 추가

```
  <role rolename="tomcat"/>
  <role rolename="manager-gui"/>
  <role rolename="admin-gui"/>

  <user username="tomcat" password="1111" roles="tomcat,manager-gui,admin-gui"/>
```

- $TOMCAT_HOME/conf/Catalina/localhost 폴더에 manager.xml 파일 추가하고 다음과 같이 작성한다.

```
<?xml version="1.0" encoding="UTF-8"?>
<Context privileged="true" antiResourceLocking="false"
         docBase="${catalina.home}/webapps/manager">
  <Valve className="org.apache.catalina.valves.RemoteAddrValve"
         allow="^.*$" />
</Context>

```

## 톰캣 서버 실행

- $TOMCAT_HOME/bin/startup.bat 실행(Windows)
- $TOMCAT_HOME/bin/startup.sh 실행(Unix/Linux)

 

 

② 개발 및 테스트용 배치 환경 구축

- 톰캣 서버가 설치된 폴더에 개발 중인 web app. 을 직접 배치하지 않기 위해

- 테스트용 배치 환경 및 폴더를 따로 준비한다.

  이클립스 워크스페이스 폴더(~/eclipse-workspace)/.metadata/.plugins/org.eclipse.wst.server.core

   워크스페이스 폴더는 Preferences > general > workspace 에서 확인 가능

 

webapps  : 이 폴더는 테스트 환경에서 사용하지 않는다.

wtpwebapps : web app 이 배치되는 폴더

 

SpringBoot = SpringFramework + Tomcat Server

 

서버 우클릭 후 Publish 클릭하면 org.eclipse.wst.server.core 에 파일 생성된다.

 

 

C:\Users\bitcamp\eclipse-workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\myapp-server\WEB-INF\classes\bitcamp\myapp\servlet 에 .class 파일 생성된다.

 

Tomcat 우클릭해서 Stop 해야 destroy() 호출되어 종료된다.

 

eclipse-workspace\Servers\Tomcat v9.0 Server at localhost-config 에 server.xml 파일 보면

Context docBase="myapp-server" path="/web" 으로 한다는 코드가 있다.

 

 

 

---

 

조언

 

*문법을 창의적으로 만들려 하지 말고 다양한 예제를 경험하라.

*미국은 전세계 모범이 될 수 없다. 개방된 국가 체제로 전세계 모든 천재들을 흡수해서 효율적인 산업을 만든다. 그러나 한국은 전세계 모범이 될 수 있다. 강제 주입과 학습으로 학생들을 길러서 저효율이지만 산업을 일궈낸다.

*과거 기술을 아는 게 미래 기술 대비하는데 중요하다. 기술이 계속 이어져 오기 때문이다.

*SI 개발에서 백엔드 핵심은 SQL 이다. 자동화가 되어 있기 때문에 단순 노동이 많다.

*프롬프트 엔지니어링이 떠오르고 있다. 질문을 어떻게 던지는지 연구한다.

 

 

---

 

과제

 

/