Java代理及Spring AOP

Spring的AOP核心采用的设计模式采用的是代理模式,先介绍下Java的代理。

这里借鉴一下其他人的介绍,https://blog.csdn.net/fighterandknight/article/details/51200470

一 代理模式

代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。

1.静态代理

先定义接口是实现类:

public interface Test{  

        public void test();  

}
      
public class TestImpl implements Test{  

        @Override
        public void test() {
            System.out.println("测试方法...");  

        }  

    }  

添加代理类:

 1 public class TestProxy implements Test{
 2         private TestImpl testImpl;
 3
 4         /**
 5          * 覆盖默认构造器
 6          *
 7          *
 8          */
 9         public TestProxy (TestImpl testImpl) {
10             this.testImpl= testImpl;
11         }
12
13         @Override
14         public void test() {
15             System.out.println("事务处理之前");
16             // 调用委托类的方法;
17             testImpl.test();
18             System.out.println("事务处理之后");
19         }
20 }
21       

测试类:

1 public class TestCount {
2         public static void main(String[] args) {
3             TestImpl testImpl = new TestImpl ();
4             TestProxy testProxy = new TestProxy (testImpl );
5             testProxy.test();
6
7         }
8     }  

2.Jdk动态代理

只能对实现了接口的类生产代理,不能针对类。

定义代理:

 1 public class MyInvocationHandler implements InvocationHandler {
 2
 3
 4         //目标对象
 5         private Object target;
 6
 7         /**
 8          * 构造方法
 9          * @param target 目标对象
10          */
11         public MyInvocationHandler(Object target) {
12             super();
13             this.target=target;
14         }
15
16          * 执行目标对象的方法
17          */
18         public Object invoke(Object proxy, Method method, Object[] args)
19                 throws Throwable {
20
21              //在目标方法执行前简单打印一下
22              System.out.println("----------before----------");
23
24              //执行目标方法对象
25              Object result=method.invoke(target, args);
26
27              //在目标方法执行之后简单打印一下
28              System.out.println("----------after----------");
29
30              return result;
31         }
32
33
34         /**
35          * 获取目标对象的代理对象
36          * @return 代理对象
37          */
38         public Object getProxy(){
39             return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
40                     this.target.getClass().getInterfaces(),this);
41         }
42
43 }

测试类:

 1 public class ProxyTest{
 2
 3         @Test
 4         public void testProxy() throws Throwable{
 5             //实例化目标对象
 6             Test test=new TestImpl();
 7
 8             //实例化Invocation
 9             MyInvocationHandler invocationHandler=new MyInvocationHandler(test);
10
11             //根据目标生成代理对象
12             Test proxy=(Test)invocationHandler.getProxy();
13
14             //调用代理对象方法
15             proxy.test();
16         }
17 }

3.cglib代理

cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法,因为采用的是继承,所以不能对final修饰的类进行代理。

定义代理:

 1 public class CglibProxy implements MethodInterceptor {
 2     private Object target;
 3
 4     /**
 5      * 创建代理对象
 6      *
 7      * @param target
 8      * @return
 9      */
10     public Object getInstance(Object target) {
11         this.target = target;
12         Enhancer enhancer = new Enhancer();
13         enhancer.setSuperclass(this.target.getClass());
14         // 回调方法
15         enhancer.setCallback(this);
16         // 创建代理对象
17         return enhancer.create();
18     }
19
20     @Override
21     // 回调方法
22     public Object intercept(Object obj, Method method, Object[] args,
23             MethodProxy proxy) throws Throwable {
24         System.out.println("事物开始");
25         proxy.invokeSuper(obj, args);
26         System.out.println("事物结束");
27         return null;
28
29
30     }
31
32 }  

测试类:

public class TestCglib {  

    public static void main(String[] args) {
        CglibProxy cglib=new CglibProxy ();
        Testmpl testImpl=(Testmpl)cglib.getInstance(new Testmpl());
        testImpl.test();
    }  

二 Spring Aop

AOP利用一种称为"横切"的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性。

使用"横切"技术,AOP把软件系统分为两个部分:核心关注点横切关注点。业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处基本相似,比如权限认证、日志、事物。

Aop中的几个概念:

切面(Aspect) :官方的抽象定义为“一个关注点的模块化,这个关注点可能会横切多个对象”。
连接点(Joinpoint) :程序执行过程中的某一行为。
通知(Advice) :“切面”对于某个“连接点”所产生的动作。
切入点(Pointcut) :匹配连接点的断言,在AOP中通知和一个切入点表达式关联。
目标对象(Target Object) :被一个或者多个切面所通知的对象。
AOP代理(AOP Proxy) 在Spring AOP中有两种代理方式,JDK动态代理和CGLIB代理。

作用:

1、降低模块之间的耦合度

2、使系统容易扩展

3、更好的代码复用。

源码太多,就不一一列举了,源码分析可以参考:https://blog.csdn.net/hello_worldee/article/details/78136616

原文地址:https://www.cnblogs.com/jameszheng/p/10256680.html

时间: 01-11

Java代理及Spring AOP的相关文章

java框架篇---spring AOP 实现原理

什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善.OOP引入封装.继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合.当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力.也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系.例如日志功能.日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无

反射实现AOP动态代理模式(Spring AOP实现原理)

其实AOP的意思就是面向切面编程. OO注重的是我们解决问题的方法(封装成Method),而AOP注重的是许多解决问题的方法中的共同点,是对OO思想的一种补充! 还是拿人家经常举的一个例子讲解一下吧: 比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录. 我们写个例子看看我们最简单的解决方案 我们先写一个接口IHello.java代码如下: package sinosoft.dj.aop.st

java框架篇---spring aop两种配置方式

第一种:注解配置AOP 注解配置AOP(使用 AspectJ 类库实现的),大致分为三步: 1. 使用注解@Aspect来定义一个切面,在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around). 2. 开发需要被拦截的类. 3. 将切面配置到xml中,当然,我们也可以使用自动扫描Bean的方式.这样的话,那就交由Spring AoP容器管理. 另外需要引用 aspectJ 的 jar 包:

深入理解Spring AOP之基本概念

深入理解Spring AOP之基本概念 AOP到底是什么 Spring AOP和IOC是听到的关于Spring最频繁的两个词了.现在来重点关注AOP这个词,IOC先放一边,下面这段话摘自Spring优势中关于面向切面的介绍: 面向切面--Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发.应用对象只实现它们应该做的--完成业务逻辑--仅此而已.它们并不负责(甚至是意识)其它的系统级关

Spring AOP的实现原理

原文出处: Listen AOP(Aspect Orient Programming),我们一般称为面向方面(切面)编程,作为面向对象的一种补充,用于处理系统中分布于各个模块的横切关注点,比如事务管理.日志.缓存等等.AOP实现的关键在于AOP框架自动创建的AOP代理,AOP代理主要分为静态代理和动态代理,静态代理的代表为AspectJ:而动态代理则以Spring AOP为代表.本文会分别对AspectJ和Spring AOP的实现进行分析和介绍. 使用AspectJ的编译时增强实现AOP 之前

[转]彻底征服 Spring AOP 之 理论篇

基本知识 其实, 接触了这么久的 AOP, 我感觉, AOP 给人难以理解的一个关键点是它的概念比较多, 而且坑爹的是, 这些概念经过了中文翻译后, 变得面目全非, 相同的一个术语, 在不同的翻译下, 含义总有着各种莫名其妙的差别. 鉴于此, 我在本章的开头, 着重为为大家介绍一个 Spring AOP 的各项术语的基本含义. 为了术语传达的准确性, 我在接下来的叙述中, 能使用英文术语的地方, 尽量使用英文. 什么是 AOP AOP(Aspect-Oriented Programming),

java 代理实现方式

先讲一下概念,代理,什么是代理? 举个例子吧.很多人喜欢在淘宝或者天猫上淘一些生活用品或者衣服,这个购买过程就产生了本文的重点,代理.你知道你购买的商家叫什么名,但是不知道他后面的厂家是谁?这件衣服是哪个厂家卖给了你,你完全不知道,其实这个过程就是代理,厂家委托商家卖衣服给你,商家就是代理类,代理卖这个厂家这个品牌的衣服,厂家就是委托类,委托商家埋衣服.什么北京区代理,黑龙江总代理,都是这个方式的. 代理分为动态,和静态.先说说静态代理, //代理接口类 public interface Spi

[Java]Spring AOP基础知识-动态代理

Spring AOP使用动态代理技术在运行期织入增强的代码,为了揭示Spring AOP底层的工作机理,有必要对涉及到的Java知识进行学习.Spring AOP使用了两种代理机制:一种是基于JDK的动态代理:另一种是基于CGLib的动态代理.之所以需要两种代理机制,很大程度上是因为JDK本身只提供接口的代理,而不支持类的代理. 带有横切逻辑的实例 我们通过具体化代码实现上一节所介绍例子的性能监视横切逻辑,并通过动态代理技术对此进行改造.在调用每一个目标类方法时启动方法的性能监视,在目标类方法调

spring aop 动态代理批量调用方法实例

今天项目经理发下任务,需要测试 20 个接口,看看推送和接收数据是否正常.因为对接传输的数据是 xml 格式的字符串,所以我拿现成的数据,先生成推送过去的数据并存储到文本,以便验证数据是否正确,这时候要批量调用这些同名方法,我觉得这里可以发展成有潜力的代码. 推送比较好做数据,队友们都写好代码,但是有个问题,方法要的值都大致相同,封装的方式不一致,多人开发,有的封装对象里面,有的直接使用 Map.get(),唉,一千个人一千个哈姆雷特嘛,只好利用反射和动态代理节省自己的代码量,而且这种方式练练手

Spring AOP 实现原理(三) 使用 使用 CGLIB 生成代理类

CGLIB(Code Generation Library),简单来说,就是一个代码生成类库.它可以在运行时候动态是生成某个类的子类. 此处使用前面定义的 Chinese 类,现在改为直接使用 CGLIB 来生成代理,这个代理类同样可以实现 Spring AOP 代理所达到的效果. 下面先为 CGLIB 提供一个拦截器实现类: public class AroundAdvice implements MethodInterceptor { public Object intercept(Obje