AOP思想实例讲解

假设有一个系统，需要权限控制，按oo的方法，做个SecurityManager, just like this:

public class SecurityManager{
public bool checkPower(User user, AcessModel am){
///here to judge user if had access to system
return true;
}
}
然后在业务逻辑中进行如下调用：
public class BusinessClass{
public void businessMethod(){
SecurityManager sm= new SecurityManager();
if(sm.checkPower(user,am)){
///you had past the check
….
}
}
}
这就造成系统的权限校验与业务逻辑掺杂一起，耦合增加，使程序的鲁棒性大打折扣。。。
但如果我们用aop则会将其彻底改观，对于websharp,可以做如下更改：
public class BusinessClass ：AspectObject{

/* 继承AspectObject，去掉businessMethod()中的:
SecurityManager sm= new SecurityManager();
if(sm.checkPower(user,am)){
///you had past the check
….
}
*/
}

public class SecurityManager ：IAspect{
///implement IAspect interface by execute method as followed:
public void execute(Object[] paramList){
///here to judge user if had access to system
}
}
最后在配置文件中添加：
<Websharp-Aspects>
<Aspect type=”pack.SecurityManager,pack” deploy-model=”Singleton” pointcut-type=”Method” action-position=”before” match=”*,*”/>
</Websharp-Aspects >
以上你就已实现一个aop! 这样Security 和Business就独立了。。。感觉websharp里对AOP的概念可能局限于拦截器这一层.

任何应用程序都由多个功能性和系统性关注点（concern）组成。功能性关注点与应用程序的日常使用相关，而 系统性 关注点则与系统的整体健康和维护相关。例如，一个银行应用程序的功能性关注点包括账户维护和允许借/贷操作，它的系统性关注点包括安全、事务、性能和审计日志记录。即使使用最好的编程方法学来开发应用程序，您最终也会发现它的功能性和系统性关注点会以跨越多个应用程序模块的形式相互混杂在一起。。。
而横切作为AOP 技术，确保独立的关注点保持模块化，同时仍然足够灵活地在整个应用程序中的不同点应用。横切包括静态和动态两种类别。动态横切体现为通过在感兴趣的特定点织入（weave in）新的行为来改变对象的执行行为, 就是指方法拦截。静态横切允许我们通过注入（inject in）附加的方法和/或属性来直接改变对象的结构。静态横切和动态横切的区别在于它不修改一个给定对象的执行行为。相反，它允许通过引入附加的方法字段和属性来修改对象的结构。此外，静态横切可以把扩展和实现附加到对象的基本结构中.

AOP的典型组成：（由低到高）
连接点（join point）是程序中的某个特定执行点，比如某个类中的一个方法。指需要我们要注入职责的地方--最底层
切入点（point cut）是特定于语言的结构，它表示或捕捉某个特定的连接点, 确定具体植入位置，在职责前植入还是在后植入。
通知（advice）是在到达某个特定的切入点时要执行的一段代码（通常是一个横切功能）。
方面（aspect）是定义切入点和通知以及它们之间的映射的一个结构。方面由 AOP 编译器用来在现有对象中的特定

Spring中的AOP接口



我们希望通过一个自定义的Aspect，来为业务方法添加上Security 验证，与.net例子相同。
其主要思路是：通过定义业务接口，在业务接口的方法上（Joinpoint）添加该Aspect。 先定义业务接口，并实现业务方法：
public interface BusinessInf {
public void buzMethod();
}
public class BusinessImpl implements BusinessInf {
public void buzMethod ()
{
//here buz handling
}
}
然后定义一个拦截器，拦截器需要符合AOP Alliance的规范：
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class SecurityInterceptor implements MethodInterceptor
{
public Object invoke(MethodInvocation methodInvocation) throws Throwable
{
try
{
//here put your security codes if success, proceed, otherwise ,return.
Object retVal = methodInvocation.proceed();///go ahead next request, if past
return retVal;
}
}
}
然后，我们需要通过配置文件把这些bean组合起来：
<beans>
<bean id="bizImpl" class=" BusinessImpl " />
<bean id="securityIntercept" class="SecurityInterceptor " />
<bean id=" BusinessInf " class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces"><value> BusinessInf </value></property>
<property name="interceptorNames">
<list>
<value> securityIntercept </value>
<value> bizImpl</value>
</list>
</property>
</bean>
</beans>
AOP切面化是纵向的，多个访问类同时访问一个共享数据对象时，每个访问类在访问这个数据对象时，需要将数据对象上锁，访问完成后，再实行解锁，供其它并发线程访问，传统做法如图


而aop 后


如果你研究过AspectJ，可能对AOP更深入，时间关系，不做AspectJ的细述。
AOP可以应用的范围：
　 Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging, tracing, profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池
Synchronization　同步
Transactions 事务
甚至系统之间集成

注意：
AOP需要支持Aspect的容器，当然你也可以自己做一个：），任何一个东西或工具不能放之四海皆准，不要凡事都AOP,很有可能找成程序支零破碎，云里雾里，不易懂，一定要根据实际！

AOP思想深入：




通过 Aop思想来进行需求的Aspect分析，最后Aspect的架构，怎么样呢？最近在读《Aspect-Oriented Software Development With Use Cases》，读完后更新此部分如下：

AOP 包括三个清晰的开发步骤：
方面分解：分解需求撮出横切关注点。在这一步里，你把核心模块级关注点和系统级的横切关注点分离开来、就前面所提到的信用卡例子来说
你可以分解出三个关注点：核心的信用卡处理、日志和验证。
关注点实现：各自独立的实现这些关注点，还用上面信用卡的例子，你要实现信用卡处理单元、日志单元和验证单元。
方面的重新组合：在这一步里，方面集成器通过创建一个模块单元—一方面来指定重组的规则，重组过程—一也叫织入（weaving）或结合
（integrating）——则使用这些信息来构建最终系统、还拿信用卡的那个例子来说 你可以指定（用某种AOP的实现所提供的语言）每个操作的开始和结束需要记录，并且每个操作在涉及到业务逻辑之前必须通过验证。



看看这张图，你就可能理解AOP的架构设计，模块之间交呼完全通过AOP,而非特定的业务层，这种动态的分离要一直保持到最终的实现。