《转》JAVA动态代理(JDK和CGLIB)
该文章转自:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html
JAVA的动态代理
代理模式
代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。
按照代理的创建时期,代理类可以分为两种。
静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
动态代理:在程序运行时,运用反射机制动态创建而成。
首先看一下静态代理:
1、Count.java
package net.battier.dao; /**
* 定义一个账户接口
*
* @author Administrator
*
*/
public interface Count {
// 查看账户方法
public void queryCount(); // 修改账户方法
public void updateCount(); }
2、CountImpl.java
package net.battier.dao.impl; import net.battier.dao.Count; /**
* 委托类(包含业务逻辑)
*
* @author Administrator
*
*/
public class CountImpl implements Count { @Override
public void queryCount() {
System.out.println("查看账户方法..."); } @Override
public void updateCount() {
System.out.println("修改账户方法..."); } } 、CountProxy.java
package net.battier.dao.impl; import net.battier.dao.Count; /**
* 这是一个代理类(增强CountImpl实现类)
*
* @author Administrator
*
*/
public class CountProxy implements Count {
private CountImpl countImpl; /**
* 覆盖默认构造器
*
* @param countImpl
*/
public CountProxy(CountImpl countImpl) {
this.countImpl = countImpl;
} @Override
public void queryCount() {
System.out.println("事务处理之前");
// 调用委托类的方法;
countImpl.queryCount();
System.out.println("事务处理之后");
} @Override
public void updateCount() {
System.out.println("事务处理之前");
// 调用委托类的方法;
countImpl.updateCount();
System.out.println("事务处理之后"); } }
3、TestCount.java
package net.battier.test; import net.battier.dao.impl.CountImpl;
import net.battier.dao.impl.CountProxy; /**
*测试Count类
*
* @author Administrator
*
*/
public class TestCount {
public static void main(String[] args) {
CountImpl countImpl = new CountImpl();
CountProxy countProxy = new CountProxy(countImpl);
countProxy.updateCount();
countProxy.queryCount(); }
}
观察代码可以发现每一个代理类只能为一个接口服务,这样一来程序开发中必然会产生过多的代理,而且,所有的代理操作除了调用的方法不一样之外,其他的操作都一样,则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能,那么此时就必须使用动态代理完成。
再来看一下动态代理:
JDK动态代理中包含一个类和一个接口:
InvocationHandler接口:
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明:
Object proxy:指被代理的对象。
Method method:要调用的方法
Object[] args:方法调用时所需要的参数
可以将InvocationHandler接口的子类想象成一个代理的最终操作类,替换掉ProxySubject。
Proxy类:
Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下的操作方法:
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明:
ClassLoader loader:类加载器
Class<?>[] interfaces:得到全部的接口
InvocationHandler h:得到InvocationHandler接口的子类实例
Ps:类加载器
在Proxy类中的newProxyInstance()方法中需要一个ClassLoader类的实例,ClassLoader实际上对应的是类加载器,在Java中主要有一下三种类加载器;
Booststrap ClassLoader:此加载器采用C++编写,一般开发中是看不到的;
Extendsion ClassLoader:用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类;
AppClassLoader:(默认)加载classpath指定的类,是最常使用的是一种加载器。
动态代理
与静态代理类对照的是动态代理类,动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。
动态代理示例:
1、BookFacade.java
1 package net.battier.dao;
2
3 public interface BookFacade {
4 public void addBook();
5 }
2、BookFacadeImpl.java
package net.battier.dao.impl; import net.battier.dao.BookFacade; public class BookFacadeImpl implements BookFacade { @Override
public void addBook() {
System.out.println("增加图书方法。。。");
} } 、BookFacadeProxy.java package net.battier.proxy; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; /**
* JDK动态代理代理类
*
* @author student
*
*/
public class BookFacadeProxy implements InvocationHandler {
private Object target;
/**
* 绑定委托对象并返回一个代理类
* @param target
* @return
*/
public Object bind(Object target) {
this.target = target;
//取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this); //要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)
} @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;
} }
3、TestProxy.java
package net.battier.test; import net.battier.dao.BookFacade;
import net.battier.dao.impl.BookFacadeImpl;
import net.battier.proxy.BookFacadeProxy; public class TestProxy { public static void main(String[] args) {
BookFacadeProxy proxy = new BookFacadeProxy();
BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
bookProxy.addBook();
} }
但是,JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了。
Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能实现JDK的动态代理,cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。
示例
1、BookFacadeCglib.java
1 package net.battier.dao;
2
3 public interface BookFacade {
4 public void addBook();
5 }
2、BookCadeImpl1.java
package net.battier.dao.impl; /**
* 这个是没有实现接口的实现类
*
* @author student
*
*/
public class BookFacadeImpl1 {
public void addBook() {
System.out.println("增加图书的普通方法...");
}
}
3、BookFacadeProxy.java
package net.battier.proxy; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy; /**
* 使用cglib动态代理
*
* @author student
*
*/
public class BookFacadeCglib 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 obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("事物开始");
proxy.invokeSuper(obj, args);
System.out.println("事物结束");
return null; } }
4、TestCglib.java
package net.battier.test; import net.battier.dao.impl.BookFacadeImpl1;
import net.battier.proxy.BookFacadeCglib; public class TestCglib { public static void main(String[] args) {
BookFacadeCglib cglib=new BookFacadeCglib();
BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());
bookCglib.addBook();
}
}
以上为转载内容,下面是自己写的Test
package com.xt.test; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; interface Anim {
public void sound(); public void name();
} class Dog implements Anim { @Override
public void sound() {
// TODO Auto-generated method stub
System.out.println("汪汪汪!");
} @Override
public void name() {
// TODO Auto-generated method stub
System.out.println("一条小狗!");
} } class Cat implements Anim { @Override
public void sound() {
// TODO Auto-generated method stub
System.out.println("喵喵喵!");
} @Override
public void name() {
// TODO Auto-generated method stub
System.out.println("一只小猫!");
} } interface Car {
public void name(); public void color(); public void run();
} class Bmw implements Car { @Override
public void name() {
// TODO Auto-generated method stub
System.out.println("一辆宝马!");
} @Override
public void color() {
// TODO Auto-generated method stub
System.out.println("黑色!");
} @Override
public void run() {
// TODO Auto-generated method stub
System.out.println("车子开动!");
} } class Wm implements Car { @Override
public void name() {
// TODO Auto-generated method stub
System.out.println("一辆大众!");
} @Override
public void color() {
// TODO Auto-generated method stub
System.out.println("银色!");
} @Override
public void run() {
// TODO Auto-generated method stub
System.out.println("车子开动!");
} } /**
* JDK动态代理代理类
*
* @author student
*
*/
class DynamicProxy implements InvocationHandler {
private Object target; /**
* 绑定委托对象并返回一个代理类
*
* @param target
* @return
*/
public Object bind(Object target) {
this.target = target;
// 取得代理对象
Object o = Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this); // 要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)
return o;
} @Override
/**
* 调用方法
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
if (target instanceof Anim && method.getName().equals("sound"))
System.out.println("准备叫:");
if (target instanceof Car && method.getName().equals("run"))
System.out.println("车子点火!");
// 执行方法
result = method.invoke(target, args);
if (target instanceof Anim && method.getName().equals("sound"))
System.out.println("叫响了");
if (target instanceof Car && method.getName().equals("run"))
System.out.println("车子停了!");
return result;
} } public class DynamicProxyTest {
public static void main(String[] args) {
DynamicProxy proxy = new DynamicProxy();
Anim dog = (Anim) proxy.bind(new Dog());
dog.name();
dog.sound();
System.out.println("---------------------");
Anim cat = (Anim) proxy.bind(new Cat());
cat.name();
cat.sound();
System.out.println("---------动态的精髓来了,无需再构建代理,不同接口使用相同代理即可------------");
// 动态的精髓来了,无需再构建代理,不同接口使用相同代理即可
Car bmw = (Car) proxy.bind(new Bmw());
bmw.name();
bmw.color();
bmw.run();
System.out.println("---------------------");
Car wm = (Car) proxy.bind(new Wm());
wm.name();
wm.color();
}
}
输出结果:
一条小狗!
准备叫:
汪汪汪!
叫响了
---------------------
一只小猫!
准备叫:
喵喵喵!
叫响了
---------动态的精髓来了,无需再构建代理,不同接口使用相同代理即可------------
一辆宝马!
黑色!
车子点火!
车子开动!
车子停了!
---------------------
一辆大众!
银色!
《转》JAVA动态代理(JDK和CGLIB)的更多相关文章
- 动态代理jdk和cglib的区别
学习来源贴:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html JDK实现动态代理需要实现类通过接口定义业务方法,对于没有接口的类, ...
- 动态代理(JDK、CGLIB)
JDK-Proxy(动态代理): 特点:要求被代理的对象必须接口 缺点:如果一个对象没有任何接口实现,则不能使用JDK动态代理 1.创建一个Animal 提供一个方法 2.创建一个cat类.实现Ain ...
- Java动态代理-JDK自带实现
上篇文章讲解了什么是静态代理,但是静态代理有一个问题就是需要建立很多的代理类,这样我们需要修改代理的方法的时候,需要在每个类中都要修改,这对于我们来说:当代理类很多的时候工作量就会成倍的增加. 于是针 ...
- Java动态代理 ----- jdk代理与cglib代理
1.jdk代理 针对接口进行代理,接口可以没有方法, InvocationHandler会拦截所有方法,不过好像意义不大....只能执行Object类的方法,执行结果有点奇怪... package t ...
- [转]java动态代理(JDK和cglib)
转自:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html java动态代理(JDK和cglib) JAVA的动态代理 代理模式 代理 ...
- java动态代理(JDK和cglib)
转:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html JAVA的动态代理 代理模式 代理模式是常用的java设计模式,他的特征是代 ...
- 《转》java动态代理(JDK和cglib)
该文章转自:http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html JAVA的动态代理 代理模式 代理模式是常用的java设计模式,他的 ...
- java动态代理(JDK和cglib实现对比)
详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt214 JAVA的动态代理 代理模式 代理模式是常用的java设计模式,他的特 ...
- Spring学习(四)—— java动态代理(JDK和cglib)
JAVA的动态代理 代理模式 代理模式是常用的java设计模式,他 的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托 ...
随机推荐
- Android特效 五种Toast详解
Toast是Android中用来显示显示信息的一种机制,和Dialog不一样的是,Toast是没有焦点的,而且Toast显示的时间有限,过一定的时间就会自动消失.而且Toast主要用于向用户显示提示消 ...
- 手机低端市场,联发科 vs 高通
联发科(MTK) 是山寨机的源头,我过去曾经鄙视他,现在来了180度转弯. 其实联发科是台湾的上市公司,手机如此复杂的东西,当年 联发科能把基础的手机做出来,而后小山寨厂改改外形,配件就能出若干款手机 ...
- 【转】android中如何查看某个线程的logcat--不错
原文网址:http://my.oschina.net/u/236164/blog/51022 单一个项目由很多人开发,然后大家各自打各自的log.到最后logcat就根本没法看了. adb自带的参数里 ...
- hdu-3790最短路径问题
Problem Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Inp ...
- libvirtVirsh
virsh基于不同协议远程连接libvirt drivers(Hypervisors) 基于OS系统账号ssh登陆
- MyBatis的事务处理
先来假设这样一个问题:如果数据库里面有一个用户表和一个作家表,那么当要添加一条数据到作家表中时,作家表的id必须是用户表中的其中一个id,因为作家一定也要是一个用户.这时就涉及到事务处理. 在上一篇博 ...
- ZMQ设置socket选项
Name zmq_setsockopt –设置ZMQ socket的属性 Synopsis int zmq_setsockopt (void *socket, int option_name, con ...
- DB2完美卸载
会安装,也要会卸载.详细的安装说明不多,我这个我觉得写得还算全. 准备工作. 1.用 ps -ef|grep db2 找出db2安装目录 2. ./db2level 查出DB2的 ...
- springboot中的406(Not Acceptable)错误
今天遇到一个很奇怪的问题,我用springboot开发时,用ajax请求服务想返回json数据,页面总是报406错误,这个错误使我郁闷了很久,原来我的后台服务是这么写的 看到没value的后面有个.h ...
- DevExpress之时间控件
dateEdit和timeEdit 基本属性 DisplayFormat.FormatString-------失去焦点是控件显示的格式,timeEdit用不上 EditMask----------- ...