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

浅淡代理模式以及其适用性
1.什么是代理模式？
   其实代理这个东西就源自于生活,好比你要去买个电脑，你不可能到厂商那去买，不仅不方便，而且麻烦，这时候就有许多的代理商，在代理商你不仅可以买到你所需的产品，同时还可以享受附加产品，比如售后，风险保障以及赠品等等。这样相当于代理商衍生了附加的东东。
  JAVA中的代理模式：
  我们仍以买东西这个模型来
  

public class Company {public void sale(){System.out.println("SALE PRODUCT ONLY");}}

最初的这个模型，只有company,他只单纯的卖产品，这时我们为其加入代理商，代理商不仅卖商品，还会有一些附加产品.这时就需要进行一些改动。
一个抽象类，负责提供 “卖产品”的抽象方法

public abstract class BaseSale {public abstract void sale();}

COMPANY对象继承抽象类

public class Company extends BaseSale{public void sale(){System.out.println("SALE PRODUCT ONLY");}}

建立代理商

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");}@Overridepublic void sale() {     baseSale.sale();     this.saleAdd_On();}}

模拟购买行为,此时用户通过代理商进行购买

public class Buy {public static void main(String[] args) {Company company = new Company();BaseSale baseSale = new Retail(company);baseSale.sale();}}

运行结果：
SALE PRODUCT ONLY
sale Add-On

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

从这种代理模式来说，其中最为实在的就是同一个指定方法里面进行了多态，这样在开发中给我们带来了便利，同时利于维护程序结构。
像上面所做的还可以进行一层优化，以适用于数据配置：

List<BaseSale> list  = getBaseSaleList();BaseSale baseSale = new Retail(list);baseSale.sale();

这样将所有的代理加入List中，通过相关的逻辑从相应的配置中读取， 这样就相当的方便。

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

建立抽象类，里面有 update , add 方法

public abstract class BaseBO {　　　　public abstract boolean update(BaseDO baseDO);public abstract boolean add(BaseDO baseDO);}

以一个员工业务对象为例，这里是具体的员工对象处理

public class StaffBO extends BaseBO {       public boolean add(BaseDO baseDO) {          // add baseDO ..}@Overridepublic boolean update(BaseDO baseDO) {  // update baseDO..}

建立代理类

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 前预处理}        @Overridepublic boolean add(BaseDO baseDO) {             //代理add 事件     return boEntity.add(this.BeforeAdd(baseDO));}@Overridepublic boolean update(BaseDO baseDO) {             // 代理update 事件     return boEntity.update(this.BeforeUpdate(baseDO));}

代理完毕，此时系统只需调用代理方法，而无需直接调用staff方法

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);            //....}

这样在系统中，开发人员所有的对象操作全部调用代理，这样不仅可以节省代码量，也可以避免不必要的错误。当然有许多人认为在AOP流行的当代，这个代理做法完全没有必要，其实各有各的选择吧。权当参考～

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

查看更多 下一篇