class A ->B
class Main ->A
class B
main메소드 있는 것을 찾아서 실행 ->Run
class들의 순서를 묶어서 하는 것이다. python에서는 __main__.py이다.
Main -> A -> B
실행했을 경우 B->A->MAIN
build는 실행가능한 파일을 만든다.
vs visual c가 재일 강력하다. 53기가이다.
visual statio 안에서 linux도 가능하다.
c언어는 외부 라이브러리를 사용하고 싶으면 직접 검색해서 다운로드 -> 파일을 include 해서 사용->
a.c-> b.c를 사용
b.c ->a.c를 사용
a.c (#include b.c)
b.c (#include a.c)
=>c언어에서는 오류가 난다.그래서 head를 잘 해야 한다.
검색->cran->다운로드 ->import 메모리에 가져오는 개념
c언어는 두번 include하면 에러 가 난다.
int a = 10;
int a = 20;
import는 메모리에서 가져온다.
import는 같은 것 있으면 덮어 씌운다.
str = 10 ;//python에서는 안된다. 기존의 str이 없어지는 개념이다.
사용가능한 라이브러리 ->repository ->개발자
->개발자
버전 문제가 해결된다.
dependiencies ->필요한 라이브러리 가져오기
**Maven
=>java build tool
1. build
=> 컴파일(소스 코드를 운영체제나 Virtual Machine 이 이해할 수 있는 코드로 변환) 된 코드들을 가지고 실행 가능한 프로그램을 만들어내는 작업
코드들의 순서라던가 포함 관계를 파악해서 실행을 하게 되면 메모리에 순서대로 적재(로드)해서 실행해도록 해주는 것입니다.
2.java build tool의 종류
1) ant: build만해주는 tool
=>최근에는 거의 사용되지 않고 문법만 다른 툴에서 사용할 수 있도록 해주고 있습니다.
2)Maven: build tool이면서 외부 라이브러리 관리를 관리하게 해주는 tool
=>이전에 만들어진 java application들은 겅의 이 방식입니다.
3)gradle: build tool이면서 외부 라이브러리 관리를 관리하게 해주는 tool
=>andriod가 채택한 방식
=>build.gradle 이라는 설정 파일에 json방식으로 설정
3.maven
=>pom.xml파일을 이용해서 프로젝트를 관리
=>pom.xml파일에 설정을 하면 build를 할 때 그 설정에 따라 작업들을 자동으로 수행해주는 tool
4.maven설치
=>eclipse 계열의 IDE를 사용하면 내장되어 있습니다.
5.MAVEN프로젝트 생성
1)MAVEN프로젝트로 처음부터 생성
=>eclipse에서 maven프로젝트를 만들거나 spring프로젝트를 만든 경우
6.pom.xml 파일의 설정 태그
1)repositories
=>라이브러리를 다운로드 받을 저장소를 설정
=>설정하지 않으면 maven중앙 저장소에서 다운로드
=>오라클의 경우 오픈 소스가 아니라서 중앙 저장소에 없기 떄문에 repositories를 설정해야 만 다운로드 가능
=>공공기관이나 대기업의 경우는 별도의 저장소를 가지는 경우가 많아서 그 저장소를 설정합니다.
2)dependencies
=>실제 다운로드ㅡ 받을 외부 라이브러리를 설정
7. 라비으러리 사용 과정
1) pom.xml파일의 dependencies 태그에 라이브러리를 설정
2)project가 build될 때 자신의 계정의 .p2디렉토리에서 라비브러리를 찾아서 사용
3)없으면 저장소에 다운로드 받아서 .p2에 저장하고 사용
8.인터넷이 느리거나 동시에 여러 컴퓨터가 접속해서 다운로드 받는 경우 제대로 다운로드가 안되는 경우가 있습니다.
이런 경우에는 다른 컴퓨터에서 reposirotyf를 복사해서 붙여넣기 한 후 사용해도 됩니다.
9.MySQL 라이브러리 클래스 로드 - 실습
1) java application프로젝트를 생성
java -> java project만들기
Main.java 만들기
2)Main클래스를 만들어서 실행
public class Main {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");
System.out.println("Mysql 드라이버 로드 성공");
}catch (Exception e) {
System.out.println("MySQL 드라이버 다운로드 실패");
}
}
}
3)실행을 하면 드라이버 파일이 없어서 예외가 발생
4) 이전의 방식으로 이 문제를 해결하고자 하는 경우
-java application: Mysql드라이버 다운로드 받고 프로젝트에 복사하고 파일을 선택한 후 builid path 에 추가를 해우저야 합니다.
-java web applicationL Mysql드라이버 다운로드 받고ㅗ 프로젝트의 webcontent/web-inf/lib디렉토리를 복사해서
5)maven프로젝트의 경우 -pom.xml 파일에 mysql의존성만 설정하면 됨. (프로젝트 종류와 상관없음)
=>프로젝트를 maven프로젝트로 변환
=> 프로젝트를 선텍히거 마우스 오른쪽을 클릭한 후
tensorflow -> numpy
->scikit-learn
a.c -> b
b 를 설치하고 해야 한다
프로젝트를 선택하고 마우스 오른쪽을 클릭한 후 [COnfigure]- [convert to Maven Project]
=>생성된 pom.xml파일에 의존성을 설정하는 코드를 추가
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>java</groupId>
<artifactId>java</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
</dependencies>
</project>
6) 실행
=>프로젝트 안에 Maven Dependencies라는 디렉토리가 1개 만들어지고 mysql드라이버를 다운로드 하고 build pah에 추가를 해줍니다.
=>드라이브가 설치되어 예외가 발생하지 않습니다.
** STS(Spring Tool Suite)설치
=>Spring 학습을 할 때는 이 Tool을 많이 사용하고 우리나라에서는 공공기관(전자정부 프레임워크)이나 대기업 프로젝트(삼성 -Any Framework등)를 할 때는 대부분 전용 프레임워크를 사용하는데 사용법이 sts랑 유사
1.sprint.io사이트에서 다운로드
2.eclipse plug-in으로 설치
=>[help] -[Eclipse Market Place]에서 sts를 검색
=>3.xx버전을 install
최근에는 4.xx 버전이 출시되었느느데 아직 현업에서는 3.xx버전을 이용
cloud 환경을 spring으로 많이 만든다.
빅데이터 저장 처리는 spring 으로 많이 한다.
Hadoop -> java이다. 처리 쪽은 자바만 가지고 애매하다 함수형이 안되서 그래서 java로 확정된 scala, clousure, kotlin
스프링
복잡하다. ->디자인 패턴
자바의 버전 3개
java me : micro 용어가 좀 다르다. embedded할 경우 사용한다. 요부분은 iot라고 한다.
Iot(embedded) =>embedded는 피씨에서 작업을 안한다.
3개 인데 만드는 회사가 다르다. ->작제 만드는 것이다.
아트메가 128
아두이노 : 이탈리아
라즈베리파이 : 영국 linux를 깐다 .기능이 좀 더 많다.
java se : standard : java application
스마트폰은 컴퓨터로 한다.
스마트폰 applicatoin이나 피씨 application
java ee : enterprise web server applicatoin -> oracle이 eclipse에게 ee를 줬다.
instance가 잘못 만들어지면 여러가 만들 수 있고 메모리 낭비가 심하다.
특히 서버에서의 문제
제어의 역전 spring 에서는 class제공하는 것 만들고
스프링에서는 개발하고 적기만 하면 알아서 해준다.
로그인 확인 -> 로기은 페이지
è 로그인 되여있으면 글 쓰기
상품
freamwork ->class제공 -------- > ClassEX ->인스턴스 사용
MS <-> JAVA
바꾸는 것인 문제이다.
머신러닝->알고리즘 구현 -> SCIKIT -LEARN ->TENSORFLOW->PYTORCH
tensorflow가 1.0, 2.0으로 바뀐다. 그래서 계속 공부하면서 적용해야 한다.
spring-> 큰 프로젝트를 할 경우 좀 더 쉽고 빨리 개발 하는 것이다.
스프링 프로젝트 종류
Spring Boot(Spring Starter Project): 간단하게 실행하고 배포가 가능한 수준의 애플리케이션을 만들 때 사용하는데 WAS 설정없이 실행이 가능하기 때문에 테스트 하기에 편리하지만 기존의 웹 프로젝트 설정과 다른 방법으로 사용해야 하고 JSP 설정은 별도로 수행
=>jsp도 출력하는 방식이 다르다. 최근에는 이것이 많이 나온다.
Spring Template Project(Spring Legacy Project): WAS를 사용하거나 이전에 Spring Project를 만들어 본 경우 사용하는 방식인데 WAS로 인한 리소스 소모가 심하다는 단점이 있지만 기존 프로젝트들이 이 방식으로 많이 만들어져 있음
=> 그전에 한 것
spring 5 버전까지 나왔다. 하지만
4 버전 부터 cloud등이 나왔다. api서버도
java 1.8로 바꾸는 것이좋다.
java 1.8 부터 :
1) try ~ resource
try(){
}
()안에 사용하면 close안해도 된다. 자동으로 메모리 close가 된다. 1,7에서 추가했다.
2) 람다와 스트림 api함수를 프레임워크
1.8 ->big data때문에 하면
함수 단위로 뭔가 하면 1.8이부터
**IoC(제어의 역전)
=> 클래스는 개발자가 만들고 클래스의 인스턴스는 프레임워크가 was가 만들어서 일반적인 프로그래밍의 흐름의 반대로 수행되는 것
상속의 단점 이 <-> 프레임워크 사용의 단점
알고리즘 공부 여부
simple java 선택
1.Factory Method Pattern 실습
1) Java Project를 생성
1) Temp 클래스 생성
public class Temp {
private int num;
private String name;
public Temp(int num, String name) {
super();
this.num = num;
this.name = name;
}
public Temp() {
super();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Temp [num=" + num + ", name=" + name + "]";
}
}
2) main 클래스를 소유한 main클래스를 만들고 Temp클래스를 사용
public class Main {
public static void main(String[] args) {
Temp temp = new Temp();
temp.setNum(1);
temp.setName("Park");
System.out.println(temp);
}
}
=>사용자가 만든 클래스를 가지고 직접 생성자를 호출해서 인스턴스를 만들고 사용
2.Factory Method Pattern
=>클래스의 인스턴스를 new를 직접 호출해서 생성하지 않고 다른 클래스의 메소드를 이용해서 생성하는 방식
=>만드는 과정이 복잡하거나 디자인 패턴이나 기타 코드를 클래스에 추가하고자 하는 경우 사용
3.실습
1)Factory 클래스로 사용할 클래스를 추가
TempFacory 클래스
//temp 클래스의 Facotry 클래스
public class TempFacory {
public static Temp create() {
return new Temp();
}
}
2)main메소드 수정
public class Main {
public static void main(String[] args) {
Temp temp1 = TempFacory.create();
temp1.setNum(2);
temp1.setName("Park1");
System.out.println(temp1);
}
}
TempFacory클래스가 spring 으로 생각한다.대신해줬다. 도대체 왜 하는지?
4.Singleton패턴
=>클래스가 인스턴스를 1개만 만들 수 있도록 된 디자인 패턴
=>서버쪽 클래스들은 대부분의 경우 여러 개의 인스턴스를 만들지 않고 하나의 인스턴스가 스레드를 이용해서 클라이언트 들의 요청을 처리하도록 해야 하는 경우가 대부분이고
clinet가 똑같은 일을 한다.하지만 동시에 오지 않는다.
서버가 3개가 있는 것이 아니라 하나 있어 도 된다.
서버가 만들고 없에는 데에 걸리는 것도 고려해야 한다.
클라이언트1 이 처리하다가 클라이언트2가 오면 대기 해서 스레드를 사용하면 된다.
스레드 - 함수 단위
메소드 (함수)
변수-> 함수->클래스 -> 객체
객체를 만든 이유는 포장을 하는 이유는 안전하기 떄문이다.
객체 지향은 안정성 때문이다.
서버쪽에서 메소드를 사용할려면 스레드를 사용한다.
스레드는 동시에 하는 것이 아니라 쉬는 시간이나 끝나면 한다.
메소드는 짧아야 한다.
프로그램은 함수 단위로
여러개 인스턴스를 만들지 않게 하려면 SINGLETON을 알아야 한다.
singleton 한개만 만들어야 한다.목적이 공유이다. static
static은 하나만 만들어서 공유한다.
//temp 클래스의 Facotry 클래스
public class TempFacory {
//Temp의 Facory 메소드
//spring이 하는 역할
static Temp temp = new Temp();
public static Temp create() {
//return new Temp();
return temp;
}
}
public class Main {
public static void main(String[] args) {
/*
Temp temp = new Temp();
temp.setNum(1);
temp.setName("Park");
System.out.println(temp);
*/
//만들어서 사용해서 쓰면 된다.
//singleton인지
Temp temp = TempFacory.create();
temp.setNum(1);
temp.setName("Park");
System.out.println(temp.hashCode());
Temp temp1 = TempFacory.create();
temp1.setNum(2);
temp1.setName("Park1");
System.out.println(temp1.hashCode());
//spring에서는 우리가 만들지 않는다. 사용하기만 한다.
//만들어주는 것을 Facorty 제어의 역전이라고 한다.
}
}
** Spring java application project 생성
1. [File] -[New] - [Other] - [spring project] - [simple spring maven] - [ project] finish
2. 디렉토리가 생성되지 않은 경우
1) Maven 프로젝트 변환
프로젝트를 선택하고 마우스 오른똑을 누른 후 [configure] - [conbert to mavern project]
2) pom.xml파일에 블로그의 코드를 복사해서 붙여 넣기
project 태그 안에 작성
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>spring</groupId>
<artifactId>spring</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- 이 코드를 pom.xml 파일에 붙여 넣습니다. -->
<!-- 자주 사용하는 코드를 프로퍼티로 설정해놓은 태그
프로그램에서 변수를 만드는 것과 유사 -->
<properties>
<!-- Generic properties -->
<!-- 자바 버전 -->
<java.version>1.8</java.version>
<!-- 소스 코드와 출력되는 문자열을 인코딩 설정 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- Spring -->
<!-- spring 버전 4.0.1, 5.0.7 -->
<spring-framework.version>5.0.7.RELEASE</spring-framework.version>
<!-- Hibernate / JPA(요즘에는 ) -->
<hibernate.version>4.2.1.Final</hibernate.version>
<!-- Logging -->
<!-- 로그 라이브러리 버전 -->
<logback.version>1.0.13</logback.version>
<slf4j.version>1.7.5</slf4j.version>
<!-- Test -->
<!-- 테스트 라이브러리 버전으로 최근에는 4.12이상 사용해야 함 -->
<junit.version>4.12</junit.version>
</properties>
<!-- 의존성 라이브러리 설정 -->
<dependencies>
<!-- Spring and Transactions -->
<!-- 스프링 기본 라이브러리 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring-framework.version}</version>
</dependency>
<!-- Logging with SLF4J & LogBack -->
<!-- 로그 기록 라이브러리 설정 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>${logback.version}</version>
<scope>runtime</scope>
</dependency>
<!-- Hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<!-- Test Artifacts -->
<!-- spring test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring-framework.version}</version>
<scope>test</scope>
</dependency>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
3) 속성을 2개 갖는 클래스를 생성
=> 디렉토리가 만들어진 경우에는 src/main/java라는 디렉토리에 생성하고 그렇지 않은 경우는 root디렉토리에 생성
=>디렉토리가 없는 경우는 프로젝트를 선택하고 source folder를 추가(main/src)하고 클래스를 추가
** spring 의 Bean Container
=>spring에서는 spring이 제어권을 가지고 생성하고 관계를 설정하는 객체를 spring bean이라고 합니다.
이 Bean이 spring이 객체를 생성하고 관리하는 제어의 역전이 적용된 객체
=>Bean Container을 이용하는 방법
1. annotation을 이용하는 방법
1) 설정
=>클래스를 만들고 클래스 위에 @Configuration어노테이션을 추가
=>인스턴스를 생성해서 리턴하는 메소드 위에 @Bean이라는 어노테이션을 추가
2) 사용
AnnotaitionConfigApplicationContext 변수명 = new AnnotationConfigApplicationContext(1번에서(앞에서 )만든 클래스이름.class);
인스턴스이름 = 변수명.getBean("메소드이름", 메소드가 리턴하는 클래스이름.class);
=>이렇게 만들면 싱글톤을 적용하지 않아도 자동으로 싱글톤 패턴의 객체가 리턴됩니다.
3)실습
=>Factory 클래스의 역할을 수행할 클래스를 생성
domain.Factory클래스
//spring의 Bean을 설정해주는 클래스라는 어노테이션
@Configuration
public class Factory {
//Bean을 만들어주는 메소드 라는 어노테이션
@Bean
public static Item create() {
return new Item();
}
}
=>main메소드를 소유한 클래스를 만들어서 인스턴스를 만든 후 테스트
domain.SpringMain
public class SpringMain {
public static void main(String[] args) {
//springContainer 클래스 객체 만들기
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Factory.class);
//Bean생성 메소드를 호출해서 bEAN을 생성
//Facory클래스의 create라는 메소드를 이용해서 인스턴스를 생성하고 리턴
Item item1 = context.getBean("create",Item.class);
item1.setNum(1);
item1.setName("사과");
System.out.println(item1);
//해시코드 출력
System.out.println(item1.hashCode());
Item item2 = context.getBean("create",Item.class);
item2.setNum(2);
item2.setName("한라봉");
System.out.println(item2);
System.out.println(item2.hashCode());
}
}
어노테이션을 이용해서 사용하는 방법이다.
2.xml을 이용하는 방법 : 현재까지는 이 방법을 많이 사용
1)spring bean configuration파일을 추가
2)객체를 생성하는 테그를 설정
클래스 경로에 해당하는 객체를 생성해서 리턴 ~ 싱글톤
<bean id="아이디" class="클래스 경로" />
3)사용
GenericXmlApplicationContext 변수명 = new GenericXmlApplicationContext(xml파일 경로);
인스턴스이름 = 변수명.getBean("메소드이름/아이디", 메소드가 리턴하는 클래스이름.class);
4)실습
=>spring bean configuraion file을 추가 -applicationcontext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- domain.Item이라는 클래스의 객체를 만들어주는 태그 -->
<bean id="item" class="domain.Item"/>
</beans>
=>main 메소드수정
SpringMain.java
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:applicationcontext.xml");
//xml일 파일을 이용할 때는 id를 기재
Item item1 = context.getBean("item",Item.class);
item1.setNum(1);
item1.setName("사과");
System.out.println(item1);
//해시코드 출력
System.out.println(item1.hashCode());
Item item2 = context.getBean("item",Item.class);
item2.setNum(2);
item2.setName("한라봉");
System.out.println(item2);
System.out.println(item2.hashCode());
3.Bean태그의 속성
1) class: 생성할 인스턴스의 class - 패키지이름까지 포함시켜야 합니다.
2) id : 외부에서 인스턴슬ㄹ 가져다가 사용하기 위한 이름
=>생략하면 클래스이름 뒤에 #0을 붙입니다.
3)init-method: 인스턴스를 생성할 때 호출되는 메소드
4) destroy - method:인스턴스가 소멸될 때 호출되는 메소드
5) lazy-init(지연 생성) :true를 설정하면 처음부터 만들어지지 않고 처음 사용할 때 만들어집니다.
=>클라이언트 프로그램을 제작할 떄 사용
=>lazy-init이 false이면 프로그램이 실행될 때 전부 만들어지고 실행
서버는 전부 만들어 놓고 사용하고 client는 필요할 때 생성한다. 메모리 때문에
6)scope: web에서만 설정하는 것이므로 기본은 singleton이고 호출할 때마다 생성하는 prototype이나 request, session등의 scope 를 설정하는 것이 가능
**DI(Dependency Injection - 의존성 주입)
=>의존성: 클래스의 객체가 다른 클래스의 객체에서 사용되는 것
=>주입: 클래스 안에서 사용하는 객체를 내부에서 만들지 않고 외부에서 만드는 것을 대입 받는 것
주입을 받는 방법은 생성자에서 받는 방법이 있고 setter를 이용해서 주입받는 방법이 있습니다.
spring에서의 di는 생성자나 setter를 이용해서 직접 받는 것이 아니고 설정파일을 이용해서 주입받는 것
a(b()) =>a 메모리 영역을 만들어야 하는데 b영역 만들고 끝나면 a로 돌아와서 a 를 한다. 메소드안에서 메소드 부르면 제귀
x= b() =>b 를 끝나고 a를 한다.
a(x)
필요할 때 추가하는 것이 좋다. 코드의 가독성 때문이다.
필요할 때 하는 것이 좋고 메모리 절약
DI di1 = new DI(msg: msg) ;// andriod이나 intelliJ에서 해준다.
생성자를 이용할 때는 변수를 잘 사용해야 한다.
1. spring에서의 의존성 주입
=>생성자(contructor)를 이용한 주입
=>프로퍼티(property - setter)를 이용한 주입
2. 생성자를 이용한 주입
<bean class ="클래스 경로" id ="bean의 id">
<constructor-arg value ="값"/>
</bean>
=>consturctor의 매개변수가 여러 개 인 경우에는 index속성을 이용해서 인덱스(순서)를 설정
3. 생성자를 이용한 의존성 주입을 위한 실습
1) 프로퍼티 1개를 갖는 클래스를 생성
=>프로퍼티(property) : 변수와 접근자 메소드를 모두 가진 것
접근자 메소드 없이 변수만 존재하는 경우 멤버 변수
public class DTO {
private String name;
public DTO() {
super();
}
public DTO(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2) main /src-> src/main /resources디렉토리에 Spring bean Configration file을 생성
=>diconfig.xml
3) di패키지에 main메소드를 소유한 클래스를 만들고 앞에서 만든 bean가져다 사용하기
파일이 없으면 경로를 틀리거나 파일을 없을 경우
=>main메소드에 작성
생성자를 이용한 주입
public class DIMain {
public static void main(String[] args) {
//스프링 설정 파일의 경로 설정
GenericXmlApplicationContext context = new GenericXmlApplicationContext("classpath:diconfig.xml");
//bean찾아오기
//클래스이름 변수명 =context.getBean("id",클래스이름.class);
//주입 받는 코드가 없음
DTO dto = context.getBean("dto",DTO.class);
System.out.println(dto);//di.DTO@1b26f7b2 이상한 hash코드가 나온다.
//diconfig.xml파일에서 설정한 내용이 출력
System.out.println(dto.getName());
context.close();
}
}
4.property를 이용한 주입
<bean id ="아이디" class="클래스경로">
<property name="프로퍼티이름" value="값"/>
</bean>
=>property가 여러개 이면 property태그를 추가해서 해결
=>property태그의 name에 설정하는 것은 변수명이 아니고 setter메소드에서 set을 제외한 부분의 첫 글자만 소문자로 변경한 것입닏.
어느 언어에서든지 간에 property라고 부를 때는 변수명이 아니고 getter나 setter메소드에서 get과 set을 제외한 부분의 첫글자만 소문자로 변경한 것입니다.
1) diconfig.xml파일에 프로퍼티를 이용한 주입 코드를 작성
<bean id="dto1" class="di.DTO">
<property name="name" value="프로퍼티를 이용한 주입"></property>
</bean>
2) main메소드 추가
DTO dto1 = context.getBean("dto1",DTO.class);
System.out.println(dto1);
System.out.println(dto1.getName());
value는 값이고
reference는 참조이다.
4. 다른 bean을 주입
=>value는 직접 값을 설정하는 형식
=> 이미 만들어진 다른 bean을 주입하는 것이 가능
<constructor-arg>
<ref bean ="다른 bean의 id" />
</constuctor-arg>
<property name ="프로퍼티이름">
<ref bean="다른 bean의 id"/>
</property>
1) diconfig.xml에 추가
<bean id ="string" class="java.lang.String">
<constructor-arg value="다른 beam을 이용한 주입"></constructor-arg>
</bean>
<bean id="dto2" class="di.DTO">
<!-- NAME프로퍼티에 STRING이라는 BEAN을 대입 -->
<property name="name">
<ref bean="string"></ref>
</property>
</bean>
2) main 메소드에서 확인
6.Main Project를 만들고 이전 실행이 잘 되었는데 git hub에 업로드 한 후 제대로 실행이 안되면 프로젝틀 선택하고 마우스 오른쪽을 클릭한 후 [Maven] -[update project] 를 한 후 실행
7.c와 p네임스페이스를 이용하는 방법
1) c 네임 스페이스를 설정파일에 추가하면 생성자를 이용한 주입을 bean태그의속성으로 가능
c: 이름 = 값을 추가하는 것이 가능
2) p 네임스페이스를 추가하면 프로퍼티를 이용한 주입을 bean 태그의 속성으로 가능
p:이름 = "값"
p:이름-ref ="다른 bean의 아이디"
8.집단 자료형의 주입
=>list, set ,map, properties
1)List타입의 데이터를 주입하고자 하는 경우
<list value- type="자료형">
<value>값</value>
<value>값</value>
...
</list>
=>value - type을 생략하면 자료형을 유추합니다.
=>다른 bean의 참조를 대입할 때는 <value>대신에 <ref bean="bean의 id"/>
=>배열과 list의 차이
배열은 크기가 고정 ,중간에 데이터를 삽입하거나 삭제를 할려면 배열을 복사해두고 작업, 메모리 낭부가 없음
list는 크기 변경 가능, 여분의 메모리를 가지고 있어야 하므로 메모리 낭비가 발생
2)Map
=>key와 value를 쌍으로 저장하는 자료구조
<map>
<entry>
<key>key의 값</key>
<value>value의 값</value>
</entry>
</map>
3)properties
=>key와 value를 쌍으로 저장하는 자료구조
=>map과 다른 점은 map은 key와 value에 모든 자료형이 가능하지만 properties.는 key와 value에 java.lang.String만 됩니다.
<props>
<prop key="key의 값" >value</prop>
</pops>
4)Set
=>데이터를 중복없이 순서와 상관없이 저장
=>설정 방법은 list동일한데 태그의 이름만 set으로 설정
9.xml설정과 어노테이션 설정을 같이 사용
context네임스페이스 annotation-config태그를 xml설정 파일에 추가해주어야 합니다.
<context: annotation-config/>
클래스의 bean생성 -Ioc
.객체를 대신 만들어주는 것
<bean id="아이디" class="클래스경로" >
</bean>
bean에 다른 bean또는 값을 주입 -DI
<bean id="아이디" class="클래스경로" >
<property name ="프로퍼티이름" value ="값" />
</bean>
<bean id="아이디" class="클래스경로" >
<property name ="프로퍼티이름" >
<ref bean="다른 bean의 아이디"/>
</property>
</bean>