네트워크를 돌아다녀

IoC/DI 관련 실습 01 / 02

new민지(); — Mon, 8 Jan 2024 22:07:26 +0900

■■■ IoC/DI 관련 실습 01 ■■■

※ 스프링 프레임워크 없이 IoC/DI 개념 실습

○ 실습 성격 및 주요사항
   1. 콘솔 프로젝트
   2. 성적 처리
      국어, 영어, 수학 점수를 입력 받아 총점, 평균을 출력하는 프로그램

○ 물리적 파일 구성
   1. Record.java → 인터페이스
   2. RecordView.java → 인터페이스
   3. RecordImpl1.java → Record 인터페이스를 구현하는 클래스
   4. RecordImpl2.java → Record 인터페이스를 구현하는 클래스
   5. RecordViewImpl.java → RecordView 인터페이스를 구현하는 클래스
   6. Main.java → 클래스, main() 메소드를 포함하는 테스트 클래스

1. Record.java → 인터페이스

/* ================
 	Record.java
 	- 인터페이스
 ==================*/

package com.test.spr;

public interface Record
{
	public void setKor(int kor);
	public int getKor();
	
	public void setEng(int eng);
	public int getEng();
	
	public void setMat(int mat);
	public int getMat();

	public int getTotal();
	
	public double getAvg();

}

2. RecordView.java → 인터페이스

/* ===================
 	RecordView.java
 	- 인터페이스
 ====================*/

package com.test.spr;

public interface RecordView
{
	// setter 메소드 선언 
	public void setRecord(Record record);
	
	// 입력 액션 전용 메소드 선언
	public void input();
	
	// 출력 액션 전용 메소드 선언
	public void output();
	
}

3. RecordImpl1.java → Record 인터페이스를 구현하는 클래스

4. RecordImpl2.java → Record 인터페이스를 구현하는 클래스

RecordImpl2.java 클래스에서는 기본 점수 100점을 추가하고, 평균을 4로 나누었다.

/* =========================================
 	RecordImpl1.java
 	- 클래스
 	- Record 인터페이스를 구현하는 클래스
 ===========================================*/

package com.test.spr;

public class RecordImpl1 implements Record
{
	// 주요 속성 구성 
	private int kor, eng, mat;

	// Record 의 메소드 모두 재정의
	@Override
	public void setKor(int kor)
	{
		this.kor = kor;
	}

	@Override
	public int getKor()
	{
		return kor;
	}

	@Override
	public void setEng(int eng)
	{
		this.eng = eng;
	}

	@Override
	public int getEng()
	{
		return eng;
	}

	@Override
	public void setMat(int mat)
	{
		this.mat = mat;
	}

	@Override
	public int getMat()
	{
		return mat;
	}

	@Override
	public int getTotal()
	{

		int result = 0;
		
		result = this.getKor() + this.getEng() + this.getMat();
		
		return result;
	}

	@Override
	public double getAvg()
	{
		double result = 0;
		
		result = this.getTotal()/3.0;
		
		return result;
	}
	
}

/* ========================================================
 	RecordImpl2.java
 	- 클래스
 	- Record 인터페이스를 구현하는 클래스
 	- RecordImpl1 에 적용된 업무와 차별화된 업무 수행
 =========================================================*/

package com.test.spr;

public class RecordImpl2 implements Record
{
	// 주요 속성 구성 
	private int kor, eng, mat;

	// Record 의 메소드 모두 재정의
	@Override
	public void setKor(int kor)
	{
		this.kor = kor;
	}

	@Override
	public int getKor()
	{
		return kor;
	}

	@Override
	public void setEng(int eng)
	{
		this.eng = eng;
	}

	@Override
	public int getEng()
	{
		return eng;
	}

	@Override
	public void setMat(int mat)
	{
		this.mat = mat;
	}

	@Override
	public int getMat()
	{
		return mat;
	}

	@Override
	public int getTotal()
	{

		int result = 0;
		
		// 기본 점수(100점) 추가
		result = 100 + this.getKor() + this.getEng() + this.getMat();

		return result;
	}

	@Override
	public double getAvg()
	{
		double result = 0;
		
		// 기본 점수(100점)가 포함된 상태에서의 평균 처리
		result = this.getTotal()/4.0;

		return result;
	}	
	
}

6. Main.java → 클래스, main() 메소드를 포함하는 테스트 클래스

/* ===========================================
  	Main.java
  	- 클래스
  	- main() 메소드를 포함하는 테스트 클래스
 ============================================*/

package com.test.spr;

public class Main
{
	public static void main(String[] args)
	{
		// [스프링이 처리하고 관리하게 될 영역] 
		// → 즉, 스프링 컨테이너 안에서 벌어지게 될 상황
		//--------------------------------------------------------------------------
		
		// ① RecordImpl1(Record) 객체 생성 과정
		//RecordImpl1 rec1 = new RecordImpl1();
		Record rec1 = new RecordImpl1(); 				// RecordView 입장에서 dependency(의존 객체)
		
		// ② RecordImpl2(Record) 객체 생성 과정
		//RecordImpl2 rec2 = new RecordImpl2();
		Record rec2 = new RecordImpl2(); 				// RecordView 입장에서 dependency(의존 객체)
		
		
		// RecordViewImpl 객체 생성 과정
		// Record(의존 객체 → RecordImpl1) 객체 필요
		//RecordViewImpl view = new RecordViewImpl();
		RecordView view = new RecordViewImpl();
		
		//-- check~!!
		// (스프링 컨테이너안에서 일어날 일)
		// 의존 객체 주입
		//-- 의존 객체 주입 방법을 사용하게 되면 
		//   느슨한 결합을 구성할 수 있게 되고
		//   한 쪽의 변동상황이 다른쪽에 영향을 덜 줄 수 있게 된다.
		view.setRecord(rec2); 					//-- setter injection
												//-- (setter 를 통한 주입)
		
		//--------------------------------------------------------------------------
		
		view.input();
		view.output();
		
		
	}
	
	
}

■■■ IoC/DI 관련 실습 02 ■■■

※ 스프링 프레임 적용 IoC/DI 개념 실습

○ 실습 환경 구성
   → 스프링 자원을 활용할 수 있는 환경 구성
   1. 프로젝트 명 마우스 우클릭
   2. Build Path > Configure Build Path... 메뉴 선택
   3. Libraries 탭 선택 > Add External JARs...버튼 선택
   4. 필요한 jar 파일을 해당 프로젝트에 외부 라이브러리로 등록
      - 경로 1   → C:\s-f-3.0.2-with-docs\dist
        ·파일 1 → org.springframework.asm-3.0.2.RELEASE.jar
·파일 2 → org.springframework.beans-3.0.2.RELEASE.jar
        ·파일 3 → org.springframework.context-3.0.2.RELEASE.jar
        ·파일 4 → org.springframework.core-3.0.2.RELEASE.jar
·파일 5 → org.springframework.expression-3.0.2.RELEASE.jar
      - 경로 2   → C:\s-f-3.0.2-dependencies\org.apache.commons
C:\s-f-3.0.2-dependencies\org.apache.commons
                    \com.springsource.org.apache.commons.logging\1.1.1
        ·파일 6 → com.springsource.org.apache.commons.logging-1.1.1.jar

   5. 스프링 프레임워크의 환경 설정 파일을 XML 형식으로 생성
      생성 위치는 프로젝트 하위의 src 디렉터리 (현재 실습 환경은 콘솔이므로...)
      현재 실습 환경에서의 파일 이름은 사용자가 임의로 부여해서 생성하는 것이 가능
      → applicationContext.xml

   6. 생성한 applicationContext.xml 파일에
      스프링이 참조하게 될 객체에 대한 정보와 DI 설정을 추가하게 되며
      이와 같은 문서의 구성을 위해 스프링에서 제공하는 문서 참조
      - 참조 경로 → C:\s-f-3.0.2-with-docs\docs\spring-framework-reference\htmlsingle
        · 참조 파일 → spring-framework-reference.xml
        · 참조 위치 → III. Core Technologies
                             3.2.1. Configuration metadata
           → 링크로 이동하면 xml 샘플 파일을 확인할 수 있으며,
              이 내용을 복사하여 applicationContext.xml에 덮어쓰기(전체 선택 후 붙여넣기)

○ 실습 성격 및 주요사항
   1. 콘솔 프로젝트
   2. 성적 처리
      국어, 영어, 수학 점수를 입력 받아 총점, 평균을 출력하는 프로그램

○ 물리적 파일 구성
   1. Record.java → 인터페이스
      → SpringPrj 프로젝트의 기존 소스코드 활용
   2. RecordView.java → 인터페이스
      → SpringPrj 프로젝트의 기존 소스코드 활용
   3. RecordImpl1.java → Record 인터페이스를 구현하는 클래스
      → SpringPrj 프로젝트의 기존 소스코드 활용
   4. RecordImpl2.java → Record 인터페이스를 구현하는 클래스
      → SpringPrj 프로젝트의 기존 소스코드 활용
   5. RecordViewImpl.java → RecordView 인터페이스를 구현하는 클래스
      → SpringPrj 프로젝트의 기존 소스코드 활용
   6. Main.java → 클래스, main() 메소드를 포함하는 테스트 클래스
      → 수정 check~~!!
   7. applicationContext.xml
      → 프로젝트 > src 폴더 하위에 생성 (현재 파일의 이름은 임의로 지정가능)

7. applicationContext.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- ※ 스프링이 제공하는 환경 설정 XML 파일 샘플 -->
   	<!--    → 스프링이 생성하고 관리해야 할 객체들에 대한 정보 전달 -->
   	 
   	<!-- RecordImpl1 (Record) 클래스에 대한 객체 정보 전달 -->
   	<bean id="record1" class="com.test.spr.RecordImpl1"></bean>
   	 
   	<!-- RecordImpl1 (Record) 클래스에 대한 객체 정보 전달 -->
   	<bean id="record2" class="com.test.spr.RecordImpl2"></bean>

	<!-- RecordVieImpl (RecordView) 클래스에 대한 객체 정보 전달-->
	<bean id="view" class="com.test.spr.RecordViewImpl">
	
		<!-- RecordImpl1 또는 RecordImpl2 객체에 대한 DI 설정 정보 전달 -->
		<!-- 『property』엘리먼트는 setter 메소드에 대한 정의 -->
		<!-- 즉, 『setXxx()』메소드의 경우 『property name="xxx"』 -->
		<!-- 와 같은 형식으로 기술하여 설정하게 된다. -->
		<property name="record">
				
				<!-- 『ref』 엘리먼트에 의해 DI 객체에 대한 참조 지정 -->
				<ref bean="record2"/>
						
		</property>
		
		<!-- ※ 위 구문은 (line 23~28) -->
		<!--    <property name = "record" ref = "record1"></property> -->
		<!--    와 같은 형태로 작성해도 된다.-->
	
	</bean>

</beans>

여기서 ID record1, record2 는 변수명과 같이 사용자가 원하는 이름으로 지정하면 된다.

class 는 전달한 객체의 경로를 지정한다.

6. 수정된 Main.java → 클래스, main() 메소드를 포함하는 테스트 클래스

/* ===========================================
  	Main.java
  	- 클래스
  	- main() 메소드를 포함하는 테스트 클래스
 ============================================*/

package com.test.spr;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main
{		
		// ※ 스프링 프레임워크에서는 
		//    객체 생성 과정 및 DI(의존객체 주입)에 대한 설정은
		//    스프링 환경 설정 파일로 대체된다. (→ applicationContext.xml)
		
		// 스프링 프레임워크에게...
		// applicationContext.xml 파일을 읽어서
		// 생성 및 관리할 객체에 대한 정보를 얻을 수 있도록 해야한다.
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 『getBean()』메소드를 이용하여 사용자가 원하는 객체를 얻어낸다.
		//  메소드의 인자값으로 식별자(id)를 통해 구분하여 지정하게 된다.
		//RecordView view = (RecordView)context.getBean("view");
		
		// 스프링 3.0 이후 버전부터 사용가능한 코드
		RecordView view = context.getBean("view", RecordViewImpl.class);
		
		view.input();
		view.output();
	}
	
}

Spring Framework 환경설정

new민지(); — Mon, 8 Jan 2024 21:53:03 +0900

※ 스프링 프레임워크(Spring Framework) 구성을 위해
   스프링 프레임워크 관련 리소스를 다운로드 받아야 하는데
   http://www.spring.io 경로에 접근하여 확인해보면
   다운로드 받을 수 있는 경로를 찾을 수 없는 상태이다.
   (STS 연동 (Maven 활용)만 가능한 상태)

○ 적용 및 테스트가 원활한 버전으로 실습 환경 구성 (비 STS)

   ① spring-framework-3.0.2-wiht-docs.zip
      기본적인 스프링 프레임워크 구성에 필요한 필수적인 jar 파일과
      스프링 프레임워크 설명문서(pdf 버전, html 버전)가 포함된 항목,
      스프링 원래의 jar 파일들~

   ② spring-framework-3.0.2-dependencies.zip
      스프링 프레임워크 구성에 의존성을 가진 jar 파일들이 포함된 항목,
      어떤 기능을 수행하는냐에 따라 추가적으로 필요한 항목.
      스프링이 참조하는 의존 jar 파일들~@!!

※ 주의
   다운로드 받은 두개의 압축 파일은 C:\ 또는 D:\ 드라이브 루트에
   폴더를 생성하여 압축을 풀어놓는다.
   그 안에 들어있는 jar 파일들을 선택적으로 복사하여 사용할 예정이기 떄문애
   쉬운 경로에 압축을 풀어놓는다는 의미도 있지만
   압축을 해제하는 과정에서 이름(경로포함)이 길어서 특정 파일에 대해
   제대로 압축을 해제하지 못하고 오류가 발생하기 때문에
   간단한 경로에서 압축을 해제할 수 있도록 한다.

Spring Framework 이해하기

new민지(); — Mon, 8 Jan 2024 21:52:17 +0900

■■■ Spring Framework 이해하기 ■■■

○ 개요

   1. Framework
      어플리케이션을 구현하고 관리하는 환경(틀, 약속)

   2. Spring Framework
      전달 받은 설정 정보에 의해 어플리케이션을 구성하고,
      객체를 생성, 관리하는 주체.

○ 스프링 프레임워크(Spring Framework)의 개념

   스프링은 자바 엔터프라이즈 어플리케이션 개발에 사용되는
   어플리케이션 프레임워크

   어플리케이션 프레임워크는 어플리케이션 개발을 빠르고
   효율적으로 할 수 있도록 어플리케이션의 바탕이 되는 틀과
   공통 프로그래밍 모델, 그리고 API 등을 제공해준다.

   - 어플리케이션의 기본 틀 → 스프링 컨테이너

     스프링은 스프링 컨테이너 또는 어플리케이션 컨텍스트라고 불리는
     스프링 런타임 엔진을 제공한다.
     스프링 컨테이너는 설정 정보를 참고해서
     어플리케이션을 구성하는 오브젝트(객체)를 생성하고 관리한다.
     스프링 컨테이너는 독립적으로 동작할 수도 있지만
     보통... 웹 모듈에서 동작하는 서비스나 서블릿으로 등록해서 사용한다.

     스프링을 사용하려면 먼저 스프링 컨테이너를 다루는 방법과
     스프링 컨테이너가 어플리케이션 오브젝트를 이용할 수 있도록
     설정 정보를 작성하는 방법을 알아야 한다.

     ==>> 설정 정보에 의해 어플리케이션을 구성하고
          객체를 생성, 관리하는 주체

   - 공통 프로그래밍 모델 → IoC/DI, 서비스 추상화 . AOP

     프레임워크는 어플리케이션을 구성하는 오브젝트(객체)가
     생성되고 동작하는 방식에 대해 틀을 제공해줄 뿐 아니라
     어플리케이션 코드가 ★★ 어떻게 작성되어야 하는지에 대한 기준 ★★ 도 제시한다.
     이런 틀을 보통 프로그래밍 모델이라고 한다.
     스프링은 세가지 핵심 프로그래밍 모델을 제공한다.

     ① ★ IoC/DI ★
        오브젝트 생명 주기와 의존 관계에 대한 프로그래밍 모델이다.
        스프링은 ★유연★하고 확장성이 뛰어난 코드를 만들 수 있게 도와주는
        객체 지향 설계 원칙과 디자인 패턴의 핵심 원리를 담고 있는
        IoC/DI 를 프레임워크의 핵심 근간으로 삼고 있다.
        스프림 프레임워크에서 동작하는 코드는
        ★IoC/DI 방식에 따라 작성되어야★ 스프링이 제공하는 가치를 제대로 누릴 수 있다.
        스피링이 직접 제공하는 모든 기술과 API, 심지어 컨테이너까지도
IoC/DI 방식으로 작성되어(만들어져)있다.
        스프링을 바르게 이해하고 효율적으로 사용하는데
        ★기본이 되며 가장 중요한 기술★ 이다.

        ·IoC → - 객체 관리의 주체.
                 - Inversion of Control : 제어의 역전 (역제어)
                 - 객체 생성과 관리를 직접하는 것이 아니라
                   외부(컨테이너)에서 만들어진 오브젝트(객체)를
                   제공받는 입장이 되는것.
                 - Bean : 스프링이 관리하는 대상 // 제품
                 - Bean Factory : 객체를 관리하는 주체 // 공장
                   일반적으로 이 기능을 확장한 Application Context 를 사용하게 된다.
                 - Application Context : Bean Factory 의 확장 버전. // 공단
                 - 설정 정보 : 어떤 객체들이 관리 대상인지 설정한 정보
                   XML, Annotation 등을 이용한다.
                   객체 의존도 관계도 표현되어 있다.
                 - IoC 컨테이너(스프링 컨테이너보다 좀 더 구체적) : 객체를 등록하고 관리하는 공간

         ·DI → - 객체를 관리하는 방법
- 자바에서 객체를 생성하고 관리하는 방법은
   모두 has-a 관계를 통해 처리해 왔기 때문에
   이들은 모두 의존관계가 치밀하고 밀접한 상황일수 밖에 없다.
   때문에... 이러한 강한 결합 상태는
   유연성을 떨어뜨리는 결과를 초래하게 된다.
   이러한 결합 상태를 풀어주는 과정(방법)이 DI 이다.
- Depency Injection: 의존성 주입(의존관계 주입)
- 의존관계 주입 : 의존 객체를... 이 객체를 사용하는 객체에...
   외부에서 주입하는 액션 (상태)
- 의존관계 : A가 실행되기 위해서는 B를 필요로 하는 상태
- 외존객체 : A 입장에서 의존 객체는 B (즉, 주입되는 객체)

※ 우선... A 객체에 B객체의 주소를 넘겨줌으로써
    B객체를 사용하게 된다면...
    A객체는 여전히 B 객체를 사용하는 데는 문제가 없고,
    B객체는 A 객체와의 결합 상태가 느슨해진다고 할 수 있다.

    이때, 넘겨주는 방법은 생성자 또는 setter() 메소드를
    이용하는 방법이 있다.

    DI 를 위해 객체는 작은 객체부터 생성해서
    큰 객체로 DI하는 과정을 반복적으로 거치게 된다.

    이때, 완성된 오브젝트(객체)가 만들어질 때까지
    객체를 관리할 주체(누군가가...)가 필요한데
    그 역할을 하는 것이 바로 컨테이너인 것이다.

     ② 서비스의 추상화
        스프링을 사용하면 환경이나 서버, 특정 기술에
        종속되지 않고, 이식성이 뛰어나며 유연한 어플리케이션을
        만들 수 있게 되는데 이를 가능하게 해주는 것이 바로 서비스 추상화 이다.,
        구체적인 기술과 환경에 종속되지 않도록
        유연한 추상 계층을 두는 방법이다.

     ③ AOP(Aspect Oriented Programming)
        이 AOP 는 어플리케이션 코드에 산재해서 나타나는 부가적인 기능(공통기능)을
        독립적인 상태로 모듈화 하는 프로그래밍 모델이다.,
        스프링은 AOP 를 이용해서 다양한 엔터프라이즈 서비스를
        적용하고도 깔끔한 코드를 유지할 수 있게 해준다


   - 기술 API

     스프링은 엔터프라이즈 어플리케이션 개발의 다양한 영역에
     바로 활용될 수 있는 방대한 양의 기술 API 를 제공한다.
     UI 작성은 물론이고, 웹 프리젠테이션 계층, 비즈니스 서비스 계층,
     기반 서비스 계층, 도메인 계층, 데이터 액세스 계층 등에서
     필요한 주요 기술을 스프링에서 일관된 방식으로 사용할 수 있도록
     지원해주는 전략 클래스를 제공한다.
     스프링이 제공하는 API와 지원 기술은
     모두 스프링 프로그래밍 모델에 따라 작성되었기 때문에
     이를 가져다 쓰는 것 만으로도
     스프림 프로그래밍 모델을 코드에 자연스럽게 적용할 수 있다.
     스프링의 모든 기술은 표준 자바 엔터프라이즈 플랫폼 (JavaEE)에 기술을 두고 있다.
     표준 기술과 더불어 유명 오픈소스 기술과 주요 상용 기술에 대한
     지원 기능도 다양하게 제공한다.

○ 스프링 프레임워크 (Spring Framework)의 주요 기능과 특징

   1. 경량 컨테이너
      자바 객체를 담고, 이들 자바 객체의 생성과 소멸의
      라이프 사이클을 관리.

   2. DI(Dependency Injection)
      의존성(관계) 주입(삽입)을 지원.
      설정 파일을 통해 객체간의 의존 관계를 정의.

   3. AOP(Ascept Oriented Progamming)
      관점 지향 프로그래밍을 지원.
      여러 모듈에 공통적으로 쓰이는 기능을 분리하여
      각 모듈에 적용하는 것이 가능.

   4. POJO(Plan Old Java Object)
      가장 기본적인 자바 객체를 지원
      기존 작성 코드의 유지성을 향상.
      → 보통의 자바(빈) 객체
         - 상속(Ⅹ)
         - 인터페이스(Ⅹ)

   5. 트랜잭션 처리
      JDBC나 JTA를 사용하는 설정 파일을 통해
      트랜잭션을 관리하여 동일한 코드를 여러 환경에서
      사용하도록 하는 것이 가능

   6. 다양한 프레임워크와의 조합
      myBatis(iBatis), Hivernate, Struts, Struts2, JPA, JDO, Quartz 등
      다른 프레임워크 뿐 아니라 사용자가 만든 프레임워크와의 연동성을 제공한다.

※ 스프링 프레임워크(Spring Framework)에서 가장 중요한 개념

   - DI(Dependency Injection, 의존성 주입, 의존관계 주입)
     : 객체를 생성하고 관리하는 의존성에 대해서
       어떻게 처리하는가에 대한 개념

   - IoC(Inversion of Control, 제어의 역전)
     : 인스턴스의 생성부터 소멸까지의 인스턴스 생명주기 관리를
       컨테이너가 대신하는 개념

jQuery의 ajax() 활용 실습 (기초/사칙연산)

new민지(); — Tue, 2 Jan 2024 22:36:23 +0900

AjaxTest01.jsp

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
	request.setCharacterEncoding("UTF-8");
	String cp = request.getContextPath();
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>AjaxTest01.jsp</title>
<link rel="stylesheet" type="text/css" href="css/main.css">
<script type="text/javascript" src="http://code.jquery.com/jquery.min.js"></script>
<script type="text/javascript">

	$(function()
	{
		$("#sendBtn").click(function()
		{
			// 테스트
			//alert("확인~");
			
			var params = "name=" + $.trim($("#name").val())
					   + "&content=" + $.trim($("#content").val());
			
			// ※ jQuery 의 ajax() 함수 사용(호출)
			/*
			$.ajax();
			$.ajax(
			{
				type:"POST"					// 데이터 전송 및 페이지 요청 방식
				,url:"AjaxTest01_ok.jsp"	// 요청 페이지 URL
				,data:params				// 요청 페이지 (AjaxTest01_ok.jsp)에서 수신하게 되는 데이터
				,success:동작				// 페이지요청 및 데이터 전달이 성공했을 때의 처리
				,beforeSend:반환값확인		// 요청 전 확인해야 할 항목 처리(true/false)
				,error:동작					// 처리과정에서 문제가 발생했을때 처리
			});
			*/
			$.ajax(
			{
				type:"POST"
				,url:"AjaxTest01_ok.jsp"
				,data:params					// url 지정 페이지로 넘길 값	// check~!!
				,success: function(args)
				{
					$("#resultDiv").html(args);
					
					$("#name").val("");
					$("#content").val("");
					$("#name").focus();
				}
				,beforeSend:showRequest			// 함수 호출이 아닌 반환값을 확인 하는 것이기 때문에 showRequest() Ⅹ //check~!
				,error:function(e)
				{
					alert(e.responseText);
				}
			});
			
		});
	});
	
	function showRequest()
	{
		if (!$.trim($("#name").val()))
		{
			alert("이름을 입력해야 합니다.");
			$("#name").focus();
			
			return false;
		}	
		
		if (!$.trim($("#content").val()))
		{
			alert("내용을 입력해야 합니다.");
			$("#content").focus();
			
			return false;
		}	
		
		return true;
	}
	

</script>
</head>
<body>

<div>
	<h1>jQuery의 ajax() 활용 실습</h1>
	<hr />
</div>

<div>
	이름<input type="text" id="name" class="txt" />
	<br><br>
	
	내용
	<textarea name="" id="content" rows="3" cols="50"></textarea>
	<br><br>
	
	<input type="button" value="등록하기" id="sendBtn" />
</div>
<br><br>

<div id="resultDiv">
</div>


</body>
</html>

AjaxTest01_ok.jsp

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
	request.setCharacterEncoding("UTF-8");
	String cp = request.getContextPath();
%>
<%

/* 	// AjaxTest01_ok.jsp
	
	String name = request.getParameter("name");
	String content = request.getParameter("content"); */


%>
<%-- 이름 : <b><%=name%></b>
<br>
내용 : <b><%=content %></b>
<br> --%>

이름 : <b>${param.name }</b>
<br>
내용 : <b>${param.content }</b>
<br>

AjaxTest03.jsp

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
	request.setCharacterEncoding("UTF-8");
	String cp = request.getContextPath();
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>AjaxTest03.jsp</title>
<link rel="stylesheet" type="text/css" href="css/main.css">
<script type="text/javascript" src="http://code.jquery.com/jquery.min.js"></script>
<script type="text/javascript">

	$(function()
	{
		$("#sendButton").click(function()
		{
			var params = "su1=" + $.trim($("#su1").val())
					   + "&su2=" + $.trim($("#su2").val())
					   + "&op=" + $.trim($("#oper").val());
			
			$.ajax(
			{
				type:"POST"
				,url:"ajaxtest03ok.do"
				,data:params
				,success: function(args)
				{
					$("#result").html(args);
				}
				,beforeSend:showRequest
				//,beforeSend:function()			// 별다른 검증과정 없이 넘길려면 함수로 선언해서 진행해야함.
				//{									   beforeSend 에게 넘겨줘야하는 값이 함수기 때문이다.
				//	return true 	
				//}
				,error:function(e)
				{
					alert(e.responseText);
				}
			});
			
		});
		
	});
	
	function showRequest()
	{
		if ($("#su1").val()=="")
		{
			alert("첫번째 정수를 입력해주세요");
			$("#su1").focus();			
			return false;
		}
		
		if ($("#su2").val()=="")
		{
			alert("두번째 정수를 입력해주세요");
			$("#su2").focus();			
			return false;
		}
		
		return true;
	}


</script>
</head>
<body>

<div>
	<h1>jQuery 의 ajax() 활용 실습</h1>
	<hr />
</div>

<div>
	<input type="text" id="su1" class="txt txtNum"/>
	
	<select id="oper">
		<option value="add">덧셈</option>
		<option value="sub">뺄셈</option>
		<option value="mul">곱셈</option>
		<option value="div">나눗셈</option>
	</select>
	
	<input type="text" id="su2" class="txt txtNum"/>
	<input type="button" value=" = " id="sendButton" class="btn"/>	
</div>
<br>

<br><br>
<div id="result">
</div>

<br />
<br />

<div>
	<input type="radio" name="rdo"/>rdo1
	<input type="radio" name="rdo"/>rdo2
</div>

<div>
	<input type="checkbox" name="chk" />chk1
	<input type="checkbox" name="chk" />chk2
</div>

<div>
	<input type="text" />
</div>


</body>
</html>

AjaxTest03_ok.jsp

<%@ page contentType="text/html; charset=UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
	request.setCharacterEncoding("UTF-8");
	String cp = request.getContextPath();
%>
${result }

jQuery 의 load() 활용 실습

new민지(); — Tue, 2 Jan 2024 21:51:04 +0900

LoadTest01.html


<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>LoadTest01.html</title>
<link rel="stylesheet" type="text/css" href="css/main.css">
<script type="text/javascript" src="http://code.jquery.com/jquery.min.js"></script>
<script type="text/javascript">

	// ※ 『load()』
	//    『$(선택자).load("로드를 원하는 html 문서의 위치와 이름");』
	//     -- jQuery 의 기능이 수행되는 과정에서 다른 html 문서를 로드
	//     -- HTML 을 읽어들여서 DOM 에 삽입하는 기능을 수행
	
	$(document).ready(function()
	{
		$("#btn .btnLoad").click(function()
		{
			// 테스트
			//alert("확인");
			
			$("#ctlGrid").load("LoadTest02.html");
			//-- 『비동기』방식으로 페이지 로드
			
			window.alert("여기서 작성한 메세지가 먼저 출력된다.");
			//-- Line 22 보다 이 메세지 박스가 먼저 출력~!!
			//   이유는... 비동기~!!
			
		});
	});

</script>
</head>
<body>

<div>
	<h1>jQuery 의 load() 활용 실습</h1>
	<hr />
</div>

<div>
	<div id="btn">
		<div class="btnLoad">HTML 읽어오기 버튼</div>
	</div>
	<br>
	
	<div id="ctlGrid">
	</div>
</div>


</body>
</html>

LoadTest02.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>LodeTest02.html</title>
<link rel="stylesheet" type="text/css" href="css/main.css">
</head>
<body>

load()에 대한 실습

</body>
</html>

Ajax 의 기본 개념

new민지(); — Tue, 2 Jan 2024 21:42:42 +0900

■■■ AJAX(에이작스) ■■■ 에이잭스, 아작스 등등

○ 개요

   AJAX 는 XML 에 기반한 종합 기술로
   비동기 자바스크립트 XML (Asynchronous Javascript And XML) 을 줄인말로
   자바 스크립트로 HTTP 요청을 보내서 XML 응답을 받아 사용하는 기술이다.

   AJAX 는 하나의 독립된 기술이... 아니다.
   화면은 HTML + CSS로 구성 및 작성하고
   화면에 대한 조작과 상호작용은 문객체 모델(Document Object Mode : DOM) 로 처리하고
   데이터 교환은 XML 형식으로 처리하며,
   데이버 변환과 검색은 XML 기술은 XSL 과 Xpath 를 사용하며,
   비동기 통신에는 웹 브라우저 안에 내장되어 있는
   XMLHttpRequest 객체를 사용하고.
   이 모~~든 것을 하나로 묶어주는 개념으로
   Javascript / jQuery 를 사용하는 것.
   이것을 AJAX 라고 한다.

○ 특징

   - 비동기 자바 스크립트 XML
   - 자바스크립트로 HTTP 요청을 보내서 XML 응답을 받아 사용
   - 처리 과정
     ① HTTP 요청을 보냄
        → ② XML 문서를 응답으로 받음
              → ③ 자동으로 XML 객체가 생성
                    → ④ 자바스크립트는 XML 객체에 접근하여 다양한 작업을 수행

   ==>> HTML+CSS, DOM, XML, XSLT, XPath, XMLHttpRequest, Javascript 를 합쳐서 사용

○ 장점

   - 비동기 통신을 사용함으로써 데이터를 보내고 나서도
     사용자는 다른 작업을 수행할 수 있다.
   - 데이터만 들어가 있는 형식으로 응답을 받았기 때문에
     전통적인 웹 어플리케이션 방식에 비해 서버특 처리 속도가 빠르고
     전송 데이터 양도 훨씬 적다.
   - 응답으로 받은 XML 문서를 XML 객체로 접근하여 스크립트로 조작하고
     Xpath를 사용하여 XML 문서를 검색하거나 XSL 을 사용하여 변환을 할 수 있다.
     따라서 실행 속도가 빠르다.
   - 불필요한 데이터 요청을 최소화 할 수 있고
     많은 일들이 클라이언트인 웹 브라우저에서 처리 될 수 있다.

○ 단점

   - 외부 검색 엔진이 웹 페이지를 검색할 수 없는 문제가 잇다.
   - AJAX 는 클라이언트 풀링 박싱으로 실시간 서비스를 제공할 수 없다.
   - AJAX 가 포함된 HTML 페이지가 속한 서버가 아닌 다른 서버로 요청을 보낼 수 없고,
     클라이언트 PC의 파일에 접근 할 수도 없다. → 실질적인 ajax 단점이 될 수는 없음!

○ 기존 웹 사이트에서 AJAX를 사용하면 효과가 있는 경우
   또는, AJAX 어플리케이션으로 개발할 필요가 있는 경우

   - 웹 페이지를 전환하지 않고 현재 페이지에서 다른 동작을 수행하고자 할 대
   - 불필요한 팝업을 사용하여 처리하는 작업을 다른 방법을 통해 대체하려 할 때
   - 여러 번 불필요한 화면을 다시 출력할 때
   - 특정한 데이터를 반복 사용하면서 다양한 작업을 수행할 때

○ 주의사항

   - 뒤로가기 버튼 사용의 어려움
     AJAX 는 Javascript 를 사용하여 동작하기 때문에
     페이지 단위의 브라우저에서 사용자 경험(ux)와 다르게 작동하는 경우가 잇다.
     특히, 뒤로가기 번틍의 기능 상실로 AJAX 를 유해한 기술로 매도하기도 한다.
     (뒤로가기 버튼은 웹 서핑을 수행하는 사용자들이
      일반 클릯 다음으로 많이 사용하는 기술이므로...)
     하지만, 이미 iframe 을 사용한 해결책이 제시된 바 있으며
     AJAX 를 활용한 서비스 사용 경험이 증대되며 이런 문제는 줄어들고 잇다.

   - 진행상황 파악의 어려움
     XMLHttpReauest 를 통해 통신하는 경우
     웹 페이지 로딩과는 달리 사용자에게 아무런 진행 정보가 주어지지 않는다.
     그래서 아직 요청이 완료되지 않앗는데 사용자가 페이지를 떠나거나
     기다림을 참지 못한 사용자가 다른 기능을 수행함으로써 오작동을 일크림
     우려가 발생하게 된다.
     이 경우 사용자의 요청이 처리중에 있다는 표시를 화면에 보여주도록 처리할 수 있다.
     중간 중간 "loading" 상태 표시를 통해 사용자의 요청이 처리중임을 알려주는
     방법을 예로 들 수 있다.
     이러한 상태는 XMLHttpRequest.readyState 의 상태를 통해 판단 할 수 있다.
     또한, 이 때 사용할 수 있는 이미지를 활용하기도 한다.

○ 참고 사이트

   - http://www.w3.org
   - http://www.w3schools.com

○ AJAX 의 필요성

   기존의 웹 브라우저는 서버로부터 페이지 단위로만 데이터를 수신하여 받을 수 있었다.
   때문에 간단한 상호작용을 하려고 해도 페이지 전체를 로딩해야 했고
   이것은 대역폭 낭비를 초래하게 되었다.
   하지만, AJAX 를 사용하면 XML 파일 조각 단위로 데이터를 받아올 수 있기 때문에
   전체 페이지를 다시 로드하지 않아도 페이지 일부를 동적으로 갱신할 수 잇다.

○ AJAX 객체의 사용

   AJAX 객체를 사용하려면 먼저 AJAX 생성 함수를 사용하여 AJAX 객체를 만들어야 한다.
   인터넷 익스플로러의 경우 『new ActiveXObject("Microsoft.XMLHTTP")』를 실행하며
   모질라 웹 브라우저의 경우 『new XMLHttpRequest()』 를 실행하여 AJAX 객체를 생성한다.
   인터넷 익스플로러 7.0 이후부터는 모질라 웹 브라우저 처럼
   『new XMLHttpRequest()』 를 통해 객체를 생성할 수 있다.

EL(Expression Lauguage)과 JSTL(JSP Standard Tag Library)

new민지(); — Thu, 21 Dec 2023 18:33:59 +0900

○ EL (Expression Lauguage : 표현 언어)

   EL 은 JSTL 1.0 스펙에서 잠깐 소개 되었다가
   JSP 2.0 부터 공식적으로 포함되었으며
   JSP 페이지에 사용되는 자바 코드를 대신해서
   액션 태그 엘리먼트의 속성에 값을 지정하는 역할을 한다.

   예를 들어,
   <someTags:aTag> 액션 태그 엘리먼트 속성은 attribute 이고
   속성 값은 <%pageContent.getAttribute("aName")%> 인 경우
   <someTags: aTag attribute=<%pageContent.getAttribute('aName')%>"> 의 방식으로 표현해야 하지만

   표현 언어 EL에서는 다음과 같이 표현한다
   <someTags:aTag attribute="${aName}">

○ JSTL (JSP Standard Tag Library)

   JSP 에서는 XML 처럼 사용자가 태그를 정의해서 사용하는 것이 가능하며
   이와 같은 사용자 정의 태그를 커스텀 태그라고 하는데
   이들 중 자주 사용하는 것을 표준으로 만들어 놓은 것이 JSTL 이다.
   JSP Standard Tag Library 는 일반적인 웹 어플리케이션 기능인
   반복(iteration)과 조건, 데이터 관리, 포맷, XML 조작, 데이터베이스 액세스를
   구현하는 커스텀 태그 라이브러리 모음이다.

   JSP 의 스크립트와 HTML 코드를 혼용하여 사용하면
   개발의 편의성을 제공하긴 하지만 코드의 복잡성을 증대시키는 문제가 있다.
   이와 같은 문제를 해결하기 위해 로직 부분의 JSP 코드를 태그로 대치시켜
   HTML 과 같은 태그로 이루어진 코딩 방법이 제시 되었다.

   JSTL 은 JSP 로직을 담당하는 부분인 if, for, while, DB처리 등과 관련된
   표준 커스텀 태그를 제공함으로 써
   코드를 간결하고 가독성이 좋도록 하며
   데이터 포맷, 반복 콘텐트 또는 조건 콘텐트 와 같은
   전형적인 표현 레이어를 위한 표준 구현을 제공하기 때문에
   JSP 작성자들이 어플리케이션 개발에 집중하는데 도움이 된다.

   JSP(JSTL) 작성시 주의할 사항은
   액션 태그도 그렇지만 JSTL 커스텀 태그도 XML 기반에서 작성되었기 때문에
   모든 태그는 시작 태그와 종료태그의 쌍으로 이루어져야 한다는 것이다.

   기존의 컨텍스트에서 JSTL 을 사용하기 위해서는
   웹 어플리케이션의 WEB-INF/lib 디렉터리에
   필요한 라이브러리를 복사하여 붙여넣으면 된다.
   JSTL 의 주된 라이브러리 파일은 jstl.jar, standard.jar 파일이고,
   jaxen-full.jar, sxpath.jar, jaxp-api.jar 파일등이 필요하다.
   이 파일들을 적재하고 컨텍스트를 리로드 한다.

   - JSTL 을 사용하기 위한 환경 설정

  ·『https://jakarta.apache.org/』 에 접속
  ·왼편에 구성된 메뉴 목록들 중 『Taglibs』 클릭
     → 『https://tomcat.apache.org/taglibs/』 페이지로 이동
  ·왼편에 구성된 메뉴 목록들 중 『Standard』 클릭
    → 『https://tomcat.apache.org/taglibs/standard/』 페이지로 이동
  ·본문의 내용 중 『Standard 1.1 』항목의 『download』 클릭
    → 『https://archive.apache.org/dist/jakarta/taglibs/standard/』 페이지로 이동
  ·본문의 내용 중 『binaries』 클릭
    → 『https://archive.apache.org/dist/jakarta/taglibs/standard/binaries/』 페이지로 이동
  ·본문의 목록 중 『jakarta-taglibs-standard-1.1.2.zip 2004-10-25 20:57  933K』 클릭
    → 다운로드 대화 창 → 파일 다운로드 및 저장
    → 다운로드 완료 및 압축 해제

    이후 ... (압축 해제 후)...
    『C:\Downloads\12_JSTL\jakarta-taglibs-standard-1.1.2\lib』 디렉터리 안에 있는
    『jstl.jar』 파일과 『standard.jar』 파일
    이렇게 두개의 jar 파일을
    현재 작업할(작업중인) 프로젝트의 『WebContent > WEB-INF > lib 』 경로에
    복사하여 붙여넣기 한다.

    다음으로..
    이클립스 환경 설정(window) > (Preferences) 클릭
    → Web 항목 > JSP Files > Editor > Templates 접근

    리스트 항목들 중 (체크 박스는 건드리지 말고...)
    new JSP File(html5) 항목 선택 후 수정(Edit 버튼 클릭)
    이어 열리는 대화창에서
    최초 디렉티브(page) 아래의 다음과 같은 내용 추가

    『<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>』

   - JSTL 사용

     JSTL 은 태생이 커스텀 태그이기 때문에 JSP와 밀접한 관계가 잇다.
     application, session, request, response, pageContext 등의
     내장 객체에 쉽게 접근하며, 그 외에도 파라미터, 쿠키, 헤더 등을
     복잡한 코드를 사용하지 않고 쉽게 직관적으로 사용할 수 잇다.
     또하느 기본적인 연산이나. 객체 비교등을 『.equals()』 메소드등을
     사용하는 대신 『==』 과 같이 쉽게 구현하였으며,
     조건, 반복, 이동에 따르른 태그를 지원하기 떄문에
     태그만으로도 반복 기능을 구현할 수 있다.

     JSTL 의 처리 영역은 크게 4가지로 나눌 수 있다.
     core,       format    xml       sql
     (기본 핵심 기능) (형식화) (xml 처리) (sql 처리)

※ 주요 분류 및 종류

  ○ Core
     - 기능 : 변수지원, 흐름제어, URL 처리 등
     - 접두어(prefix) : c
     - URL : http://java.sun.com/jsp/jstl/core

  ○ xml
     - 기능 : XML 코어, 흐름제어, XML변환 등
     - 접두어 (Prefix) : fmt
     - URL : http://java.sun.com/jsp/jstl/xml

  ○ 국제화(형식화)
     - 기능 : 지역, 메세지 형식, 숫자및날짜형식 등
     - 접두어 (Prefix) : fmt
     - URL : http://java.sun.com/jsp/jstl/fmt

  ○ 데이터베이스
     - 기능: SQL 지원
     - 접두어 (Prefix) : sql
     - URL: http://java.sun.com/jsp/jstl/sql

  ○ Functions
     - 기능: 컬렉션 처리
     - 접두어 (Prefix) : fn
     - URL : http://java.sun.com/jsp/jstl/functions

※ JSTL 에 taglib 추가
<%@ taglib prefix="c" url="http://java.sum.com/jsp/jstl/core" %>
<%@ taglib prefix="x" url="http://java.sum.com/jsp/jstl/xml" %>
<%@ taglib prefix="fmt" url="http://java.sum.com/jsp/jstl/fmt" %>
<%@ taglib prefix="sql" url="http://java.sum.com/jsp/jstl/sql" %>
<%@ taglib prefix="fn" url="http://java.sum.com/jsp/jstl/functions" %>

Servlet의 기초문법 2 (Test2.java / Test2.jsp / Test2_result.jsp)

new민지(); — Thu, 21 Dec 2023 18:26:19 +0900

사용자가 제일 먼저 만나는 페이지는 Test2.jsp 이다.

Test2.jsp 페이지 구성은 다음과 같다.

<%@ page contentType="text/html; charset=UTF-8"%>
<%
	request.setCharacterEncoding("UTF-8");
	String cp = request.getContextPath();
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Test2.jsp</title>
<link rel="stylesheet" type="text/css" href="css/main.css">
</head>
<body>

<div>
	<h1>서블릿에서 데이터 흐름</h1>
	<hr />
</div>

<div>
	<form action="<%=cp %>/test2" method="post">
	이름<input type="text" name="name" class="txt"/><br>
	나이<input type="text" name="age" class="txt"/><br><br>
	
	<button type="submit" class="btn">확인</button>
	</form>
</div>

</body>
</html>

사용자가 이름과 나이를 입력하고 확인 버튼을 누르면 WebApp21/test2 라는 페이지로 이동이 된다.

여기에서 test2 라는 페이지를 호출하면 web.xml 에서 구성한 servlet 으로 이동하게 된다.

구성한 servlet은 다음과 같다.

  <!-- Test2 클래스 → servlet 구성 -->
  <servlet>
  	<servlet-name>test2servlet</servlet-name>
  	<servlet-class>com.svt.Test2</servlet-class>
  </servlet>
  
  <servlet-mapping>
  	<servlet-name>test2servlet</servlet-name>
  	<url-pattern>/test2</url-pattern>
  </servlet-mapping>

servlet-mapping 에 url-pattern 주소를 호출하면 servlet-name 이 test2servlet인 servlet을 찾아간다.

위에 있는 servlet으로 이동하면 class 주소가 있다. 이 클래스로 이동하여 동작을 실행한다.

Test2.java 로 이동하게 되면 HttpServlet 를 상속하는 Test2 클래스가 있다.

구성된 코드는 다음과 같다.

/*=======================
 	ServletSample.java
 ========================*/

package com.svt;

import java.io.IOException;

import javax.security.auth.message.callback.PrivateKeyCallback.Request;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Test2 extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	// 사용자의 http 프로토콜 요청이 GET 방식일 경우 호출 되는 메소드
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doGetPost(request, response);
	}	
	// 사용자의 http 프로토콜 요청이 POST 방식일 경우 호출 되는 메소드
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doGetPost(request, response);
	}
}

Test2.jsp 파일에서 action 처리를 하면서 넘겨주는 메소드가 post 방식이냐 get방식이냐에 따라서

doGet(HttpServletRequest request, HttpServletResponse response) 메소드 혹은 doPost메소드(HttpServletRequest request, HttpServletResponse response) 를 호출한다.

Test2.jsp 파일에서 post 방식으로 넘겨줬기 때문에 doPost(HttpServletRequest request, HttpServletResponse response) 메소드를 호출한다. 메소드 안에 doGetPost(request, response) 를 호출하는데 이 메소드는 사용자 정의 메소드이다.

	// 사용자 정의 메소드
	protected void doGetPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		// GET 방식이든 POST 방식이든 
		// 어떤 방식의 요청에도 모두 처리 할 수 있는 사용자 정의 메소드
		
		// 서블릿 관련 코딩
		
		//  이전 페이지(Test2.jsp)로부터 넘어온 데이터 수신
		//  → name, age
		
		// 한글 깨짐 방지
		request.setCharacterEncoding("UTF-8");
		
		// 데이터 수신
		String name = request.getParameter("name");
		String age = request.getParameter("age");
		
		// 업무 처리 
		String str = "이름은 " + name + ", 나이는 " + age + "세 입니다.";

		// 처리한 업무 넘기기
		request.setAttribute("result", str); // ★★★★
		// 포워딩 하는 페이지에 값을 넘기기 위한 준비(설정)
		// 즉, str 값을 result 라는 이름으로 Test2_result.jsp 페이지로 
		// 넘기기 위한 준비
		
		// 포워딩~~!!★★★★★
		RequestDispatcher dispatcher = request.getRequestDispatcher("/Test2_result.jsp");
		dispatcher.forward(request, response);
		
	}

사용자에게 새로운 주소를 요청하게 하는 것이 아니라 내가 호다닥 만들어서 전달을 해주는 것이다.

물론 사용자는 이사실을 알지 못한다....

Servlet 의 기초 문법 1.(Test1.java)

new민지(); — Thu, 21 Dec 2023 18:10:35 +0900

/*=======================
 	Test1.java
 ========================*/

package com.svt;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Test1 extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	// 사용자의 http 프로토콜 요청이 GET 방식일 경우 호출 되는 메소드
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doGetPost(request, response);
	}	
	// 사용자의 http 프로토콜 요청이 POST 방식일 경우 호출 되는 메소드
	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		doGetPost(request, response);
	}
	
	// 사용자 정의 메소드
	protected void doGetPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		// GET 방식이든 POST 방식이든 
		// 어떤 방식의 요청에도 모두 처리 할 수 있는 사용자 정의 메소드

		// ①
		/*
		response.setContentType("text/html; charset=UTF-8");
		PrintWriter pw = response.getWriter();
	
		pw.println("<html>");
		pw.println("<head>");
		pw.println("<title>" + "Test1.java"+"</title>");
		pw.println("</head>");
		pw.println("<body>");
		pw.println("<div>");
		pw.println("<h1>name: " + "홍길동" + "</h1>");
		pw.println("<h1>age : " +19+"</h1>");
		pw.println("</div>");
		pw.println("</body>");
		pw.println("</html>");
		*/
		
		// ②
		/*
		String name = "길현욱";
		int age = 21;
		
		response.setContentType("text/html; charset=UTF-8");
		PrintWriter pw = response.getWriter();
	
		pw.println("<html>");
		pw.println("<head>");
		pw.println("<title>" + "Test1.java"+"</title>");
		pw.println("</head>");
		pw.println("<body>");
		pw.println("<div>");
		pw.println("<h1>name: " + name + "</h1>");
		pw.println("<h1>age : " + age +"</h1>");
		pw.println("</div>");
		pw.println("</body>");
		pw.println("</html>");
		*/
		
		//③
		
		//   『ServletConfig』
		// -- 컨테이너가 서블릿을 초기화할 때
		//    서블릿 당 하나씩 ServletConfig 을 생성하게 된다.
		ServletConfig config = getServletConfig();
		
		// 『web.xml』에 『<init-param>』	
		String name = config.getInitParameter("name");
		String age = config.getInitParameter("age");
		
		/*
		response.setContentType("text/html; charset=UTF-8");
		PrintWriter pw = response.getWriter();
	
		pw.println("<html>");
		pw.println("<head>");
		pw.println("<title>" + "Test1.java"+"</title>");
		pw.println("</head>");
		pw.println("<body>");
		pw.println("<div>");
		pw.println("<h1>name: " + name + "</h1>");
		pw.println("<h1>age : " + age +"</h1>");
		pw.println("</div>");
		pw.println("</body>");
		pw.println("</html>");
		*/
		
		
		// ④
		
		//  『ServletContext』
		// -- ServletConfig 는 서블릿에 대한 환경을 설정하는 과정에서
		//    필요한 값들을 전달하는 형태로 주요 사용된다면....
		//    ServletContext는 서블릿에서 사용되는 컨텍스트를
		//    구성하는 형태로 활용된다.
		ServletContext context = getServletContext();
		
		String type = context.getInitParameter("type");
		
		response.setContentType("text/html; charset=UTF-8");
		PrintWriter pw = response.getWriter();
	
		pw.println("<html>");
		pw.println("<head>");
		pw.println("<title>" + "Test1.java"+"</title>");
		pw.println("</head>");
		pw.println("<body>");
		pw.println("<div>");
		pw.println("<h1>name: " + name + "</h1>");
		pw.println("<h1>age : " + age +"</h1>");
		
		pw.println("<h1>type : " + type +"</h1>");
		
		pw.println("</div>");
		pw.println("</body>");
		pw.println("</html>");
		
	}
}

Servlet 의 개념

new민지(); — Thu, 21 Dec 2023 18:08:11 +0900

0. 웹 어플리케이션을 구축하기 위한 웹 프로그램을 구성하는 언어의 한 종류.
   (JAVA 기반)

1. JSP 에서 정적인 부분들 담당하고, Servlet 에서는 동적인 처리를 위한
   부분으로 사용되어 보다 효율적인 웹 어플리케이션을 구축할 수 있다.
   - jsp            →  단점. MVC 패턴을 적용하기 힘들다.
   - servlet        →  단점. 웹 페이지(view) 작성이 번거롭고 복잡하다. (불편)
   - servlet + jsp  →  MVC 패턴 적용 및 웹 페이지(view)를 보다 편리하게 작성.
                        단점. 구조가 복잡해지게 된다.

2. jsp 는 내부적으로 Web Container 가 Servlet 으로 변경시켜준다.

3. WEB-INF 는 환경 설정 파일이 저장되는 곳
   ( 외부에서는 접근 불가/ 금지)  check~!
   -lib: 라이브러리 파일을 저장(ojdbc6.jar, jstl.jar 등)
   -J2EE
   -J2SE
   -classes : class 파일이 저장(servlet)
   classes > com > util > MyUtil.class
   원래는 이렇게 만들어져야 하지만 이클립스가 자동으로 연결

   실제 위치는
   C:\WebStudy\.metadata\.plugins\org.eclipse.wst.server.core
   \tmp0\work\Catalina\localhost\WebApp20\org\apache\jsp

   *.jar : java
   *.war : web(프로젝트 아래 모든 것을 압축할 때)
   *.ear : jar + war
   web.xml : context path의 환경 설정

4. 『init()』과 『destroy()』 는 단 한번 호출 되며
   service() 는 클라이언트의 요청이 있을 때 마다 호출된다.
   이제는 JSP 를 service() 메소드 내부에 코딩하는 것과 같다.

5. GenericServlet 이나 HttpServlet 을 활용한다.

6. URL 패턴을 지정하는 방법은 크게 3가지이다.

   - 『/a』
   - 『/*』
   - 『.do』

7. web.xml 을 수정하면 서버를 꼭 재구동한 이후에 실행해야 한다.

8. 지금까지는
   JSP(입력) → JSP(처리, 결과) 였으나
   JSP 와 함께 Servlet 을 다루게 된 이후에는
   JSP(입력) → Servlet(결과를 위한 처리) → JSP(결과) 방식으로 구성된다.