왕초보 개발자

📌 자원의 위치와 식별(접근, 경로) 방법에 따른 분류

  1. file system resource : 파일 시스템 상에 존재하는 파일 형태, 물리 경로를 통한 직접 접근.
     ex) D:\00.medias\images\cat1.jpg

  2. class path resource : class path 상에 존재하는 자원
     ex) /images/cat1.jpg : class path 기준의 절대 경로(qualified name)로 접근(논리 경로)
     ex) kr.or.ddit.servlet01.DescriptionServlet == kr/or/ddit/servlet01/DescriptionServlet
     ex) /kr/or/ddit/sample.properties

  3. web resource : web 상에 존재하는 자원, URL/URI 형태의 주소를 통한 접근
     ex) https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png
     ex) http://localhost/WebStudy01/resources/images/cat1.jpg
     ex) /resources/images/cat1.jpg
     ex) /WebStudy01/resources/images/cat1.jpg
     ex) ../resources/images/cat1.jpg

📌URL(URI) 표기 방식

  * 절대 경로 (클라이언트가 사용하는지 서버가 사용하는지 먼저 구분 )

      protocol://ip[dn][:port]/context/depth../resourcename
    - CLIENT SIDE : /WebStudy01/resources/images/cat1.jpg  =>프론트엔드에서 동작할 때 사용 
         -> window.location 객체의 모든 프로퍼티는 생략 가능

     - SERVER SIDE : /resources/images/cat1.jpg  => 백엔드에서 동작할 때 사용 
        <%=application.getContextPath() %>
        <%
          String file = application.getResource("/resources/images/cat1.jpg").getFile();
          out.println(file);
         %>

    *상대 경로 : 현재 위치를 기준으로 한 상대적 경로 표현
    CLIENT SIDE: window.location.href 를 기준으로 경로 표현

 URI(Uniform Resource Identifier) : 네트워크상의 자원을 가리키는 고유 식별자(*ID)이다.
   ex) /image/imageForm.do => URI에 가깝다

   URI의 하위개념

📌서블릿이란?

WAS 의해 관리되는 객체의 형태로, 웹상에서 발생한 요청을 받고, 그에 대한 응답을 전송할 수 있는 객체들의 요건에 대한 명세(spec) 

 1. 서블릿 기초

서블릿은 JSP표준에 앞서 자바에서 웹 어플리케이션 개발을 위해 만들어진 표준으로, 규약에 따른 서블릿 개발 과정은 

다음과 같다.

  - 서블릿 규약에 따라 자바 코드를 작성(HttpServlet 상속 후 필요 메소드 재정의)

  - 자바 코드를 컴파일 하여 클래스 파일 생성

  - 클래스 파일을 /WEB-INF/classes 디렉토리 패키지 구조에 따라 저장

  - web.xml 파일에 서블릿 클래스 등록 및 리퀘스트와의 매핑

    (서블릿 3.0 규약부터 @WebServlet 어노테이션으로 대체)

  - 톰캣 등의 컨테이너 재실행(서블릿 리로딩 기능이 있는 경우 생략)

  - 웹 브라우저에서 요청 처리 결과 확인

 WAS(Web Application Server), Web Container, Servlet Container, JSP Container
   * Containr ? 내부의 관리객체(Component)에 대한 생명주기 관리사(운영 주체), 
                     객체 관리 중 발생하는 이벤트들에 대한 콜백(callback)구조를 가짐
                      $("#btn").on('click function(실행코드)} 
    - Servlet Containr ? 내부의 관리객체(Servlet)에 대한 생명주기 관리사(운영 주체)
    - JSP Containr ? 내부의 관리객체(JSP)에 대한 생명주기 관리사(운영 주체)

   *서블릿의 callback 메소드 종류

    - lifecycle callback :  생명주기 내에서 단 한 번씩 호출 ex) init, destroy

    - request callback : 요청 발생시마다 각 쓰레드 내에서 반복 호출되는 메소드

                                 ex) service , doxxx(service 에 의해 호출되고, request method에 따라 선택됨) 

        - 콜백 메소드 호출 순서

          객체 생성 직후 init 호출 -> 리퀘스트 발생시 service 호출 -> service메소드내에서 현재 리퀘스트의 http method

           구분 후 해당 doxxx 메소드 호출 -> 객체 소멸 직전 destroy 호출

 *서블릿 개발 단계
   1. HttpServlet 을 상속받은 구현체 정의
     - 필요한 callback 메소드 재정의
   2. compile : /WEB-INF/classes(context 's classpath)에 배포  
   3. 컨테이너에 등록
    - 2.x : web.xml -> servlet -> servlet-name, servlet-class, loadstartup, init-param

              - servlet-name : 컨테이너 내에서 관리되는 서블릿 인스턴스의 이름을 지정

              - servlet-class : 컨테이너 내에서 관리될 서블릿 클래스를 지정

              - init-param : 서블릿의 초기화 파라미터 설정(param-name, param-vlaue 로 구성)

              - load-on-startup : 서블릿의 인스턴스 생성 순위 지정                   
    - 3.x : @webServlet

   4. 서블릿 매핑
    - 2.x : web.xml -> servlet-mapping => servlet-name, url-pattern
    - 3.x : @WebServlet(value, urlPatterns)
    url : 
    경로 매핑 : ex) image/imageForm.do(절대 경로)
    확장자 매핑 : ex) *.l306, *.jsp (경로를 포함하지 않는다.)
    /image/*.l306(X)

 MIME(Multipurpose Internet Mail extensions)

  : 원래 목적은 이메일의 첨부되는 데이터의 타입(확장자)를 지정하기 위한 텍스트였으며,

    현재는 메일 뿐만 아니라 HTTP 등의 프로토콜에서 응답 데이터의 타입을 설명하기 위한

    목적으로 사용되고 있다.

    mainType/subType;charset=XXX
     ex) text/html;charset=UTF-8, text/plain;charset=UTF-8
           text/javascript, text/css
          image/gif, video/mpeg, audio/mp4

 2. URL 패턴 매핑 규칙

  웹 컨테이너에 등록된 서블릿은 웹상의 리퀘스트르 직접 처리할 수 있도록 url과의 매핑 과정이 필요하다

  web.xml에 직접 등록과정을 거치는 경우, <url-pattern> 엘리먼트를 통해 매핑 설정을 하고 @WebServlet

  을 사용하는 경우, 어노테이션의 속성으로 매핑 설정을 할 수 있다.

   (1) 매핑 규칙의 종류

      1. '/'로 ㅣ작하고 '/*' 로 끝나는 패턴은 경로 매핑을 위해 사용

      2.'*./' 로 시작하는 패턴은 확장자에 대한 매핑을 할 때 사용

      3. 오직 '/'만 포함하는 경우 어플리케이션의 기본 서블릿의로 매핑

 3. 서블릿 동작 과정(Servlet Contatiner의 역할)

    (1) 서블릿 요청 처리 과정

         등록 및 매핑 과정을 거친 서블릿이 매핑된 url을 사용한 요청을 처리하는 과정

         매핑 url패턴에 맞는 리퀘스트 발생 ->

         서블릿 컨테이너에서 매핑 서블릿의 인스턴스 검색 있다면: 해당 서블릿의 콜백 메소드 호출 

                                                                                           없다면: 해당 서블릿의 인스턴스 생성 -> 

                                                                                           서블릿의 콜백 메소드 호출

     (2) 서블릿 동작 과정에서 서블릿 컨테이너의 역할

       서블릿 컨테이너는 웹 어플리케이션 서버에서 Http 요청을 받아 처리하는 기초 역할을 담당한다.

       앞서 살펴본 서블릿의 동작 절차를 보면, 등록된 url-pattern에 매핑되는 리퀘스트를 서블릿에게

       처리 위임하기 위해 인스턴스를 생성 및 관리하며 적절한 형태의 콜백 메소드(service)를 호출해주는

       역할을 담당하는 것이 곧 서블릿 컨테이너라 할 수 있다.

4. 서블릿의 단점 및 JSP 사용 이유

    1. 스크립트 방식에 비해 구현 후 반드시 컴파일 및 등록과 매핑이라는 과정을 거쳐야 한다.

    2. 서블릿 리로딩 기능이 없는 WAS의 경우에, 등록 후 웹 리퀘스트를 받기 위해서는 컨테이너를 재시작

        해야 한다.

    3. 어플리케이션 구현 소스 내에 구성 스크립트 소스가 들어가므로 웹 디자이너와 웹 개발자 사이의 역할 분담

        및 협업이 자연스럽지 못한 단점이 있다

📌SOLID:

S : 단일 책임 원칙 : 한 클래스는 하나의 책임만 가져야한다.

O : 개방 폐쇄 원칙 : 소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.

L :  리스코프 치환 원칙 : 프로그램의 객체 는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로

                                        바꿀 수 있어야 한다
I : 인터페이스 분리 원칙 : 특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫다

D : 의존관계 역전 원칙 : 프로그래머는 “추상화에 의존해야지, 구체화에 의존하면 안된다

📌model1 과 model2의 차이

model1 : 

하나의 서블릿이 모든걸(요청,응답) 처리

JSP 파일 내에서 뷰와 컨트롤러가 모두 실행되어지는 구조를 지닙니다.

즉, JSP 페이지에  로직을 처리하기 위한 코드와 출력을 담당하는 코드가 함께 존재합니다.

이는 웹브라우저의 요청과 요청에 대한 작업을 처리함과 동시에 클라이언트에게 결과를 출력하게 됩니다.

- 장점

• 단순한 구조로 인해 개발 기간이 짧습니다.
• 난이도가 낮습니다

- 단점

• 복잡도가 높아질수록 기능이 섞인 코드때문에 유지보수가 어렵습니다.
• 디자이너와 개발자 간 의사소통이 필요합니다.

model2 : 

웹 개발에 MVC 패턴을 적용해 model1에 비해 더욱 편리하게 유지보수할 수 있도록 하였습니다.

위에서 설명한 MVC 패턴의 작동구조와 같이

웹 브라우저의 요청을 컨트롤러가 받고,  모델에서 요청에 대한 결과를 도출합니다.

이후 다시 컨트롤러가 사용자에게 보여줄 알맞은 뷰를 선택하고 데이터를 전달하면

마지막으로 뷰는 사용자에게 화면을 출력해주게 됩니다.

대부분 Model은 JavaBean / View는 JSP / Controller는 Servlet에서 담당하게 됩니다.

- 장점

• 컨트롤러와 뷰의 분리로 인해 유지보수와 확장이 편리합니다.
• 디자이너와 개발자의 작업이 분리되어 분업에 용이합니다.

- 단점

• 개발 초기 단계에 구조 설계에 비교적 많은 작업량과 시간이 필요합니다.
• 자바와 구조에 대한 깊은 이해도가 필요하기 때문에 높은 수준을 요합니다.

main07.py

from random import random
import sys

from PyQt5 import uic 
from PyQt5.QtWidgets import QApplication, QWidget, QMainWindow
from numba.tests.npyufunc.test_ufuncbuilding import equals
from PyQt5.Qt import QMessageBox


form_class = uic.loadUiType("./main07.ui")[0]

class MyWindow(QMainWindow, form_class): 
    def __init__(self): 
        super().__init__() 
        self.setupUi(self)
        
        self.pb1.clicked.connect(self.btnClick)
        self.pb2.clicked.connect(self.btnClick)
        self.pb3.clicked.connect(self.btnClick)
        self.pb4.clicked.connect(self.btnClick)
        self.pb5.clicked.connect(self.btnClick)
        self.pb6.clicked.connect(self.btnClick)
        self.pb7.clicked.connect(self.btnClick)
        self.pb8.clicked.connect(self.btnClick)
        self.pb9.clicked.connect(self.btnClick)
        self.pb0.clicked.connect(self.btnClick)
        self.pb_call.clicked.connect(self.myCall)
     
    def myCall(self):
        str_tel = self.le.text()
        QMessageBox.about(self,'calling',str_tel)
      
    def btnClick(self,):
        print("버튼이 클릭되었습니다.")
        a = self.sender().text()
        str_new = self.sender().text()
        str_old = self.le.text()  
        self.le.setText(str_old+str_new);

if __name__ == "__main__": 
    app = QApplication(sys.argv) 
    myWindow = MyWindow() 
    myWindow.show() 
    app.exec_()

📌결과

main08.py

from random import random
import sys

from PyQt5 import uic 
from PyQt5.QtWidgets import QApplication, QWidget, QMainWindow


form_class = uic.loadUiType("./main08.ui")[0]

class MyWindow(QMainWindow, form_class): 
    def __init__(self): 
        super().__init__() 
        self.setupUi(self)
        
        self.pb.clicked.connect(self.btnClick)
        self.le_mine.returnPressed.connect(self.btnClick)

        
    def btnClick(self):
        print("버튼이 클릭되었습니다.")
        
        mine =self.le_mine.text();
        com = ""
        result = ""
        
        rnd = random(); 
        if rnd > 0.66 :
            com = "가위";
        elif rnd > 0.33 :
            com = "바위";
        else :
            com = "보";
        print(com)   
        
        
        
        if mine == com  :
            result = "비김" 
        elif mine =="가위" and com =="보" or mine == "바위" and com =="가위" or mine =="보" and com =="바위" :
            result = "이김" 
        else :
            result = "짐"
            
        print(result)
        
        
        self.le_com.setText(com);
        self.le_result.setText(result);
        
        

if __name__ == "__main__": 
    app = QApplication(sys.argv) 
    myWindow = MyWindow() 
    myWindow.show() 
    app.exec_()

📌결과

ooptest02.py

class Trump:
    def __init__(self):
        self.cnt_building = 50
    def maemae(self,cnt):
        self.cnt_building += cnt
        
if __name__ == '__main__':
    t = Trump()
    print(t.cnt_building)
    t.maemae(7)
    print(t.cnt_building)

결과

50
57

ooptest03.py

from day03.ooptest02 import Trump

if __name__ == '__main__':
    
    t = Trump()
    print(t.cnt_building)
    t.maemae(10)
    print(t.cnt_building)

결과

50
60

ooptest04.py

class LeeJY:
    def __init__(self):
        self.pocket = ["삼성전자"]
    def insu(self,company_name):
        self.pocket.append(company_name)

ooptest05.py

from day03.ooptest02 import Trump
from day03.ooptest04 import LeeJY


class KimJH(Trump, LeeJY):
    def __init__(self):
        
        Trump.__init__(self)
        LeeJY.__init__(self)
        
if __name__ == '__main__':
    k = KimJH()
    print(k.cnt_building)
    print(k.pocket)
    k.maemae(10)
    k.insu("애플")
    print(k.pocket)
    print(k.cnt_building)

결과

50
['삼성전자']
['삼성전자', '애플']
60

ooptest01.py

class Vehicle:
    def __init__(self):
        print("생성자")
        self.cnt_wheel = 2    
    def addWheel(self):
        self.cnt_wheel += 2
    def __del__(self):    
        print("소멸자") 

class Car(Vehicle):
    def __init__(self):
        self.amount_fuel = 0
        super().__init__()
    def mantank(self):
        self.amount_fuel = 100
    def onedollor(self):
        if self.amount_fuel >= 100:
            print("만땅이유")
            return 
        self.amount_fuel+=1
                  
c = Car()
print(c.cnt_wheel)
print(c.amount_fuel)
c.addWheel()
c.mantank()
c.onedollor()
print(c.cnt_wheel)
print(c.amount_fuel)

결과

생성자
2
0
만땅이유
4
100
소멸자

test01-1.py

from random import random

mine = ""
com = ""
result = ""

mine = input("가위바위보 입력 ")

rnd =random()
if rnd > 0.66 :
    com ="가위"
elif rnd > 0.33:
    com ="바위"
else :
    com ="보"
print("com",com)    

if com == mine :
    result = "비김"
elif com =="가위" and mine=="바위" or com=="바위" and mine=="보" or com=="보" and mine=="가위":
    result = "이김"
else :
    result ="짐"  
    
print("mine",mine)     
print("결과 : ",result)

test01-2.py

from random import random

com = ""
mine = ""
result = ""

mine = input("가위바위 보를 입력하세요") 

rnd = random()
if rnd > 0.66 :
    com ="가위"
elif rnd > 0.33 :    
    com = "바위"
else :
    com ="보"    

if com == "가위" and mine ="가위" result="비김"
if com == "가위" and mine ="바위" result="승리"
if com == "가위" and mine ="보" result="패배"

if com == "바위" and mine ="바위" result="비김"
if com == "바위" and mine ="보" result="승리"
if com == "바위" and mine ="가위" result="패배"

if com == "보" and mine ="보" result="비김"
if com == "보" and mine ="가위" result="승리"
if com == "보" and mine ="바위" result="패배"

print("나",mine)
print("컴",com)
print("결과 : ",result)

📌client/server  환경의 이해

정보시스템의 구성 요소와 정보를 요청하는 클라이언트와 정보를 제공하는 서버로 분리하는 네트워크 아키텍처가 등장했는데 이를 클라이언트/서버 아키텍처라 한다.

  (1) Client/Server 아키텍처 구성요소

  * presentation Rules : 사용자 인터페이스를 담당(User Interface)

  * Application logic(Business Rules) : 업무 프로세스(Business process)를 정의

  * Data Access Rules : Data Service 를 담당하는 영역에 access 담당

W.S(웹서버, 정적컨텐츠)

웹브라우저의 요청을 받아 그에 따른 결과(응답)을 웹브라우저에 전송

주로 정적인 HTML, 이미지, CSS, 자바스크립트 파일을 웹브라우저에 제공할 때사용

  주요제품) Apache,IIS 등

W.A.S(웹어플리케이션서버, 동적컨텐츠)

게시글 목록, 로그인 처리와 같은 기능, 즉 로직을 실행(처리)하고, 그 결과를 응답으로 웹 서버에 전달

     1.로우데이터 확보(dao) 
     2.인포메이션화(service) 
     3.언어화시켜 컨텐츠로 만듬(view)/controller: 클라이언트의 요구사항분석         

주요제품) Tomcat, Jeus 등                                                             
                                                                      

  W.A.S가 필요한 이유
1 개발환경 상에서 없는 api를 빌려쓰기 위해
2 클라이언트가 언제 어디서 요청을 보낼지 몰라서 24시간 대기할 수 있는 80번 포트를 대기할 수 있는 상태로 한다
  (특정포트 감시)
3 백그라운드에서 동작할 수 있는 어플리케이션을 운영하다가 관련 요청이 들어오면 서비스를 제공한다(=컨테이너)

* Client/Server 시스템 관련 용어

1. 서블릿이란?

• HTTP protocol 서비스를 지원하는 javax.servlet.http.HttpServlet 클래스를 상속하여 개발하며, Servlet은 컨테이너에 의해서 실행되고 관리된다.
• HTML 변경 시 Servlet을 재컴파일해야 하는 단점이 있다.
• 서블릿은 외부 요청마다 프로세스보다 가벼운 스레드로써 응답한다.

2. JSP와 서블릿의 차이점

  기능의 차이는 없고 컨테이너의 역할의 차이만 있다. 

1. JSP : HTML 문서 안에 java 코드를 포함하고 있다. MVC에서 View 역할
2. 서블릿 : 자바 코드 안에 HTML을 포함하고 있다. 주로 MVC에서 컨트롤러 역할

3. 서블릿 컨테이너(톰캣 등)란?

• HTTP 요청을 받아서 Servlet을 실행하고 생명주기를 관리하는 역할을 한다.
• servlet과 웹서버가 통신할 수 있는 방법을 제공
• 멀티 스레딩을 지원하여 클라이언트의 다중 요청을 알아서 처리

4.JSP 컨테이너(톰캣 등)란?

  JSP를 서블릿으로 변환하는 프로그램

​

- JSP 컨테이너 역시 서블릿으로 구현된 프로그램

- JSP 컨테이너가 JSP 파일을 서블릿 소스로 변환할 때의 기본 스펙은 컨테이너마다 동일하며, 상속관계나 생성되는 서블릿 클래스명만 다르게 생성된다

​

JSP 컨테이너는 JSP 파일을 서블릿 소스로 변환 및 컴파일까지만 담당하는 프로그램이며,

변환된 서블릿의 수행은 서블릿 컨테이너가 담당

​

5. 서블릿과  JSP의 특징

 Servlet

 Java 코드 안에 HTML 코드 (하나의 클래스)
 data processing(Controller)에 좋다.
 즉 DB와의 통신, Business Logic 호출, 데이터를 읽고 확인하는 작업 등에 유용하다.
 Servlet이 수정된 경우 Java 코드를 컴파일(.class 파일 생성)한 후 동적인 페이지를 처리하기 때문에 전체 코드를 업데이   트하고 다시 컴파일한 후 재배포하는 작업이 필요하다. (개발 생산성 저하)

JSP

 HTML 코드 안에 Java 코드
 presentation(View)에 좋다.
 즉 요청 결과를 나타내는 HTML 작성하는데 유용하다.
 JSP가 수정된 경우 재배포할 필요가 없이 WAS가 알아서 처리한다. (쉬운 배포)