JAVA的23种设计模式---中介者模式

最新推荐文章于 2024-08-20 08:15:00 发布

IngramLJJ

最新推荐文章于 2024-08-20 08:15:00 发布

阅读量225

点赞数

分类专栏：设计模式文章标签： java 设计模式技术人博客

本文链接：https://blog.csdn.net/wuxianlijiaji/article/details/72600249

版权

设计模式专栏收录该内容

22 篇文章 0 订阅

订阅专栏

概要：

该文章参考了《设计模式之禅》一书及一些前辈的博客文章

1.该文章阐述了中介者模式的基础原理及示例代码；
2.该文章适合初学设计模式的技术人员研习；
3.该文章有许多不足之处，请各位大咖指正，喷子绕道；

正文：

中介者模式：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互

1.中介者模式示例代码实现：

package com.csdn;
/**
 * 抽象中介者
 * @author Administrator
 *
 */
public abstract class AbstractMediator {
    //魏国
    protected Wei wei;
    //蜀国
    protected Shu shu;
    //吴国
    protected Wu wu;
    //构造器初始化三国
    public AbstractMediator(){
        this.wei = new Wei(this);
        this.shu = new Shu(this);
        this.wu = new Wu(this);
    }
    //最重要的事件方法，处理多个对象之间的关系
    public abstract void execute(String string,Object...objects) throws Exception;

}

package com.csdn;

import java.lang.reflect.Field;
/**
 * 具体中介者
 * @author Administrator
 *
 */
public class Mediator extends AbstractMediator{
    //中介者最重要的方法，处理各方关系
    @Override
    public void execute(String string, Object... objects) throws Exception {
        //魏国请求和平
        if(string.equalsIgnoreCase("weiForPeace")){
            this.weiForPeace();
        //蜀国请求和平
        }else if(string.equalsIgnoreCase("shuForPeace")){
            this.shuForPeace();
        //吴国请求和平
        }else if(string.equalsIgnoreCase("wuForPeace")) {
            this.wuForPeace();
        //魏国实力增长导致另外两国实力下降
        }else if(string.equalsIgnoreCase("weiIncrease")){
            this.weiIncrease();
        //蜀国实力增长导致另外两国实力下降
        }else if(string.equalsIgnoreCase("shuIncrease")){
            this.shuIncrease();
        //吴国实力增长导致另外两国实力下降
        }else if(string.equalsIgnoreCase("wuIncrease")){
            this.wuIncrease();
        }               
    }
    //吴国实力增长导致另外两国实力下降执行方法
    private void wuIncrease() {
        super.wei.decrease();
        super.shu.decrease();   
    }
    //蜀国实力增长导致另外两国实力下降执行方法
    private void shuIncrease() {
        super.wei.decrease();
        super.wu.decrease();    
    }
    //魏国实力增长导致另外两国实力下降执行方法
    private void weiIncrease() {
        super.shu.decrease();
        super.wu.decrease();
    }
    //魏国请求和平，三国实力重置
    private void weiForPeace() throws Exception {
        System.out.println("魏国求和，三国实力重置！");
        System.out.println("魏国实力恢复成功！"+"实力为:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀国实力恢复成功！"+"实力为:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吴国实力恢复成功！"+"实力为:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //蜀国请求和平，三国实力重置
    private void shuForPeace() throws Exception {
        System.out.println("蜀国求和，三国实力重置！");
        System.out.println("魏国实力恢复成功！"+"实力为:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀国实力恢复成功！"+"实力为:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吴国实力恢复成功！"+"实力为:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //吴国请求和平，三国实力重置
    private void wuForPeace() throws Exception {
        System.out.println("吴国求和，三国实力重置！");
        System.out.println("魏国实力恢复成功！"+"实力为:"+recovery(super.wei.getClass(), "WEI_STRENGTH"));
        System.out.println("蜀国实力恢复成功！"+"实力为:"+recovery(super.shu.getClass(), "SHU_STRENGTH"));
        System.out.println("吴国实力恢复成功！"+"实力为:"+recovery(super.wu.getClass(), "WU_STRENGTH"));
    }
    //通过反射，重置三国实力具体方法
    public int recovery(Class clazz,String string) throws Exception{
        Field fieldWei = clazz.getDeclaredField(string);
        fieldWei.setAccessible(true);
        fieldWei.setInt(string, 10);        
        return fieldWei.getInt(string);
    }
}

package com.csdn;
/**
 * 抽象同事类，每个国家都需实现
 * @author Administrator
 *
 */
public abstract class AbstractColleague {
    //中介者
    protected AbstractMediator mediator;
    //构造器初始化中介者
    public AbstractColleague(AbstractMediator _mediator){
        this.mediator = _mediator;
    }   
    //三个国家需要实现的方法
    public abstract void increase() throws Exception;
    public abstract void decrease();
    public abstract void getStrength();
    public abstract void reset() throws Exception;
}

package com.csdn;
/**
 * 魏国
 * @author Administrator
 *
 */
public class Wei extends AbstractColleague{
    //将魏国和中介者链接
    public Wei(AbstractMediator _mediator) {
        super(_mediator);
    }
    //魏国实力
    private static int WEI_STRENGTH = 10;
    //魏国实力增长
    @Override
    public void increase() throws Exception{
        WEI_STRENGTH += 1;
        System.out.println("魏国实力增长到:"+WEI_STRENGTH);
        super.mediator.execute("weiIncrease");
    }
    //魏国实力下降
    @Override
    public void decrease(){
        WEI_STRENGTH -= 1;
        System.out.println("魏国实力减弱到:"+WEI_STRENGTH);
    }
    //显示魏国实力
    @Override
    public void getStrength(){
        System.out.println("魏国实力为："+WEI_STRENGTH);
    }
    //魏国求和
    @Override
    public void reset() throws Exception{
        System.out.println("魏国实力为："+WEI_STRENGTH);
        super.mediator.execute("weiForPeace");
    }
}

package com.csdn;
/**
 * 蜀国
 * @author Administrator
 *
 */
public class Shu extends AbstractColleague{
    //将蜀国和中介者链接
    public Shu(AbstractMediator _mediator) {
        super(_mediator);
    }
    //蜀国实力
    private static int SHU_STRENGTH = 10;
    //蜀国实力增长
    @Override
    public void increase() throws Exception{
        SHU_STRENGTH += 1;
        System.out.println("蜀国实力增长到:"+SHU_STRENGTH);
        super.mediator.execute("shuIncrease");
    }
    //蜀国实力下降
    @Override
    public void decrease(){
        SHU_STRENGTH -= 1;
        System.out.println("蜀国实力减弱到:"+SHU_STRENGTH);
    }
    //显示蜀国实力
    @Override
    public void getStrength(){
        System.out.println("蜀国实力为："+SHU_STRENGTH);
    }
    //蜀国求和
    @Override
    public void reset() throws Exception{
        System.out.println("蜀国实力为："+SHU_STRENGTH);
        super.mediator.execute("shuForPeace");
    }
}

package com.csdn;
/**
 * 吴国
 * @author Administrator
 *
 */
public class Wu extends AbstractColleague{
    //将吴国和中介者链接
    public Wu(AbstractMediator _mediator) {
        super(_mediator);
        // TODO Auto-generated constructor stub
    }
    //吴国实力
    private static int WU_STRENGTH = 10;
    //吴国实力增长
    @Override
    public void increase() throws Exception{
        WU_STRENGTH += 1;
        System.out.println("吴国实力增长到:"+WU_STRENGTH);
        super.mediator.execute("wuIncrease");
    }
    //吴国实力下降
    @Override
    public void decrease(){
        WU_STRENGTH -= 1;
        System.out.println("吴国实力减弱到:"+WU_STRENGTH);
    }
    //显示吴国实力
    @Override
    public void getStrength(){
        System.out.println("吴国实力为："+WU_STRENGTH);
    }
    //吴国求和
    @Override
    public void reset() throws Exception{
        System.out.println("吴国实力为："+WU_STRENGTH);
        super.mediator.execute("wuForPeace");
    }
}

package com.csdn;
/**
 * 模拟战场
 * @author Administrator
 *
 */
public class Battlefield {
    public static void main(String[] args) throws Exception{
        //创建中介者及三国实体对象
        AbstractMediator mediator = new Mediator();
        Wei wei = new Wei(mediator);
        Shu shu = new Shu(mediator);
        Wu wu = new Wu(mediator);
        /*输出：
        魏国实力增长到:11
        蜀国实力减弱到:9
        吴国实力减弱到:9*/
        wei.increase();
        /*输出：
        吴国实力增长到:10
        魏国实力减弱到:10
        蜀国实力减弱到:8*/
        wu.increase();
        /*输出：
        蜀国实力为：8
        蜀国求和，三国实力重置！
        魏国实力恢复成功！实力为:10
        蜀国实力恢复成功！实力为:10
        吴国实力恢复成功！实力为:10*/
        shu.reset();
        /*输出：
        蜀国实力增长到:11
        魏国实力减弱到:9
        吴国实力减弱到:9*/
        shu.increase();     
    }
}

注：
a：该示例在代码实现方面还可以进行部分优化
b：同事类必须有中介者，而中介者可以只有部分同事类
c：同事类的行为分为两种，一种是同事本身的行为，用来改变自身状态，处理自身行为，与其他的同事类和中介者没有任何依赖，这种行为叫自发行为。还有一种是必须依赖中介者才能完成的行为，叫依赖方法
d：通常中介者模式中的同事类是协作关系，处理不同的业务。如果两个对象不能提炼出共性，那就不要去刻意追求两者的抽象，抽象只要去定义出模式需要的角色即可，根据项目实际情况而定（本示例为了展示的更加清晰，在同事类业务区分这方面可能不太恰当，三国相比于是同事类可能更像兄弟类）

2.中介者模式通用模型代码实现：

package com.csdn;
/**
 * 通用抽象中介者
 * @author Administrator
 *
 */
public abstract class Mediator {
    //定义同事类
    protected ConcreteColleague1 c1;
    protected ConcreteColleague2 c2;
    //通过getter/setter方法把同事类注入过来
    public ConcreteColleague1 getC1() {
        return c1;
    }
    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }
    public ConcreteColleague2 getC2() {
        return c2;
    }
    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }
    //中介者模式的业务逻辑
    public abstract void doSomething1();
    public abstract void doSomething2();
}

package com.csdn;
/**
 * 通用中介者
 * @author Administrator
 *
 */
public class ConcreteMediator extends Mediator{
    @Override
    public void doSomething1() {
        //调用同事类的方法，只要是public的都可以调用
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
    @Override
    public void doSomething2() {
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
}

package com.csdn;
/**
 * 抽象同事类
 * @author Administrator
 *
 */
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator _mediator){
        this.mediator = _mediator;
    }
}

package com.csdn;
/**
 * 具体同事类
 * @author Administrator
 *
 */
public class ConcreteColleague1 extends Colleague{
    //通过构造函数传递给中介者
    public ConcreteColleague1(Mediator _mediator) {
        super(_mediator);
    }
    public void selfMethod1(){
        //自己的业务逻辑
    }
    public void depMethod1(){
        //自己的业务逻辑
        //自己处理不了的业务逻辑，给中介者处理
        super.mediator.doSomething1();
    }
}

package com.csdn;
/**
 * 具体同事类
 * @author Administrator
 *
 */
public class ConcreteColleague2 extends Colleague{
    //通过构造函数传递给中介者
    public ConcreteColleague2(Mediator _mediator) {
        super(_mediator);
    }
    public void selfMethod2(){
        //自己的业务逻辑
    }
    public void depMethod2(){
        //自己的业务逻辑
        //自己处理不了的业务逻辑，给中介者处理
        super.mediator.doSomething2();
    }
}