07JavaEE第七章spring

Spring 是什么?

Spring 是于 2003 年兴起的一个轻量级的,IOC 和 AOP 的 Java 开发框架，它是为了简化企业级应用开发而生的。

Spring 优点

轻量级的

Spring 框架使用的 jar 都比较小，一般在 1M 以下或者几百 kb。Spring 核心功能的所需的 jar 总共在 3M 左右。 Spring 框架运行占用的资源少，运行效率高。

非侵入式

编写一些业务类的时候不需要继承 spring 特定的类，通过配置完成依赖注入后就可以使用，此时，spring 就没有侵入到我业务类的代码里.

IOC

即 Inversion of Control，缩写为 IOC，就是由 Spring IoC 容器管理对象，而非传统实现中由程序代码直接操控.

AOP

通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

一站式框架

Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架。

Spring体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mlZMdOL0-1647175543431)(C:\Users\褚哲希\AppData\Roaming\Typora\typora-user-images\1646736349497.png)]

Core Container(核心容器):

• Beans: 管理 Beans

• Core: Spring 核心

• Context: 配置文件

• ExpressionLanguage: SpEL 表达式

AOP(切面编程)

AOP 框架: Aspects

Data Access(数据库整合): JDBC, ORM, OXM, JMS, Transaction

Web(MVC Web 开发): Web, Servlet, Portlet, Struts

Test(Junit 整合)

官网地址:https://spring.io/

Spring Hello World 搭建

导入jar

开发类

编写配置文件（配置需要spring管理的类）

• 容器实现类ClassPathXmlApplicationContext(“spring.xml”) 读取spring文件

  getBean（“对象名”）

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ffyc</groupId>
    <artifactId>SpringPro</artifactId>
    <version>1.0</version>
    <name>SpringPro</name>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
        <junit.version>5.6.2</junit.version>
    </properties>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.0</version>
            </plugin>
        </plugins>
    </build>
</project>

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

    <!--
    配置spring要管理的对象，spring框架管理生成的对象我们成为一个bean
    id 对象名
    class 管理的类名
    -->
    <bean id="user" class="com.ffyc.spring.model.User"></bean>
</beans>

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
   
    public static void main(String[] args) {
   
        /*
         启动spring框架,读取配置文件
         IOC 控制反转 是spring的核心功能
             控制反转 将生成对象的权利 反转给spring框架，由spring框架一同管理
        */
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml"); //spring容器
        User user = app.getBean("user",User.class);
        System.out.println(user);
    }
}

IOC(控制反转)

​ 控制反转

​ 以前是正控，在哪用，在哪new

​ 现在是反控同一交给spring，交给spring管理的对象，spring在创建时，就可以为我们的对象添加额外的功能。

读作**“反转控制”(Inverse of Control)更好理解，不是什么技术，而是一种设计思想，就是**将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对 象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。

正控：若要使用某个对象，需要自己去负责对象的创建

反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，

不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架.

**目的:**降低耦合度

底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机制

Spring Bean 管理

基于 xml 配置方式

bean 配置需要 spring 管理的类id 生成的对象名

class 全类名

name 对象别名,可以为多个

<?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要管理的对象，spring框架管理生成的对象我们成为一个bean
    id 对象名
    class 管理的类名
    name 定义对象名，定义多个
    -->
    <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User"></bean>
</beans>

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
   
    public static void main(String[] args) {
   
        /*
         启动spring框架,读取配置文件
         IOC 控制反转 是spring的核心功能
             控制反转 将生成对象的权利 反转给spring框架，由spring框架一同管理
        */
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml"); 
        User user = app.getBean("user1",User.class);
//        User user = app.getBean("user1",User.class);
        System.out.println(user);
    }
}

scope:

• singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式。

  <?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要管理的对象，spring框架管理生成的对象我们成为一个bean
      id 对象名
      class 管理的类名
      name 定义对象名，定义多个
      scope="singleton" 默认值 对象作用域
            singleton：单例的，只会创建一个对象 在spring框架启动时，就会创建对象
      -->
      <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User" scope="singleton"></bean>
  </beans>
  

  public class Test1 {
       
      public static void main(String[] args) {
       
          ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
          User user = app.getBean("user",User.class);
          System.out.println(user); //com.ffyc.spring.model.User@1794d431
          User user1 = app.getBean("user",User.class);
          System.out.println(user1); //com.ffyc.spring.model.User@1794d431
          //说明创建的是一个对象
      }
  }
  

• prototype:原型 getBean()的时候都会 new Bean()

  <?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要管理的对象，spring框架管理生成的对象我们成为一个bean
      id 对象名
      class 管理的类名
      name 定义对象名，定义多个
      scope="singleton" 默认值 对象作用域
            singleton：单例的，只会创建一个对象 在spring框架启动时，就会创建对象
      prototype：原型的 多例的 每次获取时，都会创建一个新的对象
      request：每次http请求创建一个
      session：每次会话创建一个
  -->
      <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User" scope="prototype"></bean>
  </beans>
  

  package com.ffyc.spring.test;
  
  import com.ffyc.spring.model.User;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class Test1 {
       
      public static void main(String[] args) {
       
          ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
          User user = app.getBean("user",User.class);
          System.out.println(user); //com.ffyc.spring.model.User@604ed9f0
          User user1 = app.getBean("user",User.class);
          System.out.println(user1); //com.ffyc.spring.model.User@6a4f787b
          //创建两次对象
      }
  }
  

• request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext环境

session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上

Xml 配置方式依赖注入【DI：Dependency Injection】

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设置给该对象。

实现 IOC 需要 DI 做支持

注入的方式：

• 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"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      <!--
        依赖注入：就是在spring创建对象的同时，为对象中的属性赋值
        注入方式：
           set方法注入（常用）
           构造方法注入
      -->
      <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User" scope="prototype">
          <!--set方法注入 无参构造方法-->
          <property name="num" value="100"></property>
          <property name="name" value="jim"></property>
      </bean>
  </beans>
  

  public class UserService {
       
      UserDao userDao; //注入
      public void save(){
       
         userDao.save();
      }
  }
  

  public class User {
       
      private int num;
      private String name;
  
      public User() {
       
          System.out.println("User无参构造方法");
      }
  
      public User(int num, String name) {
       
          System.out.println("User有参构造方法");
          this.num = num;
          this.name = name;
      }
  
      public int getNum() {
       
          return num;
      }
  
      public void setNum(int num) {
       
          this.num = num;
      }
  
      public String getName() {
       
          return name;
      }
  
      public void setName(String name) {
       
          this.name = name;
      }
  
      @Override
      public String toString() {
       
          return "User{" +
                  "num=" + num +
                  ", name='" + name + '\'' +
                  '}';
      }
  }
  

• 构造方法注入

  <?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创建对象的同时，为对象中的属性赋值
        注入方式：
           set方法注入（常用）
           构造方法注入
      -->
      <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User" scope="prototype">
          <!--构造方法注入 调用有参的构造方法-->
          <constructor-arg name="num" value="101"></constructor-arg>
          <constructor-arg name="name" value="jim"></constructor-arg>
      </bean>
  </beans>
  

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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
      依赖注入：就是在spring创建对象的同时，为对象中的属性赋值
      注入方式：
         set方法注入（常用）
         构造方法注入
    -->
    <bean id="user" name="user1,user2" class="com.ffyc.spring.model.User" scope="prototype">
        <!--set方法注入-->
        <!--<property name="num" value="100"></property>
        <property name="name" value="jim"></property>-->
        <!--构造方法注入-->
        <constructor-arg name="num" value="101"></constructor-arg>
        <constructor-arg name="name" value="jim"></constructor-arg>
    </bean>
    <!--spring框架生成UserDao对象-->
    <bean id="userdao" class="com.ffyc.spring.dao.UserDao"></bean>

    <!--spring框架生成对象UserService,同时注入UserDao-->
    <bean id="userService" class="com.ffyc.spring.service.UserService"