Spring轻量级开发---基础知识和初体验

1.首先先来看看最简单的hello world程序

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

2.如果需要修改输出的字符串的内容，需要重新编译代码和测试相关联的功能，这是很不合理和危险的。一个更好的解决方案是让程序接收外部消息字串，这样就可以在运行时决定输出的内容。

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

3.这样的修改可以让我们改变输出的字串，这是一个进步。但观察这个程序，有两个功能:取得外部参数、输出字串

这两个功能被捆绑在一起，这是过程化的思维方式。所以我们需要分离职责

为了使程序的架构更灵活，我们应该将这两个职责装入不同的组件里，可以使用接口来实现两个不同的职责。而主程序main只和这两个组件接口打交道。

首先建两个接口

public interface IMessageDisplayer {
    /**
     * 消息显示者接口
     */
    void display();
    
    /**
     * 
     * 提供get/set方法
     */
    void setIMessageSupplier(IMessageSupplier s);
    IMessageSupplier getIMessageSupplier();
}

public interface IMessageSupplier {
    /**
     * 取得消息
     */
    String getMessage();
}

然后分别给出这两个类的实现

public class HelloWorldDisplayer implements IMessageDisplayer {

    private IMessageSupplier messageSupplier=null;
    
    public void display() {
        if(null==messageSupplier){
            throw new RuntimeException("messageSupplier为空");
        }
        System.out.println(messageSupplier.getMessage());
    }

    public IMessageSupplier getIMessageSupplier() {
        return messageSupplier;
    }

    public void setIMessageSupplier(IMessageSupplier s) {
        this.messageSupplier=s;
    }
}

public class HelloWorldSupplier implements IMessageSupplier{
    public String getMessage(){
        return "HelloWorldSup";
    }
}

然后重构下主程序即可

public class HelloWorldBetter {
    /**
     * 初步重构HelloWorld之后的主程序体
     * 解耦了消息显示者和消息提供者这两个职责
     */
    public static void main(String[] args) {
        //创建消息显示者
        IMessageDisplayer messageDisplayer=new HelloWorldDisplayer();
        //创建消息提供者
        IMessageSupplier messageSupplier=new HelloWorldSupplier();
        //注入消息提供者
        messageDisplayer.setIMessageSupplier(messageSupplier);
        //显示消息
        messageDisplayer.display();
    }
}

4.经过这样重构后，我们的成果已经比较成功了。但仍存在一些问题，如果想替换接口的实现类，则依然需要在程序中手动改动代码，那么程序代码依然要经历重新编译测试的风险，为了克服这一缺点，可以引入单例工厂(Singleton Factory)

我们首先创建一个单例工厂类

/**
 * Message组件生产工厂，这是一个单例类
 * 通过读取外部属性文件msgbean.properties
 * 获取MessageDisplayer和MessageSupplier的实现类名
 * 并由工厂创建各自的实例
 */
public class MessageSupporterFactory {

        /**
         * 全局单一的工厂实例 注意需要静态
         */
        private static MessageSupporterFactory factory=null;
        
        /**
         * 外部属性
         */
        private static Properties props;
        
        /**
         * 创建MessageSupportFactory单例方法
         * 使用Synchronized保障线程安全
         */
        public synchronized static MessageSupporterFactory getInstance()   {
            if(factory==null)
                factory=new MessageSupporterFactory();
            return factory;
        }
        private MessageSupporterFactory(){
            props=new Properties();
            try{
                props.load(new FileInputStream("conf/ch2/msgbean.properties"));
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        
        /**
         * 产生IMessageDisplayer的工厂方法
         */
        public IMessageDisplayer makeMessageDisplayer(){
            //读取IMessagePlayer具体的实现名字
            String displayClass=props.getProperty("display.class");
            try {
                return (IMessageDisplayer)Class.forName(displayClass).newInstance();
            } catch (InstantiationException e) {
                System.out.println("can not instantiate an object of type "+displayClass);
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                System.out.println("can not access class "+displayClass);
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                System.out.println("can not find the class "+displayClass);
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 产生IMessageSupplier的工厂方法
         */
        public IMessageSupplier makeMessageSupplier(){
            //读取IMessageSupplier具体的实现名字
            String supplyClass=props.getProperty("supply.class");
            try {
                return (IMessageSupplier)Class.forName(supplyClass).newInstance();
            } catch (InstantiationException e) {
                System.out.println("can not instantiate an object of type "+supplyClass);
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                System.out.println("can not access class "+supplyClass);
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                System.out.println("can not find the class "+supplyClass);
                e.printStackTrace();
            }
            return null;
        }
}

然后只要创建properties文件即可。

display.class=ch2.HelloWorldDisplayer;
supply.class=ch2.HelloWorldSupplier;

现在只需要稍微修改一下主程序main就可以达到预期效果了。

public class HelloWorldBetterWithFactory {
    public static void main(String[] args) {
        //创建消息显示者
        IMessageDisplayer messageDisplayer=MessageSupporterFactory.getInstance().makeMessageDisplayer();
        //创建消息提供者
        IMessageSupplier messageSupplier=MessageSupporterFactory.getInstance().makeMessageSupplier();
        //注入消息提供者
        messageDisplayer.setIMessageSupplier(messageSupplier);
        //显示消息
        messageDisplayer.display();
    }
}

程序中通过读取配置文件获得类名，并通过反射获取类的实例，从而实现输出的目的。尽管一个hello world程序不需要这么繁琐地做修改，但其中的道理却很有用: 为避免程序重新编译测试的风险，我们应该尽量把程序的责任分离，降低耦合度。而工厂模式和反射则是一个降低耦合度的很好用的方法。