Java反射与动态代理
2019-09-04 07:19:20来源:博客园 阅读 ()
Java反射与动态代理
1.反射对象
1.1 通过反射构建无参数对象
public class ReflectServiceImpl {
public void sayHello(String name){
System.err.println("Hello "+name);
}
public ReflectServiceImpl getInstance(){
ReflectServiceImpl object = null;
try {
//给类加载器注册一个类ReflectServiceImpl的全限定类名,然后通过newInstance方法初始化一个类对象
object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return object;
}
}
1.2 通过反射生成带有参数的构建方法
public class ReflectServiceImpl2 {
private String name;
public ReflectServiceImpl2(String name){
this.name = name;
}
public void sayHello(String name){
System.err.println("Hello "+name);
}
public ReflectServiceImpl2 getInstance(){
ReflectServiceImpl2 object = null;
try {
/*
想通过forName加载到类的加载器。然后通过getConstructor方法,他的参数可以是多个,
这里定义为String.class,意为有且只有一个参数类型为String的构建方法
通过这个方法可以对重名方法进行排除,此时再用newInstance方法生成对象,只是newIntstance方法也多了一个参数而已
实际就等于object=new ReflectServiceImpl2("迪丽热巴");
*/
Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl2").getConstructor(String.class).newInstance("迪丽热巴");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return object;
}
}
反射的优点是只要配置就可以生成对象,可以解除程序的耦合度,比较灵活。反射的缺点是运行比较慢。但是大部分情况下为了灵活度,降低程序的耦合度,我们还是会使用反射的。 比如Spring IoC容器
2.反射方法
public class ReflectServiceImpl {
public void sayHello(String name){
System.err.println("Hello "+name);
}
public ReflectServiceImpl getInstance(){
ReflectServiceImpl object = null;
try {
//给类加载器注册一个类ReflectServiceImpl的全限定类名,然后通过newInstance方法初始化一个类对象
object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return object;
}
//获取和反射方法
public Object reflectMethod(){
Object obj = null;
ReflectServiceImpl target = new ReflectServiceImpl();
try {
/*
* 当有了具体的对象target,而不知道具体是哪个类时,也可以使用
* target.getClass().getMethod("sayHello", String.class);来代替他
* 其中第一个参数是方法名称,第二个参数是参数类型,是一个列表,多个参数可以继续编写多个类型,这样便能获得放射的方法对象
*
* */
Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class);
/*
* 放射方法 是运用obj=method.invoke(target,"迪丽热巴");代码完成的
* 第一个参数是target ,就是确定用哪个对象调用方法,而"迪丽热巴"是参数
* 就等同于target.sayHello("迪丽热巴")
* */
obj=method.invoke(target,"迪丽热巴");
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return obj;
}
}
3.实例
通过实例来看看如何放射生成对象和反射调度方法
public static Object reflect(){
ReflectServiceImpl object = null;
try {
//反射得到ReflectServiceImpl对象
object = (ReflectServiceImpl)Class.forName("com.lean.ssm.chapter2.ReflectServiceImpl").newInstance();
//反射得到sayHello方法
Method method = object.getClass().getMethod("sayHello", String.class);
try {
//相当于object.sayHello
method.invoke(object,"迪丽热巴");
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return object;
}
获取放射对象需要使用类加载器,获取放射方法需要知道是哪个对象
2.动态代理模式
动态代理的意义在于生成一个占位(又称代理对象),来代理真实对象,从而控制真实对象的访问
先来谈谈什么是代理模式。假设这样的一个场景,你的公司是一家软件公司,你是一位软件工程师。客户带着需求去找公司显然不会直接和你谈,而是去找商务谈,此时客户会认为商务就代表公司。
让我们用一张图来表示代理模式的含义
显然客户是通过商务区访问软件工程师的,那么商务(代理对象)的意义在于什么呢?
商务可以进行谈判,比如项目启动前的商务谈判,软件的价格,交付进度的时间节点等,
或者项目完成后的商务追讨收账款等。
代理的作用就是:在真实对象访问之前或者之后加入对应的逻辑,或者根据其他的规则控制是否使用真实对象
经过上面的论述,我们知道商务和软件工程师是代理和被代理的关系,客户是经过商务去访问软件工程师的。此时客户就是程序中的调用者,商务就是代理对象,软件工程师就是真实对象。
? 所以,我们需要在调用者调用对象之前产生一个代理对象,而这个代理对象需要和真实对象建立代理关系,所以代理必须分为两个步骤
代理对象和真实对象建立代理关系
实现代理对象的代理逻辑方法
在Java中有多种动态代理技术,比如JDK、CGLIB、Javassist、ASM,其中最常用的动态代理技术有两种:一种是JDK动态代理,这是JDK自带的功能;另一种是CGLIB,这是第三方提供的一个技术。目前Spring常用JDK和CGLIB,而mybatis还是用了Javassist,无论哪种代理技术,他们的理念都是相似的。
在JDK动态代理中,我们必须使用接口,而CGLIB不需要。
2.1 JDK动态代理
? JDK动态代理是 java.lang.reflect.*包提供的方式,他必须借助一个接口才能产生代理对象
定义接口
public interface HelloWorld {
public void sayHelloWorld();
}
实现接口
public class HelloWordImpl implements HelloWorld {
public void sayHelloWorld() {
System.out.println("Hello World");
}
}
? 这是最简单的Java接口和实现类的关系,此时可以开始动态代理了。按照我们之前的分析,先要建立起代理对象和真实服务对象的关系,然后实现代理逻辑,所以一共分为两步
? 在JDK动态代理中,要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口,他里面定义了一个invoke方法,并提供接口数组用于下挂代理对象
?
//创建代理对象,必须实现InvocationHandler接口
public class JdkProxy implements InvocationHandler {
//真实对象
private Object target = null;
/**
* 建立代理对象和真实对象的代理关系,并返回代理对象
* @param target 真实对象
* @return 代理对象
*/
public Object bind(Object target){
//用于保存真实对象
this.target=target;
//返回的是代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
/**
*代理方法逻辑
* @param proxy 代理对象
* @param method 当前调度方法
* @param args 当前方法参数
* @return 代理返回结果
* @throws Throwable 异常
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("进入代理逻辑方法");
System.out.println("在调度真实对象前的服务");
//相当于调度真实对象的方法,只是通过反射实现而已
Object obj = method.invoke(target, args);
System.out.println("在调度真实对象之后的服务");
return obj;
}
}
第一步,建立代理对象和真实对象的关系。
newProxyInstance方法包含三个参数。
第一个是类加载器
第二个是把动态代理挂在哪个接口上
第三个是定义实现方法逻辑的代理类,this表示当前对象,他必须实现InvocationHandler接口的invoke方法,他就是代理逻辑方法的现实方法
第二步,实现代理逻辑方法,invoke方法可以实现代理逻辑,invoke方法的有3个参数
proxy,代理对象,就是bind方法生成的对象
method,当前调度的方法
args,调度方法的参数
测试动态代理
public static void testJdkProxy(){
JdkProxy jdk = new JdkProxy();
//绑定关系,因为挂在接口HelloWorld下,所以声明对象HelloWorld proxy
HelloWorld proxy =(HelloWorld)jdk.bind(new HelloWordImpl());
//注意,此时HelloWorld对象已经是一个代理对象,他会进入代理的逻辑方法invoke里
proxy.sayHelloWorld();
}
CGLIB动态代理
JDK动态代理必须提供接口才能使用,在一些不能提供接口的环境中,只能采用其他第三方技术,比如CGLIB动态代理。他的优势在于不需要提供接口,只要一个非抽象类就能实现动态代理
public class CglibProxy implements MethodInterceptor {
/**
* 生成CGLIB代理对象
* @param cls Class类
* @return Class类的CGLIB代理对象
*/
public Object getProxy(Class cls){
//CGLIB enhancer 增强类对象
Enhancer enhancer = new Enhancer();
//设置增强类型
enhancer.setSuperclass(cls);
//定义代理逻辑对象为当前对象,要求当前对象实现MethodInterceptor方法
enhancer.setCallback(this);
//生成代理对象并返回9
return enhancer.create();
}
/**
*
* @param proxy 代理对象
* @param method 方法
* @param args 方法参数
* @param methodProxy 方法代理
* @return 代理逻辑返回
* @throws Throwable 异常
*/
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("调用真实对象前");
//CGLIB反射调用真实对象方法
Object result = methodProxy.invokeSuper(proxy,args);
System.out.println("调用真实对象后");
return result;
}
}
? 这里用 了CGLIB的加强者,通过设置超类的方法(setSuperclass),然后通过setCallback(方法)设置哪个类为它的代理类。其中,参数为this就意味着当前对象,那就要求用this这个对象实现接口MethodInterceptor的方法——intercept,然后返回代理对象。
? 那么此时当前类的intercept方法就是其代理逻辑方法,其参数内容见代码注解,我们在反射真实对象前后进行了打印,CGLIB是通过如下代码完成的
Object result = methodProxy.invokeSuper(proxy,args);
? 测试一下CGLIB动态代理
public static void testCGLIBProxy(){
CglibProxy cp = new CglibProxy();
ReflectServiceImpl obj=(ReflectServiceImpl) cp.getProxy(ReflectServiceImpl.class);
obj.sayHello("迪丽热巴");
}
以上的所有内容皆来自Java EE互联网轻量级框架整合开发
原文链接:https://www.cnblogs.com/train99999/p/11454327.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
上一篇:Interger等包装类的比较
- 国外程序员整理的Java资源大全(全部是干货) 2020-06-12
- 2020年深圳中国平安各部门Java中级面试真题合集(附答案) 2020-06-11
- 2020年java就业前景 2020-06-11
- 04.Java基础语法 2020-06-11
- Java--反射(框架设计的灵魂)案例 2020-06-11
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash