AOP 面向切面的编程

AOP 面向切面的编程
代理模式：为其他对象提供了一个代理以控制对这个对象的访问
代理模式一般涉及到的角色有
抽象角色：声明真实对象和代理对象的共同接口
代理角色：代理对象角色内部含有对真实对象的应用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代理真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象经行封装
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

如
1、设置一个 subject.Java为抽象角色
subject.Java：
package com.test.proxy;
// 抽象角色 声明了真实角色以及代理角色的公共类
public abstract class Subject
{
abstract public void request();
}
2、设置RealSubject为真实角色
RealSubject.java
package com.test.proxy;
//真实角色：实现了Subject的request()方法
public class RealSubject extends Subject
{
    public RealSubject()
    {
    }
    public void request()
    {
        System.out.println("From real subject.");
    }
}
3、设置ReoxySubject.java为代理角色
ReoxySubject.java
package com.test.proxy;
//代理角色
public class ProxySubject extends Subject
{
    private RealSubject realSubject; // 以真实角色作为代理角色的属性
    public ProxySubject()
    {
    }
    public void request() // 该方法封装了真实对象的request方法
    {
        preRequest();
        if (realSubject == null)
        {
            realSubject = new RealSubject();
        }
        realSubject.request(); // 此处执行真实对象的request方法
        postRequest();
    }
    private void preRequest()
    {
        // something you want to do before requesting
    }
    private void postRequest()
    {
        // something you want to do after requesting
    }
}
4、客户端调用方法
package com.test.proxy;
//客户端调用
public class Client
{
    public static void main(String[] args)
    {
        Subject sub = new ProxySubject();
        sub.request();
    }
}
当运行时运行的是代理类 而代理类封装了真实角色的方法
动态代理模式：
只能动态代理接口不能动态代理类
步骤：
1. 创建一个实现接口InvocationHandler的类它必须实现invoke方法
2. 创建被代理的类以及接口
3. 通过Proxy的静态方法 newProxyInstance（ClassLoader loader，Class[] interfaces,InvocationHandler  h）创建一个代理
4. 通过代理调用方法
如
1、同样Subject.java为抽象角色
package com.test.dynamicproxy;
//抽象角色(之前是抽象类，此处应改为接口)：
public interface Subject
{
    public void request();
}
2、RealSubject.java为真实角色
package com.test.dynamicproxy;
//具体角色
public class RealSubject implements Subject
{
    public RealSubject()
    {
    }
    public void request()
    {
        System.out.println("From real subject.");
    }
}
3、DynamicSubject.Java为代理类
package com.test.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//代理处理器

/**
* 该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；
* 此外，在该类还实现了invoke方法，该方法中的 method.invoke(sub,args);
* 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象， args为执行被代理对象相应操作所需的参数。
* 通过动态代理类，我们可以在调用之前或之后执行一些相关操作
*/

public class DynamicSubject implements InvocationHandler
{
private Object sub;
public DynamicSubject()
{
}
public DynamicSubject(Object obj)
{
sub = obj;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
System.out.println("before calling " + method);
method.invoke(sub, args);
System.out.println("after calling " + method);
return null;
}
}
4、客户调用Client.java类
package com.test.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
//客户端
public class Client
{
public static void main(String[] args) throws Throwable
{
RealSubject rs = new RealSubject(); // 在这里指定被代理类
InvocationHandler ds = new DynamicSubject(rs);
Class<?> cls = rs.getClass();
// 以下是一次性生成代理
Subject subject = (Subject) Proxy.newProxyInstance(
cls.getClassLoader(), cls.getInterfaces(), ds);
subject.request();
}
}

AOP技术本质
1、 join point（连接点）：是程序执行中的一个精确执行点，列如类中的一个方法。他是一个抽象的概念，在实现AOP时，并不确定去定义一个join point。
2、 point cut（切入点）：本质是一个人捕获连接点的结构。在AOP中可以定义一个point cut，来捕获相关的方法调用。
3、 advice（通知）：是point cut的执行码，是执行方面的具体逻辑。
4、 aspect（方面）：point cut和advice结合起来就是aspect，它类似oop中的一个类，但它代表的更多是对象间横向的关系
5、 introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的AOP工具又将其称为mixin