java IoC

     IoC，控制反转，是spring的核心，通俗点讲就是我们不必再自己去用new创建对象了，通过l配置将类注入到IoC容器中，在启动时，IoC容器去帮我们创建对象，并管理其依赖关系，这种实现方式叫做DI，依赖注入。为什么我们要用IoC去帮我们管理对象呢，因为通常一个业务逻辑都是由多个对象合作完成工作的，如果自己管理的话比较，就要在一个方法中调用多个对象，不好管理，重用性低。

     //使用工厂模式加配置文件的方式模范了一个简易IoC的工作原理 //1.BeanFactory.java  bean工厂，创建对象 //2.PropertiesReader.java 读取配置文件 //3.普通bean类 //4.测试类 

 

package myIoC;
/**
 * 1.读取配置文件接口，有两个实现类，一个用类加载路径读取配置文件，第二个用文件路径读取配置文件
 * 2.提供Bean工厂方法
 * @author LH-PC
 *
 */
public interface ApplicationContext {
    
    /**
     * bean工厂方法
     * @param name
     * @return
     */
    Object getBean(String name);
    Object getBean(String name, String className);
    
}

package myIoC;

import java.util.Date;
import java.util.Map;

/**
 * ApplicationContext实现类之一，类加载读取配置文件
 * @author LH-PC
 *
 */
public class ClassPathXmlApplicationContext implements ApplicationContext{

    private String propertiesName;
    
    /**
     * 构造方法用于加载配置文件
     * @param xml
     */
    public ClassPathXmlApplicationContext(String propertiesName){
        //初始化属性
        this.propertiesName = propertiesName;
    }
    
    /**
     * 通过类加载方式的工厂方法
     */
    public Object getBean(String name) {
        //读取配置文件
        PropertiesReader propertiesReader = new PropertiesReader(propertiesName);
        Object object = null;
        //创建对象
        Map<String, String> map = propertiesReader.getProperties();
        try {
            System.err.println(new Date() +": " + "BeanFactory开始生产对象...");
            object =  Class.forName(map.get(name)).newInstance();
            System.err.println(new Date() +": " + "生产对象完毕");
        } catch (InstantiationException e) {
            System.err.println(new Date() +": " + "创建对象异常");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.err.println(new Date() +": " + "IllegalAccessException异常");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.err.println(new Date() +": " + "类加载异常");
            e.printStackTrace();
        }
        
        return object;
    }

    public Object getBean(String name, String className) {
        // TODO Auto-generated method stub
        return null;
    }

}

package myIoC;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

//读取properties文件类
public class PropertiesReader {
    
    private Properties pro = null;
    private InputStream in = null;
    private String propertiesName = null;
    
    public PropertiesReader(String propertiesName){
        this.propertiesName = propertiesName;
    }

    @SuppressWarnings("rawtypes")
    public  Map<String,String> getProperties(){
        Map<String, String> map = new HashMap<String, String>();
        pro = new Properties();  //创建properties对象
        try {
            System.err.println(new Date() +": " + "开始读取" + propertiesName + "...");
            in = PropertiesReader.class.getClassLoader().getResourceAsStream(propertiesName); //通过反射机制读取配置文件
            if(in == null){
                System.err.println(new Date() +": " + "读取流为空");
            }else{
                //开始加载文件内容
                pro.load(in);
                System.err.println(new Date() +": " + propertiesName + "读取成功");
            }
            Enumeration en = pro.propertyNames();        //迭代器遍历pro
            while(en.hasMoreElements()){
                String key = (String) en.nextElement();  //遍历key
                String value = pro.getProperty(key);     //根据key取出value，放进map
                map.put(key,value);
            }
        } catch (IOException e) {
            System.err.println(new Date() +": " + "io异常");
            e.printStackTrace();
        }
        finally{
            if(in != null){
                try {
                    in.close();//关闭读取流
                    System.err.println(new Date() +": " + "读取流关闭成功");
                } catch (IOException e) {
                    System.err.println(new Date() +": " + "读取流关闭失败");
                    e.printStackTrace();
                }  
            }
        }
        return map;
    }
    
    public static void main(String[] args) {
        PropertiesReader propertiesReader = new PropertiesReader("myIoc/applicationContext.properties");
        Map<String, String> map = propertiesReader.getProperties();
        System.out.println("ok");
    }

}

student=myIoC.Student
bean2=test.BeansImpl2
bean3=test.BeansImpl3

package myIoC;

/**
 * MyIoC测试类
 * @author LH-PC
 */
public class IoCTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myIoc/applicationContext.properties");
        Student student = (Student) applicationContext.getBean("student");
        student.setSid("15301");
        student.setSname("海");
        System.out.println(student.getSid());
        System.out.println(student.getSname());

    }

}

/**
 * 测试实体类
 * @author LH-PC
 *
 */
class Student {
    private String sname;
    private String sid;

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

}