第一节：Spring简介

Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架。

EE开发分成三层结构：

• WEB层：Spring MVC;
• 业务层：Bean管理（IOC）;
• 持久层：Spring的JDBC模板，ORM模板用于整合其他的持久层框架。

第二节：Spring的优势

• 方便解耦，简化开发
  Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理。
• AOP编程的支持：
  Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
• 声明式事务的支持：
  只需要通过配置就可以完成对事务的管理，而无需手动编程。
• 方便程序的测试：
  Spring对Junit4支持，可以通过注解方便的测试Spring程序。
• 方便集成各种优秀框架：
  Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持，降低JavaEE API的使用难度。
  Spring对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等)，都提供了封装，使这项API应用难度大大降低。

第三节：Spring入门

3.1 Spring的下载

https://spring.io/projects/spring-framework

点击图示中的gitHub图标

3.2 Spring Jar包分析

• docs:API和开发规范
• libs:jar包和源码
• schema: 约束

3.3 创建Web项目，引入Spring的开发包

导入jar包并添加日志与Spring的配置文件

3.4 创建接口以及实现类，并实现接口中的方法

/**
 * 接口
 */
public interface UserDao {

    public void sayHally();

}

/**
 * 接口实现
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void sayHally() {
        //工厂模式+ 配置文件+代理模式
        System.out.println("Hello Spring...");
    }
}

3.5 创建applicationContext.xml配置文件，引入约束配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    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">
    <!--Spring的入门案例-->
    <bean id="userDao" class="com.seapp.spring.dao.impl.UserDaoImpl"/>


</beans>

3.6 创建测试类，实现对接口的调用

    @Test
    public void Demo01(){
        //通过配置来进行调用
        //1.创建Spring工厂类
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过工厂解析xml获取Bean实例
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        //3.执行对应的方法
        userDao.sayHally();
    }

第四节：Spring中的概念解析

• IOC:控制反转，将对象的创建权交给了Spring.
• DI：Dependency Injection 依赖注入 需要由IOC的环境，Spring创建这个类的过程中，Spring将类依赖的属性设置进去。

第五节：Spring执行过程中的角色分析

5.1 Spring中的工厂：ApplicationContext

• ClassPathXmlApplicationContext：加载类路径下spring的配置文件。
• FileSystemXmlApplicationContext：截止本地磁盘下spring的配置文件。

5.2 BeanFactory

BeanFactory和ApplicationContext的区别？

     BeanFactory:是在getBean的时候才生成类的实例。
     ApplicationContext:在加载applicationContext.xml的时候创建。

5.3 Spring的相关配置：

• 5.1 id属性和name属性标签的配置
  • id：给Bean起个名字，在约束中采用ID的约束、唯一、必须以字母开始。可以使用字母、数字、连字符、下划线、句号、冒号。id中不能出现特殊字符。
  • name:给Bean起个名字，没有采用ID的约束。name出现特殊字符，如果<bean>没有id的话，name可以当id使用。
• 5.2 scope属性：Bean的作用范围

* singleton:默认值，单例的。
* prototype:多例的。
* request:WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中。
* session：WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中。
* globalSession：WEB项目中，应用在Porlet环境，如果没有Porlet环境那么globalSession相当于session。

第六节： Spring生成Bean的三种方式：

6.1 无参数的构造方式：

<!--方式一：无参数的构造方法的实例化-->
<bean id = "bean1" class="com.seapp.spring.BeanDemo01"></bean>

6.2 静态工厂实例化的方式：

//提供一个工厂类
public class Bean2Factory{
  public static Bean2 getBean2(){
    return new BeanDemo02();
  }
}

<!-- 方式二：静态工厂实例化 -->
<bean id = "bean2" class = "com.seapp.spring.Bean2Factory" factory-method="getBean2"/>

6.3 实例工厂实例化的方式：

//提供Bean3的实例工厂：
public class Bean3Factory{
  public Bean3 getBean3(){
    return new Bean3();
  }
}

<!-- 方式三：实例工厂实例化Bean-->
<bean id = "bean3Factory" class = "com.seapp.spring.Bean3Factory"></bean>
<bean id = "bean3" factory-bean = "bean3Factory" factory-method = "getBean3"></bean>

第七节：Spring中Bean的属性注入

7.1 通过构造方式注入：

//提供JavaBean类，并创建构造函数
public class Car01 {

    private String name;
    private long price;

    public Car01(String name, long price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car01{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

//在Spring配置文件中，配置Bean对象，并实现属性注入
<!--Spring注入方式一：构造方式-->
    <bean id="car01" class="com.seapp.spring.dao.Car01">
        <constructor-arg name="name" value="奔驰"/>
        <constructor-arg name="price" value="10000"/>
    </bean>

//构建测试类，实现对JavaBean对象的调用
 @Test
    public void Demo02() {
        //1.创建Spring工厂类
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过工厂解析xml获取bean实例
        Car01 car01 = (Car01) applicationContext.getBean("car01");
        System.out.println(car01.toString());
    }

7.2 通过set方法注入：

//提供JavaBean类，并对属性设置set方法
public class Car02 {

    private String name;
    private String price;

    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(String price) {
        this.price = price;
    }


    @Override
    public String toString() {
        return "Car02{" +
                "name='" + name + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}

//在Spring配置文件中，配置Bean对象，并实现属性注入
<!--Spring注入方式二：set方法进行注入-->
    <bean id="car02" class="com.seapp.spring.dao.Car02">
        <property name="name" value="宝马"/>
        <property name="price" value="20000"/>
    </bean>

//构建测试类，实现对JavaBean对象的调用
   @Test
    public void Demo03() {
        //1.创建Spring工厂类
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过工厂解析xml获取bean实例
        Car02 car02 = (Car02) applicationContext.getBean("car02");
        System.out.println(car02.toString());
    }

7.2 Spring中Bean对对象的注入实例：

//提供JavaBean类，其中有属性对应的Car01对象
public class EmployMent {

    private String userName;
    private Car01 car01;

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setCar01(Car01 car01) {
        this.car01 = car01;
    }

    @Override
    public String toString() {
        return "EmployMent{" +
                "userName='" + userName + '\'' +
                ", car01=" + car01 +
                '}';
    }
}


//在Spring配置文件中，配置Bean对象，并实现属性注入
<!--Spring注入：实现对象的注入
  * ref:指向配置文件中的配置对象。Bean的id或name.
-->
    <bean id="employ" class="com.seapp.spring.dao.EmployMent">
        <property name="userName" value="王者"/>
        <property name="car01" ref="car01"/>
    </bean>

//构建测试类，实现对JavaBean对象的调用
   @Test
    public void Demo04() {
        //1.创建Spring工厂类
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.通过工厂解析xml获取bean实例
        EmployMent employ = (EmployMent) applicationContext.getBean("employ");
        System.out.println(employ.toString());
    }

7.4 Bean属性注入P名称空间的注入(Spring 2.5+)

• 引入P名称空间的约束

  
  
• Spring配置文件中Bean的配置：

    <!--Spring注入方式二：set方法进行注入(通过p名称空间实现属性注入)
        - 普通属性    p:属性名称 = "值"  
        - 对象属性    p:对象名称-ref = "值"
    -->
    <bean id="car02" class="com.seapp.spring.dao.Car02"
          p:name="宝马" p:price="20000">
    </bean>

    <!--Spring注入：实现对象的注入（p名称空间实现）-->
    <bean id="employ" class="com.seapp.spring.dao.EmployMent"
          p:userName="王者" p:car01-ref="car01">
    </bean>

7.5 Spring中Bean通过SPEL进行属性注入(Spring 3.0+)

SPEL：Spring表达式语言（Spring Expression Language）。SpEL是一种强大的、简洁的装配Bean的方式，它通过运行期执行的表达式将值装配到Bean的属性或构造器参数中。

• SPEL语法：

      #{SPEL}
  

• 案例实战：

<!--Spring注入方式二：set方法进行注入(通过SPEL属性注入)-->
    <bean id="car02" class="com.seapp.spring.dao.Car02">
        <property name="name" value="#{'摩托车'}"/>
        <property name="price" value="#{200}"/>
    </bean>


    <bean id="carInfo" class="com.seapp.spring.dao.CarInfo">
        <property name="name" value="#{'自行车'}"/>
    </bean>

    <!--Spring注入方式一：构造方式(SPEL实现对属性注入)-->
    <bean id="car01" class="com.seapp.spring.dao.Car01">
        <constructor-arg name="name" value="#{carInfo.name}"/>
        <constructor-arg name="price" value="#{carInfo.getPrice()}"/>
    </bean>

    <!--Spring注入：实现对象的注入（p名称空间实现）-->
    <bean id="employ" class="com.seapp.spring.dao.EmployMent">
        <property name="userName" value="#{'王者'}"/>
        <property name="car01" value="#{car01}"/>
    </bean>

7.6 Spring中通过Bean注入复杂类型：

<!-- Spring的集合属性的注入============================ -->
    <!-- 注入数组类型 -->
    <bean id="collectionBean" class="com.itheima.spring.demo5.CollectionBean">
        <!-- 数组类型 -->
        <property name="arrs">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        
        <!-- 注入list集合 -->
        <property name="list">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        
        <!-- 注入set集合 -->
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>
        
        <!-- 注入Map集合 -->
        <property name="map">
            <map>
                <entry key="aaa" value="111"/>
                <entry key="bbb" value="222"/>
                <entry key="ccc" value="333"/>
            </map>
        </property>
    </bean>

第八节：Spring的分模块开发的配置

8.1 在创建工厂的时候加载多个配置文件

ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext
("applicationContext01.xml","applicationContext02.xml");

8.2 在一个配置文件中包含另一个配置文件：

<import resource = "applicationContext02.xml"/>