设计模式

简介:

v前言

  以前做项目的时候并没有想过用过采用什么样的设计模式进行开发。唯一用过的模式也就是MVC的开发模式了。但是当初对MVC模式理解的也是很片面。为了提高程序的运行效率,或者是对程序进行更进一步的优化,合理的设计模式是十分重要的。

vMVC模式

  

 来自百度百科

MVC 是一种使用 MVC(Model View Controller 模型-视图-控制器)
    • Model(模型)表示应用程序核心(比如数据库记录列表)。
    • View(视图)显示数据(数据库记录)。
    • Controller(控制器)处理输入(写入数据库记录)。
MVC 模式同时提供了对 HTML、CSS 和 JavaScript 的完全控制。

vModel

    (模型)是应用程序中用于处理应用程序数据逻辑的部分。
通常模型对象负责在数据库中存取数据。

vView

  (视图)是应用程序中处理数据显示的部分。
   通常视图是依据模型数据创建的。

vController

    (控制器)是应用程序中处理用户交互的部分。
通常控制器负责从视图读取数据,控制用户输入,并向模型发送数据。
 
 其中最典型的MVC就是JSP + servlet + javaBean的模式。用javaEE做过网站的都知道,structs框架就是采用的MVC的设计模式。
 

v简单不能再简单的mvc的例子

1.用户请求 

复制代码
......
<form action="LoginServlet" name="login" method="post">
    姓名:<input type="text" name="userName">
    密码:<input type="text" name="password">
    <input type="submit" value="提交">
</form>
......
复制代码

2.Model部分

复制代码
......javaBean, 处理应用程序数据逻辑的部分
public class LoginService {
public LoginService(){}
public boolean checkLogin(String userName, String password){ //DAO层实现数据的查询,根据数据库中的信息进行对比判断是否登录成功 //用于登录成功后可以调用GetMessage()得到最终VIEW中要显示的数据。 } public List<Message> GetMessage(String userName){ //返回用户的信息,存入Message实例中,并放入sessino中。 } }
复制代码

3.Controler部分

复制代码
......
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    public LoginServlet() {
        super();
    }
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session=request.getSession();
        ......
        判断登录是否成功
        ......
        
        ......
        通过Model的逻辑处理,得到View中要显示的数据,并跳转到相应的View
        ......
        response.sendRedirect("index.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        process(request,response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        process(request, response);
    }
}
复制代码

4.View部分

复制代码
......jsp页面
<%
    ......
        通过session获得Model产生的数据并显示
    ......
%>
......
复制代码

 

v观察者模式

   观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监察一个主题对象。这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的

那些观察者对象,使这些观察者对象能够自动更新。

 java观察者模式

v实现观察者模式

1.创建被观察者类,它继承自java.util.Observable类;
2.创建观察者类,它实现java.util.Observer接口;
3.对于被观察者类,
   添加它的观察者:
void addObserver(Observer o)
addObserver()方法把观察者对象添加到观察者对象列表中。
当被观察事件发生时,执行:
setChanged();
notifyObservers();
setChange()方法用来设置一个内部标志位注明数据发生了变化;

   notifyObservers()方法会去调用观察者对象列表中所有的Observer的update()方法,通知它们数据发生了变化。
   只有在setChange()被调用后,notifyObservers()才会去调用update()。至于为什么可以看一下下面的源码。

复制代码
    /**
     * If {@code hasChanged()} returns {@code true}, calls the {@code update()}
     * method for every observer in the list of observers using null as the
     * argument. Afterwards, calls {@code clearChanged()}.
     * <p>
     * Equivalent to calling {@code notifyObservers(null)}.
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * If {@code hasChanged()} returns {@code true}, calls the {@code update()}
     * method for every Observer in the list of observers using the specified
     * argument. Afterwards calls {@code clearChanged()}.
     *
     * @param data
     *            the argument passed to {@code update()}.
     */
    @SuppressWarnings("unchecked")
    public void notifyObservers(Object data) {
        int size = 0;
        Observer[] arrays = null;
        synchronized (this) {
            if (hasChanged()) {//如果变换了,arrays才不会为null
                clearChanged();
                size = observers.size();
                arrays = new Observer[size];
                observers.toArray(arrays);
            }
        }
        if (arrays != null) {
            for (Observer observer : arrays) {
                observer.update(this, data);
            }
        }
    }
复制代码


4.对于观察者类,实现Observer接口的唯一方法update
void update(Observable o, Object arg)
形参Object arg,对应一个由notifyObservers(Object arg);传递来的参数,当执行的是notifyObservers();时,arg为null。

v观察者模式举例

   1.生产者充当被观测的对象,生产者可以生产的水果如下。

复制代码
class ProduceFruit extends Observable{
    private String[] msg = {"苹果", "香蕉", "橘子"};
    
    private int fruitNum;
    
    public String[] getMsg() {
        return msg;
    }
    public int getFruitNum() {
        return fruitNum;
    }
    public void setFruitNum(int fruit, int fruitNum) {
        this.fruitNum = fruitNum;
        setChanged();
        notifyObservers(fruit);
    }
    
}
复制代码

   2.多个消费者充当观察者,每个消费者观察不同的水果生产情况

复制代码
class ConsumeFruit implements Observer{
    private String consumeMsg;
    
    @Override
    public void update(Observable o, Object arg) {
        ProduceFruit pf = (ProduceFruit)o;
        Integer index = (Integer)arg;
        if(consumeMsg.equals(pf.getMsg()[index])){
            //每种水果对应的不同的消费观察者
            System.out.println(consumeMsg + "消费的数量 " + pf.getFruitNum());
        }
    }

    public ConsumeFruit(String consumeMsg) {
        super();
        this.consumeMsg = consumeMsg;
    }
}
复制代码

  3.生产者(被观察者)随机生产水果,通知消费者(观察者)进行消费

复制代码
public class Main {
    public static void main(String[] args){
        ProduceFruit pf = new ProduceFruit();
        pf.addObserver(new ConsumeFruit("苹果"));//观察苹果生产
        pf.addObserver(new ConsumeFruit("香蕉"));//观察香蕉生产
        pf.addObserver(new ConsumeFruit("橘子"));//观察橘子生产
        Random rd = new Random();
        for(int i=0; i<5; ++i){
            int fruit = Math.abs(rd.nextInt())%3;
            int fruitNum = Math.abs(rd.nextInt())%100;
            pf.setFruitNum(fruit, fruitNum);
        }
if(pf instanceof ProduceFruit) System.out.println(true);

if(pf.getClass().equals(ProduceFruit.class)) System.out.println(true);

     if(pf.getClass() == ProduceFruit.class) System.out.println(true);

    }
}
复制代码

vJDK中已经实现的一套观察者模式

    最典型的就是Swing框架的JButton的实现。JButton继承自AbstractButton,在AbstractButton中维护了一组监听器,它们就扮演者被观察的角色。而AbstractButton本身就是被观察对象。监听器ActionListener并不是依靠循环监听去获取按钮何时被单击,而是当按钮被单击时,通过AbstractButton的fireActionPerformed()方法回调ActionListener.actionPerformed()方法实现。基于这种结构,在应用程序开发时,只要简单的实现ActionListerner接口(也就是Observer),并将其添加到按钮的观察者列表中,那么当单击事件发生就可以自动促发监听器的业务处理函数。

  1.亲测一个小例子

复制代码
class BtnListener implements ActionListener{
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("click");
    }
}

public class Main {
    public static void main(String[] args){
        JFrame p = new JFrame();
        JButton btn = new JButton("点击我!");
        btn.addActionListener(new BtnListener());
        btn.setPreferredSize(new Dimension(200, 200));
        p.add(btn);
        p.pack();//调整此窗口的大小,以适合其子组件的首选大小和布局
        p.setVisible(true);
    }
}
复制代码

  2.以下是AbstractButton中的一段处理代码

复制代码
protected void fireActionPerformed(ActionEvent event) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        ActionEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==ActionListener.class) {
                // Lazily create the event:
                if (e == null) {
                      String actionCommand = event.getActionCommand();
                      if(actionCommand == null) {
                         actionCommand = getActionCommand();
                      }
                      e = new ActionEvent(AbstractButton.this,
                                          ActionEvent.ACTION_PERFORMED,
                                          actionCommand,
                                          event.getWhen(),
                                          event.getModifiers());
                }
                ((ActionListener)listeners[i+1]).actionPerformed(e);
            }
        }
    }
复制代码

   写到这里,不得不说一下MVC模式和观察者模式结合的小例子。Long long ago,我用C写了一个贪吃蛇的小游戏,没有什么技术含量,当时并没有考虑用什么样的设计模式去写,而是想怎么写就怎么写,最终完成了。我知道这样的写法非常的不好,尤其是出现BUG的时候,调试起来是非常的麻烦。基于上面的两个设计模式,看一下“贪吃蛇”新的设计思路。

v“贪吃蛇”设计模式

  1.Model,并充当被观察者

复制代码
class SnakeModel extends Observable implements Runnable{
    //......
    //Snake状态信息,以及状态变化的方法。
    //......
    @Override
    public void run() {
        //通过线程实现 模型的状态变化。
        //每次的状态变化,Model通知View数据已经更新,请更新视图。
        //......
    }
}
复制代码

  2.View,并充当观察者

复制代码
class SnakeView extends JFrame implements Observer{
    private void initView(){
        //初始化视图
        //......
    }
    @Override
    public void update(Observable o, Object arg) {
        SnakeModel mode = (SnakeModel)o;//获取被监控的模型
        //根据模型中Snake状态信息,开始更新Snake的视图
        //......
    }
}
复制代码

  3.Controler,将Model和View结合起来

复制代码
class SnakeControl extends KeyAdapter{
    private SnakeModel model;//待控制的贪吃蛇的模型对象
    private SnakeView view;//贪吃蛇的视图对象
    private void initControl(){
        //创建SnakeModel
        //创建SnakeView
        model.addObserver(view);//为模型添加视图(被观察者添加观察者)
        view.addKeyListener(this);//为视图添加键盘的事件处理器
    }
    @Override
    public void keyPressed(KeyEvent e) {
        super.keyPressed(e);
        int keyCode = e.getKeyCode();
        //根据不同的按键,通过Model设置Snake新的状态
    }
}
复制代码

  最后通过主函数,创建SnakeControl对象就可以是整个程序跑起来了。设计方法很重要,最后就是一步一步的完善了。关于设计模式就先写到这里了,过几天再完善,要考6级了,先复习...

目录
相关文章
|
6月前
|
设计模式 算法 Java
C++设计模式
C++设计模式
40 0
|
设计模式 程序员
设计模式 | 模版方法
设计模式 | 模版方法
82 0
|
6月前
|
设计模式 消息中间件 Kubernetes
设计模式总结(二)
设计模式总结(二)
|
6月前
|
设计模式 存储 安全
[设计模式] 常见的设计模式
[设计模式] 常见的设计模式
|
6月前
|
设计模式 前端开发 C++
什么是设计模式?
什么是设计模式?
68 0
|
设计模式 算法 程序员
2023-6-9-一天一种设计模式
2023-6-9-一天一种设计模式
75 0
|
设计模式 容器
2022-9-19-C++各种设计模式的简单总结
2022-9-19-C++各种设计模式的简单总结
79 0
|
设计模式 Java
23种设计模式
23种设计模式
142 0
|
设计模式 XML 开发框架
设计模式的理解
设计模式的理解
设计模式的理解
|
设计模式 数据可视化 程序员
设计模式(一)
设计模式
122 0