10-Design-Pattern-Lite

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
【一级处理器】正在处理...
【二级处理器】正在处理...
【三级处理器】正在处理...