代理模式-装饰器模式-适配器模式

69 阅读 0 评论 46 点赞

我是靠谱客的博主无奈招牌，最近开发中收集的这篇文章主要介绍代理模式-装饰器模式-适配器模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

适配器模式

装饰器模式

代理模式：

适配器模式

什么是是适配器模式呢？他的作用是什么呢？

适配器模式，就是当老的接口已经不支持新的业务逻辑时，需要定义一个新的接口，实现新的业务，关键：老接口的实现类也能实现新接口的方法；

所以说我们要有新的业务接口，以及他的实现类；

问题来了，我们为啥要专门实现一个新接口的业务类呢？

因为，我们的老接口实现的类需要增加新的业务方法，所以需要实例化一个新的业务对象，以便于调用新的业务方法；

总得来说，适配器模式就是增加新的业务方法，并且不对老接口实现类进行修改，让老的实现类也一样实现新的业务方法；

目的：接口不相容的实现业务类也能干同一件事情；

代码：

新的接口：

package com.wyh.适配器模式;

/**
 * @author diao 2022/2/24
 */
//新订单需要升级，而老的接口不具备此功能，并且针对所有平台导致不方便修改
// 弄一个新的接口，将订单时间延长
public interface NewOrderApi {
    public void updateDate(String OrderId,String date,String user);
}

新接口实现的业务类：

package com.wyh.适配器模式;

/**
 * @author diao 2022/2/24
 */
//新接口实现类
public class NewOrderApiImpl implements NewOrderApi{
    @Override
    public void updateDate(String OrderId, String date,String user) {
        System.out.println(user+"已将订单"+OrderId+"的有效日期延长至"+date);
    }
}

测试类：

package com.wyh.适配器模式;

/**
 * @author diao 2022/2/24
 */
public class NewOrderTest {
    public static void main(String[] args) {
        //新接口引用——>接口方法的实现类对象
       NewOrderApi newOrderApi=new NewOrderApiImpl();
       newOrderApi.updateDate("Fairy","2022-2-22","user");
    }
}

老的接口：

package com.wyh.适配器模式;

/**
 * @author diao 2022/2/24
 */
public interface OldOrderApi {
    //老接口,此时就不用传入date参数了，新接口已经帮你做事了
    public void updateDate(String orderId,String user);
}

老接口的业务类（添加新的业务方法）：

package com.wyh.适配器模式;

/**
 * @author diao 2022/2/24
 */
public class OldOrderImpl implements OldOrderApi{
    //注入新的接口对象
    NewOrderApi newOrderApi;

    //通过构造方式将对新的接口引用赋值

    public OldOrderImpl(NewOrderApi newOrderApi) {
        this.newOrderApi = new NewOrderApiImpl();
    }

    //在不影响老接口的实现时，同时添加新接口方法
    @Override
    public void updateDate(String orderId, String user) {
        newOrderApi.updateDate(orderId,"2022-3-1",user);
    }
}

装饰器模式

装饰器模式的特点是什么？

装饰器模式呢，相对于适配器模式，特点：丰富原来接口的功能，但是并不会添加新的接口，也不会对原接口进行更改；

也就是说新的功能只能在业务实现类去添加——>装饰器；

public class NewSourceOrderApiImpl implements SourceOrderApi {
 
	SourceOrderApi sourceOrderApi;
	public NewSourceOrderApiImpl(SourceOrderApi sourceOrderApi){
		this.sourceOrderApi = sourceOrderApi;
	}
	@Override
	public void updateDate(String orderId, String date, String client) {
		sourceOrderApi.updateDate(orderId, date, client);
		System.out.println(client+"已将订单"+orderId+"的退款期延长至"+date);		
		
	}
 
}

public class Test {
 
	public static void main(String[] args) {
		SourceOrderApi sourceOrderApi = new NewSourceOrderApiImpl(new SourceOrderApiImpl());
		sourceOrderApi.updateDate("123456", "2014-10-15", "user");
	}
 
}

代理模式：

一样的，同样是增加业务方法，但是他这个业务方法既不在接口也不在实现类中，而是放在代理类中；

比如说要加一个安全机制，但是原接口肯定是不能动的，而业务类的话，安全机制范围肯定很大，所以得定义一个代理类，放入安全机制方法；

引伸：所以说AOP是这么来的，用一个代理类里面封装方法，然后作用在其他类方法上；

总结：当需要实现范围很大的方法时，就需要代理模式；像那种实现类中添加一点修饰的——>修饰器模式；添加一个新的功能，无论老实现业务类还是新的——>适配器模式

代理类：

package com.wyh.代理;

import com.wyh.适配器模式.NewOrderApi;
import com.wyh.适配器模式.NewOrderApiImpl;

/**
 * @author diao 2022/2/24
 */
//代理模式最明显的就是：代理对象与原对象都是实现一个接口的；
// 而适配者模式是匹配新的接口，老的用老接口的就用老的，只是增强了方法罢了

public class ProxyOrderApiImpl implements NewOrderApi {
    //新接口引用
     NewOrderApi newOrderApiImpl;

     //通过构造器的方式注入新接口实现类对象
    public ProxyOrderApiImpl(NewOrderApi newOrderApiImpl) {
        this.newOrderApiImpl = new NewOrderApiImpl();
    }

    @Override
    public void updateDate(String OrderId, String date, String user) {
        //这里加一层验证机制
        if("admin".equals(user)){
            newOrderApiImpl.updateDate(OrderId,date,user);
        }else{
            System.out.println("没有权限，请用admin账户");
        }

    }
}

测试类：

package com.wyh.代理;

import com.wyh.适配器模式.NewOrderApi;
import com.wyh.适配器模式.NewOrderApiImpl;

/**
 * @author diao 2022/2/24
 */
public class ProxyTest {
    public static void main(String[] args) {
      NewOrderApi proxyOrderApi=new ProxyOrderApiImpl(new NewOrderApiImpl());
       proxyOrderApi.updateDate("Fairy","2022-11-1","user");
    }
}