1、Spring

1.1、简介

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由 EJB 完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

• 目的：解决企业应用开发的复杂性
• 功能：使用基本的 JavaBean 代替 EJB，并提供了更多的企业应用功能
• 范围：任何 Java 应用

Spring是一个轻量级控制反转（IOC）和面向切面（AOP）的容器框架

• Spring：春天 —> 给软件行业带来了春天
• 2002，首次推出了 Spring 框架的雏形：interface21 框架！
• Spring框架以 interface21 框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版。
• 创始人：Rod Johnson
• Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

• SSH： Struct2 + Spring + Hibernate
• SSM： SpringMVC + Spring + Mybatis

官网：https://spring.io/projects/spring-framework#overview
官方下载地址：http://repo.spring.io/release/org/springframework/spring
Github：https://github.com/spring-projects/spring-framework

导包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<!------------Spring与Mybatis整合需要下面这个包------------------>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.15</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.15</version>
</dependency>

1.2、优点

• Spring是一个开源的免费的容器（框架）！
• Spring是一个轻量级的、非入侵式的框架！
• 控制反转（IOC）、面向切面编程（AOP） ——-> 面试必问
• 支持事务的处理，对框架整合的支持！

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程的框架（AOP）！

1.3、组成

1.4、拓展

在Spring的官网有这个介绍：现代化的Java开发，就是基于Spring的开发

• Spring Boot
  • 一个快速开发的脚手架
  • 基于SpringBoot可以快速的开发单个微服务
  • 约定大于配置
• Spring Cloud
  • SpringCloud是基于SpringBoot实现的

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

Spring的弊端：发展太久之后，违背了原来的理念。配置十分繁琐。

2、IOC理论推导

2.1、推导

原来：

1. UserDao接口
2. UserDaoImpl 接口实现类
3. UserService 业务接口
4. User ServiceImpl 业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分庞大，修改一次的成本代价太高！

我们使用一个set接口，进行动态值的注入

private UserDao userDao;

// 利用set进行动态值的注入！
public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

• 之前，程序是主动创建对象！控制权在程序员手里
• 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象，控制权移交到了用户手里

具体源码见：D:\IntelliJ IDEA workSpace\Maven\javaEE\spring-study\spring01-ioc1

这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上。 这是 IOC 的原型！

2.2、IOC本质

控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。

3、HelloSpring

pojo类：Hello

package com.jungle.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

XML文件配置：applicationContext.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 使用Spring来创建对象，在Spring中这些对象都被叫做Bean
        之前：
            类型  变量名 = new 类型();
            Hello hell = new Hello();
        现在：
            id = 变量名
            class = new 的对象
            property 相当于给对象中的属性设置一个值
    -->
    <bean id="hello" class="com.jungle.pojo.Hello">
        <property name="str" value="HelloSpring"/>
    </bean>

</beans>

测试类：MyTest

import com.jungle.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        // 获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 我们的对象现在都在Spring中管理了，需要使用直接去容器中拿出来
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

此外，对D:\IntelliJ IDEA workSpace\Maven\javaEE\spring-study\spring01-ioc1的例子也用Spring装配重新做了一遍

思考问题？

• Hello 对象是谁创建的？
  • hello对象是由Spring创建的
• Hello 对象的属性是怎么设置的？
  • hello对象的属性是由Spring容器设置的

这个过程就叫做控制反转：

• 控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
• 反转：程序本身不创建对象，而变成被动的接收对象。
• 依赖注入：就是利用set方法来进行注入的

IoC是一种编程思想，由主动的编程变成被动的接收，可以通过new ClassPathXmlApplicationContext()去浏览一下低层源码。
OK，到了现在，我们彻底不用在程序中改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IoC，一句话总结就是：对象由Spring来创建，管理，装配！

4、IoC创建对象的方式

1. 使用无参构造创建对象，默认的！ ```java import com.jungle.pojo.User; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest { @Test public void testSpring(){ // User user1 = new User(); ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”); User user = (User) context.getBean(“user”); user.show(); } }

使用new或者是通过context.getBean的方式，都一样会走实体类的默认构造函数（如果没有显示构造器的话），**说明Java Bean的本质和new是一样的，只不过Bean是被封装好的，更加简便的用法。**

2. 假设我们要使用有参构造创建对象，怎么办？
   1. 下标赋值
```xml
<!--第一种，下标赋值-->
<bean id="user1" class="com.jungle.pojo.User">
  <constructor-arg index="0" value="Jungle1"/>
</bean>

1. 类型注入（不建议使用）

   <!--第二种，通过类型创建,必须是全限定名（不建议使用）-->
   <bean id="user2" class="com.jungle.pojo.User">
   <constructor-arg type="java.lang.String" value="Jungle2"/>
   </bean>
   

2. 参数名设置

   <!--第三种，直接通过参数名来设置-->
   <bean id="user3" class="com.jungle.pojo.User">
   <constructor-arg name="name" value="Jungle3"/>
   </bean>
   

   总结：在配置文件加载的时候，容器中管理的对象就已经被初始化了！

5、Spring配置

5.1、别名

<!--别名。如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>

5.2、Bean的配置

<!--
    id: bean的唯一标识符，也就是相当于我们学的对象名
    class：bean对象所对应的类型的全限定名：包名 + 类型
    name：也是别名，而且name可以取多个别名（逗号、分号、空格都可以分割）
-->
<bean id="userTwo" class="com.kuang.pojo.UserTwo" name="user2,u2">
      <property name="name" value="Jungle"/>
</bean>

5.3、import

这个import一般用于团队开发使用，它可以将多个配置文件导入合并为一个
例如：现在项目中由多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

• 张三
• 李四
• 王五
• applicationContext.XML

  <import resource="bean1.xml"/>
  <import resource="bean2.xml"/>
  <import resource="bean3.xml"/>
  

  使用的时候，直接使用总的配置就可以了

6、依赖注入DI

DI：Dependency Injection

6.1、构造器注入

前面已经讲过了

6.2、Set方式注入（终点）

• 依赖注入：Set注入！
  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入！

【环境搭建】

1. 复杂类型 ```java package com.jungle.pojo;

public class Address { private String address; }

2. 真实测试对象
```java
package com.jungle.pojo;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

1. applicationContext.xml

   <?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
   
    <bean id="address" class="com.jungle.pojo.Address">
        <property name="address" value="广技师"/>
    </bean>
   
    <bean id="student" class="com.jungle.pojo.Student">
        <!--第一种，普通值注入，用value就可以了-->
        <property name="name" value="Jungle"/>
        <!--第二种，Bean注入，使用ref-->
        <property name="address" ref="address"/>
        <!--第三种，数组注入-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--第四种，list注入-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
        <!--第五种，map注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="111111222222223333"/>
                <entry key="学生证" value="201903424xxxx"/>
            </map>
        </property>
        <!--第六种，set注入-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>PUBG</value>
                <value>apex</value>
            </set>
        </property>
        <!--第七种，null注入-->
        <property name="wife">
            <null></null>
        </property>
        <!--第八种，properties注入-->
        <property name="info">
            <props>
                <prop key="birth">1999.06.14</prop>
                <prop key="sex">man</prop>
                <prop key="home">GD</prop>
            </props>
        </property>
    </bean>
   </beans>
   

2. MyTest.java ```java import com.jungle.pojo.Student; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”); Student student = (Student) context.getBean(“student”); System.out.println(student.toString()); } }

运行结果：<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/21723656/1645779256627-8a177dcf-0c21-45b1-9eb9-5fe27262479e.png#clientId=u7846052a-18e0-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=294&id=u710bb909&margin=%5Bobject%20Object%5D&name=image.png&originHeight=294&originWidth=670&originalType=binary&ratio=1&rotation=0&showTitle=false&size=24077&status=done&style=none&taskId=u51622c91-1961-4bd2-8005-45e9f824110&title=&width=670)

<a name="sM7p2"></a>
## 6.3、拓展方式注入

我们可以使用p命名空间和c命名空间进行注入！

使用<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/21723656/1645807724264-a9c63ad0-3c13-4e20-bf67-c7dfc20be600.png#clientId=u5feb093f-876a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=616&id=uce9ed4b3&margin=%5Bobject%20Object%5D&name=image.png&originHeight=616&originWidth=1040&originalType=binary&ratio=1&rotation=0&showTitle=false&size=494090&status=done&style=none&taskId=ub3692a66-5868-4389-81d4-87f20d01ef2&title=&width=1040)

测试<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/21723656/1645807744543-b1b637db-2274-4dee-ad8e-37053828738f.png#clientId=u5feb093f-876a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=227&id=u96b9914b&margin=%5Bobject%20Object%5D&name=image.png&originHeight=227&originWidth=1155&originalType=binary&ratio=1&rotation=0&showTitle=false&size=146521&status=done&style=none&taskId=ub7330c2b-3b42-4599-95ed-fe0f87087db&title=&width=1155)

注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束！<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/21723656/1645807777305-b2750640-ea53-427a-8989-d4e23865a0d7.png#clientId=u5feb093f-876a-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=93&id=u410eef6a&margin=%5Bobject%20Object%5D&name=image.png&originHeight=93&originWidth=772&originalType=binary&ratio=1&rotation=0&showTitle=false&size=64823&status=done&style=none&taskId=ub76b54f2-d20e-41da-a30a-4e9607e9681&title=&width=772)


<a name="KSPAE"></a>
# 6.4、Bean的作用域
| **Scope** | **Description** |
| --- | --- |
| [singleton](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-singleton) | (Default) Scopes a single bean definition to a single object instance for each Spring IoC container. |
| [prototype](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-prototype) | Scopes a single bean definition to any number of object instances. |
| [request](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-request) | Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring .ApplicationContext |
| [session](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-session) | Scopes a single bean definition to the lifecycle of an HTTP . Only valid in the context of a web-aware Spring .SessionApplicationContext |
| [application](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-application) | Scopes a single bean definition to the lifecycle of a . Only valid in the context of a web-aware Spring .ServletContextApplicationContext |
| [websocket](https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#websocket-stomp-websocket-scope) | Scopes a single bean definition to the lifecycle of a . Only valid in the context of a web-aware Spring .WebSocketApplicationContext |


1. 单例模式（Spring默认机制）
```xml
<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" scope="singleton"/>

1. 原型模式：每次从容器中get的时候，都会产生一个新对象

   <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="狂神" scope="prototype"/>
   

2. 其余的request、session、application……这些只能在web开发中使用

7、Bean的自动装配

• 自动装配是Spring满足bean依赖的一种方式！
• Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配的方式

1. 在xml中显示的配置
2. 在java中显示配置
3. 隐式的自动装配bean【重要】

7.1、测试

1. 环境搭建
   1. 一个人有狗和猫两只宠物！

7.2、自动装配

自动装配的关键字：autowire

1. 通过名称自动装配

   <bean id="cat" class="com.jungle.pojo.Cat"/>
    <bean id="dog" class="com.jungle.pojo.Dog"/>
   
    <!--byName: 会自动在容器上下文中查找和自己对象set方法后面的值对应的bean id
    -->
    <bean id="people" class="com.jungle.pojo.People" autowire="byName">
        <property name="name" value="Jungle"/>
   <!--        <property name="cat" ref="cat"/>-->
   <!--        <property name="dog" ref="dog"/>-->
    </bean>
   

2. 通过类型自动装配 ```xml

<!--SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--绑定mybatis配置文件(可以不写)-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <!--注册Mapper.xml文件-->
    <property name="mapperLocations" value="classpath:com/jungle/dao/*.xml"/>
</bean>

<!--SqlSessionTemplate: 全面取代之前在Mybatis中使用的sqlSession-->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

4. applicationContext.xml 配置文件（团队开发）
```xml
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="spring-dao.xml"/>

    <!--Spring绑定实现类-->
    <bean id="userMapperImpl" class="com.jungle.dao.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
    </bean>

</beans>

Spring整合Mybatis会多出一个接口的实现类，因为Spring去接管对象会自动创建，而Mybatis无法自动创建，所以我们常常会把这一块功能在测试类上做，或者抽象成一个复用类，然后在测试类中直接调用，而Spring这个实现类做的工作就相当于这个复用类的工作。<br />只不过，我们用一个set方法（因为Spring去接管对象会自动创建）来替代原来的一系列复杂的代码。


还可以使用 SelSessionDaoSupport

实现类        UserMapperImpl2
```java
package com.jungle.dao;

import com.jungle.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="spring-dao.xml"/>

    <!--Spring绑定实现类,实现Spring注入-->
    <bean id="userMapperImpl" class="com.jungle.dao.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
    </bean>

    <bean id="userMapperImpl2" class="com.jungle.dao.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <constructor-arg ref="dataSource"/>
</bean>

<!--结合AOP实现事务的织入-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <!--给mapper方法配置事务,name是方法名，*代表全部-->
  <!--配置事务的传播特性：propagation-->
  <tx:attributes>
    <tx:method name="add" propagation="REQUIRED"/>
    <tx:method name="update" propagation="REQUIRED"/>
    <tx:method name="delete" propagation="REQUIRED"/>
    <tx:method name="*" propagation="REQUIRED"/>
  </tx:attributes>
</tx:advice>

<!--配置事务切入-->
<aop:config>
  <aop:pointcut id="txPointCut" expression="execution(* com.jungle.dao.*.*(..))"/>
  <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>