代理模式分为2种
其实就是实现一个代理类,来代理你所需要代理的类,访问的时候,通过访问代理类,来达到一定的效果
举个例子:
权限:有一个系统有很多权限,比如说只有管理员有增加的功能.用户访问到DAO的saveMessage方法
这个其实就是真正需要的保存方法,但是只有管理员才有权限
public class DbMessage implements Message{
...
public void saveMessage(String name) throws ForumAlreadyExistsException {
this.name = name;
//这里真正将新名称保存到数据库中
saveToDb();
}
}
怎么办了,创建一个代理类
public class MessageProxy implements Message{
private DbMessage dbMessage;
private UserBean user;
public ForumProxy(DbMessage dbMessage, UserBean user)
{
this.dbMessage= dbMessage;
this.user= user;
}
.....
public void saveMessage(String name) throws Exception
{
//只有是系统或论坛管理者才可以修改名称
if (user.getRight.equal("***")) {
forum.saveMessage(name);
}
else {
throw new Exception();
}
}
}
利用代理类来实现权限的判断,Jive论坛系统的权限好象采用的代理模式,不过如果不是很了解的人,用起来可能会为了使用
代理模式而写代理模式,这样就违背了原来的意愿,只有写了一定多的代码的人才能炉火纯青的写.我只能表面理解.
1:静态代理.静态代理代理和被代理对象在代理之前是确定的。他们都实现相同的接口或者继承相同的抽象类。
上面的权限采用的也是静态代理
贴一些网上面比较有说明性的代码
Subject.java
/**
* 抽象角色
*/
public abstract class Subject {
abstract public void request();
}
RealSubject.java
/**
* 真实角色：实现了Subject的request()方法
*/
public class RealSubject extends Subject {
public RealSubject() {
}
public void request() {
System.out.println("真实角色的请求方法RealSubject.request()被调用!");
}
}
ProxySubject.java
/**
* 代理角色
*/
public class ProxySubject extends Subject {
private RealSubject realSubject; // 以真实角色作为代理角色的属性
public ProxySubject() {
}
// 该方法封装了真实对象的request方法
public void request() {
preRequest(); //代理前执行的操作
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request(); // 此处执行真实对象的request方法
postRequest(); //代理后执行的操作
}
private void preRequest() {
// something you want to do before requesting
System.out.println("代理前执行的操作ProxySubject.preRequest()!");
}
private void postRequest() {
// something you want to do after requesting
System.out.println("代理后执行的操作ProxySubject.postRequest()!");
}
}
Client.java
/**
* 客户端调用
*/
public class Client {
public static void main(String[] args) {
Subject sub = new ProxySubject();
sub.request();
}
}
这就是静态代理,通过访问代理类,来实现想要的方法,
客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，同样达
到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。
另外，如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是
实际使用时，一个真实角色必须对应一个 代理角色，如果大量使用会导致类的急剧膨胀.
2:动态代理
如果事先并不知道真实角色，该如何使用代理,这就是动态代理所要解决的问题.
以下引用
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接口中声明过的方法)
动态代理类
所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该
class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个
Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接
管实际的工作
在使用动态代理类时，我们必须实现InvocationHandler接口。
底下的例子和上面共用同个subject接口,
动态代理类DynamicSubject.java
/**
* 代理处理器
*
* 该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；
* 此外，在该类还实现了invoke方法，该方法中的 method.invoke(sub,args);
* 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，
* args为执行被代理对象相应操作所需的参数。
* 通过动态代理类，我们可以在调用之前或之后执行一些相关操作
*/
public class DynamicSubject implements InvocationHandler {
private Object sub; //被代理对象
public DynamicSubject() {
}
/**
* 构造方法,并初始化被代理对象
* @param obj 是被代理的对象
*/
public DynamicSubject(Object obj) {
sub = obj;
}
/**
*
* @param proxy 指代理类
* @param method 被代理的方法
* @param args 被代理的方法所需要的参数数组
* @return 在代理实例上处理方法调用并返回结果。
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理前执行的操作!");
method.invoke(sub, args);
System.out.println("代理后执行的操作!");
return null;
}
client.java
/**
* 客户端
*/
public class Client {
static public void main(String[] args) throws Throwable {
RealSubject rs = new RealSubject(); // 在这里指定被代理类
//通过被代理类对象声明一个代理类对象
InvocationHandler dynamicSubject = new DynamicSubject(rs);
Class<?> cls = rs.getClass();
// 以下是一次性生成代理类实例:
// 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
Subject subject = (Subject) Proxy.newProxyInstance(
cls.getClassLoader(), //定义代理类的类加载器
cls.getInterfaces(), //代理类要实现的接口列表
dynamicSubject); //指派方法调用的调用处理程序:InvocationHandler对象
subject.request(); //调用代理处理器上的方法
}
}
上面用动态代理来代理了静态代理,在运行时生成Class,在生成时候给他一组接口,然后这个class就宣称实现了这些接口
上面的例子实现代理了自己写的类,其实动态代理可以代理已有的类,例如vector
public class VectorProxy implements InvocationHandler {
private Object proxyobj;
public VectorProxy(Object obj) {
proxyobj = obj;
}
public static Object factory(Object obj) {
Class<?> cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),
cls.getInterfaces(), new VectorProxy(obj));
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("before calling " + method);
if (args != null) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i] + "");
}
}
Object object = method.invoke(proxyobj, args);
System.out.println("after calling " + method);
return object;
}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
List<String> v = (List<String>) factory(new Vector<String>(10));
v.add("New");
v.add("York");
System.out.println(v);
v.remove(0);
System.out.println(v);
}
}
当做个笔记,
扫一扫
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
