Spring-步入Spring旅途

一、Spring前言

讲Spring之前先写段代码，体会一下Java创建对象的方式，这块你理解了对后面有好处！

1、原始时代-new对象

直接new创建对象，代码如下：

//User.java
package com.ty.bean;

public class User {
    private String username;
    private String password;

   /**
 	* 省略有参无参构造，getter/setter方法
 	*/
}

//UserDao.java
public interface UserDao {
    void getUser(String username,String password);
}

//UserDao的实现类UserDaoImpl.java
public class UserDaoImpl implements UserDao {
    @Override
    public void getUser(String username, String password) {
        System.out.println("用户名："+username+"\t密码："+password);
    }
}

//UserService.java
public interface UserService {
    void getUser(String username,String password);
}

//UserService的实现类UserServiceImpl.java
public class UserServiceImpl implements UserService {
    private UserDao userDao= new UserDaoImpl();
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

正常来讲这里还需要写一个UserController，但是我们只是测试，所以就写一个TestUser类

public class TestUser {
    @Test
    public void test(){
        UserService userService=new UserServiceImpl();
        userService.getUser("jack","root");
    }
}

这是之前学习经常写的方式用来完成某种功能，service层调用dao层；UserService的实现类调用UserDao的实现类。想象一下：如果我们业务更改了，增加了一个UserService的实现类BUserServiceImpl，使用的时候代码就要变成这样

public class TestUser {
    @Test
    public void test(){
        //UserService userService=new UserServiceImpl();
        UserService userService=new BUserServiceImpl();
        userService.getUser("jack","root");
    }
}

这就是所谓的耦合，调用的时候要修改代码，即直接new ， 显然不符合面向对象的设计原则---------开闭原则

2、过渡时代-工厂

工厂方式，再原来的代码修改一下

先创建一个BeanFactory.java文件

//创建工厂类，BeanFactory.java
public class BeanFactory {
    public static UserService getUser(){
        return new UserServiceImpl();
    }
}

这样使用的时候就变成这样

 @Test
    public void test(){
        UserService userService= BeanFactory.getUser();
        userService.getUser("jack","root");
    }

这样虽然使用的时候没有耦合了，但是BeanFactory里面还是有代码耦合的即：return UserService，那怎么办呢?可以利用反射创建对象

过渡时代进阶-反射

public class BeanFactory {
    public static UserService getUser(){
        UserService userService=null;
        try {
            Class<?> clazz = Class.forName("com.ty.service.UserServiceImpl");
            userService= (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return userService;
    }

这样比直接new好多了，减少了耦合，但是还有些不妥，获取类限定名的时候还是需要改来改去。即：

Class<?> clazz = Class.forName("com.ty.service.UserServiceImpl");

下面我们可以用properties属性配置文件存储文件限定名，代码如下：

userService=com.ty.service.UserServiceImpl

#这就实现把具体的类限定名和代码相分离，未来只需要修改此配置文件即可

public class BeanFactory {
    private static UserService userService;
    //创建Properties对象来加载properties属性配置文件
    private static Properties environment = new Properties();
    private static InputStream resource;

    static {

        //加载applicationContext.properties配置文件
        resource = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
        try {
            environment.load(resource);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                resource.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static UserService getUserService() throws Exception {

        Class<?> clazz = Class.forName(environment.getProperty("userService"));
        userService = (UserService) clazz.newInstance();
        return userService;
    }
}

这样未来增加了service代码，只需要修改properties配置文件即可，例如

public class BUserServiceImpl implements UserService {
    private UserDao userDao= new UserDaoImpl();
    @Override
    public void getUser(String username, String password) {
        System.out.println("B");
        userDao.getUser(username,password);
    }
}

#配置文件就改成这样
userService=com.ty.service.BUserServiceImpl

//测试文件
  @Test
  public void test2() throws Exception {
      UserService userService= BeanFactory.getUserService();
      userService.getUser("jack","root");
  }

我们顺便用这种方式把UserService调用UserDao进行改进

public static UserDao getUserDao() {
        UserDao userDao=null;
        Class<?> clazz = null;
        try {
            clazz = Class.forName(environment.getProperty("userDao"));
            userDao = (UserDao) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }

        return userDao;
    }

public class UserServiceImpl implements UserService {
    private UserDao userDao= BeanFactory.getUserDao();
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

userDao=com.ty.dao.UserDaoImpl

    @Test
    public void test2() throws Exception {
        UserService userService= BeanFactory.getUserService();
        userService.getUser("jack","root");
    }

工厂方法基本设计完成了，但是还有点小问题，那就是每次都需要在BeanFactory工厂类写一个与其对应的对象创建工厂方法，好麻烦，而且这些方法长得基本差不多，能不能设计一个通用的工厂方法呢，那必须能啊，上代码

public class BeanFactory {
    private static Properties environment = new Properties();
    private static InputStream resource;

    static {

        //加载applicationContext.properties配置文件
        resource = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
        try {
            environment.load(resource);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                resource.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     *
     * @param key 配置文件对应的userService，userDao
     * @return
     */
   public static Object getBean(String key){
       Object returnedObject=null;
       try {
           Class<?> clazz = Class.forName(environment.getProperty(key));
           returnedObject=clazz.newInstance();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (InstantiationException e) {
           e.printStackTrace();
       }
       return returnedObject;
   }
}

userService=com.ty.service.UserServiceImpl

userDao=com.ty.dao.UserDaoImpl

public class UserServiceImpl implements UserService {
    private UserDao userDao= (UserDao) BeanFactory.getBean("userDao");
    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

 @Test
    public void test2() throws Exception {
        UserService userService= (UserService) BeanFactory.getBean("userService");
        userService.getUser("jack","root");
    }
}

这样一个通用工厂就完成了，这种方式你还需要先自己提供工厂类和方法，我们如果用Spring的话，工厂类不用我们手动实现，Spring提供了工厂

3、近代-IOC方式

ioc容器创建对象，这种方式我们后面会详细讲解

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser(String username, String password) {
        userDao.getUser(username,password);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="com.ty.service.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="com.ty.dao.UserDaoImpl"></bean>
</beans>

 @Test
    public void test3(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.getUser("jack","root");
    }

这样我们就把创建对象的方式的一个小Demo写完了，只就是Spring框架的核心之一：ioc，我们先简单介绍一下Spring

二、spring介绍

我们交流的时候都说Spring是指Spring Framework，因为其它的分支模块都直接说了，比如SpringBoot、SpringCloud等等

官网地址：https://spring.io/projects/spring-framework

压缩包下载地址：https://repo.spring.io/release/org/springframework/spring/

源码地址：https://github.com/spring-projects/spring-framework

英文官网可能看不懂，github上还有一个中文网址，只不过不是最新版本的，不过没太大影响

https://gitee.com/fl_982659186/spring-docs

Spring 是为了解决企业级应用开发的复杂性而创建的。在 Spring 之前，有一个重量级的工具叫做 EJB，使用 Spring 可以让 Java Bean 之间进行有效的解耦，而这个操作之前只有 EJB 才能完成，EJB 过于臃肿，使用很少。Spring 不仅仅局限于服务端的开发，在测试性和松耦合方面都有很好的表现。 官网有一个简短的Spring介绍，说明Spring产生的原因

Spring makes programming Java quicker, easier, and safer for everybody. Spring’s focus on speed, simplicity, and productivity has made it the world's most popular Java framework.

总结就是Spring能为我们快速、轻松和安全的进行Java编程
详细：https://spring.io/why-spring

官网上还有一个Spring的概述

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/overview.html#overview

中文翻译：https://gitee.com/fl_982659186/spring-docs/blob/master/pages/overview/overview.md

核心解释

spring是一个一站式开源框架。

spring是为了简化企业开发而生的，使得开发变得更加优雅和简洁。

spring是一个IOC和AOP的容器框架。

​ IOC：控制反转

​ AOP：面向切面编程

​ 容器：包含并管理应用对象的生命周期，就好比用桶装水一样，spring就是桶，而对象就是水

三、Spring 特点

​ 1、Spring通过DI、AOP和消除样板式代码来简化企业级Java开发

​ 2、Spring框架之外还存在一个构建在核心框架之上的庞大生态圈，它将Spring扩展到不同的领域，如Web服 务、REST、移动开发以及NoSQL

​ 3、低侵入式设计，代码的污染极低

​ 4、独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺

​ 5、Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦

​ 6、Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式处理，从而提供了更好的复用

​ 7、Spring的ORM和DAO提供了与第三方持久层框架的的良好整合，并简化了底层的数据库访问

​ 8、Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

如何简化开发

​ 基于POJO的轻量级和最小侵入性编程

​ 通过依赖注入和面向接口实现松耦合

​ 基于切面和惯例进行声明式编程

​ 通过切面和模板减少样板式代码

四、Spring 框架结构

模块解释：
Test:Spring的单元测试模块
Core Container:核心容器模块,主要组件是 BeanFactory是不是好熟悉，上面咱们实现了一个简易版的BeanFactory
AOP+Aspects:面向切面编程模块
Instrumentation:提供了class instrumentation支持和类加载器的实现来在特定的应用服务器上使用,几乎不用
Messaging:包括一系列的用来映射消息到方法的注解,几乎不用
Data Access/Integration:数据的获取/整合模块，包括了JDBC,ORM,OXM,JMS和事务模块
Web:提供面向web整合特性

五、ioc初识

ioc（Inversion of Control )：控制反转，这是一个思想，简单一句话就是创建对象的控制权利交给Spring的容器 我们稍微详细展开一下

• 谁控制谁
• 控制什么
• 什么是反转
• 哪些方面被反转

先看一下官网如何介绍的

 IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern

 IOC与大家熟知的依赖注入同理，. 这是一个通过依赖注入对象的过程 也就是说，它们所使用的对象，是通过构造函数参数，工厂方法的参数或这是从工厂方法的构造函数或返回值的对象实例设置的属性，然后容器在创建bean时注入这些需要的依赖。 这个过程相对普通创建对象的过程是反向的（因此称之为IoC），bean本身通过直接构造类来控制依赖关系的实例化或位置，或提供诸如服务定位器模式之类的机制。

可能稍微晦涩，用现实的事物举个例子。我们要找女盆友，传统的方式是你自己按照标准亲自一步步筛选，然后就需要打听她们的兴趣爱好、qq号、电话号、微信号等等，想办法认识她们再继续下一步事情。控制反转的方式的话就是有一个婚介所，这个媒介所就是一个容器，里面有很多女生的资料，你把你的标准告诉工作人员，然后剩下的步骤由他们去操作，最后给你就返回一个符合你标准的女盆友，你就和她谈恋爱、结婚就行了。

说到这我们把上面演示过的demo画图演示一下

我们总结一下上面说的4个小问题

• 谁控制谁：以前我们都是手动创建即new所需的对象，程序员自己来控制对象的创建过程。而有了IOC容器之后，就会变成由IOC容器来控制对象
• 控制什么：实现过程中所需的对象以及所需依赖的对象
• 什么是反转：以前我们自己new依赖对象就是正转，而有了反转之后，依赖的对象由ioc容器创建后注入到对象中，由主动创建变成了被动接受，这是反转
• 哪些方面被反转：依赖的对象

DI

DI ( Dependency Injection )：依赖注入

很多人把IOC和DI说成一个东西，笼统来说的话是没有问题的，但是本质上还是有所区别的,希望大家能够严谨一点，IOC和DI是从不同的角度描述的同一件事，IOC是从容器的角度描述，而DI是从应用程序的角度来描述，也可以这样说，IOC是设计思想，而DI是具体的实现方式

上面的控制反转概念其实是模糊的 （可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系） ，所以后来就有了 “依赖注入” ，这个就很好理解，很直截了当就能说明IOC容器用来维护对象的依赖关系。

六、其它

我们面向对象设计的过程尽量达到低耦合，在面向对象设计的软件系统中，底层的实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。

​ 需要注意的是，在这样的组合关系中，一旦某一个对象出现了问题，那么其他对象肯定回有所影响，这就是耦合性太高的缘故，但是对象的耦合关系是无法避免的，也是必要的。随着应用程序越来越庞大，对象的耦合关系可能越来越复杂，经常需要多重依赖关系，因此，无论是架构师还是程序员，在面临这样的场景的时候，都需要减少这些对象的耦合性。

​ 耦合的关系不仅仅是对象与对象之间，也会出现在软件系统的各个模块之间，是我们需要重点解决的问题。而为了解决对象之间的耦合度过高的问题，我们就可以通过IOC来实现对象之间的解耦，spring框架就是IOC理论最最广泛的应用。

从上图中可以看到，当引入了第三方的容器之后，几个对象之间就没有了耦合关系，全部对象都交由容器来控制，这个容器就相当于粘合剂，将系统的对象粘合在一起发挥作用。