본문 바로가기
수업 정리

60일차 수업정리(Spring - lombok)

Vita500cc 2020. 7. 1. 17:58

**lombok 라이브러리

    => DTO 클래스를 편리하게 만들도록 해주는 라이브러리

    => DTO 클래스를 만들때 인스턴스 변수만 선언하고 나머지는 어노테이션을 이용해서 작성하게 해주는 라이브러리

    => 최근에 등장한 언어들은 변수를 선언하면 getter와 setter를 자동으로 생성해주기도 함

    => Java에서는 DTO를 생성하고 유효성 검사를 수행하는 부분까지 어노테이션으로 설정할 수 있는 라이브러리 등장

1. lombok 설치

    => IDE가 미리 설치되어 있어야 함

  1) https://projectlombok.org/download 에서 다운로드

 

Download

 

projectlombok.org

  2) 다운로드 파일 실행 -> 터미널에서 수행

    => java -jar 다운로드 받은 파일 경로

  3) IDE 선택창이 보이는 데 여기서 설치할 IDE를 선택하고 Install/Update 버튼 클릭

  4) IDE를 시작

 

2. lombok 사용

    => lombok의 의존성을 설정하여 사용

 

**Java에서 데이터베이스 사용

1. JDK에서 제공하는 API만을 이용하여 사용

 

2. API를 편리하게 사용하도록 해주는 프레임워크나 라이브러리를 이용

    => Spring JDBC : Spring이 제공하는 JDBC 클래스 이용(교재, 인터넷 샘플에서 주로 이용)

    => MyBatis : SQL Mapper Framework, Spring과의 조합으로 공공기관, 금융, 대기업등 대규모 SI에서 사용

    => JPA(Hibernate) : Object Relation Mapper Framework, 최근에 많이 사용하는 관계형 DB 연동 프레임워크

        - 다른 언어에서도 대부분 이 방식을 지원

        - Apple의 Core Data가 SQLite를 ORM 형식으로 이용

 

**프레임워크를 이용하여 데이터베이스를 연동하는 이유

    => 데이터베이스 연결이나 해제같은 중복작업을 템플릿으로 제공하여 코드를 간결하게 만들수 있음

    => 가독성이 높은 예외 클래스 제공

        - 자바 : sql문제발생시 SQL Exception 발생

        - Spring : SQL Exception을 여러개의 예외 클래스로 분리하여 예외 발생

    => SQL Mapper Framwork의 경우는 SQL과 프로그래밍언어의 코드를 분리시켜 유지보수를 편리하게 함

    => ORM의 경우는 SQL없이 데이터 베이스 연동도 가능

    => 트랜젝션 처리도 쉽게 해줌

    => 파라미터 매핑이나 결과 매핑을 자동으로 해줌

 

**Spring에서의 데이터베이스 연결

1. Simple Spring Maven 프로젝트 생성

    => MAC에서는 Simple Spring Maven 프로젝트 생성

    => 디렉토리 구조가 안만들어지는 경우 아래 작업을 순서대로 실행

  1) Java Project를 생성

 

  2) Maven Project로 변환 : 마우스 오른쪽을 클릭해서 [Configure] - [Convert to  Maven Project]를 실행

 

  3) 아래 코드를 pom.xml 파일의 </build> 태그 아래에 추가

<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-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 -->
	<junit.version>4.11</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 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>${spring-framework.version}</version>
		<scope>test</scope>
	</dependency>
    
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>${junit.version}</version>
		<scope>test</scope>
	</dependency>
</dependencies>

 

**JUnit을 이용하여 JDBC 코드로 데이터베이스 연결을 확인

1. 사용할 데이터베이스의 의존성을 pom.xml에 설정

    => Oracle : repository와 dependency를 모두 설정

  1) repository 설정

    => dependencies 태그 외부에 작성

<repositories>
	<repository>
		<id>oracle</id>
		<name>ORACLE JDBC Repository</name>
		<url>http://maven.jahia.org/maven2</url>
	</repository>
</repositories>

  2) dependencies 설정

<dependency>
	<groupId>com.oracle</groupId>
	<artifactId>ojdbc7</artifactId>
	<version>12.1.0.2</version>
</dependency>

 

2. Test를 위한 클래스를 만들어서 코드를 작성

    => src/test/java 디렉토리에 생성

        - 위의 클래스가 없으면 src 디렉토리에 생성

        - 클래스명은 아무 이름이나 상관없지만 Test는 안됨

import java.sql.Connection;
import java.sql.DriverManager;

import org.junit.Test;

public class DBTest {
	@Test
	public void dbConnect() {
		try {
			//드라이버 클래스를 로드(1회만)
			Class.forName("oracle.jdbc.driver.OracleDriver");
			//데이터 베이스 연결
			Connection con = DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.200:1521:xe", "user08", "user08");
			
			//데이터 베이스 사용
			System.out.println(con);
			
			//연결 해제
			con.close();
		}catch (Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
	
}

 

3. 실행

    => 메소드 위에 커서를 두고 마우스 오른쪽을 클릭한 후 [Run As] - [JUnit Test]를 실행

 

4. 데이터베이스 접속 정보

  1) 데이터베이스 종류를 의미하는 드라이버 클래스 이름

  2) 데이터베이스 접속 URL

  3) 게정

  4) 비밀번호

    => 계정과 비밀번호는 생략되기도 함

 

**DTO & DAO 패턴

1. DTO 패턴

    => 데이터베이스 연동을 하다보면 여러개의 컬럼을 하나로 묶어야 하는 경우가 많은데 이때 각각의 변수를 사용해도

        되지만 이렇게 하면 하나의 행을 나타내기 위해서 너무 많은 변수를 만들어야 함

    => 여러개의 컬럼(열)을 하나로 표현하기 위한 방법

        - java.util.Map을 이용

        - 개발자가 이러한 컬럼들을 표현할 수 있는 사용자 정의

        - 자료형(Class)을 만들어서 사용가능

    => 이러한 사용자 정의 자료형을 만들어서 사용하는 것을 DTO 패턴이라고 함

    => DTO 패턴 적용 법

        - 각 컬럼의 데이터를 저장할 인스턴스 변수를 private로 선언

        - 각 변수를 접근 할 수 있는 getter와 setter 메소드를 생성

        - 디버깅을 위해서 toString 메소드를 재정의

        - 개발자들마다 위의 기본 옵션에 생성자, compareTo, equals, clone, hashCode메소드를 추가하기도 함

        - Serializable 인터페이스를 implements하기도 함

 

2. DAO(Data Access Object) 패턴

    => 저장소에 관련된 코드를 별도의 클래스에 작성하는 패턴

    => Spring에서는 IoC와 DI를 이용해서 사용하는 것을 권장

 

**DataSource

    =>Spring에서는 데이터베이스 연동시 DataSource 사용을 강제

    => 데이터베이스 접속 정보를 java코드의 문자열 상수로 만들어서 사용하는 것은 바람직하지 않음

        - 데이터베이스 접속정보는 개발환경에서 실행 또는 운영환경으로 옮겨갈때 변경될 가능성이 높은 코드

        - 데이터베이스 자체의 이전으로 인해 변경될 수 있음

        - 자바코드 변경시 컴파일부터 다시 해야 함

            -> 데이터베이스 접속 정보를 별도의 파일이나 DB에 작성해두고 사용하는 방법을 권장

                - 수정이 되면 build만 다시하거나 재실행만 시키면 됨

    => DB 사용시마다 연결, 해제하는 것은 자원의 낭비이므로 DB연결을 미리 만들어두고 빌려쓰는형태로 사용

        - Connection Pool이라고 함

 

**Spring에서 DataSource를 이용하는 방법

1. spring-jdbc 라는 라이브러리를 추가

 

2. spring bean configuration 파일에 DataSource 빈을 생성

<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
	<property name="driverClassName" value="드라이버 클래스이름"/>
	<property name="url" value="데이터베이스 접속 URL"/>
	<property name="username" value="계정이름"/>
	<property name="password" value="비밀번호"/>
</bean>

 

3. 스프링 코드에서 DataSource 주입받아서 사용

    => 연결은 DataSource.getConnection();

 

**DataSource를 이용하여 오라클에 연결

1. pom.xml 파일에 spring-jdbc 의존성을 설정

<!-- 오라클 의존성 -->
<dependency>
	<groupId>com.oracle</groupId>
	<artifactId>ojdbc7</artifactId>
	<version>12.1.0.2</version>
</dependency>
		
<!-- Spring에서 데이터베이스를 사용할 때 추가해야 하는 의존성 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>${spring-framework.version}</version>
</dependency>

 

2. src/main/resources 또는 src 디렉토리에 SpringBeanConfigurateion

<!-- 오라클 연동을 위한 dataSource -->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" 
id="dataSource">
	<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
	<property name="url" value="jdbc:oracle:thin:@192.168.0.200:1521:xe"/>
	<property name="username" value="user08"/>
	<property name="password" value="user08" />
</bean>

 

3. main 메소드를 소유한 클래스를 만들고 실행

public static void main(String[] args) {
	try {
		//spring 설정파일 실행
		GenericXmlApplicationContext context = new GenericXmlApplicationContext(
				"applicationContext.xml");
		//DataSource 가져오기
		DataSource ds = context.getBean(DataSource.class);
		
		//connection 만들기
		Connection con = ds.getConnection();
		System.out.println(con);
		
	}catch (Exception e) {
		System.out.println(e.getMessage());
		e.printStackTrace();
	}
}

 

**DataSource를 이용하여 MySQL에 연결

1. MySQL의존성을 pom.xml에 설정

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<!-- MySQL 의존성 -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.49</version>
</dependency>

 

2. applicationContext.xml 파일에서 DataSource 수정

<!-- MySQL 사용을 위한 설정 -->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
	<property name="url" value="jdbc:mysql://localhost:3306/myproject?useUnicode=true&amp;characterEncoding=utf8"/>
	<property name="username" value="root"/>
	<property name="password" value="900826" />
</bean>

 

3.재실행

    => 데이터베이스 접속정보가 변경되더라도 java 코드를 수정할 필요가 없음

 

**MyBatis

    => Java에서 가장 유명한 데이터베이스 연동 프레임워크는 MyBatis와 Hibernate

    => MyBatis의 이전 이름은 iBatis

1. 특징

    => SQL Mapper Framework : SQL과 프로그래밍 언어의 코드를 분리

    => PreparedStatement의 파라미터 매핑과 executeQuery에서 리턴하는 ResultSet과 결과자료형의 매핑을 자동 수행

    => Spring과 같이 사용 가능

    => 다른 데이터베이스 연동 프레임워크보다 쉬워서 SI 프로젝트에 많이 이용

    => 사용방식 : xml을 이용하는 방식, 인터페이스를 이용하는 방식

        - 이전에는 xml 이용 방식을 주로 사용, 최근에는 인터페이스를 이용하는 방식을 많이 사용

    => 다른 언어에서도 사용이 가능

    => 전자정부 프레임워크의 샘플 프로젝트의 데이터베이스 연동 방식

 

2. Spring 프로젝트에서 MyBatis를 사용하기 위한 의존성

    => 연동하고자 하는 데이터베이스 의존성

    => spring-jdbc

    => mybatis

    => spring-mybatis

 

3. XML을 이용하는 방식의 Bean 설정

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="DataSource의 ID"/>
    <property name="configLocation" ref="환경설정 파일의 경로"/>
    <property name="mapperLocations" ref="매퍼파일의 위치"/>
</bean>
<!-- 환경설정 파일은 사용하지 않으면 property 생략 가능 -->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
	<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

 

4. SqlSession 타입을 주입받아서 사용

 

5. 환경 설정 파일

    => DTO 클래스의 경우 패키지명 기재시 코드가 너무 길어져에 DTO 클래스들의 패키지를 설정하여 패키지를 생략하고 사용할 수 있도록 설정

 

6. 매퍼 파일

<mapper namespace="매퍼네임스페이스">
	<select id="식별자" resultType="select 구문의 결과 하나의 행을 저장할 자료형"
    parameterType="SQL 작성시 파라미터로 설정한 데이터를 대입할 자료형">
    	select 구문
        
    <!-- 전에는 파라미터 작성시 ?지만 여기서는 #{이름} -->
    </select>
    <insert id="식별자" parameterType="파라미터 자료형">
    	insert 구문
    </insert>
</mapper>

    => resultType, parameterType은 1개만 설정가능, 다수의 데이터로 구성되면 DTO 클래스나 MAP으로 묶어서 전송

        - 아무런 설정도 하지 않으면 DTO 클래스의 경우는 프로퍼티명으로 매핑괴고 Map의 경우는 Key로 매핑

 

7. 자바에서 사용방법

  1) select : SqlSession.selectOne 또는 selectList를 호출

    => 첫번째 매개변수는 호출할 SQL의 ID를 문자열로 설정 - 필수

    => 두번째 매개변수는 Parameter인데 Parameter가 없으면 생략 가능

    => 리턴타입은 selectOne은 resultType으로 리턴되고, selectList는 resultType의 List로 리턴됨

        - selectOne은 검색된 데이터가 없으면 null 리턴, 2개 이상 검색되면 예외 발생

        - selectList는 검색된 데이터가 없으면 size가 0

  2) select 이외 구문 : insert, update, delete 메소드를 호출 - 아무거나 호출해도 됨
    => 매개변수는 select와 동일

    => 리턴타입은 정수(영향받은 행의 수)

 

8. 자료형 매핑

  1) number(int, float) : Integer, Double, BigDecimal(오라클의 숫자자료형은 Map으로 받는 경우)

  2) char, varchar2(varchar), clob(text) : String

  3) date - java.sql.Date(날짜), java.util.Date(날짜와 시간)

  4) time - java.sql.Time(시간), java.util.Date

  5) timestamp - java.sql.Timestamp

  6) blob(파일의 내용) - byte[]

    => 파일 저장시 대부분 blob에 저장하지 않고, 파일을 서버에 저장한 후, 파일의 경로를 문자열로 저장

 

9. 주의할 점

    => xml을 이용하는 경우

        - 부등호 사용을 못하므로 &lt; 또는 &gt; 로 설정

    => like 사용시 데이터베이스마다 다르게 설정

        - MySQL : like concat('% 나 _', vkfkalxj, '% 나_')

        - oracle : like '% 나 _' || 파라미터 || '% 나 _'

        - MSSQL : like '% 나 _' + 파라미터 + '% 나 _'

 

**XML을 이용한 MyBatis 연동

1. 연동할 테이블 생성

    => 오라클에서 작업

-- goods 테이블이 있으면 삭제
DROP TABLE GOODS;

CREATE TABLE goods(
	code number(10) PRIMARY KEY,
	name varchar2(60),
	regdate date
);

INSERT INTO GOODS(code, name, regdate)
values(1, '사과', sysdate);

INSERT INTO GOODS(code, name, regdate)
values(2, '배', sysdate-1);

INSERT INTO GOODS(code, name, regdate)
values(3, '고추참치', sysdate-100);

INSERT INTO GOODS(code, name, regdate)
values(4, '팥빙수', TO_DATE('2020-07-01', 'YYYY-MM-DD'));

SELECT *
FROM goods;

COMMIT;

 

2. MyBatis를 연동할 프로젝트를 생성

    => Simple Spring Maven 프로젝트 생성

    => 위의 프로젝트 생성이 안되면 Java Project를 만들어서 Maven 프로젝트로 변환하고 pom.xml수정

 

3. Oracle과 MyBatis를 사용하기 위한 의존성을 pom.xml 파일에 추가

  1) repositorys를 먼저 추가

<repositories>
	<repository>
		<id>oracle</id>
		<name>ORACLE JDBC Repository</name>
		<url>http://maven.jahia.org/maven2</url>
	</repository>
</repositories>

  2) dependency 추가

<!-- 오라클 -->
<dependency>
	<groupId>com.oracle</groupId>
	<artifactId>ojdbc7</artifactId>
	<version>12.1.0.2</version>
</dependency>

<!-- 스프링에서 데이터베이스 사용을 위한 의존성 -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>${spring-framework.version}</version>
</dependency>

<!-- MyBatis 사용을 위한 의존성 -->
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.4.6</version>
</dependency>

<!-- Spring에서 MyBatis를 사용하기 위한 의존성 -->
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis-spring</artifactId>
	<version>1.3.2</version>
</dependency>

<!-- lombok - DTO를 편리하게 만드는 의존성 -->
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.8</version>
</dependency>

 

4. DTO 클래스를 생성

    => mybatis.domain.GoodVO

package mybatis.domain;

import java.util.Date;

import lombok.Data;

@Data
public class GoodVO {
	private int code;
	private String name;
	private Date regdate;
	
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Date getRegdate() {
		return regdate;
	}
	public void setRegdate(Date regdate) {
		this.regdate = regdate;
	}
	
	@Override
	public String toString() {
		return "GoodVO [code=" + code + ", name=" + name + ", regdate=" + regdate + "]";
	}
}

 

5. MyBatis 환경설정 파일을 생성

    => 필수는 아님

    => DTO 클래스의 경로는 mybatis.domain.GoodVO 라고 입력해야 하는데 환경 설정 파일에 패키지를 등록해두면

       GoodVO라는 이름만으로 mybatis에서 사용할 수 있음

    => src/main/resources 또는 src에 추가 : mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<!-- 생략할 패키지 이름 등록 -->
	<typeAliases>
		<package name="mybatis.domain"/>
	</typeAliases>
</configuration>

 

6. SQL을 작성할 mapper 파일을 생성

    => mapper 파일은 별도의 디렉토리에 생성

    => src에 mappers라는 디렉토리를 생성하고 good.xml 파일로 생성

    => 이 파일은 테이블마다 별도로 하나씩 생성됨

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="good">
	<!-- goods 테이블의 전체 데이터를 가져오는 SQL -->
	<!-- id : 구별하기 위한 이름, 
	parameterType : where절에 대입할 파라미터 자료형
	resultType : select절의 내용을 전부 저장할 수 있는 자료형 -->
	<select id="allgood" resultType="GoodVO">
		select * from goods
	</select>
</mapper>

 

7. Spring 설정 파일에 MyBatis를 XMl을 이용해서 연동하기 위한 Bean 생성 코드를 작성

    => src/applicatinoContext.xml 파일에 작성

<!-- DataSource 빈생성 코드 -->
<!-- MySQL 사용을 위한 설정 -->
<bean
	class="org.springframework.jdbc.datasource.DriverManagerDataSource"
	id="dataSource">
	<property name="driverClassName"
		value="com.mysql.jdbc.Driver" />
	<property name="url"
		value="jdbc:mysql://localhost:3306/myproject?useUnicode=true&amp;characterEncoding=utf8" />
	<property name="username" value="root" />
	<property name="password" value="900826" />
</bean>

<!-- XML을 이용하여 MyBatis 연동을 할 때 사용하는 bean -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<!-- 앞에서 만든 DataSource의 id를 설정 -->
	<property name="dataSource" ref="dataSource" />
	<!-- 환경 설정 파일의 경로를 설정 : 생략가능 -->
	<property name="configLocation" value="mybatis-config.xml" />
	<!-- 매퍼 파일의 경로를 설정 : 필수 -->
	<property name="mapperLocations" value="mappers/good.xml" />
</bean>
<!-- 위에서 id를 변경하지 않는 한 고정 -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
	<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

 

8. DAO 클래스를 생성하고, sql을 호출하는 메소드를 생성

    => mybatis.dao.GoodDAO

package mybatis.dao;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import mybatis.domain.GoodVO;

//bean을 자동 생성할 수 있도록 해주는 어노테이션
//Component, Controller, Service, Repository
@Repository
public class GoodDAO {
	//데이터베이스 연동 프레임워크의 변수
	//동일한 자료형의 bean이 있으면 자동으로 주입해주는 어노테이션
	@Autowired
	private SqlSession sqlSession;
	
	//테이블의 전체 데이터를 가져오는 메소드
	public List<GoodVO> allgood(){
		return sqlSession.selectList("good.allgood");
	}
}

 

9. 어노테이션으로 작업한 내용을 실행할 수 있도록 설정을 추가

    => Spring MVC Project에는 이미 추가되어 있어서 할 필요 없음

    => applicationContext.xml에서 수행

  1) context 네임스페이스 추가

 

  2) 2개의 설정 태그 추가

<context:annotation-config />
<context:component-scan base-package="mybatis"></context:component-scan>

 

10. main 메소드를 소유한 Main 클래스를 만들고 작성한 후 실행

import org.springframework.context.support.GenericXmlApplicationContext;

import mybatis.dao.GoodDAO;

public class Main {

	public static void main(String[] args){
		try {
			GenericXmlApplicationContext context = 
				new GenericXmlApplicationContext(
					"applicationContext.xml");
			GoodDAO dao = context.getBean(GoodDAO.class);
			System.out.println(dao.allgood());
			context.close();
		}catch(Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}
}

 

 

 

**수업외**

**Java Application 실행파일

    => Java Application(Web Browser를 이용하여 접속 또는 URL 통신) : war

    => Android : apk

 

**실행

    => jar 파일 : java -jar 파일경로(windows에서 사용시 java 명령어가 있는 디렉토리가 path에 설정되어 있어야 함)

    => war 파일 : WAS(Web Application Container)를 이용하여 실행

    => apk 파일 : 안드로이드 기기에서 실행

 

**프레임워크나 라이브러리 구동 방식

    => 작성은 프레임워크나 라이브러리의 규칙에 맞춰, 실제 구현은 프로그래밍 언어가 제공하는 API로 변경되어 수행

    => executeUpdate(select 이외 구문) , executeQuery(select 구문)

        - mybatis에서는 insert, update, delete, selectOne, selectList

 

 **Maven project에서의 pom.xml

    => maven 설정파일

1. properties 

    => 아래 구문에서 많이 사용할 텍스트를 별도의 이름으로 만들어 둔것

    => 자주 사용하는 버젼을 직접 입력하면 버전을 잘못써서 충돌이 발생할 가능성이 있어 별도의 이름을 사용

    => java, spring, junit 등의 버전을 설정

 

2. repositories

    => maven project는 기본적으로 maven 중앙 처리 장소에서 라이브러리 다운, repository 설정시 저장소에서 다운로

       드 받고 없으면 중앙저장소에서 다운로드

    => 수업시간에는 Oracle 사용시에만 설정

 

3. dependencies

    => 사용할 외부 라이브러리의 의존성을 설정

    => 다운로드 받아서 build path에 추가

 

**Java에서 가장 중요한 버젼 변화

    - 1.5 -> 1.6 : 제너릭 사용이 가능

    - 1.7 -> 1.8 : try~resoure, 람다, 스트림 API를 제공 

 

**데이터베이스 URL

1.Oracle

    -  jdbc:oracle:thin:서버URL:포트번호:SID

    - jdbc:oracle:thin:@서버URL:포트번호/ServiceName

    - 학원 : jdbc:oracle:thin:@192.168.0.200:xe

 

2. MySQL

    - jdbc:mysql://서버URL:포트번호?데이터이름?

    - useUnicode=true&characterEncodeing=utf8

 

    - 내 MySQL :  jdbc:mysql://loccalhost:3306/이름?

    - useUnicode=true&characterEncodeing=utf8

 

    - 내 MySQL :  jdbc:mysql://192.168.0.200:3306/이름?

    - useUnicode=true&characterEncodeing=utf8

      -> 계정 : root, 비번 ; *******

 

**라이브러리 다운로드가 안되서 pom.xml 파일에 에러가 나는 경우

    => \\192.168.0.200접속, hybrid/spring/repository 디렉토리 내용복사, 자기 계정/m2/repository 디렉토리에 넣기

        - .이 붙는 디렉토리는 Mac, Linux에서는 숨김 디렉토리

        - Mac에서는 shift + command + . 을 눌러야 보임

 

**pom.xml 파일에 라이브러리 이름을 제대로 작성했는데 사용할 수없는 경우

1. repository 디렉토리를 전부 삭제하고 프로젝트를 선택하고 마우스 오른쪽 [Maven] - [Update Project]를 실행

    => 라이브러리를 다시 다운로드 받음

    => 현재 STS에서는 이 잓업을 수행하면 java build path를 1.5로 변경하기 때문에 build path를 수정해야 함

 

2. 라이브러리를 제대로 다운로드 받은 곳에서 repository를 복사

 

**XML

    => 데이터를 표현하기 위한 형식

    => xml에는 2가지 종류가 있음

1. 설정 파일로 설정되는 것으로 해석을 개발자가 하지 않는 파일

    => 최상단에 xml 형식, 그 아래에 DOCTYPE이 있음 이 부분을 DTD라고 하는데 xml 파일을 해석하는 위치를 설정

 

2. 데이터 파일로 해석을 개발자가 하는 파일

 

 

저작자표시

'수업 정리' 카테고리의 다른 글

62일차 수업 정리(Spring - Transaction, Hibernate, MyBatis)  (0) 2020.07.03
61일차 수업정리(Spring - MyBatis)  (0) 2020.07.02
59일차 수업 정리(Spring)  (0) 2020.06.30
58일차 수업정리(로그인 처리, Script 언어, 요청처리 디버깅)  (0) 2020.06.29
57일차 수업정리(회원 가입 관련 Tip)  (0) 2020.06.26

'수업 정리' Related Articles

티스토리툴바