架构师训练营 1 期第 3 周：代码重构 - 总结

public class SorterFactory {
    public static <T> Sorter<T> getSorter() {
        return new BubbleSorter<T>();
    }
}

public class Client {
    public static void main(String[] args) {
        Integer[] array = { 5, 4, 9, 7, 6, 3, 8, 1, 0, 2 };
        Sorter<Integer> sorter = SorterFactory.getSorter();
        Sortable<Integer> sortable = SortableFactory.getSortable(array);
        Comparator<Integer> comparator = ComparatorFactory.getComparator();
        sorter.sort(sortable, comparator);
        …… 
    }
}

class SorterFactory_2 {
    @SuppressWarnings("unchecked")
    public static <T> Sorter<T> getSorter(String implClass) {
        try {
            Class impl = Class.forName(implClass);
            return (Sorter<T>) impl.newInstance();
        } catch (Exception e) {
            throw new IllegalArgumentException("Illegal class name: " +
                implClass, e);
        }
    }
}

Sorter<Integer> sorter = SorterFactory_2.getSorter("demo.sort.impl.BubbleSorter");

class SorterFactory_3 {
    private final static Properties IMPLS = loadImpls();

    private static Properties loadImpls() {
        Properties defaultImpls = new Properties();
        Properties impls = new Properties(defaultImpls);
        defaultImpls.setProperty("sorter", "demo.sort.impl.BubbleSorter”);

        try {
            impls.load(SorterFactory_3.class.getResourceAsStream("sort.properties"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return impls;
    }

    @SuppressWarnings("unchecked")
    public static <T> Sorter<T> getSorter() {
        String implClassName = IMPLS.getProperty("sorter");

        try {
            Class implClass = Class.forName(implClassName);
            return (Sorter<T>) implClass.newInstance();
        } catch (Exception e) {
            throw new IllegalArgumentException("Illegal class name: " +
                implClassName, e);
        }
    }
}

public class Singleton1 {
    private static Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return instance;
    }
}

public class Singleton2 {
    private static Singleton2 instance = null;

    private Singleton2() {
    }

    public static synchronized Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

public class Singleton3 {
    private static class SingletonHolder {
        private static Singleton3 instance = new Singleton3();
    }

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        return SingletonHolder.instance;
    }
}

类的适配器
public class ListSortable<T> extends ArrayList<T> implements NewSortable<T> {
    public T getElement(int i) {
        return get(i);
    }

    public void setElement(int i, T o) {
        set(i, o);
    }
}

public interface NewSortable<T> {
    int size();
    T getElement(int i);
    void setElement(int i, T o);
}

对象的适配器
public class ListSortable<T> implements Sortable<T> {
    private final List<T> list;
    public ListSortable(List<T> list) {
        this.list = list;
    }

    public int size() {
        return list.size();
    }

    public T get(int i) {
        return list.get(i);
    }

    public void set(int i, T o) {
        list.set(i, o);
    }
}

public class BubbleSorterTests extends TestCase {
    private Integer[] array;
    private Sorter sorter;

    protected void setUp() {
        array = new Integer[] { 5, 4, 9, 7, 6, 3, 8, 1, 0, 2 };
        sorter = new BubbleSorter();
    }

    public void testSort() {
        Sortable sortable = new ArraySortable(array);
        Comparator comparator = new IntegerComparator();
        sorter.sort(sortable, comparator);

        for (int i = 0; i < 10; i++) {
            assertEquals(i, array[i].intValue());
        }
    }
}

public abstract class TestCase extends Assert implements Test {
    public void runBare() throws Throwable {
        Throwable exception = null;
        setUp();
        try {
            runTest();
        } catch (Throwable running) {
            exception = running;
        } finally {
            try {
                tearDown();
            } catch (Throwable tearingDown) {
                if (exception == null) {
                    exception = tearingDown;
                }
            }
        }

        if (exception != null) {
            throw exception;
        }
    }

    protected void runTest() throws Throwable {
        // 利用动态机制调用testXXX()
    }

    protected void setUp() throws Exception {
    }

    protected void tearDown() throws Exception {
    }
}

public abstract class SortableTests extends TestCase {
    protected Sortable<Integer> sortable;
    protected void setUp() {
        Integer[] data = new Integer[10];
        for (int i = 0; i < 10; i++) {
            data[i] = i;
        }
        sortable = createSortable(data);
    }
    protected abstract Sortable<Integer> createSortable(Integer[] data);
    public final void testGet() {
        for (int i = 0; i < 10; i++) {
            assertEquals(i, sortable.get(i).intValue());
        }
        try {
            sortable.get(-1);
            fail();
        } catch (RuntimeException e) {
        }
        try {
            sortable.get(10);
            fail();
        } catch (RuntimeException e) {
        }
    }
    public final void testSet() {
        for (int i = 0; i < 10; i++) {
            sortable.set(i, 100);
            assertEquals(100, sortable.get(i).intValue());
        }
        try {
            sortable.set(-1, 999);
            fail();
        } catch (RuntimeException e) {
        }
        try {
            sortable.set(10, 999);
            fail();
        } catch (RuntimeException e) {
        }
    }
    public final void testSize() {
        assertEquals(10, sortable.size());
    }
}

//测试ListSortable
public class ListSortableTests extends SortableTests {
    @Override
    protected Sortable<Integer> createSortable(Integer[] data) {
        List<Integer> list = Arrays.asList(data);
        return new ListSortable<Integer>(list);
    }
}

//测试ArraySortable
public class ArraySortableTests extends SortableTests {
    @Override
    protected Sortable<Integer> createSortable(Integer[] data) {
        return new ArraySortable<Integer>(data);
    }
}

public abstract class ComparatorTests<T> extends TestCase {
    protected T o1;
    protected T o2;
    protected boolean ascending;
    protected boolean isBefore;

    public ComparatorTests(T o1, T o2, boolean ascending, boolean isBefore) {
        super("testIsBefore");
        this.o1 = o1;
        this.o2 = o2;
        this.ascending = ascending;
        this.isBefore = isBefore;
    }

    public void testIsBefore() {
        assertEquals(isBefore, createComparator(ascending).isBefore(o1, o2));
    }

    protected abstract Comparator<T> createComparator(boolean ascending);
}

public class IntegerComparatorTests extends ComparatorTests<Integer> {
    public IntegerComparatorTests(Integer o1, Integer o2, boolean ascending,
        boolean isBefore) {
        super(o1, o2, ascending, isBefore);
    }

    public static Test suite() {
        TestSuite suite = new TestSuite("IntegerComparatorTests");
        suite.addTest(new IntegerComparatorTests(1, 1, true, false));
        suite.addTest(new IntegerComparatorTests(1, 2, true, true));
        suite.addTest(new IntegerComparatorTests(2, 1, true, false));
        suite.addTest(new IntegerComparatorTests(1, 1, false, false));
        suite.addTest(new IntegerComparatorTests(1, 2, false, false));
        suite.addTest(new IntegerComparatorTests(2, 1, false, true));
        return suite;
    }

    @Override
    protected Comparator<Integer> createComparator(boolean ascending) {
        return new IntegerComparator(ascending);
    }
}

public class AllTests {
    public static Test suite() {
        TestSuite suite = new TestSuite("sort");
        suite.addTestSuite(BubbleSorterTests.class);
        suite.addTestSuite(InsertionSorterTests.class);
        suite.addTestSuite(ArraySortableTests.class);
        suite.addTestSuite(ListSortableTests.class);
        suite.addTest(IntegerComparatorTests.suite());
        suite.addTest(ComparableComparatorTests.suite());
        return suite;
    }
}

public class TestDecorator extends Assert implements Test {
    protected Test fTest;

    public TestDecorator(Test test) {
        fTest = test;
    }

    /**
     * The basic run behaviour.
     */
    public void basicRun(TestResult result) {
        fTest.run(result);
    }

    public int countTestCases() {
        return fTest.countTestCases();
    }

    public void run(TestResult result) {
        basicRun(result);
    }

    @Override
    public String toString() {
        return fTest.toString();
    }

    public Test getTest() {
        return fTest;
    }
}

public class PerformanceTests extends TestSetup {
    private long start;
    private int repeat;

    public PerformanceTests(Test test, int repeat) {
        super(new RepeatedTest(test, repeat));
        this.repeat = repeat;
    }

    protected void setUp() throws Exception {
        start = System.currentTimeMillis();
    }

    protected void tearDown() throws Exception {
        long duration = System.currentTimeMillis() - start;
        System.out.printf("%s repeated %,d times, takes %,d ms\n", getTest(),
            repeat, duration);
    }

    public static Test suite() {
        TestSuite suite = new TestSuite("performance");
        Test bubbleTests = new TestSuite(BubbleSorterTests.class);
        Test insertionTests = new TestSuite(InsertionSorterTests.class);
        suite.addTest(new PerformanceTests(bubbleTests, 10000));
        suite.addTest(new PerformanceTests(insertionTests, 10000));
        return suite;
    }
}

public class Client {
    private UserService userService;

    public setUserService(UserService userService) {
        this.userService = userService;
    }
}

// 配置文件
<bean id="userService" class="com.hello.UserDaoImpl">
    <property name="userDao" ref="userDao" />
</bean>
<bean id="client" class="com.hello.Client">
    <property name="userService" ref="userService" />
</bean>