观察者模式、简单一对一双向聊天系统

观察者模式

简介

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

组成

1. 抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
2. 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
3. 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
4. 具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

代码示例

创建抽象主题角色接口

public interface Observered {//抽象主题角色
    public void addObserver(Observer observer);
    public void removeObserver(Observer observer);
    public void notifyObservers(String str);
}

创建抽象观察角色接口

public interface Observer {
    public void update(String str);//抽象观察角色
}

创建具体观察者角色类

public class ObserverPerson implements Observer{

    @Override
    public void update(String str) {//具体观察者角色
        System.out.println(str);
    }
}

创建具体主题角色类

import java.util.ArrayList;

public class ObserveredPerson implements Observered{//具体主题角色
    ArrayList<Observer> list = new ArrayList<Observer>();//存放具体观察者的集合

    @Override
    public void addObserver(Observer observer) {
        list.add(observer); 
    }

    @Override
    public void removeObserver(Observer observer) {
        list.remove(observer);  
    }

    @Override
    public void notifyObservers(String str) {
        for(Observer observer:list){
            observer.update(str);
        }
    }
}

创建Test类

public class Test {
    public static void main(String[] args) {
        Observered enemy = new ObserveredPerson();
        Observer soldier1 = new ObserverPerson();
        Observer soldier2 = new ObserverPerson();
        Observer soldier3 = new ObserverPerson();
        enemy.addObserver(soldier1);
        enemy.addObserver(soldier2);
        enemy.addObserver(soldier3);
        enemy.notifyObservers("报告长官：发现敌人活动！");
    }
}

运行结果：

简单聊天系统

利用Swing构建一个UI窗体，创建一个基于TCP的客户端和服务器的一对一双向聊天系统

代码：

创建Client类

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Client extends JFrame implements ActionListener {
    Socket s;
    PrintWriter pw;
    BufferedReader br;
    JTextArea jta;
    JTextField jtf;
    JButton jb;
    JPanel jp;
    JScrollPane jsp;

    public static void main(String[] args) {
        new Client();
    }

    public Client() {
        jta = new JTextArea();
        jsp = new JScrollPane(jta);
        jtf = new JTextField(15);
        jb = new JButton("发送");
        jb.addActionListener(this);
        jp = new JPanel();
        jp.add(jtf);
        jp.add(jb);
        this.add(jsp, BorderLayout.CENTER);
        this.add(jp, BorderLayout.SOUTH);
        this.setSize(300, 200);
        this.setTitle("客户端");
        this.setVisible(true);

        try {
            s = new Socket("127.0.0.1", 10000);
            jta.append("客户端已成功连接服务器\n");
            Thread t = new Thread(new GetServerToClientMessage(Client.this));
            t.start();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            pw = new PrintWriter(s.getOutputStream(), true);
            String str = jtf.getText();
            jta.append("客户端说：" + str + "\n");
            pw.println(str);
            pw.flush();
            jtf.setText("");
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }
    public void read(){
        try {
            while (true) {
                br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                jta.append("服务器说：" + br.readLine()+ "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建接收服务器消息的线程类

public class GetServerToClientMessage implements Runnable {
    private Client client;
    public GetServerToClientMessage(Client client) {
        this.client = client;
    }

    @Override
    public void run() {
        client.read();
    }
}

创建Server类

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class Server extends JFrame implements ActionListener {
    Socket s;
    PrintWriter pw;
    BufferedReader br;
    JTextArea jta;
    JTextField jtf;
    JButton jb;
    JPanel jp;
    JScrollPane jsp;
    ServerSocket ss;

    public static void main(String[] args) {
        new Server();
    }

    public Server() {
        jta = new JTextArea();
        jsp = new JScrollPane(jta);
        jtf = new JTextField(15);
        jb = new JButton("发送");
        jb.addActionListener(this);
        jp = new JPanel();
        jp.add(jtf);
        jp.add(jb);
        this.add(jsp, BorderLayout.CENTER);
        this.add(jp, BorderLayout.SOUTH);
        this.setSize(300, 200);
        this.setTitle("服务器");
        this.setVisible(true);


        try {
            ss = new ServerSocket(10000);
            s = ss.accept();
            jta.append("客户端已成功连接服务器\n");
            Thread t = new Thread(new GetClientToServerMessage(Server.this));
            t.start();
        } catch (IOException e) {
            e.printStackTrace();
        }   
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            pw = new PrintWriter(s.getOutputStream(), true);
            String str = jtf.getText();
            jta.append("服务器说：" + str + "\n");
            pw.println(str);
            pw.flush();
            jtf.setText("");
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }

    public void read(){
        try {
            while (true) {
                br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                jta.append("客户端说：" + br.readLine()+ "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建接收客户端消息的线程类

public class GetClientToServerMessage implements Runnable {
    private Server server;
    public GetClientToServerMessage(Server server) {
        this.server = server;
    }

    @Override
    public void run() { 
        server.read();
    }
}

运行结果：