浅淡代理模式以及其适用性

1.什么是代理模式？
其实代理这个东西就源自于生活,好比你要去买个电脑，你不可能到厂商那去买，不仅不方便，而且麻烦，这时候就有许多的代理商，在代理商你不仅可以买到你所需的产品，同时还可以享受附加产品，比如售后，风险保障以及赠品等等。这样相当于代理商衍生了附加的东东。
JAVA中的代理模式：
我们仍以买东西这个模型来
Java代码
[JAVA]
public class Company {
public void sale()
{
System.out.println(“SALE PRODUCT ONLY”);
}
}
[/JAVA]

最初的这个模型，只有company,他只单纯的卖产品，这时我们为其加入代理商，代理商不仅卖商品，还会有一些附加产品.这时就需要进行一些改动。
一个抽象类，负责提供 “卖产品”的抽象方法
[JAVA]
public abstract class BaseSale {
public abstract void sale();
}
[/JAVA]
COMPANY对象继承抽象类
[JAVA]
public class Company extends BaseSale{
public void sale()
{
System.out.println(“SALE PRODUCT ONLY”);
}
}
[/JAVA]
建立代理商
Java代码
[JAVA]
public class Retail extends BaseSale{
private BaseSale baseSale;
public Retail(BaseSale baseSale)
{
this.baseSale = baseSale;
}
public void saleAdd_On()
{
System.out.println(“sale Add-On”);
}
@Override
public void sale() {
baseSale.sale();
this.saleAdd_On();
}
}
[/JAVA]
模拟购买行为,此时用户通过代理商进行购买
[JAVA]
public class Buy {
public static void main(String[] args) {
Company company = new Company();
BaseSale baseSale = new Retail(company);
baseSale.sale();
}
}
[/JAVA]
运行结果：
SALE PRODUCT ONLY
sale Add-On

以上就是一个简单的静态代理模式。此节只讲述静态模式，当然也因为我本人不太喜欢动态代理。

从这种代理模式来说，其中最为实在的就是同一个指定方法里面进行了多态，这样在开发中给我们带来了便利，同时利于维护程序结构。
像上面所做的还可以进行一层优化，以适用于数据配置：
[JAVA]
List BaseSalelist  = getBaseSaleList();
BaseSale baseSale = new Retail(list);
baseSale.sale();
[/JAVA]
这样将所有的代理加入List中，通过相关的逻辑从相应的配置中读取， 这样就相当的方便。

2. 代理模式在开发中的应用
简单的静态代理到此告一段落，本人很喜欢将代理模式用于实际开发中，接下来我会说说我对于代理模式的应用，当然也希望各位大牛拍砖。
我的应用方式其实很相似于AOP的思想，但是我不喜欢使用SPRING　AOP，原因也是因为我不太喜欢动态代理的缘由。
在我们开发中，经常有一些相似的操作或是预处理，比如我们在新增一个对象的时候，我们需要对此对象进行一些的验证，如果UPDATE，我们经常都需要进行乐观锁设置等等。这些操作，如果使用代理模式可以避免一些重复的CODING，更重要的是避免了因疏忽导致的低级错误。

建立抽象类，里面有 update , add 方法
[JAVA]
public abstract class BaseBO {
public abstract boolean update(BaseDO baseDO);
public abstract boolean add(BaseDO baseDO);
}
[/JAVA]
以一个员工业务对象为例，这里是具体的员工对象处理
[JAVA]
public class StaffBO extends BaseBO {
public boolean add(BaseDO baseDO) {
// add baseDO ..
}
@Override
public boolean update(BaseDO baseDO) {
// update baseDO..
}
[/JAVA]
建立代理类
[JAVA]
public class BaseProxyProcess extends BaseBO {
private BaseBO  boEntity;
private BaseDO  baseDO;
// 构造
public BaseProxyProcess(BaseBO boEntity, BaseDO baseDO) {
this.boEntity = boEntity;
this.baseDO =  baseDO;
}
private BaseDO BeforeUpdate(BaseDO baseDO) {
//  update前预处理
}
private BaseDO BeforeAdd(BaseDO baseDO)
{
//  add 前预处理
}
@Override
public boolean add(BaseDO baseDO) {
//代理add 事件
return boEntity.add(this.BeforeAdd(baseDO));
}
@Override
public boolean update(BaseDO baseDO) {
// 代理update 事件
return boEntity.update(this.BeforeUpdate(baseDO));
}
[/JAVA]
代理完毕，此时系统只需调用代理方法，而无需直接调用staff方法
[JAVA]
public class StaffAO {
private StaffBO staffBO;
public ResultWrapper createStaff(Staff staff)
{
//通过构造方法将欲被代理类实体(staffBO)传入并进行代理
proxy = new BaseProxyProcess(staffBO, staff);
proxy.add(staff));//
//….
}
public ResultWrapper updateStaff(Staff staff)
{
proxy = new BaseProxyProcess(staffBO ,staff);
proxy.update(staff);
//….
}
[/JAVA]
这样在系统中，开发人员所有的对象操作全部调用代理，这样不仅可以节省代码量，也可以避免不必要的错误。当然有许多人认为在AOP流行的当代，这个代理做法完全没有必要，其实各有各的选择吧。权当参考～

以上皆属本人自己的想法，如果有不妥之处请回复， 欢迎交流