建造器模式实战（Builder模式）

最近在阅读在Effective Java第三版，其中提到了建造器模式（建造者详解：https://blog.csdn.net/sinat_35821285/article/details/80004060），找了一个实际生产使用的例子。

（当遇到多个构造器参数时要考虑使用建造器模式，即Builder模式。）

1）最常见的字符串建造器：

的

使用：

public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}

2）线程工厂建造者的部分代码，完整代码请看Guava

public final class ThreadFactoryBuilder {
    // 线程名称前缀
    private String nameFormat = null;
    // 设置通过该线程工厂实例创建的线程是否为守护线程
    private Boolean daemon = null;
    // 设置通过该线程工厂实例创建的线程的优先级: 1~10
    private Integer priority = null;
    // 设置通过该线程工厂实例创建的线程的未捕获异常处理器
    private UncaughtExceptionHandler uncaughtExceptionHandler = null;
    // 设置真实运行的后台线程工厂实例
    private ThreadFactory backingThreadFactory = null;

    public ThreadFactoryBuilder() {}

    public ThreadFactoryBuilder setName(String name) {
        this.nameFormat = name + "-%d";
        return this;
    }

    public ThreadFactoryBuilder setDaemon(boolean daemon) {
        this.daemon = daemon;
        return this;
    }

    public ThreadFactoryBuilder setPriority(int priority) {
        this.priority = priority;
        return this;
    }

    public ThreadFactoryBuilder setUncaughtExceptionHandler(UncaughtExceptionHandler uncaughtExceptionHandler) {
        this.uncaughtExceptionHandler = Verify.notNull(uncaughtExceptionHandler);
        return this;
    }

    public ThreadFactoryBuilder setThreadFactory(ThreadFactory backingThreadFactory) {
        this.backingThreadFactory = Verify.notNull(backingThreadFactory);
        return this;
    }

    public ThreadFactory build() {
        return doBuild(this);
    }

    // 拆分，以便匿名ThreadFactory不能包含一个可以返回到Builder构造实例的引用。
    private static ThreadFactory doBuild(ThreadFactoryBuilder builder) {
        final String nameFormat = builder.nameFormat;
        final Boolean daemon = builder.daemon;
        final Integer priority = builder.priority;
        final UncaughtExceptionHandler uncaughtExceptionHandler = builder.uncaughtExceptionHandler;
        final ThreadFactory backingThreadFactory =
            (builder.backingThreadFactory != null) ? builder.backingThreadFactory : Executors.defaultThreadFactory();
        final AtomicLong count = (nameFormat != null) ? new AtomicLong(0) : null;
        return new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runnable) {
                Thread thread = backingThreadFactory.newThread(runnable);
                if (nameFormat != null) {
                    thread.setName(format(nameFormat, count.getAndIncrement()));
                }
                if (daemon != null) {
                    thread.setDaemon(daemon);
                }
                if (priority != null) {
                    thread.setPriority(priority);
                }
                if (uncaughtExceptionHandler != null) {
                    thread.setUncaughtExceptionHandler(uncaughtExceptionHandler);
                }
                return thread;
            }
        };
    }
}

使用：我们利用建造者可以创建线程池，利用多线程来完成一些任务

public class ThreadFactoryBuilderTest {
	public static void main(String[] args) {
		// 创建Task
		Service service = new Service();
		// 线程工厂建造者
		ThreadFactory threadFactory = new ThreadFactoryBuilder().setName("test-pool") // 设置使用此ThreadFactory创建的线程时使用的命名前缀
				.setDaemon(false) // 设置通过该线程工厂实例创建的线程是否为守护线程
				.setPriority(1) // 设置通过该线程工厂实例创建的线程的优先级
				// .setThreadFactory(backingThreadFactory)
				.build(); // 建造者模式完成

		ExecutorService pool = Executors.newCachedThreadPool(threadFactory);

		for (int i = 0; i < 9; i++) {
			pool.submit(service);
		}
		pool.shutdown();
	}

	public static class Service implements Runnable {
		private static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

		public void run() {
			System.out.println(Thread.currentThread().getName() + ":doSomething start-time:"
					+ sf.format(System.currentTimeMillis()));
		}
	}
}