Spring5学习笔记（完整版）

1、Spring

1.1、简介

• Spring:春天----->给软件行业带来的春天！

• Spring理念：使现有的技术更加容易使用，本身是个大杂烩，整合了现有的技术框架

• SSM:SpringMvc+Spring+MyBatis

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

• 官方下载地址：https://docs.spring.io/spring-framework/docs/4.3.9.RELEASE/spring-framework-reference/

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

1.2、优点

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

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

IOC理论推导

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

IOC本质

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

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

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式，而Spring中实现控制反转的是IOC容器，其实现方法是以来注入。

IOC创建对象的方式

1、使用无参构造创建对象，默认

2、假设我们要使用有参构造创建对象

​ 1、下标赋值

​ 2、类型

​ 3、参数名

Spring配置

别名

如果创建了别名，也可以通过别名创建对象

<alias name = "user" value = "userNew"></alias>

Bean的配置

id:bean的唯一标识符，也就是相当于我们学的对象名
class:bean对象所对应的全限定名： 包名+类型
name:也是别名，而且name可以同时取多个别名

import

这个import，一般用于团队开发使用，他可以将多个配置文件导入合并为一个

依赖注入

构造器注入

set方式注入

依赖注入：Set注入！

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

其他方式

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

<?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">
    <!--p命名空间注入，可以直接注入属性的值-->
    <bean id="user" class="com.kuang.pojo.User" p:name="青青" p:age="18"></bean>
    <!--c命名空间注入，通过构造器注入-->
    <bean id ="user2" class="com.kuang.pojo.User" c:age="19" c:name="冰冰"></bean>
</beans>

注意点：p命名和c命名空间不能直接使用，需要导入xml约束

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

bean的作用域

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

1、单例模式（默认模式）

    <bean id ="user2" class="com.kuang.pojo.User" c:age="19" c:name="冰冰" scope="singleton"></bean>

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

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

3、其余的request session application，这些个只能在web开发中使用到！

Bean的自动装配

自动装配是Spring满足bean依赖的一种方式！

Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配的方式

• 在xml中显示配置

• 在java中显示配置

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

  • byName

       <!--
            byName:会自动在容器上下文中插肿，和自己对象set方法后面的值对应的beanid
            byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean
        -->
        <bean id="person" class="com.kuang.pojo.Person" autowire="byName">
            <property name="name" value="青青"></property>
        </bean>
    

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

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

注解实现自动装配

jdk1.5开始支持注解，Spring2.5开始支持注解

开启注解的支持
<context:annotation-config/>

要是用注须知：

1、导入约束 context约束

2、配置注解的支持

@Autowired

直接在属性上使用即可，也可以set方法上使用

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

科普

@Nullable 字段标记了这个注解，说明这个字段可以为null

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解完成的时候，我们可以使用@Qualifier(value=“xxx”)去配合@Autowired的使用，指定一个唯一的bean对象注入

@Resource和@Autowired的区别：

• 都是自动装配的，都可以放在属性字段上
• @Autowired通过byType的方式实现，而且必须要求这个对象存在！
• @Resource通过byname的方式实现，如果找不到名字，则通过ByType实现，如果两个都找不到，就报错
• 执行顺序不同：@Autowired通过byType的方式实现，@Resource通过byname的方式实现

使用注解开发

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

使用注解需要导入context的约束，增加注解的支持

@Component:组件，放在类上，说明这个类被spring管理了

1、bean

2、属性如何注入

package com.kuang.pojo;

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

@Component
public class User {
    @Value("青青")
    public String name;
}

3、衍生的注解

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

• dao【@Repository】
• service【@Service】
• controller【@Controller】

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

4、自动装配

5、作用域 @Scope

6、小结

xml与注解：

• xml更加万能，适用于任何场合！维护简单方便
• 注解 不是自己的类使用不了，维护相对复杂
• xml与注解的最佳实践：
  • xml用来管理bean
  • 注解只负责完成属性的注入
  • 我们在使用的过程中，只需要注意一个问题，必须让注解生效，就需要开启注解的支持

使用java的方式配置spring

我们现在要完全不使用Spring的xml配置了，全权交给Java来做

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能

package com.kuang.pojo;

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

//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("青青")
    public void setName(String name) {
        this.name = name;
    }

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

package com.kuang.config;

import com.kuang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration //这个也会被Spring容器托管，注册到容器中，因为它本身就是一个@Component.
// @Configuration代表这是一个配置类，
@ComponentScan("com.kuang.pojo")
public class KuangConfig {
//    注册一个bean，就相当于我们之前写的一个bean标签
//    这个方法
    @Bean
    public User getUser(){
        return new User();
    }
}

import com.kuang.config.KuangConfig;
import com.kuang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
        User user = (User) context.getBean("getUser");
        System.out.println(user.getName());
    }
}

代理模式

代理模式的分类：

• 静态代理
• 动态代理

静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人

代码步骤：

• 接口
• 真实角色
• 代理角色
• 客户端访问代理角色

代理模式的好处：

• 可以使真实角色的操作更加纯粹
• 公共业务就交给代理角色
• 公共业务发生拓展的时候，方便集中管理

缺点：

• 一个真实角色就会产生一个代理角色：代码量会翻倍~开发效率更低

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类 的动态代理
  • 基于接口—JDK动态代理
  • 基于类----cglib
  • java字节码实现：javasist

需要了解两个类：Proxy:代理,InvocationHandler：调用处理的程序

InvocationHandler

package com.kuang.demo4;

import com.kuang.demo03.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们会用这个类自动生成代理
public class ProxyInvocationHandler implements InvocationHandler {
    /*被代理的接口*/
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //    生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    /*处理代理实例，并返回结果*/
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        //        动态代理的本质，就是使用反射机制实现
        Object result = method.invoke(target, args);
        return result;
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

动态代理的好处

• 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
• 公共也就交给代理角色！实现了业务的分工
• 公共业务发生的扩展的时候，方便集中管理！
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务。
• 一个动态代理类可以代理多个类，只要是实现类同一个接口即可。

AOP在Spring中的作用

提供声明式亢；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，如日志，安全，缓存，事务等等……
• 切面（ASPECT）:横切关注点被模块化的特殊对象。即，它是一个类
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法
• 目标（Target）:被通知对象
• 代理（Proxy）：想目标对象应用通知之后创建的对象
• 切入点：（PointCut）：切面通知执行的“地点”的定义
• 连接点（JointPoint）：与切入点匹配的执行点

方式一：使用Spring API接口【主要是SpringAPI接口实现】

方式二：自定义来实现【主要是切面】

方式三：使用注解实现

整合Mybatis

步骤：

1、导入相关jar包

• junit
• mybatis
• mysql数据库
• spring相关的
• aop织入
• mybatis-spring【new】

2、编写配置文件

3、测试

回忆mybatis

1. 编写实体类
2. 编写核心配置文件
3. 编写接口
4. 编写Mapper.xml
5. 测试

Mybatis-Spring

1. 编写数据源配置
2. sqlSessionFactory
3. sqlSessionTemplate
4. 需要给接口加实现类
5. 将自己写的实现类，注入到Spring中
6. 测试使用即可！

声明式事务

1、回顾事务

• 把一组业务当成一个业务来做；要么都成功，要么都失败！
• 事务在项目开发中，十分的重要，设计到数据的一致性问题，不能马虎
• 确保完整性和一致性

事务的ACID原则

• 原子性
• 一致性
• 隔离性：多个业务可能操作同一个资源，防止数据损坏
• 持久性：事务一旦提交，无论系统发生什么问题，结果都不会发再被影响，被持久化的写到存储器中

Spring中的事物管理

• 声明式事务：AOP
• 编程式事务：需要再写代码,进行事务的管理

为什么需要事务？

• 如果不配事务，可能存在数据提交不一致的情况下
• 如果我们不再Spring中配置声明式事务，我们就需要在代码中手写配置事务

4. 编写Mapper.xml
5. 测试

Mybatis-Spring

1. 编写数据源配置
2. sqlSessionFactory
3. sqlSessionTemplate
4. 需要给接口加实现类
5. 将自己写的实现类，注入到Spring中
6. 测试使用即可！

声明式事务

1、回顾事务

• 把一组业务当成一个业务来做；要么都成功，要么都失败！
• 事务在项目开发中，十分的重要，设计到数据的一致性问题，不能马虎
• 确保完整性和一致性

事务的ACID原则

• 原子性
• 一致性
• 隔离性：多个业务可能操作同一个资源，防止数据损坏
• 持久性：事务一旦提交，无论系统发生什么问题，结果都不会发再被影响，被持久化的写到存储器中

Spring中的事物管理

• 声明式事务：AOP
• 编程式事务：需要再写代码,进行事务的管理

为什么需要事务？

• 如果不配事务，可能存在数据提交不一致的情况下
• 如果我们不再Spring中配置声明式事务，我们就需要在代码中手写配置事务
• 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎。