今天完成的事情：Spring 的初步学习

一、基本概念

Spring:Spring是分层的JavaSE/EE应用全栈（full-stack）轻量级开源框架，以IoC(反转控制)和AOP(面向切面编程)为内核，提供了展现层SpringMVC和                持久层 SpringJDBC以及业务层事务管理等众多的企业级应用技术。是目前使用最多的JavaEE企业应用开源框架

程序的耦合:程序的依赖关系（类之间的依赖，方法之间的依赖）。

解耦：降低程序之间的依赖关系，在实际开发中，编译期不依赖，运行时才依赖。

Bean:在计算机语言中有组件的意思。

 JavaBean：用Java语言编写的可重用组件。javabean>实体类，用javabean创建service和dao对象

                  ①、需要一个配置文件来配置service和dao配置的内容，唯一标识=全限定类名（key=value)

                  ②、通过配置文件中配置的内容，反射创建对象

二、学习了三层架构 

持久层->业务层->表现层

持久层

public class AccountDaoImpl implements IAccountDao {
    public void saveAccount(){
        System.out.println("保存了账户");
    }
}

业务层

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
    public void saveAccount(){
        accountDao.saveAccount();
    }
}

表现层

public class Client {
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}

由此（白色部分）可以看出调用的时候都必须要new一个对象，才能使程序正常运行，独立性太差。在此就引用了工厂模式解耦，目的是提高开发效率，提高独立性。

三、工厂模式解耦

1、创建账户的持久层接口

public interface IAccountDao {
    /**
     * 模拟保存账户
     */
    void saveAccount();
}

2、创建账户的持久层实现类

public class AccountDaoImpl implements IAccountDao {
    public void saveAccount(){
        System.out.println("保存了账户");
    }
}

3、创建账户的业务层接口

public interface IAccountService {
        /**
         * 模拟保存
         */
        void saveAccount();
    }

4、创建账户的业务层实现类

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");
    public void saveAccount(){
        int i = 1;
        accountDao.saveAccount();
        System.out.println(i);
        i++;
    }
}

5、设置配置文件

在resources目录下创建一个bean.properties配置文件，文件内容如下

accountService=com.itxzy.service.impl.AccountServiceImpl
accountDao=com.itxzy.dao.impl.AccountDaoImpl

后边com.~~~~~是全限定类名，要根据项目的路径来写

6、创建工厂类

步骤：①、定义一个properties对象

          ②、定义一个Map(容器)，用于存放我们要创建的对象。

          ③、实例化对象。

          ④、获取properties文件的流对象

          ⑤、实例化容器

          ⑥、取出配置文件中的所有key

          ⑦、遍历枚举

          ⑧、取出每个key

          ⑨、根据key获取value

          ⑩、反射创建对象

          ⑪、把key和value存入容器

代码如下

public class BeanFactory {
    //1，定义一个Properties对象
    private static Properties props;
    //2.定义一个Map,用于存放我们要创建的对象。我们把它称为容器
    private static Map<String,Object> beans;
    static {
        try {
            //3.实例化对象
            props = new Properties();
            //4.获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //5.实例化容器
            beans = new HashMap<String, Object>();
            //6.取出配置文件中的所有Key
            Enumeration keys = props.keys();
            //7.遍历枚举
            while (keys.hasMoreElements()){
                //8.取出每个key
                String key = keys.nextElement().toString();
                //9.根据key获取value
                String beanPath = props.getProperty(key);
                //10.反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //11.把key和value存入容器
                beans.put(key,value);
            }
        }catch (Exception e){
            throw new ExceptionInInitializerError("初始化properties失败!");
        }
    }

最后还要获取Bean对象， 有两种模式，下边是使用了多例对象

/**
 * 根据Bean的名称获取Bean对象(多例对象)
 * @param beanName
 * @return
 */
public static Object getBean(String beanName){
    Object bean = null;
    try {
        String beanPath = props.getProperty(beanName);
        bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
    }catch (Exception e){
        e.printStackTrace();
    }
    return bean;

}

多例对象模式运行结果如下

采用多例模式产生了多次的对象，意思就是多次使用new重新实例化对象；如果是单例模式的话，就前前后后都使用同一个对象，至始至终都是只创建一个对象，就是只new一次。由于多例对象创建多次，其执行效率肯定没有单例对象执行的效率高的。

下边使用了单例对象（推荐）

/**
 * 根据bean的名称来获取对象（单例对象）
 * @param beanName
 * @return
 */
public static Object getBean(String beanName){
    return beans.get(beanName);
}

单例模式运行结果如下

四、IOC（Inversion of Control  控制反转）

主要作用就是降低程序间的依赖关系，以前的控制靠自己，现在的控制靠容器，这种控制权的转换时控制反转。

以前创建对象靠自己new一个

private IAccountDao accountDao = new AccountDaoImpl();

现在的由BeanFactory 获取 beanName 来创建，控制权在BeanFactory手中。工厂包分配对象？？（滑稽脸）

private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");

明天计划的事情：IOC环境搭建