Java从工厂方法模式到 IOC/DI思想 详解Java从工厂方法模式到 IOC/DI思想

public interface FileOper{

  public Boolean exceptFile（String data）;
}
public class XMLFileOp implment FileOper{

   public Boolean exceptFile(String data){
      System.out.println("导出一个xml文件");
      return true;
   } 
}
public class Factory{

    public static FileOper createFileOp(){

        return new XMLFileOp();
    } 

}
public Class Test{

 public static void main(String args[]){

    FileOper op = Factory.createFileOp();
    op.exceptFile("测试");

}


}

public Class TxtFileOp implment FileOper{     
    public Boolean ExceptFile（String data）{      
        System.out.println("导出txt文件")；   
        return true； 
    } 
}

public class AbstractFactoryTest {
    public static void main(String[] args) {
        try {
            Product a;
            AbstractFactory af;
            af = (AbstractFactory) ReadXML1.getObject();
            a = af.newProduct();
            a.show();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}
//抽象产品：提供了产品的接口
interface Product {
    public void show();
}
//具体产品1：实现抽象产品中的抽象方法
class ConcreteProduct1 implements Product {
    public void show() {
        System.out.println("具体产品1显示...");
    }
}
//具体产品2：实现抽象产品中的抽象方法
class ConcreteProduct2 implements Product {
    public void show() {
        System.out.println("具体产品2显示...");
    }
}
//抽象工厂：提供了厂品的生成方法
interface AbstractFactory {
    public Product newProduct();
}
//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory {
    public Product newProduct() {
        System.out.println("具体工厂2生成-->具体产品2...");
        return new ConcreteProduct2();
    }
}

class ReadXML1 {
    //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
    public static Object getObject() {
        try {
            //创建文档对象
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File("src/FactoryMethod/config1.xml"));
            //获取包含类名的文本节点
            NodeList nl = doc.getElementsByTagName("className");
            Node classNode = nl.item(0).getFirstChild();
            String cName = "FactoryMethod." + classNode.getNodeValue();
            //System.out.println("新类名："+cName);
            //通过类名生成实例对象并将其返回
            Class<?> c = Class.forName(cName);
            Object obj = c.newInstance();
            return obj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

/**
 * 文件导出接口
 * 实现将指定数据的导出
 * 扩展：实现该接口，可指定生产具体文件类型
 * @author GCC
 */
public interface ExportFileApi {

    /**
     * 导出文件
     * @param data 待导出数据
     * @return boolean
     */
    boolean exportFile(String data);

}
/**
 * 生产Excel文件导出器
 * @author GCC
 */
public class ExportExcelFile implements ExportFileApi {
    @Override
    public boolean exportFile(String data) {
        //todo 处理数据
        return false;
    }
}
/**
 * 导出功能口，工厂
 * @author GCC
 */
public abstract class ExportFileOperate {

    public Logger logger = Logger.getLogger(ExportFileOperate.class);
    //使用产品对象来实现一定功能的方法，这里是实现数据导出
    public void export(String data){
        ExportFileApi exportoper = methodFactory();
        if(exportoper.exportFile(data)){
            logger.info("文件导出成功");
            return;
        }
        logger.error("文件导出失败");

    }

    //工厂方法
    protected abstract ExportFileApi;

}
/**
 * 将指定数据导出为Excel文件
 * @author GCC
 */
public class ExportExcelFileFactory extends ExportFileOperate {

    @Override
    protected ExportFileApi methodFactory() {
        return new ExportExcelFile();
    }
}
/**
 * 客户用例
 */
public class App 
{
    static Logger logger = Logger.getLogger(App.class);

    public static void main( String[] args )
    {
        ExportFileOperate ex = new ExportExcelFileFactory();
        ex.export("测试数据");
    }
}

public class SimpleFactory {
    public Calculator create(String type){

        switch (type){
            case "+":
                //返回一个具有加法功能的计算器对象
                return new AddCalculator();
            case "-":
                //返回一个具有减法功能的计算器对象
                return new DeCalculator();
            default:return null;
        }
    }
}

public class Person {

    private String name;
    //依赖文件操作对象
    private FileUtil fileUtil;

    private int age;

    //提供set方法，供外部注入
    public void setFileUtil(FileUtil fileUtil){
        this.fileUtil = fileUtil;
    }
    
    public void opFile(String fileurl){
        fileUtil.createFile(fileurl);
    }
    

}

public abstract class Person {

    private String name;

    private int age;

    //交给子类去实现我的依赖
    public abstract FileUtil getFileutil();

    public void opFile(String fileurl){
        getFileutil().createFile(fileurl);
    }


}