手写单例、工厂与代理

// 饿汉
public class Singleton1 { private static final Singleton1 INSTANCE = new Singleton1(); private Singleton1(){} public static Singleton1 get(){return INSTANCE;} }
// 懒汉同步
public class Singleton2 { private static Singleton2 s; public static synchronized Singleton2 get(){ if(s==null) s=new Singleton2(); return s; } }
// 双重检查 DCL
public class Singleton3 { private static volatile Singleton3 s; public static Singleton3 get(){ if(s==null){ synchronized(Singleton3.class){ if(s==null) s=new Singleton3(); } } return s; } }
// 静态内部类
public class Singleton4 { private static class Holder{ static final Singleton4 I=new Singleton4(); } public static Singleton4 get(){ return Holder.I; } }
// 枚举单例
public enum Singleton5 { INSTANCE; public void doSomething(){} }

public class User {
    private final String name; // final 不可变
    private final int age;
    private User(String name, int age){ this.name=name; this.age=age; }
    public static Builder builder(){ return new Builder(); }
    public static class Builder {
        private String name; private int age;
        public Builder name(String n){ name=n; return this; }
        public Builder age(int a){ age=a; return this; }
        public User build(){ return new User(name, age); }
    }
}
// User.builder().name("张三").age(20).build();

public class SimpleIoc {
    Map<String, Class<?>> beanDefs = new HashMap<>();
    Map<String, Object> singletons = new HashMap<>(); // 一级缓存
    Map<String, Object> early = new HashMap<>();      // 二级缓存
    Map<String, Supplier<Object>> factories = new HashMap<>(); // 三级缓存
    public void register(String name, Class<?> clazz){ beanDefs.put(name, clazz); }
    public Object getBean(String name) {
        if (singletons.containsKey(name)) return singletons.get(name);
        if (early.containsKey(name)) return early.get(name);
        if (factories.containsKey(name)) { // 从三级缓存拿到早期引用
            Object o = factories.get(name).get();
            early.put(name, o);
            return o;
        }
        // 创建并注入依赖
        Object bean = createBean(name);
        singletons.put(name, bean);
        return bean;
    }
    Object createBean(String name){ /* 反射实例化 + 注入依赖 */ return null; }
}

@Scope("prototype") // 每次获取都新建实例
@Component
public class PrototypeBean {}
// 默认 singleton @Scope("singleton")

// JDK 动态代理
public interface Greet { void hi(); }
public class GreetImpl implements Greet { public void hi(){ System.out.println("hi"); } }
Greet proxy = (Greet) Proxy.newProxyInstance(
    GreetImpl.class.getClassLoader(),
    new Class[]{Greet.class},
    (p, method, args) -> { System.out.println("before"); Object r = method.invoke(new GreetImpl(), args); System.out.println("after"); return r; });
// CGLIB
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(GreetImpl.class);
enhancer.setCallback((MethodInterceptor)(obj, method, args, proxy) -> { System.out.println("before"); return proxy.invokeSuper(obj, args); });
Greet proxy2 = (Greet) enhancer.create();

@Component
public class ServiceA {}
@Component
public class ServiceB {
    private final ServiceA a;
    @Autowired
    public ServiceB(ServiceA a){ this.a = a; } // 构造注入
}
// 容器扫描：遍历包下类，对带 @Component 的类，用构造器参数解析依赖并实例化

public interface Stream { void write(String s); }
public class FileStream implements Stream { public void write(String s){ /* 写文件 */ } }
public class BufferedStream implements Stream {     // 装饰器
    private final Stream inner;
    public BufferedStream(Stream s){ inner=s; }
    public void write(String s){ System.out.println("加缓冲"); inner.write(s); }
}
public class EncryptedStream implements Stream {    // 装饰器
    private final Stream inner;
    public EncryptedStream(Stream s){ inner=s; }
    public void write(String s){ System.out.println("加密"); inner.write(s); }
}
// 组合：new EncryptedStream(new BufferedStream(new FileStream()))

public abstract class AbstractPipeline {
    public final void process() {          // 模板方法：固定骨架
        Object obj = createObject();        // 工厂方法扩展点
        stepBefore(obj);
        stepMain(obj);
        stepAfter(obj);
    }
    protected abstract Object createObject(); // 子类实现
    void stepBefore(Object o){}
    void stepMain(Object o){}
    void stepAfter(Object o){}
}
// 策略模式：算法对象可替换
public class Context { private Strategy s; public void setStrategy(Strategy s){ this.s=s; } public void run(){ s.execute(); } }

public class EventBus {
    private final Map<Class<?>, List<Consumer<Object>>> listeners = new ConcurrentHashMap<>();
    private final ExecutorService pool = Executors.newCachedThreadPool();
    public void subscribe(Class<?> type, Consumer<Object> c){ listeners.computeIfAbsent(type, k->new CopyOnWriteArrayList<>()).add(c); }
    public void publish(Object event) {
        List<Consumer<Object>> l = listeners.get(event.getClass());
        if (l == null) return;
        for (Consumer<Object> c : l) {
            pool.submit(() -> {
                try { c.accept(event); } catch (Exception e) { /* 隔离异常，不影响其他监听器 */ }
            });
        }
    }
}

public class Subject {
    private final List<Observer> observers = new ArrayList<>();
    private final ExecutorService pool = Executors.newCachedThreadPool();
    public void attach(Observer o){ observers.add(o); }
    public void detach(Observer o){ observers.remove(o); } // 解绑，防止泄漏
    public void notifyChange() {
        for (Observer o : observers) {
            pool.submit(() -> o.update()); // 异步通知
        }
    }
}

// JDK：需要接口
Greet proxy = (Greet) Proxy.newProxyInstance(cl, new Class[]{Greet.class}, handler);
// CGLIB：不需要接口，superclass 不能是 final
Enhancer e = new Enhancer();
e.setSuperclass(ConcreteClass.class); // 若 ConcreteClass 是 final 则失败
e.setCallback((MethodInterceptor)(obj, method, args, proxy) -> proxy.invokeSuper(obj, args));

public class Prototype implements Cloneable {
    private List<String> list = new ArrayList<>();
    @Override public Prototype clone() {       // 浅拷贝
        try { return (Prototype) super.clone(); } catch (CloneNotSupportedException e){ throw new RuntimeException(e); }
    }
    public Prototype deepClone() {              // 深拷贝（序列化）
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            new ObjectOutputStream(bos).writeObject(this);
            return (Prototype) new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray())).readObject();
        } catch (Exception e){ throw new RuntimeException(e); }
    }
}

// MyBatis 简化
public class MapperProxy<T> implements InvocationHandler {
    private final Class<T> mapperInterface;
    private final SqlSession session;
    public Object invoke(Object proxy, Method method, Object[] args) {
        MapperMethod mm = resolve(method); // 解析 SQL
        return mm.execute(session, args);  // 执行 SQL 并返回
    }
}
// 生成代理
T mapper = (T) Proxy.newProxyInstance(cl, new Class[]{mapperInterface}, new MapperProxy<>(mapperInterface, session));

@Component
public class MyFactoryBean implements FactoryBean<MyObj> {
    public MyObj getObject() { return new MyObj(); } // 工厂方法创建对象
    public Class<?> getObjectType() { return MyObj.class; }
    public boolean isSingleton() { return true; }
}
// 获取：ctx.getBean("myFactoryBean") -> MyObj；ctx.getBean("&myFactoryBean") -> 工厂本身
// @Bean 工厂方法
@Configuration
public class Config {
    @Bean
    public DataSource dataSource() { return new HikariDataSource(); }
}

public interface PayStrategy { void pay(double amount); }
public class WechatPay implements PayStrategy { public void pay(double a){ /* 微信 */ } }
public class AlipayPay implements PayStrategy { public void pay(double a){ /* 支付宝 */ } }
public class PayFactory {
    private static final Map<String, PayStrategy> map = new HashMap<>();
    static { map.put("wechat", new WechatPay()); map.put("alipay", new AlipayPay()); }
    public static PayStrategy get(String type){ return map.get(type); } // 消除 if-else
}
// 使用：PayFactory.get("wechat").pay(100);

// 第三方库
public class ThirdPartySms { public void sendEms(String m){ /* 第三方 API */ } }
// 业务期望接口
public interface SmsSender { void send(String msg); }
// 适配器：转换接口，隔离第三方
public class SmsAdapter implements SmsSender {
    private final ThirdPartySms third = new ThirdPartySms();
    public void send(String msg){ third.sendEms(msg); } // 转换
}
// 业务只依赖 SmsSender，第三方变化只改适配器

// 简单工厂
class SimpleFactory { public static Product create(String type){ return type.equals("a")?new A():new B(); } }
// 工厂方法
abstract class Factory { abstract Product create(); }
class AFactory extends Factory { Product create(){ return new A(); } }
// 抽象工厂
interface AbstractFactory { ProductA createA(); ProductB createB(); }
class Factory1 implements AbstractFactory { public ProductA createA(){ return new A1(); } public ProductB createB(){ return new B1(); } }

public class LogHandler implements InvocationHandler {
    private final Object target;
    public LogHandler(Object t){ target = t; }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before " + method.getName());
        Object r = method.invoke(target, args); // 调用真实对象
        System.out.println("after");
        return r;
    }
}
Greet proxy = (Greet) Proxy.newProxyInstance(
    Greet.class.getClassLoader(),
    new Class[]{Greet.class},
    new LogHandler(new GreetImpl()));

public class LazyFactory<T> {
    private final Supplier<T> supplier;
    private volatile T instance; // volatile 保证可见性与有序性
    public LazyFactory(Supplier<T> s){ supplier = s; }
    public T get() {
        if (instance == null) {                 // 第一层判空
            synchronized (this) {
                if (instance == null) {         // 第二层判空（双重检查）
                    instance = supplier.get();
                }
            }
        }
        return instance;
    }
}

public Object invoke(Object proxy, Method method,
    Object[] args) throws Throwable {
    try { return method.invoke(target, args); }
    catch (InvocationTargetException e) { throw e.getCause(); } // 还原真实异常
}
// 若真实异常未在接口方法 throws 声明，代理会包装成 UndeclaredThrowableException