- 코틀린(Kotlin)은 인텔리제이(IntelliJ IDEA)라는 제품으로 유명한 젯브레인(JetBranins)에서 만든 언어로, 2011년 최초로 공개된 후 오랜 시간 개발을 거쳐 2016년 2월 1.0 정식 버전이 출시되었습니다.
코틀린은 간결한 문법과 풍부한 기능, 높은 안정성을 토대로 높은 생산성을 보장하는 것을 목표로 개발되었습니다. 또한, 자바와 호환되어 자바로 작성된 프로젝트에 코틀린 코드를 추가할 수도 있고 자바 코드를 모두 코틀린으로 대체 할 수도 있습니다. 뿐만 아니라, 코트린은 구글의 연례 개발자 행사인 구글I/O 2017에서 안드로이드의 공식 지원 언어로 채택되었습니다.
2. 코틀린의 컴파일 과정
Java 코드와 Kotlin 코드가 함께 있는 프로젝트의 빌드 과정
Kotlin 컴파일러가 Kotlin 코드를 컴파일해 .class 파일을 생성한다. 이 과정에서 Kotlin 코드가 참조하는 Java 코드가 함께 로딩되어 사용된다.
Java 컴파일러가 Java 코드를 컴파일해 .class 파일을 생성한다. 이때 이미 Kotlin이 컴파일한 .class 파일의 경로를 클래스 패스에 추가해 컴파일한다.
3. 코틀린 자바의 차이
3.1 변수 선언
- 자바 변수 선언
String value = "test"; // 변수
final String value = "test"; // 상수
//new 키워드로 클래스 선언
Test test = new Test();
- 코틀린 변수 선언
var/val 변수명: 변수타입 = 초기화
변수 타입 생략 가능 (컴파일러가 타입을 정해줄 수 있음 = 타입추론(TypeInference))
var value: String = "test" // 변수
val value: String = "test" // 상수
var value = "test"
val value = "test"
val test:Test = Test()
3.2 변수 null 여부
- 자바 변수 선언
@NotNull
String value = "test";
@Nullable
String value = "test";
- 코틀린 변수 선언
특징으로는 컴파일시 null여부를 확인한다.
var value: String = "test" // @NotNull
val value: String? = "test" // @Nullable
3.3 접근 제한자
- 자바 접근 제한자
public : 모든 접근을 허용
protected : 같은 패키지(폴더)에 있는 객체와 상속관계의 객체들만 허용
default : 같은 패키지(폴더)에 있는 객체들만 허용
private : 현재 객체 내에서만 허용
- 코틀린 접근 제한자
- 코틀린 공식 문서에 따르면 internal이 말하는'같은 모듈'은 아래 상황을 뜻합니다. 쉽게 생각해 같은 프로젝트 라고 생각하면 좋을 것 같습니다.
IntelliJ IDEA Module
Maven Project
Gradle Source Set(with the exception that the test source set can access the internal declarations of main)
a set of files compiled with one invocation of the <kotlinc> Ant task
public : JAVA와 동일
private : JAVA와 동일
protected : JAVA와 동일
internal : 같은 모듈 내에서 어디서든 접근 가능
3.4 함수 선언
- 자바 함수 선언
public int sum(int a, int b) {
return a + b
}
- 코틀린 함수 선언
fun으로 선언, 함수명(파라미터): 리턴타입
사용되는 파라미터 (a, b)는 상수인것이 특징
fun sum(a: Int, b: Int): Int {
return a + b
}
3.5 클래스 선언
- 자바 클래스 선언
public class Test {
private String name;
public Test(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
- 코틀린 클래스 선언
class Test(val name: String)
//getter, setter 자동으로 만들어줌
내부 name변수 사용할때는 test.name으로 사용할 수 있음
val test:Test = Test("mylee")
// mylee
println(test.name)
test.name = "testName"
// testName
println(test.name)
4. 코틀린의 장 단점
4.1 널 안정성 (null safety)
만약 아래와 같은 함수를 가진 자바 라이브러리를 코틀린에서 사용한다고 할 때 코틀린에서 리턴타입 String을 String?(nullable)로 인식한다.
String getStr() {
....
return str;
}
따라서 아래와 같은 코드는 컴파일 시점에서 에러가 발생한다.
NotNull 변수에 nullable을 리턴하는 함수를 사용했기 때문이다. 이렇게 컴파일 시점에서 Null 에러를 잡아낼 수 있다.
(nullable을 리턴하는 코틀린 함수여도 마찬가지)
var test: String = getStr()
만약 아래와 같이 !! 연산자를 이용하면 컴파일 오류를 피할 수 있다. (!! 연산자는 Null이 아님을 보장할 수 있음) 하지만 Null값이 들어오면 에러 발생
var test: String = getStr()!!
safety call (안전한 호출)
자바에서 다음과 같이 String을 대문자로 변환할 때 만약 변수가 null이라면 에러가 발생한다.
String str; 가 있다고 가정
// str값이 null일 경우 에러 발생
System.out.println(str.toUpperCase());
따라서 if문이나, 삼항연사자 같은 방법으로 에러를 피함
코틀린에서는 이런 Null에러를 피하기위해 Safety call을 제공한다.
?. 연산자를 사용하면 null일경우 다음 함수를 호출하지 않는다.
println(str?.toUpperCase())
?: (엘비스 연산자)
삼항연산자와 비슷한 구조인데 b?.length가 null일경우 오른쪽 -1을 리턴하게 된다.
println(b?.length ?: -1)
4.2 코드가 간결해짐
- 클래스, 함수형 프로그래밍 등 코드가 간결해 질 수 있음. 예제로 filter같은 예시를 들어놓은 블로그가 있는데 자바에서 Stream사용하는거랑 큰 차이가 있는지는 잘 모르겠음.
/WEB-INF/spring/appServlet 경로에 security-context.xml을 작성한다. 먼저 name은 text, password는 test1234로 ROLE_USER를 만들고 /secured의 경로로 접근할경우 ROLE_USER인 사람만 접근할 수 있게 설정한다
다음과 같은 spring MVC 아키텍처에서 우리는 controller와 view부분만 만들면 되며 나머지 부분은 스프링에서 제공한다. 사용자의 request가 들어올 경우 dispatcher servlet가 요청을 가로채고 handler Mapping에 전달한 후 컨트롤러로 요청이 전달하고 우리가 만든 컨트롤러에 의해 view 네임을 선택하면 view Resolver에 의해 view네임을 가진 jsp를 선택하게 된다.
2. 스프링 MVC 실습하기
사전준비
다음과 같이 pom.xml에 필요한 라이브러리를 추가한다. 게터, 세터를 용이하게 만들어주는 lombok mysql과 연동하기 위한 dbcp, mysql-connector, spring-jdbc를 추가한다. 다음과 같은 deoendency를 추가한다
다음과 같이 Spring Legacy Project의 Spring MVC Project를 클릭하고 helloSpringMVC라는 프로젝트를 생성한다
#2) home.jsp 수정
다음과 같이 기본으로 있는 home.jsp를 수정한다. 클릭할 시 createoffer로, offers로 요청을 보내는 a태그가 2개 있다. 이때 ${pageContext.request.contextPath}는 서버에서 설정된 contextPath를 의미한다.
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
<html>
<head>
<title>Home</title>
</head>
<body>
<p> <a href="${pageContext.request.contextPath}/offers">show current offers</a>
<p> <a href="${pageContext.request.contextPath}/createoffer">Add a new offer</a>
</body>
</html>
#3) OffersController 생성하기
다음과 같은 OffersController를 생성한다.
package kr.ac.hansung.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import kr.ac.hansung.model.Offer;
import kr.ac.hansung.service.OffersService;
@Controller
public class OffersController {
@RequestMapping("/offers")
public String showOffers(Model model) {
return "offers";
}
@RequestMapping("/createoffer")
public String createOffer(Model model) {
return "createoffer";
}
}
#4) offers.jsp createoffers.jsp생성하기
jsp코드는 이후에 수정될 예정이니 controlle가 jsp로 제대로 요청을 전달하는지 확인만 할 목적으로 기본 jsp2개를 생성한다
#5) 실행하기
다음과 같이 제대로 매핑이 된 것을 확인할 수 있다.
#6) dao, model, service 생성하기
다음 그림과 같은 구조를 생성하기 위해 dao, model, service를 생성한다. 사용자의 요청이 들어오면 Dispatcher Servlet에서 이를 컨트롤러에 전달해주고 컨트롤러는 이에 맞는 서비스에게 전달하고 서비스는 DAO에게 DAO는 DB에 접근하고 모델을 통해 View로 사용자에게 response 하는 구조이다
OfferDAO
처음 프로젝트 생성할 때 패키 지명을 kr.ac.hansung으로 지정했기 때문에 DAO의 패키지명을 kr.ac.hansung.dao로 패키지를 만들고 내부에 다음과 같은 OfferDAO라는 클래스를 생성한다. @Repository 에노테이션을 통해 DAO클래스임을 명시하고 @Autowired를 통해 DB에 접근할 jdbctemplet을 의존성 주입시킨다.
package kr.ac.hansung.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import kr.ac.hansung.model.Offer;
@Repository
public class OfferDAO {
private JdbcTemplate jdbcTemplateObject;
@Autowired
public void setDataSource(DataSource dataSource) {
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public int getRowCount() {
String sqlStatement = "select count(*) from offers";
return jdbcTemplateObject.queryForObject(sqlStatement, Integer.class);
}
public Offer getOffer(String name) {
String sqlStatement = "select * from offers where name=?";
return jdbcTemplateObject.queryForObject(sqlStatement, new Object[]{name}, new RowMapper<Offer>() {
@Override
public Offer mapRow(ResultSet rs, int rowNum) throws SQLException {
Offer offer = new Offer();
offer.setId(rs.getInt("id"));
offer.setName(rs.getString("name"));
offer.setEmail(rs.getString("email"));
offer.setText(rs.getString("text"));
return offer;
}
});
}
public List<Offer> getOffers() {
String sqlStatement = "select * from offers";
return jdbcTemplateObject.query(sqlStatement, new RowMapper<Offer>() {
@Override
public Offer mapRow(ResultSet rs, int rowNum) throws SQLException {
Offer offer = new Offer();
offer.setId(rs.getInt("id"));
offer.setName(rs.getString("name"));
offer.setEmail(rs.getString("email"));
offer.setText(rs.getString("text"));
return offer;
}
});
}
public boolean insert(Offer offer) {
String sqlStatement = "insert into offers (name, email, text) values (?,?,?)";
String name = offer.getName();
String email = offer.getEmail();
String text = offer.getText();
return (jdbcTemplateObject.update(sqlStatement, new Object[]{name, email, text}) == 1);
}
public boolean update(Offer offer) {
String sqlStatement = "update offers set name=?, email=?, text=? where id=?";
String name = offer.getName();
String email = offer.getEmail();
String text = offer.getText();
int id = offer.getId();
return (jdbcTemplateObject.update(sqlStatement, new Object[]{name, email, text, id}) == 1);
}
}
Offer
kr.ac.hansung.model 패키지를 생성하고 다음과 같은 Offer클래스를 생성한다. lombok의 게터 세터 에노테이션을 통하여 게터 세터를 만든다
package kr.ac.hansung.model;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Offer {
private int id;
private String name;
private String email;
private String text;
public Offer() {
}
public Offer(String name, String email, String text) {
this.name = name;
this.email = email;
this.text = text;
}
public Offer(int id, String name, String email, String text) {
this.id = id;
this.name = name;
this.email = email;
this.text = text;
}
@Override
public String toString() {
return "Offer [id=" + id + ", name=" + name + ", email=" + email + ", text=" + text + "]";
}
}
OfferService
kr.ac.hansung.service패키지를 생성하고 다음과 같은 OfferService 클래스를 생성한다. Service에노테이션을통해 이클래스가 서비스임을 명시하고 Autowired를 통해 DAO객체를 의존성 주입시킨다.
package kr.ac.hansung.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import kr.ac.hansung.dao.OfferDAO;
import kr.ac.hansung.model.Offer;
@Service
public class OffersService {
private OfferDAO offersDao;
@Autowired
public void setOffersDao(OfferDAO offersDao) {
this.offersDao = offersDao;
}
public List<Offer> getCurrent() {
// TODO Auto-generated method stub
return offersDao.getOffers();
}
}
#7) service-context.xml dao-context.xml 생성하기
기존의 HomeController가 작동할 수 있었던 이유는 web.xml을 보면 알 수 있다. 먼저 에노테이션이 활성화되어있고 ViewResolver를 사용하여 jsp의 이름을 받을 경우 name.jsp로 변경하여 연결해주는 것을 확인할 수 있다. 또한 base-package가 정해져 있어 패키지의 에노테이션을 확인하는것을 알 수 있다. 이처럼 service와 dao의 bean을 생성하고 autowired해주기위해 service-context.xml 와 dao-context.xml을 생성한다.
먼저 src/main/webapp/WEB-INF/spring/appServlet에 다음과 같은 service-context.xml을 생성한다. kr.ac.hansung.service패키지를 스캔하도록 되어있으며 에노테이션을 사용한다고 적혀있다.
다음으로는 service-context.xml과 같은 위치인 src/main/webapp/WEB-INF/spring/appServlet에 다음과 같은 dao-context.xml을 생성한다. dao-context에는 dbcp를 활용하여 DB에 접근하게 할 dataSource Bean이 정의되어있다. 또한 placeholder로 dbcp에서 참고할 properties파일의 위치가 정의되어있다.
src/main/webapp/WEB-INF에 props라는 폴더를 생성하고 다음과 같은 jdbc.properties 파일을 생성한다. 이는 dao-context.xml에서 dbcp를 이용하여 db에 접근할 때 사용하는 파일으로서 다음과 같다.
jdbc.username = 아이디를 입력
jdbc.password = 비밀번호를 입력
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/csemall
#9) web.xml 수정하기
이렇게 dao와 service를 생성하였어도 실행할 경우 에러가 발생한다. 이는 스프링에서 dao-context.xml와 service-context.xml을 바라보고 있지 않기 때문이다. 따라서 다음과 같이 web.xml을 수정한다. 기존에는 root-context.xml만 바라보고 있었지만 생성한 service-context.xml과 dao-context.xml을 추가해줌으로써 스프링이 xml파일을 바라보게 한다.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets
and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/spring/root-context.xml
/WEB-INF/spring/appServlet/service-context.xml
/WEB-INF/spring/appServlet/dao-context.xml
</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
#10) offers.jsp수정
DB에 존재하는 정보를 받아오는 jsp를 구성하기 위해 다음과 같이 offers.jsp를 수정한다.
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Insert title here</title>
</head>
<body>
<c:forEach var="offer" items="${offers}">
<p>
<c:out value="${offer}">
</c:out>
</p>
</c:forEach>
</body>
</html>
1. 사용자는 /으로 접속하게 되면 HomeController에 의해 home.jsp로 접속하게 된다.
2. 사용자가 offers로 요청을 보내게 되면 디스패쳐 서블릿에 의해 OffersController로 요청을 전달하고, /offers로 매핑된 showOffers함수를 호출한다. showOffers는 autowired 된 offerService의 getCurrent() 함수를 호출한다.
3. offerService의 getCurrent함수는 autowried 된 offerDAO의 getOffers를 호출한다
4. offerDAO의 getOffers는 DB에 저장된 객체를 리스트로 저장하여 서비스로 반환하고 서비스는 다시 컨트롤러로 반환한다.
5. 컨트롤러에서는 모델을 이용하여 view에 있는 jsp로 결과값과 함께 반환하고, 사용자는 마지막으로 반환된 offers.jsp를 확인하게 된다.
지난 #8 강의에 이어 MYSQL과 연동하여 Update, delete, insert 하는 방법을 설명하도록 한다.
1. INSERT
먼저 지난번 query와 달리 update메소드를 사용하며 다음과 같이 사용한다 update메서드 내부에는 insert sql문, new Object로 name, email, text를? 에 넣어주는 방식으로 사용하며 이때 반환하는 값이 1이면 true를 리턴한다.
public boolean insert(Offer offer) {
String sqlStatement = "insert into offers (name, email, text) values (?,?,?)";
String name = offer.getName();
String email = offer.getEmail();
String text = offer.getText();
return (jdbcTemplateObject.update(sqlStatement, new Object[]{name, email, text}) == 1);
}
2. UPDATE
insert와 같이 update메소드를 사용하며 사용방법은 다음과 같다.
public boolean update(Offer offer) {
String sqlStatement = "update offers set name=?, email=?, text=? where id=?";
String name = offer.getName();
String email = offer.getEmail();
String text = offer.getText();
int id = offer.getId();
return (jdbcTemplateObject.update(sqlStatement, new Object[]{name, email, text, id}) == 1);
}
3. DELETE
마찬가지로 update 메소드를 사용하며 사용방법은 다음과 같다.
public boolean delete(int id) {
String sqlStatement = "delete from offers where id = ?";
return (jdbcTemplateObject.update(sqlStatement, new Object[]{id}) == 1);
}
DB에 접근하기 위해 다음 그림과 같이 DAO는 JDBC Template에 이는 JDBC Driver를 통해 Database에 접근하고 DataSource를 이용하여 DB에 실질적으로 커넥션 한다.
2. Data Source
데이터 베이스에 접근하기 위해 DataSource를 사용한다 DataSource의 종류는 다양하지만 DBCP라이브러리의 BasicDataSource를 통상 많이 사용하므로 실습에서도 이를 사용할 예정이다.
3. DAO란?
Data Access Object의 약자로서 서비스는 DB에 대해 아무것도 모르고, 실질적으로 DB에 접근하는 오브젝트를 의미한다. 쉽게 생각하여 DB의 CRUD를 실질적으로 수행하는 코드가 담긴 부분이다.
4. JDBC란?
JDBC란 DB와의 커넥션, SQL 사용, Close 커넥션 등 잡다한 일들을 해주는 프레임 워크이다. 기본 JAVA JDBC는 커넥션 등 try catch의 반복으로 반복적인 코드를 짜야하지만 Spring JDBC를 사용하면 SQL만 코드를 작성하고 나머지는 Spring 프레임워크에서 담당한다.
5. 실습하기
#1) 사전 준비
Mysql 5.7.28 설치
Mysql내부에는 csemall라는 DB, offers라는 테이블을 만들고 다음과 같은 구조로 이루어져 있다.
id(INT)
name
email
text
1
Alice
Alice@google.com
alice
2
Bob
Bob@google.com
bob
3
Jun
Jun@google.com
jun
#2) Simple Spring Maven 프로젝트 실행
다음과 같은 helloDB프로젝트를 생성한다.
#3) pom.xml 수정
다음과 같은 dependency를 추가하고 저장을 누르면 maven에 라이브러리가 추가된 것을 확인할 수 있다.
props라는 패키지를 생성하고 그 밑에 jdbc.properties라는 파일을 생성한다. 파일 내부는 다음과 같다 이는 DB의 정보를 담고 있으며, 생성할 bean에 하드 코딩하는 것보다 좋은 방법이다.
jdbc.username = root
jdbc.password = 사용자 비밀번호를 입력
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/csemall
#5) beans.xml 생성
다음과 같이 beans.xml을 생성한다 context:annotation은 DAO클래스에서 사용할 @Autowired를 활성화한다는 의미이며 context:component는 @Component 에노 테이션이 있는 어떤 패키지를 scan 할 건지 명시하는 부분이다. bean으로 생성한 dataSource는 #4에서 생성한 jdbc.properties를 사용하여 실제 DB와 커넥션을 하는 부분이다 dbcp2의 BasicDataSource클래스를 사용하고 있고 이 클래스는 DataSource인터페이스를 따르는 클래스이다. 마지막으로 context:property-placeholder는 앞서 사용할 jdbc.properties가 어떤 위치에 있는지 명시하는 부분이다.
src/main/java아래의 csemall이라는 패키지를 만들고 다음과 같은 Class를 생성한다. @Component 에노테이션은 이 클래스는 id가 offerDAO라는 bean을 하나 생성하겠다는 의미이다. 또한 JdbcTemplate를 사용하여 bean에 생성한 dataSource를 주입(@Autowired)시켜 DB와 실질적인 커넥션을 해주는 부분이 담겨있다. getRowCount() 부분은 다음과 같은 sql을 query 하고 결과는 Integer로 받는다는 의미이다.
package csemall;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
@Component("offerDAO")
public class OfferDAO {
private JdbcTemplate jdbcTemplateObject; //얘는 new를 사용해됨 이후 DataSource는 DI를 통해 주입 시킬예정
@Autowired
public void setDataSource(DataSource dataSource) { //DataSource는 인터페이스인데 우리가 앞서 bean에 선언한 datasource가 이 인터페이스를 따르고 DI한다
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public int getRowCount() {
String sqlStatement = "select count(*) from offers";
return jdbcTemplateObject.queryForObject(sqlStatement, Integer.class);
}
}
#6) Offer.java 클래스 생성
Lombok을 이용해 @Getter, @Setter를 생성하였고 DB에 저장된 id, name, email, text를 받는다. 이는 추후에 사용될 클래스이다.
만약 다음과 같이 Bean으로 만들 클래스 내부에 로깅, 트랜잭션, 실제 코드인 비즈니스 로직이 함께 있다고 생각해보자. 로깅, 트랜잭션, 비즈니스 로직 순서대로 작동하겠지만 이는 좋은 코드라고 할 수 없다. 따라서 로깅, 트랜잭션과 비즈니스 로직을 분리하기 위해 AOP가 존재한다
Bank 클래스
AOP는 다음 그림처럼 선처리, 후처리(런타임시 짜집기함)를 가능하게 지원하기 때문에 메인 Bean을 만드는 클래스를 따로 두고 로깅, 트랜잭션을 선처리 후처리로 다음과 같은 구조를 만드는 것이다.
다음 그림처럼 a.f()가 실직적인 타겟이되는 joinpoint가 되고 그림 앞에 보라색, 주황색이 선처리 후처리를 담당하는 어드바이스가 된다. 어드바이스는 joinpoint는 Pointcut이 가리키게 된다
다음 그림을 보면 조금더 이해하기 쉽다
AOP 구조 설명
2. AOP실습
#1) spring-aspect를 이용한 실습
1. pom.xml dependency추가
다음과 같은 디펜던시를 추가하면, Maven Dependencies에 spring-aspects라이브러리가 추가된 것을 확인할 수 있다.
public class Logger{
public void aboutToSound() {
System.out.println("Before: about to sound");
}
}
3. animal.xml Namespaces 수정 및 aop추가
다음과 같이 Namespaces에 aop를 추가한다
aop 추가
aop추가를 완료하였다면 다음과 같은 코드를 추가한다 <aop:aspect ref="Logger">를 통해 Logger클래스를 Aspect로 이용하겠다는 의미이며, <aop:pointcut expression="execution(void kr.ac.hansung.helloDI.*.sound())" id="selectSound" />를 통해 helloDI패키지의 sound() 함수를 joinpoint로 지정하겠다는 의미이다. 이때 *은 와일드카드로서 어떤 클래스든 상관없다는 의미를 가진다. <aop:before method="aboutToSound" pointcut-ref="selectSound" />는 before어드바이스를 추가하겠다는 의미로 aboutToSound라는 메서드를 이용하며 ref로는 위에 선언한 pointcut의 id를 가진다. 따라서 pointcut은 jointpoint를 가르키고 advice는 그 pointcut을 가리킨다
다음과 같이 Logger 클래스를 수정한다 @Aspect로 클래스가 Aspect라는 걸 명시하고 @Pointcut을 통해 sound() 메서드를 joinpoint로 지정하겠다는 것을 명시하고 @Before로 이전 어드바이스를 추가한다.
@Aspect
public class Logger{
@Pointcut("execution(void kr.ac.hansung.helloDI.*.sound()")
private void selectSound() {}
@Before("selectSound()")
public void aboutToSound() {
System.out.println("Before: about to sound");
}
}
앞 강의에서 DI란 무엇인지와 생성자를 이용하여 의존성 주입을 하는 방법을 실습해 보았다면 이번 강의에서는 Annotation을 이용하여 의존성 주입을 해볼 예정이다.
먼저 에노테이션이란 기존 XML을 이용하여 의존성 주입을 하는 것이 아닌 @Required 같은 태그를 이용하여 의존성 주입을 하는 것을 의미한다. 의존성 주입 에노테이션으로는 다음과 같은 3가지가 있다
#1 @Required
XML의 Bean의 property에 해당하는 부분 중 필수적인 부분을 명시할 때 다음과 같이 사용한다. 쉽게 말해 XML에 bean중 property가 꼭 있어야 하니 없으면 에러가 발생한다고 생각하면 좋다 즉 @required를 사용할때 xml에 property에 name에 해당하는 부분이 반드시 있어야 에러가 발생하지 않는다.
public class Boy{
private String name;
@required
public void setName(String name){
this.name = name;
}
}
#2 @Autowired
이전 강의에서 의존성 주입을 할 때 bean에 property를 사용하여 세터를 통한 주입을 했었다. 하지만 Class의 기존 세터 부분을 지우고 @Autowired 에노테이션을 추가하면 자동으로 의존성 주입이 이루어진다. 이는 다음 코드처럼 Boy클래스는 property를 사용하여 세터를 통해 bean을 생성했고 college라는 bean은 propery를 통해 boy라는 bean을 의존성 주입 했지만 College클래스에 @Autowired 에노테이션을 추가하고 세터부분을 지우고, 마찬가지로 bean의 property부분을 지우면 자동으로 의존성 주입이 이루어지는것을 확인할 수 있다.
public class Boy {
private String name;
private int age;
// getters and setters ...
}
public class College {
@Autowired
private Boy student;
//이부분부터
public void setStudent(Boy aboy){
this.stuendt = aboy;
}
//이부분까지 삭제
}
<bean id=“boy” class=“Boy”>
<property name=“name” value=“Rony”/>
<property name=“age” value=“10”/>
</bean>
<bean id=“college” class=“College”>
<property name=“student” ref=“boy”/> //이부분 삭제
</bean>
#3 @Qualifier
만약 Autowired를 할때 다음과 같이 Boy 클래스의 bean이 두 개 있으면 어떤 걸 자동으로 Autowired를 할지 몰라 오류가 생긴다 따라서 이럴 때 @Qualifier를 사용한다. 다음과 같이 bean에는 qualifer의 value를 지정하고 Class에는 @Qualifier의 에노테이션과 함께 value를 설정하면 어떤 bean을 주입할지 정하게 된다
PetOwner.java클래스의 생성자 부분을 지우고 다음과 같이 @Autowired에노테이션을 추가합니다
package kr.ac.hansung.helloDI;
import org.springframework.beans.factory.annotation.Autowired;
public class PetOwner {
@Autowired
private AnimalType animal;
public void play() {
animal.sound();
}
}
다음과 같이 코드를 수정하고 Run 하게 되면 다음과 같은 에러가 발생하는 것을 확인할 수 있습니다. 앞서 공부한 것처럼 2개의 bean 중 어떤 bean을 주입할지 모르기 때문에 다음과 같은 error가 발생하는 것입니다. 따라서 2가지 방법을 통해 해결해보도록 하겠습니다.
error
#3) @Qualifier추가 및 animal.xml수정
다음과 같이 Qualifier에노테이션을 사용하여 다음과 같이 어떤 빈을 주입할지 선택합니다.
PetOwner.java
package kr.ac.hansung.helloDI;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class PetOwner {
@Autowired
@Qualifier(value="cat")
private AnimalType animal;
public void play() {
animal.sound();
}
}
