- 浏览: 413754 次
- 性别:
- 来自: 广州
文章分类
最新评论
-
liyuanhoa_:
...
struts2.0中struts.xml配置文件详解 -
chenmingde:
...
Velocity应用(一) -
weizhikai_ai:
第二十六,当一个线程进入一个对象的一个synchronized ...
Java常见面试题(含答案) -
Aurora_lr:
...
Spring宠物商店学习笔记(一) - -
zs911zs:
all copy from http://www.iteye ...
Mule入门文档
一.起源
有时,我们在写一些功能方法的时候,需要加上特定的功能.比如说在方法调用的前后加上日志的操作,或者是事务的开启与关闭.对于一个方法来说,很简单,只要在需要的地方增加一些代码就OK.但是如果有很多方法都需要增加这种特定的操作呢?
没错,将这些特定的代码抽象出来,并且提供一个接口供调用者使用:Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
那么在其他的方法中,就可以使用RecordLog.recordLog()方法了.但你会发现,这仍不是个好的设计,因为在我们的代码里到处充塞着
RecordLog.recordLog()这样的语句:
Java代码
public class A
{
public void a()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类A的方法a的操作
}
}
public class B
{
public void b()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类B的方法b的操作
}
}
......
public class A
{
public void a()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类A的方法a的操作
}
}
public class B
{
public void b()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类B的方法b的操作
}
}
......
这样虽然会在一定程度减轻代码量,但你会发现,仍有大量的地方有重复的代码出现!这绝对不是优雅的写法!
为了避免这种吃力不讨好的现象发生,“代理”粉墨登场了.
二.传统的代理.静态的代理.面向接口编程
同样为了实现以上的功能,我们在设计的时候做了个小小的改动.
2.1 抽象出来的记录日志的类:
Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
2.2 设计了一个接口:
Java代码
public interface PeopleInfo
{
public void getInfo();
}
public interface PeopleInfo
{
public void getInfo();
}
该接口只提供了待实现的方法.
2.3 实现该接口的类:
Java代码
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
这个类仅仅是实现了PeopleInfo接口而已.平平实实.好了.关键的地方来了.就在下面!
2.4 创建一个代理类:
Java代码
public class PeopleInfoProxy implements PeopleInfo
{
// 接口的引用
private PeopleInfo peopleInfo;
// 构造函数 .针对接口编程,而非针对具体类
public RecordLogProxy(PeopleInfo peopleInfo)
{
this.peopleInfo = peopleInfo;
}
// 实现接口中的方法
public void record()
{
// 1.记录日志
RecordLog.recordLog();
// 2.方法的具体实现
peopleInfo.getInfo();
}
}
public class PeopleInfoProxy implements PeopleInfo
{
// 接口的引用
private PeopleInfo peopleInfo;
// 构造函数 .针对接口编程,而非针对具体类
public RecordLogProxy(PeopleInfo peopleInfo)
{
this.peopleInfo = peopleInfo;
}
// 实现接口中的方法
public void record()
{
// 1.记录日志
RecordLog.recordLog();
// 2.方法的具体实现
peopleInfo.getInfo();
}
}
这个是类是一个代理类,它同样实现了PeopleInfo接口.比较特殊的地方在于这个类中有一个接口的引用private PeopleInfo peopleInfo;通过
这个引用,可以调用实现了该接口的类的实例的方法!
而不管是谁,只要实现了PeopleInfo这个接口,都可以被这个引用所引用.也就是说,这个代理类可以代理任何实现了接口的PeopleInfo的类.具体
如何实现,请看下面:
2.5 Main
Java代码
public class Main
{
public static void main(String[] args)
{
// new了一个对象
PeopleInfoImpl peopleInfoImpl = new PeopleInfoImpl("Rock",24);
// 代理该对象
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy(PeopleInfoImpl);
// 调用代理类的方法.输入的是目标类(即被代理类的方法的实现)
peopleInfoProxy.getInfo();
}
}
public class Main
{
public static void main(String[] args)
{
// new了一个对象
PeopleInfoImpl peopleInfoImpl = new PeopleInfoImpl("Rock",24);
// 代理该对象
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy(PeopleInfoImpl);
// 调用代理类的方法.输入的是目标类(即被代理类的方法的实现)
peopleInfoProxy.getInfo();
}
}
这样,输出的结果将是:
记录日志...
我是Rock,今年24岁了.
由这个例子可见,这么做了之后不但省略了很多代码,而且不必要知道具体是由哪个类来执行方法.只需实现了特定的接口,代理类就可以打点一切
了.这就是面向接口的威力!HOHO...
三.动态代理.Java的动态机制.
面向接口的编程确实让我们省了不少心,只要实现一个特定的接口,就可以处理很多的相关的类了.
不过,这总是要实现一个“特定”的接口,如果有很多很多这样的接口需要被实现...也是件比较麻烦的事情.
好在,JDK1.3起,就有了动态代理机制,主要有以下两个类和一个接口:
Java代码
java.lang.reflect.Proxy
java.lang.reflect.Method
java.lang.reflect.InvocationHandler
java.lang.reflect.Proxy
java.lang.reflect.Method
java.lang.reflect.InvocationHandler
所谓动态代理,就是JVM在内存中动态的构造代理类.说的真是玄,还是看看代码吧.
3.1 抽象出来的记录日志的类:
Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
3.2 设计了一个接口:
Java代码
public interface PeopleInfo
{
public void getInfo();
}
public interface PeopleInfo
{
public void getInfo();
}
该接口只提供了待实现的方法.
3.3 实现该接口的类:
Java代码
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
一直到这里,都和第二节没区别,好嘛,下面就是关键哟.
3.4 创建一个代理类,实现了接口InvocationHandler:
Java代码
public class PeopleInfoProxy implements InvocationHandler
{
// 定义需要被代理的目标对象
private Object target;
// 将目标对象与代理对象绑定
public Object bind(Object targer)
{
this.target = target;
// 调用Proxy的newProxyInstance方法产生代理类实例
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// 实现接口InvocationHandler的invoke方法
// 该方法将在目标类的被代理方法被调用之前,自动触发
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
Object result = null;
// 1.目标类的被代理方法被调用之前,可以做的操作
RecordLog.recordLog();
// 2.方法的具体实现
result = method.invoke(target, args);
// 3.还可以在方法调用之后加上的操作
// 自己补充
return result;
}
}
public class PeopleInfoProxy implements InvocationHandler
{
// 定义需要被代理的目标对象
private Object target;
// 将目标对象与代理对象绑定
public Object bind(Object targer)
{
this.target = target;
// 调用Proxy的newProxyInstance方法产生代理类实例
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// 实现接口InvocationHandler的invoke方法
// 该方法将在目标类的被代理方法被调用之前,自动触发
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
Object result = null;
// 1.目标类的被代理方法被调用之前,可以做的操作
RecordLog.recordLog();
// 2.方法的具体实现
result = method.invoke(target, args);
// 3.还可以在方法调用之后加上的操作
// 自己补充
return result;
}
}
关于Proxy, Method, InvocationHandler的具体说明,请参见JDK_API.
只对代码中关键部分做些解释说明:
3.4.1 Java代码
Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
表示生成目标类的代理类,传入的参数有目标类的ClassLoader, 目标类的接口列表, 和实现了接口InvocationHandler的代理类.
这样,bind方法就得到了目标类的代理类.
3.4.2 Java代码
method.invoke(target, args);
method.invoke(target, args);
目标类的被代理方法在被代用前,会自动调用InvocationHandler接口的invoke方法.
在该方法中,我们可以对目标类的被代理方法进行加强,比如说在其前后加上事务的开启和关闭等等.
这段代码才是真正调用目标类的被代理方法.
就这样,我们不用实现其他任何的接口,理论上就能代理所有类了.调用的方式如下:
3.5 Main:
Java代码
public class Main
{
public static void main(String[] args)
{
PeopleInfo peopleInfo = null;
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy();
// 传入的参数是目标类实例,生成代理类实例,类型为Object
Object obj = peopleInfoProxy.bind(new PeopleInfoImpl("Rock", 24));
if(obj instanceof PeopleInfo)
{
peopleInfo = (PeopleInfo)obj;
}
peopleInfo.getInfo();
}
}
public class Main
{
public static void main(String[] args)
{
PeopleInfo peopleInfo = null;
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy();
// 传入的参数是目标类实例,生成代理类实例,类型为Object
Object obj = peopleInfoProxy.bind(new PeopleInfoImpl("Rock", 24));
if(obj instanceof PeopleInfo)
{
peopleInfo = (PeopleInfo)obj;
}
peopleInfo.getInfo();
}
}
执行结果和上一节一样.
这就是使用Java动态代理机制的基本概述.而下一节,将要把Dynamic Proxy(动态代理)和AOP联系起来.
四.AOP概述.Spring的AOP.
AOP(Aspect Oriented Programming)面向切面编程.是一种比较新颖的设计思想.是对OOP(Object Orientd Programming)面向对象编程的一种有益的补充.
4.1 OOP和AOP
OOP对业务处理过程中的实体及其属性和行为进行了抽象封装,以获得更加清晰高效果的逻辑划分.研究的是一种“静态的”领域.
AOP则是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段.研究的是一种“动态的”领域.
举例说,某个网站(5016?)用户User类又可分为好几种,区长,管理员,斑竹和普通水友.我们把这些会员的特性进行提取进行封装,这是OOP.
而某一天,区长开会了,召集斑竹等级以上的会员参与,这样,普通水友就不能访问相关资源.
我们怎么做到让普通水友访问不了资源,而斑竹等级以上会员可以访问呢.
权限控制.对,权限.当水友们进行操作的时候,我们给他的身份进行权限的判断.
请注意,当且仅需水友门执行了操作的时候,我们才需要进行权限判断,也就是说,这是发生在一个业务处理的过程中的一个片面.
我们对这一个片面进行编程,就是AOP!
我这样,你应该能理解吧.
4.2 AOP的基本术语
4.2.1 切面Aspect
业务处理过程中的一个截面.就像权限检查.
通过切面,可以将不同层面的问题隔离开:浏览帖子和权限检查两者互不相干.
这样一来,也就降低了耦合性,我们可以把注意力集中到各自的领域中.
上两节的例子中,getInfo()和recordLog()就是两个领域的方法,应该处于切面的不同端.哎呀,不知不觉间,我们就用了AOP.呵呵...
4.2.2 连接点JoinPoint
程序运行中的某个阶段点.如某个方法的调用,或者异常的抛出等.
在前面,我们总是在getInfo()的前后加了recordLog()等操作,这个调用getInfo()就是连接点.
4.2.3 处理逻辑Advice
在某个连接点采取的逻辑.
这里的逻辑有三种:
I. Around 在连接点前后插入预处理和后处理过程.
II. Before 在连接点前插入预处理过程.
III.Throw 在连接点抛出异常的时候进行异常处理.
4.2.4 切点PointCut
一系列连接点的集合,它指明处理逻辑Advice将在何在被触发.
4.3 Spring中的AOP
Spring提供内置AOP支持.是基于动态AOP机制的实现.
所谓动态AOP,其实就是动态Proxy模式,在目标对象的方法前后插入相应的代码.(比如说在getInfo()前后插入的recordLog())
Spring AOP中的动态Proxy模式,是基于Java Dynamic Proxy(面向Interface)和CGLib(面向Class)的实现.
为什么要分面向接口和面向类呢.
还记得我们在生成代理类的代码吗:
Java代码
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
这里面的参数不许为空,也就是说:obj.getClass().getInterfaces()必有值,即目标类一定要实现某个接口.
有了这些,JVM在内存中就动态的构造出代理出来.
而没有实现任何接口的类,就必须使用CGLib来动态构造代理类.值得一提的是,CGLib构造的代理类是目标类的一个子类.
4.4 相关工程简解
Spring的相关知识不应该在这里讲,难度系数过大.这里只给个简单例子.供参考.
4.4.1 准备工作
打开Eclipse.新建Java工程,取名为AOP_Proxy.完成.
复制spring-2.0.jar.粘贴到AOP_Proxy下.
右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找spring-2.0.jar-->添加确定.
复制commons-logging.jar.粘贴到AOP_Proxy下.
右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找commons-logging.jar-->添加确定.
4.4.2 写代码
代码略.配置文件略.
4.4.3 导入工程的步骤
新建工程AOP_Proxy-->完成-->右击AOP_Proxy-->导入-->常规-->文件系统-->找到项目文件,导入完成.
两个jar包和项目文件(项目文件需要先解压).
有时,我们在写一些功能方法的时候,需要加上特定的功能.比如说在方法调用的前后加上日志的操作,或者是事务的开启与关闭.对于一个方法来说,很简单,只要在需要的地方增加一些代码就OK.但是如果有很多方法都需要增加这种特定的操作呢?
没错,将这些特定的代码抽象出来,并且提供一个接口供调用者使用:Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
那么在其他的方法中,就可以使用RecordLog.recordLog()方法了.但你会发现,这仍不是个好的设计,因为在我们的代码里到处充塞着
RecordLog.recordLog()这样的语句:
Java代码
public class A
{
public void a()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类A的方法a的操作
}
}
public class B
{
public void b()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类B的方法b的操作
}
}
......
public class A
{
public void a()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类A的方法a的操作
}
}
public class B
{
public void b()
{
// 1.记录日志
RecordLog.recordLog();
// 2.类B的方法b的操作
}
}
......
这样虽然会在一定程度减轻代码量,但你会发现,仍有大量的地方有重复的代码出现!这绝对不是优雅的写法!
为了避免这种吃力不讨好的现象发生,“代理”粉墨登场了.
二.传统的代理.静态的代理.面向接口编程
同样为了实现以上的功能,我们在设计的时候做了个小小的改动.
2.1 抽象出来的记录日志的类:
Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
2.2 设计了一个接口:
Java代码
public interface PeopleInfo
{
public void getInfo();
}
public interface PeopleInfo
{
public void getInfo();
}
该接口只提供了待实现的方法.
2.3 实现该接口的类:
Java代码
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
这个类仅仅是实现了PeopleInfo接口而已.平平实实.好了.关键的地方来了.就在下面!
2.4 创建一个代理类:
Java代码
public class PeopleInfoProxy implements PeopleInfo
{
// 接口的引用
private PeopleInfo peopleInfo;
// 构造函数 .针对接口编程,而非针对具体类
public RecordLogProxy(PeopleInfo peopleInfo)
{
this.peopleInfo = peopleInfo;
}
// 实现接口中的方法
public void record()
{
// 1.记录日志
RecordLog.recordLog();
// 2.方法的具体实现
peopleInfo.getInfo();
}
}
public class PeopleInfoProxy implements PeopleInfo
{
// 接口的引用
private PeopleInfo peopleInfo;
// 构造函数 .针对接口编程,而非针对具体类
public RecordLogProxy(PeopleInfo peopleInfo)
{
this.peopleInfo = peopleInfo;
}
// 实现接口中的方法
public void record()
{
// 1.记录日志
RecordLog.recordLog();
// 2.方法的具体实现
peopleInfo.getInfo();
}
}
这个是类是一个代理类,它同样实现了PeopleInfo接口.比较特殊的地方在于这个类中有一个接口的引用private PeopleInfo peopleInfo;通过
这个引用,可以调用实现了该接口的类的实例的方法!
而不管是谁,只要实现了PeopleInfo这个接口,都可以被这个引用所引用.也就是说,这个代理类可以代理任何实现了接口的PeopleInfo的类.具体
如何实现,请看下面:
2.5 Main
Java代码
public class Main
{
public static void main(String[] args)
{
// new了一个对象
PeopleInfoImpl peopleInfoImpl = new PeopleInfoImpl("Rock",24);
// 代理该对象
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy(PeopleInfoImpl);
// 调用代理类的方法.输入的是目标类(即被代理类的方法的实现)
peopleInfoProxy.getInfo();
}
}
public class Main
{
public static void main(String[] args)
{
// new了一个对象
PeopleInfoImpl peopleInfoImpl = new PeopleInfoImpl("Rock",24);
// 代理该对象
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy(PeopleInfoImpl);
// 调用代理类的方法.输入的是目标类(即被代理类的方法的实现)
peopleInfoProxy.getInfo();
}
}
这样,输出的结果将是:
记录日志...
我是Rock,今年24岁了.
由这个例子可见,这么做了之后不但省略了很多代码,而且不必要知道具体是由哪个类来执行方法.只需实现了特定的接口,代理类就可以打点一切
了.这就是面向接口的威力!HOHO...
三.动态代理.Java的动态机制.
面向接口的编程确实让我们省了不少心,只要实现一个特定的接口,就可以处理很多的相关的类了.
不过,这总是要实现一个“特定”的接口,如果有很多很多这样的接口需要被实现...也是件比较麻烦的事情.
好在,JDK1.3起,就有了动态代理机制,主要有以下两个类和一个接口:
Java代码
java.lang.reflect.Proxy
java.lang.reflect.Method
java.lang.reflect.InvocationHandler
java.lang.reflect.Proxy
java.lang.reflect.Method
java.lang.reflect.InvocationHandler
所谓动态代理,就是JVM在内存中动态的构造代理类.说的真是玄,还是看看代码吧.
3.1 抽象出来的记录日志的类:
Java代码
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
public class RecordLog
{
public static void recordLog()
{
// 记录日志的操作
System.out.println("记录日志...");
}
}
3.2 设计了一个接口:
Java代码
public interface PeopleInfo
{
public void getInfo();
}
public interface PeopleInfo
{
public void getInfo();
}
该接口只提供了待实现的方法.
3.3 实现该接口的类:
Java代码
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
public class PeopleInfoImpl implements PeopleInfo
{
private String name;
private int age;
// 构造函数
public PeopleInfoImpl(String name, int age)
{
this.name = name;
this.age = age;
}
public void getInfo()
{
// 方法的具体实现
System.out.println("我是" + name + ",今年" + age + "岁了.");
}
}
一直到这里,都和第二节没区别,好嘛,下面就是关键哟.
3.4 创建一个代理类,实现了接口InvocationHandler:
Java代码
public class PeopleInfoProxy implements InvocationHandler
{
// 定义需要被代理的目标对象
private Object target;
// 将目标对象与代理对象绑定
public Object bind(Object targer)
{
this.target = target;
// 调用Proxy的newProxyInstance方法产生代理类实例
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// 实现接口InvocationHandler的invoke方法
// 该方法将在目标类的被代理方法被调用之前,自动触发
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
Object result = null;
// 1.目标类的被代理方法被调用之前,可以做的操作
RecordLog.recordLog();
// 2.方法的具体实现
result = method.invoke(target, args);
// 3.还可以在方法调用之后加上的操作
// 自己补充
return result;
}
}
public class PeopleInfoProxy implements InvocationHandler
{
// 定义需要被代理的目标对象
private Object target;
// 将目标对象与代理对象绑定
public Object bind(Object targer)
{
this.target = target;
// 调用Proxy的newProxyInstance方法产生代理类实例
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// 实现接口InvocationHandler的invoke方法
// 该方法将在目标类的被代理方法被调用之前,自动触发
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
Object result = null;
// 1.目标类的被代理方法被调用之前,可以做的操作
RecordLog.recordLog();
// 2.方法的具体实现
result = method.invoke(target, args);
// 3.还可以在方法调用之后加上的操作
// 自己补充
return result;
}
}
关于Proxy, Method, InvocationHandler的具体说明,请参见JDK_API.
只对代码中关键部分做些解释说明:
3.4.1 Java代码
Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
表示生成目标类的代理类,传入的参数有目标类的ClassLoader, 目标类的接口列表, 和实现了接口InvocationHandler的代理类.
这样,bind方法就得到了目标类的代理类.
3.4.2 Java代码
method.invoke(target, args);
method.invoke(target, args);
目标类的被代理方法在被代用前,会自动调用InvocationHandler接口的invoke方法.
在该方法中,我们可以对目标类的被代理方法进行加强,比如说在其前后加上事务的开启和关闭等等.
这段代码才是真正调用目标类的被代理方法.
就这样,我们不用实现其他任何的接口,理论上就能代理所有类了.调用的方式如下:
3.5 Main:
Java代码
public class Main
{
public static void main(String[] args)
{
PeopleInfo peopleInfo = null;
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy();
// 传入的参数是目标类实例,生成代理类实例,类型为Object
Object obj = peopleInfoProxy.bind(new PeopleInfoImpl("Rock", 24));
if(obj instanceof PeopleInfo)
{
peopleInfo = (PeopleInfo)obj;
}
peopleInfo.getInfo();
}
}
public class Main
{
public static void main(String[] args)
{
PeopleInfo peopleInfo = null;
PeopleInfoProxy peopleInfoProxy = new PeopleInfoProxy();
// 传入的参数是目标类实例,生成代理类实例,类型为Object
Object obj = peopleInfoProxy.bind(new PeopleInfoImpl("Rock", 24));
if(obj instanceof PeopleInfo)
{
peopleInfo = (PeopleInfo)obj;
}
peopleInfo.getInfo();
}
}
执行结果和上一节一样.
这就是使用Java动态代理机制的基本概述.而下一节,将要把Dynamic Proxy(动态代理)和AOP联系起来.
四.AOP概述.Spring的AOP.
AOP(Aspect Oriented Programming)面向切面编程.是一种比较新颖的设计思想.是对OOP(Object Orientd Programming)面向对象编程的一种有益的补充.
4.1 OOP和AOP
OOP对业务处理过程中的实体及其属性和行为进行了抽象封装,以获得更加清晰高效果的逻辑划分.研究的是一种“静态的”领域.
AOP则是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段.研究的是一种“动态的”领域.
举例说,某个网站(5016?)用户User类又可分为好几种,区长,管理员,斑竹和普通水友.我们把这些会员的特性进行提取进行封装,这是OOP.
而某一天,区长开会了,召集斑竹等级以上的会员参与,这样,普通水友就不能访问相关资源.
我们怎么做到让普通水友访问不了资源,而斑竹等级以上会员可以访问呢.
权限控制.对,权限.当水友们进行操作的时候,我们给他的身份进行权限的判断.
请注意,当且仅需水友门执行了操作的时候,我们才需要进行权限判断,也就是说,这是发生在一个业务处理的过程中的一个片面.
我们对这一个片面进行编程,就是AOP!
我这样,你应该能理解吧.
4.2 AOP的基本术语
4.2.1 切面Aspect
业务处理过程中的一个截面.就像权限检查.
通过切面,可以将不同层面的问题隔离开:浏览帖子和权限检查两者互不相干.
这样一来,也就降低了耦合性,我们可以把注意力集中到各自的领域中.
上两节的例子中,getInfo()和recordLog()就是两个领域的方法,应该处于切面的不同端.哎呀,不知不觉间,我们就用了AOP.呵呵...
4.2.2 连接点JoinPoint
程序运行中的某个阶段点.如某个方法的调用,或者异常的抛出等.
在前面,我们总是在getInfo()的前后加了recordLog()等操作,这个调用getInfo()就是连接点.
4.2.3 处理逻辑Advice
在某个连接点采取的逻辑.
这里的逻辑有三种:
I. Around 在连接点前后插入预处理和后处理过程.
II. Before 在连接点前插入预处理过程.
III.Throw 在连接点抛出异常的时候进行异常处理.
4.2.4 切点PointCut
一系列连接点的集合,它指明处理逻辑Advice将在何在被触发.
4.3 Spring中的AOP
Spring提供内置AOP支持.是基于动态AOP机制的实现.
所谓动态AOP,其实就是动态Proxy模式,在目标对象的方法前后插入相应的代码.(比如说在getInfo()前后插入的recordLog())
Spring AOP中的动态Proxy模式,是基于Java Dynamic Proxy(面向Interface)和CGLib(面向Class)的实现.
为什么要分面向接口和面向类呢.
还记得我们在生成代理类的代码吗:
Java代码
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
这里面的参数不许为空,也就是说:obj.getClass().getInterfaces()必有值,即目标类一定要实现某个接口.
有了这些,JVM在内存中就动态的构造出代理出来.
而没有实现任何接口的类,就必须使用CGLib来动态构造代理类.值得一提的是,CGLib构造的代理类是目标类的一个子类.
4.4 相关工程简解
Spring的相关知识不应该在这里讲,难度系数过大.这里只给个简单例子.供参考.
4.4.1 准备工作
打开Eclipse.新建Java工程,取名为AOP_Proxy.完成.
复制spring-2.0.jar.粘贴到AOP_Proxy下.
右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找spring-2.0.jar-->添加确定.
复制commons-logging.jar.粘贴到AOP_Proxy下.
右击AOP_Proxy-->属性-->Java构建路径-->库-->添加JAR-->找commons-logging.jar-->添加确定.
4.4.2 写代码
代码略.配置文件略.
4.4.3 导入工程的步骤
新建工程AOP_Proxy-->完成-->右击AOP_Proxy-->导入-->常规-->文件系统-->找到项目文件,导入完成.
两个jar包和项目文件(项目文件需要先解压).
发表评论
-
访问Spring示例JPetStore的OrderService服务
2008-11-27 17:27 1384Spring--当前流行的J2EE开发的轻量级框架,提供了对M ... -
read-jpetstore-1-安装与配置
2008-11-27 17:26 1280项目导入 登录http://www.springframe ... -
spring jpetstore研究入门—完结篇
2008-11-27 16:07 1448相关文章: springframe ... -
spring jpetstore研究入门—安装篇
2008-11-27 16:06 1553之所以写这个jpetstore研究入门的文章,是为了给茫然不知 ... -
spring JpetStore学习笔记
2008-11-27 16:04 1901首先看看工程的web.xml文件 指定web应用的根, 为W ... -
spring入门编程问题集锦
2008-11-27 16:01 1036相关文章: 问一下<sping:bind& ... -
在Spring中使用JMS
2008-11-26 16:37 1114准备工作: 熟悉下JMS的基础知识,这里不再罗嗦,主要是实 ... -
Spring发布包内容详解
2008-11-26 16:26 947版权声明:作者junsan, ... -
在项目中应用Spring的Acegi安全框架的步骤
2008-11-26 12:22 18750、准备:配置数据源 1、配置认证管理器(org.acegi ... -
Spring宠物商店学习笔记(二)
2008-11-26 12:21 1317项目框架 1、Struts/Spring MVC 2、Sp ... -
Spring宠物商店学习笔记(一) -
2008-11-26 12:21 2746一、概述 JPet ... -
Spring基础知识(三)
2008-11-26 12:20 1190参阅:Spring Framework 开 ... -
Spring基础知识(二)
2008-11-26 12:19 1223参阅:Spring Framework 开 ... -
Spring基础知识(一)
2008-11-26 12:19 1437http://book.csdn.net/bookfiles/ ... -
Spring精髓
2008-11-26 12:18 18511\、好处 A、 使用配置文件来组装应用系统,使得在不用修改 ... -
Spring Security 中文参考文档
2008-11-25 16:56 1328http://peak.iteye.com/blog/2361 ... -
Spring的声明式事务管理
2008-11-21 16:37 6441小结:用Spring AOP配置事务要注意的几项 Spring ...
相关推荐
动态代理和AOP是Java和Spring框架中的重要概念,它们为开发者提供了强大的代码复用和模块化设计的能力。本文将深入解析这两个主题,并结合提供的源码进行详细讲解。 首先,让我们了解一下动态代理。在Java中,动态...
在Spring框架中,动态代理和AOP(面向切面编程)是两个重要的概念,它们极大地增强了代码的可维护性和灵活性。下面将详细讲解这两个概念及其实际应用。 动态代理,是Spring提供的一种机制,允许我们在不修改原对象...
总之,Java动态代理和AOP提供了强大的工具,使我们能够优雅地实现代码解耦,提高代码的复用性和可维护性。通过代理对象,我们可以在不修改原始类代码的情况下,添加额外的功能或改变原有行为,这对于系统的服务层和...
这些代码可能涉及到如何创建分页对象,如何与数据库交互获取分页数据,以及如何在AOP中使用动态代理进行拦截和处理。 总的来说,Java分页、动态代理和AOP是Java开发中的关键技术,它们能帮助我们构建出更加高效、可...
在Java编程领域,代理机制和面向切面编程(AOP)是两个重要的概念,它们在Spring框架中得到了广泛的应用。本文将深入探讨这两个主题,并结合JDK的反射和CGLIB库来阐述其实现原理。 首先,我们来看动态代理。动态...
在IT领域,动态代理和AOP(面向切面编程)是两种重要的编程概念,它们能够帮助我们实现代码的解耦和模块化。本篇将详细探讨JDK动态代理和Spring AOP,以及它们在实际应用中的作用。 首先,JDK动态代理是Java提供的...
Spring AOP支持不同的代理策略,包括JDK动态代理和CGLIB代理。如果被代理的类没有实现接口,Spring AOP会采用CGLIB来生成代理对象。CGLIB(Code Generation Library)是一个开源的代码生成库,它允许运行时在内存中...
首先,我们需要引入Spring AOP和AspectJ的依赖,这通常在pom.xml或build.gradle文件中完成。然后,我们可以定义一个切面(Aspect),它包含通知(Advice)——即在特定连接点执行的代码。通知可以是前置通知(Before...
Java动态代理实现AOP Java动态代理是实现Aspect Oriented Programming(AOP)的重要手段。在Java中,动态代理可以通过java.lang.reflect InvocationHandler接口和java.lang.reflect.Proxy类来实现。AOP的主要思想...
AOP(Aspect Oriented Programming,面向切面编程)是一种编程范式,旨在提供一种方法来组织和模块化系统中的交叉关注点,如日志、事务管理、权限控制等。它通过将这些关注点与核心业务逻辑分离,实现代码的解耦,...
现在让我们深入探讨JDK动态代理和Spring AOP的原理。 首先,JDK动态代理基于Java的反射机制,通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来实现。Proxy类用于创建一个代理对象,...
ByteBuddy是Java的一个库,用于在运行时创建和修改Java类和接口,它是创建Java代理或者实现AOP(面向切面编程)框架的理想工具。在本项目"基于Bytebuddy的Java Agent AOP框架.zip"中,我们将探讨如何使用ByteBuddy...
MethodInterceptProxy是一个专门针对Android平台的动态代理库,它使得开发者能够方便地实现面向切面编程(AOP)以及进行单元测试和数据访问框架的优化。本文将深入探讨MethodInterceptProxy的原理、使用方法以及其在...
Spring提供了两种AOP代理方式:JDK动态代理和CGLIB。如果目标对象实现了至少一个接口,Spring会选择JDK动态代理;如果没有实现接口,Spring则会使用CGLIB代理。 AOP在Spring中的实现还涉及了切点(Pointcut)、通知...
Spring框架是AOP实现的一个典范,它提供了两种主要的动态代理方式:JDK动态代理和CGLib动态代理。 **JDK动态代理**: JDK动态代理基于Java的反射API实现,适用于接口代理。当目标对象实现了至少一个接口时,Spring...
Spring支持两种类型的AOP代理:JDK动态代理和CGLIB代理。 - JDK动态代理:基于Java反射API实现,适用于接口代理。如果目标对象实现了至少一个接口,Spring会使用JDK动态代理创建一个代理对象,该代理对象在调用...
### Java反射与代理实现AOP #### 一、AOP概念及应用场景 AOP(Aspect-Oriented Programming,面向切面编程)是一种编程思想和技术,主要用于处理横切关注点问题,比如日志记录、性能统计、安全控制、事务处理、...
Spring 提供了两种方式来实现AOP代理:JDK动态代理和CGLIB代理。 1. **JDK动态代理**: - JDK动态代理基于Java的接口实现,适用于目标对象实现了接口的情况。Spring会为这个接口创建一个代理类,代理类在调用真实...
在`006_Dynamic_Proxy_Spring_AOP`这个压缩包中,可能包含了关于动态代理和Spring AOP的示例源代码。通过分析这些代码,你可以深入理解动态代理的实现细节,以及Spring如何在内部使用它来实现AOP功能。你可以查看...