投稿
  1. 极客之音首页
  2. 后端漫谈

设计模式：代理模式—静态模式—动态模式—适配器模式—策略模式—观察者模式

seven_ • • 后端漫谈 • 阅读 189

导读：本篇文章讲解 设计模式：代理模式—静态模式—动态模式—适配器模式—策略模式—观察者模式，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

设计模式：代理模式—静态模式—动态模式—适配器模式—策略模式—观察者模式

静态代理 —代码：

ISales :

package com.test1;

public interface ISales {
    void sale();
}

AppFarmer :

package com.test1;

/**
 * 果农
 */
public class AppFarmer implements ISales{
    @Override
    public void sale() {
        System.out.println("果农卖水果5元一斤。。。。");
    }
}

InternetCelebrity :

package com.test1;

/**
 * 网红代理
 */
public class InternetCelebrity implements ISales{
    //果农:是网红的代理目标
    private AppFarmer appFarmer;

    //有参构造，传入要代理的目标对象
    public InternetCelebrity(AppFarmer appFarmer) {
        this.appFarmer = appFarmer;
    }

    @Override
    public void sale() {
        System.out.println("抽取20%代理费...");
        this.appFarmer.sale();
    }
}

Test1 :

package com.test1;

public class Test1 {
    public static void main(String[] args) {
        //果农对象
        AppFarmer appFarmer=new AppFarmer();
        //网红对象：代理果农
        InternetCelebrity internetCelebrity=new InternetCelebrity(appFarmer);
        //调用售卖方法
        internetCelebrity.sale();
    }
}

布局&运行结果：

在这里插入图片描述

动态代理(必须有接口)—代码：😦 😃

ISales ：

package com.test2;

public interface ISales {
    void sale();
}

AppFarmer ：

package com.test2;

import com.test1.ISales;

/**
 * 果农
 */
public class AppFarmer implements ISales {
    @Override
    public void sale() {
        System.out.println("果农卖苹果,5元一斤。。。。");
    }
}

BannerFarmer ：

package com.test2;

/**
 * 蕉农:被代理的目标对象
 */
public class BannerFarmer implements ISales{
    @Override
    public void sale() {
        System.out.println("香蕉农卖香蕉，5元一斤。。。");
    }
}

HandlerObj ：

package com.test2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 构建代理任务类
 */
public class HandlerObj implements InvocationHandler {
    //InvocationHandler:执行任务接口

    //被代理的目标对象:果农，蕉农。。。
    private Object target;

    //有参构造，传入要代理的目标对象
    public HandlerObj(Object target) {
        this.target =target;
    }

            //定义方法，获取代理类实例对象(相当于静态代理中的网红代理对象)
    public Object getProxyObj(){
        //Proxy.newProxyInstance:创建针对目标对象的一个代理类的实例对象
        //生成动态代理
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //附加代理类的行为
        System.out.println("代理类执行代理操作，收取20%代理费");
        //通过反射方式，在目标对象上调用方法(sale方法)
        Object res=method.invoke(target,args);
        return res;
    }


}

Test ：

package com.test2;

public class Test {
    public static void main(String[] args) {
        //果农对象
        AppFarmer appFarmer=new AppFarmer();
        //代理任务类
        HandlerObj handlerObj=new HandlerObj(appFarmer);
        //获取代理对象
        ISales iSales=(ISales) handlerObj.getProxyObj();
        //执行方法
        iSales.sale();

        System.out.println("======================");

        //蕉农
        BannerFarmer bannerFarmer=new BannerFarmer();
        HandlerObj handlerObj1=new HandlerObj(bannerFarmer);
        ISales iSales1=(ISales) handlerObj1.getProxyObj();
        iSales1.sale();
    }
}

布局&运行结果：

在这里插入图片描述

CGLIB代理—代码：

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

pom.xml :(注：配置jar包)

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>0920_SJMS_KTLX</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>0920_SJMS_KTLX Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.1</version>
    </dependency>
  </dependencies>
</project>

AppFarmer：

package com.test3;

/**
 * 果农
 */
public class AppFarmer{
    public void sale() {
        System.out.println("果农卖苹果,5元一斤。。。。");
    }
}

BannerFarmer ：

package com.test3;

/**
 * 蕉农:被代理的目标对象
 */
public class BannerFarmer {
    public void sale() {
        System.out.println("香蕉农卖香蕉，5元一斤。。。");
    }
}

interceptorObj ：

package com.test3;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method; //pom.xmml文件引入cglib-nodep-3.2.12.jar包

/**
 * 定义拦截对象,拦截目标对象的方法
 */
public class interceptorObj implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("method:"+method);
        System.out.println("methodProxy:"+methodProxy);
        System.out.println("代理类执行代理方法，收取20%代理费。。。");
        //使用代理方法，在目标对象上执行
        Object res=methodProxy.invokeSuper(o,objects);
        return res;
    }
}

Test ：

package com.test3;

import net.sf.cglib.proxy.Enhancer;

public class Test {
    public static void main(String[] args) {
        //cglib增强类，用于创建目标类的子类
        Enhancer enhancer=new Enhancer();
        //设置要代理的目标类
        enhancer.setSuperclass(AppFarmer.class);
        //设置代理执行的拦截方法对象
        enhancer.setCallback(new interceptorObj());
        //创建目标类的子类代理对象
        AppFarmer appFarmer=(AppFarmer) enhancer.create();
        //调用方法
        appFarmer.sale();

        System.out.println("==========================");

        Enhancer enhancer1=new Enhancer();
        enhancer1.setSuperclass(BannerFarmer.class);
        enhancer1.setCallback(new interceptorObj());
        BannerFarmer bannerFarmer=(BannerFarmer) enhancer1.create();
        bannerFarmer.sale();
    }
}

布局&运行结果：

在这里插入图片描述

类适配器模式—代码：

可以看到，类适配器是通过继承源类，实现目标接口的方式实现适配的

IDc ：

package com.test4;

/**
 * 直流电接口
 */
public interface IDc {
    int getDc();
}

DianYuan ：

package com.test4;

/**
 * 电源类，提供220v交流电
 */
public class DianYuan {
    public int ac(){
        return 220;
    }
}

ChongDianQi ：

package com.test4;

/**
 * 定义电源类适配器类，继承源类，实现新接口
 */
public class ChongDianQi extends DianYuan implements IDc{
    /**
     * 将220v交流电变为5v直流电
     * @return
     */
    @Override
    public int getDc() {
        int jl=ac();
        //交流电转为直流电
        return jl/44;
    }
}

Test ：

package com.test4;

public class Test {
    public static void main(String[] args) {
        //类的适配器模式：创建新类，继承源类，实现新接口

        //ChongDianQi：适配器类
        IDc dc=new ChongDianQi();
        int zl=dc.getDc();
        System.out.println("获取的直流电："+zl+"V");
    }
}

布局&运行结果：

在这里插入图片描述

对象的适配器模式—代码：

在这里插入图片描述

IDc ：

package com.test5;

/**
 * 直流电接口
 */
public interface IDc {
    int getDc();
}

DianYuan ：

package com.test5;

/**
 * 电源类，提供220v交流电
 */
public class DianYuan {
    public int ac(){
        return 220;
    }
}

ChongDianQi ：

package com.test5;

/**
 * 定义电源类适配器类：继承源类，实现新接口
 */
public class ChongDianQi implements IDc {
    private DianYuan dianYuan=new DianYuan();
    /**
     * 将220v交流电变为5v直流电
     * @return
     */
    @Override
    public int getDc() {
        int jl=dianYuan.ac();
        //交流电转为直流电
        return jl/44;
    }
}

Test ：

package com.test5;

public class Test {
    public static void main(String[] args) {
        //类的适配器模式：创建新类，继承源类，实现新接口

        //ChongDianQi：适配器类
        IDc dc=new ChongDianQi();
        int zl=dc.getDc();
        System.out.println("获取的直流电："+zl+"V");
    }
}

布局&运行结果：

在这里插入图片描述

接口的适配器模式—代码：

在这里插入图片描述

IDc ：

package com.test6;

/**
 * 直流电接口
 */
public interface IDc {
    int out5vDc();
    int out12Dc();
    int out20Dc();
}

DianYuan ：

package com.test6;

/**
 * 电源类，提供220v交流电
 */
public class DianYuan {
    public int ac(){
        return 220;
    }
}

DefaultAdapter ：

package com.test6;

/**
 * 默认适配器
 */
public class DefaultAdapter implements IDc{
    @Override
    public int out5vDc() {
        return 0;
    }

    @Override
    public int out12Dc() {
        return 0;
    }

    @Override
    public int out20Dc() {
        return 0;
    }
}

ComputerCDQ ：

package com.test6;

/**
 * 电脑充电器，将电源转为20v直流
 */
public class ComputerCDQ extends DefaultAdapter{
    //创建电源对象
    private DianYuan dianYuan=new DianYuan();

    /**
     * 获取20v直流电
     * @return
     */
    @Override
    public int out20Dc() {
        return dianYuan.ac()/11;
    }
}

PhoneCDQ ：

package com.test6;

/**
 * 手机充电器：转换电源为5v直流
 */
public class PhoneCDQ extends DefaultAdapter{
    //创建电源对象
    private DianYuan dianYuan=new DianYuan();

    @Override
    public int out5vDc() {
        return dianYuan.ac()/44;
    }
}

Test ：

package com.test6;

public class Test {
    public static void main(String[] args) {
        IDc computerDc=new ComputerCDQ();
        System.out.println("电脑充电器："+computerDc.out20Dc()+"v");

        IDc phoneDc=new PhoneCDQ();
        System.out.println("手机充电器："+phoneDc.out5vDc()+"v");

    }
}

布局&运行结果：

在这里插入图片描述

策略模式—代码：

IStrategy :

package com.test7;

/**
 * 策略接口
 */
public interface IStrategy {
    int yunsuan(int num1,int num2);
}

StrategyAdd ：

package com.test7;

public class StrategyAdd implements IStrategy{
    @Override
    public int yunsuan(int num1, int num2) {
        return num1+num2;
    }
}

StrategySub ：

package com.test7;

public class StrategySub implements IStrategy{
    @Override
    public int yunsuan(int num1, int num2) {
        return num1-num2;
    }
}

Context ：

package com.test7;

/**
 * 上下文类，表示策略使用的一个场景
 */
public class Context {
    private IStrategy iStrategy;

    //通过构造设置初始策略
    public Context(IStrategy iStrategy) {
        this.iStrategy = iStrategy;
    }

    //通过set方法设置策略
    public void setiStrategy(IStrategy iStrategy) {
        this.iStrategy = iStrategy;
    }

    //业务方法
    public void ys(int num1,int num2){
        //通过策略对象，实现业务方法
        int res=this.iStrategy.yunsuan(num1,num2);
        System.out.println("业务执行结果："+res);
    }
}

Test ：

package com.test7;

public class Test {
    public static void main(String[] args) {
        //创建策略对象
        IStrategy iStrategy=new StrategyAdd();
        //构建业务上下文(运行环境)对象,关联一个策略
        Context context=new Context(iStrategy);
        //调用业务方法，内部会使用设置的策略完成处理
        context.ys(100,200);

        //切换业务
        context.setiStrategy(new StrategySub());
        context.ys(100,200);
    }
}

布局&运行结果：

在这里插入图片描述

观察者模式—代码：

ISubject ：

package com.test8;

/**
 * 被观察者/观察目标
 */
public interface ISubject {
    //添加观察者。当观察者关注主题的时候，将观察者添加到观察者列表中
    void attach(IObserver observer);
    //删除观察者。当观察者取消关注时，将观察者从列表中删除
    void detach(IObserver observer);
    //通知观察者。当公众号更新信息时，通知所有的观察者
    void publish(String info);
}

IObserver ：

package com.test8;

/**
 * 观察者接口
 */
public interface IObserver {
    //当主题更新时，调用update方法，来通知观察者
    void update(String info);
}

WXUser ：

package com.test8;

public class WXUser implements IObserver {
    private String name;

    public WXUser(String name) {
        this.name = name;
    }

    /**
     * 当主题更新时，对应观察者做出响应
     * @param info
     */
    @Override
    public void update(String info) {
        System.out.println(this.name+"查看:"+info);
    }
}

GongZhongHao ：

package com.test8;

import java.util.ArrayList;
import java.util.List;

public class GongZhongHao implements ISubject{
    //定义观察者列表，用于存储关注该主题(公众号)的观察者(微信用户)
    List<IObserver> observerList = new ArrayList<>();

    //添加观察者
    @Override
    public void attach(IObserver observer) {
        observerList.add(observer);
    }

    //删除观察者
    @Override
    public void detach(IObserver observer) {
        observerList.remove(observer);
    }

    //公众号更新，通知观察者
    @Override
    public void publish(String info) {
        System.out.println("公众发布新内容："+info);
        for (IObserver observer : observerList){
            //将信息推送给观察者,观察者接到信息更新
            observer.update(info);
        }
    }
}

Test ：

package com.test8;

public class Test {
    public static void main(String[] args) {
        IObserver o1 = new WXUser("张三");
        IObserver o2 = new WXUser("李四");
        IObserver o3 = new WXUser("王五");

        ISubject yzh7=new GongZhongHao();
        //添加公众号的观察者
        yzh7.attach(o1);
        yzh7.attach(o2);
        yzh7.attach(o3);
        //公众号发布新消息
        yzh7.publish("今天天气不错");
        //取消关注
        yzh7.detach(o1);
        //发布新消息
        yzh7.publish("中午吃面条...");
    }
}

布局&运行结果：

在这里插入图片描述

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/118027.html

赞 (0)
seven_的头像seven_bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！