public interface AppleSeller {
    void privide(int quantity);
}
//一般其实不需要使用内部类，这里模拟下权限的隔离
public class AppleSellerProxy implements AppleSeller {
    private AppleSeller fakeSeller;
    private AppleSeller certifiedProvider;
    public AppleSellerProxy(){
        fakeSeller=new FakeProvider();
        certifiedProvider=new CertifiedProvider();
        System.out.println("供应商找完了！");
    }
    @Override
    public void privide(int quantity) {
        if(quantity>100){
            System.out.println("买的很多，给他一些假货！");
            fakeSeller.privide(quantity/2);
            certifiedProvider.privide(quantity-quantity/2);
            return;
        }
        System.out.println("给真货！");
        certifiedProvider.privide(quantity);
    }
    private class CertifiedProvider implements AppleSeller{
        @Override
        public void privide(int quantity) {
            System.out.println("给你"+quantity+"个正品！");
        }
    }
    private class FakeProvider implements AppleSeller{
        @Override
        public void privide(int quantity) {
            System.out.println("给你"+quantity+"个假货！");
        }
    }
}
public class Client {
    public static void main(String[] args) {
        // 对于客户来说，你只能找到代理而找不到供货商
        AppleSeller seller=new AppleSellerProxy();
        seller.privide(10);
        seller.privide(1000);
        // 在实际的开发当中也是如此，提供给客户端的接口其实是一个代理，
        // 用于进一步的精细控制，比如灰度发布的逻辑与权限的逻辑等, 
        // 之后再把不同的请求发送至不同的服务端
    }
}

public interface ColorFlyweight {
    String getColorName();
    void draw();
}
public class BaseColor implements ColorFlyweight {
    private String name;
    public BaseColor(String name) {
        this.name = name;
    }
    @Override
    public String getColorName() {
        return name;
    }
    @Override
    public void draw() {
        System.out.println("Draw: "+name);
    }
}
/**
 * 复合的颜色，这些颜色由基础的颜色进行合成，复用率低，一般不需要共享
 */
public class CompositeColor implements ColorFlyweight{
    Map<ColorFlyweight,Integer> colorPanel;
    public CompositeColor(){
        colorPanel=new HashMap<>();
    }
    public void add(ColorFlyweight color,Integer depth){
        colorPanel.put(color,depth);
    }
    public void remove(ColorFlyweight color){
        colorPanel.remove(color);
    }
    @Override
    public String getColorName() {
        List<String> colorNameList=new ArrayList<>();
        colorPanel.forEach((color,depth)->{
            colorNameList.add(color.getColorName()+"("+depth+")");
        });
        return String.join("-",colorNameList);
    }
    @Override
    public void draw() {
        List<String> colorNameList=new ArrayList<>();
        colorPanel.forEach((color, depth) -> {
            colorNameList.add(color.getColorName() + "(" + depth + ")");
        });
        System.out.println("Draw: " + String.join("-", colorNameList));
    }
}
public class ColorFactory {
    private static Map<String, ColorFlyweight> colors = new HashMap<>();
    private static ColorFactory factory = new ColorFactory();
    private ColorFactory() {
    }
    public static ColorFactory instance() {
        return factory;
    }
    /**
     * 模拟获取不同的基色
     */
    public ColorFlyweight getBaseColor(String name) {
        ColorFlyweight color = colors.get(name);
        if (null == color) {
            color = new BaseColor(name);
            colors.put(name, color);
        }
        return color;
    }
    /**
     * 模拟获取不同的混合颜色
     */
    public ColorFlyweight getCompositeColor(String[] names, Integer[] depths) {
        final CompositeColor color = new CompositeColor();
        IntStream.range(0, names.length)
                .forEach(idx -> color.add(getBaseColor(names[idx]), depths[idx]));
        return color;
    }
}
public class App {
    public static void main(String[] args) {
        ColorFlyweight red = ColorFactory.instance().getBaseColor("R");
        red.draw();
        ColorFlyweight green = ColorFactory.instance().getBaseColor("G");
        green.draw();
        ColorFlyweight blue = ColorFactory.instance().getBaseColor("B");
        blue.draw();
        String[] whiteColorArray = { "R", "G", "B" };
        Integer[] whiteDepthArray = { 255, 255, 255 };
        ColorFlyweight white = ColorFactory.instance()
                .getCompositeColor(whiteColorArray, whiteDepthArray);
        white.draw();
        String[] blackColorArray = { "R", "G", "B" };
        Integer[] blackDepthArray = { 0, 0, 0 };
        ColorFlyweight black = ColorFactory.instance()
                .getCompositeColor(blackColorArray, blackDepthArray);
        black.draw();
    }
}