AOP概念:

  Aspect Oriented Programming(AOP),面向切面编程。AOP主要实现的目的是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段,以获得逻辑过程中各部分之间低耦合性的隔离效果。比如我们最常见的就是日志记录了,举个例子,我们现在提供一个服务查询学生信息的,但是我们希望记录有谁进行了这个查询。如果按照传统的OOP的实现的话,那我们实现了一个查询学生信息的服务接口(StudentInfoService)和其实现类(StudentInfoServiceImpl.java),同时为了要进行记录的话,那我们在实现类(StudentInfoServiceImpl.java)中要添加其实现记录的过程。这样的话,假如我们要实现的服务有多个呢?那就要在每个实现的类都添加这些记录过程。这样做的话就会有点繁琐,而且每个实现类都与记录服务日志的行为紧耦合,违反了面向对象的规则。那么怎样才能把记录服务的行为与业务处理过程中分离出来呢?看起来好像就是查询学生的服务自己在进行,但却是背后日志记录对这些行为进行记录,并且查询学生的服务不知道存在这些记录过程,这就是我们要讨论AOP的目的所在。AOP的编程,好像就是把我们在某个方面的功能提出来与一批对象进行隔离,这样与一批对象之间降低了耦合性,可以就某个功能进行编程。

 

切面(Aspect):一个关注点的模块化,这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中,切面可以使用基于模式或者基于注解的方式来实现。

连接点(Joinpoint):在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。在Spring AOP中,一个连接点总是表示一个方法的执行。

通知(Advice):在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知。许多AOP框架(包括Spring)都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链。

切入点(Pointcut):匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时)。切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法。

引入(Introduction):用来给一个类型声明额外的方法或属性(也被称为连接类型声明(inter-type declaration))。Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,你可以使用引入来使一个bean实现IsModified接口,以便简化缓存机制。

目标对象(Target Object): 被一个或者多个切面所通知的对象。也被称做被通知(advised)对象。既然Spring AOP是通过运行时代理实现的,这个对象永远是一个被代理(proxied)对象。

AOP代理(AOP Proxy):AOP框架创建的对象,用来实现切面契约(例如通知方法执行等等)。在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。

织入(Weaving):把切面连接到其它的应用程序类型或者对象上,并创建一个被通知的对象。这些可以在编译时(例如使用AspectJ编译器),类加载时和运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。

 

通过前置通知例子先学习用法

假设有一个接口TestServiceInter有一个方法sayHello,它有两个实现类Test1Service和Test2Service,现在需要实现在调用sayHello之前完成拦截,实现相关日志的记录,相关的关系图如下:

 

 

 

 

1、创建被代理对象(目标对象)

TestServiceInter.java

package com.aop;  
public interface TestServiceInter {  
  
    public void sayHello();  
} 

Test1Service.java

public class Test1Service implements TestServiceInter {  
  
    private String name;  
      
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public void sayHello() {  
        // TODO Auto-generated method stub  
        System.out.println("hi "+name);  
    }  
  
}  

 

2、创建前置通知(拦截器)

import java.lang.reflect.Method;  
  
import org.springframework.aop.MethodBeforeAdvice;  
  
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {  
  
    /** 
     * method: 被调用方法名字 
     * args: 给method传递的参数 
     * target: 目标对象 
     */  
    public void before(Method method, Object[] args, Object target)  
            throws Throwable {  
        // TODO Auto-generated method stub  
        System.out.println("记录日志..."+method.getName());  
  
    }  
  
}  

3、配置代理对象ProxyFactoryBean

在bean.xml中配置通知,被代理对象,以及将通知织入代理对象中

 

配置文件(bean.xml)需要配置三种对象:

1、被代理对象(被拦截的对象)。

2、通知(拦截器,,如统一的日志组件,流控组件),

3、代理对象(ProxyFactoryBean,实现方法调用前的拦截),

<!-- 配置被代理的对象 -->  
<bean id="test1Service" class="com.aop.Test1Service">  
<property name="name" value="顺平" />  
</bean>  
<!-- 配置通知 --> <bean id="MyMethodBeforeAdvice" class="com.aop.MyMethodBeforeAdvice" />

<!-- 配置代理对象 --> <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- 代理接口集 --> <property name="proxyInterfaces"> <list> <value>com.aop.TestServiceInter</value> </list> </property> <!-- 把通知织入到代理对象 --> <property name="interceptorNames"> <!-- 相当于包MyMethodBeforeAdvice前置通知和代理对象关联,我们也 可以把通知看出拦截器 --> <value>MyMethodBeforeAdvice</value> </property> <!-- 配置被代理对象,可以指定 --> <property name="target" ref="test1Service"/> </bean> </beans>

 

4、main方法里使用

ApplicationContext ac=new ClassPathXmlApplicationContext("com/aop/beans.xml");  
TestServiceInter ts=(TestServiceInter) ac.getBean("proxyFactoryBean");  
ts.sayHello(); 

 

 

 

 

 

AOP 主要是利用代理模式的技术来实现的。

1、静态代理:就是设计模式中的proxy模式

a、业务接口

复制代码
/**
 * 抽象主题角色:声明了真实主题和代理主题的共同接口。
 * 
 * @author yanbin
 * 
 */
public interface ITalk {

    public void talk(String msg);

}
复制代码

b、业务实现

复制代码
/**
 * 真实主题角色:定义真实的对象。
 * 
 * @author yanbin
 * 
 */
public class PeopleTalk implements ITalk {

    public String username;
    public String age;

    public PeopleTalk(String username, String age) {
        this.username = username;
        this.age = age;
    }

    public void talk(String msg) {
        System.out.println(msg + "!你好,我是" + username + ",我年龄是" + age);
    }

    public String getName() {
        return username;
    }

    public void setName(String name) {
        this.username = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

}
复制代码

c、代理对象

复制代码
/**
 * 代理主题角色:内部包含对真实主题的引用,并且提供和真实主题角色相同的接口。
 * 
 * @author yanbin
 * 
 */
public class TalkProxy implements ITalk {

    private ITalk talker;

    public TalkProxy(ITalk talker) {
        // super();
        this.talker = talker;
    }

    public void talk(String msg) {
        talker.talk(msg);
    }

    public void talk(String msg, String singname) {
        talker.talk(msg);
        sing(singname);
    }

    private void sing(String singname) {
        System.out.println("唱歌:" + singname);
    }

}
复制代码

d、测试类

复制代码
/**
 * 代理测试类,使用代理
 *
 * @author yanbin
 * 
 */
public class ProxyPattern {

    public static void main(String[] args) {
        // 不需要执行额外方法的。
        ITalk people = new PeopleTalk("AOP", "18");
        people.talk("No ProXY Test");
        System.out.println("-----------------------------");

        // 需要执行额外方法的(切面)
        TalkProxy talker = new TalkProxy(people);
        talker.talk("ProXY Test", "代理");
    }

}
复制代码

从这段代码可以看出来,代理模式其实就是AOP的雏形。 上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。

这样就实现了,其他的辅助方法和业务方法的解耦。业务不需要专门去调用,而是走到talk方法,顺理成章的调用sing方法

再从这段代码看:1、要实现代理方式,必须要定义接口。2、每个业务类,需要一个代理类。

2、动态代理:jdk1.5中提供,利用反射。实现InvocationHandler接口。

业务接口还是必须得,业务接口,业务类同上。

a、代理类:

复制代码
/**
 * 动态代理类
 * 
 * @author yanbin
 * 
 */
public class DynamicProxy implements InvocationHandler {

    /** 需要代理的目标类 */
    private Object target;

    /**
     * 写法固定,aop专用:绑定委托对象并返回一个代理类
     * 
     * @param delegate
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * @param Object
     *            target:指被代理的对象。
     * @param Method
     *            method:要调用的方法
     * @param Object
     *            [] args:方法调用时所需要的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        // 切面之前执行
        System.out.println("切面之前执行");
        // 执行业务
        result = method.invoke(target, args);
        // 切面之后执行
        System.out.println("切面之后执行");
        return result;
    }

}
复制代码

b、测试类

复制代码
/**
 * 测试类
 * 
 * @author yanbin
 * 
 */
public class Test {

    public static void main(String[] args) {
        // 绑定代理,这种方式会在所有的方法都加上切面方法
        ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());
        iTalk.talk("业务说明");
    }
}
复制代码

输出结果会是:

切面之前执行
people talk业务说法
切面之后执行

说明只要在业务调用方法切面之前,是可以动态的加入需要处理的方法。

从代码来看,如果再建立一个业务模块,也只需要一个代理类。ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());  将业务接口和业务类绑定到动态代理类。

但是这种方式:还是需要定义接口。

3、利用cglib

CGLIB是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强。采用的是继承的方式。不细说,看使用

a、业务类

复制代码
/**
 * 业务类
 * 
 * @author yanbin
 * 
 */
public class PeopleTalk {

    public void talk(String msg) {
        System.out.println("people talk" + msg);
    }

}
复制代码

b、cglib代理类

复制代码
/**
 * 使用cglib动态代理
 * 
 * @author yanbin
 * 
 */
public class CglibProxy implements MethodInterceptor {

    private Object target;

    /**
     * 创建代理对象
     * 
     * @param target
     * @return
     */
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        System.out.println("事物开始");
        result = methodProxy.invokeSuper(proxy, args);
        System.out.println("事物结束");
        return result;
    }

}
复制代码

c.测试类

复制代码
/**
 * 测试类
 * 
 * @author yanbin
 * 
 */
public class Test {

    public static void main(String[] args) {
        PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk());
        peopleTalk.talk("业务方法");
        peopleTalk.spreak("业务方法");
    }

}
复制代码

最后输出结果:

事物开始
people talk业务方法
事物结束
事物开始
spreak chinese业务方法
事物结束

 

 

 

 

参考:

韩顺平老师Spring视频

http://www.cnblogs.com/yanbincn/archive/2012/06/01/2530377.html

 

 posted on 2016-08-05 11:01  布鲁布鲁sky  阅读(227)  评论(0编辑  收藏  举报