IoC
|-------> DL (EJB, Spring)
|-------> DI (Spring)
|-----------> Setter Injection
|-----------> Constructor Injection
|-----------> Method Injection
- IoC : Inversion of Control
- DL  : Dependency Lookup
- DI  : Dependency Injection

Context ctx = new InitialContext();
UserServiceHome home = (UserServiceHome)ctx.lookup("JNDI_BEAN_NAME");
UserService service = home.create();

WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletCtx);
UserService service = (UserService)wac.getBean("KEY_BEAN_NAME");

public class UserServiceImpl implements UserService {
private UserDAO userDAO;
public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}
public int addUser(User user) {
...
return userDAO.insert(user);
}
...
}

<beans>
<bean id="userDAO"
class="net.javajigi.user.dao.MySQLUserDAO" />
<bean id="userService"
class="net.javajigi.user.service.UserServiceImpl" >
<property name="userDAO" >
<ref local="userDAO" />
</property>
</bean>
...
</beans>

public class UserServiceImpl implements UserService {
private UserDAO userDAO;
public UserServiceImpl(UserDAO userDAO) {
this.userDAO = userDAO;
}
public int addUser(User user) {
...
return userDAO.insert(user);
}
...
}

<beans>
<bean id="userDAO"
class="net.javajigi.user.dao.MySQLUserDAO" />
<bean id="userService"
class="net.javajigi.user.service.UserServiceImpl" >
<constructor-arg>
<ref local="userDAO" />
</constructor-arg>
</bean>
...
</beans>

 
public class UserServiceImpl
implements UserService, ApplicationContextAware {
private ApplicationContext ctx;
public void setApplicationContext(ApplicationContext ctx)
throws BeansException {
this.ctx = ctx;
}
...
public boolean login(String userId, String password)
throws PassworkdMismatchException, UserNotFoundException {
...
User user = findUser(userId);
if(!user.isMatchPassword(password)) {
throw new PasswordMismatchException(
ctx.getMessage("password.mismatch.exception", new Object[] { userId }, null));
}
return true;
}
...
}

<beans>
<bean id="messageSource" 
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>Messages</value>
</list>
</property>
</bean>
...
</beans>

 
public class UserServiceImpl
implements UserService {
private MessageSourceAccessor msAccessor;
public void setMessageSourceAccessor(MessageSourceAccessor msAccessor) {
this.msAccessor = msAccessor;
}
...
public boolean login(String userId, String password)
throws PassworkdMismatchException, UserNotFoundException {
...
User user = findUser(userId);
if(!user.isMatchPassword(password)) {
throw new PasswordMismatchException(
msAccessor.getMessage("password.mismatch.exception", new Object[] { userId }, null));
}
return true;
}
...
}

<beans>
...
<bean id="messageSource" 
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basenames">
<list>
<value>Messages</value>
</list>
</property>
</bean>
<bean id="messageSourceAccessor"
class="org.springframework.context.support.MessageSourceAccessor">
<constructor-arg>
<ref local="messageSource" />
</constructor-arg>  
</bean>
<bean id="userService"
class="net.javajigi.user.service.UserServiceImpl" >
<property name="userDAO" >
<ref local="userDAO" />
</property>
<property name="messageSourceAccessor" >
<ref local="messageSourceAccessor" />
</property>
</bean>
...
</beans>

<web-app>
<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>
...
</web-app>

String[] path = {"/WEB-INF/applicationContext.xml"};
ApplicationContext ctx = new new ClassPathXmlApplicationContext(paths);
UserDAO userDAO = (UserDAO)ctx.getBean("userDAO");

String[] path = {"project/web/WEB-INF/applicationContext.xml"};
ApplicationContext ctx = new new FileSystemXmlApplicationContext(paths);
UserDAO userDAO = (UserDAO)ctx.getBean("userDAO");

ProxyFactory pf = new ProxyFactory();
pf.addAdvice(new SUserLoggingAdvice());
pf.addAdvice(new EmailNotificationThrowsAdvice());
pf.setTarget(targetObject);
UserService userService = (UserService)pf.getProxy();
...

public class UserLogginPointcut
extends StaticMethodMatcherPointcut {
public boolean matches(Method method, Class cls) {
if("addUser".equals(method.getName()) {
return true;
}
return false;
}
public ClassFilter getClassFilter() {
return new ClassFilter() {
public boolean matches(Class cls) {
return (cls == UserServiceImpl.class || cls == MySQLUserDAO.class);
}
}
}
}

ProxyFactory pf = new ProxyFactory();
Pointcut logginPC = new UserLogginPointcut();
Advisor loggingAdvisor = new DefaultPointcutAdvisor(loggingPC
, new UserLoggingAdvice());
pf.addAdvisor(loggingAdvisor);
Pointcut emailPC = new EmailNotificationPointcut();
Advisor emailAdvisor = new DefaultPointcutAdvisor(emailPC
, new EmailNotificationThrowsAdvice());
pf.addAdvisor(emailAdvisor);
pf.setTarget(target);
UserService userService = (UserService)pf.getProxy();

<bean id="userDAO" 
class="net.javajigi.user.dao.MySQLUserDAO" />

<bean id="aspect" 
class="net.javajigi.advice.LoggingAspect" factory-method="aspectOf" />

package org.springframework.beans.factory;
public interface FactoryBean {
Object getObject()
throws Exception;
Class getObjectType();
boolean isSingleton();
}

public class AOPFactoryBean
implements FactoryBean, BeanFactoryAware, InitializingBean {
private boolean singleton = true;
private Object instance;
private String[] interceptorNames;
private Object target;
private BeanFactory beanFactory;
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
public void setInterceptorNames(String[] interceptorNames) {
this.interceptorNames = interceptorNames;
}
pulic void setTarget(Object target) {
this.target = target;
}
public void afterPropertiesSet() throws Exception {
... Setter Injection 된 인스턴스 체크...
}
public Advisor getAdvisor(String interceptorName) {
Object advObject = beanFactory.getBean(interceptorName);
if(advObject instanceof Advisor) {
return (Advisor)advObject;
} else if(advObject instanceof Advice) {
return new DefaultPointcutAdvisor((Advice)advObject);
} else { 
return null;
}
}
public Object getObject() throws Exception { ... }
public Class getObjectType() { ... }
public boolean isSingleton() { ... }
}  

<beans>
...
<bean id="userDAOTarget">
...
</bean>
<bean id="userServiceTarget">
...
</bean>
<bean id="userLoggingadvisor">
...
</bean>
<bean id="userLoggingAdvice">
...
</bean>
<bean id="emailNotificationAdvisor">
...
</bean>
<bean id="meailNotificationThrowsAdvice">
...
</bean>
<bean id="userDAO" 
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target">
<ref local="userDAOTarget" />
</property>
<property name="interceptorNames">
<list>
<value>userLoggingadvisor</value>
</list>
</property>
</bean>
<bean id="userService" 
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target">
<ref local="userServiceTarget" />
</property>
<property name="interceptorNames">
<list>
<value>userLoggingadvisor</value>
<value>emailNotificationAdvisor</value>
</list>
</property> 
</bean>
...
</beans>

<beans>
...
<bean id="userDAO">
...
</bean>
<bean id="userService">
...
</bean>
<!-- Default Advisor를 기준으로 해당 패턴에 일치하는 모든 빈에 대해서 Advice 적용 -->
<bean id="proxyCreator" 
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
<bean id="userLoggingadvisor">
...
</bean>
<bean id="userLoggingAdvice">
...
</bean>
<bean id="emailNotificationAdvisor">
...
</bean>
<bean id="meailNotificationThrowsAdvice">
...
</bean>
...
</beans>

<beans>
...
<bean id="userDAO">
...
</bean>
<bean id="userService">
...
</bean>
<!-- BeanNameAutoProxyCreator 를 설정 -->
<bean id="proxyCreator" 
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*DAO</value>
<value>*Service</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>userLoggingadvisor</value>
<value>emailNotificationAdvisor</value>
</list>
</property>
</bean>
<bean id="userLoggingadvisor">
...
</bean>
<bean id="userLoggingAdvice">
...
</bean>
<bean id="emailNotificationAdvisor">
...
</bean>
<bean id="meailNotificationThrowsAdvice">
...
</bean>
...
</beans>

# insert, update, delete 관련 메소드

int update(String sql)

int update(String sql, Object[] args)

int update(String sql, Object[] args, int[] argTypes)

# select 관련 메소드

int queryForInt(String sql)

int queryForInt(String sql, Object[] args)

long queryForLong(String sql)

long queryForLong(String sql, Object[] args)

Object queryForObject(String sql, Class requiredType)

Object queryForObject(String sql, Object[] args, RowMapper rowMapper)

List queryForList(String sql)

LIst queryForList(String sql, Object[] args)

# PreparedStatementSetter 사용

PreparedStatementSetter psSetter = new PreparedStatementSetter() {

public void seValues(PreparedStatement ps)

throws SQLException{

.. 구현 ..

}

}

ResultReader resultReader = new ResultReader() {

List list = new ArrayList();

public void processRow(Result rs)

throws SQLException {

.. 구현 ..

}

public List getResults() {

return list;

}

}

List list = getJdbcTemplate().query(sql, psSetter, resultReader);

return list;

public class SelectByNo extends MappingSqlQuery {
public SelectByNo(DataSource ds, String sql) {
super(ds, sql);
declareParameter(new SqlParameter(Types.INTEGER));
}
public Object mapRow(ResultSet rs, int rownum)
throws SQLException {
.. 구현 ..
}
}
public Insert extends SqlUpdate {
public Insert(DataSource ds, String sql) {
super(ds, sql);
declareParameter(new SqlParameter(Types.VARCHAR));
declareParameter(new SqlParameter(Types.VARCHAR));
.. declareParameter() 정의 ..
}
}
//DAO 클래스 내에서
public class SpringDAO 
extends SpringDAOSupport
implements ISpringDAO {
private SelectByNo selectByNo;
private Insert insert;
public void initDAO() throws Exception {
super.initDAO(); 
this.selectByNo = new SelectByNo(getDataSource(), selectByNoSql);
this.insert = new Insert(getDataSource(), insertSql);
}
public int insert(int no, SpringVO vo)
throws Exception {
insert.update(new Object[] { vo.getName(), vo.getTitle(), .... });
int[] i = insert.flush();
return i[0];
}
public List selectByNo(int vono)
throws Exception {
return selectByNo.execute(vono);
}
...
}

<bean id="myJdbcDAOSupport" abstract="true" class="~~~~" >
<property name="dataSource" >
<ref local="dataSource" />
</property>
</bean>
<bean id="userDAO" parent="myJdbcDAOSupport" class="~~~" >
...
</bean>
<bean id="boardDAO" parent="myJdbcDAOSupport" class="~~~" >
...
</bean>  

- 프로젝트 규모에 따라 수평적 분리, 수직적 분리로 나눈다.
- 수평적 분리 :
User 컴퍼넌트 : applicationContext-user.xml ( UI, Business, Persistence 설정)
Board 컴퍼넌트 : applicatoinContext-board.xml ( UI, Business, Persistence 설정)
- 수직적 분리 : 
UI, Business, Persistence 계층별로 설정
- 위 두가지 방법다 장단점 내포
- 그러므로 빈설정파일 관리 전략에서 공통 모듈의 UI, Business, Persistence 계층의 abstract class 의 설정, 하위는 업무별(user, board)로 빈 설정파일을 관리함(수평적 분리 적용)

package org.springframework.transaction;
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition) 
throws TransactionException;
void commit(TransactionStatus status)
throws TransactionException;
void rollback(TransactionStatus status)
throws TransactionException;
}

PlatformTransactionManager 
|
AbstractPlatformTransactionManager
|        |          |        |
HibernateTransactionManager  |          |        |
DataSourceTransactionManager |        |
JmsTransactionManager |
JtaTransactionManager

=== applicationContext-jdbc.xml ===
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager" >
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" >
<property name="transactionManager" >
<ref bean="transactionManager" />
</property>
<property name="preInterceptors" >
<list>
<ref bean="loggingAdvice" />
<ref bean="emailNotificationThrowsAdvice" />
</list>
</property>
<property name="transactionAttributes" >
<props>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
=== applicationContext-board.xml ===
<bean id="boardServiceTarget" 
class="net.javajigi.board.service.BoardServiceImpl" >
<property name="boardDAO" >
<ref local="boardDAO" />
</property>
<property name="boardFileDAO" >
<ref local="boardFileDAO" />
</property>
</bean>
<bean id="boardService" parent="txProxyTemplate" >
<property name="target" >
<ref local="boardServiceTarget" />
</property>
<property name="transactionAttributes" >
<props>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED</prop>
<prop key="findBoardWithView">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>

PROPAGATION, ISOLATION, readOnly, -Exceptions, +Exceptions

전달행위(필수) 격리레벨(선택) readOnly유무(선택) Rollback규칙(선택)

- 전달행위 : 위 전달행위 중 하나 선택

- 격리레벨 : 위 격리레벨 중 하나 선택

- readOnly : select 쿼리 수행 시 설정

- Rollback 규칙 : Spring 에서는 디폴트 설정이 RuntimeException 이 발생하는 경우 Rollback, Checked Exception 이 발생하는 경우 Commit 되도록 하고 있음 (-) 로 시작되는 Exception 에 대해서는 무조건 Rollback, (+)로 시작되는 Exception 에 대해서는 무조건 Commit 되도록 규칙을 변경할 수 있음.

- ex) PROPAGATION_REQUIRED, ISOLATION_SERIALIZABLE, -net.javajigi.user.PasswordMismatchException

- AspectJ 메인 사이트 : http://www.eclipse.org/aspectj

- AspectJ 기반 개발환경을 지원하는 사이트 : http://www.eclipse.org/ajdt/

- AspectJ in Action(번역서 존재)

- Checked Exception 은 명시적으로 호출자의 예외발생에 따른 뭔가를 처리해 주어야 할때만 사용