Spring5笔记（配置和零配置）

最新推荐文章于 2024-04-24 14:51:36 发布
最新推荐文章于 2024-04-24 14:51:36 发布
阅读量236 收藏
点赞数 1
分类专栏： 学习笔记 文章标签： spring java aop ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34912889/article/details/105085231
版权

文章目录

Spring的优缺点

优点：
1）Spring是一个开源的免费的框架（容器）
2）轻量级的、非入侵式的框架
3）控制反转（IOC），面向切面编程（AOP）
4）支持事务的处理，对其他框架整合的支持
一句话总结：Spring是一个轻量级的控制反转（IOC）和面向切面编程的框架
缺点：
配置繁琐，配置地狱

新建项目

新建一个项目
maven配置依赖，这里就不提取版本什么的了

<!--引入SpringMvc就可以了，他会帮我们引入一大堆Spring东西-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>
<!--为了集成mybatis用-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

Spring对于IOC的实现（DI）演示

有关IOC和DI的介绍百度一搜一大堆我就不写了
直接来看看在spring中如何使用

构造器注入

一. 使用基于配置的方式
1）新建一个pojo类

public class Human {

        private String name;
        private int age;

        public Human(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public Human(){
            System.out.println("这是无参的构造函数");
        }

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

在resources文件夹中，新建一个beans.xml，然后在文件中写入如下内容，然后注入bean的时候就在beans标签中写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-3.0.xsd">

</beans>

我们可以使用默认的无参构造函数创建bean

<bean id="human" class="com.jxw.pojo.Human"></bean>

也可以使用有参的构造函数创建bean，有参的构造函数有三种方式指定参数
第一种，使用index指定参数位置

<bean id="human" class="com.jxw.pojo.Human">
   <constructor-arg index="0" value="jxw" />
   <constructor-arg index="1" value="25" />
</bean>

使用index指定参数位置赋值需要注意的是，参数的索引是从0开始的，和数组一样

第二种，使用类型匹配参数

<bean id="human" class="com.jxw.pojo.Human">
    <constructor-arg type="java.lang.String" value="jxw" />
    <constructor-arg type="int" value="25" />
</bean>

使用类型匹配参数需要注意的一点是，除了几种基本数据类型，引用类型的参数需要写出完全限定名，当然这种方式是不建议使用的，因为当构造函数有两个相同类型的参数就搞不定了

第三种，使用名称指定参数赋值

<bean id="human" class="com.jxw.pojo.Human">
    <constructor-arg name="name" value="jxw" />
    <constructor-arg name="age" value="25" />
</bean>

如果使用配置的方式，我们最常用的应该就是第三种了
那么就这样赋值就能满足我们的需求了吗？先来看下面的一个例子

public class Information {

    private Human human;

    private Gender gender;

    public Information(Human human, Gender gender) {
        this.human = human;
        this.gender =gender;
    }

    public Human getHuman() {
        return human;
    }

    public void setHuman(Human human) {
        this.human = human;
    }

    public Gender getGender() {
        return gender;
    }

    public void setGender(Gender gender) {
        this.gender = gender;
    }
}
enum Gender {
    男,
    女
}

这里的human要如何赋值呢，这时候ref参数登场了

<bean id="human" class="com.jxw.pojo.Human">
    <constructor-arg name="name" value="jxw" />
    <constructor-arg name="age" value="25" />
</bean>

<bean id="information" class="com.jxw.pojo.Information">
    <constructor-arg type="com.jxw.pojo.Human" ref="human" />
    <constructor-arg name="gender" value="男"/>
</bean>

这里的ref能连接到的是一个已经在配置文件中配置好的bean，比如上面的bean的id是human，那么我们想要引用他的时候，ref后面跟上human就可以了
information的constructor-arg我混合使用了两种不同的方式指定，一个是type，一个是name，经过测试是可以混合使用的，所以在配置文件中只要是能让Spring找到对应的参数，怎么混合都可以
需要注意的是，Spring会在加载完配置文件之后就帮我们初始化配置文件中所有的bean，而不是在我们获取的时候才会去初始化。

set注入

最基本的方式

<bean id="human" class="com.jxw.pojo.Human" >
    <property name="name" value="jxw" />
</bean>

使用该方式会调用对象的set方法来给属性注入值，所以想这样配置的时候，属性必须要有set方法
如果使用如下方式配置，那么human实例的name属性的值将会是“jxw2”，因为property标签是调用set方法赋值，那么在调用之前必然是先创建一个实例，实例创建的时候constructor-arg标签指定了构造函数的赋值，不难理解property标签必然会覆盖掉构造函数赋的值

<bean id="human" class="com.jxw.pojo.Human" >
	<constructor-arg name="name" value="jxw" />
    <property name="name" value="jxw2" />
</bean>

Spring配置

别名

<alias name="human" alias="human2"/>

给配置好的bean指定别名，name为已经配置过的bean的id，allias为别名
这里我给human指定别名为human2，在我获取对象的时候使用human和human2都可以获取到human这个bean

Bean的配置

<bean id="human" class="com.jxw.pojo.Human" name="human3 human4,human5;human6">
    <constructor-arg name="name" value="jxw" />
    <constructor-arg name="age" value="25" />
    <property name="name" value="大帅比" />
</bean>
  • id：bean的唯一标识，相当于对象名
  • class：指定bean所对应对象的全限定名：包名 + 类名
  • name：指定别名，跟alias作用一样，而且更灵活，可以同时指定多个别名，可以使用空格、逗号、分号进行分割，而且可以混合使用
  • constructor-arg： 构造函数的参数，前面写了就不多介绍了
  • property：会调用set方法进行赋值，使用该标签赋值的时候一定要实现属性的set方法

import

一般用于团队开发使用，可以引入其他配置文件，将多个配置文件合并成为一个
新建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-3.0.xsd">

    <import resource="beans.xml"/>
    <import resource="beans2.xml"/>
</beans>

这里的improt将beans和beans2合并到一起，在使用ClassPathXmlApplicationContext对象的时候，直接获取applicationContext.xml文件的配置就能获取到beans和beans2的文件的配置，假如beans和benas2中有重复的配置，Spring还会帮我们去重

c命名空间注入和p命名空间注入

必须先引入约束
在这里插入图片描述

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

使用方式

    <bean id="human" class="com.jxw.pojo.Human" 
    name="human3 human4,human5;human6" c:name="jxw" c:age="25" p:name="大帅比">
    </bean>

c和构造器参数的赋值标签一样的功能
p是property标签一样的功能，调用set方法赋值

bean常用的作用域

1.单例模式（Spring默认，如果不做特殊配置的话也是单例的）

<bean id="human" class="com.jxw.pojo.Human" scope="singleton">
</bean>

整个生命周期内该bean都是单例的
2.原型模式：每次从容器中get都创建新的bean

<bean id="human" class="com.jxw.pojo.Human" scope="prototype">
</bean>

bean的自动装配

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

在Spring中有三种装配方式
1.在xml中配置
2.在java代码中使用注解配置
3.隐式的自动装配bean【重要】

新建三个类

public class Cat {
    public void shout(){
        System.out.println("miao~");
    }
}
public class Dog {
    public void shout(){
        System.out.println("wang~");
    }
}
public class Person {
    private Cat cat;
    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;
    }
}

现在要给person的Cat和Dog属性赋值，使用如下配置方式会自动找到set方法来赋值

byName自动装配

<bean id="dog" class="com.jxw.pojo.Dog"></bean>
<bean id="cat" class="com.jxw.pojo.Cat"></bean>
<bean id="person" class="com.jxw.pojo.Person" p:name="jxw" autowire="byName"></bean>

使用该方法会根据属性的set方法名进行匹配完成自动装配，但是需要保证的是该id是唯一的，并且该bean的id要和set方法名后半部分一致

byType自动装配

<bean class="com.jxw.pojo.Dog"></bean>
<bean class="com.jxw.pojo.Cat"></bean>
<bean id="person" class="com.jxw.pojo.Person" p:name="jxw" autowire="byType"></bean>

使用该方法可以根据属性的类型来进行自动装配，同时被自动装配的bean可以没有id属性，但是需要注意的是，该bean的类型必须是唯一的，就是在配置文件中不可以有与其类型相同的bean，否则会产生冲突，同时person类中也只有一个该类型的属性才可以

使用注解完成自动装配

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

首先配置注解的支持

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

	<!-- 启用对注解的支持 -->
	<context:annotation-config/>

    <bean id="cat" class="com.jxw.pojo.Cat"/>
    <bean id="dog" class="com.jxw.pojo.Dog"/>
    <bean id="person" class="com.jxw.pojo.Person" p:name="jxw"/>
</beans>

注意beans的节点头部需要添加的context约束
修改Person类，在属性上面添加@Autowired注解，就会自动注入到Person类的实例中了，注解方式使用的是反射给属性赋值的，所以Person类的属性也不再需要set方法了，前提Person类和属性对象都在IOC容器中

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

    public Cat getCat() {
        return cat;
    }

    public Dog getDog() {
        return dog;
    }

    public String getName() {
        return name;
    }

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

required属性。注解required属性默认为true，表示该属性不可以为空，否则可以为空

 @Autowired(required = false)

@Autowired注解默认使用的注入方式为byName，当byName找不到的时候会使用byType来查找
当环境比较复杂，使单独的@Autowired方式获取不到的时候可以配合@Qualifier使用
@Qualifier注解，指定byName方式来获取

@Qualifier(value = "cat")

@Resource和@Autowired的区别

@Resource注解功能和@Autowired注解功能和使用方式一样，效率差一丢丢
区别

  • @Autowired默认通过byType来执行，当byType没办法实现的时候，会byName，可以配合@Qualifier注解使用，找不到不会报错
  • @Resource默认使用byName，当name不存在会使用byType，找不到会报错
  • 默认使用的顺序不同，一个报错一个不报错

使用注解开发

在Spring4之后，必须要保证AOP的包导入了
配置文件修改为自动扫描

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

    <!-- 启用对注解的支持 -->
    <context:annotation-config/>
    <!--启动自动扫描-->
    <context:component-scan base-package="com.jxw.*"/>
</beans>

创建java类

//该注解等同于<bean id="user" class="com.jxw.pojo.User"/>
@Component
public class User {
    @Value("jxw")
    private String name;

    public String getName() {
        return name;
    }

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

使用@Componet注解标识该对象为组件
@Value(“jxw”)为属性name注入值"jxw"，也可以给set方法添加该注解

@Component的衍生注解

  • dao @Repstory
  • service @Service
  • controller @Controller
    这四个注解的功能都是一样的，只不过为了标识当前类是哪一层的

@Scope注解

跟配置文件中的scope属性一样，配置bean的作用域的，该注解放在类上面

小结：

  • xml适用于任何场景，维护简单方便
  • 注解只能在当前类使用，维护相当复杂
    xml与注解的最佳实现
    xml维护bean的创建
    注解只负责属性的注入
    使用注解的时候必须开启注解的支持

@Configuration注解

public class User {
    //相当于property标签
    @Value("jxw")
    private String name;

    public String getName() {
        return name;
    }

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

//这个类也是放到Spring容器中托管，因为它本身也是一个@Component
//@Configuration代表这是一个配置类，和beans.xml作用一样
@Configuration
@ComponentScan("com.jxw.*")//配置自动扫描
@Import(JxwConfig2.class)//引入另一个配置类
class JxwConfiguration {

    //注册一个bean相当于之前在配置文件中的bean标签，方法名相当于id，返回值相当于class
    @Bean
    public User getUser(){
        return new User();//返回要注入的对象
    }
}

测试方法

@Test
public void configTest(){
   ApplicationContext context = new AnnotationConfigApplicationContext(JxwConfiguration.class);
   //getUser要和@Bean注解的方法名一样
   User user = context.getBean("getUser", User.class);

   System.out.println(user.getName());
}

@Bean

使用@Bean注解的方法，表示该方法会返回一个bean，然后将一个bean注入到容器中，方法名则等同于配置文件方式配置的id

@ComponentScan

当我们使用配置的方式想要使用注解的时候，我们需要额外去写一个开启注解支持的配置，而有了这个方法，我们终于可以零配置注入bean了
当使用@ComponentScan注解指定自动扫描的包，只需要配合使用@Component注解，就可以自动将bean注入到容器中，不再需要任何配置

代理模式

代理模式又分静态代理和动态代理，他们的优点基本是一样的

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  • 公共业务交给代理角色，实现了业务的分工
  • 公共业务发生扩展时，方便集中管理

静态代理的缺点

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

所以接下来我们就要引入动态代理

动态代理

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

我这里使用JDK动态代理实现一个代理
需要了解两个类，这两个类都在反射包下

  • Proxy 代理类
  • InvocationHandler 调用处理程序

AOP

面向切面编程
概念

  • Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
  • Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
  • Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
  • Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
  • Target（目标对象）：织入 Advice 的目标对象.。
  • Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程
    横切关注点：日志、安全、缓存、事务等

使用方式：

使用Spring的API接口实现

首先配置Maven依赖

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>
</dependencies>

必须引入aspectj的aspectjweaver织入包，不然就会报错
这让我想起了我毕业就职第一个公司的Paas平台，平台上有对象触发器功能，跟这个切面差不多，但其实更像serverless，我只需要在对象下面创建某种类型的触发器，触发器内实际是一个方法，编写该方法，便可以在请求之前、之后等时机修改请求的参数、过滤条件、返回值、甚至页面中的表格、操作列等
编写增强类，既然我觉得像那个触发器，那我这里肯定要试试在before里面修改参数的值，会不会带到真正执行的方法里面去

public class AfterLogAdvice implements AfterReturningAdvice {

    /**
     * return之后的方法
     * @param returnValue 返回值
     * @param method 方法
     * @param args 方法参数
     * @param target 执行的类的实例
     * @throws Throwable
     */
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        List<String> list = Stream.of(args).map(e->e.toString()).collect(Collectors.toList());
        String argsStr = String.join(",",list);
        System.out.println(target.getClass().getName() + "类的" + method.getName() + "方法执行完成了\n参数为:" + argsStr +"\n返回值为:" + returnValue);
    }
}

	/**
     * 在执行之前的增强
     * @param method 执行的方法
     * @param args 参数
     * @param target 目标对象	
     * @throws Throwable
     */
public class BeforeLogAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println();
        List<String> list = Stream.of(args).map(e->e.toString()).collect(Collectors.toList());
        String argsStr = String.join(",",list);
        System.out.println(target.getClass().getName() + "类的" + method.getName() + "方法准备执行了\n参数为:" + argsStr);
        //修改参数看看能否生效
        args[0] = 15;
    }
}

/**
 * 定义接口
 */
public interface UserService {

    String getUser(Integer id);
    String deleteUser(Integer id);
    String addUser(Integer id, String name);
    String updateUser(Integer id, String name);
}

/**
 * 实现类
 */
public class UserServiceImpl implements UserService {

    public String getUser(Integer id) {
        return id.toString();
    }

    public String deleteUser(Integer id) {
        return id.toString();
    }

    public String addUser(Integer id, String name) {
        return id + ":" + name;
    }

    public String updateUser(Integer id, String name) {
        return id + ":" + name;
    }
}

还差最后一步，就是把增强环绕配置到切面上，配置文件如下，文件头需要引入aop的约束

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

    <!--注册bean-->
    <bean id="userService" class="com.jxw.service.UserServiceImpl"/>
    <bean id="after" class="com.jxw.advice.AfterLogAdvice"/>
    <bean id="before" class="com.jxw.advice.BeforeLogAdvice"/>
    <!--配置切面，使用Spring原生方式-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.jxw.service.UserService.*(..))"/>
        <!--配置切入点-->
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

测试方法：

@Test
public void TestAdvice(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = context.getBean("userService2", UserService.class);
    userService.addUser(1,"aa");
}

运行结果：
在这里插入图片描述
从运行结果可以看出，在before里面修改的参数值确实带到后面了，而且配置切入点的时候，表达式中配置某个接口的话，他所有的实现类都会被切

自定义实现AOP

定义增强类

public class DiyAdvice {
    public void after(){
        System.out.println("===========方法执行后=============");
    }
    public void before(){
        System.out.println("===========方法执行前=============");
    }
}

UserService还是用上面定义的
然后配置切面，切入点等信息

<bean id="diy" class="com.jxw.diy.DiyAdvice"/>
<aop:config>
    <!--指定增强类-->
    <aop:aspect ref="diy">
        <!--指定切入点-->
        <aop:pointcut id="point" expression="execution(* com.jxw.service.UserService.*(..))"/>
        <!--指定切入点和在切入点执行的方法-->
        <aop:after method="before" pointcut-ref="point"/>
        <aop:before method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

测试方法：

@Test
public void TestDiyAdvice(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.addUser(1,"aa");
}

运行结果：
在这里插入图片描述
这种方式执行显然没有使用Spring的API强大，没有办法获取方法、参数、目标实例、返回值等信息，自然也就没有办法对这些东西进行操作，但是胜在简单

使用注解实现AOP

定义切面类
使用@Aspect标记该类为切面增强类
使用@After、@Before、@Around等注解来标记方法，并且需要在注解的参数传入切入点的表达式

/**
 *定义切面
 */
@Aspect   //标记该类是增强类
public class AnnotationAdvice {


    @Before("execution(* com.jxw.service.UserService.*(..))")
    public void before(){
        System.out.println("===========方法执行前=============");
    }

    @After("execution(* com.jxw.service.UserService.*(..))")
    public void after(){
        System.out.println("===========方法执行前=============");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.jxw.service.UserService.*(..))")
    public void Around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("===========环绕方法执行前=============");
        //该参数可以获取到方法执行所需的绝大多数信息，proceed方法为执行目标方法
        jp.proceed(jp.getArgs());
        System.out.println("===========环绕方法执行后=============");
    }
}

然后需要注入切面增强类，并且开启注解支持

<bean id="annoAdvice" class="com.jxw.advice.AnnotationAdvice"/>
<!--开启切面的注解支持-->
<aop:aspectj-autoproxy/>

UserService还是用上面的
测试方法

@Test
public void TestAnnoAdvice(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.addUser(1,"aa");
}

执行结果：
在这里插入图片描述
从结果可以看出执行顺序是：
Around中方法执行前的代码–>Before–>Around中方法执行后的代码–>After

声明式事务

因为可以配置AOP，所以事务也可以做到声明式事务
Spring支持两种事务管理方式

  • 声明式事务：AOP
  • 编程式事务：需要在代码中进行事务的管理

下面写一个声明式事务的例子
1）使用事务的话肯定要将某个ORM框架整合到Spring中，当然你乐意的话使用原生的JDBC也行，我这里使用Mybatis，所以先引入maven依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.10</version>
</dependency>
<dependency>
	<groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.17</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.4</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.4</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

2）配置Spring的配置文件

<?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:context="http://www.springframework.org/schema/context"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans    
                        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd    
                        http://www.springframework.org/schema/context    
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/aop 
                        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
                        http://www.springframework.org/schema/tx 
                        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd    
                        http://www.springframework.org/schema/mvc    
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">  
    
    <!--配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/MybatisStudy?useSSL=true&amp;autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=UTF8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    
	<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->  
	<bean id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
	    <property name="dataSource" ref="dataSource" />  
	</bean>  
	 <!-- 通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- 切面 -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice"
			pointcut="execution(* com.running.business.service.*.*(..))" />
	</aop:config>
</beans>
  • DataSourceTransactionManager 就是Spring的事务管理器，我们需要将其注入到IOC中
  • tx:advice 是事务管理的通知，把事务管理器配置到transaction-manager属性上
    • tx:attributes 中配置事务的各种行为
      • tx:method
        • name 属性表示要管理的方法，可以用 * 通配符
        • propagation 属性配置事物的传播行为
        • read-only 表示该方法是只可以读的，不可以增删改
  • 最后把通知配置到切面上就可以了

Spring事务的传播行为

spring事务的传播行为说的是，当多个事务同时存在的时候，spring如何处理这些事务的行为。
Spring内置了七种事务传播行为，他们分别是

  • REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。

  • SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。‘

  • MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

  • REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。

  • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

  • NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

  • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则按REQUIRED属性执行。

Spring笔记5--Spring配置
weixin_47324424的博客
07-07 119
5、Spring配置 1.别名 alias alias 设置别名 , 为bean设置别名 , 可以设置多个别名 <!--设置别名：在获取Bean的时候可以使用别名获取--> <alias name="userT" alias="userNew"/> 2、Bean的配置 <!--bean就是java对象,由Spring创建和管理--> <!-- id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符 如果配置id,
Spring5-Spring的基本配置
weixin_49512993的博客
09-08 371
文章目录Spring5-Spring的基本配置三、Spring的基本配置1、别名2、Bean的配置3、import四、依赖注入1、构造器注入2、set方式注入（重点）依赖注入环境搭建3、扩展方式注入4、bean作用域单例模式(Spring默认机制)原型模式（每次从容器中get的时候都会产生一个新对象）其他模式 Spring5-Spring的基本配置 三、Spring的基本配置 1、别名 <!--别名，起了别名可以通过别名来获取对象--> <alias name="user"
Spring 学习笔记(一)：Spring 框架简介及 IDEA 配置
最新发布
qq_71946662的博客
04-24 2043
刚刚开始 Spring 框架，记录一下学到的东西和遇到的问题
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring Cloud Alibaba - 学习笔记 - Nacos配置
灵台方寸山斜月三星洞
02-27 3953
Spring Cloud Alibaba - 学习笔记 - 配置文件配置文件默认优先级常规用法参考资料 配置文件默认优先级 线上的配置优先级最高。 先加载 bootstrap 后加载 application 优先级 配置 Top 1 nacos上：${spring.application.name}-${profile}.${file-extension:properties} Top 2 application.properties Top 3 application.yml
Spring5笔记.zip
08-26
虽非Spring5的一部分，但Spring Boot与Spring5紧密相关，它简化了Spring应用的初始化和配置。Spring Boot 2.x版本已经默认集成了Spring5，提供了快速开发现代Web应用的能力。 5. **Spring MVC**： Spring5对...
编程不良人的SpringCloud笔记和资料，全套
06-21
Spring Cloud Gateway是SpringCloud的新一代API网关，基于Spring Framework 5、Project Reactor和Spring Boot 2.x构建，提供更高级的路由功能以及过滤器链的处理。 10. **Spring Cloud Sleuth追踪** Sleuth是一个...
尚硅谷spring5视频笔记.zip
04-21
《尚硅谷spring5视频笔记》是一份详尽的Spring框架第五版的学习资料，它涵盖了Spring 5的关键概念、新特性和实战应用。Spring是Java领域中最流行的企业级应用框架之一，Spring 5作为其最新版本，引入了许多重要的...
Spring5-尚硅谷框架课堂笔记.rar
08-10
《Spring5 尚硅谷框架课堂笔记》是一份深入解析 Spring 框架的珍贵资料，主要针对 Spring 5 版本进行了详尽的讲解。Spring 是一个开源的 Java 应用程序框架，它以 IoC（Inversion of Control，控制反转）和 AOP...
Spring学习笔记之RedisTemplate的配置与使用教程
08-27
以上就是Spring中配置和使用RedisTemplate的基本步骤。RedisTemplate提供了诸如`opsForValue()`、`opsForHash()`等方法，分别对应不同的数据结构操作。通过这些方法，我们可以方便地与Redis进行交互，而无需关心底层...
ubuntu18.04设置静态ip地址（简单版）个人学习使用
qq_34912889的博客
06-30 1975
声明：我是个人电脑的学习及使用 前提：为了创建nacos集群，我创建了多台虚拟机，因为nacos集群需要配置各台服务器的ip，如果不设置静态ip，每次重启都会造成ip地址的改变，所以我需要设置一下静态IP，防止重启后需要修改配置的问题 配置静态ip前需要先知道几个东西 网关、dns、子网掩码、网卡名 dns我就用了谷歌的，因为 8.8.8.8 太好记了 网关的查看方法：route -n Gateway下面圈起来的就是网关地址，Genmask下面第二行是子网掩码，我的是255.255.255.0，也就是24位
Maven笔记（从配置仓库开始）
qq_34912889的博客
03-23 994
下载，环境变量配置跳过 首先设置\conf\settings.xml文件 配置本地仓库位置 <localRepository> D:/repo </localRepository> 配置阿里云的源 <mirror> <id>aliyunmaven</id> <mirrorOf>*</mirr...
MyBatis入门(从零到一)
qq_34912889的博客
04-09 676
文章目录MyBatis官方文档地址实际操作可能会遇见的问题引入MyBatis依赖CURD各写一遍使用map参数类型配置解析核心配置文件环境变量配置（properties）类型别名（typeAliases）映射器（mappers） MyBatis官方文档地址 https://mybatis.org/mybatis-3/zh/index.html 实际操作可能会遇见的问题 1.配置文件没有注册 2.绑...
Sentinel笔记（五）@SentinelResource注解
qq_34912889的博客
07-05 525
如何在项目中添加Sentinel的支持请看这里 Sentinel笔记（一）第一个监控实例 文章目录系统自适应限流注解 系统自适应限流 这个没啥东西就放在这个位置了，除了自适应和CPU占用率，都和之前的限流规则一样，只不过是使用范围覆盖了整个服务的所有资源 官方文档 系统保护规则是从应用级别的入口流量进行控制，从单台机器的 load、CPU 使用率、平均 RT、入口 QPS 和并发线程数等几个维度监控应用指标，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。 系统保护规则是应用整体维度的，而不是资源维
nacos笔记（一）单机版
qq_34912889的博客
06-28 484
文章目录linux下安装启动 linux下安装 我的环境是ubuntu18.04，JDK1.8 nacos中文官网 nacos的github下载地址 将下载好的文件放到 /usr/local/ 下 使用命令tar -zxvf nacos-server-1.3.0.tar.gz解压 启动 解压出文件夹nacos进入/usr/local/nacos/bin目录 使用bash -f ./startup.sh -m standalone 命令启动单机版nacos 出现以上提示表示启动成功，不放心的话可以查看最
Sentinel笔记（二）流量监控
qq_34912889的博客
07-03 408
文章目录流量监控规则添加流控规则两种方式创建第一个流控规则测试一下 流量监控规则 资源名：唯一名称，默认请求路径 针对来源：Sentinel可以针对调用者进行限流，填写微服务名，指定对哪个微服务进行限流 ，默认default(不区分来源，全部限制) 阈值类型/单机阈值： QPS(每秒钟的请求数量)：当调用该接口的QPS达到了阈值的时候，进行限流； 线程数：当调用该接口的线程数达到阈值时，进行限流 是否集群：不需要集群 流控模式： 直接：接口达到限流条件时，直接限流 关联：当关联的资源达到阈值时，就
SpringBoot笔记（一）————第一个SpringBoot项目
qq_34912889的博客
04-16 378
文章目录SSM基础第一个SpringBoot项目（Maven）使用官网构建（目前Eclipse只能用官网构建）使用IDEA构建（其实也是内置的官网链接）解决Maven下载太慢启动！写个controller试试约定大于配置 SSM基础 学习SpringBoot之前必须要熟悉Spring，SpingBoot不是一个完全重新写的东西，他是基于Spring来开发的，有很多默认的配置由SpringBoot为...
Sentinel笔记（三）降级规则
qq_34912889的博客
07-03 356
如何在项目中添加Sentinel的支持请看这里 Sentinel笔记（一）第一个监控实例 文章目录概述降级规则RT（平均响应时间）异常比例异常数 概述 官网 官网截图 在降级规则菜单内可以添加降级规则 简单解释： RT（平均响应时间，秒级） 平均响应时间 超出阈值 且 在时间窗口内通过的请求 >= 5，两个条件同时满足后触发降级 窗口期过后关闭断路器 RT默认最大4900ms，若需要变更此上限可以通过启动配置项 -Dcsp.sentinel.statistic.max.rt=xxx 来配置。
nacos笔记（四）集群与持久化
qq_34912889的博客
06-30 257
文章目录使用Mysql持久化集群配置 使用Mysql持久化 mysql的安装过程就不介绍了，版本用的是5.7.29，系统ubuntu18.04 Nacos 使用的是1.3.0版本 官方文档介绍 linux下nacos安装过程：nacos笔记（一）单机版 要使用mysql来存数据，那么肯定需要有一个数据库和相应的表，获取数据库脚本有两种途径 从官方文档提供的github地址 sql语句源文件 从自己解压出的nacos文件夹下找到 conf/nacos-mysql.sql 文件 我是用的解压出来的文件，
Spring入门：配置与Bean实例详解
"韩顺平的Spring笔记提供了一个深入浅出的入门指南，主要讲解了Spring框架的基础概念、配置方法以及应用过程。Spring是一个广泛应用于企业级Java应用程序的轻量级I/O（IoC）容器框架，它简化了组件之间的依赖管理和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值