모던 자바 인 액션 Part2 Chapter10 추가

Modern-Java-In-Action/Modern Java in Action.md

@@ -14,3 +14,4 @@
 ### Part3. 스트림과 람다를 이용한 효과적 프로그래밍
 - [Chapter8. 컬렉션 API 개선](https://github.com/banjjoknim/TIL/blob/master/Modern-Java-In-Action/src/Chapter8/Chapter8.md)
 - [Chapter9. 리팩터링, 테스팅, 디버깅](https://github.com/banjjoknim/TIL/blob/master/Modern-Java-In-Action/src/Chapter9/Chapter9.md)
+- [Chapter10. 람다를 이용한 도메인 전용 언어](https://github.com/banjjoknim/TIL/blob/master/Modern-Java-In-Action/src/Chapter10/Chapter10.md)

Modern-Java-In-Action/src/Chapter10/BuyStocksSteps.java

@@ -0,0 +1,30 @@
+package Chapter10;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class BuyStocksSteps {
+    private Map<String, Integer> stockUnitPrices = new HashMap<>();
+    private Order order = new Order();
+
+    public void setUnitPrice(String stockName, int unitPrice) {
+        stockUnitPrices.put(stockName, unitPrice);
+    }
+
+    public void buyStocks(int quantity, String stockName) {
+        Trade trade = new Trade();
+        trade.setType(Trade.Type.BUY);
+
+        Stock stock = new Stock();
+        stock.setSymbol(stockName);
+
+        trade.setStock(stock);
+        trade.setPrice(stockUnitPrices.get(stockName));
+        trade.setQuantity(quantity);
+        order.addTrade(trade);
+    }
+
+    public void checkOrderValue(int expectedValue) {
+//        assertEquals(expectedValue, order.getValue());
+    }
+}

Modern-Java-In-Action/src/Chapter10/GroupingBuilder.java

@@ -0,0 +1,28 @@
+package Chapter10;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collector;
+
+import static java.util.stream.Collectors.groupingBy;
+
+public class GroupingBuilder<T, D, K> {
+    private final Collector<? super T, ?, Map<K, D>> collector;
+
+    public GroupingBuilder(Collector<? super T, ?, Map<K, D>> collector) {
+        this.collector = collector;
+    }
+
+    public Collector<? super T, ?, Map<K, D>> get() {
+        return collector;
+    }
+
+    public <J> GroupingBuilder<T, Map<K, D>, J> after(Function<? super T, ? extends J> classifier) {
+        return new GroupingBuilder<T, Map<K, D>, J>(groupingBy(classifier, collector));
+    }
+
+    public static <T, D, K> GroupingBuilder<T, List<T>, K> groupOn(Function<? super T, ? extends K> classifier) {
+        return new GroupingBuilder<T, List<T>, K>(groupingBy(classifier));
+    }
+}

Modern-Java-In-Action/src/Chapter10/LambdaOrderBuilder.java

@@ -0,0 +1,33 @@
+package Chapter10;
+
+import java.util.function.Consumer;
+
+public class LambdaOrderBuilder {
+
+    private Order order = new Order();
+
+    public static Order order(Consumer<LambdaOrderBuilder> consumer) {
+        LambdaOrderBuilder builder = new LambdaOrderBuilder();
+        consumer.accept(builder);
+        return builder.order;
+    }
+
+    public void forCustomer(String customer) {
+        order.setCustomer(customer);
+    }
+
+    public void buy(Consumer<TradeBuilder> consumer) {
+        trade(consumer, Trade.Type.BUY);
+    }
+
+    public void sell(Consumer<TradeBuilder> consumer) {
+        trade(consumer, Trade.Type.SELL);
+    }
+
+    private void trade(Consumer<TradeBuilder> consumer, Trade.Type type) {
+        TradeBuilder builder = new TradeBuilder();
+        builder.trade.setType(type);
+        consumer.accept(builder);
+        order.addTrade(builder.trade);
+    }
+}

Modern-Java-In-Action/src/Chapter10/MethodChainingOrderBuilder.java

@@ -0,0 +1,31 @@
+package Chapter10;
+
+public class MethodChainingOrderBuilder {
+
+    public final Order order = new Order();
+
+    private MethodChainingOrderBuilder(String customer) {
+        order.setCustomer(customer);
+    }
+
+    public static MethodChainingOrderBuilder forCustomer(String customer) {
+        return new MethodChainingOrderBuilder(customer);
+    }
+
+//    public TradeBuilder buy(int quantity) {
+//        return new TradeBuilder(this, Trade.Type.BUY, quantity); // 주식을 파는 TradeBuilder 만들기
+//    }
+//
+//    public TradeBuilder sell(int quantity) {
+//        return new TradeBuilder(this, Trade.Type.SELL, quantity);
+//    }
+
+    public MethodChainingOrderBuilder addTrade(Trade trade) {
+        order.addTrade(trade);
+        return this;
+    }
+
+    public Order end() {
+        return order;
+    }
+}

Modern-Java-In-Action/src/Chapter10/MixedBuilder.java

@@ -0,0 +1,29 @@
+package Chapter10;
+
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public class MixedBuilder {
+
+    public static Order forCustomer(String customer, TradeBuilder... tradeBuilders) {
+        Order order = new Order();
+        order.setCustomer(customer);
+        Stream.of(tradeBuilders).forEach(b -> order.addTrade(b.trade));
+        return order;
+    }
+
+    public static TradeBuilder buy(Consumer<TradeBuilder> consumer) {
+        return buildTrade(consumer, Trade.Type.BUY);
+    }
+
+    public static TradeBuilder sell(Consumer<TradeBuilder> consumer) {
+        return buildTrade(consumer, Trade.Type.SELL);
+    }
+
+    private static TradeBuilder buildTrade(Consumer<TradeBuilder> consumer, Trade.Type buy) {
+        TradeBuilder builder = new TradeBuilder();
+        builder.trade.setType(buy);
+        consumer.accept(builder);
+        return builder;
+    }
+}

Modern-Java-In-Action/src/Chapter10/NestedFunctionOrderBuilder.java

@@ -0,0 +1,45 @@
+package Chapter10;
+
+import java.util.stream.Stream;
+
+public class NestedFunctionOrderBuilder {
+
+    public static Order order(String customer, Trade... trades) {
+        Order order = new Order();
+        order.setCustomer(customer);
+        Stream.of(trades).forEach(order::addTrade);
+        return order;
+    }
+
+    public static Trade buy(int quantity, Stock stock, double price) {
+        return buildTrade(quantity, stock, price, Trade.Type.BUY);
+    }
+
+    public static Trade sell(int quantity, Stock stock, double price) {
+        return buildTrade(quantity, stock, price, Trade.Type.SELL);
+    }
+
+    private static Trade buildTrade(int quantity, Stock stock, double price, Trade.Type buy) {
+        Trade trade = new Trade();
+        trade.setQuantity(quantity);
+        trade.setType(buy);
+        trade.setStock(stock);
+        trade.setPrice(price);
+        return trade;
+    }
+
+    public static double at(double price) {
+        return price;
+    }
+
+    public static Stock stock(String symbol, String market) {
+        Stock stock = new Stock();
+        stock.setSymbol(symbol);
+        stock.setMarket(market);
+        return stock;
+    }
+
+    public static String on(String market) {
+        return market;
+    }
+}

Modern-Java-In-Action/src/Chapter10/Order.java

@@ -0,0 +1,57 @@
+package Chapter10;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Order {
+
+    private String customer;
+    private List<Trade> trades = new ArrayList<>();
+
+    public void addTrade(Trade trade) {
+        trades.add(trade);
+    }
+
+    public String getCustomer() {
+        return customer;
+    }
+
+    public void setCustomer(String customer) {
+        this.customer = customer;
+    }
+
+    public double getValue() {
+        return trades.stream()
+                .mapToDouble(Trade::getValue)
+                .sum();
+    }
+
+    public static void main(String[] args) {
+        Order order = new Order();
+        order.setCustomer("BigBank");
+
+        Trade trade1 = new Trade();
+        trade1.setType(Trade.Type.BUY);
+
+        Stock stock1 = new Stock();
+        stock1.setSymbol("IBM");
+        stock1.setMarket("NYSE");
+
+        trade1.setStock(stock1);
+        trade1.setPrice(125.00);
+        trade1.setQuantity(80);
+        order.addTrade(trade1);
+
+        Trade trade2 = new Trade();
+        trade1.setType(Trade.Type.BUY);
+
+        Stock stock2 = new Stock();
+        stock1.setSymbol("GOOGLE");
+        stock1.setMarket("NASDAQ");
+
+        trade1.setStock(stock2);
+        trade1.setPrice(375.00);
+        trade1.setQuantity(50);
+        order.addTrade(trade2);
+    }
+}

Modern-Java-In-Action/src/Chapter10/Person.java

@@ -0,0 +1,19 @@
+package Chapter10;
+
+public class Person {
+    private final String name;
+    private final int age;
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getAge() {
+        return age;
+    }
+}

Modern-Java-In-Action/src/Chapter10/Stock.java

@@ -0,0 +1,23 @@
+package Chapter10;
+
+public class Stock {
+
+    private String symbol;
+    private String market;
+
+    public String getSymbol() {
+        return symbol;
+    }
+
+    public String getMarket() {
+        return market;
+    }
+
+    public void setSymbol(String symbol) {
+        this.symbol = symbol;
+    }
+
+    public void setMarket(String market) {
+        this.market = market;
+    }
+}

Modern-Java-In-Action/src/Chapter10/StockBuilder.java

@@ -0,0 +1,13 @@
+package Chapter10;
+
+public class StockBuilder {
+    public Stock stock = new Stock();
+
+    public void symbol(String symbol) {
+        stock.setSymbol(symbol);
+    }
+
+    public void market(String market) {
+        stock.setMarket(market);
+    }
+}

Modern-Java-In-Action/src/Chapter10/Tax.java

@@ -0,0 +1,29 @@
+package Chapter10;
+
+public class Tax {
+    public static double regional(double value) {
+        return value * 1;
+    }
+
+    public static double general(double value) {
+        return value * 1.3;
+    }
+
+    public static double surcharge(double value) {
+        return value * 1.05;
+    }
+
+    public static double calculate(Order order, boolean useRegional, boolean useGeneral, boolean useSurcharge) {
+        double value = order.getValue();
+        if (useRegional) {
+            value = Tax.regional(value);
+        }
+        if (useGeneral) {
+            value = Tax.general(value);
+        }
+        if (useSurcharge) {
+            value = Tax.surcharge(value);
+        }
+        return value;
+    }
+}

Modern-Java-In-Action/src/Chapter10/TaxCalculator.java

@@ -0,0 +1,25 @@
+package Chapter10;
+
+import java.util.function.DoubleUnaryOperator;
+
+public class TaxCalculator {
+    public DoubleUnaryOperator taxFunction = d -> d;
+
+    public TaxCalculator with(DoubleUnaryOperator f) {
+        taxFunction = taxFunction.andThen(f);
+        return this;
+    }
+
+    public double calculate(Order order) {
+        return taxFunction.applyAsDouble(order.getValue());
+    }
+
+    public static void main(String[] args) {
+        Order order = new Order();
+        double value = new TaxCalculator()
+                .with(Tax::regional)
+                .with(Tax::surcharge)
+                .calculate(order);
+        System.out.println(value);
+    }
+}

Modern-Java-In-Action/src/Chapter10/Trade.java

@@ -0,0 +1,46 @@
+package Chapter10;
+
+public class Trade {
+    public enum Type {BUY, SELL}
+
+    private Type type;
+    private Stock stock;
+    private int quantity;
+    private double price;
+
+    public Type getType() {
+        return type;
+    }
+
+    public Stock getStock() {
+        return stock;
+    }
+
+    public int getQuantity() {
+        return quantity;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public void setStock(Stock stock) {
+        this.stock = stock;
+    }
+
+    public void setQuantity(int quantity) {
+        this.quantity = quantity;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+
+    public double getValue() {
+        return quantity * price;
+    }
+}

Modern-Java-In-Action/src/Chapter10/TradeBuilder.java

@@ -0,0 +1,21 @@
+package Chapter10;
+
+import java.util.function.Consumer;
+
+public class TradeBuilder {
+    public Trade trade = new Trade();
+
+    public void quantity(int quantity) {
+        trade.setQuantity(quantity);
+    }
+
+    public void price(double price) {
+        trade.setPrice(price);
+    }
+
+    public void stock(Consumer<StockBuilder> consumer) {
+        StockBuilder builder = new StockBuilder();
+        consumer.accept(builder);
+        trade.setStock(builder.stock);
+    }
+}

Modern-Java-In-Action/src/Chapter10/TradeBuilderWithStock.java

@@ -0,0 +1,16 @@
+package Chapter10;
+
+public class TradeBuilderWithStock {
+    private final MethodChainingOrderBuilder builder;
+    private final Trade trade;
+
+    public TradeBuilderWithStock(MethodChainingOrderBuilder builder, Trade trade) {
+        this.builder = builder;
+        this.trade = trade;
+    }
+
+    public MethodChainingOrderBuilder at(double price) {
+        trade.setPrice(price);
+        return builder.addTrade(trade);
+    }
+}