160526: 51회차

종료하기 전 티스토리 네이버 로그아웃 할 것

1. 툴

동일

추가시: 

2. 폴더

동일

추가시:

3. 사용할 사이트

동일

추가시:

4. 공부하는 것

[21][Spring] STS 다운로드 및 설치, Spring Framework 특징, Spring Framework 주요 모듈

[01] STS(Spring Tool Suite)   
   - http://spring.io/tools/sts 
   - 스프링 개발 지원, 메이븐등의 플러그인 내장으로 Controller 개발 지원 편리. 
   - 개발 라이브러리 자동 지원. 


1. 다운로드 및 설치 
   http://spring.io/tools/sts 


  




   spring-tool-suite-3.7.3.RELEASE-e4.5.2-win32-x86_64.zip spring/ sts 폴더에 다운 받아서 여기서 압축풀기로 품


  설치 폴더 :  javadb/spring/sts/ 
  작업 폴더 :  javadb/spring/workspace/ 
  Maven  폴더 : C:/Users/blue/.m2/repository(자동생성) 

2. 스프링 프레임워크 특징

 

 - 경량 컨테이너로서 자바 객체를 직접 관리한다. 각각의 객체 생성, 소멸과 
 

    같은 라이프 사이클을 관리하며 스프링으로부터 필요한 객체를 얻어올 수 있다.

 

 

 - 스프링은 POJO(Plain Old Java Object) 방식의 프레임워크이다. 
 

    일반적인 J2EE 프레임워크에 비해 구현을 위해 특정한 인터페이스를 구현하거나 
 

    상속을 받을 필요가 없어 기존에 존재하는 라이브러리 등을 지원하기에 용이하고 
 

    객체가 가볍다.

 

 - 스프링은 제어 반전(IoC : Inversion of Control)을 지원한다.
 

    컨트롤의 제어권이 사용자가 아니라 프레임워크에 있어서 필요에 따라 스프링에서 
 

    사용자의 코드를 호출한다.

 

 - 스프링은 의존성 주입(DI : Dependency Injection)을 지원한다.
 

    각각의 계층이나 서비스들 간에 의존성이 존재할 경우 프레임워크가 서로 연결시켜준다.

 

 

 - 스프링은 관점 지향 프로그래밍(AOP : Aspect-Oriented Programming)을 지원한다.
 

    따라서 트랜잭션이나 로깅, 보안과 같이 여러 모듈에서 공통적으로 사용하는 기능의 경우 
 

    해당 기능을 분리하여 관리할 수 있다.

 

 - 스프링은 영속성과 관련된 다양한 서비스를 지원한다.
 

    iBatis나 Hibernate 등 이미 완성도가 높은 데이터베이스 처리 라이브러리와
 

    연결할 수 있는 인터페이스를 제공한다.

 

 - 스프링은 확장성이 높다. 스프링 프레임워크에 통합하기 위해 간단하게 기존 라이브러리를 
 

    감싸는 정도로 스프링에서 사용이 가능하기 때문에 수많은 라이브러리가 이미 스프링에서 
 

    지원되고 있고 스프링에서 사용되는 라이브러리를 별도로 분리하기도 용이하다.

 

 

 

3. 스프링 주요 모듈

 

제어 반전 컨테이너
 

제어 반전(IoC: Inversion of Control) 컨테이너는 스프링의 가장 중요하고 핵심적인 기능으로서 
 

자바의 반영(reflection)을 이용해서 객체의 생명주기를 관리하고 의존성 주입(Dependency Injection)을 
 

통해 각 계층이나 서비스들간의 의존성을 맞춰준다. 
 

이러한 기능들은 주로 환경설정을 담당하는 XML 파일에 의해 설정되고 수행된다.

 

관점 지향 프로그래밍 프레임워크
 

스프링은 로깅이나 보안, 트랜잭션 등 핵심적인 비즈니스 로직과 관련이 없으나 여러 곳에서 공통적으로 
 

쓰이는 기능들을 분리하여 개발하고 실행 시에 서로 조합할 수 있는 관점 지향 프로그래밍(AOP)을 지원한다.
 

기존에 널리 사용되고 있는 강력한 관점 지향 프로그래밍 프레임워크인 AspectJ도 내부적으로 사용할 수 있으며,
 

스프링 자체적으로 지원하는 실행시(Runtime)에 조합하는 방식도 지원한다.

 

데이터 액세스 프레임워크
 

스프링은 데이터베이스에 접속하고 자료를 저장 및 읽어오기 위한 여러 가지 유명한 라이브러리,
 

즉 JDBC, iBatis(MyBatis), Hibernate 등에 대한 지원 기능을 제공하여 데이터베이스 프로그램밍을
 

쉽게 사용할 수 있다.

 

트랜잭션 관리 프레임워크
 

스프링은 추상화된 트랜잭션 관리를 지원하며 XML 설정파일 등을 이용한 선언적인 방식 및 프로그래밍을 
 

통한 방식을 모두 지원한다.

 

모델-뷰-컨트롤러 패턴
 

스프링은 웹 프로그램밍 개발 시 거의 표준적인 방식인 Spring MVC라 불리는 모델-뷰-컨트롤러(MVC)
 

패턴을 사용한다. DispatcherServlet이 Contoller 역할을 담당하여 각종 요청을 적절한 서비스에
 

분산시켜주며 이를 각 서비스들이 처리를 하여 결과를 생성하고 그 결과는 다양한 형식의 View 서비스들로
 

화면에 표시될 수 있다.

----

스프링 프레임워크 - 라이프 사이클 관리! :>

그리고 이미 만들어놓은 객체를 가져다가 씀 =그래서 new를 잘 안 씀 'ㅅ')ㅋㅋ

스프링은 푸조 방식의 프레임워크 - 제이투EE프레임워크 (머리가 아픈것 - 예전에 쓰던 것)

푸조는 어... 얘는 넘나 조은 것이래... 잘모르게슴 - 기존의 제이투이보다 넘나 가ㅑ벼운 것

푸조

푸우조

1. 라이브러리도 간단하고

2. 가볍고

 

 - 스프링은 제어 반전(IoC : Inversion of Control)을 지원한다.

 

    컨트롤의 제어권이 사용자가 아니라 프레임워크에 있어서 필요에 따라 스프링에서 

 

    사용자의 코드를 호출한다.

 

서블릿 - 객체를 생성하고 라이프 사이클을 주관하는 게 웹서버

근데 스프링은 스프링에서 코드의 라이프 사이클을 주관하나 봄 (스프링이 뭐여)

스프링은 의존성 주입을 지원한다.

각각의 계층이나 서비스들 간에 의존성이 존재할 경우 프레임워크가 서로 연결시켜주는것

 

의존성 주입 - 디펜던시 인젝쎤이라서 DI - 얘는 좀 쉽대... 이잉

스프링은 관점 지향 프로그래밍임 - AOP

아스펙트 - 오리엔티드 - 프로그래밍

트랜잭션이나 로깅, 보안과 같이 여러 모듈에서 공통적으로 사용하는 기능의 경우 해당 기능을 분리하여 관리할 수 있다.

실제로 필요한 중요한 내용/업무를 하나의 다른 클래스로 빼서 - 보안이 필요시에 가져다가 사용함(?) 인가봄...

 

 - 스프링은 영속성과 관련된 다양한 서비스를 지원한다.

 

    iBatis나 Hibernate 등 이미 완성도가 높은 데이터베이스 처리 라이브러리와

 

    연결할 수 있는 인터페이스를 제공한다.

이제는 아이바티-스 안쓰고 마이바티스 쓰는 곳도 많은 것 :-)

나나 나-나

바티스친구 - 쿼리매핑

하이버네이트 - 얘는 쿼리문이 없고 객체 지향적인 것 (...ㅇ...)

써보면 MVC->Spring하면... 

스프링이 더 쉬...울거라고...어어어

:-)~!

 - 스프링은 확장성이 높다. 스프링 프레임워크에 통합하기 위해 간단하게 기존 라이브러리를 

 

    감싸는 정도로 스프링에서 사용이 가능하기 때문에 수많은 라이브러리가 이미 스프링에서 

 

    지원되고 있고 스프링에서 사용되는 라이브러리를 별도로 분리하기도 용이하다.

 

라이브러리 지원 넘나 좋은 것입니다

이게 확장성이 좋아서 점점 많이 쓰는 것

보통 회사에서는 자체-프-레임워-크를 씁니다^^

근데 자체 프레임워크 기반이 되는 게 스프링 ~~~~~~~~~~

슾흐링

10시 9분

-------------

-제어 반전 컨테이너

인버젼 오브 컨트롤 - 제어 반전 IOC 컨테이너는 넘나 중요한 스프링의 기능 - ★

자바의 반영을 이용해서 객체 생명주기 관리 & 의존성 주입

을 통해 각계층이나 서비스들간의 의존성을 맞춰줌!!!!

이거도 XML 파일에 의해 설정&수행됨 

-------

-관점 지향 프로그래밍 프레임워크

//복돌이

스프링은 로깅이나 보안, 트랜잭션 등 핵심적인 비즈니스 로직과 관련이 없으나 여러 곳에서 공통적으로 

 

쓰이는 기능들을 분리하여 개발하고 실행 시에 서로 조합할 수 있는 관점 지향 프로그래밍(AOP)을 지원한다.

 

기존에 널리 사용되고 있는 강력한 관점 지향 프로그래밍 프레임워크인 AspectJ도 내부적으로 사용할 수 있으며,

 

스프링 자체적으로 지원하는 실행시(Runtime)에 조합하는 방식도 지원한다.

 

데이터 액세스 프레임워크

 

스프링은 데이터베이스에 접속하고 자료를 저장 및 읽어오기 위한 여러 가지 유명한 라이브러리,

 

즉 JDBC, iBatis(MyBatis), Hibernate 등에 대한 지원 기능을 제공하여 데이터베이스 프로그램밍을

 

쉽게 사용할 수 있다.

 

트랜잭션 관리 프레임워크

 

스프링은 추상화된 트랜잭션 관리를 지원하며 XML 설정파일 등을 이용한 선언적인 방식 및 프로그래밍을 

 

통한 방식을 모두 지원한다.

-------------

으으 쓰프링 책... 넘나 창렬...

사야하는 것?... ?!?!?

우리의친구 오라클 책처럼 머리가 아픈거시빈다

그냥 나는 빌려야지...

----------------------

MVC - 뮤델 -뷰 -컨트롤러 패턴

웹 프로그래밍 개발 시 표준인 것... - 을 사용합니다^^

 DispatcherServlet이 Contoller 역할을 담당하여 각종 요청을 적절한 서비스에

 

분산시켜주며 이를 각 서비스들이 처리를 하여 결과를 생성하고 그 결과는 다양한 형식의 View 서비스들로

 

화면에 표시될 수 있다.

 

---------------------------------------

STS 실행하면

이클립스랑 비슷하게 생겼음

으으 - 그리고 서버가 피보탈 티시 서버인데 이걸 나중에 톰캣으로 바꿀거임요

수푸ㅠ링 레거시 프로젝트->심플 스프링 유틸리티 프로젝트

-> 글고 라이부러리는 spring.sts.sample 써씀

굳이 내가 써주ㅓ야 함 'ㅅ')...

팩토리 - 클래스를 만들어주는 것 :>

------------

빈이라는 거에다가 객체를 생성해 놓으면 -아! xml 파일에서

//constructor - 의존성 주입 (DI)

1. 생성자를 통해서 주입

2. setter를 통해서 주입

import org.springframework.core.io.Resource;

이거는 스프링 프레임웤 라이브러리라서 이클립스에서는 사용 불가능

아니면 수동으로 lib 갖다놓으면 되긴 합니다

package spring.sts.ioc;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.FileSystemResource;

import org.springframework.core.io.Resource;

public class HelloApp {

/**

* @param args

*/

public static void main(String[] args) {

// Resource resource = new

// FileSystemResource("spring/sts/ioc/message.xml");

Resource resource = new ClassPathResource("message.xml");

BeanFactory factory = new XmlBeanFactory(resource);

InterMessage a = (InterMessage) factory.getBean("m");

System.out.println(a.sayHello("Spring"));

}

}

이거 같은 경우에는

클래스 - 인터페이스 - 팩토리+조립기(bean) 

----------

스프링 라이브러리

Spring library

C:\Users\soldesk\.m2

인데

C:\Users\soldesk\.m2\repository

이거 안에 있는 거를 다 지운당

-> maven -> update project

---

 

[23][spring] DI(Dependency Injection)의 구현

[1]. DI(Dependency Injection) 
   - 객체 사이의 의존관계를 자기 자신이 아닌 외부에 의해서 설정된다는 개념 
   - DI 컨테이너가 특정클래스가 필요로 하는 인스턴스를 자동으로 생성, 
     취득하여 연결 시켜주는 역할을 합니다. 
   - 스프링 컨테이너는 빈 객체를 저장하고 있으며, 각 객체간의 의존 관계를  
     관리해 줍니다. 

   1. Constructor Injection 
     생성자를 통해서 의존관계를 연결시키는 것을 말합니다. 


     [ Foo.java] 
     public class Foo{ 
       private Bar bar; 
       public Foo(Bar bar){ 
           this.bar = bar; 
       } 



    -XML 설정파일의 <constructor-arg>요소 
     생성자를 통해서 의존관계를 설정하기 위해서  XML 설정파일에서  
     <bean>요소의 하위 요소로<constructor-arg> 를 추가해야 합니다. 

     <bean id="foo" class="Foo"> 
        <constructor-arg> 

           <ref bean = "bar"/> 
        
        </constructor> 
      </bean> 


     <bean id="bar" class="Bar" /> 

    - 전달인자 2개인 생성자에 연결 관계 설정(index 생략가능) 

     <bean id="foo" class="Foo"> 
        <constructor-arg index="0"> 
           <ref bean = "bar"/> 
        </constructor> 

       <constructor-arg index="1"> 
           <ref bean = "bar"/> 
        </constructor> 

      </bean> 
       
   -  생성자 전달값이 기본형 이거나 String 타입이라면 <ref> 태그 대신  
      <value>태그를  사용합니다. 
       <value>의 기본값은 String이며, type으로 파라메터 타입을 설정할 
       수 있습니다. 

     <bean id="foo" class="Foo"> 
        <constructor-arg> 
           <value type="long">10<value> 
        </constructor> 
      </bean> 



   - [주의]<bean> 태그에 생성자와 관련된 정보(<constructor-arg> 태그)를 
     명시 하지 않으면 스프링은 기본생성자로 객체를 생성함으로,  
     파라미터가 있는 생성자 를 정의했다면 기본 생성자도 함께  
     정의해 주어야 합니다. 



   2. Setter Injection 
   -  클래스의 의존관계를 연결하기 위해서 setter메소드를 이용하는 방법입니다. 
     

 [ Foo.java] 
     public class Foo{ 
       private Bar b; 
       Foo(){}//기본생성자(jvm 이 자동으로 만들어줌) 
       public void setB(Bar bar){ 
           this.b= bar; 
       } 


    - <property> 요소를 사용합니다. 

    <bean id="foo" class="Foo"> 
      <property name="b" ref="bar"> </property> 

     </bean> 

     <bean id="bar" class="Bar" /> 



   - XML 네임스페이스를 이용한 프로퍼티 설정 
     네임스페이스가 "http://www.springframework.org/schema/p"인 접두어를  
    사용하면 프로퍼티값을 간편히 설정가능 합니다. 

    p:프로퍼티명="기본타입 데이타" 
    p:프로퍼티명-ref="빈 객체"  

    단, 프로퍼티이름이 Ref로 끝나는 경우는 <property>태그로 값 설정해야합니다. 



  

   3. static 메서드를 이용해서 싱클톤 패턴이 적용된 클래스 

     public class ParserFactory{ 

        private static ParserFactory instance = new ParserFactory(); 
        public static ParserFactory getInstance(){ 
               return instance; 

        } 
       : 
       : 
    } 
    
    <bean id="parserFactory" class="www.spring.ParserFactory" 

      factory-method="getInstance"> 



   4.  필요한 객체를 제공하는 룩업메소드를 구현하는 방식의 룩업 메서드 인젝션 

     publlic abstract class Processor{ 

          public void process(String commName){ 

                   ComFactory factory = getComFactory(); 
                    
                   Command command = factory.createComm(commName); 

                   command.excute(); 

          } 

          //의존 객체를 구할때 사용되는 룩업메소드 
          protected abstract ComFactory getComFactory(); 

     } 

    
    <bean id="process" class="sts.spring.Processor"> 

            <lookup-method name="getComFactory" bean="commFactory"/> 

     </bean> 

    
    <bean id="commFactory" class="sts.spring.ComFactoryImpl"/> 


    - <lookup-method>의 name속성은 룩업메소드이름, 
       
        bean속성은 룩업메소드가 리턴할 빈객체의 식별값을 입력합니다. 

   - 룩업메소드 규칙 

    접근제한자  : public, protected 
    리턴형        : void 
    매개변수     : 없다 
    추상메소드  : 가능 
    final형태     : 아님 
     
      
    - CGLIB 모듈필요(cglib-nodep-2.1.jar) 




  5. 콜렉션 타입 프로퍼티 설정 

   - list 
     객체목록 <ref>태그 
     래퍼 및 String  <value>태그사용 
     Generic 사용시 type명시안해도 알맛게 변환해줌 


   <bean name=""................> 

    <property name=""> 
     
          <list> 
              <ref bean =""/> 
              <ref bean =""/> 
              <bean class=""/> 
          </list> 
     </property> 
    </bean> 
    
    <bean name =""  class=""/> 
    <bean name="" class=""/> 



   <bean name=""................> 

    <property name=""> 
     
          <list> 
               <value>0.2</value> 
               <value>0.3</value> 
          </list> 
     </property> 
    </bean> 



   
   <bean name=""................> 

    <property name=""> 
     
          <list value-type="java.lang.Double"> 
              <value>0.2</value> 
               <value>0.3</value> 
          </list> 
     </property> 
    </bean> 



   <bean name=""................> 

    <property name=""> 
     
          <list> 
              <value type="java.lang.Doublue">0.2</value> 
               <value type="java.lang.Float">0.3</value> 
          </list> 
     </property> 
    </bean> 

   


  - Map  
    <entry></entry> 
    Map 저장할 한 개의 <키,값>을 표현한다. 


<bean name=""................> 

    <property name=""> 
     
          <map> 
             <entry> 
               <key><value type="java.lang.Doublue">0.2</value></key> 
                <ref  bean=""> 
              </entry> 
             <entry> 
               <key><value>rest</value></key> 
                <ref  bean=""> 
              </entry> 
          </map> 
     </property> 
    </bean> 





          <map> 
             <entry key="1" value="1th"/> 
              <entry key-ref="pro" value-ref="handle"/> 
            </map> 


    
         <map key-type="java.lang.Integer"  value-type="java.leng.Doublue"> 
             <entry> 
                 .... 
              </entry> 
          </map> 






 - Property  
   <props></props>태그사용 

  

<bean name=""................> 

    <property name=""> 
     
          <props> 
             <prop key="">....</prop> 
             <prop key="">....</prop> 
          </props> 
     </property> 
    </bean> 







 4. DI 패턴 실습 예제 1 

          Project Type: Spring  Project --> Simple Spring Utility Project    
          Name: diApp1 
          Package: sts.di.app1 
          Library: 프로젝트 생성시 관련 Spring 라이브러리가 자동으로 다운로드  
                      됩니다. 작업 컴퓨터는 인터넷에 연결되어 있어야 합니다. 


>>>>> di.InterMessage.java 

package sts.di.app1; 

public interface InterMessage { 
void sayHello(); 
} 



>>>>> MessageBean.java 

package sts.di.app1; 

import java.io.IOException; 

public class MessageBean implements InterMessage { 
  private String name; 
  private String greeting; 
   
  private Outputter outputter; 

   
  public void sayHello() { 
    String message = greeting + name + "!"; 
    System.out.println(message); 
    try { 
      outputter.output(message); 
    } catch(IOException e) { 
      e.printStackTrace(); 
    } 
  } 

   public MessageBean(String name) { 
    this.name = name; 
  } 
  
  public void setGreeting(String greeting) { 
    this.greeting = greeting; 
  } 
   
  public void setOutputter(Outputter outputter) { 
    this.outputter = outputter; 
  } 
} 

     
>>>>> appContext.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:p="http://www.springframework.org/schema/p" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> 
<bean id="messageBean" class="sts.di.app1.MessageBean" > 
        <constructor-arg> 
            <value>Spring</value> 
        </constructor-arg> 

        <property name="greeting"> 
            <value>Hello, </value> 
        </property> 
        
  </bean> 

</beans> 





>>>>> HelloApp.java 

package sts.di.app1; 

import org.springframework.beans.factory.BeanFactory; 
import org.springframework.beans.factory.xml.XmlBeanFactory; 
import org.springframework.core.io.ClassPathResource; 
import org.springframework.core.io.Resource; 

public class HelloApp { 
/** 
 * @param args 
 */ 
public static void main(String[] args) { 

// ApplicationContext context = new ClassPathXmlApplicationContext("appContext.xml"); 

        //        InterMessage m = (InterMessage)context .getBean("messageBean"); 


Resource resource = 
new ClassPathResource("appContext.xml"); 
BeanFactory factory = new XmlBeanFactory(resource); 

InterMessage m = (InterMessage)factory.getBean("messageBean"); 
m.sayHello(); 
} 
} 





>>>>> Outputter.java 

package sts.di.app1; 

import java.io.IOException; 

public interface Outputter { 
void output(String message) throws IOException; 
} 




>>>>>FileOutputter.java 

package sts.di.app1; 

import java.io.FileWriter; 
import java.io.IOException; 

public class FileOutputter implements Outputter { 
  private String filePath; 
   
  public void output(String message) throws IOException { 
    FileWriter out = new FileWriter(filePath); 
    out.write(message); 
    out.close(); 
  } 
  public void setFilePath(String filePath) { 
    this.filePath = filePath; 
  } 
} 



>>>>> appContext.xml에 추가 

                            : 
                            : 

        <property name="outputter" ref="outputter"> 
        </property> 
        
  </bean> 

  <bean id="outputter" class="sts.di.app1.FileOutputter" > 
     <property name="filePath"> 
          <value>out.txt</value> 
     </property> 
   
   </bean> 






 4. DI 패턴 실습 예제 2 

          Project Type: Spring  Project --> Simple Spring Utility Project    
          Name: diApp2 
          Package: sts.di.app2 
          Library: 프로젝트 생성시 관련 Spring 라이브러리가 자동으로 다운로드  
                      됩니다. 작업 컴퓨터는 인터넷에 연결되어 있어야 합니다. 



>> >>> ArticleDTO.java 

package sts.di.app2; 

public class ArticleDTO { 
private String name; 
private String title; 
private String content; 
private String date; 

public ArticleDTO() { 
super(); 
// TODO Auto-generated constructor stub 
} 

public String getName() { 
return name; 
} 

public void setName(String name) { 
this.name = name; 
} 

public String getTitle() { 
return title; 
} 

public void setTitle(String title) { 
this.title = title; 
} 

public String getContent() { 
return content; 
} 

public void setContent(String content) { 
this.content = content; 
} 

public String getDate() { 
return date; 
} 

public void setDate(String date) { 
this.date = date; 
} 


} 



>> >>>IArticleDAO.java 

package sts.di.app2; 

public interface IArticleDAO { 

void insert(ArticleDTO article); 

} 




>>>>>OracleArticleDAO.java 

package sts.di.app2; 

public class OracleArticleDAO implements IArticleDAO { 


public void insert(ArticleDTO article) { 
System.out.println("OracleArticleDAO.insert() 실행"); 
} 

} 



>>>>> MysqlArticleDAO.java 


package sts.di.app2; 

public class MysqlArticleDAO implements IArticleDAO { 


public void insert(ArticleDTO article) { 
System.out.println("MysqlArticleDAO.insert() 실행"); 
} 

} 



>>>>> IWriteArticleMgr.java 

package sts.di.app2; 

public interface IWriteArticleMgr { 

public void write(ArticleDTO article); 
} 




>>>>> WriteArticleMgr.java 

package sts.di.app2; 

public class WriteArticleMgr implements IWriteArticleMgr { 

private IArticleDAO articleDAO; 

public WriteArticleMgr(IArticleDAO articleDAO) { 
this.articleDAO = articleDAO; 
} 


public void write(ArticleDTO article) { 
System.out.println("WriteArticleServiceImpl.write() 메소드 실행"); 
articleDAO.insert(article); 
} 

} 
  

>>>>> TestMain.java 

package sts.di.app2; 

import org.springframework.beans.factory.BeanFactory; 
import org.springframework.beans.factory.xml.XmlBeanFactory; 
import org.springframework.core.io.ClassPathResource; 
import org.springframework.core.io.Resource; 

public class TestMain { 

public static void main(String[] args) { 
Resource resource = new ClassPathResource("appContext.xml"); 
BeanFactory beanFactory = new XmlBeanFactory(resource); 

// DI 적용 
IWriteArticleMgr articleMgr = (IWriteArticleMgr)beanFactory.getBean("writeArticleMgr"); 
articleMgr.write(new ArticleDTO()); 
} 
} 



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

<bean name="writeArticleMgr" class="sts.di.app2.WriteArticleMgr"> 
<constructor-arg> 
<ref bean="articleDAO" /> 
</constructor-arg> 
</bean> 

<!--  <bean name="articleDAO" --> 
<!--  class="sts.di.app2.MysqlArticleDAO"> --> 
<!--  </bean> --> 

<bean name="articleDAO" 
class="sts.di.app2.OracleArticleDAO"> 
</bean> 
</beans>

생성자 호출시

기본 생성자를 안 만들어놓고 호출하면 

오류남 :>

   - [주의]<bean> 태그에 생성자와 관련된 정보(<constructor-arg> 태그)를 

     명시 하지 않으면 스프링은 기본생성자로 객체를 생성함으로,  

     파라미터가 있는 생성자 를 정의했다면 기본 생성자도 함께  

     정의해 주어야 합니다. 

p:프로퍼티 ="기본 타입 데이터" 

멤버변수

p:프로퍼티명-ref="빈 객체"

이거는 오류 날 확률이 좀 있어서 ... 'ㅅ';;

룩업메소드 패스

콜렉션 타입 프로퍼티 설정

리스트

<?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:p="http://www.springframework.org/schema/p" 

xsi:schemaLocation="http://www.springframework.org/schema/beans 

http://www.springframework.org/schema/beans/spring-beans.xsd"> 

<bean id="messageBean" class="sts.di.app1.MessageBean" > 

        <constructor-arg> 

            <value>Spring</value> 

        </constructor-arg> 

        <!-- 생성자로 di -->

        <property name="greeting"> 

            <value>Hello, </value> 

        </property> 

        <!-- setter로 di -->

        

  </bean> 

</beans> 

[25][spring] Spring기반 MVC의 원리(주요구성요소, 처리순서,web.xml 설정)

[01] 스프링 MVC의 주요 구성 요소 

       



     - DispatcherServlet  
       클라이언트의 요청을 전달받는다. Controller(Action)에게 
       클라이언트의 요청을 전달하고, 컨트롤러가 리턴한 결과값을 
       View에 전달하여 알맞은 응답을 생성하도록 합니다. 

  
     - HandlerMapping  
       클라이언트의 요청 URL을 어떤 Controller(Action)가 처리할지를 
       결정한다. 요청 URL과 Controller클래스의 맵핑을 관리합니다. 

    
     - Controller(Action) 
       클라이언트의 요청을 처리한 뒤, 그 처리 결과를  ModelAndView  
       에 담아서  DispatcherServlet에 반환합니다.  
       스트럿츠의 Action과 동일한 역할을 수행한다. 

                                     
     - ModelAndView 
       Controller(Action)가 모델의 처리한 결과 및 뷰 선택에 필요한 정보를  
       담는다  


     - ViewResolver   
       Controller(Action)의 처리 결과를 생성할 뷰를 결정한다. 
       View정보가 논리적인 View이름일 경우에는 bean설정 파일에 정의되어   
       있는 ViewResolver클래스를 이용하여 클라이언트에게 출력할 View 
       객체를 얻게 됩니다. 


     - View  
       Controller(Action)의 처리 결과 화면을 생성합니다. 
       출력데이터를 설정합니다. 




1. Spring의 MVC의 처리 순서


  

   

---

   1) 클라이언트의 요청이 DispatcherServlet에게 전달 

   2) DispatcherServlet은 HandlerMapping을 사용하여 클라이언트의 요청을  
      처리할 Controller 객체 추출 

   3) DispatcherServlet은 컨트롤러 객체의 handleRequest()메소드를 호출 
      하여 클라이언트의 요청을 처리 

   4) 콘트롤러의 메소드는 처리 결과 정보를 담은 ModelAndView 객체를 리턴 
       
   5) DispatcherServlet은 ViewResolver로부터 응답 결과를 생성할 뷰 객체 추출 

   6) View는 클라이언트에게 전송할 응답을 생성 




     Spring MVC




2. DispatcherServlet,스프링 컨텍스트 설정 및 한글처리  

  - 자바 웹어플리케이션 설정파일인 web.xml에 세개의 정보를 설정합니다. 


  1) 클라이언트의 요청을 전달받을 DispatcherServlet 설정

   
  2) 공통으로 사용할 어플리케이션 컨텍스트 설정 

   
  3) 한글처리용 필터 설정



<?xml version="1.0" encoding="UTF-8"?> 
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xmlns="http://java.sun.com/xml/ns/javaee"  
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> 
  <context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/spring/root-context.xml</param-value> 
  </context-param> 
  <listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
  </listener> 
  <servlet> 
    <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/dispatcher-servlet.xml              
      </param-value> 
    </init-param> 
    <load-on-startup>1</load-on-startup> 
  </servlet> 
  <servlet-mapping> 
    <servlet-name>appServlet</servlet-name> 
    <url-pattern>/</url-pattern> 
  </servlet-mapping>  // 요기까지는 알아서 해주고
  <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> 
  <welcome-file-list> 
    <welcome-file>index.jsp</welcome-file> 
  </welcome-file-list> //이거는 미제가 아니니까 나중에 써줘야함 ㅠㅠ
</web-app> 

컨트롤러의 6가지 역할 ^>^

야! 다까먹었당 :>

아 이거 액션이 하는 거구나 (^_^)!

1요청

2요청분석

3모델사용

4리퀘스트에 저장

5결과를 보여줄 뷰페이지 리턴

5자나...?!

액션은 컨트롤러랑 같은 것

아! 뷰가 다양화되면서 view도 resolver가 필요한 것 -.-)

아오 3시 21분인뎅

6시 20분까지

3시간

남았고

발표는 1시간 정도 했으면 조캣당

 

그러면 2시간 남은 것

아니면 홈페이지^^

리다이렉트나 포워드나 넘나 비슷한 것

글고 디스패처 서블릿이 2개일 경우

설정 파일이 2개(여러개)이지만 -  같이 공통적으로 쓸 수 있는 게 아니라 따로 선언을 해줘야 함

중복되는 경우 - 뭐가 안되고 머리가 아프니까

컨텍스트 - 파람에서 공통으로 쓸거를 적으면 1/2에서 둘 다 접근이 가능하다.

그래서 root-context.xmlㅣ 최상위 인것

[26][spring] Spring MVC Project의 실습

[01] Spring MVC Project의 실습 

 

 

1. Spring MVC 기본예제 1 

 

- Project Type: Spring  Project --> Spring MVC Project    

           Name: mvc_basic 

        Package: spring.mvc.basic 

        Library: 프로젝트 생성시 관련 Spring 라이브러리가 자동으로 다운로드  

                 됩니다. 작업 컴퓨터는 인터넷에 연결되어 있어야 합니다. 

 

 

 

- 프로젝트 구성 

   /mvc_basic/src/main/java                                : Java class 저장 폴더 

   /mvc_basic/src/main/webapp/resources           : CSS, JS, Image등의 리소스 

   /mvc_basic/src/main/webapp/WEB-INF             : Web 환경 설정  

   /mvc_basic/src/main/webapp/WEB-INF/spring  : Spring 환경 설정  

   /mvc_basic/src/main/webapp/WEB-INF/views   : Spring jsp file 

 

 

 

>>> web.xml 

 

        : 

 

 

<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> 

 

 

 

>>>> MyinfoController.java 

 

package spring.mvc.basic; 

 

import java.util.HashMap; 

 

import javax.servlet.http.HttpServletRequest; 

import javax.servlet.http.HttpServletResponse; 

 

import org.springframework.web.servlet.ModelAndView; 

import org.springframework.web.servlet.mvc.AbstractController; 

 

public class MyinfoController extends AbstractController { 

    private String name; 

    private String phone; 

    private String addr; 

 

    public void setName(String name) { 

        this.name = name; 

    } 

 

    public void setPhone(String phone) { 

        this.phone = phone; 

    } 

 

    public void setAddr(String addr) { 

        this.addr = addr; 

    } 

 

    @Override 

    protected ModelAndView handleRequestInternal(HttpServletRequest arg0, 

    HttpServletResponse arg1) throws Exception { 

        ModelAndView mv = new ModelAndView(); 

        mv.setViewName("view/myinfo"); 

        HashMap map = new HashMap(); 

        map.put("name", name); 

        map.put("phone", phone); 

        map.put("addr", addr); 

        mv.addAllObjects(map); 

 

        return mv; 

    } 

} 

 

 

 

 

 

 

 

 

>>>>MyteamController.java 

 

package spring.mvc.basic; 

 

import java.util.ArrayList; 

import java.util.HashMap; 

import java.util.List; 

import java.util.Map; 

 

import javax.servlet.http.HttpServletRequest; 

import javax.servlet.http.HttpServletResponse; 

 

import org.springframework.web.servlet.ModelAndView; 

import org.springframework.web.servlet.mvc.Controller; 

 

public class MyteamController implements Controller { 

 

    @Override 

    public ModelAndView handleRequest(HttpServletRequest arg0, 

    HttpServletResponse arg1) throws Exception { 

        List list = new ArrayList(); 

        Map map = new HashMap(); 

        map.put("name", "왕눈이"); 

        map.put("phone","010-1111-2222"); 

        map.put("addr", "서울시 강남구 역삼동"); 

        list.add(map); 

 

        Map map2 = new HashMap(); 

        map2.put("name", "아로미"); 

        map2.put("phone","010-2222-3333"); 

        map2.put("addr", "서울시 관악구 신림동"); 

        list.add(map2); 

 

        Map map3 = new HashMap(); 

        map3.put("name", "투투"); 

        map3.put("phone","010-4444-5555"); 

        map3.put("addr", "서울시 강남구 역삼동"); 

        list.add(map3); 

 

        ModelAndView mv = new ModelAndView("view/myteam"); 

        mv.addObject("list",list); 

 

        return mv; 

     } 

 

} 

 

 

 

 

>>>> TodayController.java 

 

package spring.mvc.basic; 

 

import javax.servlet.http.HttpServletRequest; 

import javax.servlet.http.HttpServletResponse; 

 

import org.springframework.web.servlet.ModelAndView; 

import org.springframework.web.servlet.mvc.Controller; 

 

public class TodayController implements Controller { 

    private String birth; 

 

    public void setBirth(String birth) { 

        this.birth = birth; 

    } 

    @Override 

    public ModelAndView handleRequest(HttpServletRequest arg0, 

    HttpServletResponse arg1) throws Exception { 

        ModelAndView mv = new ModelAndView("view/currToday"); 

        mv.addObject("birth",birth); 

        mv.addObject("today",getToday()); 

        mv.addObject("age",getAge()); 

        return mv; 

    } 

 

    /** 

     * 생일의 정보를 이용해서 나이구해서 리턴함 

     * @return 

     */ 

    private int getAge() { 

    // TODO Auto-generated method stub 

        return 0; 

    } 

 

    /** 

     * 오늘의 날짜를 생성해서 리턴함 

     * @return 

     */ 

    private String getToday() { 

    // TODO Auto-generated method stub 

        return null; 

    } 

 

} 

 

 

 

 

 

>>>>HelloController.java 

 

package spring.mvc.basic; 

 

import java.util.Calendar; 

 

import javax.servlet.http.HttpServletRequest; 

import javax.servlet.http.HttpServletResponse; 

 

import org.springframework.web.servlet.ModelAndView; 

import org.springframework.web.servlet.mvc.AbstractController; 

 

public class HelloController extends AbstractController { 

    private String me; 

    private String msg; 

 

    public void setMe(String me) { 

        this.me = me; 

    } 

 

    public void setMsg(String msg) { 

        this.msg = msg; 

    } 

 

    @Override 

    protected ModelAndView handleRequestInternal(HttpServletRequest request, 

    HttpServletResponse response) throws Exception { 

        System.out.print("conteroller 호출"); 

        ModelAndView mav = new ModelAndView(); 

        mav.setViewName("view/hello"); 

        mav.addObject("greeting", getGreeting()); 

        mav.addObject("me", me); 

        mav.addObject("msg", msg);

        

        return mav; 

    } 

 

    private String getGreeting() { 

 

        int hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY); 

 

        if (hour >= 6 && hour <= 10) { 

            return "좋은 아침입니다."; 

        } else if (hour >= 12 && hour <= 15) { 

            return "점심 식사는 하셨나요?"; 

        } else if (hour >= 18 && hour <= 22) { 

            return "좋은 밤 되세요"; 

        } 

 

        return "안녕하세요"; 

    } 

 

} 

 

 

 

>>>>>> src/main/webapp/WEB-INF/spring/appServlet/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:p="http://www.springframework.org/schema/p" 

xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

 

<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->

 

<!-- Enables the Spring MVC @Controller programming model -->

<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>

 

<context:component-scan base-package="spring.mvc.basic" />

 

<beans:bean name="helloController" class="spring.mvc.basic.HelloController" 

    p:me="helloController"  

    p:msg="MVC 실습" /> 

 

   <beans:bean name="myinfoController" class="spring.mvc.basic.MyinfoController" 

    p:name="아로미" 

    p:phone="010-1111-2222" 

    p:addr="서울시 서초구 역삼동" /> 

 

   <beans:bean name="myteamController" class="spring.mvc.basic.MyteamController" /> 

 

   <beans:bean name="todayController" class="spring.mvc.basic.TodayController" 

    p:birth="1989년10월10일"/>

 

   <beans:bean id="handlerMapping" 

class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> 

<beans:property name="order" value="1" /> 

<beans:property name="alwaysUseFullPath" value="true" /> 

<beans:property name="mappings"> 

   <beans:props> 

       <beans:prop key="/">homeController</beans:prop> 

       <beans:prop key="/greeting/hello.do">helloController</beans:prop> 

       <beans:prop key="/teaminfo/myinfo.do">myinfoController</beans:prop> 

       <beans:prop key="/teaminfo/myteam.do">myteamController</beans:prop> 

       <beans:prop key="/today/currToday.do">todayController</beans:prop> 

   </beans:props> 

</beans:property> 

</beans:bean> 

 

 

</beans:beans>

 

 

 

 

 

>>>> views/home.jsp 

 

<%@ page language="java" contentType="text/html; charset=utf-8" 

    pageEncoding="utf-8"%> 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 

<html> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=utf-8"> 

<title>Insert title here</title> 

<style type="text/css">

*{ 

  font-family: gulim; 

  font-size: 24px; 

} 

</style>

</head> 

<body> 

<P>  The time on the server is ${serverTime}. </P> 

<br/> 

<ul> 

<li><a href="./greeting/hello.do">인사</a></li>  

<li><a href="./teaminfo/myinfo.do">나의정보 </a></li> 

<li><a href="./teaminfo/myteam.do">팀의 정보</a></li>  

<li><a href="./today/currToday.do">현재날짜와 나이</a></li> 

</ul> 

</body> 

</html> 

 

 

 

 

 

>>>> views/view/hello.jsp 

 

<%@ page language="java" contentType="text/html; charset=UTF-8" %> 

<html> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 

<title>인사</title> 

<style type="text/css">

*{ 

  font-family: gulim; 

  font-size: 24px; 

} 

</style>

</head> 

<body> 
<center>

[${me}] 인사말: <strong>${greeting}</strong><br><br> 

<% 

String hello = (String)request.getAttribute("greeting"); 

%> 

[${msg}] 인사말: <strong><%=hello %></strong><br> 
</center>

</body> 

</html> 

 

 

 

>>>> views/view/myinfo.jsp 

 

<%@ page language="java" contentType="text/html; charset=UTF-8" 

    pageEncoding="UTF-8"%> 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 

<html> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 

<title>나의 정보</title> 

<style type="text/css">

*{ 

  font-family: gulim; 

  font-size: 24px; 

} 

</style>

</head> 

<body> 

<center> 

<h3>나의 정보</h3> 

이름 : ${name} <br/> 

전번 : ${phone} <br/> 

주소 : ${addr} <br/> 

</center> 

 

</body> 

</html> 

 

 

>>>> views/view/myteam.jsp 

 

<%@ page language="java" contentType="text/html; charset=UTF-8" 

    pageEncoding="UTF-8"%> 

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

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 

<html> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 

<title>Insert title here</title> 

<style type="text/css">

*{ 

  font-family: gulim; 

  font-size: 24px; 

} 

</style>

</head> 

<body> 

<table align="center" border="1" width="550" cellpadding="0" cellspacing="0"> 

<caption>팀 목록</caption> 

<tr> 

<th>번호</th><th>이름</th><th>전화번호</th><th>주소</th> 

</tr> 

<c:set var="no" value="${0}"/> 

<c:forEach var="map" items="${list}" varStatus="state"> 

<c:set var="no" value="${no+1}"/> 

<tr> 

<td>${no}</td> 

<td>${map.name}</td> 

<td>${map.phone}</td> 

<td>${map.addr}</td> 

</tr> 

</c:forEach>

 

</table> 

</body> 

</html> 

 

 

 

>>>>> views/view/currToday.jsp 

 

 

<%@ page language="java" contentType="text/html; charset=UTF-8" 

    pageEncoding="UTF-8"%> 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 

<html> 

<head> 

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 

<title>Insert title here</title> 

<style type="text/css">

*{ 

  font-family: gulim; 

  font-size: 24px; 

} 

</style>

</head> 

<body>
<center> 

 오늘의 날짜 <br/> 

 ${today}<br/> 

 ${birth}생일인 사람의 나이는<br/> 

 ${age}세이다. 
</center>

</body> 

</html>

성 명 : 관리자 | 조

5. 수업

진도: 

hw: 

6. 할것

으으 아슬아슬하게 안지각...OTL

STS - 웹서버랑 - 문자형식이랑 - 웹브라우저 - 바꿔줄 것

그리고 DB development에서