动态代理体现了反射的动态性。
反射的动态性就是编译期是无法确定代码体的结构,而运行时才确定下来,并且会随着运行环境的不同(如创建的运行时类的不同)而有不同的代码体。
动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。
静态代理:
package com.xxx.java;
/**
* 静态代理举例
* 特点:代理类和被代理类在编译期间,就确定下来了。
*/
//接口
interface ClothFactory{
void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory = factory;
}//factory即nike
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();//Nike工厂生产一批运动服
System.out.println("代理工厂做一些后续的收尾工作");
}
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产一批运动服");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nike = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nike);//将被代理类的对象作为代理类的形参
proxyClothFactory.produceCloth();
}
}
动态代理:
package com.xxx.java;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Human{
String getBelief();
void eat(String food);
}
//被代理类(被代理类静态,代理类要动态)
class SuperMan implements Human{
//重写接口中的getBelief、eat抽象方法
@Override
public String getBelief() {
return "I believe I can fly!";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃" + food);
}
}
/*
要想实现动态代理,需要解决的问题?
问题一:如何根据加载到内存中的被代理类,动态的创建一个代理类及其对象。
问题二:当通过代理类的对象调用方法a时,如何动态的去调用被代理类中的同名方法a。(代理类调用方法a,怎么样被代理类也调方法a)
*/
class ProxyFactory{
//调用此方法,返回一个代理类的对象。解决问题一
public static Object getProxyInstance(Object obj){//obj:被代理类的对象(根据加载到内存中的被代理类对象obj,动态的创建一个代理类及其对象)
MyInvocationHandler handler = new MyInvocationHandler();//创建MyInvocationHandler类的对象handler
handler.bind(obj);//给被代理类的对象obj赋值
//newProxyInstance:创建代理类的对象
//obj.getClass().getClassLoader():获取obj是由哪个类加载器加载的;(代理类和被代理类要实现同样的类加载器)
//obj.getClass().getInterfaces():获取obj的接口(代理类和被代理类要实现同样的接口)
//handler:InvocationHandler,接口。因为InvocationHandler是接口,所以后面还要定义这个接口的实现类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
}
}
class MyInvocationHandler implements InvocationHandler {//InvocationHandler是MyInvocationHandler类型的对象
private Object obj;//需要使用被代理类的对象进行赋值
public void bind(Object obj) {//使用bind(绑定)的方法对被代理类的对象obj赋值
this.obj = obj;
}
//当我们通过代理类的对象,调用方法a时,就会自动的调用如下的方法:invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
@Override
/*proxy:代理类的对象
*method:代理类的对象所调用的方法
*
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//抽象方法的具体实现
//method:即为代理类对象调用的方法,此方法也就作为了被代理类对象要调用的方法
//obj:被代理类的对象
//args:obj对象所对应的方法的形参
Object returnValue = method.invoke(obj, args);
//上述方法的返回值就作为当前类中的invoke()的返回值。
return returnValue;
}
}
public class ProxyTest {
public static void main(String[] args) {
SuperMan superMan = new SuperMan();
//proxyInstance:代理类的对象
//通过ProxyFactory.getProxyInstance(superMan)创建代理类对象proxyInstance,此时通过handler会直接跳到handler的实现类MyInvocationHandler里面的invoke方法,
//根据传入的形参superMan,或者根据human,确定该代理类对象proxyInstance所对应的被代理类。
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象proxyInstance调用方法时,会自动的调用被代理类SuperMan中同名的方法
String belief = proxyInstance.getBelief();
System.out.println(belief);
proxyInstance.eat("四川麻辣烫");
System.out.println("*****************************");
NikeClothFactory nikeClothFactory = new NikeClothFactory();
//动态创建代理类的对象proxyClothFactory
ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
//通过代理类的对象调用produceCloth方法,此时会动态调用被代理类nike这个对象的方法
proxyClothFactory.produceCloth();
//即只需要提供被代理类、以及接口,然后即可动态创建代理类的对象
}
}
很显然,
静态代理模式下,StaticProxyTest
的mian函数调用produceCloth时,代理类和被代理类的对象一开始就定死了。
而在动态代理模式下,客户通过代理类ProxyFactory
来构造想要调用的方法所处的类的对象(如):
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
再调用该对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象,如:proxyInstance.getBelief();
、proxyInstance.eat("四川麻辣烫");
、 proxyClothFactory.produceCloth();
等等。
那么在这个过程中,我们想要实现某个类的某个功能(要实现这些方法首先需要构建类(被代理类)的对象,再去调用这些方法),会直接根据不同的被代理类的对象,动态地创建代理类的对象。