AOP小结

AOP主要采用代理模式来实现的,静态代理(设计模式中的代理模式),动态代理(反射机制,实现InvocationHandler接口),cglib实现(采用继承方式,针对目标类生成子类,并覆盖方法进行增强)

AOP将那些与业务核心不大相关的杂七杂八的东西独立开,每次实现了业务核心之前或之后,调用一下对应的方法

JDK动态代理和CGLIB字节码生成的区别?
* JDK动态代理只能对实现了接口的类生成代理,而不能针对类

* CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法

  因为是继承,所以该类或方法最好不要声明成final

应用场景:操作日志,安全监测,事务处理等等​

Aspect Oriented Programming  面向切面编程。解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。

具体思想是:定义一个切面,在切面的纵向定义处理方法,处理完成之后,回到横向业务流。

AOP 在Spring框架中被作为核心组成部分之一,的确Spring将AOP发挥到很强大的功能。最常见的就是事务控制。工作之余,对于使用的工具,不免需要了解其所以然。学习了一下,写了些程序帮助理解。

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业务方法
事物结束

(能代理接口和类,但是使用麻烦,不能代理final类)

AOP小结

AOP小结AOP小结

AOP小结

AOP小结

上一篇:elasticsearch Java Client用户指南


下一篇:Python学习笔记五:错误与异常