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中配置声明式事务,我们就需要在代码中手写配置事务
  1. 编写Mapper.xml
  2. 测试

Mybatis-Spring

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

声明式事务

1、回顾事务

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

事务的ACID原则

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

Spring中的事物管理

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

为什么需要事务?

  • 如果不配事务,可能存在数据提交不一致的情况下
  • 如果我们不再Spring中配置声明式事务,我们就需要在代码中手写配置事务
  • 事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎。
上一篇:【学习】023 分布式任务调度平台


下一篇:Spring5笔记(尚硅谷版)