'Back-End'에 해당되는 글 135건

 Method Overloading

If a class have multiple methods by same name but different parameters, it is known as Method Overloading

1. Advantage of method overloading

- Method overloading increases the readability of the program

2. Different ways to overloading the method

2_1. By changing number of arguments

2_2. By changing the data type

1) By changing the number of arguments

package overloading; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; import org.junit.Test; import org.junit.runner.JUnitCore; public class Overloading { public static void main(String[] args){ JUnitCore.main("Array.ArrayConvert"); } int sum(int a, int b){ return a + b; } int sum(int a, int b, int c){ return a+b+c; } @Test public void byNum(){ Overloading test = new Overloading(); assertThat(test.sum(10,10,10),is(30)); assertThat(test.sum(10,10),is(20)); } }

2) By changing the data type

package overloading; public class Overloading { public static void main(String[] args){ Overloading test = new Overloading(); test.sum(10, 10); test.sum(10, 10,10); } void sum(int a, int b){ System.out.println(a+b); } void sum(double a, double b, double c){ System.out.println(a+b+c); } }  

3. Questions

3_1. Why method overloading is not possible by changing the return type of method?

- there may occur ambiguity.

3_2. Can we overloading main() method?

 public class Overloading { public static void main(int a){ System.out.println(a); } public static void main(String args[]){ System.out.println("main() method invoked"); main(10); } }  

- Yes

AOP_2

1. 애노테이션을 이용한 AOP

1_1 Advice

package AOP.aop; @Aspect @Component public class MyFirstAspect { @Before("execution(* getProduct(String))") public void before(){ System.out.println("Hello Before!"); } @After("execution(* getProduct(String))") public void after(){ System.out.println("Hello After"); } @AfterReturning(value="execution(* getProduct(String))", returning="product") public void afterReturning(Product product){ //메소드 호출이 예외를 내보내지 않고 종료했을때 동작함 System.out.println("Hello AfterReturning"); } @Around("execution(* getProduct(String))") public Product around(ProceedingJoinPoint pjp)throws Throwable{ //메소드전후 System.out.println("Hello Around before"); Product p = (Product)pjp.proceed(); System.out.println("Hello Around After"); return p; } @AfterThrowing(value="execution(* getProduct(String))", throwing="ex") public void afterThrowing(Throwable ex){ //예외 발생시 System.out.println("Hello Throwing"); } }

- getProduct() 이용 할떄 마다 어드바이스 동작

- 애노테이션이 붙어있는 것을 어드바이스라한다

- execution은 포인트컷이며 필터링 조건이다

1_2. Bean

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd"> <context:component-scan base-package="AOP.*"/> <aop:aspectj-autoproxy/> </beans>

1_3. Annotation Advice

a. @Before, @After

1) 기본형태

@Before("primitivePointCut"), @After("primitivePointCut")

메소드명은 임의

메소드의 인수는 없는게 기본

메소드의 반환값은 void가 기본

2) 메소드 명을 출력하도록 변경

- org.aspectj.lang.JoinPoint설정

@Before("execution(* getProduct(String))") public void before(JoinPoint jp){ System.out.println("Hello Before!"); Signature sig = jp.getSignature(); System.out.println("Methodname:"+sig.getName()); Object[] obj = jp.getArgs(); System.out.println("instance value:"+obj[0]); }

b. @AfterReturning

2. Bean 정의 파일을 이용한 AOP

<aop:config> <aop:aspect id="myAspect" ref="myFristAspect"> <aop:pointcut id="pc" expression="execution(* getProduct(string))"/> <aop:before pointcut-ref="pc" method="before"/> <aop:after pointcut-ref="pc" method="after"/> <aop:after-returning pointcut-ref="pc" method="afterReturing"/> <aop:around pointcut-ref="pc" method="around"/> <aop:after-throwing pointcut-ref="pc" method="afterThrowing"/> </aop:aspect> </aop:config>

3. 포인트컷 기술 방법

- AspectJ 라는 AOP제품 사용

- 호출하는 쪽의 메소드나 클래스, 호출되는 쪽의 메소드나 클래스를 조건으로 지정할 수 있는 Primitive Pointcut이라 불리는 포인트컷이 준비됨

- 자주사용하는 포인트컷은 execution 이다

3_1. execution기본 문구

execution(메소드 수식자^메소드의 반환값^패키기.클래스 또는 인터페이스.메소드명(인수의 형|. 인수의형...| ^throws^에외)

^:공백을 의미함 

Example

- public String getMethod() 메소드에서 에스펙트를 실행할 수 있는 포인트컷 기술방법은?

a : execution(public String com.kyle.service.ProductDaoImpl.getProduct())

b : execution(* *..*getMethod())

c : execution(* *..ProductDaoImpl.*())

d : execution(public String get*(..))

e : execution(* com.kyle.service.*.*(..))

3_2. 논리연산자 이용

- 포인트컷은 몇가지 포인트컷을 조합해서 사용가능

1) || 또는 OR

Example

execution(* *..ProductServiceImpl.findProduct()) or

execution(* *..ProductDaoImpl.getProduct())

Define

findProduct() 또는 getProduct()를 지정

2) && 또는 and

Example

execution(* * ProductServiceImpl.findProduct())&&

execution(* *..ProductDaoImpl.getProduct())

Define

findProduct() 와 getProduct()를 지정

3) !또는 not    

Example

execution(* findProduct()) and not

execution(* *..ProductDaoImpl.*())

Define

ProductDaoImpl이외의 클래스의 메소드 findProduct() 를 지정

DI_2

1. Bean 정의 파일로 DI

1_1. BeanFactory

- DI 컨테이너의 핵심이 됨

- BeanFactory는 실행 시에 건네지는 Bean정의 파일(applicationContext.xml)을 바탕으로 인스턴스를 생성하고 인젝션한다

- 웹 어플리케이션 개발에 개발자가 직접 이용하는 일은 별로 없다

- ClassPathXmlApplicationContext는 BeanFactory의 상위에 있다

- BeanFactory의 이용

BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationContext.xml");

1) Bean정의 파일

- Bean의 정의 파일을 프로퍼티, xml, LDAP 등으로 다루지만 XML이 일반적이다

- Bean정의 파일 이용시 Setter 메소드가 필요하다

- 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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="productService" class="DI.service.ProductServiceImpl" autowire="byType"/> <bean id="productDao" class="DI.dao.ProductDaoImpl"/> </beans>

- ProductServiceImpl

package DI.service; import DI.dao.ProductDao; import DI.domain.Product; public class ProductServiceImpl implements ProductService{ private ProductDao productDao; public Product findProduct(String name){ return productDao.findProduct(name); } public void setProductDao(ProductDao productDao){ this.productDao = productDao; } }

2) Bean 정의 파일 분할

- 규모가 커질수록 빈 정의 파일을 분할 하는게 좋다

- 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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${jdbc.driverClass}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> </beans>

- applicationContext-bean.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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <bean id="productService" class="DI.service.ProductServiceImpl" autowire="byType"/> <bean id="productDao" class="DI.dao.ProductDaoImpl"/> </beans>

- import.xml

<beans> <import resource="config/services.xml"/> <import resource="resources/dataaccess.xml"/> </beans>

3)  프로퍼티 파일 이용

a.  bean정의 파일 경우

- message.properties

message = "Hello Spring"

- 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" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <util:properties id="msgProperties" location="classpath:DI/properties/message.properties"/> <bean id="message" class="sample.MessageServiceImpl"> <property name="message" value="#{msgProperties.message}"/> </bean> </beans>

- MessageServiceImpl

package DI.service; public class MessageServiceImpl implements MessageService{ private String message; public void setMessage(String message){ this.message = message; } public String getMessage(){ return message; } }

b. annotation  경우

- 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" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <context:annotation-config/> <context:component-scan base-package="DI.*"/> <util:properties id="msgProperties" location="classpath:DI/properties/message.properties"/> </beans>

- MessageServiceImpl

package DI.service; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; @Component public class MessageServiceImpl implements MessageService{ @Value("#{msgProperties.message") private String message; public String getMessage(){ return message; } }

2. ApplicationContext

- ApplicationContext 는  BeanFactory를 확장해 Bean 정의파일 읽기, 메세지 소스, 이벤트 처리 등의 기능을 추가한것이다

2_1. Bean 정의 파일 읽기

- 웹 어플리케이션은  ContextLoaderListener 클래스나  ContextLoaderServlet 클래스에 의해 자동으로 ApplicationContext(XmlWebApplicationContext 클래스)가 로드됨

a. web.xml

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd" > <web-app> <display-name>Archetype Created Web Application</display-name> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- Listener를 사용 할수 없을시 <servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> --> </web-app>

b. 복수의  Bean 정의 파일

<context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml / WEB-INF/applicationContext-persist.xml</param-value> </context-param>

c. 웹 어플리케이션에선 ApplicationContext를 클래스에서 직접 이용할 일이 없지만 간단한 예제 어플리케이션을 만들때는 아래처럼 사용한다

    ApplicationContext context = new ClassPathXmlApplicationContext("a.xml","b.xml","c.xml");

d. ApplicationContext를 POJO로 만들어진 클래스에 직접 이용할떄

- @Autowired를 사용

@Component public class ProductServiceImpl implements ProductService{ private ProductDao productDao; @Autowired private ApplicationContext ac; public Product findProduct(String name){ productDao = (ProductDao) ac.getBean("/DI/dao/ProductDaoImpl.class"); return productDao.findProduct(name); } }

3. Spring logging

- 스프링은 기본적으로 Commons Logging으로 로그를 출력함

- Log4j라이브러리가 있으면 Commons Logging이 Log4j를 사용한다

- WEB-INF 또는 클래스 패스 아래에 두면 사용가능하다

- log4j.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> <appender name="stdout" class="org.apache.log4j.ConsoleAppender"> <layout class="org.apahce.log4j.PatternLayout"> <param name="ConversionPattern" value="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/> </layout> </appender> <logger name="org.springframework.beans"> <level value="debug"/> </logger> <logger name="org.springframework.transaction"> <level value="debug"/> </logger> <root> <priority value="error"/> <appender-ref ref="stdout"/> </root> </log4j:configuration>

4. Spring unitTest

- DI 컨테이너로 관리하는 오브젝트를 유닛 테스트하기 위한 기능이 제공됨

- Test.java

package DI.test; import org.junit.Test; import org.junit.runner.RunWith; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.*; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import DI.domain.Product; import DI.service.ProductService; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations={"../applicationContext.xml"}) public class ProductServiceTest { @Autowired ProductService productService; @Test public void testFindProduct(){ Product product = productService.findProduct("Kyle"); assertEquals(new Product("Kyle",100),product); } }

- 데이터 베이스 테스트시 자바의 내장 데이터베이스를 사용한다

DI_1

1. What is DI

- DI는 인터페이스를 이용해 컴포넌트화를 실현함

- 오브젝트 사이의 의존 관계를 만든다

1_1 DI 하지 않았을때

- 각자의 new한 다음에 각각의 인스턴스를 생성해서 사용

1_2 DI 사용

- new라는 키워드를 사용하지 않는다

- DI컨테이너 생성, ProductService의 인스턴스 취득은 ApplicationContext에서 함

- 작은 어플리케이션에서는 main에서 DI컨테이너 생성

- DI컨테이너가 인스턴스를 생성할 클래스, 인스턴스를 전달 받은 클래스는 모두 POJO로 작성된다

- 팩토리메소드 같은 디자인 패턴이 필요없다

- DI컨테이너는 클래스를 단 한번 인스턴스로 만들고 재사용 함으로 싱글톤을 구현한다

2. Using of DI

- 서비스와 컨트롤러, 서비스와 DAO의 의존관계를 구축하는데 어울림

- 서비스와 도메인(Product), DAO와 도메인(Product)은 어울리지 않는다

3. DI by using annotation

3_1. DI를 사용하는 방법

1) Bean정의 파일을 사용한 DI

2) Annotation을 사용한 DI

3_2. @Autowired, @Component

package DI.service; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import DI.dao.ProductDao; import DI.domain.Product; @Component public class ProductServiceImpl implements ProductService{ @Autowired private ProductDao productDao; public Product findProduct(String name){ return productDao.findProduct(name); } }

- DI 컨테이너는 @Autowired가 붙은 인스턴스 변수의 형에 대입할 수 있는 클래스를 @Component가 붙은 클래스 중에서 찾아내 그 인스턴스를 인젝션한다

- 인젝션이 setProductDao 같은 셋터 메소드는 필요없다

3_3. 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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"> <context:annotation-config/> <context:component-scan base-package="DI.*"/> </beans>

- bean 스키마 : Bean(컴포넌트) 설정

- context스키마 : Bean(컴포넌트) 검색과 애노테이션 설정

- <context:annotation-config/>

@Autowired, @Resource를 이용할 때의 선언이다

context:component-scan혹은 mvc:annotation-driven이 있으면 생략 가능

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

@Component, @Service등의 컴포넌트를 이용할떄 선언

context:exclude-filter(검색하지 않는 컴포넌트 조건)

use-default-filters="false"(지정한 패키지 아래 컴포넌트를 찾지 않을떄)

context:include-filter(검색할 컴포넌트릐 조건)

3_4. @Autowired

1) @Autowired 위치

- 메소드에 선언

@Autowired public void setFoo(Foo foo){ this.foo = foo } @Autowired public void setFoo(Foo foo, Bar bar){ this.foo = foo; this.bar = bar; } ..... @Component public class Foo{ } @Component public class Bar{ }

- 생성자 인젝션

public class Foo{ @Autowired public Foo(Bar b){...}

2) @Autowired 필수 설정

@Autowired(required = false) public void setFoo(Foo foo){ this.foo = foo; }

3) 인젝션할 클래스 찾는 방법

(1) byType 

- @Component가 붙은 클래스가 여러개 있어도 형이 다르면 @Autowired가 붙은 인스턴스 변수에 인젝션되지 않는다

(2) byName 

- 인젝션할 클래스를 형이 아닌 이름으로 찾아주는 방법

@Autowired @Qualifier("productDao") private ProductDao productDao; ... @Component("productDao") public class ProductDaoImpl implements ProductDao{ ... }

(3) context:component-scan 이용

- context:component-scan을 어느 정도 크기의 컴포넌트마다 기술해 두고, 만약 어떤 컴포넌트를 테스트 용으로 바꾸자고 할때는 그 컴포넌트 부분의 정의만 테스트로 바꿈

-평상시

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="..."> <context:annotation-config/> <context:component-scan base-package="sample.di.business.*"/> <context:component-scan base-package="sample.di.service.*"/> </beans>

- 컴포넌트 스캔변경

<beans xmlns="..."> <context:annotation-config/> <context:component-scan base-package="sample.di.business.*"/> <!-- <context:component-scan base-package="sample.di.service.*"/> --> <context:component-scan base-package="test.*"/> </beans>

3_5. @Component

- @Component는 DI 컨테이너가 관리하는, 주로 인젝션을 위한 인스턴스를 설정함

- 클래스 선언 앞에 @Component를 붙이면 스프링의 DI컨테이너가 찾아서 관리함

1) @Component의 확장

- @Controller

- @Service

- @Repository

2) @scope

- @Scope뒤에 value속성을 지정하면 인스턴스화와 삭제를 제어함

- @Scope을 생략하면 해당 클래스는 싱글톤이된다

@Component @Scope("singleton") public class ProductDaoImpl implements ProductDao{ ... }

singleton : 인스턴스를 싱글톤으로 한다

prototype : 이용할 떄마다 인스턴스화 한다

request : Servlet API의 Request 스코프인 동안만 인스턴스가 생존한다

session : Servlet API의 Session 스코프인 동안만 인스턴스가 생존

예제 소스 : https://github.com/KyleJeong/SpringFramework/tree/master/simpleProject/src/main/java/DI