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"?>
    <!-- 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("자동차가 굴러갑니다.");
    }
}



인터페이스 tire.java
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"?>
    
    <!-- @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(스프링 컨테이너 설정 메타 데이터 만들기)

  1. bean 생성하기 -xml, annotation
  2. bean 의존성 주입, xml, annotation
  3. 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>

    <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"?>
    <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"?>
    <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"?>
    <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);
    }
}

















저작자표시 비영리 변경금지
홈서버용 조립PC 만들기1_조립순서, 간단이해



조립순서
메인보드 -> cpu 삽입 -> cpu 쿨러 결합(열그리스를 조금 발라주기) -> RAM메모리카드 삽입 -> 그래픽카드 삽입 -> IO쉴드를 케이스에 끼우기 -> 메인보드 조립하기 -> ssd 메인보등 연결/케이스에 고정 -> hdd 메인보드 연결/케이스에 고정 -> 파워 서플라이 연결/케이스에 고정 -> CMOS 셋업




핵심부품목록


CPU
사람머리의 생각하는 역할(연산)


CPU 쿨러
CPU의 열을 식혀주는 장치


메인보드
사람의 몸(머리, 팔, 다리가 붙어있으며, 연결해주는 곳)
각 부품들과 호환성과 안전성을 따져야함.


RAM
사람의 일시적인 기억을 저장하는 역할
CPU 명령을 처리하는 역할로 RAM 용량이 크면 속도 빨라짐


그래픽카드(GPU 또는 VGA로 불림)
사람의 시신경같은 부분
모니터 화면 출력하는 일을 함.


HDD(하드디스크)
사람의 장기적인 기억을 저장하는 역할(느림)
가격이 저렴하지만 속도가 느림


SSD
사람의 장기적인 기억을 저장하는 역할(빠름)
가격이 비싸지만 속도가 빠름.


케이스
사람의 골격, 피부(외형)


파워 서플라이
사람의 에너지 공급역할.
부품을 많이 달릴수록 높은 전력의 파워 서플라이를 사용해야함.
높은 전력의 파워 서플라이는 전기세가 많이 나감


그 밖에 ODD, 모니터, 키보드와 마우스 


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


티스토리 블로그 운영 총망라1 (A to Z)_무단 스크랩 마우스 오른쪽클릭 복사 방지(플러그인/javascript)


티스토리 회원가입은 운영진 또는 기존 블로거의 초대장을 받아야지만 운영이 가능하다.
핸드폰에 티스토리 어플을 설치하고, 회원가입하는 방법도 있다.

여기서는 회원가입은 완료되었다는 전제하에 진행하겠다.



일단 마우스 오른쪽 클릭 복사가 뭐냐면..
블로그 글을 선택 복사 후 메모장에 붙여넣기하면 자료가 복사가 된다는 것이다.
그리고, 이것을 출처를 밝히지 않고 자신의 창작물(?)로 활용하신다는 것....




무단으로 복사해서 출처도 밝히지 않고 스크랩하시는 분이 없었으면 좋겠다.
하지만, 그렇지 않다는 거....
그리고 햐~ 그걸 막는 방법을 또 연구해야한다는 거...







각설하고...
2가지 방법이 있다.
첫번째 플러그인 사용
단점: 플러그인 설치를 해도, 일부 브라우저에서는 플러그인 효과가 없다.
즉, 마우스 오른쪽 복사/붙여넣기가 가능하다.

그래도, 일단 플러그인을 적용해두자.

블로그 관리화면으로 이동
플러그인 버튼 클릭






마우스 오른쪽 클릭 방지 클릭






적용 클릭






두번째 방법
스크립트를 추가해서 하는 방법으로 마우스 오른쪽 복사 자체가 안된다.

스킨편집을 눌러준다.





html편집을 클릭해준다.




<head></head>안에 아래 스크립트를 추가해준다.
<!--복사방지 스크립트 시작-->
<script type="text/javascript">
var omitformtags=["input", "textarea", "select"]
omitformtags=omitformtags.join("|")
    
function disableselect(e){
    if (omitformtags.indexOf(e.target.tagName.toLowerCase())==-1)
        return false
}

function reEnable(){
    return true
}

if (typeof document.onselectstart!="undefined")
    document.onselectstart=new Function ("return false")
else{
    document.onmousedown=disableselect
    document.onmouseup=reEnable
}
</script>    
<!--복사방지 스크립트 끝-->





기존 <body>의 속성에 아래 부분을 추가해준다.
oncontextmenu="return false" onselectstart="return false" ondragstart="return false">




화면 우측 상단에 저장클릭해준다.




이제 블로그 글위에 마우스를 가져다되면, 마우스 오른쪽 버튼을 클릭할수 없게된다.


읽고 도움이되셨다면, 좋아요 부탁드립니다.







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

+ Recent posts

티스토리툴바