Property(속성) 


Property(속성) 란 무엇인가요 ? 

=> 일반적으로 DTO(Data Transfer Object) 또는 VO(Value Obejct) 에서 볼 수 있다. 

=> 인스턴스 변수와 getter와 setter로 만들어진 형태 


[Properties ]

=> 키와 값을 쌍으로 갖는 자료구조 또는 파일입니다. 

=> 키와 값을 자료형이 모두 String(문자열) 입니다. 

=> 변경 가능성이 있는 문자열을 별도의 properties 파일에 작성해두고 프로그램 내에서 호출하는 형태로 많이 사용합니다. 

=> 변경 가능성이 있는 문자열을 String 타입의 객체에 저장해두고 사용하면 수정을 할 때 컴파일을 다시해서 실행시켜야합니다. 

=> 컴파일을 다시해서 실행하게 되면 시간이 오래 걸리게 되면 컴파일을 하다 예기치 못한 오류를 발생가능성이 있습니다.

=> 별도의 파일이나 테이터베이스를 이용하게 되면 컴파일을 다시 하지 않고 재실행 만으로 변경 내용을 적용할 수 있기 때문에 

예기치 못한 오류를 발생시킬 가능성이 줄어들게 됩니다. 



[유의사항]

=>properties 작성할 때 유의할 점은 utf-8로 인코딩해서 작성해야 하는 것입니다. 

=>eclipse에서는 text file이나 encoding 옵션을 utf-8로 설정 해두고 작업을 하는 것이 편리합니다. 



[예제를 하나 만들어 봅시다]

준비 :  기본적인 오라클 셋팅은 되어 있어야합니다. 


1. Simple Spring Maven Project 생성 

2. 프로젝트를 선택하고 마우스 오른쪽 클릭하고 [Properties] - Project Facets  에서  java version변경 

3. pom.xml 파일에서 Spring version을 4.x.x로 변경 

4. src/main/resources 디렉토리에 db.properties 파일을 생성 


1
2
user.email=ggangpae1@naver.com
user.name=관리자 
cs


5. main클래스에서 properties 불러보기  


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package main;
 
import java.io.IOException;
 
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.io.support.ResourcePropertySource;
 
public class Main {
 
    // 응용 프로그램이 호출할 수 있는 유일한 메소드 모양입니다.
    public static void main(String[] args) {
 
        // 자바의 프로퍼티
 
        // ApplicationContext 객체 만들기
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 
        // 시스템 프로퍼티를 읽을 수 있는 객체를 생성
        ConfigurableEnvironment env = (ConfigurableEnvironment) context.getEnvironment();
 
        // Property 파일의 내용을 읽을 수 있는 객체를 생성
        MutablePropertySources pSource = env.getPropertySources();
 
        // 프로퍼티 파일 연결
        try {
            pSource.addFirst(new ResourcePropertySource("classpath:user.properties"));
            
            
            System.out.println("이메일:"+env.getProperty("user.email"));
            System.out.println("이메일:"+env.getProperty("user.name"));
            
 
        } catch (IOException e) {
            System.out.println("[Main] Property 예외" + e.getMessage());
            e.printStackTrace();
        }
 
        // applicationContext 객체 닫기
        context.close();
    }
 
}
cs


[ 스프링 설정 파일에 properties 파일 읽기  ]


설정파일은     SpringBeanConfiguration 파일을 src/main/resources 디렉토리에 생성합니다. 

<context:property-placeholder location=“classpath:/프로퍼티파일 경로"/> 

태그를 스프링 설정 파일에 추가하고 ${프로퍼티 파일의 키}를 작성하면 프로퍼티 파일에서 키에 해당하는 문자열을 가져와서 출력을 하게 됩니다. 


1.src/main/resources 디렉토리에 db.properties 파일을 만들고 db 접속 정보를 프로퍼티로 생성

1
2
3
4
5
6

 
db.driver=oracle.jdbc.driver.OracleDriver
db.url=jdbc:oracle:thin:@localhost:1521:xe
db.user=user08
db.password=user08
cs



2.driver, url, user, password를 프로퍼티(인스턴스 변수, getter, setter)로 갖는 db.Dao 클래스를 생성


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package domain;
 
public class DbVo {
 
    
    
    private String driver; 
    private String url; 
    private String user; 
    private String password;
    
    public String getDriver() {
        return driver;
    }
    public void setDriver(String driver) {
        this.driver = driver;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUser() {
        return user;
    }
    public void setUser(String user) {
        this.user = user;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    
    @Override
    public String toString() {
        return "DbVo [driver=" + driver + ", url=" + url + ", user=" + user + ", password=" + password + "]";
    } 
    
    
    
}
cs


3.SpringBeanConfiguration 파일을 src/main/resources 디렉토리에 생성하고 Dao 클래스의 객체를 만드는 코드를 추가

1)context 네임스페이스 추가


2)프로퍼티 파일의 내용을 읽을 수 있는 태그 추가

1
<context:property-placeholder location="classpath:/db.properties" />
cs

3)Dao 클래스의 bean을 생성하는 코드를 추가하고 property에 db.properties 파일의 내용을 설정하는 코드를 작성 - DI

1
2
3
4
5
6
7
8
9
10
    <!-- db.Dao 클래스의 객체를 생성하는 코드 -->
    <bean id="dao" class="db.Dao">
        <!-- driver 라는 프로퍼티에 db.properties 파일에 작성한
        db.driver 라는 키의 값을 대입 -->
        <property name="driver" value="${db.driver}" />
        <property name="url" value="${db.url}" />
        <property name="user" value="${db.user}" />
        <property name="password" value="${db.password}" />
    </bean>
 
cs


4.main 메소드의 내용을 수정해서 dao 빈의 내용을 출력

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//응용 프로그램이 호출할 수 있는 유일한 메소드 모양입니다.
    public static void main(String[] args){
        
        //ApplicationContext 객체 만들기
        GenericXmlApplicationContext context = 
            new GenericXmlApplicationContext(
                "classpath:applicationContext.xml");
        
        //db.Dao 클래스의 bean 가져오기
        Dao dao = context.getBean(Dao.class);
        System.out.println(dao);
        
        
        //ApplicationContext 객체 닫기
        context.close();
        
    }
 
cs


저작자표시 비영리 변경금지

'Java > 스프링' 카테고리의 다른 글

JdbcTemplate 클래스  (0) 2018.04.09
Spring 2-2 TEST 디렉토리 사용  (0) 2018.04.09
Spring 1- 2 DI와 IOC ,@Component @Bean 사용 정리  (0) 2018.04.06
DI(Dependency Injection)  (0) 2018.04.05
Spring 1-1) IOC 제어의 역전  (0) 2018.04.05

**Spring의 IOC 이용 


1. IOC(Inversion of Control)란 무엇인가? 

객체 생성을 직접하지 않고 프레임워크나 컨테이너가 생성해 준 객체를 이용하는 것을 IOC(제어의 역전)이라고 합니다. 



2. IOC방법은 어떠한 방법이 있을까요 ? 

1.  어노테이션(@)을 이용하는 방법    AnnotationConfigApplicationContext, 

2.   XML 파일을 이용하는 2가지 방법이 있습니다. 

GenericXmlApplicationContext 클래스가 ApplicationContext 인터페이스를 implements 




3. 제어의 역전(IOC)에 대해 이해해 봅시다.

일반적인 프로그램에서의 오브젝트에 대한 제어는 오브젝트를 생성하고 그 오브젝트를 이용해서 작업을 수행하는 형태입니다.

예를 들어서 

ClassA 가 있고 이걸 Main에서 호출해서 사용하려면 

ClassA exm = new ClassA(); 형식으로 객체를 생성해야할 것입니다. 


하지만, 제어의 역전이란 앞에서의 코드처럼 직접 객체를 생성하지 않고 다른 곳에서 생성해 준 객체를 가지고 작업을 수행하는 방식입니다.


4. 이러한 예는 서블릿에서도 찾을 수 있다. 

Eclipse 기반의 톰캣 컨테이너를 사용하는 프로젝트에서 서블릿은 직접 생성자를 호출해서 객체를 생성한 적이 없는데 

클라이언트의 요청이 오면 서블릿 객체의 doGet이나 doPost 메소드가 호출되는데 

이는 서블릿 객체에 대한 제어 권한을 컨테이너가 소유하고 있어서 적절한 시점에 서블릿 클래스의 오브젝트를 생성하고 

그 안의 메소드를 호출해주는 형태로 동작하기 때문인데 이러한 방식을 제어의 역전이라고 합니다.


프레임워크나 Connection Pool을 이용한 데이터베이스 활용도 제어의 역전을 활용한 예로 객체 생성 시 객체의 생성자를 직접 호출하지 않습니다.



IOC(제어의 역전 활용해봅시다. )


1. 어노테이션 방법 


1
2
3
4
5
6
7
8
9
10
//팩토리 클래스로 만들어주는 어노테이션
@Configuration
public class GoodDaoFactory {
    //GoodDao 클래스의 객체 생성 메소드를 호출해서 리턴
    //객체를 생성해주는 메소드라는 어노테이션
    @Bean
    public static GoodDao create() {
        return new GoodDao();
    }
}
cs



2. 메인 클래스 생성 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package main;
 
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import dao.GoodDao;
import dao.GoodDaoFactory;
 
public class Main {
 
    //Java 응용 프로그램에서 사용되는 entry point(진입점)
    //Java 응용 프로그램을 실행하면 이 메소드가 호출됩니다.
    public static void main(String[] args) {
              
        //스프링의 annotation을 이용해서 객체 생성 
        //팩토리 클래스 지정 
        AnnotationConfigApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(GoodDaoFactory.class);
        
        //객체 생성 
        GoodDao goodDao = applicationContext.getBean("create",GoodDao.class);
        
        //메소드 호출 
        System.out.println(goodDao.getGood("001"));
        
        
    }
}
cs




**XML 파일을 이용한 Bean 설정 (IOC)  


Spring Bean Configuration 파일을 만들어서 bean 태그를 이용해서 설정하면 어노테이션을 이용했던 것처럼 사용할 수 있습니다. 

이 방법이 더 많이 사용됩니다. 

=> Spring Bean Configuration파일은 beans 태그로 시작해야합니다. 


1. beans 태그 

beans 태그를 만들 때 네임스페이스 또는 xml 스키마 관련 정보를 같이 넣어야 합니다. 

하위 태그로는 <bean>, <import>, <decription>,  <alias> 등이 있습니다. 


1-1) bean 태그 : 객체를 생성하기 위한 태그 

2) import 태그 : 설정해야 할 내용이 많을 때나 여러 곳에서 공통으로 사용하는 설정이 있을 때 다른 파일에 설정 내용을 작성하고 

호출해서 사용하기 위한 태그 

<import resource="다른 설정 파일 경로"/>



2. bean 태그를 이용해서 객체 생성 

1) spring bean configuration 파일에 bean 태그를 추가 

<bean id ="구별 아이디" class="객체를 생성할 클래스 경로 "> </bean>


2-1) 가져다가 사용할 파일에 추가 

GenericeXmlApplicationContext  변수명 = new GenericXmlApplicationContext("스프링 설정파일 경로");

클래스 이름 객체 변수명 = 변수명.getBean("구별할 아이디", 클래스이름.class);




실습해봅시다. 

1. Spring에서   spring legacy project를 생성한 후 


2. src/main/ resource에 오른쪽 클릭 New => Spring Bean Configuration


3. 파일 이름은  : applicationContext.xml 설정 


1
2
3
4
5
6
7
8
9
10
 
<?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.xsd">

<!-- GoodDao 클래스의 객체를 goodDao라는 이름으로 생성 -->
    <bean id = "goodDao" class="dao.GoodDao" destroy-method=""></bean>
    
</beans>
cs


1
2
3
4
5
6
7
8
// 메인에서 실행

GenericXmlApplicationContext context =
 new GenericXmlApplicationContext("classpath:applicationContext.xml");
 
객체 생성         
GoodDao goodDao = context.getBean("goodDao", GoodDao.class);    //xml 파일에설정한 class태그에서 .다음클래스이름 가져오면됩니다. 
System.out.println(goodDao.getGood("001"));
context.close();
 
cs








이 글에서 사용한 클래스 내용 


dao. ClassDAO


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package dao;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
 
import domain.Good;
 
public class GoodDao{
 
    Connection con;
    PreparedStatement pstmt;
    ResultSet rs;
 
    public GoodDao() {
        System.out.println("생성자");
    }
 
    public void init() {
        System.out.println("초기화 메소드");
    }
 
    // 문자열로 된 code를 입력받아서 goods 테이블에서 데이터를
    // 찾아서 리턴하는 메소드
    public Good getGood(String code) {
 
        Good good = null;
        // 문제가 발생할 가능성이 있는 코드
        try {
            // 오라클 드라이버 클래스 로드
            Class.forName("oracle.jdbc.driver.OracleDriver");
            // 데이터베이스 연결
            con = DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.200:1521:xe", "user08", "user08");
 
            // goods 테이블에서 code를 가지고 테이터를 조회하는 sql
            pstmt = con.prepareStatement("select *from goods where code =? ");
            pstmt.setString(1, code);
 
            // SQL 실행
            rs = pstmt.executeQuery();
            if (rs.next()) {
                good = 
                good.setCode(rs.getString("code"));
                good.setName(rs.getString("name"));
                good.setManufacture(rs.getString("manufacture"));
                good.setPrice(rs.getInt("price"));
            }
            // 문제가 발생했을 때 수행할 코드
        } catch (Exception e) {
            System.out.println("[Dao] get메소드 예외 " + e.getMessage());
            e.printStackTrace();
            // 무조건 수행할 코드
            // 프로그램은 필연적으로 예측할 수없는 예외가 생길 수 있습니다.
            // 프로그램은 예외가 생겨도 팅기면 안되기 때문에 try catch를 씁니ㅏㄷ.
        } finally {
 
            try {
                if (rs != null)
                    rs.close();
                if (pstmt != null)
                    pstmt.close();
                if (con != null)
                    con.close();
            } catch (SQLException e) {
                System.out.println("[DAO]닫기 예외" + e.getMessage());
                e.printStackTrace();
            }
 
        }
        return good;
    }
 
}
cs





domain.Good


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package domain;
 
 
 
public class Good  {
    //데이터를 저장하기 위한 변수 
    //private : 객체가 사용할 수 없음 
    private String code;
    private String name;
    private String manufacture;
    private  int price;
    
    public  Good(String code) {
        this.code = code; 
    }
    //객체가 변수를 사용할 수 있도록 해주는 메소드 
    //일반 변수는 동기화 제어를 할 수 없지만 메소드는 가능합니다. 
    // 동시에 같이 쓸 수 있다. 
    
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getManufacture() {
        return manufacture;
    }
    public void setManufacture(String manufacture) {
        this.manufacture = manufacture;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    
    
    
    
    @Override
    public String toString() {
        return "Good [code=" + code + ", name=" + name + ", manufacture=" + manufacture + ", price=" + price + "]";
    }
    
    
}
 
cs




applicationContext.xml 


1
<bean id = "goodDao" class="dao.GoodDao" init-method="init" lazy-init="true"></bean>
cs


저작자표시 비영리 변경금지

'Java > 스프링' 카테고리의 다른 글

Spring 2-2 TEST 디렉토리 사용  (0) 2018.04.09
Spring 2-1 Property(속성)  (0) 2018.04.09
Spring 1- 2 DI와 IOC ,@Component @Bean 사용 정리  (0) 2018.04.06
DI(Dependency Injection)  (0) 2018.04.05
1. Spring의 정의와 특징  (0) 2018.04.05

스프링 




스프링이란 무엇인가 ? 

자바 엔터프라이즈 개발을 편하게 해주는 오픈 소스로 경량급 Application 프레임워크입니다. 



스프링의 특징 

=> 가장 강력한 자바 오픈소스 프레임워크 
=> J2EE가 가진 거의 모든 기능을 소유한 프레임워크 

ü복잡함에 반기를 들어서 나온 프레임워크
ü플랫폼 호환성 문제 해결
ü스프링은 JavaEE가 제공하는 다수의 기능을 지원하고 있기 때문에 JavaEE를 대체
ü스프링은 IoC(제어의 역전)을 지원
+> Ioc(제어의 역전) 객체를 내가 만들지 않는 것 클래스 
=> ex ) FIlter, Controller 
ü스프링은 DI(Dependency Injection)패턴을 지원
=> DI : 의존성 주입  Maven의 Pom.xml 

ü스프링은 AOP(Aspect Oriented Programming)를 지원
=> AOP :  관점 지향프로그래밍 관점에 따라 나누어 작업하자 
ü스프링은 POJO(Plain Old Java Object)를 지원

=> POJO는 MVC 패턴을 적용한 프로젝트에서 DAO, VO, SERVICE  순순한 자바로부터 상속, 
=> POJO가 아닌 애는 HTTPServlet을 상속받은 Controller가됩니다.  

ü트랜잭션 처리를 위한 일관된 방법을 제공
ü영속성 - MyBatis, Hibernate, JPA등과 같은 프레임워크와의 연동을 지원
ü편리한 MVC 구조를 가지고 있고 WAS에 종속되지 않는 개발 환경
ü2.5버전에서 어노테이션을 이용한 설정 지원
ü3.0에서는 Java 클래스를 이용한 설정 지원
ü4.0에서는 REST 방식의 Controller 지원


v스프링 프로젝트 종류

üSpring Boot를 이용(Spring Starter Project): 최대한 간단하게 실행하고 배포가 가능한 수준의 애플리케이션을 만들 때 사용하는데 WAS 설정없이 실행이 가능하기 때문에 테스트 하기에 편리하지만 기존의 웹 프로젝트 설정과 다른 방법으로 사용하며 JSP 설정은 별도로 수행 <작은 프로젝트에서 사용>

üSpring Template Project 이용(Spring Legacy Project): WAS를 사용하거나 이전에 Spring Project를 만들어본 경우 사용하는 방식인데 WAS로 인한 리소스 소모가 심하다는 단점이 있지만 기존 프로젝트들이 이 방식으로 많이 만들어져 있음 <큰 프로젝트에서 사용>






저작자표시 비영리 변경금지

'Java > 스프링' 카테고리의 다른 글

Spring 2-2 TEST 디렉토리 사용  (0) 2018.04.09
Spring 2-1 Property(속성)  (0) 2018.04.09
Spring 1- 2 DI와 IOC ,@Component @Bean 사용 정리  (0) 2018.04.06
DI(Dependency Injection)  (0) 2018.04.05
Spring 1-1) IOC 제어의 역전  (0) 2018.04.05

+ Recent posts

티스토리툴바