（反射应用案例）反射与工厂设计模式

如果要想进行对象的实例化处理除了可以使用关键字new之外，还可以使用反射机制来完成，但是为什么需要提供有一个反射实例化？那么到底是使用关键字new还是使用反射呢？

如果要想更好的理解此类问题，最好的解释方案就是通过工厂设计模式来解决。工厂设计模式最大的特点就是：客户端的程序类不直接牵扯到对象的实例化管理，只与接口发生关联，通过工厂类获取指定接口的实例化对象。

package reflect;

//定义接口
interface IMessage{

    public void send();

}
//接口实现
class NetMessage implements IMessage{

    @Override
    public void send() {
        System.out.println("【消息发送】");
    }

}

public class Demo {

    public static void main(String[] args) throws Exception {

       IMessage msg = new NetMessage();//如果直接实例化会造成耦合问题

    }

}

在实际的开发之中，接口的主要作用是为了不同的层提供有一个操作的标准，但是此时直接将一个子类设置为接口实例化操作，那么一定会有耦合问题，所以使用了工厂设计模式来解决此问题。

范例：利用工厂设计模式解决

package reflect;

//定义接口
interface IMessage{

    public void send();

}
//接口实现
class NetMessage implements IMessage{

    @Override
    public void send() {

        System.out.println("【消息发送】");

    }

}
//定义工厂类
class Factory{

    private Factory(){} //没有产生实例化对象的意义

    public static IMessage getInstance(String className){

        if("NetMessage".equalsIgnoreCase(className)){
            return new NetMessage();
        }
        return null;

    }
}

public class Demo {

    public static void main(String[] args) throws Exception {

       IMessage msg = Factory.getInstance("NetMessage");
       msg.send();    //结果：【消息发送】

    }

}

此种设计模式属于静态工厂设计模式，也就是说如果现在追加一个子类，则意味着工厂类一定要做出修改，如果不追加这种判断是无法获取指定接口对象的。

范例：为IMeesge追加一个子类

package reflect;

//定义接口
interface IMessage{

    public void send();

}
//接口实现1
class NetMessage implements IMessage{

    @Override
    public void send() {

        System.out.println("【消息发送】");

    }

}
//接口实现2
class CloudMessage implements IMessage{

    @Override
    public void send() {

        System.out.println( "【云消息发送】");

    }

}

//定义工厂类
class Factory{

    private Factory(){} //没有产生实例化对象的意义

    public static IMessage getInstance(String className){

        if("NetMessage".equalsIgnoreCase(className)){
            return new NetMessage();
        }else if("CloudMessage".equalsIgnoreCase(className)){
            return new CloudMessage();
        }
        return null;

    }
}

public class Demo {

    public static void main(String[] args) throws Exception {

       IMessage msg = Factory.getInstance("cloudmessage");
       msg.send();    //结果：【云消息发送】

    }

}

工厂设计模式最有效解决的是子类与客户端的耦合问题，但是解决的核心思想是在于提供有一个工厂类作为过渡端，随着项目的进行，你的IMsseage的子类会增多，随着子类增多工厂类也要修改。

那么此时最好的解决方法就是不使用关键字new来完成,因为关键字new在使用的时候需要有一个明确的类存在。所以此时newInstance()方法只需要有一个明确表示类名称的字符串即可应用。

package reflect;

import java.lang.reflect.InvocationTargetException;

//定义接口
interface IMessage{

    public void send();

}
//接口实现1
class NetMessage implements IMessage{

    @Override
    public void send() {

        System.out.println("【消息发送】");

    }

}
//接口实现2
class CloudMessage implements IMessage{

    @Override
    public void send() {

        System.out.println( "【云消息发送】");

    }

}

//定义工厂类
class Factory{

    private Factory(){} //没有产生实例化对象的意义

    public static IMessage getInstance(String className)  {

        IMessage instance = null;
        try {
            //通过字符串获取对象，再通过构造方法实例化
            instance =(IMessage) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;

    }
}

public class Demo {

    public static void main(String[] args) throws Exception {

       IMessage msg = Factory.getInstance("reflect.CloudMessage");  //传入指定路径字符串
       msg.send();  //结果：【云消息发送】

    }

}

这个时候可以发现，利用反射机制实现的工厂模式最大的优势在于，对于接口子类的扩充将不再影响到工厂类的定义。

但是在实际的项目之中会存在大量的接口，并且这些接口都可能需要通过工厂类实例化，所以此时的工厂设计模式不应该只为一个IMessage接口服务。

范例：利用泛型解决受限接口的问题

package reflect;

import java.lang.reflect.InvocationTargetException;

//定义接口1
interface IMessage{

    public void send();

}
//IMessage接口实现1
class NetMessage implements IMessage{

    @Override
    public void send() {

        System.out.println("【消息发送】");

    }

}
//IMessage接口实现2
class CloudMessage implements IMessage{

    @Override
    public void send() {

        System.out.println( "【云消息发送】");

    }

}
//定义接口2
interface IService{

    public void service();

}

//IService实现接口
class HouseService implements IService{

    @Override
    public void service(){

        System.out.println("【住房服务】");

    }

}



//定义工厂类
class Factory{

    private Factory(){} //没有产生实例化对象的意义

    /**
     * 获取接口实例化对象
     * @param className 接口的子类
     * @param clazz  描述的是一个接口的类型
     * @param <T>   如果子类存在则返回指定接口实例化对象
     * @return
     */
    public static <T>T getInstance(String className,Class<T> clazz)  {

        T instance = null;
        try {
            //通过字符串获取对象，再通过构造方法实例化
            instance =(T) Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return instance;

    }
}

public class Demo {

    public static void main(String[] args) throws Exception {

       IMessage msg = Factory.getInstance("reflect.CloudMessage",IMessage.class);  //传入指定路径字符串
       msg.send();  //结果：【云消息发送】
        IService iService = Factory.getInstance("reflect.HouseService",IService.class);
        iService.service(); //结果:【住房服务】

    }

}