Spring框架学习Day01

1 Spring

1.1 简介

前身：Spring框架以interface21框架（2002年出现）为基础，经过不断设计丰富

出现：2004年3月24日，正式推出Spring1.0版本

作者：Rod Johnson 悉尼大学音乐博士

理念：

• 强大的向后兼容、使代码的质量更高标准
• 使现有的技术更加容易使用，整合了现有的技术框架

SSH：Struct2 + Spring + Hibernate

SSM：SpringMVC + Spring + MyBatis

官网：https://spring.io/projects/spring-framework

下载地址：https://repo1.maven.org/maven2/org/springframework/spring/

**中文文档：**https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-basics

依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.10</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.10</version>
</dependency>

1.2 优点

• Spring是一个开源的免费框架（容器）
• Spring是一个轻量级的，非侵入式的框架
• 控制反转（IOC）面向切面（AOP）
• 支持事务的框架，对框架整合的支持

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

1.3 组成

核心容器

核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文

Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Spring DAO

JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM

Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

Spring Web 模块

Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架

MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4 拓展

SpringBoot

• 一个快速开发的脚手架
• 基于SpringBoot可以快速发展的开发单个微服务
• 约定大于配置

Spring Cloud

• SpringCloud是基于SpringBoot实现的

2 IOC理论指导

2.1 控制反转

以前：当用户需要修改某个需求，我们需要在Dao层和Service层反复修改代码

现在：当用户需要修改某个需求，我们只需要先写好接口，用户输入什么就自动完成相应的业务

这就是控制反转（IOC）原型

控制反转loC(Inversion of Control)

是一种设计思想，DI(依赖注入)是实现loC的一种方法，也有人认为Dl只是loC的另一种说法。

没有loC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。

Spring实现

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

3 HelloSpring

3.1 举例

在service的实现类中，动态设置dao层中userDao的类型

private UserDao userDao;

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

/**
 * 调用Dao获取用户
 */
@Override
public void getUser() {
    userDao.getUser();
}

测试类中

@Test
public void test(){
    UserService userService = new UserServiceImpl();
    ((UserServiceImpl) userService).setUserDao(new UserDaoOracleImpl());
    userService.getUser();
}

• Hello 对象是谁创建的

  hello对象是由Spring创建的

• Hello对象的属性是怎么设置的?

  hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转

控制:

谁来控制对象的创建?

传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的.

反转∶

程序本身不创建对象，而变成被动的接收对象．

依赖注入:

就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收．

要实现不同的操作，只需要在xml配置文件中进行修改，

所谓的loC,一句话搞定:对象由Spring来创建，管理，装配!

3.2 IOC流程

**步骤1：**在pom.xml中引入依赖spring-webmvc

**步骤2：**写dao层和service层

**步骤3：**编写在resources文件夹下创建Spring容器

**步骤4：**到官网拿(services.xml)基本配置信息并放到beans.xml中

**步骤5：**使用Spring创建bean对象

**步骤6：**编写测试类引入ClassPathXmlApplicationContext对象并加载Spring容器

**步骤7：**使用context对象调用getBean("")获取响应的bean对象

**步骤8：**使用Spring创建的对象操作

4 IOC创建对象的方式

pojo类

package com.xzzlx.pojo;

/**
 * @author:zhangheng
 * @Description:
 * @date:2021/10/14 18:32
 */
public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

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

    public void showInfo(){
        System.out.println("name = " + name);
    }
}

测试

import com.xzzlx.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author:zhangheng
 * @Description:
 * @date:2021/10/14 18:32
 */
public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        user.showInfo();
    }
}

4.1 无参构造创建对象

默认

4.2 有参构造创建对象

1 下标赋值

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

<bean id="user" class="com.xzzlx.pojo.User">
  <constructor-arg index="0" value="张三"/>
</bean>

</beans>

2 类型赋值 不建议使用

beans.xml中

<bean id="user" class="com.xzzlx.pojo.User">
<constructor-arg type="java.lang.String" value="zhangsan"/>
</bean>

3 参数名

<bean id="user" class="com.xzzlx.pojo.User">
 <constructor-arg name="name" value="zhangsan03"/>
</bean>

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

举例

<bean id="moreComplexObject" class="example.ComplexObject">
    <!-- results in a setAdminEmails(java.util.Properties) call -->
    <property name="adminEmails">
        <props>
            <prop key="administrator">administrator@example.org</prop>
            <prop key="support">support@example.org</prop>
            <prop key="development">development@example.org</prop>
        </props>
    </property>
    <!-- results in a setSomeList(java.util.List) call -->
    <property name="someList">
        <list>
            <value>a list element followed by a reference</value>
            <ref bean="myDataSource" />
        </list>
    </property>
    <!-- results in a setSomeMap(java.util.Map) call -->
    <property name="someMap">
        <map>
            <entry key="an entry" value="just some string"/>
            <entry key="a ref" value-ref="myDataSource"/>
        </map>
    </property>
    <!-- results in a setSomeSet(java.util.Set) call -->
    <property name="someSet">
        <set>
            <value>just some string</value>
            <ref bean="myDataSource" />
        </set>
    </property>
</bean>

4.3 扩展方式注入

P命名注入:类似于set属性注入

pojo

package com.xzzlx.pojo;

/**
 * @author:zhangheng
 * @Description:
 * @date:2021/10/14 18:32
 */
public class User {
    private String name;
    private int age;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public void showInfo(){
        System.out.println("name = " + name + "\t" + "age = " + age);
    }

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

beans.xml

使用之前导入xml约束：

xmlns:p=“http://www.springframework.org/schema/p”

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.xzzlx.pojo.User" p:name="zhangsan" p:age="23"/>

</beans>

测试

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = context.getBean("user", User.class);
    System.out.println(user);
}

C命名注入：类似于construct-args注入

使用之前导入xml约束：

xmlns:c=“http://www.springframework.org/schema/c”

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--c命名空间注入，通过构造器注入：construct-args-->
    <bean id="user2" class="com.xzzlx.pojo.User" c:name="li si" c:age="23"/>

</beans>

测试

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

4.4 Bean的作用域

 <bean id="user2" class="com.xzzlx.pojo.User" c:name="li si" c:age="23" scope="singleton"/>

scope = “singleton” 单例（默认）

scope = “prototype” 原型

request session application websocket 在web开发中应用

5 Bean的自动装配

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

在Spring中有三种装配的方式
1.在xml中显示的配置

2.在java中显示配置

3.隐式的自动装配bean【重要】

5.1 byName自动装配

byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的 beanid

5.2 byType自动装配

byType:会自动在容器上下文中查找，和自己对象属性类型相同的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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="dog" class="com.xzzlx.pojo.Dog"/>
    <bean id="cat" class="com.xzzlx.pojo.Cat"/>

    <bean id="people" class="com.xzzlx.pojo.People" autowire="byName">
        <property name="name" value="法外狂徒张三"/>
    </bean>


    <bean id="people" class="com.xzzlx.pojo.People" autowire="byType">
        <property name="name" value="法外狂徒张三"/>
    </bean>

</beans>

注意：

• byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致!

• bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致!

5.3 注解实现自动装配

1 导入约束：context约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean id="cat" class="com.xzzlx.pojo.Cat"/>
    <bean id="dog" class="com.xzzlx.pojo.Dog"/>
    <bean id="people" class="com.xzzlx.pojo.People"/>


</beans>

2 配置注解的支持

<context:annotation-config/>

3 需要装配的People类

package com.xzzlx.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }
}

@Autowired

• 直接在属性上使用即可!

• 也可以在set方式上使用!

  使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC(Spring）容器中存在，且符合名字byname!

@Autowired(required = false) 默认为true

@Qualifier(value = xxx) 默认为"" 当Autowired的byType无法匹配出来的时候，按照xxx和Ioc容器bean的Id进行匹配

一起使用

@Resource(name = xxx) 有java提供的 jdk1.8之后取消了

public class People {
    @Autowired
    @Qualifier(value = "cat222")
    private Cat cat;
    
    @Autowired
    private Dog dog;
    
    private String name;

}

6 使用注解开发

Spring4之后，要使用注解开发，必须要保证aop的包导入了

使用注解之前，先配置注解的支持

<context:annotation-config/>

和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"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">
		
	<context:component-scan base-package="com.xzzlx"/>
    <context:annotation-config/>

</beans>

6.1 Bean

@Component放在类上面，说明该类被Spring管理了，就是bean

6.2 属性如何注入

package com.xzzlx.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {
    @Value("法外狂徒张三")
    public String name;
}

6.3 衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层!

• dao层 @Repository
• service层 @service
• controller层 @controller

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

6.4 自动装配

@Autowired(required = false)	默认为true

@Qualifier(value = xxx)			默认为"" 当Autowired的byType无法匹配出来的时候，按照xxx和Ioc容器bean的Id进行匹配

Autowired和Qualifier可以一起使用

@Nullable						该属性可以为空

@Resource(name = xxx)			有java提供的	jdk1.8之后取消了

6.5 作用域

修饰在一个类上面

@Component
@Scope("singleton")
public class User {
    @Value("法外狂徒张三")
    public String name;
}

6.6 小节

xml与注解:

• xml 更加万能，适用于任何场合!维护简单方便。
• 注解不是自己类使用不了，维护相对复杂

xml与注解最佳实践:

• xml用来管理bean;
• 注解只负责完成属性的注入;

我们在使用的过程中，只需要注意一个问题:必须让注解生效，就需要开启注解的支持