Spring概述

代码—>SSM框架学习之Spring（一）全部代码

   Spring是什么

  Spring是分层的Java SE/EE应用full–stack轻量级开发框架，以loc（Inverse Of Control : 反转控制）和AOP(Aspect Oriented Programming : 面向切面编程)为内核，提供了展现层Spring MVC 和持久层Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开开源世界众多著名的第三方矿建和类库，逐渐成为使用最多的Java EE　企业级应用开源框架。

  Spring的发展历程和优势

    方便解耦,简化开发

  通过Spring提供的Ioc容器,可以将对象键的关系交由Spring进行控制,避免硬编码所造成的过度程序耦合.用户也不必再为单例模式类,属性文件解析等这些底层的需求编写代码,可以专注于上层的应用.

    AOP编程的支持

  通过Spring的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

    声明式事务的支持

  可以将我们从单调的烦闷的事务管理代码中解脱出来，通过声明方式灵活的进行事务管理，提高开发效率和质量。

    方便成勋的调试

  可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

    方便集成各种优秀的框架

  Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts，Hibernate,Hessian,Quartz等）的直接支持。

    降低JavaEE API的使用难度

  Spring对JavaEE API（JDBC，JavaMail，远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。

    Java源码是经典学习范例

  Spring的源代码设计精妙，结构清晰，匠心独用，处处体现着大师对Java设计模式的灵活运用以及对Java记技术的高深造诣。它的代码无疑是java技术的最佳实践范例。

Spring体系结构

IoC的概念和作用

  什么是程序的耦合

    程序的耦合指的是程序间的依赖关系，例如当类没有MySQL的驱动（jar包）时程序就会在编译期出现问题，依赖又分为
      （1）类之间的依赖
      （2）方法之间的依赖
    平常提到的解耦则指的是降低程序间的依赖性，但是依赖性只能是降低并不能完全去除，多个程序间有一个完全没有依赖关系，只能说明该程序是多余的。

      解决程序耦合

    一，通过反射来注册驱动
      第一行是正常的驱动注册代码，而第二行是通过反射来注册驱动，都能得到一样得数据，如图二

                                     

  代码示例

public class JdbcDemol  {
    public static void main(String[] args)throws Exception {
        //1.注册驱动
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
       // Class.forName("com.mysql.jdbc.Driver");
        System.out.println("----通过new对象注册驱动------");
        //2.获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/springs?serverTimezone=UTC","root","与数据库用户名对应的密码");
        //3.获取操作数据库的预处理对象
        PreparedStatement pstm = conn.prepareStatement("select * from account");
        //4.执行SQL，得到结果集
        ResultSet rs = pstm.executeQuery();
        //5.遍历结果集
        System.out.println("---从数据库中得到的结果集---");
        while(rs.next()){
            System.out.println(rs.getString("aname"));
        }
        //6.释放资源
        rs.close();
        pstm.close();
        conn.close();

    }
}

    二、工厂模式解耦
      上述的反射模式提供了一个解耦的思路

      在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的
方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
      那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

      

  代码示例

      测试代码

    public static void main(String[] args) {
        for(int i=0;i<5;i++) {
        //工厂模式案例的代码实现
        IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }
    }

    static{
        try {
            //实例化对象
            props = new Properties();//只能降低依赖，不能完去除依赖
            //获取properties文件流对象
            java.io.InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
    
            }
            }catch (Exception e){
                throw new ExceptionInInitializerError("初始程序化失败!");
             }

    }

    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;
    }

  测试结果

    这种方式每次创建的时候都会实例化一个新的对象，当每次使用同一个对象时都要被重新实例，这被叫做多例对象，其效率不如单例对象高，单例对象即指每次使用同一对象时实例化第一次后下次使用时不在重新创建，而是使用之前的创建过的。

    由此我们有了一个新的思路将最开始实例化的对象保存起来，以此来提供给下一次使用

改进后的代码

 static{
        try {
            //实例化对象
            props = new Properties();//只能降低依赖，不能完去除依赖
            //获取properties文件流对象
            java.io.InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例话容器
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            while(keys.hasMoreElements()){
                //取出每个key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
            }catch (Exception e){
                throw new ExceptionInInitializerError("初始程序化失败!");
             }

    }

 public static Object getBean(String beanName){
        return beans.get(beanName);
    }

  测试结果

    对某个类的重复使用通过单例模式提高了其运行效率，不必每次重复的去读取配置文件

控制反转-Inversion Of Control

      之前我们通过new一个对象来实例化一个对象，这种方式是应用程序主动去创建对象，可以说此时的应用成勋是用友对象创建的主动权的。关系类似于下图。

                                                  
      后来我们通过反射创建对象这一思想使用工厂模式来被动的创建对象，可以说此时的应用程序是被动创建对象的，即将对象创建的权力交由工厂来创建对象，又称控制反转（Inversion Of Control），关系类似于下图
                                        

    控制反转（Inversion Of Control）小结

      控制饭庄中，应用成勋把对象创建的权力交给框架了，这是框架的重要特征，并非是面向对象编程的专用术语。它包括依赖注入和依赖查找。
          好处：降低了程序间的依赖关系，又称消减耦合。

使用Spring的IOC解决程序耦合