'Back-End/SpringFrame_1'에 해당되는 글 23건

BusinessLayer_1

1. 트랜잭션

1) 요청에 걸친 트랜잭션

- 롱트랜잭션, 약한결합 트랜잭션이라 한다

- 여러 요청에 걸친 트랜잭션

- 애플리케이션 설계 혹은 시스템 운영으로 대응

- 올라인으로 책을 구입해서 집으로 배송되고 은행에서 대금이 인출

2). 요청 안에서 트랜잭션

- 쇼트 트랜잭션, 밀결합 트랜잭션

- 데이터소스가 하나일때는 로컬 트랜잭션, 여러개에 걸칠 때는 글로벌 트랜잭션

- 스프링 트랜잭션 기능을 이용

- 주문확정 요청을 받아 발주 테이블과 고객테이블, 재고 테이블이 갱신

1_1. 트랜잭션의 경계

- 트랜잭션의 경계는 프레젠테이션 층과 비즈니스 로직 층 사이에 있다

- 컨트롤러에서 서비스 클래스의 메소드가 호출되면 시작

- 서비스 클래스의 메소드를 마치고 컨트롤러로 되돌아 갈 때가 트랜잭션 종료

1_2. 트랜잭션 처리를 구현하는 장소 문제

비즈니스 로직 안에서 트랜잭션 처리 문제점

1) transfer()는 프레젠테이션 층에 공개된 서비스의 메소드인 트랜잭션 경계이다

2) 이체 서비스 옆은 DAO이며 계좌의 잔고를 갱신하는 updateZandaka()가 있다

3) transfer()에서 updateZandaka()를 각각 호출한다

4) 비즈니스 로직안에서 커넥션 취득이나 커밋/롤백을 호출할 필요가 있다

5) 은폐되어야할 JDBC의 API에 비즈니스 층이 의존하게된다

1_3. AOP를 이용한 트랜잭션 처리

- 선언적 트랜잭션 구현

- AOP로 서비스에 어드바이스를 적용함

- 스프링이 제공하는 트랜잭션 매니저와 어드바이스 사용

2. 트랜잭션 매니저

- 트랜잭션 시작과 종료, 롤백 처리를 비롯해 트랜잭션의 정의정보를 세밀하게 설정함

- 데이터 엑세스기술을 은폐해 기술이 바뀌어도 같은 방법으로 매니저 사용

2_1. 트랜잭션 정의 정보

- 트랜잭션 매니저로 설정할수 있는 정의 정보

a. 전파(Propagation) 속성

b. 독립성 수준

c. 시간만료

d. 읽기전용상태(Read-Only Status)

e. 롤백 대상 예외

f. 커밋 대상 예외

1) 전파 속성

- 트랜잭션의 전파 방법을 설정하는 속성

1 : 컨트롤러 1에서 서비스 1을 호출, 트랜잭션은 서비스1의 메소드가 호출되었을 때 시작됨

2 :  컨트롤러 2에서 서비스2를 호출하고 서비스2에서 서비스 1을 호출

- 서비스2의 메소드가 호출 될 때 트랜잭션 시작, 그 트랜잭션 안에서 서비스1 호출

- 서비스 1이 호출되면 동시에 트랜잭션을 새로 시작할지 아니면 원래 트랜잭션(서비스2) 그대로 이어갈지 선택 해야한다

- 이런 선택을 우린 전파속성이라 한다

전파 속성의 종류

개발에서는 기본적으로 PROPAGATION_REQUIRED로 문제 없다

2) 독립성 수준

- 트랜잭션 처리가 병행해서 실행될 때 의 각 트랜잭션의 독립성을 결정하는 것이다

- Example

a. 트랜잭션 1과 트랜잭션 2과 나란히 실행됨

b. 트랜잭션1이 무엇인가 데이터베이스의 레코드를 갱신 했다고 한다, 단 트랜잭션 도중이므로 아직 커밋 안함, 오류가 일어난다면 롤백해서 불안정한 상황

c. 트랜잭션 2는 1의 갱신한 데이터를 읽어 오려한다, 읽어 오려는 데이터는 커밋되지 않은 불확정한 상태 이다

d. 이때 트랜잭션2는 갱신된 데이터를 읽어와도 되는가?

e. 모순 되지 않게 하려면 트랜잭션1이 커밋해서 확정된 후에 데이터를 읽어와야 한다

f. 트랜잭션1과 2과 나란히 실행될 때 모순되지 않게 처리하는 속성이 독립성 이다

- 독립성 수준의 종류

- 데이터가 모순되는 3가지 상태

a. Dirty Read

- 다른 트랜잭션이 변경했지만, 아직 커밋하지 않은 데이터를 읽어내는 것이다.

b. Unrepeatable Read

- 트랜잭션 내에서 같은 데이터를 여러번 읽을 때, 다른 트랜잭션이 해당 데이터를 변경하면 이전에 읽은 데이터와 다른 데이터를 읽어내는 것

c. Phantom Read

- 트랜잭션 내에서 같은 데이터를 여러번 읽을 때, 다른 트랜잭션이 새로운 레코드를 추가하면 이전에 없던 레코드를 읽어 내는것

- 독립성 수준과 데이터 모순 상태

X: 허용안함, O: 허용

- 아래로 갈수록 독립성 수준이 높다.

- 독립성이 강해지면 성능이 나뻐진다.

- Example

과자 가게 아줌마가 한번에 아이들에게 과자를 팔면 200원이 모자란다. 그래서 한줄로 세우고 순서대로 계산하면 계산은 맞지만 시간이 오래걸린다

DataAccessLayer_2

1. NamedParameterJdbcTemplate

- SQL의 파라미터에 플레이스홀더(?마크)를 사용하지 않을 때 사용

- 파라미터의 순서를 맞출 필요가 없다

1_1 메소드 체인 사용 

npJdbcTemplate.update( "INSERT INTO PET(PET_ID, PET_NAME)" + "VALUES(:PET_ID, :PET_NAME)" , new MapSqlParameterSource() .addValue("PET_ID",pet.getPetId()) .addValue("PET_NAME",pet.getName()) );

- : 뒤의 문자열이 파라미터의 이름

- 개발자가 자유롭게 이름을 정할 수 있다

- MapSqlParameterSource를 이용함으로서 파라미터의 순서가 어긋날 위험성을 줄인다

1_2. 메소드 체인 사용 안함

MapSqlParameterSource map = new MapSqlParameterSource(); map.addValue("PET_ID",pet.getPetId()); map.addValue("PET_NAME",pet.getPetName()); npJdbcTemplate.update( "INSERT INTO PET(PET_ID, PET_NAME)" + "VALUES(:PET_ID, :PET_NAME)" ,map );  

2. 배치업데이트, 프로시저 콜

2_1.  배치 업데이트

- 많은 양의 레코드를 한번에 갱신하기 위한 것

1) batchUpdate()

A. jdbcTemplate

List<Object[]> args = new ArrayList<Object[]>(); for(Pet pet : petList){ args.add(new Object[].{ pet.getOwnerName(), pet.getPetId() }); } int[] num = jdbcTemplate.batchUpdate( "UPDATE PET SET OWBER_NAME = ? WHERE PET_ID= ?" , args );  

B. NamedParameterJdbcTemplate

List<MapSqlParameterSource> args = new ArrayList<MapSqlParameterSource>(); for(Pet pet : petList){ MapSqlParameterSource m = new MapSqlParameterSource() .addValue("PET_ID", pet.getId()) .addValue("OWNER_NAME",pet.getOwnerName()); args.add(m); } int[] num = jdbcTemplate.batchUpdate( "UPDATE PET SET OWBER_NAME = :OWNER_NAME WHERE PET_ID= :PET_ID" , args.toArray(new MapSqlParameterSource[]{}) );  

- 두번째 인자가 배열이다

2_2. 프로시저 콜

- 데이터베이스에 준비된 스토어드 프로시저를 호출 할때 사용

Ex)

프로시저 이름 : CALC_PET_PRICE

IN 파라미터 : IN_PET_ID

OUT 파라미터 : OUT_PRICE

1) HSQLDB 데이터 베이스

SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate.getDataSource()) .withProcedureName("CALC_PET_PRICE"); .withoutProcedureColumnMetaDataAccess() .declareParameters( new SqlParameter("IN_PET_ID",Types.INTEGER), new SqlOutParameter("OUT_PRICE",Types.INTEGER) ); MapSqlParameterSource in = new MapSqlParameterSource() .addValue("IN_PET_ID",id); Map<String, Object> out = call.execute(in); int price = (Integer)out.get("OUT_PRICE");  

2) ORACLE, SQL 서버..

SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate.getDataSource()) .withProcedureName("CALC_PET_PRICE"); MapSqlParameterSource in = new MapSqlParameterSource() .addValue("IN_PET_ID",id); Map<String, Object> out = call.execute(in); int price = (Integer)out.get("OUT_PRICE");  

3. 범용 데이터 엑세스 예외

- 스프링 JDBC에서만 사용되는 것이 아니라 스프링이 제동하는 데이터 엑세스 기능 전체에서 이용

- 독자적인 예외를 범용적 예외로 변환 함으로써 예외를 핸들링하는 클래스가 데이터 엑세스 기술에 의존하지 않아도 됨

- 스프링이 오류의 원인을 판단해 범용데이터로 변환하브로 SQLException을 분석할 필요 없다

3_1. 적용

1) Template 

- JdbcTemplate, NamedParameterJdbcTemplate을 사용하면 SQLException은 자동으로 적용된다

2) @Repository

- DAO클래스에 @Repository 애노테이션을 설정하고 Bean 정의파일에 아래 설정을 하면 적용됨

<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>  

4. 데이터 소스

- 데이터 소스: 데이터 소스와의 접속 오브젝트인 Connection 오브젝트의 팩토리 이다

- Connection 오브젝트의 생애 주기는 데이터 소스에 맡겨져 있고, 일반 어플리케이션에서 커넥션 풀에 의해Connection 오브젝트를 돌려쓰는 구조로됨

4_1. 데이터 소스의 이용

1) dataSource 정의

<bean id = "dataSource"> ... </bean>  

2) 인젝션

<bean id="foo"> <property name ="dataSource" ref ="dataSource"/> </bean>  

or

@Autowired private DataSource dataSource;  

4_2. 스프링이 제공하는 데이터 소스

    - 두 클래스 모두 테스트 용도로 만들어 졌으며 커넥션 풀을 지원하지 않는다

- 실제 현장에서 사용 안함

1) SingleConnectionDataSource

- 하나의 커넥션 오브젝트를 닫지 않고 다시 사용한다

- 테스트 케이스에서 커밋, 롤백하고 싶을 때 도움이 된다

2) DriverManagerDataSource

- 커넥션을 요청할 때 마다 커넥션 오브젝트를 생성해서 돌려준다

<bean id="dataSource" class="org.springframework.jdbc.dataSource.DriverManagerDataSource> <property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <context:property-placeholder location="jdbc.properties"/>  

jdbc.driverClassName=org.hsqldb.jdbc.JDBCDriver jdbc.url=jdbc:hsqldb:hsql://locationhost/sample jdbc.username=sa jdbc.password= jdbc.maxPoolSize=20  

4_3. 서드파티가 제공하는 데이터 소스

- 대표적인 제품으로 DBCP(아파치)와 c3p0가 있다

1) DBCP

- 커넥션 수 지정가능 

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> <property name="maxActive" value="${jdbc.maxPoolSize}"/> </bean>  

4_4. 애플리케이션 서버가 제공하는 데이터 소스

- 보통 애플리케이션 서버 제품은 데이터 소스의 오브젝트 생성/관리 기능이 있다

- 네이밍 서비스 이용

- JNDI를 이용하여 데이터 소스 오브젝트를 가져옴

4_1. JNDI를 이용하여 소스를 얻는 방법

1) JndiObjectFactoryBean

- 데이터 소스 JNDI 이름 : jdbc/MyDataSource

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="${jndi.datasource}"/> </bean> <context:property-placeholder location="jndi.properties"/>  

jndi.datasource = jdbc/MyDataSource  

2) jee  스키마를 사용

- JndiObjectFactoryBean 보다 권장

<jee:jndi-lookup id="dataSource" jndi-name="${jndi.datasource}"/>  

3) @Resource 

  - 원래 스프링 독자적인 것이 아니지만 용도가 변경됨(@Autowired + @Qualifier)

@Resource(name="${jndi.datasource}") private DataSource dataSource;  

<context:component-scan> <bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"> <property name="alwaysUseJndiLookup" value="true"/> </bean>  

DataAccessLayer_1

- 비즈니스 로직과 데이터베이스 접속같은 SQL발행을 분리하는것이다

1. DAO Pattern

- 데이터 베이스접속과 SQL 발행 같은 데이터 액세스 처리를 DAO라고 불리는 오브젝트로 분리

- 데이터 엑세스에 특화된 처리를 비즈니스 로직에 숨긴다. 

- 데이터 엑세스 방식이 변경되어도 DAO만 변경하면됨

2. 자바의 데이터 엑세스 기술과 스프링의 기능

1) 대표적인 데이터 엑세스 기술

- JDBC, Hibernate, MyBatis(iBatis), JPA, S2DAO ...

- 스프링은 기존의 다섯가지 데이터 엑세스 기술을 더욱 사용하기 쉽게한다

2) 스프링 기능을 이용하여 얻는 장점

- 데이터 엑세스 처리를 간결하게 기술할 수 있다

- 스프링이 제공하는 범용적이고 체계적인 데이터 엑세스 예외를 이용할 수 있다

- 스프링의 트랜젝션 기능을 이용할 수 있다

3. 스프링 JDBC

- 소스코드가 심플해 진다

- SQLException의 원인을 특정하는 처리도 필요없다

3_1. Template 클래스의 소스 단순화

1) JdbcTemplate class

- 메소드의 종류가 풍부

- 스프링 버전 1.0 부터 제공

2) NamedParameterJdbcTemplate

- SQL 파라미터에 임의의 이름을 붙여 SQL을 발행할 수 있다

- 스프링 버전 2.0 부터 제공

3) SimpleJdbcTemplate

- JdbcTemplate + NamedParameterJdbcTemplate

- 3.1 부터는 권장되지 않는다

3_2. 템플릿 클래스의 Bean 등록

1) Bean등록

<!--JdbcTemplate--> <bean class="org.springframework.jdbc.core.JdbcTemplate"> <constructor-arg ref="dataSource"/> <bean> <!--NamedParameterJdbcTemplate--> <bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"> <constructor-arg ref="dataSource"/> </bean>

2) 인젝션

@Repository public class SpringJdbcAccountDao implements AccountDao{ @Autowired private JdbcTemplate jdbcTemplate; @Autowired private NamedParameterJdbcTemplate npJdbcTemplate;  

3_3. SELECT문 - 도메인으로 변환하지 않을때

- 레코드의 수를 조회할 때 한 레코드안의 특정 컬럼 처럼 단순값을 가져올때

1) queryForInt, queryForLong

- 수치형 값을 가져올때

int count = jdbcTemplate.queryForInt("SELECT COUNT(*) FROM PET");  

2) queryForObject

- 취득 결과가 문자열이나 날짜형일 때

String petName = jdbcTemplate.queryForObject("SELECT PET_NAME FROM PET WHERE PET_ID=?",String.class, id);  

String petName = jdbcTemplate.queryForObject("SELECT BIRTH_DAY FROM PET WHERE PET_ID=?",Date.class, id);  

3) queryForMap

- 레코드의 값을 가져옴

Map<String, Object> pet = jdbcTemplate.queryForMap("SELECT * FROM PET WHERE PET_ID = ?", id);  

4) queryForList

- 여러 레코드의 Map 데이터를 가져옴

A. 익명의 클래스 사용

Pet pet = jdbcTemplate.queryForObject( "SELECT * FROM PET WHERE PET_ID = ?" , new RowMapper<Pet>(){ public Pet mapRow(ResultSet rs, int rowNum)throws SQLException{ Pet p = new Pet(); p.setPetId(rs.getInt("PET_ID")); p.setPetName(rs.getString("PET_NAME")); p.setOwnerName(rs.getString("OWNER_NAME")); return p; } } , id);  

B. 익명의 클래스 사용 안함

class MyRowMapper implements RowMapper<Pet>{ public Pet mapRow(ResultSet rs, int rowNum)throws SQLException{ Pet p = new Pet(); p.setPetId(rs.getInt("PET_ID")); p.setPetName(rs.getString("PET_NAME")); p.setOwnerName(rs.getString("OWNER_NAME")); return p; } } Pet pet = jdbcTemplate.queryForObject( "SELECT * FROM PET WHERE PET_ID = ?" , new MyRowMapper<Pet>() , id);  

2) query

- 여러 레코드의 오브젝트 가져옴

Pet pet = jdbcTemplate.query( "SELECT * FROM PET WHERE PET_ID = ?" , new RowMapper<Pet>(){ public Pet mapRow(ResultSet rs, int rowNum)throws SQLException{ Pet p = new Pet(); p.setPetId(rs.getInt("PET_ID")); p.setPetName(rs.getString("PET_NAME")); p.setOwnerName(rs.getString("OWNER_NAME")); return p; } } , id);  

3) BeanPropertyRowMapper

- RowMapper 구현 클래스, 도메인을 자동으로 생성

- 내부에서 리플렉션을 사용 하므로 성능이 나쁘다

Pet pet = jdbcTemplate.queryForObject( "SELECT * FROM PET WHERE PET_ID = ?" , new BeanPropertyRowMapper<Pet>(Pet.class) , id);  

4) ResultSetExtractor

- 조인한 테이블의 여러 레코드를 가져오고 싶을 때

- 소스 코드가 복잡해진다

Owner owner = jdbcTemplate.query( "SELECT * FROM OWNER O INNER JOIN PET P" + "ON O.OWER_NAME = P.OWNER_NAME " + "WHERE O.OWNER_NAME = ?" , new ResultSetExtractor<Owner>(){ public Owner extractData(ResultSet rs)throws SQLException, DataAccessException{ if(!rs.next()){ return null; } Owner owner = new Owner(); owner.setOwnerName(rs.getString("OWNER_NAME")); do{ Pet p = new Pet(); p.setPetId(rs.getInt("PET_ID")); p.setPetName(rs.getString("PET_NAME")); p.setOwnerName(rs.getString("OWNER_NAME")); owner.getPetList().add(pet); }while(rs.next()); return owner; } }, ownerName);  

3_5. INSERT/UPDATE/DELETE 

1) update

- insert/update/delete 모두 update()로 사용가능

jdbcTemplate.update( "INSERT INTO PET (PET_ID,PET_NAME, OWNER_NAME, PRICE, BIRTH_DATE)" + "VALUES(?,?,?,?,?)" ,pet.getPetId(),pet.getPetName(),pet.getOwnerName(),pet.getPrice(), pet.getBirthDate());  

jdbcTemplate.update( "UPDATE PET SET PET_NAME = ?" ,pet.getPetName());  

jdbcTemplate.update( "DELETE FROM PET WHERE PET_NAME = ?" ,pet.getPetName());  

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() 를 지정