Spring AOP总结
[code]
Spring AOP(Aspect Oriented Programming)

应用程序通常包含两种代码：一是核心业务代码，一是和业务关系不大的代码如日志、事物处理等。
AOP的思想就是使这两种代码分离，从而降低了两种代码的偶合性，达到了易于重用和维护的目的。
AOP和OOP：
在AOP里，每个关注点的实现并不知道是否有其他关注点关注它，这是AOP和OOP的主要区别，
在AOP里组合的流向是从横切关注点到主关注点，在OOP中组合流向是从主关注点到横切关注点。
AOP和OOP所关注的对象不同，AOP是OOP有益的补充，不是对立面。

AOP的3个关键概念：
1：切入点：（PiontCut)
连接点（Jion piont)：是指程序运行中的某个阶段，如方法的调用、异常的抛出等。
PiontCut就是Jion piont点的集合，它是程序中需要注入的Advice的集合。指明Advice
在什么 条件下才被触发。
2：通知（Advice):
某个连接点采用的处理逻辑，也就是向连接点注入的代码。
3：Advisor
是PiontCut和Advice的配置器，它包含PiontCut和Advice，是把Advice注入到PiontCut位置的代码。


Spring 的3种切入点的实现：
1：静态切入点：
静态切入点只限于给定的方法和目标类。不考虑方法的参数。
2：动态切入点：
动态切入点不仅限于给定的方法和目标类，还可以指定方法的参数。
动态切入点有很大的性能损耗，一般很少使用。
3：自定义切入点：
正在发展


Spring 的通知：
1：Interception Around通知

Interception Around在Jion Point的前后执行。实现Interception Around通知要实现
MethodInterceptor接口，示例代码如下：
(1)Logger logger=Logger.getLogger(this.getClass().getName());

public Object invoke(MethodInvocation arg0) throws Throwable {
// TODO Auto-generated method stub
logger.log(Level.INFO,arg0.getArguments()[0]+"开始审核数据:");
Object result=arg0.proceed();
logger.log(Level.INFO,arg0.getArguments()[0]+"审核数据结束!");

return result;
}

(2)
/* public class LoginInterceptor implements MethodInterceptor{
public Object invoke(MenthodInvocation invocation) throws Throwable{
System.out.println("开始审核数据");
Object result = invocation.proceed();
System.out.println("审核数据结束");
return result;
}
}*/

2:Before通知
(1)通过log4j.properties实现
Logger logger=Logger.getLogger(this.getClass().getName());

public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
// TODO Auto-generated method stub
logger.log(Level.INFO,arg1[0]+"开始数据操作:");

}
(2):
Before通知在JiontPoint的前执行。实现Befored通知要实现
MethodBeforeAdvice接口，示例代码如下：
public class LoginBeforeAdvice implements MethodBeforeAdvice{
public void before(Menthod m,Object [] atgs,Object target) throws Throwable{
System.out.println("开始审核数据");
}
}


3:After Return 通知

After Return通知在JiontPoint后执行。实现After Returnd通知要实现
AfterReturningAdvice接口，示例代码如下：
public class LoginAfterAdvice implements AfterReturningAdvice{
public void afterReturning(Method m,Object [] atgs,Object target) throws Throwable{
System.out.println("审核数据结束");
}
}

4:Throw通知
(1)Logger logger=Logger.getLogger(this.getClass().getName());
public void afterThrowing(Method arg1, Object[] arg2,Object arg3,Throwable subclass ) throws Throwable{
System.out.println(arg2[0]+"审核数据异常");
}

Throw通知在JiontPoint抛出异常时执行。实现Throw通知要实现
ThrowsAdvice接口，示例代码如下：
public class LoginThrowAdvice implements ThrowsAdvice{
public void afterThrowing(Method arg1, RemoteException ex) throws Throwable{
System.out.println("审核数据异常");
}
}

5：Introduction 通知

Introduction通知在JiontPoint 调用完毕后执行。实现Introduction通知要实现
IntroductionAdvisor接口和IntroductionInterceptor接口。

用ProxyFactoryBean创建AOP代理
使用org.springfamework.aop.framework.ProxyFactoryBean是创建AOP代理的基本方式。

1：使用ProxyFactoryBean代理目标类中的所有方法(参考代码：workspace20070228\SpringAOP1)
示例代码：
<beans>
<bean id="log" class="logAround"/>
<bean id="logBefore" class="logBefore"/>
<bean id="logAfter" class="logAfter"/>
<bean id="logThrow" class="logThrow"/>
<bean id="timebook" class="TimeBook"/>
<!-设定代理类-->
<bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean">
<!--代理的是接口-->
<property name="proxyInterfaces">
<value>TimeBookInterface</value>
</property>
<!--要代理的目标类-->
<property name="target">
<ref bean="timebook"/>
</property>
<!--程序中的Advice-->
<property name="interceptorNames">
<list>
<value>logBefore</value>
<value>logAfter</value>
<value>logThrow</value>
</list>
</property>
</bean>
</beans>


2：使用ProxyFactoryBean代理目标类中的指定方法

示例代码：
<beans>
<bean id="log" class="logAround"/>
<bean id="logBefore" class="logBefore"/>
<bean id="logAfter" class="logAfter"/>
<bean id="logThrow" class="logThrow"/>
<bean id="timebook" class="TimeBook"/>
<!--代理目标类的指定方法-->
<bean id ="logAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref bean="log"/>
</property>
<!--指定要代理的方法-->
<property name="patterns">
<value>.*doCheck.*</value>
</property>
</bean>
<!-设定代理类-->
<bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean">

<!--要代理的目标类-->
<property name="target">
<ref bean="timebook"/>
</property>
<!--程序中的Advice-->
<property name="interceptorNames">
<list>
<value>logAdvisor</value>
</list>
</property>
</bean>
</beans>

---------------------------------------------------------

正则表达式：
1：.表示可以匹配任何一个字符
2：[]表示只有[]里指定的字符才能匹配
3：*表示匹配次数
4：？表示可以匹配1或0次
5：\是正则表达式的连接符

---------------------------------------------------------------
Spring 中两种AOP代理方式
1:动态代理
动态代理是指代理的是接口，Spring默认的是动态代理
2：CGLIB代理
<beans>
<bean id="log" class="logAround"/>
<bean id="logBefore" class="logBefore"/>
<bean id="logAfter" class="logAfter"/>
<bean id="logThrow" class="logThrow"/>
<bean id="timebook" class="TimeBook"/>
<bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyTargetClass">
<value>true</value>
</property>
<property name="target">
<ref bean="timebook"/>
</property>
<property name="interceptorNames">
<list>
<value>logBefore</value>
<value>logAfter</value>
<value>logThrow</value>
</list>
</property>
</bean>
</beans>

-----------------------------------------------------------------------
Spring 中的自动代理方式

自动代理可以跨越多个类，不管哪个类中的方法只要符合要求都可以代理
<beans>
<bean id="log" class="logAround"/>
<bean id="logBefore" class="logBefore"/>
<bean id="logAfter" class="logAfter"/>
<bean id="logThrow" class="logThrow"/>
<bean id="timebook" class="TimeBook"/>
<bean id="timework" class="TimeWork"/>
<!--使用自动代理-->
<bean id="autoProxy" class ="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
<bean id="logBeforAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref bean="logBefore"/>
</property>
<property name="patterns">
<value>.*do.*</value>
</property>
</bean>
</beans>

------------------------------------------------------------
Spring中的事务处理

事务处理是由多个步骤组成，这些步骤之间有一定的逻辑关系，作为一个整体的操作过程，所有的步骤必须同时成功或失败。
1：提交 当所有的操作步骤都被完整执行后，称为该事物被提交。
2：回滚 由于某个操作失败，导致所有的步骤都没被提交则事物必须回滚，回到事物执行前的状态。

事务的特性：
ACID：原子性（Atomicity)一致性(Consistency）隔离性（Isolation)持久性(Durablity)

Spring中的事务处理是基于动态AOP机制的实现。

1：编程式事务处理：

spring 提供的TransactionTemplate能够以编程的方式实现事务控制。

HelloADO.java:
private DataSource dataSource;
private PlatformTransactionManager transactionManager;
public int create(String msg){
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
TransactionStatus status = transactionManager.getTransaction(def);

try{
JdbcTemplate jt = new JdbcTemplate(dataSource);
int i=jt.update("insert into st(name,password) values('zz','zz')");
return i;
}catch (Exception e){
transactionManager.rollback(status);
return 0;
}
finally {
transactionManager.commit(status);
}
}
applicationContext.xml

<beans>
<bean id ="dataSource" class ="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/newdb</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>lxl</value>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<bean id="helloDAO" class ="HelloDAO">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
</bean>
</beans>

2：声明式事务处理：

HelloADO.java:

public class HelloDAO {
private DataSource dataSource ;
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
jdbcTemplate = new JdbcTemplate(dataSource);
}
public void create(String name){
jdbcTemplate.update("insert into st(name,password)values('lxl','lxl')");
}
}
applicationContext.xml
<beans>
<bean id ="dataSource" class ="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/newdb</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>lxl</value>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<bean id="helloDAO" class ="HelloDAO">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<!-- 声明式事务处理-->
<bean id="helloDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="target">
<ref bean="helloDAO"/>
</property>
<property name="transactionAttributes">
<props>
<!-- 对create方法进行事务管理，PROPAGATION_REQUIRED表示如果没有事务就新建一个事务-->
<prop key="create*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
</beans>
[/code]