学习总结

1 Spring概述

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

2 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 技术的最佳实践的范例。

3 IoC（控制反转-Inversion Of Control）的概念和作用

容器：由于我们是很多对象，肯定要找个集合来存。这时候有 Map 和 List 供选择。 到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。 所以我们的答案就是在应用加载时，创建一个 Map，用于存放三层对象。 我们把这个 map 称之为容器。

工厂：工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。 原来： 我们在获取对象时，都是采用 new 的方式。是主动的。现在： 我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一。

明确 ioc 的作用： 削减计算机程序的耦合(解除我们代码中的依赖关系)。

4 使用 spring 的 IOC 解决程序耦合

4.1 maven 准备 spring 的开发包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.2.9.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>

4.2 在类的根路径下创建一个任意名称的 xml 文件（不能 是中文）写上约束

4.3 让 spring 管理资源，在配置文件中配置 service 和 dao

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 构造函数创建对象 单例模式 -->
    <bean id="accountService" class="com.itlaobing.spring.service.impl.IAccountServiceImpl">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
    <bean id="accountDao" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

测试是否成功

    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口，就是在获取 spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2.根据 bean 的 id 获取对象
        IAccountService accountService = (IAccountService) context.getBean("accountService");
        System.out.println(accountService);
        IAccountDao accountDao = (IAccountDao) context.getBean("accountDao");
        System.out.println(accountDao);
    }

4.3.1 BeanFactory 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。 ApplicationContext 是它的子接口。

创建对象的时间点不一样。 ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。 BeanFactory：什么使用什么时候创建对象。

4.3.2 ApplicationContext 接口的实现类

• ClassPathXmlApplicationContext： 它是从类的根路径下加载配置文件 推荐使用这种
• FileSystemXmlApplicationContext： 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
• AnnotationConfigApplicationContext: 当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

4.3.3 IOC 中 bean 标签和管理对象细节

作用

• 用于配置对象让 spring 来创建的。
• 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性

• id：给对象在容器中提供一个唯一标识。用于获取对象。
• class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
• scope：指定对象的作用范围。
  • singleton :默认值，单例的.
  • prototype :多例的.
  • request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
  • session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
  • global session :WEB 项目中,应用在 Portlet 环境（Portlet是基于Java的Web组件）.如果没 有 Portlet 环境那么globalSession 相当于 session.
• init-method：指定类中的初始化方法名称。
• destroy-method：指定类中销毁方法名称。

bean 的作用范围和生命周期

单例对象：scope="singleton"

一个应用只有一个对象的实例。它的作用范围就是整个引用。

生命周期：

对象出生：当应用加载，创建容器时，对象就被创建了。

对象活着：只要容器在，对象一直活着。

对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope="prototype"

每次访问对象时，都会重新创建对象实例。

生命周期：

对象出生：当使用对象时，创建新的对象实例。

对象活着：只要对象在使用中，就一直活着。

对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

实例化 Bean 的三种方式

第一种方式：使用默认无参构造函数

<!-- 构造函数创建对象 多例模式 构造函数注入 -->
    <bean id="accountDao1" scope="prototype" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <constructor-arg index="0" type="boolean" value="flag"/>
    </bean>

第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象

public class StaticFactory {

    public static IAccountDao createInstance(){

        return new IAccountDaoImpl();
    }
}

此种方式是: 使用 StaticFactory 类中的静态方法 createInstance创建对象，并存入 spring 容器

id 属性：指定 bean 的 id，用于从容器中获取

class 属性：指定静态工厂的全限定类名

factory-method 属性：指定生产对象的静态方法

<!-- 静态工厂创建对象 set注入 -->
    <bean id="accountDaoStaticFactory" class="com.itlaobing.spring.factory.StaticFactory" factory-method="createInstance">
        <property name="flag" value="true" />
    </bean>

第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象

public class InstanceFactory {

    public IAccountDaoImpl createInstance(){
        return new IAccountDaoImpl();
    }
}

此种方式是： 先把工厂的创建交给 spring 来管理。 然后在使用工厂的 bean 来调用里面的方法

factory-bean 属性：用于指定实例工厂 bean 的 id。

factory-method 属性：用于指定实例工厂中创建对象的方法。

 <!-- 实例工厂创建对象 懒加载 p名称空间注入 -->
    <bean id="accountDaoInstanceFactory" class="com.itlaobing.spring.factory.InstanceFactory" >
    </bean>
    <bean id="accountDaoFactory" factory-bean="accountDaoInstanceFactory" factory-method="createInstance" lazy-init="true"
    p:flag="false ">
    </bean>

懒加载

懒加载（Lazy）是指在启动Spring容器时不实例化bean对象，而是在需要对象时实例化bean对象。懒 就是不提前准备好bean对象，需要bean对象时才实例化bean对象，有懒惰的表现。 当Scope="singleton"时，表示Spring容器启动时实例化Bean对象；Scope="prototype"时，表示调用 getBean()时初实例化Bean对象，而不是在容器启动时实例化Bean对象。在bean定义中设置lazy-init="true"，表示该bean懒加载。

spring 的依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。 我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的 情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。 简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

构造函数注入，顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通 过配置的方式，让 spring 框架来为我们注入。具体代码如下：

public class IAccountDaoImpl implements IAccountDao {

    private boolean flag;

    public IAccountDaoImpl(boolean flag) {
        this.flag = flag;
    }
}

<!-- 构造函数创建对象 多例模式 构造函数注入 -->
    <bean id="accountDao1" scope="prototype" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <constructor-arg index="0" type="boolean" value="flag"/>
    </bean>

set 方法注入 顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：

public class IAccountDaoImpl implements IAccountDao {

    private boolean flag;
    
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

    <!-- 静态工厂创建对象 set注入 -->
    <bean id="accountDaoStaticFactory" class="com.itlaobing.spring.factory.StaticFactory" factory-method="createInstance">
        <property name="flag" value="true" />
    </bean>

使用 p 名称空间注入数据（本质还是调用 set 方法）此种方式是通过在 xml 中导入 p 名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用 类中的set 方法实现注入功能。配置文件代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
  <!-- 实例工厂创建对象 懒加载 p名称空间注入 -->
    <bean id="accountDaoInstanceFactory" class="com.itlaobing.spring.factory.InstanceFactory" >
    </bean>
    <bean id="accountDaoFactory" factory-bean="accountDaoInstanceFactory" factory-method="createInstance" lazy-init="true"
    p:flag="false ">
    </bean>
</beans>

注入集合属性 顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是 集合。 我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下：

import lombok.Data;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

@Data
public class Cat {

    private int age;

    private String name;

    private double weight;

    private String[] arr;

    private List<String> list;

    private Map<String , Object> map;

    private Set<String> set;

    private Properties properties;

    public void init(){
        System.out.println("init cat");
    }

    public void destroy(){
        System.out.println("destory cat");
    }

    public void eat(String food){
        System.out.println("Hello world");
        System.out.println("Cat 正在吃" + food);
    }
}

<!-- 注入集合属性 -->
    <bean id="cat" class="com.itlaobing.spring.test.Cat" init-method="init" destroy-method="destroy">
        <property name="name" value="鱼丸" />
        <property name="age" value="3" />
        <property name="weight" value="5" />
        <!-- 数组 -->
        <property name="arr" >
            <array>
                <value>白猫</value>
                <value>黑猫</value>
            </array>
        </property>

        <!-- list集合 -->
        <property name="list">
            <list>
                <value>虹猫</value>
                <value>黑猫警长</value>
                <value>蓝猫</value>
            </list>
        </property>

        <!-- map集合-->
        <property name="map" >
            <map>
                <entry key="斗罗" value="三少" />
                <entry key="诡秘" value="乌贼" />
            </map>
        </property>

        <!-- set集合-->
        <property name="set">
            <set>
                <value>呐喊</value>
                <value>狂人日记</value>
            </set>
        </property>

        <property name="properties">
            <props>
                <prop key="url">jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8</prop>
            </props>
        </property>
    </bean>

心得体会

今天终于开始学习spring了，对他期待已久，今天主要学习了他基于xml配置对对象的创建和依赖注入，对他们怎么用有了一定的了解，但是在实际项目中的具体作用还有点茫然，可能需要在实际项目中使用才能更好的理解。