Spring프레임워크1
1교시
수업준비
자바설치(java se)
자바환경변수 설정
이클립스 설치(java ee버전)
이클립스 인코딩 utf-8설정: general -> workspace -> UTF8
수업방향: 스프링프레임워크로 간단한 게시판 만들어보기
스프링 프레임워크이란?
자바를 기반으로 한, 다양한 어플리케이션을 제작하기 위한 프로그래밍 오픈소스 프레임워크
Rod Johnson 창시
엔터프라이즈 어플리케이션 개발의 복잡성을 줄여주기 위한 목적
POJO(Plain Old Java Object)를 사용해서 가능하게함.
마치 컴퓨터가 CPU, HDD, RAM 등으로 이루어져서 하나의 컴퓨터 기능을 이루는 것처럼,
우리는 스프링을 활용하여 각각의 구성요소를 만들어 연결해서 어플리케이션이 만들예정
우리가 해야할 것!
- 스프림 프레임웍 구성요소
- 구성요소 작성방법
- 구성요소간 설정하는 법
특징
- 자바 객체 관리 경량급 컨테이너
- POJO 방식의 프레임워크
- 제어역전을 지원(Inversion of Control)
- 의존성 주입을 지원(Dependency Injection)
- 관점지향 프로그래밍 지원(AOP: Aspect Oriented Programming)
- 다양한 API제공 및 연동지원: ex) hiebernate, mibatis 등을 간단하게 붙일수 있음
2교시
이클립스에 Spring 설정하기
help -> eclipse marketplace -> 검색: "sts" -> install
설치가 제대로 됬다면,
project 생성 -> other -> "spring" 검색후 아래 사진처럼 나오면 성공한 것임.
일반적 java 코딩(아래)
Class B b = new Class A(); <-- 일반적으로 프로그래머가 주입해서 참조시키는것
스프링은 주입을 자동으로 해줌.
그것을 배우기위해서, 제어역전지원, 의존성지원특징을 배울것임.
의존성 주입객체, 의존성 주입설정을 해보자!
아래 사진의 구조를 스프링은 스프링 컨테이너에 담고 있음
우리는 이 것을 설정하기 위해서, xml에 설정을 입힘.
스프링 설정전 개념을 익히기 위해서 자바 프로젝트로 개념을 익히자.
자바 프로젝트 만들기(자바프로젝트를 만들어서 Spring 프로젝트로 변화시키기)
프로젝트: Day01_Depenedcy_Injection
패키지: di01
아래 클래스
/*
* 선생님 노트
* 스프링 프레임워크에서의 의존성 주입방법:
* 1. 생성자(constructor) 주입방법
* 2. 설정자(setter) 주입
*/
스프링 컨테이너 설정은 Spring Bean Configuration File을 생성해서 함.
파일명을 applicationContext로 하기
di01 패키지작업장
결과
Tire.java
인터페이스 Tire
package di01;
public interface Tire {
public void roll();
}
ChinaTire.java
package di01;
public class ChinaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("중국 타이어!");
}
}
KoreaTire.java
package di01;
public class KoreaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("한국 타이어!");
}
}
Car.java
package di01;
public class Car {
// 다른객체를 사용하는 클래스, Tire에 의존한다.
private Tire tire; // tire의 객체를 멤버변수로 가지고, 사용도 하고있음.
public void setTire(Tire tire) {
this.tire = tire;
}
// Car는 Tire에 의존함.
public void drive() {
tire.roll();
System.out.println("자동차가 굴러갑니다.");
}
}
Driver.java
package di01;
public class Driver {
public static void main(String[] args) {
// TODO Auto-generated method stub
// Car 객체 만들어서 객체가 가지는 멤버 변수에 의존성 주입
Car myCar = new Car();
Tire tire = new KoreaTire();
myCar.setTire(tire); // 바로 이부분이 의존성 주입!
// 의존성주입과정: 객체를 만들고, 대입해주는것을 기존에는 프로그래머가 함.
// 스프링이 위와 같은 의존성주입과정을 대신해줌.
myCar.drive();
/*
* 선생님 노트
* 다음 di02패키지 작업장에서 의존성 주입을 배워보자.
* 스프링 프레임워크에서의 의존성 주입방법:
* 1. 생성자(constructor) 주입방법
* 2. 설정자(setter) 주입
*/
}
}
3교시
3교시 목표
1. 스프링 컨테이너 객체생성
2. 스프링 컨테이너에서 생성한 bean 꺼내와서 사용하기
먼저 개념 이해
스프링 컨테이너의 설명, 계층 및 종류
container종류: BeanFactory> ApplicationContext> WebApplicationContext
<Bean>태그의 정의, 속성의 종류
scope기본값 singleton 1개의 파일을 계속해서씀.
scope가 prototype이면 요청할때마다 새로 생성해서 만듦.
factory-method: instance를 불러오는 기능
lazy-init: 늦게초기화를 함.
파일(설정 메타데이터)
sts 라이브러리를 marketplace에서 제대로 install했다면,
프로젝트 -> 마우스 오른쪽 -> new -> other-> Spring bean configuration 하면 생김(xml 파일임)
maven을 이용하여 라이브러리 관리를 함.
실전
이제 실제로 해보기
1번: Configuration 파일은 생성완료했음.
2번: 프로젝트를 Maven이 관리할수 있도록 설정유지
2-1번. 프로젝트를 Maven이 관리할수 있도록 설정변경(maven 설정하기): 프로젝트 우클릭 -> Configure -> Convert to Maven Project -> Finish
2-2번. pom.xml이 생성됨을 확인할 수 있음.
2-3번. pom.xml에 depenecy태그들 추가해서 라이브러리 설치/관리하기
pom.xml의 맨밑에 <dependencies></dependencies>를 기재
아래 사이트 -> spring 검색
context 클릭 -> 4.3.10 release클릭(사람들이 가장 많이 사용추정) -> 상세페이지의 <dependency>태그를 복사
core 클릭 -> 4.3.10 release클릭(사람들이 가장 많이 사용추정) -> 상세페이지의 <dependency>태그를 복사
아래 사진
복사한것을 pom.xml에 만들어둔 <dependencies></dependencies>에 붙여넣기
이클립스 tip 코드스크립트 자동정렬하기: 전체 선택 -> 콘트롤 시프트 f (ctrl + shift + f)
그러면, maven이 라이브러리를 dependency설정값에 따라 다운받게됨.(오래걸리므로 시간이 걸림)
2-4번.
네임스페이스 설정하기: context를 설정하면, 어노테이션(아래)것들을 자동으로 찾아서 컨테이너안에 담을 수 있음
@Component
그러한 것을 찾도록 하는 태그(아래)
<context:component-scan base-package="패키지명"></context:component-scan>태그를 쓸수 있음
위와 같이됬다면, 이제 모든 준비가 끝났음.
이제 컨테이너 생성하기
di02패키지작업장: xml로 빈활용해보기
결과
Car.java
package di02;
public class Car {
// 다른객체를 사용하는 클래스, Tire에 의존한다.
private Tire tire; // tire의 객체를 멤버변수로 가지고, 사용도 하고있음.
// 생성자 의존성 주입을 위해서 생성자를 작성
public Car(Tire tire) {
this.tire = tire;
}
public void setTire(Tire tire) {
this.tire = tire;
}
// Car는 Tire에 의존함.
public void drive() {
tire.roll();
System.out.println("자동차가 굴러갑니다.");
}
}
인터페이스 Tire.java
package di02;
public interface Tire {
public void roll();
}
ChinaTire.java
package di02;
public class ChinaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("중국 타이어!");
}
}
KoreaTire.java
package di02;
public class KoreaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("한국 타이어!");
}
}
Driver.java
package di02;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class Driver {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* di01에서는 직접 자동차 객체도 만들었고
* 타이어 객체도 직접 만들었지만
* di02에서는 객체 생성 및 의존성 주입을
* spring이 하도록 만들자.
*
* 객체를 bean이라는 이름으로 Spring container에
* 가지고 있다가 필요할 때 마다 꺼내서 쓸수 있다.
*
* 스프링 컨테이너 객체
* 1. 스프링컨테이너 객체생성
* 2. 스프링컨테이너에서 생성한 bean 꺼내와서 사용하기
*/
// 스프링 컨테이너 만들때, di02밑에 있는 applicationContext.xml을 참고해서 만들어라
ApplicationContext context
= new GenericXmlApplicationContext("di02/applicationContext.xml");
// bean태그의 id값 "myCar"를 getBean의 매개변수로 넣어주기
// object를 반환하므로, Car클래스로 형변환시켜주기
Car myCar1 = (Car)context.getBean("myCar");
// 아래처럼 형변환안하고, 매개변수로 클래스를 입력해도됨.
Car myCar2 = context.getBean("myCar", Car.class);
myCar1.drive();
myCar2.drive();
}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd";>
<!-- beans 정의: bean을 담을수 있는 태그 -->
<!-- 선생님 설명
스프링 프로젝트의 구성요소
1. 스프링 컨테이너 설정파일
- 스프링 컨테이너가 가져야할 객체(bean)의 정보
- 각 객체간의 의존성 설정
2. 스프링 컨테이너
3. 컨테이너 사용부분
-->
<!-- bean 만들기
class 안에는 full package명을 넣을 것
-->
<bean id="tire" class="di02.ChinaTire"></bean>
<!--
ex) 설정자(setter)로 의존성 주입예시
<bean id="myCar" class="di02.Car">
<property name="tire" ref="tire"></property>
</bean>
-->
<!-- -->
<bean id="myCar" class="di02.Car">
<constructor-arg ref="tire"></constructor-arg>
</bean>
<!-- 사용법1. 설정자(setter)로 의존성 주입하기
<property>이용
property태그의 name속성에 setter의 이름에서 set제외하고, 맨앞글자를 소문자로 변경.
ex) setTire() -> tire가 됨.
name="tire"
property태그의 ref속성에 주입하고자하는 객체(bean)의 id값을 넣기
ref="tire"
-->
<!-- 사용법2. 생성자(constructor)로 의존성 주입하기
<constructor-arg>이용
-->
</beans>
di03패키지작업장(어노테이션으로 빈활용-설정자)
어노테이션으로 빈객체 만들기
빈으로 등록하고자하는 클래스로 이동해서 @Component를 붙이기
ex) Class Car
@AutoWired를 클래스 Car 의 setTire(Tire tire)매소드(setter)위에 적기
applicationContext 생성, 설정
결과
Car.java
package di03;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
// bean 객체를 만들어야 하는 클래스임을 표시.
// @Component("myCar") <-처럼 bean태그의 id속성 값을 지정할수도 있음.
@Component
public class Car {
// 다른객체를 사용하는 클래스, Tire에 의존한다.
// Autowired 위치: 생성자 위, Setter 위, 변수 위
@Autowired
private Tire tire; // tire의 객체를 멤버변수로 가지고, 사용도 하고있음.
// 생성자 의존성 주입을 위해서 생성자를 작성
// 생성자 주입방법도 마찬가지로 Autowired하면됨.
// qualifier()를 쓸수없음.
// @Autowired
// public Car(Tire tire) {
// this.tire = tire;
// }
//Autowired : 타입매칭을 통해서 의존성 주입할 객체를 찾아옴
//스프링컨테이너 안에서 적당한 객체(타입이 매칭되는 bean)를 가져와서 주입
//그런데 매칭되는 타입이 2개 이상이다 >> 어떤 bean을 참조 해야할지 모르기때문에 에러 발생
//같은 타입이 2개라면 이름을 정해주어야 한다. : Qualifier
//@Autowired
//@Qualifier("koreaTire")
//public void setTire(Tire tire) {
// this.tire = tire;
//}
// applicationContext에 정의된 Tire 클래스 유형의 bean을 못찾게된다면,
// Car클래스가 빈으로 생성안되게됨.
// 이때,@Autowired(required = false)를 기재하게된다면=> 못찾으면(없으면) 그냥 무시하고 Car 만들어라라는 뜻임.
// @Autowired(required = false)
// public void setTire(Tire tire) {
// this.tire = tire;
// }
// Car는 Tire에 의존함.
public void drive() {
tire.roll();
System.out.println("자동차가 굴러갑니다.");
}
}
package di03;
public interface Tire {
public void roll();
}
ChinaTire.java
package di03;
public class ChinaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("중국 타이어!");
}
}
KoreaTire.java
package di03;
import org.springframework.stereotype.Component;
@Component
public class KoreaTire implements Tire{
@Override
public void roll() {
// TODO Auto-generated method stub
System.out.println("한국 타이어!");
}
}
driver.java
package di03;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
public class Driver {
public static void main(String[] args) {
// TODO Auto-generated method stub
// @에노테이션을 이용한 bean 생성 및 의존성 주입
// 1. 어떤 클래스를 이용해서 bean 객체를 만들겠다고 설정
// 2. 어떤 패키지에서 bean객체를 만들겠다라고 설정 -> xml 작성
// 3. 생성될 때 의존성에 대한 설정 -> annotation
ApplicationContext context
= new GenericXmlApplicationContext("di03/applicationContext.xml");
// Annotation으로 bean을 생성할때, 이름을 정해주지 않으면,
// 클래스 이름 Car 첫글자를 소문자로 바꾼이름을 사용
Car myCar = context.getBean("car", Car.class);
myCar.drive();
}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.3.xsd";>
<!-- @Component annotation이 있으면 bean 객체를 만들기. -->
<!-- annotation 사용하시려면 namespace에서 context체크해놓기 -->
<!-- <context:component-scan base-package="">생성하기-->
<!-- base-package="di03" 패키지명 넣기 -->
<context:component-scan base-package="di03"></context:component-scan>
</beans>
오후수업
오늘 목표&한것 재정리
java jdk설치
eclipse 다운
STS 설치
Maven 프로젝트 변경
라이브러리 다운로드 - mvnrepository.com
Spring 설정파일 생성: Spring bean configuration file(스프링 컨테이너 설정 메타 데이터 만들기)
- bean 생성하기 -xml, annotation
- bean 의존성 주입, xml, annotation
- bean의 대표적인 속성값 이용해보고 확인하기
개념설명다시
이러한 느슨한 결합을 통해서 비슷한 유형을 찾아서 출력해주기도 함.(설정도 가능)
실습
java jdbc이용해서 실습해보기(사실 안쓰는거지만.... 복습을 위해서)
mysql설치: default로 설정하기(), next, excute눌러주기, repair, install, close등을 계속 눌르기
시작 -> 검색 -> "mysql" 후, MySQL 5.6 Command Line Client 실행
root 암호 치기
정상적으로 설치되었다면, 아래처럼 나옮.
show databases;를 쳐서 기능작동 확인
create database spring;
use spring;
spring database 만들고 사용선언
나중에 사용할건 아니지만, 테스트용으로 테이블 생성하기
create table user( id varchar(20), name varchar(20), pass varchar(20) );
만든다음 만들어졌는지 user의 스키마 구조 확인
desc user;
자료를 한개 넣어주자
실습을 위해, Java jdbc만들어서 예전방식의 db연동을 설정해보기
UserDao 클래스 만들기
실습전 잠깐 상식(아래)
maven에 mysql 연동하기
사람들이 많이 사용하는 5.1.38의 dependency 복사해서 pom.xml에 추가
아래 xml부분을 pom.xml의 depenecy태그 추가
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
<modelVersion>4.0.0</modelVersion>
<groupId>Day01_Dependency_Injection</groupId>
<artifactId>Day01_Dependency_Injection</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<resources>
<resource>
<directory>src</directory>
<excludes>
<exclude>**/*.java</exclude>
</excludes>
</resource>
</resources>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.10.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
</dependencies>
</project>
lifecycle 패키지 작업방:
DAO에 연결을 해주는 멤버변수를 가지게 하기위해서 클래스를 따로 하나 만들어주자.
Interface ConnectionProvider
package lifecycle;
import java.sql.Connection;
import java.sql.SQLException;
public interface ConnectionProvider {
public Connection getConnection() throws ClassNotFoundException, SQLException;
}
위 ConnectionProvider를 인터페이스 상속받는 ConnectorA, ConnectorB를 만들기
왜? 만약에 오라클db, mysql들에서 자료를 가져오게 설정해두면, 쉽게 db연결부분을 조정할수 잇음
connectorA.java
package lifecycle;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectorA implements ConnectionProvider{
@Override
public Connection getConnection() throws ClassNotFoundException, SQLException {
// TODO Auto-generated method stub
// 만들어둔 database이름: spring
String url = "jdbc:mysql://localhost:3306/spring";
String user = "root";
String pwd = "admin";
Class.forName("com.mysql.jdbc.Driver");
System.out.println("드라이버 로딩성공!!");
// DriverManager.getConnection(url, user,pwd);를 사용해야함.
// Connection 객체를 만들고, 위 getConnection을 담아주기
// 이게 성공하면, 이제 DB에 연결할 수 있음
Connection conn = DriverManager.getConnection(url, user,pwd);
return conn;
}
}
ConnectorB.java
package lifecycle;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectorB implements ConnectionProvider {
@Override
public Connection getConnection() throws ClassNotFoundException, SQLException {
// TODO Auto-generated method stub
// 만들어둔 database이름: spring
String url = "jdbc:mysql://localhost:3306/spring";
String user = "root";
String pwd = "admin";
Class.forName("com.mysql.jdbc.Driver");
System.out.println("드라이버 로딩성공!!");
// DriverManager.getConnection(url, user,pwd);를 사용해야함.
// Connection 객체를 만들고, 위 getConnection을 담아주기
// 이게 성공하면, 이제 DB에 연결할 수 있음
Connection conn = DriverManager.getConnection(url, user,pwd);
return conn;
}
}
ConnectionTest.java
package lifecycle;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionTest {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
//드라이버 로딩
//연결(url, user, password): DriverManager라는 클래스가 가지고 있는 getConnection()을 이용할 예정
// 만들어둔 database이름: spring
String url = "jdbc:mysql://localhost:3306/spring";
String user = "root";
String pwd = "admin";
Class.forName("com.mysql.jdbc.Driver");
System.out.println("드라이버 로딩성공!!");
// DriverManager.getConnection(url, user,pwd);를 사용해야함.
// Connection 객체를 만들고, 위 getConnection을 담아주기
// 이게 성공하면, 이제 DB에 연결할 수 있음
Connection conn = DriverManager.getConnection(url, user,pwd);
}
}
UserDAo.java
package lifecycle;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import vo.User;
public class UserDao {
// DAO: Data Access Object:
// 데이터 베이스에 있는 데이터를 조회하거나 변경, 삽입, 삭제하는 기능
// 드라이버로딩
// 연결
// 구문객체생성
// SQL
// 실행
ConnectionProvider conProvider;
// 내가 필요할때마다 연결을 얻어오면 됨.
public void setConnectionProvider(ConnectionProvider conProvider) {
this.conProvider = conProvider;
}
// 굳이 init과 destroy라고 매소드명을 적을 필요는 없지만, 테스트를 위해 아래와 같이 만들기
// applicationContext.xml의 UserDao 빈파일의 속성을 설정해주기
public void init() {
System.out.println("UserDao 사용준비 완료");
}
public void destroy() {
System.out.println("UserDao 소멸");
}
public User selectOne(String id) {
User user = null;
String sql = "select * from user where id= ?";
// PreparedStatement: Statement가 너무 불편해서, 조금 개선해서 만든 구문객체
// 변수값을 쉽게 만들수 있음.
// 선언은 밖에해야지 나중에 close할수 있음
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
conn = conProvider.getConnection();
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, id);
pstmt.executeQuery();
// execute, executeQuery, executeUpdate
// execute: DDL db의 설정값 변경시 주로 사용. select도 실행이 되긴함.
// executeQuery: select
// executeUpdate: update, delete, insert
rs = pstmt.executeQuery();
if(rs.next()) {
user = new User();
// 결과셋에 있는 문자열 가지고 와라
user.setId( rs.getString(1) );
// user.setId( rs.getString("id") ); db 테이블의 속성명(컬럼명)으로도 가능
user.setName( rs.getString(2) );
user.setPass( rs.getString(3) );
}
} catch (ClassNotFoundException | SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return user;
}
}
UserDAoTest.java
package lifecycle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import vo.User;
public class UserDaoTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 스프링 컨테이너 생성
ApplicationContext context
= new GenericXmlApplicationContext("lifecycle/applicationContext.xml");
UserDao dao = context.getBean("userDao", UserDao.class);
UserDao dao1 = context.getBean("userDao", UserDao.class);
User user = dao.selectOne("id1");
System.out.println(user);
// destroy()매소드에 있는 System.out.println("UserDao 소멸"); 출력하기위해 한건데, 안됨.ㅡㅡ
// ( (AbstractApplicationContext)context ).close();
// scope: prototype: getBean() 될때마다 새롭게 만들어냄.
// scope: singleton: getBean() 될때 계속 같은 객체를 반환
System.out.println(dao);
System.out.println(dao1);
}
}
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd";>
<bean id="userDao" class="lifecycle.UserDao" init-method="init" destroy-method="destroy" scope="singleton">
<property name="connectionProvider" ref ="cp"></property>
</bean>
<bean id="cp" class="lifecycle.ConnectorA"></bean>
</beans>
User.java
package vo;
public class User {
// table user에 데이터를 넣고 빼기위한 모델 클래스
// 모델클래스 아래의 의미를 가지고, 통상 vo, dto라고 불림
// VO:Value Object, DTO:Data Transfer Object
private String id;
private String name;
private String pass;
public User() {
super();
}
public User(String id, String name, String pass) {
super();
this.id = id;
this.name = name;
this.pass = pass;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPass() {
return pass;
}
public void setPass(String pass) {
this.pass = pass;
}
// 객체에 멤버변수를 쉽게 출력하기위한 메서드 오버라이딩
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", pass=" + pass + "]";
}
}
성공결과
아래 추가 설명부분
scope: prototype일때, 객체생성시 다른것을 생성함.
<?xml version="1.0" encoding="UTF-8"?>
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd";>
<bean id="userDao" class="lifecycle.UserDao" init-method="init" destroy-method="destroy" scope="prototype">
<property name="connectionProvider" ref ="cp"></property>
</bean>
<bean id="cp" class="lifecycle.ConnectorA"></bean>
</beans>
package lifecycle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import vo.User;
public class UserDaoTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 스프링 컨테이너 생성
ApplicationContext context
= new GenericXmlApplicationContext("lifecycle/applicationContext.xml");
UserDao dao = context.getBean("userDao", UserDao.class);
UserDao dao1 = context.getBean("userDao", UserDao.class);
User user = dao.selectOne("id1");
System.out.println(user);
// destroy()매소드에 있는 System.out.println("UserDao 소멸"); 출력하기위해 한건데, 안됨.ㅡㅡ
// ( (AbstractApplicationContext)context ).close();
// scope: prototype: getBean() 될때마다 새롭게 만들어냄.
// scope: singleton: getBean() 될때 계속 같은 객체를 반환
System.out.println(dao);
System.out.println(dao1);
}
}
scope:singleton일때, 객체생싱마다 같은 객체를 반환
<?xml version="1.0" encoding="UTF-8"?>
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd";>
<bean id="userDao" class="lifecycle.UserDao" init-method="init" destroy-method="destroy" scope="singleton">
<property name="connectionProvider" ref ="cp"></property>
</bean>
<bean id="cp" class="lifecycle.ConnectorA"></bean>
</beans>
package lifecycle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import vo.User;
public class UserDaoTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 스프링 컨테이너 생성
ApplicationContext context
= new GenericXmlApplicationContext("lifecycle/applicationContext.xml");
UserDao dao = context.getBean("userDao", UserDao.class);
UserDao dao1 = context.getBean("userDao", UserDao.class);
User user = dao.selectOne("id1");
System.out.println(user);
// destroy()매소드에 있는 System.out.println("UserDao 소멸"); 출력하기위해 한건데, 안됨.ㅡㅡ
// ( (AbstractApplicationContext)context ).close();
// scope: prototype: getBean() 될때마다 새롭게 만들어냄.
// scope: singleton: getBean() 될때 계속 같은 객체를 반환
System.out.println(dao);
System.out.println(dao1);
}
}
