Java设计模式8种

Java设计模式8种

1.模板模式
2.建造者模式
3.装饰器模式
4.工厂模式
5.策略模式
6.代理模式
7.单例模式
8.观察者模式

------------------------ DEMO ------------------------

1.模板模式

package com.example.core.mydemo.java3.model;

/**
 *模板方法模式定义一个算法的骨架，把具体的实现留给子类。
 *
 * 代码实现：任务执行模板
 * 模拟定时任务的执行流程。
 *
 * JDK 中的应用：
 * java.util.AbstractList 和 java.util.AbstractMap
 *
 * Spring 中的应用：
 * JdbcTemplate 和 RestTemplate
 */
public class DataProcessingTask extends Task{

    @Override
    protected void init() {
        System.out.println("Initializing data...");
    }

    @Override
    protected void doWork() {
        System.out.println("Processing data...");
    }
    
    /**
     * 测试类
     * output:
     * Initializing data...
     * Processing data...
     * Default cleanup...
     * @param args
     */
    public static void main(String[] args) {
        DataProcessingTask dataProcessingTask = new DataProcessingTask();
        dataProcessingTask.execute();
    }
}


package com.example.core.mydemo.java3.model;

public abstract class Task {
    public final void execute() {
        init();
        doWork();
        cleanup();
    }

    protected abstract void init();
    protected abstract void doWork();
    protected void cleanup() {
        System.out.println("Default cleanup...");
    }

}

2.建造者模式

package com.example.core.mydemo.java3.model;

import com.alibaba.fastjson.JSON;

/**
 * 建造者模式用于创建复杂对象，特别是当对象有多个可选参数时。
 * 代码实现：构建 HTTP 请求
 *
 * JDK 中的应用：
 * StringBuilder
 * Stream.Builder
 *
 * Spring 中的应用：
 * UriComponentsBuilder 用于构建 URI。
 */
public class HttpRequest {
    private String method;
    private String url;
    private String body;

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    private HttpRequest(Builder builder) {
        this.method = builder.method;
        this.url = builder.url;
        this.body = builder.body;
    }

    public static class Builder {
        private String method;
        private String url;
        private String body;

        public Builder method(String method) {
            this.method = method;
            return this;
        }

        public Builder url(String url) {
            this.url = url;
            return this;
        }

        public Builder body(String body) {
            this.body = body;
            return this;
        }

        public HttpRequest build() {
            return new HttpRequest(this);
        }
    }

    /**
     * 测试类
     * output:
     * httpRequest = {"body":"11122233","method":"POST","url":"http://www.test.com"}
     * @param args
     */
    public static void main(String[] args) {
        HttpRequest httpRequest = new HttpRequest.Builder().url("http://www.test.com").body("11122233").method("POST").build();
        System.out.println("httpRequest = " + JSON.toJSONString(httpRequest));
    }

}

3.装饰器模式

package com.example.core.mydemo.java3.model;

/**
 * 装饰器模式在不改变原始类的基础上，动态扩展其功能。
 * 代码实现：咖啡加料
 * 模拟一个咖啡订单系统，可以动态加料。
 *
 * JDK 中的应用：
 * java.io.BufferedInputStream 和 java.io.BufferedOutputStream
 *
 * Spring 中的应用：
 * BeanPostProcessor 用于动态修改 Bean 的行为。
 */
public class MilkDecorator implements Coffee{
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 1.5;
    }
    
    /**
     * 测试类
     * output:
     * Simple Coffee, Milk
     * 6.5
     * @param args
     */
    public static void main(String[] args) {
        MilkDecorator coffee = new MilkDecorator(new SimpleCoffee());
        System.out.println(coffee.getDescription());
        System.out.println(coffee.getCost());

    }
}

package com.example.core.mydemo.java3.model;

public interface Coffee {
    String getDescription();
    double getCost();
}

package com.example.core.mydemo.java3.model;

public class SimpleCoffee implements Coffee{

    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double getCost() {
        return 5.0;
    }
}

4.工厂模式

package com.example.core.mydemo.java3.model;

/**
 * 工厂模式用于封装对象的创建逻辑，特别是当类实例化过程复杂时，可以降低耦合度。
 *代码实现：简单工厂
 * 以支付系统为例，不同支付方式需要不同的对象。
 *
 * JDK 中的应用：
 * java.util.Calendar.getInstance()
 * javax.xml.parsers.DocumentBuilderFactory.newInstance()
 *
 * Spring 中的应用：
 * BeanFactory 和 ApplicationContext 都是工厂模式的体现。
 */
public class PaymentFactory {
    public static Payment createPayment(String type) {
        switch (type) {
            case "AliPay":
                return new AliPay();
            case "WeChatPay":
                return new WeChatPay();
            default:
                throw new IllegalArgumentException("Unknown payment type");
        }
    }
    
    /**
     * 测试类
     * output:
     * 支付宝支付成功
     * 微信支付成功
     * @param args
     */
    public static void main(String[] args) {
        Payment payment = PaymentFactory.createPayment("AliPay");
        payment.pay();
        Payment payment2 = PaymentFactory.createPayment("WeChatPay");
        payment2.pay();
    }

}


package com.example.core.mydemo.java3.model;

public class Payment {
    public void pay(){

    }
}

package com.example.core.mydemo.java3.model;

public class AliPay extends Payment{
    @Override
    public void pay() {
        System.out.println("支付宝支付成功");
    }
}

package com.example.core.mydemo.java3.model;

public class WeChatPay extends Payment{
    @Override
    public void pay() {
        System.out.println("微信支付成功");
    }
}

5.策略模式

package com.example.core.mydemo.java3.model;

/**
 * 策略模式将不同算法封装为独立类，并允许在运行时选择不同的策略。
 * 代码实现：促销策略
 * 以电商促销为例，支持满减、打折等多种策略。
 *
 * JDK 中的应用：
 * java.util.Comparator 是典型的策略模式。
 *
 * Spring 中的应用：
 * 事务管理（TransactionManager），支持编程式和声明式事务。
 */
public interface PromotionStrategy {
    void applyPromotion();

}


package com.example.core.mydemo.java3.model;

public class DiscountStrategy implements PromotionStrategy{

    @Override
    public void applyPromotion() {
        System.out.println("Applying discount...");
    }
}


package com.example.core.mydemo.java3.model;

public class PromotionContext {
    private PromotionStrategy strategy;

    public PromotionContext(PromotionStrategy strategy) {
        this.strategy = strategy;
    }

    public void executePromotion() {
        strategy.applyPromotion();
    }

    /**
     * 测试类
     * output: Applying discount...
     * @param args
     */
    public static void main(String[] args) {
        PromotionContext promotionContext = new PromotionContext(new DiscountStrategy());
        promotionContext.executePromotion();
    }
}

6.代理模式

package com.example.core.mydemo.java3.model;

/**
 *代理模式通过代理对象控制对目标对象的访问，常用于权限控制、日志记录等场景。
 * 代码实现：静态代理
 * 模拟对一个服务的权限控制。
 *
 * JDK 中的应用：
 * 动态代理 java.lang.reflect.Proxy
 * RMI（远程方法调用）
 *
 * Spring 中的应用：
 * AOP（面向切面编程）广泛使用代理模式。
 *
 */
public class ServiceProxy implements Service{
    private RealService realService;

    @Override
    public void execute() {
        System.out.println("Checking permissions...");
        if (realService == null) {
            realService = new RealService();
        }
        realService.execute();
    }
    
    /**
     * 测试类
     * output:
     * Checking permissions...
     * Executing real service...
     * @param args
     */
    public static void main(String[] args) {
        ServiceProxy serviceProxy = new ServiceProxy();
        serviceProxy.execute();
    }

}



package com.example.core.mydemo.java3.model;

public interface Service {
    void execute();

}


package com.example.core.mydemo.java3.model;

import java.io.Serializable;

public class RealService implements Service {

    @Override
    public void execute() {
        System.out.println("Executing real service...");
    }
}

7.单例模式

package com.example.core.mydemo.java3.model;

/**
 * https://www.cnblogs.com/12lisu/p/18599057
 *
 * 单例模式确保一个类只有一个实例，通常用于管理共享资源，如配置、缓存、线程池等。
 *代码实现：双重检查锁
 * 这是单例模式的标准写法，既保证线程安全，又避免性能损耗。
 *
 * JDK 中的应用：
 * java.lang.Runtime.getRuntime()
 * java.util.logging.Logger
 *
 * Spring 中的应用：
 * Spring 的 Bean 默认是单例模式。可以通过 @Scope("prototype") 将其改为多例。
 */
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    
    /**
     * 测试类
     * output：  同一个地址，同一个对象
     * com.example.core.mydemo.java3.model.Singleton@65b3120a
     * com.example.core.mydemo.java3.model.Singleton@65b3120a
     * @param args
     */
    public static void main(String[] args) {
        Singleton obj = Singleton.getInstance();
        System.out.println(obj.toString());
        Singleton obj2 = Singleton.getInstance();
        System.out.println(obj2.toString());
    }

}

8.观察者模式

package com.example.core.mydemo.java3.model;

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

/**
 * 观察者模式定义一对多的依赖，当一个对象状态变化时，所有依赖它的对象都会收到通知。
 *
 * 代码实现：事件通知
 * 模拟微博用户的粉丝通知。
 *
 * JDK 中的应用：
 * java.util.Observer 和 java.util.Observable
 * javax.swing.event.ChangeListener
 *
 * Spring 中的应用：
 * ApplicationEvent 和 ApplicationListener 是典型实现。
 */
public class Weibo {
    private List<Observer> observers = new ArrayList<>();

    public void follow(Observer observer) {
        observers.add(observer);
    }

    public void post(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
    
    /**
     * 测试类
     * output: 张三 received message: 下雨了
     * @param args
     */
    public static void main(String[] args) {
        Weibo weibo = new Weibo();
        weibo.follow(new User("张三"));
        weibo.post("下雨了");
    }

}


package com.example.core.mydemo.java3.model;

public interface Observer {
    void update(String message);

}

package com.example.core.mydemo.java3.model;

public class User implements Observer{
    private String name;

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

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}