摘要：但還有問題，這個類既控制了參數的輸入，又控制了參數的輸出。換句話說就是消息的輸入和輸出是耦合在一起的。進一步解耦讓我們更進一步。接下來解耦消息的生產方。實際上，到這里已經完成了一個簡易版的實現。

先上一段代碼：

public class HelloWorldTest {

    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

這是Java里面最簡單的一段代碼了，做的事情非常簡單：控制臺打印出“Hello world!”字符串。很明顯，這段代碼很不好拓展，假如我們想打印別的內容呢？

OK，接下來做一點簡單的改動：

public class HelloWorldTest {

    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println(args[0]);
        } else {
            System.out.println("Hello world!");
        }
    }
}

這樣當我們運行帶參數時，控制臺會輸出我們的第一個參數。這樣我們就取得了第一個小小的進步：我們可以不修改代碼就控制了不同的輸出。但還有問題，這個類既控制了參數的輸入，又控制了參數的輸出。換句話說就是：消息的輸入和輸出是耦合在一起的。

讓我們更進一步。首先我們添加一個獲取消息的類：

public class MessageConsumer {

    public String sayHello(String message) {
        if (Objects.isNull(message) || message.length() < 1) {
            return "Hello world!";
        }
        return message;
    }
}

這樣當輸入的參數不為null或者空字符串時，輸出參數，否則輸出Hello world!。調用方只需要在調用的時候傳入不同的參數，就達到了輸出不同內容的目的。OK，現在已經解耦了消息的輸出方，但生產方還在main方法里。接下來解耦消息的生產方。添加一個新的類來生產消息：

public class MessageRenderer {
    private MessageConsumer messageConsumer;

    public void render(){
        if (Objects.isNull(messageConsumer)){
            System.out.println("Hello world!");
        }else {
            System.out.println(messageConsumer.sayHello("MessageRenderer"));
        }
    }

    public MessageConsumer getMessageConsumer() {
        return messageConsumer;
    }

    public void setMessageConsumer(MessageConsumer messageConsumer) {
        this.messageConsumer = messageConsumer;
    }
}

這樣主函數只需要new出MessageRenderer和MessageConsumer對象即可，對于消息怎么生產和消費則不需要關心。但這樣的問題是MessageRender和MessageConsumer耦合在一起。

我們更進一步對兩個類進行抽象：

public interface MessageConsumer {

    String sayHello(String message);
}

public interface MessageRenderer {

    void render();

    MessageConsumer getMessageConsumer();

    void setMessageConsumer(MessageConsumer messageConsumer);
}

新建實現類：

public class HelloWorldMessageConsumer implements MessageConsumer {

    @Override
    public String sayHello(String message) {
        return message;
    }
}

public class HelloWorldMessageRenderer implements MessageRenderer {

    private MessageConsumer messageConsumer;

    @Override
    public void render() {
        if (Objects.isNull(messageConsumer)) {
            System.out.println("Hello world!");
        } else {
            System.out.println(messageConsumer.sayHello("HelloWorldMessageRenderer"));
        }
    }

    @Override
    public MessageConsumer getMessageConsumer() {
        return messageConsumer;
    }

    @Override
    public void setMessageConsumer(MessageConsumer messageConsumer) {
        this.messageConsumer = messageConsumer;
    }
}

程序入口：

public class HelloWorldTest {

    public static void main(String[] args) {
        MessageRenderer renderer = new HelloWorldMessageRenderer();
        MessageConsumer consumer = new HelloWorldMessageConsumer();
        renderer.setMessageConsumer(consumer);
        renderer.render();
    }
}

至此，消息的生產和消費解耦開來，生產方只依賴消費方的抽象而不是具體實現，主程序只負責new出需要的生產方和消費方即可。三者的關系如如：

運行程序我們可以得到我們想要的輸出內容，但還有一點小問題：我們現在要的是HelloWorldMessageConsumer，假如我們需要別的MessageConsumer呢？那就需要改主程序代碼了。

下面我們添加一個類來生產MessageConsumer和MessageRenderer：

public class MessageSupportFactory {

    private static MessageSupportFactory instance;
    private Properties properties;
    private MessageRenderer messageRenderer;
    private MessageConsumer messageConsumer;

    static {
        instance = new MessageSupportFactory();
    }

    public static MessageSupportFactory getInstance() {
        return instance;
    }

    private MessageSupportFactory() {
        properties = new Properties();
        try {
            properties.load(this.getClass().getResourceAsStream("/msf.properties"));
            String rendererClass = properties.getProperty("renderer.class");
            String consumerClass = properties.getProperty("consumer.class");

            messageRenderer = (MessageRenderer) Class.forName(rendererClass).newInstance();
            messageConsumer = (MessageConsumer) Class.forName(consumerClass).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public MessageRenderer getMessageRenderer() {
        return messageRenderer;
    }

    public MessageConsumer getMessageConsumer() {
        return messageConsumer;
    }
}

msg.properties代碼如下：

renderer.class=org.chunrun.learn.sp.message.HelloWorldMessageRenderer
consumer.class=org.chunrun.learn.sp.message.HelloWorldMessageConsumer

主程序代碼如下：

public class HelloWorldTest {

    public static void main(String[] args) {
        MessageConsumer consumer = MessageSupportFactory.getInstance().getMessageConsumer();
        MessageRenderer renderer = MessageSupportFactory.getInstance().getMessageRenderer();
        renderer.setMessageConsumer(consumer);
        renderer.render();
    }
}

這樣，當我們需要不同的MessageRenderer或MessageConsumer時，只需要在配置文件里指定不同的對象即可。實際上，到這里已經完成了一個簡易版的IOC實現。

這部分只需要添加配置即可，略。