代理类
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到的角色有:
抽象角色:声明真实对象和代理对象的共同接口;
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,
同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替
真实对象。同时,代理对象可以在执行真实对象操作时,附加其他
的操作,相当于对真实对象进行封装;
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象;
代理类相当于中间人,并不具有客户真正需要真实存在的物体,只是手中握有资源,
并能根据客户的要求,和真实的物体拥有者进行交流,传递信息!
-----------------------------------------------------------------------------------------------------------------------------------------------------
代理分静态代理和动态代理
静态代理:涉及角色有:抽象角色(抽象类),真实角色(继承抽象类),代理角色(继承抽象类);当然还有客户
/*把他们放在一个包下即可*/
//抽象角色
abstract public class Subject{
abstract public void request();
}
//真实角色
public class RealSubject extends Subject{ //继承抽象角色并重写起其方法
public void request() {
System.out.println("From real subject.");
}
}
//代理角色
public class ProxySubject extends Subject{ //继承同一对象
private RealSubject realSubject; // 以真实角色作为代理角色的属性
public void request() { // 该方法封装了真实对象的request方法
preRequest(); //调用真实对象自己的方法,为真实角色附加的信息,也是代理类的给你之一
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request(); // 此处执行真实对象的request方法
postRequest(); //调用真实对象自己的方法,为真实角色附加的信息,也是代理类的给你之一
}
private void preRequest() {
System.out.println("先前做的事情");
}
private void postRequest() {
System.out.println("之后做的事情");
}
public class Client{
public static void main(String[] args)
{
Subject sub = new ProxySubject(); //多态,父类的引用指向子类的实例对象
sub.request();
}
}
之后做的事情
上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色!
如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
动态代理:
Java动态代理类位于java.lang.reflect包下,一般主要涉及到以下两个类(接口算作特殊类):
(1)Interface InvocationHandler:该接口中仅定义了一个方法public object invoke(Object obj,Method method, Object[] args)
在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,
如上例中的request(),args为该方法的参数数组。 这个抽象方法在代理类中动态实现。
(2)Proxy:该类即为动态代理类,作用类似于上例中的ProxySubject,其中主要包含以下内容:protected Proxy(InvocationHandler h):构造函数,用于给内部的h赋值;
static Class getProxyClass (ClassLoader loader, Class[] interfaces):
获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组;
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):
返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
所谓动态代理类是这样一种类:它是在运行时生成的class,在生成它时你必须提供一组interface给它,
然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。
当然,这个动态代理类其实就是一个Proxy,它不会替你作实质性的工作,
在生成它的实例时你必须提供一个handler,由它接管实际的工作。
动态代理:涉及角色有:接口角色(这里是接口),具体角色(实现接口的类),代理处理器 (实现了调用处理器的类);当然还有客户(在这里动态实现代理类)
/*把他们放在一个包下即可*/
//接口角色(之前是抽象类,此处应改为接口)
public interface Subject {
public void request();
}
//具体角色
public class RealSubject implements Subject {
public RealSubject() { } //构造函数
public void request() { //复写接口中的方法
System.out.println("真正做事的。");
}
}
//代理处理器
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 该代理类的内部属性为Object类,实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值;
* 此外,在该类还实现了invoke方法,该方法中的 method.invoke(sub,args);
* 其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,
* args为执行被代理对象相应操作所需的参数。
* 通过动态代理类,我们可以在调用之前或之后执行一些相关操作
*/
public class Dynamicsubject implements InvocationHandler { //这里实现的是InvocationHandler接口
private Object sub;
public Dynamicsubject(Object obj) { //重载构造函数
sub = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//invoke()中的三个参数分别是代理类,代理方法,该方法的参数
System.out.println("调用前" + method);
method.invoke(sub, args);
System.out.println("调用后 " + method);
return null;
}
}
//客户端
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client {
static public void main(String[] args) throws Throwable {
RealSubject rs = new RealSubject(); // 在这里指定被代理类
InvocationHandler ds = new Dynamicsubject(rs); //多态,父类的引用指向子类的实例对象
Class<?> cls = rs.getClass(); //通过反射得到代理类class文件
// 以下是一次性生成代理
Subject subject = (Subject) Proxy.newProxyInstance( //动态创建真实代理类
cls.getClassLoader(), cls.getInterfaces(), ds); //将代理类的类加载器,接口,调用处理器传入
subject.request();
}
}
运行结果:调用前public abstract void DynamicProxy.Subject.request()
真正做事的。
调用后 public abstract void DynamicProxy.Subject.request()
Client类通过DynamicSubject类生成真实类的代理对象,并经由Proxy类的newProxyInstance方法实现
生成“一个能做真实类做的事的代理”,并由该代理直接调用真实类所具有的方法。
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到的角色有:
抽象角色:声明真实对象和代理对象的共同接口;
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,
同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替
真实对象。同时,代理对象可以在执行真实对象操作时,附加其他
的操作,相当于对真实对象进行封装;
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象;
代理类相当于中间人,并不具有客户真正需要真实存在的物体,只是手中握有资源,
并能根据客户的要求,和真实的物体拥有者进行交流,传递信息!
-----------------------------------------------------------------------------------------------------------------------------------------------------
代理分静态代理和动态代理
静态代理:涉及角色有:抽象角色(抽象类),真实角色(继承抽象类),代理角色(继承抽象类);当然还有客户
/*把他们放在一个包下即可*/
//抽象角色
abstract public class Subject{
abstract public void request();
}
//真实角色
public class RealSubject extends Subject{ //继承抽象角色并重写起其方法
public void request() {
System.out.println("From real subject.");
}
}
//代理角色
public class ProxySubject extends Subject{ //继承同一对象
private RealSubject realSubject; // 以真实角色作为代理角色的属性
public void request() { // 该方法封装了真实对象的request方法
preRequest(); //调用真实对象自己的方法,为真实角色附加的信息,也是代理类的给你之一
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request(); // 此处执行真实对象的request方法
postRequest(); //调用真实对象自己的方法,为真实角色附加的信息,也是代理类的给你之一
}
private void preRequest() {
System.out.println("先前做的事情");
}
private void postRequest() {
System.out.println("之后做的事情");
}
}
public class Client{
public static void main(String[] args)
{
Subject sub = new ProxySubject(); //多态,父类的引用指向子类的实例对象
sub.request();
}
}
运行结果:先前做的事情
From real subject.之后做的事情
上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色!
如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
动态代理:
Java动态代理类位于java.lang.reflect包下,一般主要涉及到以下两个类(接口算作特殊类):
(1)Interface InvocationHandler:该接口中仅定义了一个方法public object invoke(Object obj,Method method, Object[] args)
在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,
如上例中的request(),args为该方法的参数数组。 这个抽象方法在代理类中动态实现。
(2)Proxy:该类即为动态代理类,作用类似于上例中的ProxySubject,其中主要包含以下内容:protected Proxy(InvocationHandler h):构造函数,用于给内部的h赋值;
static Class getProxyClass (ClassLoader loader, Class[] interfaces):
获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组;
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):
返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
所谓动态代理类是这样一种类:它是在运行时生成的class,在生成它时你必须提供一组interface给它,
然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。
当然,这个动态代理类其实就是一个Proxy,它不会替你作实质性的工作,
在生成它的实例时你必须提供一个handler,由它接管实际的工作。
动态代理:涉及角色有:接口角色(这里是接口),具体角色(实现接口的类),代理处理器 (实现了调用处理器的类);当然还有客户(在这里动态实现代理类)
/*把他们放在一个包下即可*/
//接口角色(之前是抽象类,此处应改为接口)
public interface Subject {
public void request();
}
//具体角色
public class RealSubject implements Subject {
public RealSubject() { } //构造函数
public void request() { //复写接口中的方法
System.out.println("真正做事的。");
}
}
//代理处理器
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 该代理类的内部属性为Object类,实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值;
* 此外,在该类还实现了invoke方法,该方法中的 method.invoke(sub,args);
* 其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,
* args为执行被代理对象相应操作所需的参数。
* 通过动态代理类,我们可以在调用之前或之后执行一些相关操作
*/
public class Dynamicsubject implements InvocationHandler { //这里实现的是InvocationHandler接口
private Object sub;
public Dynamicsubject(Object obj) { //重载构造函数
sub = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//invoke()中的三个参数分别是代理类,代理方法,该方法的参数
System.out.println("调用前" + method);
method.invoke(sub, args);
System.out.println("调用后 " + method);
return null;
}
}
//客户端
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Client {
static public void main(String[] args) throws Throwable {
RealSubject rs = new RealSubject(); // 在这里指定被代理类
InvocationHandler ds = new Dynamicsubject(rs); //多态,父类的引用指向子类的实例对象
Class<?> cls = rs.getClass(); //通过反射得到代理类class文件
// 以下是一次性生成代理
Subject subject = (Subject) Proxy.newProxyInstance( //动态创建真实代理类
cls.getClassLoader(), cls.getInterfaces(), ds); //将代理类的类加载器,接口,调用处理器传入
subject.request();
}
}
运行结果:调用前public abstract void DynamicProxy.Subject.request()
真正做事的。
调用后 public abstract void DynamicProxy.Subject.request()
Client类通过DynamicSubject类生成真实类的代理对象,并经由Proxy类的newProxyInstance方法实现
生成“一个能做真实类做的事的代理”,并由该代理直接调用真实类所具有的方法。