设计模式详解

// 雇员类 - 只负责雇员信息管理
public class Employee {
    private String id;
    private String name;
    private double salary;
    
    // 雇员相关的核心业务逻辑
    public void calculateSalary() { /* ... */ }
    public void updateInfo() { /* ... */ }
}

// 打印类 - 只负责打印功能
public class EmployeePrinter {
    private Employee employee;
    
    public EmployeePrinter(Employee employee) {
        this.employee = employee;
    }
    
    public void printBasicInfo() { /* ... */ }
    public void printDetailedReport() { /* ... */ }
}

// 抽象接口 - 定义结构
public interface Connection {
    Statement createStatement();
    PreparedStatement prepareStatement(String sql);
    // ...
}

// 具体实现1 - MySQL
public class MySQLConnection implements Connection {
    @Override
    public Statement createStatement() {
        return new MySQLStatement();
    }
    // ...
}

// 具体实现2 - Oracle
public class OracleConnection implements Connection {
    @Override
    public Statement createStatement() {
        return new OracleStatement();
    }
    // ...
}

// 使用方 - 依赖抽象
public class UserDao {
    private Connection connection;
    
    public UserDao(Connection connection) {
        this.connection = connection; // 可以传入MySQL或Oracle
    }
    
    // 无需修改UserDao，即可支持新的数据库
}

// 父类：矩形
public class Rectangle {
    protected int width;
    protected int height;
    
    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    public int getArea() { return width * height; }
}

// 子类：正方形（违反LSP）
public class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        this.width = width;
        this.height = width; // 强制相等
    }
    
    @Override
    public void setHeight(int height) {
        this.width = height; // 强制相等
        this.height = height;
    }
}

// 测试
public void testRectangle(Rectangle rect) {
    rect.setWidth(5);
    rect.setHeight(4);
    // 期望面积 = 20，但Square实际返回 = 16
    assert rect.getArea() == 20 : "面积计算错误！";
}

// 抽象父类
public abstract class Shape {
    public abstract int getArea();
}

public class Rectangle extends Shape {
    private int width;
    private int height;
    // ... 正常实现
}

public class Square extends Shape {
    private int side;
    // ... 独立实现，不继承Rectangle
}

// 违反迪米特法则：明星亲力亲为处理所有事务
public class StarBad {
    public void meetFans() { /* ... */ }
    public void negotiateBusiness() { /* ... */ }
    public void handleContract() { /* ... */ }
    public void attendShow() { /* ... */ }
    // 依赖过多，精力分散
}

// 遵循迪米特法则：通过经纪人处理
public class Agent {
    private Star star;
    private Fans fans;
    private Company company;
    
    public void arrangeMeeting() {
        // 安排粉丝见面会
    }
    
    public void negotiateContract() {
        // 与商家洽谈
    }
}

public class Star {
    private Agent agent; // 只依赖直接朋友Agent
    
    public void perform() { /* 只专注表演 */ }
}

// ❌ 违反迪米特法则：老师直接依赖了Student
public class TeacherBad {
    public void command() {
        // 直接创建Student（局部变量，不是直接朋友）
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            students.add(new Student());
        }
        
        // 依赖StudentLeader
        StudentLeader leader = new StudentLeader();
        System.out.println("清点人数完毕，总共有:" + leader.counts(students) + "人");
    }
}

// ✅ 遵循迪米特法则：老师只依赖班长
public class Teacher {
    // 仅耦合StudentLeader（方法参数，直接朋友）
    public void command(StudentLeader leader) {
        System.out.println("清点人数完毕，总共有:" + leader.counts() + "人");
    }
}

public class StudentLeader {
    private List<Student> students; // Student是成员变量，直接朋友
    
    public StudentLeader(List<Student> students) {
        this.students = students;
    }
    
    public int counts() {
        return students.size();
    }
}

// 测试
public class TaskTest {
    public static void main(String[] args) {
        System.out.println("周末收假，学校领导命令老师去点名.....");
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            students.add(new Student());
        }
        Teacher teacher = new Teacher();
        teacher.command(new StudentLeader(students));
    }
}

// ❌ 庞大接口，违反ISP
public interface CloudProvider {
    void createServer();      // 创建服务器
    void deleteServer();      // 删除服务器
    void createDatabase();    // 创建数据库（阿里云支持，腾讯云暂不支持）
    void createCache();       // 创建缓存
    void createCDN();         // 创建CDN
    void createKubernetes();  // 创建K8s（阿里云支持，腾讯云暂不支持）
}

// 腾讯云实现类 - 被迫实现不支持的方法
public class TencentCloud implements CloudProvider {
    @Override
    public void createServer() { /* ... */ }
    
    @Override
    public void deleteServer() { /* ... */ }
    
    @Override
    public void createDatabase() {
        throw new UnsupportedOperationException("暂不支持");
    }
    
    @Override
    public void createCache() { /* ... */ }
    
    @Override
    public void createCDN() { /* ... */ }
    
    @Override
    public void createKubernetes() {
        throw new UnsupportedOperationException("暂不支持");
    }
}

// ✅ 拆分为最小接口
public interface ComputeService {
    void createServer();
    void deleteServer();
}

public interface DatabaseService {
    void createDatabase();
}

public interface CacheService {
    void createCache();
}

public interface CDNService {
    void createCDN();
}

// 阿里云实现 - 实现需要的接口
public class AliyunProvider implements ComputeService, DatabaseService, 
                                       CacheService, CDNService {
    // 实现所有方法
}

// 腾讯云实现 - 只实现支持的接口
public class TencentProvider implements ComputeService, CacheService, CDNService {
    // 无需实现不支持的功能
}

// 具体实现类
public class IntelCPU {
    public void work() { System.out.println("Intel CPU working..."); }
}

public class KingstonMemory {
    public void load() { System.out.println("Kingston Memory loading..."); }
}

public class SeagateDisk {
    public void read() { System.out.println("Seagate Disk reading..."); }
}

// ❌ 高层模块直接依赖底层模块
public class Computer {
    private IntelCPU cpu;           // 直接依赖具体类
    private KingstonMemory memory;  // 直接依赖具体类
    private SeagateDisk disk;       // 直接依赖具体类
    
    public void start() {
        cpu.work();
        memory.load();
        disk.read();
    }
}
// 更换AMD CPU？需要修改Computer类！

// ✅ 定义抽象接口
public interface CPU {
    void work();
}

public interface Memory {
    void load();
}

public interface Disk {
    void read();
}

// 具体实现
public class IntelCPU implements CPU {
    @Override
    public void work() { System.out.println("Intel CPU working..."); }
}

public class AMDCPU implements CPU {
    @Override
    public void work() { System.out.println("AMD CPU working..."); }
}

// 高层模块依赖抽象
public class Computer {
    private CPU cpu;       // 依赖抽象
    private Memory memory; // 依赖抽象
    private Disk disk;     // 依赖抽象
    
    public Computer(CPU cpu, Memory memory, Disk disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }
    
    public void start() {
        cpu.work();
        memory.load();
        disk.read();
    }
}

// 使用 - 可以轻松更换组件
Computer computer1 = new Computer(new IntelCPU(), new KingstonMemory(), new SeagateDisk());
Computer computer2 = new Computer(new AMDCPU(), new ADATAMemory(), new SanDiskDisk());

package com.cskaoyan.pattern.singleton;

/**
 * 饿汉式单例模式
 * 特点：类加载时即创建实例，线程安全，但不支持懒加载
 */
public class Singleton1 {

    // 1. 创建私有静态实例对象（类加载时初始化）
    private static final Singleton1 INSTANCE = new Singleton1();

    // 2. 私有化构造函数，防止外部实例化
    private Singleton1() {}

    // 3. 提供全局访问点
    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

package com.cskaoyan.pattern.singleton;

/**
 * 懒汉式单例模式 - 线程不安全版本
 * 特点：支持懒加载，但多线程环境下可能创建多个实例
 */
public class Singleton2 {

    private static Singleton2 instance;

    // 私有化构造函数
    private Singleton2() {}

    // 判断当前对象是否已经被创建
    public static Singleton2 getInstance() {
        if (instance == null) {              // 线程A执行到这里被切换
            instance = new Singleton2();     // 线程B执行完，线程A再次执行，又创建一个对象
        }
        return instance;
    }
}

线程A执行 if(instance == null) 判断通过 → 线程切换
线程B执行 if(instance == null) 判断通过 → 创建instance对象
线程A恢复执行 → 再次创建instance对象

package com.cskaoyan.pattern.singleton;

/**
 * 懒汉式单例模式 - 线程安全版本
 * 特点：线程安全，但并发性能较差
 */
public class Singleton3 {

    private static Singleton3 instance;

    // 私有化构造函数
    private Singleton3() {}

    // 引入synchronized，保证多线程模式下实例对象的唯一性
    public static synchronized Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

package com.cskaoyan.pattern.singleton;

/**
 * 懒汉式单例模式 - 双重检查锁定（DCL）
 * 特点：懒加载 + 线程安全 + 高性能
 */
public class Singleton4 {

    // volatile关键字禁止指令重排序，保证可见性
    private static volatile Singleton4 instance;

    // 私有化构造函数
    private Singleton4() {}

    public static Singleton4 getInstance() {
        // 第一次检查：避免不必要的加锁
        if (instance == null) {
            synchronized (Singleton4.class) {
                // 第二次检查：防止多个线程通过第一次检查
                if (instance == null) {
                    instance = new Singleton4();
                }
            }
        }
        return instance;
    }
}

线程A执行外层if判断通过 → 线程切换
线程B执行外层if判断通过 → 获取锁 → 创建对象 → 释放锁
线程A恢复执行 → 获取锁 → 如果没有内层if，又会创建一个对象！

/**
 * 静态内部类实现单例
 * 特点：懒加载 + 线程安全 + 代码简洁
 * JVM保证静态内部类的初始化是线程安全的
 */
public class Singleton5 {

    // 私有化构造函数
    private Singleton5() {}

    // 静态内部类
    private static class SingletonHolder {
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

/**
 * 枚举实现单例
 * 特点：最简单、最安全的实现方式
 * 天然防止反射攻击和序列化问题
 */
public enum Singleton6 {
    INSTANCE;

    // 可以添加业务方法
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

// 使用
Singleton6.INSTANCE.doSomething();

// 1. 定义产品抽象类
public abstract class Tesla {
    protected String name;
    
    public Tesla(String name) {
        this.name = name;
    }
    
    public void run() {
        System.out.println(name + "在路上跑");
    }
}

// 2. 定义具体产品
public class Model3 extends Tesla {
    public Model3() {
        super("Model 3");
    }
}

public class ModelS extends Tesla {
    public ModelS() {
        super("Model S");
    }
}

public class ModelY extends Tesla {
    public ModelY() {
        super("Model Y");
    }
}

Scanner scanner = new Scanner(System.in);
String keyword = scanner.nextLine();
Tesla tesla = null;

// 客户端耦合了具体创建逻辑
switch (keyword) {
    case "model3":
        tesla = new Model3();
        break;
    case "modely":
        tesla = new ModelY();
        break;
    case "models":
        tesla = new ModelS();
        break;
    default:
        tesla = new Tesla("未知车辆") {
            @Override
            public void run() {
                System.out.println(name + "路上请注意，道路千万条，安全第一条");
            }
        };
}
tesla.run();

/**
 * 简单工厂类
 * 封装了对象创建的细节，客户端只需传递参数
 */
public class SimpleTeslaFactory {
    
    public static Tesla create(String keyword) {
        switch (keyword.toLowerCase()) {
            case "model3":
                return new Model3();
            case "modely":
                return new ModelY();
            case "models":
                return new ModelS();
            default:
                return new Tesla("未知车辆") {
                    @Override
                    public void run() {
                        System.out.println(name + "路上请注意，道路千万条，安全第一条");
                    }
                };
        }
    }
}

Scanner scanner = new Scanner(System.in);
String keyword = scanner.nextLine();
Tesla tesla = SimpleTeslaFactory.create(keyword); // 一行代码获取对象
tesla.run();

// 1. 定义工厂接口
public interface TeslaFactory {
    Tesla createTesla();
}

// 2. 各车型对应的具体工厂
public class Model3Factory implements TeslaFactory {
    @Override
    public Tesla createTesla() {
        return new Model3();
    }
}

public class ModelYFactory implements TeslaFactory {
    @Override
    public Tesla createTesla() {
        return new ModelY();
    }
}

public class ModelSFactory implements TeslaFactory {
    @Override
    public Tesla createTesla() {
        return new ModelS();
    }
}

public class ModelXFactory implements TeslaFactory {
    @Override
    public Tesla createTesla() {
        return new ModelX();
    }
}

public class OrderTesla {
    // 使用Map缓存工厂实例
    private static Map<String, TeslaFactory> factoryMap = new HashMap<>();

    static {
        factoryMap.put("modelx", new ModelXFactory());
        factoryMap.put("modely", new ModelYFactory());
        factoryMap.put("models", new ModelSFactory());
        factoryMap.put("model3", new Model3Factory());
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String keyword = scanner.nextLine();
        
        TeslaFactory factory = factoryMap.get(keyword.toLowerCase());
        if (factory != null) {
            Tesla tesla = factory.createTesla();
            tesla.run();
        }
    }
}

// 1. 定义产品族接口
public interface TV {
    void play();
}

public interface Freezer {
    void freeze();
}

// 2. 定义抽象工厂
public abstract class AbstractFurnitureFactory {
    public abstract TV createTV();
    public abstract Freezer createFreezer();
}

// 3. 小米产品族
public class MiTV implements TV {
    @Override
    public void play() {
        System.out.println("小米电视播放中...");
    }
}

public class MiFreezer implements Freezer {
    @Override
    public void freeze() {
        System.out.println("小米冰箱制冷中...");
    }
}

public class MiFurnitureFactory extends AbstractFurnitureFactory {
    @Override
    public TV createTV() {
        return new MiTV();
    }

    @Override
    public Freezer createFreezer() {
        return new MiFreezer();
    }
}

// 4. 海尔产品族
public class HaierTV implements TV {
    @Override
    public void play() {
        System.out.println("海尔电视播放中...");
    }
}

public class HaierFreezer implements Freezer {
    @Override
    public void freeze() {
        System.out.println("海尔冰箱制冷中...");
    }
}

public class HaierFurnitureFactory extends AbstractFurnitureFactory {
    @Override
    public TV createTV() {
        return new HaierTV();
    }

    @Override
    public Freezer createFreezer() {
        return new HaierFreezer();
    }
}

public class OrderFurniture {
    public static void main(String[] args) {
        // 选择小米全屋智能
        AbstractFurnitureFactory factory = new MiFurnitureFactory();
        
        TV tv = factory.createTV();
        Freezer freezer = factory.createFreezer();
        
        tv.play();
        freezer.freeze();
        
        // 确保是同一品牌
        System.out.println("tv instanceof MiTV = " + (tv instanceof MiTV));
        System.out.println("freezer instanceof MiFreezer = " + (freezer instanceof MiFreezer));
    }
}

// 1. 定义产品类
@Data  // Lombok注解，自动生成getter/setter/toString
public class Phone {
    private String battery;  // 电池
    private String screen;   // 屏幕
    private String os;       // 操作系统
    private String camera;   // 摄像头
    private String color;    // 颜色
}

// 2. 定义建造者类
public class PhoneBuilder {
    private Phone phone = new Phone();

    // 链式调用设置属性
    public PhoneBuilder color(String color) {
        this.phone.setColor(color);
        return this;
    }

    public PhoneBuilder battery(String battery) {
        this.phone.setBattery(battery);
        return this;
    }

    public PhoneBuilder screen(String screen) {
        this.phone.setScreen(screen);
        return this;
    }

    public PhoneBuilder os(String os) {
        this.phone.setOs(os);
        return this;
    }

    public PhoneBuilder camera(String camera) {
        this.phone.setCamera(camera);
        return this;
    }

    // 构建最终对象
    public Phone build() {
        return this.phone;
    }
}

public class UseBuilder {
    public static void main(String[] args) {
        Phone phone = new PhoneBuilder()
                .battery("5000毫安大容量")
                .camera("徕卡顶级镜头")
                .color("尊贵黑")
                .screen("2K高清分辨率")
                .os("Android 14")
                .build();
        
        System.out.println("phone = " + phone);
    }
}

public class PhoneBuilder {
    private Phone phone = new Phone();
    
    public PhoneBuilder battery(String battery) {
        this.phone.setBattery(battery);
        return this;
    }
    
    // ... 其他setter方法
    
    public Phone build() {
        // 构建前进行校验
        if (phone.getBattery() == null) {
            throw new IllegalStateException("电池必须设置");
        }
        if (phone.getScreen() == null) {
            throw new IllegalStateException("屏幕必须设置");
        }
        return phone;
    }
}

// JDK的StringBuilder就是建造者模式
StringBuilder sb = new StringBuilder();
String result = sb.append("Hello")
                  .append(" ")
                  .append("World")
                  .toString();

// Lombok的@Builder注解自动生成建造者
@Builder
public class User {
    private String name;
    private int age;
    private String email;
}

// 使用生成的建造者
User user = User.builder()
                .name("张三")
                .age(25)
                .email("zhangsan@example.com")
                .build();

// 1. 定义接口
public interface UserService {
    void insert();
}

// 2. 目标类（被代理对象）
public class UserServiceImpl implements UserService {
    @Override
    public void insert() {
        System.out.println("目标类执行了insert方法");
    }
}

// 3. 代理类
public class UserServiceProxy implements UserService {
    private UserService target;

    public UserServiceProxy(UserService target) {
        this.target = target; // 注入目标对象
    }

    @Override
    public void insert() {
        System.out.println("【前置】代理之前打印一个日志");
        target.insert();  // 调用目标方法
        System.out.println("【后置】代理之后打印一个日志");
    }
}

@Test
public void testStaticProxy() {
    UserServiceProxy proxy = new UserServiceProxy(new UserServiceImpl());
    proxy.insert();
}

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

/**
 * JDK动态代理工厂
 */
public class JdkProxyFactory {

    private Object target;

    public JdkProxyFactory(Object target) {
        this.target = target;
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 类加载器
            target.getClass().getInterfaces(),   // 目标类实现的接口
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("【前置】方法执行前...");
                    Object result = method.invoke(target, args);  // 调用目标方法
                    System.out.println("【后置】方法执行后...");
                    return result;
                }
            }
        );
    }
}

@Test
public void testJdkProxy() {
    UserService userService = new UserServiceImpl();
    
    // 创建代理对象
    UserService proxy = new JdkProxyFactory(userService).getProxy();
    
    // 执行代理方法
    proxy.insert();
}

public final class $Proxy0 extends Proxy implements UserService {
    private static Method m3;  // insert方法

    public $Proxy0(InvocationHandler h) {
        super(h);
    }

    static {
        try {
            m3 = Class.forName("com.example.UserService")
                      .getMethod("insert", new Class[0]);
        } catch (Exception e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    @Override
    public final void insert() {
        try {
            // 调用InvocationHandler的invoke方法
            this.h.invoke(this, m3, null);
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * Cglib动态代理工厂
 */
public class CglibProxyFactory implements MethodInterceptor {

    private Object target;

    public CglibProxyFactory(Object target) {
        this.target = target;
    }

    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());  // 设置父类（目标类）
        enhancer.setCallback(this);                  // 设置回调
        return (T) enhancer.create();               // 创建代理对象
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("【前置】Cglib代理...");
        Object result = method.invoke(target, args);  // 调用目标方法
        System.out.println("【后置】Cglib代理...");
        return result;
    }
}

public class UserServiceImpl {
    public String getName() {
        System.out.println("目标方法执行");
        return "zhangsan";
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        UserServiceImpl target = new UserServiceImpl();
        
        // 创建Cglib代理
        UserServiceImpl proxy = new CglibProxyFactory(target).getProxy();
        
        String name = proxy.getName();
        System.out.println("返回值: " + name);
    }
}

java --add-opens java.base/java.lang=ALL-UNNAMED \
     --add-opens java.base/sun.net.util=ALL-UNNAMED \
     -jar your-application.jar

--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/sun.net.util=ALL-UNNAMED

/**
 * 抽象处理者
 */
public abstract class AbstractHandler {
    protected AbstractHandler next;  // 下一个处理者
    
    // 设置下一个处理者
    public void setNext(AbstractHandler next) {
        System.out.println(this.getClass().getSimpleName() + " → " + next.getClass().getSimpleName());
        this.next = next;
    }
    
    // 处理请求（抽象方法）
    public abstract void handle();
}

/**
 * 一级处理器
 */
public class Level1Handler extends AbstractHandler {
    @Override
    public void handle() {
        System.out.println("【一级处理器】正在处理...");
        // 如果无法处理，传递给下一个
        if (next != null) {
            next.handle();
        }
    }
}

/**
 * 二级处理器
 */
public class Level2Handler extends AbstractHandler {
    @Override
    public void handle() {
        System.out.println("【二级处理器】正在处理...");
        if (next != null) {
            next.handle();
        }
    }
}

/**
 * 三级处理器
 */
public class Level3Handler extends AbstractHandler {
    @Override
    public void handle() {
        System.out.println("【三级处理器】正在处理...");
        if (next != null) {
            next.handle();
        }
    }
}

public class ChainExecution {
    public static void main(String[] args) {
        // 创建处理器
        Level1Handler level1 = new Level1Handler();
        Level2Handler level2 = new Level2Handler();
        Level3Handler level3 = new Level3Handler();

        // 组装责任链
        level1.setNext(level2);
        level2.setNext(level3);

        // 从链头开始处理
        level1.handle();
    }
}

Level1Handler → Level2Handler
Level2Handler → Level3Handler
【一级处理器】正在处理...
【二级处理器】正在处理...
【三级处理器】正在处理...