服务提供者框架，静态工厂方法，重叠构造器，建造者模式构造器

致力做个书本的搬运工，偶尔打个log，时而加点料。#[手动滑稽]#[手动滑稽]#[手动滑稽]#

1. 静态工厂方法替代构造器

       类可以提供一个公有的 静态工厂方法 ,返回类的实例的静态方法，与设计模式的工厂方法不是一个概念。

• 静态工厂方法与构造器不同，静态工厂方法有名字
• 不必在每次调用的时候都创建一个新的对象。
• 静态工厂方法可以返回类型的任何子类型对象。
• 静态工厂方法返回的对象的类，可以随着每次调用而发生变化。
• 静态工厂方法返回的对象所属的类，在编写包含该静态工厂方法时可以不存在

示例：

//example 1、2 
// 1、静态工厂方法有名称  2、不必每次调用对象时都要创建对象
//这就像是个单例模式（设计模式）
public class Example {
    private static Example example;
	
	Example() {  
		//一个无参构造器  
    }

	//静态工厂方法
    public static Example getInstance() {
        if (example == null) {
            example = new Example();
        }
        return example;
    }
}

//example 3
// 父类声明有参构造器后，如果没有实现声明无参构造器，那么子类必须声明有参构造器
// 父类声明有参构造器，并且同时声明了无参构造器，那么子类无需声明有参构造器
public class Example {
    private static String ex;
    //Example类有参构造器
    public Example(String par) {
        this.ex = par;
    }
	//静态工厂方法返回子类对象
    public static Example getInstance(){
        return new ExampleSon("aaa");
    }
    
    static class ExampleSon extends Example {
        public ExampleSon(String par) {
            super(par);
        }
    }
}
//Example 4
//静态工厂方法返回的对象的类，可以随着每次调用而发生变化
public class Example {
    private static String ex;
    public Example(String par) {
        this.ex = par;
    }
    //根据入参(构造器入参)不一致，选择返回的实体对象类型
    public static Example getInstance() {
        if(ex.equals("aa")){
               return new Example("1");
        }
        return new ExampleSon("aaa");
    }

    static class ExampleSon extends Example {
        public ExampleSon(String par) {
            super(par);
        }
    }
}
// Example 5 以下案例构造模式为：/**** 服务提供者框架 */
// 静态工厂方法返回的对象所属的类，在编写包含该静态工厂方法时可以不存在
// 这个案例哔哔叨叨半天，其实在说一个事情，我建立了几个工厂，这几个工厂怎么对外提供服务.
// 这种方式是以服务注册的形式，对外提供。
public class Example {
    public interface Provider {
        ProvideServer provideServer();
    }
    interface ProvideServer {
        void login();
    }
    //注册容器
    private static final Map<String, Provider> providers = new HashMap<>();
    //注册器
    public void registerProvider(String name, Provider provider) {
        providers.put(name, provider);
    }
    //访问Api
    public static ProvideServer getServer(String name) {
        Provider provider = providers.get(name);
        return provider.provideServer();
    }
}

2. 服务提供者框架

服务提供者框架：个人认为和工厂模式类似，差别在获取具体工厂实例的方式上。
       服务提供者框架在获取实例时，引入了一个服务者的概念，由服务类去调取相应的“工厂方法”（实现类方法/接口）。
       然后通过服务者（服务类）注册到服务中心，进行统一管理。
       客户端使用时，服务中心根据入参分配服务者方法

以下是个人理解，流程图二描述的不是很贴切，但服务提供者框架与图二很相近

示例代码：

// 行为接口类
public interface ICommodityStore {
    /**
     * 买鱼
     */
    void buyFish();
    /**
     * 买鸡蛋
     */
    void buyEgg();
}
//行为接口实现类
@Slf4j
public class CommodityStoreImpl implements ICommodityStore {
    @Override
    public void buyFish() {
        log.info("买了一条鱼");
    }
    @Override
    public void buyEgg() {
        log.info("买了两个蛋");
    }
}

//服务者接口类
public interface ICommodityServiceProvider {
    /**
     * 对外提供服务接口
     */
    ICommodityStore buySomething();
}

//服务者接口实现类
public class CommodityServiceProviderImpl implements ICommodityServiceProvider {
    //在服务管理中心注册一个名为幸福家园的服务
    static {
        ServiceManager.registerService("幸福家园", new CommodityServiceProviderImpl());
    }
	//实现对外提供的服务接口------实际上就是实例化行为实现接口实现类（类似于打个log标签）
    @Override
    public ICommodityStore buySomething() {
        return new CommodityStoreImpl();
    }
}
//服务中心
public class ServiceManager {
	//服务者集合
    private static final Map<String, ICommodityServiceProvider> providers = new HashMap<>();
	//注册服务
    public static void registerService(String name, ICommodityServiceProvider iCommodityServiceProvider) {
        providers.put(name, iCommodityServiceProvider);
    }
	//管理中心根据服务者名称，对外提供相应的服务对象
    public static ICommodityStore getService(String name) {
        ICommodityServiceProvider iCommodityServiceProvider = providers.get(name);
        return iCommodityServiceProvider.buySomething();
    }
}

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
     	Class.forName("com.zxy.matthiolaincana.exercise.effective.two.constructor.impl.CommodityServiceProviderImpl");
        ICommodityStore iCommodityStore = ServiceManager.getService("幸福家园");
        iCommodityStore.buyEgg();
        iCommodityStore.buyFish();
    }
}

3. 重叠构造器模式

重叠构造器：第一个构造器只有必要参数，第二个构造器有一个可选参数，第二个构造器有两个可选参数，以此类推。
重叠构造器，在构造器参数相较不多的情况下，能合理使用，但是参数太多了以后，局面容易失控，可能寻找一个适合的构造器需要查看很久。这时候就可以使用建造者模式构造器了。

	/**
     * -- 重叠构造器模式
     */
    public class NutritionFacts {
        private final int fat;
        private int high;
        private int age;
        private int length;

        public NutritionFacts(int fat, int high) {
            this.fat = fat;
            this.high = high;
        }

        public NutritionFacts(int fat, int high, int age) {
            this.fat = fat;
            this.high = high;
            this.age = age;
        }

        public NutritionFacts(int fat, int high, int age, int length) {
            this.fat = fat;
            this.high = high;
            this.age = age;
            this.length = length;
        }
    }

4. 建造者模式构造器

建造者模式，具有重叠构造器的安全性，同时具有javaBeans模式的可读性。

  /**
     * builder建造者模式
     */

    public static class NutritionFactsBuilder {
        private final int fat;
        private final int high;
        private final int age;
        private final int length;

        private NutritionFactsBuilder(Builder builder) {
            fat = builder.fat;
            high = builder.high;
            age = builder.age;
            length = builder.length;
        }

        public static class Builder {
            private final int fat;
            //默认值参数
            private int high = 0;
            private int age = 0;
            private int length = 0;

            public Builder(int fat) {
                this.fat = fat;
            }

            public Builder high(int val) {
                high = val;
                return this;
            }

            public Builder age(int val) {
                age = val;
                return this;
            }

            public Builder length(int val) {
                length = val;
                return this;
            }

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

    }

5. Beans模式

  class BeanConstructor {
        private int fat;
        private int high;
        private int age;
        private int length;

        public BeanConstructor() {
        }

        public void setFat(int fat) {
            this.fat = fat;
        }

        public void setHigh(int high) {
            this.high = high;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public void setLength(int length) {
            this.length = length;
        }
    }

使用的时候先实例化对象，再调用set方法进行赋值