首页 > 其他分享 >Spring 学习笔记

Spring 学习笔记

时间:2023-01-14 17:23:52浏览次数:41  
标签:Spring 笔记 学习 bean 通知 spring println ioc public

Spring 笔记

1. Spring 基本概念

这里介绍一下,spring的基本概念,简单的说一下ioc是什么,ioc容器是什么,ioc怎么实现的。

spring默认是单例的

1.1 IOC

ioc是一种思想叫控制反转,以前需要自己创建new对象,然后将对象赋值给某个对象。现在控制反转,可以不需要new对象,不关心对象是如何创建的,只需要使用即可。

1.2 IOC 容器

ioc创建的对象会全部放在,IOC容器中,要使用只需要去IOC容器中去取。

1.3 IOC容器在spring中的实现

这个可以看了源码补充,目前现在看到视频太简单了,只是说了用了什么类

2. 安装与HelloWorld

2.1 使用maven安装

只需要在maven中引入依赖即可

<dependencies>

    <!-- 基于Maven依赖传递性,导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

</dependencies>

2.2 创建spring配置文件和测试需要的类

第一步:先创建测试的类

package com.lin.spring.helloworld;

public class HelloWorld {

    public void test1(){
        System.out.println("你好,Spring");
    }

}

第二步:创建spring配置文件

在resources创建spring配置文件,名字可以随便起,推荐叫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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        bean标签:将一个bean对象,将对象给IOS容器管理
            id:bean的唯一标识(名称),不能重复
            class:需要创建对象的类全类名
     -->
    <bean id="helloworld" class="com.lin.spring.helloworld.HelloWorld"></bean>

</beans>

2.3 创建测试类

package com.lin.spring.helloworld;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldTest {
    
    @Test
    public void test(){
        //ioc 容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据name获取
        HelloWorld baneName = (HelloWorld) ioc.getBean("helloworld");
        System.out.println(baneName);
    }

}

3. 使用XML管理Bean

3.1 获取bean的三种方式

  1. 第一种:根据bean标签的id获取
  2. 第二种:根据bean的类型获取
    1. 注意:根据类型获取bean,IOC容器中必须只有一个类型匹配bean,否则会报错
  3. 第三种:根据bean标签的id获取和类型获取(常用,这里也不能叫常用,在后面都是通过注解自动装置)

实例:

@Test
public void testIocGetBean(){
    //获取ioc容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    //根据bean标签的id获取
    Student studentOne = (Student) ioc.getBean("studentOne");
    //根据类型获取,ioc容器中的类不能重复
    Student studentTow = ioc.getBean(Student.class);
    //根据bean标签的id获取和类型获取
    Student student = ioc.getBean("studentOne",Student.class);
}

问题1:获取类型是否可以根据接口获取?

答:可以,但是类在spring ioc容器中必须是唯一的,并且类实现了该接口。

问题2:如果接口被多个类实现,并且都交给spring ioc管理了,可以根据类型获取吗?

答:不可以,多个spring也不知道使用那个会抛出异常

3.2 依赖注入之set注入

property标签:通过bean对象的属性注入(必须要创建set方法)

name:设置属性名称
value:设置属性赋值

<bean id="studentTow" class="com.lin.spring.ioc.xml.pojo.Student">
    <property name="sid" value="1001"></property>
    <property name="name" value="张三"></property>
    <property name="age" value="23"></property>
    <property name="gender" value="男"></property>
</bean>

3.3 依赖注入之构造器注入

  • constructor-arg标签:根据构造器注入
    • name属性:设置构造器参数名称
    • value属性:设置值

注意:如果constructor-arg标签不写name属性,会按照构造器顺序填充

<bean id="studentThree" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- 不设置name属性,会根据构造器顺序填充属性 -->
    <!--<constructor-arg value="1002"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="女"></constructor-arg>
        <constructor-arg value="24"></constructor-arg>-->

    <!-- 设置name,name属性不会管顺序,会按需名称添加(name的值就是构造器参数名称) -->
    <constructor-arg name="sid" value="1002"></constructor-arg>
    <constructor-arg name="name" value="李四"></constructor-arg>
    <constructor-arg name="gender" value="女"></constructor-arg>
    <constructor-arg name="age" value="24"></constructor-arg>
</bean>

3.4 特殊字符处理

记录一下null还有像<>等特殊字符字符如何处理

3.4.1 null

正确写法:

<bean id="studentFour" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- 给一个属性赋值为null -->
    <property name="gender">
        <null></null>
    </property>
</bean>

错误写法:

<bean id="studentFour" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- 如果这样写,会将null作为字符串赋值给gender变量 -->
    <property name="gender" value="null">></property>
</bean>

3.4.2 特殊字符

因为xml是标签标记语言,像<>等特殊字符,有两种方式,可以解决

方式一:使用转移字符(这里可以百度XML中常用转义符,查找)

<bean id="studentFour" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- &lt;相当于< &gt;相当于> -->
	<property name="name" value="&lt;王五&gt;"></property>
</bean>

方式二:使用xml语法定义的纯文本标签:

不管写什么都会直接赋值,不过不能写在属性里面,必须写在标签里面

<bean id="studentFour" class="com.lin.spring.ioc.xml.pojo.Student">
    <property name="name">
        <!-- <![CDATA[<>]]> 不好记,也不好写,可以使用idea快捷键,输入CD回车即可-->
        <value><![CDATA[<王五>]]></value>
    </property>
</bean>

3.5 依赖注入之Bean注入

bean注入可以定义使用IOC容器中的bean,也可以直接使用匿名类的方式

value标签或者属性都是用来填写普通类型的,比如string、int、long之类的

ref标签或者或者属性都是用来应用ioc容器中的bean,也就是对象

3.5.1 使用IOC容器的bean

只要在其他地方声明过的bean存在ioc容器中,都可以直接拿来使用,ref属性专门引用Ioc容器中的Bean

<bean id="clazz" class="com.lin.spring.ioc.xml.pojo.Clazz">
    <property name="cId" value="1"></property>
    <property name="cname" value="大班"></property>
</bean>

<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- ref属性:引用被spring ioc管理的对象,值对应id -->
	<property name="clazz" ref="clazz"></property>
</bean>

3.5.2 使用级联方式

注意:级联方式必须要保证属性必须提前被初始化,new一个空对象,或者有一个对象,不能是null,否则会报错

<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
	<property name="clazz.cId" value="2"></property>
	<property name="clazz.cname" value="小班"></property>
</bean>

3.5.3 使用内部匿名bean的方式

使用内部匿名bean进行依赖注入,内部匿名bean只能在内部使用,不能通过ioc容器获取

<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
	<property name="clazz">
        <bean id="clazz" class="com.lin.spring.ioc.xml.pojo.Clazz">
        	<property name="cId" value="3"></property>
        	<property name="cname" value="中班"></property>
        </bean>
    </property>
</bean>

3.5.4 数组注入

public class Student{
    
    private String[] hobby;
    
    //隐藏get/set方法
}
<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- 数组注入 -->
    <property name="hobby">
        <array>
            <!-- 使用ref 标签可以引入对象 -->
            <value>唱</value>
            <value>跳</value>
            <value>Rap</value>
            <value>篮球</value>
        </array>
    </property>
</bean>

3.5.5 list注入

public class Student {
    
    private List<String> hobbyList;
    
    //隐藏get/set方法
}
<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
    <!-- List -->
    <property name="hobbyList">
        <list>
            <!-- 使用ref 标签可以引入对象 -->
            <value>唱</value>
            <value>跳</value>
            <value>Rap</value>
            <value>篮球</value>
        </list>
    </property>
</bean>

3.5.6 map对象

public class Student implements Person{
    
    private Map<String,Teacher> teacherMap;
    
    //隐藏get/set方法
}
<bean id="studentFive" class="com.lin.spring.ioc.xml.pojo.Student">
    <property name="teacherMap">
        <map>
            <!-- value-ref属性改成value,就是赋值基本类型了 -->
            <entry key="1" value-ref="teacherOne"></entry>
            <entry key="2" value-ref="teacherTwo"></entry>
        </map>
    </property>
</bean>

3.6 bean的单例和多例

在spring中默认是单例的,如果想要配置多例只需要在bean标签中加上scope属性值写成prototype(多例)。多例的时候在调用的时候才会创建bean,而单例启动就会创建bean

scope属性值有两个值:

  • singleton:单利(默认就是这个)
  • prototype:多利

示例:

<bean id="student" class="com.lin.spring.ioc.xml.pojo.Student" scope="singleton">
    <property name="sid" value="1001"></property>
    <property name="name" value="张三"></property>
</bean>

3.7 bean的生命周期

生命周期步骤:实例化-> 依赖注入-> 初始化-> 销毁

  • 实例化:创建bean的时候执行

  • 依赖注入:给属性赋值的时候

  • 初始化:由bean标签的init-method属性调用

  • 销毁:由bean标签的idestroy-method属性调用

3.7.1 单例的情况

实例:打印一个bean的生命周期

实体类:

package com.lin.spring.ioc.xml.pojo;

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

    public User() {
        System.out.println("生命周期1:实例化");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("生命周期2:依赖注入");
        this.id = id;
    }

    public void initMethod(){
        System.out.println("生命周期3:初始化");
    }

    public void destroyMethod(){
        System.out.println("生命周期4:销毁");
    }
}

spring的xml配置文件:

<!--
	init-method属性:用来指定对象初始化的时候调用(里面填写方法名)
	destroy-method属性:用来指定对象销毁的时候调用(里面填写方法名)
-->
<bean id="user" class="com.lin.spring.ioc.xml.pojo.User" init-method="initMethod" destroy-method="destroyMethod">
    <property name="id" value="1"></property>
    <property name="username" value="admin"></property>
    <property name="password" value="123456"></property>
    <property name="age" value="23"></property>
</bean>

测试方法:

@Test
public void test(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    User user = ioc.getBean("user", User.class);
    System.out.println(user);

    /**
     * spring ioc容器关闭的时候,才会销毁bean,也就是ioc容器关闭的时候才会调用销毁代码
     * ClassPathXmlApplicationContext实现了ApplicationContext接口扩展了这个接口刷新和关闭的方法
     * ApplicationContext接口里面是没有销毁的方法的,ClassPathXmlApplicationContext类里面有销毁代码
     */
    ioc.close();
}

3.7.2 多例的情况

多例和单例没什么太大的区别,这里的就记录了,就是bean不会提前创建而是使用的时候才进行创建

4.使用注解管理Bean

注解和xml作用一样可以管理Bean,只是把xml的bean标签换成了注解

常用的注解,等同于xml的bean标签

  • @Component 将类标记为普通组件

  • @Controller 将类标记为控制层组件

  • @Service 将类标识为业务组件

  • @Repository 将类标识为持久层组件

这四个组件在spring ioc中,作用是一模一样的,存在的目的只是给开发人员看,提高代码的可读性

4.1 组件的扫描Bean

在spring ioc配置文件中,只需要使用context:component-scan标签配置包名,只要配置了包名,就是扫描这个包下面的所有注解

注:需要导入context命名空间,提示

4.1.1 配置基本扫描

<!-- 扫描注解:扫描是扫描这个包路径下全部类 -->
<context:component-scan base-package="com.lin.spring.ioc.annotation"></context:component-scan>
<!-- 多个可以用,隔开 -->
<context:component-scan base-package="com.lin.spring.ioc.annotation.controller,com.lin.spring.ioc.annotation.dao.impl"></context:component-scan>

4.1.2 配置不扫描谁

使用context:exclude-filter标签,可以将不想扫描的排除出去。它里面有个type属性,常用值的:annotation和assignable

  • type属性:类型

    • annotation:通过注解方式,expression(排除规则)属性填写需要排除的注解全类名

    • assignable:根据类的类型进行排除,expression(排除规则)属性填写需要排除类的全类名

  • expression属性:排除规则

示例一:根据注解排除

<context:component-scan base-package="com.lin.spring.ioc.annotation">
    <!-- 表示com.lin.spring.ioc.annotation包下面的所有类排除使用@Controller注解的 -->
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

示例二:根据类排除

<context:component-scan base-package="com.lin.spring.ioc.annotation">
    <!-- 表示com.lin.spring.ioc.annotation.controller.UserController类进行排除 -->
    <context:exclude-filter type="assignable" expression="com.lin.spring.ioc.annotation.controller.UserController"/>
</context:component-scan>

4.1.3 配置只扫描谁

使用context:include-filter标签,这个没有什么实际的用处,因为用普通扫描的包已经将需要扫描的类全部扫描进去了,没有必要在进行扫描。如果实在需要使用需要在父标签context:component-scan加上use-default-filters="false"属性

  • type属性:类型

    • annotation:通过注解方式,expression(排除规则)属性填写需要排除的注解全类名

    • assignable:根据类的类型进行排除,expression(排除规则)属性填写需要排除类的全类名

  • expression属性:排除规则

示例一:根据注解配置扫描

<context:component-scan base-package="com.lin.spring.ioc.annotation" use-default-filters="false">
    <!-- 表示com.lin.spring.ioc.annotation包下面只扫描使用@Controller注解的 -->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

示例二:根据类配置扫描

<context:component-scan base-package="com.lin.spring.ioc.annotation" use-default-filters="false">
    <!-- 表示只扫描com.lin.spring.ioc.annotation.controller.UserController类 -->
    <context:include-filter type="assignable" expression="com.lin.spring.ioc.annotation.controller.UserController"/>
</context:component-scan>

4.2 问:使用创建bean注解的id是什么?

默认是使用类名开头字母小写,比如UserController默认的bean id就是userController

4.1.1 自定义bean的id

只需要在注解的value参数中传入值,就是bean的id

例如:

@Controller("controller")
public class UserController {
    
}

4.2 使用自动装配

只需要在属性名加上@Autowired注解,就会自动将对象赋值过去。不需要提供set方法,当然也可以不加在属性上面,可以在set方法或者构造器上面。

默认通过type进行查找,如果type有多个的情况使用type+name的方式进行自动装配,如果都查找不到就抛出异

常:NoSuchBeanDefinitionException

4.2.1 加在属性上面

实例:

@Controller
public class UserController {

    @Autowired
    private UserService userService;

}

4.2.2 加在set方法上面

@Service
public class UserServiceImpl implements UserService {
    
    private UserDao userDao;
    
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

4.2.3 加在构造器上面

如果加在构造器上面,spring会优先使用带@Autowired注解的类进行处理

@Service
public class UserServiceImpl implements UserService {
    
    private UserDao userDao;
    
    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

}

5. AOP

5.1 AOP 概念

AOP挺重要的,而且概率不是特别好理解,所以这里单独开个板块,记录一下自己理解的AOP概念。

aop目的就是在不改变其他人的代码的情况,前面或者后面加上自己的代码,比如某个源码或者其他同事的代码是不能改变别人代码,这里可以使用AOP在方法执行前或者执行后加上我们希望执行的东西。再比如日志,不可能每个业务都进行日志记录,这样子工作量很大,如果使用AOP只需要配置切入点,就利用前置通知和后置通知,记录用户请求参数与返回结果

简单解释:AOP就是不改变代码的情况执行前或者执行后加上我们想要的代码。

在本人看的教程中把AOP说的过于复杂,并没有什么意义,过于抽象,现在本人还是不知道哪些相关术语代表着什么,以后知道了在补充,这里全部记录但是只补充本人理解的专业术语。

- 横切关注点
  • 通知
    • 通知比较重要:其实就是前置通知、后置通知、返回通知、异常通知、环绕通知。后面会详细补充
  • 切面
    • 封装乱七八糟的前置通知、后置通知、返回通知、异常通知、环绕通知的类
  • 目标
  • 代理
    • 被代理的目标类,不是自己实例化的类,是AOP用接口再次实例的那个类
  • 连接点
  • 切入点
    • spring aop就是根据切入点来定位,哪些类需要进行切面(也可以理解成哪些类需要通知)

5.2 AOP 入门

第一步:添加依赖

除了ioc所需要的依赖还需要单独引入spring-aspects

<dependencies>
    <!-- ioc基础依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
	
    <!-- 在IOC所需依赖基础上再加入spring-aspects依赖 -->
    <!-- spring-aspects会帮我们传递过来aspectjweaver -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.1</version>
    </dependency>

</dependencies>

第二步:配置扫描注解

除了要配置扫描bean,还需要单独加入aop:aspectj-autoproxy标签

<!-- 扫描注解:扫描是扫描这个包路径下全部类 -->
<context:component-scan base-package="com.lin.spring.aop.annotation"></context:component-scan>

<!-- 开启基于注解的AOP -->
<aop:aspectj-autoproxy />

第三步:创建目标类

@Component
public class Calculator {
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}

第四步:创建切面类

前面类需要加上@Aspect注解

package com.lin.spring.aop.annotation;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 切面类
 * 在切面中,需要加入指定的注解,将其标记为通知方法
 */
@Component
@Aspect
public class LoggerAspect {

    /**
     * 这里用代理接口或者目标类方法都可以
     * 切入点:
     *  execution()固定写法
     *  public int 与代理接口的访问修饰符和返回值一致
     *  com.lin.spring.aop.annotation.Calculator 全类名,明确表示是那个
     *  .add(int,int) 方法名和参数,参数只需要传类型即可,在java中参数类型已经可以明确表示是那个方法了
     * .
     */
    @Before("execution(public int com.lin.spring.aop.annotation.Calculator.add(int,int))")
    public void beforeAdviceMethod(){
        System.out.println("LoggerAspect,前置通知");
    }
    
}

第四步:创建测试类

import com.lin.spring.aop.annotation.Calculator;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {

    @Test
    public void testAPPByAnnotation(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
        /**
         * 使用AOP不能直接获取目标类的对象,必须使用代理的接口的对象,IOC也不会存在目标类的接口
         * 所以这里获取bean要填写获取代理对象的接口,让它自动创建代理接口和实现类
         */
        Calculator calculator = ioc.getBean(Calculator.class);
        calculator.div(1,1);
    }

}

5.3 AOP 切入点基本配置

5.3.1 切入点表达式

用*可以代表包也可以代表类也可以代表包

/**
 * 使用表达式切入点
 *   execution()固定写法
 *   * 表示代理接口所有的访问修饰符和返回值
 *   com.lin.spring.aop.annotation.Calculator.* 表示类下面的所有方法
 *       - 类也可以用*代替,表示这个包下面的所有类:com.lin.spring.aop.annotation.*.*
 *       - 包也可以用*代替,表示这个包同级的下面的所有包:com.lin.spring.*.annotation.*.*
 *   (..) 表示所有参数,我不关心你是什么参数,都进行标记切入点
 */
@Before("execution(* com.lin.spring.aop.annotation.Calculator.*(..))")
public void beforeAdviceMethod(){
    System.out.println("LoggerAspect,前置通知");
}

5.3.2 公共的切入点

很多时候有个一个切面类的规则是一样的,这样子可以定义一个公共的切人点,其他切入点都引用公共的。

只需要使用@Pointcut注解声明公共的切入点,其他切入点都引用次方法名即可

/**
 * 声明公共的切入点表达式
 */
@Pointcut("execution(* com.lin.spring.aop.annotation.Calculator.*(..))")
public void pointcut(){}

/**
 * 使用公共的切入点表达式
 * @param joinPoint
 */
@Before("pointcut()")
public void beforeAdviceMethod(JoinPoint joinPoint){
    //获取连接点所对应的签名信息,通过签名信息.getName可以获取方法名
    Signature signature = joinPoint.getSignature();

    //获取连接点所对应方法参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect,前置通知 方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
}

5.4 AOP通知-注解版本

aop核心就是通知,分别有前置通知,后置通知、返回通知、异常通知、环绕通知,它们分别有对应的注解,用于标识各种通知。

它们的执行顺序是:前置通知-->被切面的方法-->-->[异常通知]-->返回通知-->后置通知,如果异常通知被执行,返回通知不会被执行,其他都会执行

  • @Before:前置通知,在目标对象方法执行之前执行
  • @After:后置通知,在目标对象方法的finally中执行
  • @AfterReturning:返回通知,在目标对象方法返回值之后执行
  • @AfterThrowing:异常通知,目标对象方法执行发送异常后执行
  • @Around:环绕通知

5.4.1 前置通知:

@Before("pointcut()")
public void beforeAdviceMethod(JoinPoint joinPoint){
    //获取连接点所对应的签名信息,通过签名信息.getName可以获取方法名
    Signature signature = joinPoint.getSignature();
    //获取连接点所对应方法参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect,前置通知 方法:"+signature.getName()+",参数:"+ Arrays.toString(args));
}

5.4.2 后置通知

@After("pointcut()")
public void afterAdviceMethod(JoinPoint joinPoint){
    //获取连接点所对应的签名信息,通过签名信息.getName可以获取方法名
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect,后置通知 方法:"+signature.getName());
}

5.4.3 返回通知

只需要result属性的值和参数的名一致,AOP就会自动将返回值赋值给result属性值与参数名称一致的参数

@AfterReturning(value = "pointcut()",returning = "result")
public void afterReturningAdviceMethod(JoinPoint joinPoint,Object result){
    //获取连接点所对应的签名信息,通过签名信息.getName可以获取方法名
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect,返回通知 方法:"+signature.getName()+",结果:"+ result);
}

5.4.4 异常通知

只需要throwing属性的值和参数的名一致,AOP就会自动将异常赋值给result属性值与参数名称一致的参数,接收类型必须是Throwable的子类

@AfterThrowing(value = "pointcut()",throwing = "ex")
public void afterThrowingAdviceMethod(JoinPoint joinPoint,Throwable ex){
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect,异常通知 方法:"+signature.getName()+",异常:"+ ex);
}

5.4.5 环绕通知

环绕通知:相当于前置通知+后置通知+返回通知+异常通知,正常情况使用环绕通知也就不会在使用其他通知了。

@Around("pointcut()")
public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
    Object result = null;
    //表示目标对象方法的执行
    try {
        System.out.println("环绕通知-->前置通知");
        result = joinPoint.proceed();
        System.out.println("环绕通知-->返回通知");
    } catch (Throwable e) {
        e.printStackTrace();
        System.out.println("环绕通知-->异常通知");
    } finally {
        System.out.println("环绕通知-->后置通知");
    }
    return result;
}

5.5 AOP通知-XML版本

xml版本使用的概率很低,如果要使用可以结合注解的方式看,看一眼就明白了。

<aop:config>
    <!-- 设置一个公共的切入点表达式 -->
    <aop:pointcut id="pointCut" expression="execution(* com.lin.spring.aop.xml.Calculator.*(..))"/>

    <!-- 将IOC容器中的某个bean设置成切面 -->
    <aop:aspect ref="loggerAspect">
        <!-- 前置通知 -->
        <aop:before method="beforeAdviceMethod" pointcut-ref="pointCut"></aop:before>
        <!-- 后置通知 -->
        <aop:after method="afterAdviceMethod" pointcut-ref="pointCut"></aop:after>
        <!-- 返回通知 -->
        <aop:after-returning method="afterReturningAdviceMethod" pointcut-ref="pointCut" returning="result"></aop:after-returning>
        <!-- 异常通知 -->
        <aop:after-throwing method="afterThrowingAdviceMethod" pointcut-ref="pointCut" throwing="ex"></aop:after-throwing>
        <!-- 环绕通知 -->
        <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"></aop:around>
    </aop:aspect>

    <!-- 引入第二个切面 -->
    <aop:aspect ref="validateAspect" order="1">
        <aop:before method="beforeMethod" pointcut-ref="pointCut"></aop:before>
    </aop:aspect>
</aop:config>

6. 声明式事务

事务的作用,就是当某段代码发生了异常,操作的数据进行回滚

事务有两种,一种是编译式事务,一种是声明式事务,简单来说编译式事务就是要自己写代码处理,而声明式事务通过配置让框架来实现

6.1 开启事务

第一步:导入需要的maven

<dependencies>

    <!-- 基于Maven依赖传递性,导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- Spring 持久化层支持jar包 -->
    <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中,需要使用orm、jdbc、tx三个 jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>

    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.31</version>
    </dependency>

</dependencies>

第二步:先在spring配置的xml里面引入开启事务注解驱动

<!--
	开启事务注解的驱动
		将使用@Transactional注解所标识的方法活类中所有的方法使用事务管理
		如果DataSourceTransactionManager的bean id就是叫transactionManager,可以直接简写为:<tx:annotation-driven />,属性不写,只写标签
    -->
<!-- 这里导入命名空间的时候idea会提示有多个必须要选择tx: xmlns:tx="http://www.springframework.org/schema/tx"-->
<tx:annotation-driven transaction-manager="transactionManager"/>

第三步:在类上面或者方法上面加上@Transactional注解,表示开启事务

@Transactional

6.2 事务属性

事务属性分为只读、超时、休眠、回滚策略,只要发送对应的操作就会进行事务回滚

6.2.1 只读

给上readOnly属性设置成true(默认是false),该事务中只能出现查询,不能出现增删改,否则会抛出异常

Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification

are not allowed

@Transactional(readOnly = true)

6.2.2 超时

超时,默认是-1,表示不超时,如果超时会进行事物回滚,整个事务方法必须在x秒内执行完,单位是秒

@Transactional(timeout = 3)

6.2.3 回滚策略

spring事务有四个回滚策略,常用就一个

  • noRollbackFor属性:无视某个异常,让事务正常提交,多个用逗号隔离(此属性用class对象)

  • noRollbackForClassName属性:无视某个异常,让事务正常提交,多个用逗号隔离(此属性用字符串全类名)

//class对象
@Transactional(noRollbackFor = {ArithmeticException.class})

//字符串全类名
@Transactional(noRollbackForClassName = "java.lang.ArithmeticException")

6.3 事务隔离级别

事务有四个特性:一致性、原子性、隔离性、持久性。

事物的隔离级别,用于就是解决对应的问题

mysql 默认隔离级别是:可重复读脏读、幻读、不可重复读

  • 读未提交:
    • 举例:A事务的隔离级别是:读未提交,B事务的隔离级别是:可重复读
    • A事务可以读到,B事务未提交的数据,如果最终B回滚了,A读取到B的数据也就没任何意义 也叫脏读
  • 读已提交:
    • A事务的隔离级别是:读已提交,B事务的隔离级别是:可重复读
    • A事务只能读到,B事务提交的数据,未提交的数据读取不到
  • 可重复读(可重复读的隔离级别,在操作某行数据的时候,会给这行数据加锁)
    • A事务的隔离级别是:可重复读,B事务的隔离级别是:可重复读
    • 比如A事务在操作id为1的数据,这个时候B也想操作id未1的数据,这个时候b会堵塞,必须等A操作完并且提交了数据,B才能操作
    • 如果A没有提交只操作了id为1的数据,B可以操作其他表的其他数据,加锁只是针对某一行
  • 串行化(串行化会给整个表加锁)
    • A事务的隔离级别是:串行化,B事务的隔离级别是:可重复读
    • 串行化会给整个表加锁,如果A事务,没有进行提交,B事务是整个表都不能操作,会进行堵塞状态,必须等A提交完事务

各个隔离级别存在的问题:

名称 隔离级别 脏读 不可重复读 幻读
读未提交 READ UNCOMMITTED
读已提交 READ COMMITTED
可重复读 REPEATABLE READ
串行化 SERIALIZABLE

种数据库产品对事务隔离级别的支持:

名称 隔离级别 Oracle MySQL
读未提交 READ UNCOMMITTED 不支持 支持
读已提交 READ COMMITTED 支持(默认) 支持
可重复读 REPEATABLE READ 不支持 支持(默认)
串行化 SERIALIZABLE 支持 支持
@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别
@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交
@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交
@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读
@Transactional(isolation = Isolation.SERIALIZABLE)//串行化

6.4 事物的传播行为

事物的传播行为是指,比如我在方法外面有一个事物了,我在方法里面调用了某一个方法也有事物,在默认情况,spring会使用最外层的事物。也就是说默认情况下,只需要发生异常最外面那一层代码是事物都会进行回滚;

举例:使用伪代码的方式演示事物

import org.springframework.transaction.annotation.Transactional;

public class Test {

    @Transactional
    public void purchase(){
        System.out.println("购买");
    }

    @Transactional
    public void addIntegral(){
        System.out.println("增加积分");
        //故意制造异常
        System.out.println(1/0);
    }

    @Transactional
    public void checkout(){
        purchase();
        addIntegral();
        System.out.println("结账");
    }

    public static void main(String[] args) {
        new Test().checkout();
    }

}

这段代码可以看出,增加积分的时候,发生了异常,这个时候整个结账方法都会进行回滚。

@Transactional(propagation = Propagation.REQUIRED)//默认传播行为
@Transactional(propagation = Propagation.REQUIRES_NEW)//加在方法中,表示次方法每次调用都会创建一个新的事物,只要这个方法成功就提交

用上面的例子如果将purchase()方法上面的事物改成@Transactional(propagation = Propagation.REQUIRES_NEW),在运行这段代码,购买是成功的,但是到增加积分那就会抛出异常。

6.5 使用xml操作事物

基于xml操作事物需要导入aspectJ的依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>
<aop:config>
    <!-- 配置事务通知和切入点表达式 -->
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.atguigu.spring.tx.xml.service.impl.*.*(..))"></aop:advisor>
</aop:config>
<!-- tx:advice标签:配置事务通知 -->
<!-- id属性:给事务通知标签设置唯一标识,便于引用 -->
<!-- transaction-manager属性:关联事务管理器 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- tx:method标签:配置具体的事务方法 -->
        <!-- name属性:指定方法名,可以使用星号代表多个字符 -->
        <tx:method name="get*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
        <!-- read-only属性:设置只读属性 -->
        <!-- rollback-for属性:设置回滚的异常 -->
        <!-- no-rollback-for属性:设置不回滚的异常 -->
        <!-- isolation属性:设置事务的隔离级别 -->
        <!-- timeout属性:设置事务的超时属性 -->
        <!-- propagation属性:设置事务的传播行为 -->
        <tx:method name="save*" read-only="false" rollback- for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="update*" read-only="false" rollback- for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="delete*" read-only="false" rollback- for="java.lang.Exception" propagation="REQUIRES_NEW"/>
    </tx:attributes>
</tx:advice>

7. Spring的测试类

Spring有提供专门用于测试使用的注解,这样子就不用每次都去引入xml,然后在调用bean,可以直接指定测试环境,然后在引入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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://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.lin.spring.transaction"></context:component-scan>

    <!-- 引入properties文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"></property>
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="username" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <bean class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>
package com.lin.spring.transaction.test;


import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

//设置测试类运行环境,这样就可以直接通过注入的方式直接获取ioc容器中的bean
@RunWith(SpringJUnit4ClassRunner.class)
//指定spring测试环境的配置文件  classpath:表示类路径下面
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JdbcTemplateTest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void testInsert(){
        String sql = "INSERT INTO t_user values(null,?,?,?,?,?)";
        jdbcTemplate.update(sql,"root","123",23,"女","[email protected]");
        System.out.println("插入语成功");
    }
}

标签:Spring,笔记,学习,bean,通知,spring,println,ioc,public
From: https://www.cnblogs.com/lin168/p/17052063.html

相关文章

  • spring boot——请求与参数校验——spring-mvc——通过 HttpServletRequest 获取请求
    我们可以在控制器方法中设置一个HttpServletRequest类型的形参, SpringMVC会自动将请求中携带的参数封装到HttpServletRequest形参中, 然后我们就可以通过HttpS......
  • MySql学习笔记--进阶05
          ......
  • SpringSecurity基础
    1.安全框架概述解决系统安全问题的框架。如果没有安全框架,我们需要手动处理每个资源的访问控制,非常麻烦。使用安全框架,我们可以通过配置的方式实现对资源的访问限制。2......
  • 复习第7点-7.SpringMVC 的响应方式
    1.使用ServletAPI实现转发/*使用HttpServletRequest对象实现请求转发*/@RequestMapping("/httpServletRequest")publicvoidmethod1(HttpServle......
  • 【800】机器学习特征重要性可视化
    参考:数据科学|避坑!Python特征重要性分析中存在的问题模型代码(复制前一个博客的内容):查看代码fromsklearn.model_selectionimporttrain_test_splitX_train,X_t......
  • C++学习开发路线
    C++等级:0级:掌握常见C++语法和语言构造,能够顺溜地写清楚各种语言构造(很多小白鼠死在这里)1级:掌握基本的编程范式:面向过程、面向对象、泛型编程、以及C++11/14支持的函数式......
  • 复习第6点-6.SpringMVC作用域传值
    作用域范围对象名称作用范围application整个作用范围session在当前会话中有效request在当前请求中有效page在当前页面有效request/session/app......
  • Android studio学习笔记2
    Androidstudio学习笔记220201303张奕博2023.1.14androidstudio动态调试apk1.配置环境androidstudio需要安装插件:1,Smalidea2,SmaliSupport2.打开APK包注......
  • 环论中中国剩余定理证明笔记
    这一阵在看Maki的《抽象代数I》视频课(https://www.bilibili.com/video/BV1xG411j7Hk),其中第20课讲到环论的中国剩余定理,即:若(R,+,·)是交换环,Ii ◁R,i=1,...,......
  • 读编程与类型系统笔记07_子类型
    1. 子类型1.1. 在期望类型T的实例的任何地方,都可以安全地使用类型S的实例,则类型S是类型T的子类型1.1.1. 里氏替换原则(Liskovsubstitutionprinciple)2. 名义子类型......