初学菜鸟的学习日记——继续低端（代理模式设计）

前几天看了看设计模式，自己写过一段代理模式的代码也提上来，无头苍蝇，看到什么都想学，都学不精，无奈啊...

我的理解：代理模式的是一个可以把业务执行类和业务辅助处理类融合到一起执行的模式，在执行代理类的动作时，执行一切业务相关动作。用不同的业务实现类执行不同的业务，再把可以提取出来的共同业务特点撮成一个辅助处理业务的执行者。

1.先要有一件需要我们描述的东西，比如一个学习者learner

package proxy.inteface;


import proxy.entity.Knowledge;

/**
 * @author BigWet
 *万恶之源，一切动作都是为了它
 */
public interface ILearner {

    public Knowledge read();


    public void play();
}

学习者共有两个动作，就是读书和找小伙伴玩耍

2.要有具体的业务实现类。

package proxy.impl;

import proxy.entity.Knowledge;
import proxy.inteface.ILearner;

/**
 * @author BigWet
 *学习的实现类
 */
public class LearnerImpl implements ILearner{

    @Override
    public Knowledge read() {
        return new Knowledge("技能：看书");
    }
    @Override
    public void play() {
        System.out.println("装学习，瞎JB玩，啥都没学到");
    }
 }

也可以根据学习的内容不同创建其他的类 比如一个程序学习者

package proxy.impl;

import proxy.entity.Knowledge;

/**
 * @author BigWet
 *学习打代码的实现类 
 */
public class EncodeLearnerImpl extends LearnerImpl{

	@Override
	public Knowledge read() {
		return new Knowledge("新技能：看书——代理模式");
	}

}

看书操作的实体类

package proxy.entity;

/**
 * @author BigWet
 *具体业务操作的对象
 */
public class Knowledge {
    private String knowledge;
    public Knowledge(String knowlege){
        this.knowledge = knowlege;
    }
    public String getKnowledge(){
        return knowledge;
    }
}

3.看书前要先有书，所以要买书，但是还是规矩点吧，先搞一个通用的接口

package proxy.inteface;

/**
 * @author BigWet
 *业务处理辅助接口,可以什么都不定义,也可以定义一些东西,实现它的类要写明具体业务前后处理
 */
public interface Advice {
    public void doBefore();
    public void doAfter();
}

然后针对于学习业务再来一个接口

package proxy.inteface;

/**
 * @author 学习的业务前后处理接口
 *
 */
public interface StudyAdvice extends Advice{
}

最后再来具体的业务辅助实现

package proxy.impl.aop;

import proxy.inteface.StudyAdvice;

/**
 * @author BigWet
 *学习动作的前后处理，虽然不是Spring那种AOP，也不是传统的Aop，但是也有点那功能，就先这么叫吧
 */
public class StudyAopImpl implements StudyAdvice{

    @Override
    public void doBefore() {
        buyBook();
    }

    @Override
    public void doAfter() {
        writeBlog();
    }
    
    private void buyBook(){
        System.out.println("买书");
    }
    
    private void writeBlog(){
        System.out.println("写博客");
    }

}

4.现在也能买书了，也能看书了，也能玩了，也能写博客了，但是如果别人在用你公布出来的接口时，只是看书就要执行三个动作，我们要尽量简化调用者的动作，这是后能把这三个动作捏到一起就好了，所以出现了一个代理，给你提供买书看书写博客一条龙服务，而你只要告诉他你要学习，他就会把书给你买好，等你学完，帮你把博客到CSDN上。简单的代理类，如下：

package proxy;

import proxy.entity.Knowledge;
import proxy.inteface.Advice;
import proxy.inteface.ILearner;

/**
 * @author bigWet
 *
 *代理模式 实现某一个业务相对接口
 */
public class SimpleProxy implements ILearner{
    
    /**
     * 公布的接口，所有希望通过代理类实现的业务都要实现此接口
     */
    private ILearner study;
    
    /**
     * 业务前后的处理
     */
    private Advice advice;

    public SimpleProxy(ILearner study, Advice advice) {
        super();
        this.study = study;
        this.advice = advice;
    }

    @Override
    public Knowledge read() {
        advice.doBefore();
        Knowledge kl = study.read();//真正执行业务的苦力永远是具体实现类，骚年学习还是要靠自己啊T^T
        advice.doAfter();
        return kl;
    }

    @Override
    public void play() {
        study.play();
    }
}

5.我来测试一下我的代码是否有问题，一个简单的test

package proxy.test;

import proxy.SimpleProxy;
import proxy.impl.EncodeLearnerImpl;
import proxy.impl.aop.StudyAopImpl;
import proxy.inteface.Advice;
import proxy.inteface.ILearner;

public class TestProxy {
    public static void main(String[] args) {
        Advice advice = new StudyAopImpl();
        ILearner study = new EncodeLearnerImpl();//编程学习就实例化编程学习实现类，想干别的就实例化别的实现类
        ILearner proxy = new SimpleProxy(study, advice);
        Knowledge kl =proxy.read();
        System.out.println(kl.getKnowledge());
        proxy.play();
    }
}

输出结果：

买书
新技能：看书——代理模式
写博客
不好好打代码，什么都没学到

6.总结：

  代理模式只是一种设计模式，具体怎么设计要看程序员的编程习惯，怎么做才是合理的我还不知道。下了Spring对Aop支持的源代码，抽空看了，估计会对这个模式有更好的理解

ps:有点高兴，看到自己的文字叙述越来越多，好像不像以前那么懒了，都在诅咒写代码不解注释的烂屁股。。。我不想我的菊花暴露出来。。。还是养成写注释的习惯吧。。。