今天开始Spring框架的学习，主要内容为Spring框架的简介、快速入门、配置文件以及API

Spring 框架简介

一、Spring的基本概念

Spring是分层的Java SE/EE应用 full-stack 轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

二、Spring的优势

1、方便解耦，简化开发

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

2、AOP编程的支持

通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。值得注意的是AOP是一种思想。只不过是Spring将这种思想实现了。

3、声明式事务支持

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

4、方便程序的测试

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

5、方便集成各种优秀框架

Spring对各种优秀框架（Struts、Hibemate、Hessian、Quartz等）的支持。

6、降低JavaEE API的使用难度

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

7、Java源码是经典学习范例

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

三、AOP（面向切面编程）与OOP（面向对象编程）的区别

以下内容摘自百度百科。

1、区分

AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。

而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。

上面的陈述可能过于理论化，举个简单的例子，对于“雇员”这样一个业务实体进行封装，自然是OOP/OOD的任务，我们可以为其建立一个“Employee”类，并将“雇员”相关的属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。

同样，对于“权限检查”这一动作片断进行划分，则是AOP的目标领域。而通过OOD/OOP对一个动作进行封装，则有点不伦不类。

换而言之，OOD/OOP面向名词领域，AOP面向动词领域。

2、关系

很多人在初次接触 AOP 的时候可能会说，AOP 能做到的，一个定义良好的 OOP 的接口也一样能够做到，我想这个观点是值得商榷的。AOP和定义良好的 OOP 的接口可以说都是用来解决并且实现需求中的横切问题的方法。但是对于 OOP 中的接口来说，它仍然需要我们在相应的模块中去调用该接口中相关的方法，这是 OOP 所无法避免的，并且一旦接口不得不进行修改的时候，所有事情会变得一团糟；AOP 则不会这样，你只需要修改相应的 Aspect，再重新编织（weave）即可。当然，AOP 也绝对不会代替 OOP。核心的需求仍然会由 OOP 来加以实现，而 AOP 将会和 OOP 整合起来，以此之长，补彼之短。

四、Spring的体系结构

Test层：可以对上面的所有内容进行测试。

Core Container层：核心容器，上层的功能如果要运行必须要借助核心容器。

Beans：用于产生Bean对象的容器
Core：核心
Context：Spring的上下文
SpEL：Spring的表达式

Data Access/Integeation：数据访问层

Web：页面

Spring 程序开发入门

一、Spring程序开发步骤

1、Spring开发步骤图示

图解说明：

第一步：通过Dao层配置xml文件，在内部编写Bean的id标识。
第二步：service层通过Spring客户端.getBean(id标识)中的id标识向Spring框架申请Bean的对象。
第三步：Spring读取解析xml文件中的配置
第四步：根据从Service层传来的id标识搜索全限定类名路径，然后根据反射创建申请的Bean对象。
第五步：将根据反射创建的Bean对象返回给Service层。

2、Spring开发步骤

（1）导入Spring开发的基本包坐标

（2）编写Dao接口和实体类

（3）创建Spring核心配置文件

（4）在Spring配置文件中配置UserDaoImpl

（5）使用Spring的API获得Bean实例

二、代码实现

1、导入Spring开发的基本包坐标

<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.7.RELEASE</version>
  </dependency>
</dependencies>

2、编写Dao接口和实现类

//Dao接口
public interface UserDao {
    void save();
}

//实现类
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("Spring 学习");
    }
}

3、创建Spring核心配置文件

<!-- 在resources文件下新建一个Spring Config文件 -->
<?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接口中的id标识 -->
    <bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl"/>

</beans>

4、使用Spring的API获得Bean实例

package com.itheima;

import com.itheima.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoTest {
    public static void main(String[] args) {
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        //测试是否为相应的对象
        userDao.save();//运行结果：Spring 学习
    }
}

Spring 配置文件

一、Bean标签的基本配置

1、作用

用于配置对象交由Spring来创建

默认情况下他调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功

2、基本属性

id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名称

3、范围配置

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的，容器中只有一个对象，每次取出的是同一个对象
prototype	多例的，容器中存在多个对象每次取出的不是同一个对象
request	WEB项目中，Spring创建一个Bean对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

注意事项：singleton和prototype在创建对象的时机是不一样的

singleton：
- Bean实例化个数：1个
- Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
- Bean的生命周期：
  - 对象创建：当应用加载，创建容器时，对象就被创建了
  - 对象运行：只要容器在，对象一直活着
  - 对象销毁：当应用卸载，销毁容器时，对象就被销毁了
prototype：
- Bean实例化个数：多个
- Bean的实例化时机：当调用getBean()方法时实例化Bean
- Bean的生命周期：
  - 对象创建：当使用对象时，创建新的对象实例
  - 对象运行：只要对象在使用中，就一直活着
  - 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了

4、代码演示

//<bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl" scope="singleton"/>
    /**
     * 测试scope属性[value = singleton]
     * 默认值，单例的
     */
    @Test
    public void saveTest1(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);//com.itheima.dao.Impl.UserDaoImpl@4232c52b
        System.out.println(userDao2);//com.itheima.dao.Impl.UserDaoImpl@4232c52b
    }



//<bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl" scope="prototype"/>
	/**
     * 测试scope属性[value = prototype]
     * 多例的
     */
    @Test
    public void saveTest2(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);//com.itheima.dao.Impl.UserDaoImpl@536aaa8d
        System.out.println(userDao2);//com.itheima.dao.Impl.UserDaoImpl@e320068
    }

5、生命周期配置

属性：

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

代码演示：

//先在UserDaoImpl类中新建如下方法
    public UserDaoImpl() {
        System.out.println("UserDaoImpl被创建了...");
    }

    public void init(){
        System.out.println("初始化了...");
    }

    public void destroy(){
        System.out.println("销毁了...");
    }

//再修改Spring框架的核心配置文件如下，值得注意的是此时scope的值为默认值singleton
//<bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl" init-method="init" destroy-method="destroy"/>

//再编写测试方法
    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
        //此处为手动关闭容器，否则无法看见销毁方法被调用执行的结果
        ((ClassPathXmlApplicationContext) app).close();
    }

//运行结果为：
/*
	UserDaoImpl被创建了...
	初始化了...
	com.itheima.dao.Impl.UserDaoImpl@458c1321
	销毁了...
*/

6、Bean实例化的三种方式

（1）分类

无参构造方法实例化
工厂静态方法实例化
工厂实例方法实例化

（2）工厂静态方法实例化演示

①先创建一个Factory包在java目录下，并创建一个静态工厂类

package com.itheima.factory;

import com.itheima.dao.Impl.UserDaoImpl;
import com.itheima.dao.UserDao;

public class StaticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

②修改Spring的核心配置文件

1 2	<!-- 静态工厂创建Bean对象 --> <bean id="userDao" class="com.itheima.factory.StaticFactory" factory-method="getUserDao"/>

③编写测试类

    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }

/*运行结果：
	UserDaoImpl被创建了...
	com.itheima.dao.Impl.UserDaoImpl@2f943d71
*/

（3）工厂实例方法实例化演示

①同上创建一个动态的工厂类

package com.itheima.factory;

import com.itheima.dao.Impl.UserDaoImpl;
import com.itheima.dao.UserDao;

public class DynamicFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

②修改Spring的核心配置文件

<!-- 动态工厂创建Bean对象 -->
<!-- 先创建动态工厂的对象，在通过工厂对象创建UserDao对象 -->
<bean id="factory" class="com.itheima.factory.DynamicFactory"/>
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"/>

③编写测试类

    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
    }

/*运行结果：
	UserDaoImpl被创建了...
	com.itheima.dao.Impl.UserDaoImpl@2f943d71
*/

7、依赖注入

（1）分析

每次在使用Service时需要从Spring容器中获取Dao实例，能不能将Dao实例和Service实例融合在一起，使Service在创建时，Dao也一起被创建。

（2）概念

依赖注入（Dependency Injection）：它是Spring框架核心IOC的体现。

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍然会调用持久层的方法。

这种业务层和持久层的依赖关系，在使用Spring之后就由Spring来维护了。简单地说，就是等框架把持久层传入业务层，而不用我们自己去获取了。

（3）方式

分类：

构造方法（有参构造方法）
set方法

① set方法演示：

①创建一个Service包并创建接口和实现类

//接口
public interface UserService {
    void save();
}

//实现类
public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

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

    @Override
    public void save() {
        System.out.println("UserServiceIml被创建了...");
        getUserDao();
    }
}

②修改Spring的核心配置文件

<bean id="userService" class="com.itheima.service.Impl.UserServiceImpl">
    <!-- 将UserDao依赖注入 -->
    <property name="userDao" ref="userDao"/>
</bean>

③编写测试类

    @Test
    public void webTest(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }

/* 运行结果
	UserDaoImpl被创建了...
	UserServiceIml被创建了...
*/

注意事项：只有当service对象是通过容器获取的时，才会创建dao的对象。

② set依赖注入的简便方式

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加简便，主要体现在配置文件中，如下：

首先引入P命名空间

1	xmlns:p="http://www.springframework.org/schema/p"

在上述的位置添加完命名空间之后，再修改注入方式即可，注入如下：

1	<bean id="userService" class="com.itheima.service.Impl.UserServiceImpl" p:userDao-ref="userDao"/>

③ 有参构造方法演示

①在service实体类内部创建无参构造和有参构造

public UserServiceImpl() {
}

public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}

②修改Spring的核心配置文件

<bean id="userService" class="com.itheima.service.Impl.UserServiceImpl">
    <!-- name：实体类中的变量  ref：引用的bean标签id -->
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

③编写测试类

    @Test
    public void webTest(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }

/* 运行结果
	UserDaoImpl被创建了...
	UserServiceIml被创建了...
*/

（4）数据类型

上面的操作都是通过bean标签注入了对象，而除了对象也可以注入普通数据类型、集合等。

分类：

普通数据类型；
引用数据类型；
集合数据类型。

普通数据类型演示：

①在dao实体类内部创建两个基本数据类型的变量并创建set方法

private String username;
private int age;

public void setUsername(String username) {
    this.username = username;
}

public void setAge(int age) {
    this.age = age;
}

②修改Spring的核心配置文件

<!-- 配置Dao接口中的id标识 -->
<bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl">
    <property name="username" value="zhangsan"/>
    <property name="age" value="20"/>
</bean>

③编写测试类

    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }
/*
	运行结果:
	zhangsan --- 20
	save...
*/

集合数据类型演示：

①在dao实体类内部创建集合数据类型的变量并创建set方法

    private List<String> stringList;
    private Map<String, User> map;
    private Properties properties;

    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    public void setMap(Map<String, User> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

//创建一个User对象，内部属性为
    private String username;
    private int age;

②修改Spring的核心配置文件

   <bean id="userDao" class="com.itheima.dao.Impl.UserDaoImpl">
       <property name="stringList">
           <list>
               <value>aaa</value>
               <value>bbb</value>
               <value>ccc</value>
               <value>ddd</value>
           </list>
       </property>
       <property name="map">
           <map>
               <entry key="u1" value-ref="user1"/>
               <entry key="u2" value-ref="user2"/>
           </map>
       </property>
       <property name="properties">
           <props>
               <prop key="p1">ppp1</prop>
               <prop key="p2">ppp2</prop>
               <prop key="p3">ppp3</prop>
           </props>
       </property>
   </bean>

<!-- 创建User对象 -->	
   <bean id="user1" class="com.itheima.domain.User">
       <property name="username" value="张三"/>
       <property name="age" value="20"/>
   </bean>
   <bean id="user2" class="com.itheima.domain.User">
       <property name="username" value="李四"/>
       <property name="age" value="18"/>
   </bean>

③编写测试类

    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }

/*
	运行结果：
	[aaa, bbb, ccc, ddd]
	{u1=User{username='张三', age=20}, u2=User{username='李四', age=18}}
	{p3=ppp3, p2=ppp2, p1=ppp1}
	save...
*/

8、总结

<bean>
       id属性：在容器中Bean标签的唯一标识，不允许重复
       class属性：要实例化的Bean的全限定名
       scope属性：Bean的作用范围，常用的是Singleton（默认）和prototype
       <property>标签：属性注入
           name属性：属性名称（在实体类中的变量名）
           value属性：注入的普通属性值
           ref属性：注入的对象引用值
           <list>标签
           <map>标签
           <properties>标签
       <constructor-arg>标签：构造方法形式
   <import>标签：导入其他的Spring分文件

二、引入其他配置文件（分模块开发）

实际开发过程中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积庞大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

1	<import reosurce="applicationContext-xxx.xml"/>

Spring 相关API

一、ApplicationContext继承体系

ApplicationContext：接口类型，代表应用上下文，可以通过实例获得Spring容器中的Bean对象。

ApplicationContext的实现类：

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

二、getBean()方法使用

1、源码分析

   //方式一：传入配置id的值
public Object getBean(String name) throws BeansException {
       this.assertBeanFactoryActive();
       return this.getBeanFactory().getBean(name);
   }

//方式二：传入配置实体类的class
   public <T> T getBean(Class<T> requiredType) throws BeansException {
       this.assertBeanFactoryActive();
       return this.getBeanFactory().getBean(requiredType);
   }

2、测试代码

    @Test
    public void saveTest(){
        //读取xml配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //相当于service层通过id标识申请Spring框架创建Bean对象
//        UserDao userDao = (UserDao) app.getBean("userDao");
        UserDao userDao = app.getBean(UserDao.class);
        userDao.save();
    }

/*
	运行结果：
	[aaa, bbb, ccc, ddd]
	{u1=User{username='张三', age=20}, u2=User{username='李四', age=18}}
	{p3=ppp3, p2=ppp2, p1=ppp1}
	save...
*/

注意事项：当配置文件中有多个UserDao实体类配置时不可以使用这种方式创建对象，不然会报错。当存在多个相同实体类的配置对象时，使用第一种方式最好。

参考资料：2020年最新版传智黑马Java SSM 阶段采用IDEA教学

Spring框架学习（一）(Spring框架的简介、快速入门、配置文件以及API)

Spring 框架简介

一、Spring的基本概念

二、Spring的优势

1、方便解耦，简化开发

2、AOP编程的支持

3、声明式事务支持

4、方便程序的测试

5、方便集成各种优秀框架

6、降低JavaEE API的使用难度

7、Java源码是经典学习范例

三、AOP（面向切面编程）与OOP（面向对象编程）的区别

1、区分

2、关系

四、Spring的体系结构

Spring 程序开发入门

一、Spring程序开发步骤

1、Spring开发步骤图示

2、Spring开发步骤

二、代码实现

1、导入Spring开发的基本包坐标

2、编写Dao接口和实现类

3、创建Spring核心配置文件

4、使用Spring的API获得Bean实例

Spring 配置文件

一、Bean标签的基本配置

1、作用

2、基本属性

3、范围配置

4、代码演示

5、生命周期配置

6、Bean实例化的三种方式

（1）分类

（2）工厂静态方法实例化演示

（3）工厂实例方法实例化演示

7、依赖注入

（1）分析

（2）概念

（3）方式

① set方法演示：

② set依赖注入的简便方式

③ 有参构造方法演示

（4）数据类型

8、总结

二、引入其他配置文件（分模块开发）

Spring 相关API

一、ApplicationContext继承体系

二、getBean()方法使用

1、源码分析

2、测试代码