代理设计模式--Proxy

代理模式（Proxy）：为其他对象提供一种代理以控制这个对象的访问。

代理模式类别：

1.远程代理：为一个对象在不同的地址空间提供局部代理，这样可以隐藏一个对象存在于不同地址空间的事实。比如：使用nexus构建私服就相当于是使用远程代

理的方式，使得工程依赖的jar包不要一直去远程访问。

2.虚拟代理：根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象。这样就可以在一定的程度上提升系统的性能。

3.安全代理：用来控制真实对象访问时的权限。一般用于对象应该有不同的访问权限的时候。

4.智能指引：是指当调用真实对象时，代理处理另外的一些事情。如：计算真实对象的引用次数，这样当该对象没有引用是，可以自动释放它；或当第一次引用一

个持久对象时，将它装入内存；或在访问一个实际对象前，检查是否已经锁定它，以确保其他对象不能改变它，这些都是通过代理在访问一个对象时附加一些内部的处

理。

总之，代理模式其实就是在访问对象时插入一定程度的间接性处理，因为这种机制可以附加多种用途。

上面讲解都是理论上的东西，下面结合代码来分析一下代理模式中的两种代理模式：静态代理和动态代理

代理模式一般涉及到三个角色：

1.抽象角色：声明真实角色的接口

2.真实角色：抽象角色的实现

3.代理角色：代理角色内可以含有真实角色的引用，同时可以实现一些附加操作

一、静态代理

静态代理：静态代理中就是简单的将真实角色中的方法重新实现，重载抽象类中声明的方法。

静态代理的缺点是代理与真实角色一一对应，所以对于每一个要被代理的类，都要有一个代理类与之对应，并且都要实现抽象角色中的所有方法。所以这样代码的

复用率就下降了。

下面就贴出代码：

A.抽象角色：

package com.jjyy.jdbc.inter;

/**
* 电话的接口
*
* @author JiangYu 2015年3月29日
*
*/
public interface Phone {
/**
* call 方法
*/
public void call();
/**
* sendMsg 方法
*/
public void sendMsg();
}

B.代理角色

package com.jjyy.jdbc.decoration;

import com.jjyy.jdbc.inter.Phone;
/**
* 静态代理模式---前提是对象已经存在了
* @author JiangYu
* 2015年3月29日
*
*/
public class DecorateSamsungPhone implements Phone{

private Phone phone = null;
//通过构造方法传递对象
public DecorateSamsungPhone(Phone phone) {
this.phone = phone;
}
@Override
public void call() {
phone.call();
}

@Override
public void sendMsg() {
System.out.println("SamsungPhone sendMsg:Hello Samsung");
}

}

C.真实对象

package com.jjyy.jdbc.decoration;

import com.jjyy.jdbc.inter.Phone;

/**
* 静态代理设计模式
* 真实类要和代理类要实现相同的接口
* 在代理类的构造方法中传入被代理类的对象，这样就可以使用被代理对象的方法进行不同的装饰
* @author JiangYu
* 2015年3月29日
*
*/
public class SamsungPhone implements Phone {

@Override
public void call() {
System.out.println("SumsungPhone call...");
}

@Override
public void sendMsg() {
System.out.println("Phone sendMsg...");
}

}

D.测试类：

package com.jjyy.jdbc.decoration;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

import com.jjyy.jdbc.dynamicProxy.DynamicProxyIPhone;
import com.jjyy.jdbc.inter.Phone;
/**
* 静态代理模式和动态代理设计模式
* @author JiangYu
* 2015年3月29日
*
*/
public class DesignModel {
/**
* 静态代理设计模式
*/
@Test
public void decorationDesignTest(){
//被装饰类
SamsungPhone phone = new SamsungPhone();
//装饰类
DecorateSamsungPhone samsungPhone = new DecorateSamsungPhone(phone);
//调用装饰之后的对象的方法
samsungPhone.call();
samsungPhone.sendMsg();
}

}

二、动态代理

动态代理：为了解决静态代理的问题----代码的复用率低。动态代理一般要满足代理的三个角色，然后还要实现一个接口---InvocationHandler，该接口中有一

个invoke方法。

理论的知识有点抽象，贴出代码：

A.真实角色

package com.jjyy.jdbc.decoration;

import com.jjyy.jdbc.inter.Phone;
/**
* 动态代理：真实角色
* @author JiangYu
* 2015年3月29日
*
*/
public class IPhone implements Phone{

@Override
public void call() {
System.out.println("IPhone call...");
}

@Override
public void sendMsg() {
System.out.println("IPhone sendMsg...");
}

}

B.代理角色

package com.jjyy.jdbc.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 动态代理类--代理类
* @author JiangYu
* 2015年3月29日
*
*/
public class DynamicProxyIPhone implements InvocationHandler {

private Object obj = null;

public Object registerObj(Object obj){
this.obj = obj;
//所有的接口都绑定到了代理类对象上，保证真实对象和代理对象有着共同的行为
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("dynamic Proxy...");
//代理对象处理特殊的方法
if ("sendMsg".endsWith(method.getName())) {
System.out.println("IPhone sendMsg:Hello IPhone From DynamicProxy...");
return null;
}else {
return method.invoke(this.obj, args);
}
}
}

C.测试类

package com.jjyy.jdbc.decoration;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

import com.jjyy.jdbc.dynamicProxy.DynamicProxyIPhone;
import com.jjyy.jdbc.inter.Phone;
/**
* 静态代理模式和动态代理设计模式
* @author JiangYu
* 2015年3月29日
*
*/
public class DesignModel {

/**
* 动态代理设计模式--实现方式之二
* 1.真实类和代理类具有相同的行为
* 2.代理类要实现InvocationHandler接口，事项invoke方法
* 3.代理类可以对真实类的行为进行增强
* 4.调用代理类对象的方法
*/
@Test
public void dynamicProxyDesignTest(){
//真实类
IPhone phone = new IPhone();
//代理类
DynamicProxyIPhone proxy = new DynamicProxyIPhone();
//代理对象
IPhone proxyPhone = (IPhone) proxy.registerObj(phone);
//调用代理对象的方法
proxyPhone.call();
proxyPhone.sendMsg();
}
}

上面的动态代理方式是一种常规的方式，另外还有一种方式是比较常用的动态代理写法--在测试类中直接用内部类来实现InvocationHandler

package com.jjyy.jdbc.decoration;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

import com.jjyy.jdbc.dynamicProxy.DynamicProxyIPhone;
import com.jjyy.jdbc.inter.Phone;
/**
* 静态代理模式和动态代理设计模式
* @author JiangYu
* 2015年3月29日
*
*/
public class DesignModel {

/**
* 动态代理设计模式--实现方式之一
*/
@Test
public void proxyDesignTest(){
final IPhone iPhone = new IPhone();
//动态代理
Phone proxy = (Phone) Proxy.newProxyInstance(IPhone.class.getClassLoader(), IPhone.class.getInterfaces(), new InvocationHandler() {

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if("sendMsg".equals(method.getName())){//如果是sendMsg时，就进行特殊的处理
System.out.println("Iphone sendMsg:Hello IPhone");
return null;
}else {//其他的方法还是按照原来的方法进行
return method.invoke(iPhone, args);
}
}
});
//通过代理对象去执行响应的方法
proxy.call();
proxy.sendMsg();
}

}

以上的动态代理是jdk的proxy，其实它也不是完美的，它只能代理实现了接口的类，不能对类本身实现代理，如果要完成对类本身实现代理，需要用到一个开源的

cglib。