您的位置:

学习aop之java的代理机制(aop jdk动态代理原理)

本文目录一览:

spring中aop的动态代理机制有哪些

1.事务管理: (1)数据库事务:(2)编程事务(3)声明事物:Spring AOP--声明事物

2.日志处理:

3.安全验证: Spring AOP---OOP升级

静态代理原理:目标对象:调用业务逻辑 代理对象:日志管理

表示层调用---代理对象(日志管理)--调用目标对象

动态代理原理:spring AOP采用动态代理来实现

(1)实现InvocationHandler接口

(2)创建代理类(通过java API)

Java实现AOP的几种方式

(1)AOP的各种实现

在编译器修改源代码、在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码。以下是各种实现机制的比较:

类别分为静态AOP(包括静态织入)和动态AOP(包括动态代理、动态字节码生成、自定义类加载器、字节码转换)。

静态织入:

a、原理:在编译期,切面直接以字节码形式编译到目标字节码文件中 ;

b、优点:对系统性能无影响;

c、缺点:不够灵活;

动态代理 :

a、原理:在运行期,目标类加载后,为接口动态生成代理类。将切面织入到代理类中;

b、优点:更灵活;

c、缺点:切入的关注点要实现接口;

如何使用Proxy模式及Java内建的动态代理机制

在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾。

在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class),这一个类和接口是实现我们动态代理所必须用到的。首先我们先来看看java的API帮助文档是怎么样对这两个类进行描述的:

InvocationHandler:

InvocationHandler is the interface implemented by the invocation handler of a proxy instance.

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法:

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数,那么这三个参数分别代表什么呢?

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:指代我们所代理的那个真实对象

method:指代的是我们所要调用真实对象的某个方法的Method对象

args:指代的是调用真实对象某个方法时接受的参数

如果不是很明白,等下通过一个实例会对这几个参数进行更深的讲解。

接下来我们来看看Proxy这个类:

Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

Proxy这个类的作用就是用来动态创建一个代理对象的类,它提供了许多的方法,但是我们用的最多的就是 newProxyInstance 这个方法:

public static Object newProxyInstance(ClassLoader loader, Class?[] interfaces, InvocationHandler h) throws IllegalArgumentException

Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.

这个方法的作用就是得到一个动态的代理对象,其接收三个参数,我们来看看这三个参数所代表的含义:

public static Object newProxyInstance(ClassLoader loader, Class?[] interfaces, InvocationHandler h) throws IllegalArgumentException

loader:一个ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载

interfaces:一个Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口,如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了

h:一个InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上

好了,在介绍完这两个接口(类)以后,我们来通过一个实例来看看我们的动态代理模式是什么样的:

首先我们定义了一个Subject类型的接口,为其声明了两个方法:

public interface Subject

{

public void rent();

public void hello(String str);

}

接着,定义了一个类来实现这个接口,这个类就是我们的真实对象,RealSubject类:

public class RealSubject implements Subject

{

@Override

public void rent()

{

System.out.println("I want to rent my house");

}

@Override

public void hello(String str)

{

System.out.println("hello: " + str);

}

}

下一步,我们就要定义一个动态代理类了,前面说个,每一个动态代理类都必须要实现 InvocationHandler 这个接口,因此我们这个动态代理类也不例外:

public class DynamicProxy implements InvocationHandler

{

// 这个就是我们要代理的真实对象

private Object subject;

// 构造方法,给我们要代理的真实对象赋初值

public DynamicProxy(Object subject)

{

this.subject = subject;

}

@Override

public Object invoke(Object object, Method method, Object[] args)

throws Throwable

{

//在代理真实对象前我们可以添加一些自己的操作

System.out.println("before rent house");

System.out.println("Method:" + method);

// 当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用

method.invoke(subject, args);

//在代理真实对象后我们也可以添加一些自己的操作

System.out.println("after rent house");

return null;

}

}

最后,来看看我们的Client类:

public class Client

{

public static void main(String[] args)

{

// 我们要代理的真实对象

Subject realSubject = new RealSubject();

// 我们要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法的

InvocationHandler handler = new DynamicProxy(realSubject);

/*

* 通过Proxy的newProxyInstance方法来创建我们的代理对象,我们来看看其三个参数

* 第一个参数 handler.getClass().getClassLoader() ,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象

* 第二个参数realSubject.getClass().getInterfaces(),我们这里为代理对象提供的接口是真实对象所实行的接口,表示我要代理的是该真实对象,这样我就能调用这组接口中的方法了

* 第三个参数handler, 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上

*/

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject

.getClass().getInterfaces(), handler);

System.out.println(subject.getClass().getName());

subject.rent();

subject.hello("world");

}

}

我们先来看看控制台的输出:

$Proxy0

before rent house

Method:public abstract void com.xiaoluo.dynamicproxy.Subject.rent()

I want to rent my house

after rent house

before rent house

Method:public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

hello: world

after rent house

我们首先来看看 $Proxy0 这东西,我们看到,这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的,那么为什么我们返回的这个代理对象的类名是这样的呢?

Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject

.getClass().getInterfaces(), handler);

可能我以为返回的这个代理对象会是Subject类型的对象,或者是InvocationHandler的对象,结果却不是,首先我们解释一下为什么我们这里可以将其转化为Subject类型的对象?原因就是在newProxyInstance这个方法的第二个参数上,我们给这个代理对象提供了一组什么接口,那么我这个代理对象就会实现了这组接口,这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个,因为这里的接口是Subject类型,所以就可以将其转化为Subject类型了。

同时我们一定要记住,通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象,它并不是我们的InvocationHandler类型,也不是我们定义的那组接口的类型,而是在运行是动态生成的一个对象,并且命名方式都是这样的形式,以$开头,proxy为中,最后一个数字表示对象的标号。

接着我们来看看这两句

subject.rent();

subject.hello("world");

这里是通过代理对象来调用实现的那种接口中的方法,这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行,而我们的这个 handler 对象又接受了一个 RealSubject类型的参数,表示我要代理的就是这个真实对象,所以此时就会调用 handler 中的invoke方法去执行:

public Object invoke(Object object, Method method, Object[] args)

throws Throwable

{

//在代理真实对象前我们可以添加一些自己的操作

System.out.println("before rent house");

System.out.println("Method:" + method);

// 当代理对象调用真实对象的方法时,其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用

method.invoke(subject, args);

//在代理真实对象后我们也可以添加一些自己的操作

System.out.println("after rent house");

return null;

}

我们看到,在真正通过代理对象来调用真实对象的方法的时候,我们可以在该方法前后添加自己的一些操作,同时我们看到我们的这个 method 对象是这样的:

public abstract void com.xiaoluo.dynamicproxy.Subject.rent()

public abstract void com.xiaoluo.dynamicproxy.Subject.hello(java.lang.String)

正好就是我们的Subject接口中的两个方法,这也就证明了当我通过代理对象来调用方法的时候,起实际就是委托由其关联到的 handler 对象的invoke方法中来调用,并不是自己来真实调用,而是通过代理的方式来调用的。

这就是我们的java动态代理机制

java编程,spring里ioc和aop用什么原理实现的

控制反转(IOC)

(理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”)

1、Ioc—Inversion of Control:即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。

2、谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象即由Ioc容器来控制对象的创建。

谁控制谁?当然是IoC 容器控制了对象。

控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等)。

3、为何是反转,哪些方面反转了: 有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象。

为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转。

哪些方面反转了?依赖对象的获取被反转了。

还是不明白没事,下面搞个简单案例来说就懂啦 !!!

例子:当我们在任何一个有实际开发意义的程序项目中,我们会使用很多类来描述他们特有的功能,并且通过类与类之间的相互协作来完成特定的业务逻辑。这个时候,每个类都需要负责管理与自己有交互的类的引用和依赖,代码将会变的异常难以维护和极高的高耦合。而IOC的出现正是用来解决这个问题,我们通过IOC将这些依赖对象的创建、协调工作交给spring容器去处理,每个对象值需要关注其自身的业务逻辑关系就可以了。在这样的角度上来看,获得依赖的对象的方式,进行了反转,变成了由spring容器控制对象如何获取外部资源(包括其他对象和文件资料等)。

总的来说:IOC就是通过在Xml配置文件里依赖注入来解决代码问题。

IOC的注入类型有几种?主要可以划分为三种:构造函数注入、属性注入和接口注入。Spring支持构造函数注入和属性注入

面向切面(AOP)

(面向切面编程,AOP其实只是OOP的补充而已,AOP基本上是通过代理机制实现的。)

我们管切入到指定类指定方法的代码片段称为切面,而切入到哪些类、哪些方法则叫切入点。有了AOP,我们就可以把几个类共有的代码,抽取到一个切片中,等到需要时再切入对象中去,从而改变其原有的行为。

我们都知道 Java 是 OOP-面向对象编程的,它有自己的优势,也有自己的不足。比如说:在我们开发中,都会有一条业务主线(即客户的需求)。而我们要做的就是实现这个主线上的需求。我们在实现这些功能的时候,经常要干一些额外的不可避免的事情,比如事务的管理,日志的记录等,就很繁杂且代码量增多,所以 Spring 提供了另一种角度来思考程序结构,也就是把这一些事情剥离出来,然后适时适地的把它们加入到我们的代码中,比如说 声明式事务管理的时候,我们在 service 层检测到save*、update*这些方法要被调用的时候,我们先进行开启事务什么的,这就是AOP,面向编程的思想。

AOP的术语:

1、通知(Advice):就是你想要的功能,也就是上面说的 安全,事物,日志等。你给先定义好把,然后在想用的地方用一下

2、连接点(JoinPoint):这个更好解释了,就是spring允许你使用通知的地方,那可真就多了,基本每个方法的前,后(两者都有也行),或抛出异常时都可以是连接点,spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行,不过那不是咱关注的,只要记住,和方法有关的前前后后(抛出异常),都是连接点。

3、切入点(Pointcut):上面说的连接点的基础上,来定义切入点,你的一个类里,有15个方法,那就有几十个连接点了对把,但是你并不想在所有方法附近都使用通知(使用叫织入,以后再说),你只想让其中的几个,在调用这几个方法之前,之后或者抛出异常时干点什么,那么就用切点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法。

4、切面(Aspect):切面是通知和切入点的结合。现在发现了吧,没连接点什么事情,连接点就是为了让你好理解切点,搞出来的,明白这个概念就行了。通知说明了干什么和什么时候干(什么时候通过方法名中的before,after,around等就能知道),而切入点说明了在哪干(指定到底是哪个方法),这就是一个完整的切面定义。

5、引入(introduction):允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗

6、目标(target):引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被咱们织入切面。而自己专注于业务本身的逻辑。

7、代理(proxy):怎么实现整套aop机制的,都是通过代理,这个一会给细说。

8、织入(weaving):把切面应用到目标对象来创建新的代理对象的过程。有3种方式,spring采用的是运行时,为什么是运行时,后面解释。

如何用Java动态代理实现AOP

在目前的Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。 其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 Proxy 类主要用来获取动态代理对象,InvocationHandler接口用来约束调...