Spring笔记01下载概述监听器

共计 15633 个字符，预计需要花费 40 分钟才能阅读完成。

Spring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。简单来说，Spring 是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

方便解耦，简化开发
- Spring 就是一个大工厂，专门负责生成 Bean，可以将所有对象创建和依赖关系维护由 Spring 管理。通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP 变成的支持
- Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截，运行监控等功能。通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。
声明式事务的支持
- 只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
- Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
方便集成各种优秀框架
- Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的支持，如 Struts、Hibernate、Mybatis、Quartz 等
降低 JavaEE API 的使用难度
- 对 JavaEE 开发中一些难用的 API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低
Java 源码是经典学习范例
- Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

Spring 框架是一个分层架构，它包含一系列的功能要素并被分为大约 20 个模块。这些模块分为 Core Container、DataAccess/Integration、Web、AOP、Instrumentation 和测试部分。如下图所示：

web 层：Struts，SpringMVC
dao 层：Hibernate，Mybatis

程序的耦合
- 我们开发种，会写很多的类，而有些类之间不可避免地产生依赖关系，这种依赖关系称为耦合。有些依赖是必须的，有些依赖关系可以通过优化代码来解除。比如：

/**
 * 客户的业务层实现类
 */
public class CustomerServiceImpl implements ICustomerService {private ICustomerDao customerDao = new CustomerDaoImpl();    
}

上面的代码表示：业务调用持久层，并且此时业务再依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种依赖关系就是我们可以通过优化代码解决的。
再比如：下面的代码种，我们的类依赖 MySQL 的具体驱动类，如果这狮虎更换了数据库品牌，我们需要改源码来修修改数据库驱动，这显然不是我们想要的。

public class JdbcDemo1 {
    
    /**
     * JDBC 操作数据库的基本入门中存在什么问题？*       导致驱动注册两次是个问题，但不是严重的。*       严重的问题：是当前类和 mysql 的驱动类有很强的依赖关系。*                  当我们没有驱动类的时候，连编译都不让。* 那这种依赖关系，就叫做程序的耦合
     * 
     * 我们在开发中，理想的状态应该是：*       我们应该尽力达到的：编译时不依赖，运行时才依赖。*      
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");
        //2. 获取连接
        //3. 获取预处理 sql 语句对象
        //4. 获取结果集
        //5. 遍历结果集
    }

解决程序耦合的思路
- 在 JDBC 种是通过反射来注册驱动的，代码如下：
```
Clas.forName("com.mysql.jdbc.Driver");
```
- 这时的好处是，我们类中不再依赖具体的驱动类，此时就算删除 MySQL 的驱动 jar 包，依然可以编译。但是没有驱动类，所以不能运行。
- 不过，此处也有一个问题，就是我们反射类对象的全限定类名字符串是在 Java 类中写死的，一旦要改还是徐娅修改源码。为了解决这个问题，使用配置文件配置。
工厂模式解耦
- 在实际开发过程总我们把所有的 dao 和 service 和 action 对象使用配置文件配置起来，当启动服务器应用加载的时候，通过读取配置文件，把这些对象创建出来并存起来。在接下来使用的时候，直接拿就好了。
控制反转 —Inversion Of Control
- 上面解耦的思路有两个问题
  - 创建的对象存储在哪里？由于我们是很多对象，肯定要找个集合来存储，这时候有 Map 和 List 供选择。到底是选择 Map 还是 List 就看我们有没有查找的需求。有查找的需求就选 Map。所以我们的答案是：在应用加载时，创建一个 Map，用于存放 action，service 和 dao 对象。
  - 还是没解释什么是工厂? 工厂就是负责给我们从容器中获取指定对象的类。这时候获取对象的方式发生了改变。以前，我们在获取对象的时候，都是采用 new 的方式，是主动的。

现在，我么获取对象的时候，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转，他是 Spring 框架的核心之一。其作用只有一个：降低计算机程序的耦合。

使用 spring 的 IOC 解决程序耦合

下载 Spring 开发包
导入 Spring 的 jar 包
配置 Spring 的核心 xml 文件
在程序中读取 Spring 的配置文件来获取 Bean【Bean 其实就是一个 new 好的对象】

这里下载 4.2.4 版本
地址：http://repo.spring.io/release…
官网：spring.io 官网改版后，下载链接需要在对应的 GitHub 上找

spring-core-4.2.4.RELEASE.jar 包含 Spring 框架基本的核心工具类，Spring 其他组件都要使用到这个包里得嘞，是其他组件的基本核心。
spring-beans-4.2.4.RELEASE.jar 所有应用都要用到的，它包含访问配置文件、创建和管理 bean

以及进行 Inversion of Control(IoC) / Dependency Injection(DI) 操作相关的所有类。
spring-context-4.2.4.RELEASE.jarSpring 提供在基础 IoC 功能上的扩展服务，此外还提供许多企业级服务的支持,

如邮件服务、任务调度、JNDI 定位、EJB 集成、远程访问、缓存以及各种视图层框架的封装等。
spring-expression-4.2.4.RELEASE.jarSpring 表达式语言。
com.springsource.org.apache.commons.logging-1.1.1.jar 第三方的主要用于处理日志。

准备项目需要得 jar 包
- spring-framework-4.2.4.RELEASE-dist.zip【Spring 的核心包】
- spring-framework-4.2.4.RELEASE-dependencies.zip【Spring 的依赖包】
创建 Project，导入 Spring 的 jar 包
在 src 路径下创建 applicationContext.xml 文件
- 导入约束
- 把资源交给 Spring 管理，在 xml 文件中配置 User

<?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">

    <!-- 约束的位置在:
        ..\spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
        文档末尾 -->
    <!-- 
        1. 基本配置：bean 标签：指定要创建的实体类
            id 属性：可以为任意值 但是在整个配置文件中唯一
            class 属性：要实例化类的全限定名 反射
     -->
    <bean id="user" class="com.itzhouq.domain.User"></bean>

</beans>

测试

package com.itzhouq.domain;

public class User {public void run() {System.out.println("run");
    }

}

package com.itzhouq.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itzhouq.domain.User;

public class UserTeset {
    
    @Test
    public void test() {// 自己 new 的对象
        User user = new User();
        user.run();}
    
    @Test
    public void test2() {//spring 的 ioc 创建对象
        // 加载配置文件  src/classes 类路径
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 找 Spring 要对象
        User user = (User) context.getBean("user");
        user.run();}
}

作用
- 用于配置对象让 Spring 来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性
- id：给对象在容器中提供一个唯一标识，用于获取对象
- class：指定类的全限定名。用于反射创建对象，默认情况下调用无参构造函数。
- scope：指定对象的作用范围。
- init-method：指定类中的初始化方法名称。
- destroy-method: 指定类中销毁方法名称。
- import：导入外部配置文件，resource—- 外部配置文件的地址。

<bean id="user" class="cn.itzhouq.domain.User" scope="singleton" ></bean>

singleton: 单实例默认值
如果是单实例, 配置文件文件只要一加载就会创建对象放在 spring 容器 (map<id, 对象 >)
当所有人过来问 spring 容器要的时候 (getBean), 所用人用的都是同一个对象
prototype: 多实例
- 如果是多实例, 配置文件加载, 不创建对象
- 当每个人过来 getbean 的时候,getbean 一次创建一次放在容器中
什么时候用默认值 singleton(单实例)? 什么时候用 prototype(多实例)?
- action: prototype
- service/dao: singleton
request：web 项目中 Spring 创建一个 Bean 对象，将对象存入到 request 域中
session：web 项目中 Spring 创建一个 Bean 对象，将对象存入到 session 域中。
globalSession：web 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么 globalSession 相当于 session。

单例对象：scope=”singleton”
- 一个应用只有一个对象的实例。它的作用范围就是整个引用。
- 生命周期：
  - 对象出生：当应用加载，创建容器时，对象就被创建了。
  - 对象活着：只要容器在，对象一直活着。
  - 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
- 多例对象：scope=”prototype”
- 每次访问对象时，都会重新创建对象实例。
- 生命周期：
  - 对象出生：当使用对象时，创建新的对象实例。
  - 对象活着：只要对象在使用中，就一直活着。
  - 对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

无参构造方式（最常用）

@Test// 测试 bean 的三种创建方式 ------ 无参构造方式
    public void test3() {
        // 加载配置文件  src/classes 类路径
        ApplicationContext context = new         ClassPathXmlApplicationContext("applicationContext.xml");
        // 找 Spring 要对象
        User user = (User) context.getBean("user");
        user.run();}

静态工厂方式（了解）

条件：需要有一个工厂类，在这个工厂类中还需要一个静态方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {public static User createUser() {return new User();
    }

}

<!-- 静态工厂方式 -->
    <bean id="user" class="com.itzhouq.utils.BeanFactory" factory-method ="createUser">

测试

@Test// 测试 bean 的三种创建方式 ------ 静态工厂方式
    public void test4() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

实例工厂方式（了解）

条件：需要一个工厂类在这个工厂类中需要一个普通方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {//    public static User createUser() {//        return new User();
//    }
    
    // 普通方法 ---- 实例工厂
    public User createUser() {return new User();
    }
}

配置文件

<!-- 实例工厂 -->
   <bean id="beanFactory" class="com.itzhouq.utils.BeanFactory"></bean>
   <bean id="user" factory-bean="beanFactory" factory-method="createUser"></bean>

测试

@Test// 测试 bean 的三种创建方式 ------ 实例工厂方式
    public void test5() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

类路径获得配置文件
文件系统路径获得配置文件
使用 BeanFactory（了解）

public class Lession01 {

    @Test
    public void test01(){
        //Spring 容器加载有 3 种方式
        // 第一种：ClassPathXmlApplicationContext    ClassPath 类路径加载：指的就是 classes 路径
        // 最常用，Spring 的配置文件以后就放在 src 路径下
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        // 第二种方式：文件系统路径获得配置文件【绝对路径】ApplicationContext context = new FileSystemXmlApplicationContext("E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml");

        IUserService user = (IUserService) context.getBean("userService");
        user.add();

        // 第三种方式：String path = "E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml";
        BeanFactory factory = new XmlBeanFactory(new FileSystemResource(path));
        IUserService user1 = (IUserService) factory.getBean("userService");
        user1.add();}
}

Spring 内部创建对象的原理

1. 解析 xml 文件，获得类名，id，属性
2. 通过反射，用类型创建对象
3. 给创建的对象赋值

BeanFactory 采用延迟加载，第一次 getBean 时才会初始化 Bean
ApplicationContext 是对 BeanFactory 扩展，提供了更多功能
- 国际化处理
- 事件传递
- Bean 自动装配
- 各种不同应用的 Context 实现
3. 4 Spring 的依赖注入 DI
DI 属性的依赖注入，是 Spring 框架核心 IoC 的具体实现方式。Spring 在通过 Ioc 创建对象的时候，如果这个对象还有属性，就一并赋值进去，而不用我们自己去获取。

入门举例：

创建一个接口 Car

package com.itzhouq.service;

public interface Car {public void run();
}

创建实现类 CarImpl

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
    private String name;
    
    public void setName(String name) {this.name = name;}


    @Override
    public void run() {System.out.println(name+"车跑起来了.....");
    }
}

测试

package com.itzhouq.test;
import org.junit.Test;
import com.itzhouq.serviceImpl.CarImpl;
public class CarTest {    
    @Test// 自己 new 对象 自己属性赋值的方式
    public void test() {CarImpl car = new CarImpl();
        car.setName("qq");
        car.run();//qq 车跑起来了.....}
}

入门举例 2：依赖注入的方式

配置文件：

<!-- DI：属性的依赖注入 -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <!-- 
               property：是 set 属性的方式
               name：要赋值的属性名
               value：要赋的值
            -->
            <property name="name" value="兰博基尼"></property>
   </bean>

测试

@Test   //Spring 的 IOC
    public void test2() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = (Car)context.getBean("car");
        // 把这个对象的属性也在创建的时候给顺便赋值了 -----DI
        car.run();// 兰博基尼车跑起来了.....}

依赖注入的方式
- 构造函数注入（了解）
- set 方法注入（掌握）
- 使用 p 名称空间注入数据（本质还是调用 set 方法）（了解）
- 注入集合属性

条件：需要有有参构造方法

给 CarImpl 设置有参构造

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
    private String name;
    private double price;
    public void setName(String name) {this.name = name;}
    public double getPrice() {return price;}
    public void setPrice(double price) {this.price = price;}
    public String getName() {return name;}
    public CarImpl() {}
    // 有参的构造方法 ----DI 的构造器注入方式
    public CarImpl(String name, double price) {super();
        this.name = name;
        this.price = price;
    }
    @Override
    public void run() {System.out.println("价值"+price+"的"+name+"车跑起来了.....");
    }
}

配置文件

<!-- DI 的注入方式, 构造器注入方式 
           name: 要赋值的属性名
           value：要赋的值（针对的是基本数据类型和 String 类型）ref 针对的是对象类型
   -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>

测试

@Test   //Spring 的 DI 注入方式 ---- 构造器的注入方式（了解）public void test3() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = (Car)context.getBean("car");
        car.run();// 价值 1000000.0 的 BMW 车跑起来了.....}

写一个 Person 接口

package com.itzhouq.service;

public interface Person {}

PersonImpl 实现接口 Person, 设置 set 方法

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;
import com.itzhouq.service.Person;

public class PersonImpl implements Person {
    private String name;
    private Car car;
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Car getCar() {return car;}
    public void setCar(Car car) {this.car = car;}
    @Override
    public String toString() {return "PersonImpl [name=" + name + ", car=" + car + "]";
    }
}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   
   <!-- DI 的注入方式,set 注入方式 
           name: 要赋值的属性名
           value：要赋的值（针对的是基本数据类型和 String 类型）ref 针对的是对象类型, 指的是 Spring 中 bean 的 id 名
   -->
   <bean id="person" class="com.itzhouq.serviceImpl.PersonImpl">
           <property name="name" value="jack"></property>
           <property name="car" ref="car"></property>
   </bean>

测试

@Test   //Spring 的 DI 注入方式 ----set 的注入方式（了解）public void test4() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
        //PersonImpl [name=jack, car=CarImpl [name=BMW, price=1000000.0]]
    }

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

配置文件

<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">
                               
    <bean id="customerService" 
          class="com.itheima.service.impl.CustomerServiceImpl4"
          p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

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

创建一个类 CollBean，设置 set 方法

package com.itzhouq.domain;

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


public class CollBean {private String[] ss;
    private List ll;
    private Map mm;
    private Properties properties;
    public String[] getSs() {return ss;}
    public void setSs(String[] ss) {this.ss = ss;}
    public List getLl() {return ll;}
    public void setLl(List ll) {this.ll = ll;}
    public Map getMm() {return mm;}
    public void setMm(Map mm) {this.mm = mm;}
    public Properties getProperties() {return properties;}
    public void setProperties(Properties properties) {this.properties = properties;}
    @Override
    public String toString() {return "CollBean [ss=" + Arrays.toString(ss) + ", ll=" + ll + ", mm=" + mm + ", properties=" + properties + "]";
    }

}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
           <constructor-arg name="name" value="BMW"></constructor-arg>
           <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   <!-- DI 复杂属性注入 -->
   <bean id="collBean" class="com.itzhouq.domain.CollBean">
           <property name="ss">
               <!-- 数组类型 -->
               <list>
                   <value>aaa</value>
                   <value>bbb</value>
                   <value>ccc</value>
               </list>
           </property>
           <property name="ll">
               <!-- 集合类型 -->
               <list>
                   <value>111</value>
                   <value>222</value>
                   <ref bean="car"></ref>
               </list>
           </property>
           <property name="mm">
               <!-- map 类型 -->
               <map>
                   <entry key="k1" value="AAA"></entry>
                   <entry key="k2" value="BBB"></entry>
                   <entry key="k3" value-ref="car"></entry>
               </map>
           </property>
           <property name="properties">
               <!-- properties -->
               <props>
                   <prop key="hibernate.username">root</prop>
                   <prop key="hibernate.password">1234</prop>
               </props>
           </property>
   </bean>

测试

      package com.itzhouq.test;
      
      import org.junit.Test;
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      import com.itzhouq.domain.CollBean;
      
      public class CollBeanTest {
          @Test
          public void test() {ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
              CollBean cb = (CollBean) context.getBean("collBean");
              System.out.println(cb);
              /*
               * CollBean [ss=[aaa, bbb, ccc], 
               * ll=[111, 222, CarImpl [name=BMW, price=1000000.0]],
               *  mm={k1=AAA, k2=BBB, k3=CarImpl [name=BMW, price=1000000.0]}, 
               *  properties={hibernate.password=1234, hibernate.username=root}]
               */
          }
      }

需求分析：从 service 层调用 dao 层，将数据存储到数据库，存储数据的过程使用 syso 模拟一下就可以。
创建工程，导入需要的 jar 包，建包如下：

创建 dao 层和 dao 实现层

package com.itzhouq.dao;

public interface UserDao {void save();
}

package com.itzhouq.daoImpl;

import com.itzhouq.dao.UserDao;

public class UserDaoImpl implements UserDao{

    @Override
    public void save() {System.out.println("操作数据库，保存用户的数据");    
    }
}

创建 Service 层和实现层

package com.itzhouq.service;

public interface UserService {public void save();
}

package com.itzhouq.serviceImpl;

import com.itzhouq.dao.UserDao;
import com.itzhouq.daoImpl.UserDaoImpl;
import com.itzhouq.service.UserService;

public class UserServiceImpl implements UserService {
    private String name;
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {this.userDao = userDao;}
    public void setName(String name) {this.name = name;}

    @Override
    public void save() {System.out.println(name);
        // 调用 dao
        userDao.save();}
}

给 UserDaoImpl 一个 UserDao 属性

配置文件

<?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">
    <!-- 创建 dao -->
    <bean id="userDao" class="com.itzhouq.daoImpl.UserDaoImpl"></bean>
    
    <!-- 创建 service -->
    <bean id="UserService" class="com.itzhouq.serviceImpl.UserServiceImpl">
        <property name="name" value="要开始访问 dao 了"></property>
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

测试

@Test    // 使用 Spring 的 IOC+DI 来实现对象的创建和赋值
    public void test() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("UserService");
        userService.save();
        // 要开始访问 dao 了
        // 操作数据库，保存用户的数据
    }

1.Spring 介绍

1.1 Spring 概述

1.2 Spring 好处

1.3 Spring 结构体系

1.4 在项目中的架构

1.5 程序的耦合和解耦

2. Spring 快速入门

2.1 编写流程

2.2 下载地址

2.3 Spring 的核心 jar 包

2.4 Spring 入门案例

3. Spring 基于 XML 的 IOC 细节

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

3.1.1 配置文件 bean 标签

3.1.2 scope 属性：范围（重点）

3.1.3 bean 的作用范围和生命周期

3.1.4 示例化 Bean 的三种方式

3.2 加载 Spring 容器的三种方式

3.3 BeanFactory 和 ApplicationContext 对比

3. 4 Spring 的依赖注入 DI

3.4.1 构造器注入方式

3.4.2 set 方式注入

3.4.3 使用 p 名称空间注入数据 (知道就 OK)

3.4.4 注入集合属性

4. 使用案例

Just My Socks（注册教程内含优惠码）

Spring笔记01下载概述监听器

1.Spring 介绍

1.1 Spring 概述

1.2 Spring 好处

1.3 Spring 结构体系

1.4 在项目中的架构

1.5 程序的耦合和解耦

2. Spring 快速入门

2.1 编写流程

2.2 下载地址

2.3 Spring 的核心 jar 包

2.4 Spring 入门案例

3. Spring 基于 XML 的 IOC 细节

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

3.1.1 配置文件 bean 标签

3.1.2 scope 属性：范围（重点）

3.1.3 bean 的作用范围和生命周期

3.1.4 示例化 Bean 的三种方式

3.2 加载 Spring 容器的三种方式

3.3 BeanFactory 和 ApplicationContext 对比

3. 4 Spring 的依赖注入 DI

3.4.1 构造器注入方式

3.4.2 set 方式注入

3.4.3 使用 p 名称空间注入数据 (知道就 OK)

3.4.4 注入集合属性

4. 使用案例

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）