Spring全注解个人见解
xml核心配置文件是beans.xml，那么用于注解开发，class类中标注@Configuration则意为一个配置
配置文件中使用的bean标签，可以对应为class类上的@Component注解，这也可以在被@Configuration标注的配置类中使用@Bean来标识
我们可以通过@PropertySource注解来引用我们的properties文件来进行一个set注入，语法@Value(${*})
注入其他的Bean，我们可以使用@Autowired来进行一个手动的自动注入，这项功能在调用同一个配置类中的Bean时可以被省略，直接使用形参进行接收从而实现一个自动注入的功能
配置类太过于冗余？使用@Import来进行引入其他的@Configuration，让主配置类干净整洁，只需要使用@ComponentScan和@Import注解即可，子配置类可不使用@ComponentScan注解
测试Spring的注解
JUnit4可以这样使用@ExtendWith*(SpringExtension.class )和@ContextConfiguration*(classes = {SpringConfig.class})结合
JUnit5则要简单许多*@SpringJUnitConfig*(classes = {SpringConfig.class })
1. 外部注入properties文件
jdbc.properties
jdbc.user =root jdbc.password =root jdbc.url =jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false jdbc.driver =com.mysql.cj.jdbc.Driver
注入类
package com.bamboo.spring;import lombok.Data;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.PropertySource;import org.springframework.stereotype.Repository;@Repository @Data @PropertySource("classpath:jdbc.properties") public class JdbcProperties { @Value("${jdbc.user}") private String username; @Value("${jdbc.password}") private String password; @Value("${jdbc.url}") private String url; @Value("${jdbc.driver}") private String driverClassName; }
2. 方式1【单@Configuration配置】 package com.bamboo.spring.config;import com.alibaba.druid.pool.DruidDataSource;import com.bamboo.spring.JdbcProperties;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Import;import org.springframework.jdbc.core.JdbcTemplate;import javax.sql.DataSource;@Configuration @ComponentScan("com.bamboo.spring") public class SpringConfig { @Autowired private JdbcProperties jdbcProperties; @Bean public DataSource getDruidDataSource () { DruidDataSource dataSource = new DruidDataSource (); dataSource.setUrl(jdbcProperties.getUrl()); dataSource.setDriverClassName(jdbcProperties.getDriverClassName()); dataSource.setUsername(jdbcProperties.getUsername()); dataSource.setPassword(jdbcProperties.getPassword()); return dataSource; } @Bean public JdbcTemplate jdbcTemplate (DataSource dataSource) { return new JdbcTemplate (dataSource); } }
3. 方式2【@Import集合多@Configuration配置】
主配置类
package com.bamboo.spring.config;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Import;@Configuration @ComponentScan("com.bamboo.spring") @Import(value = {DruidDataSourceConfig.class, JdbcTemplateConfig.class}) public class SpringConfig {}
从配置类1：DruidDataSource
package com.bamboo.spring.config;import com.alibaba.druid.pool.DruidDataSource;import com.bamboo.spring.JdbcProperties;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration public class DruidDataSourceConfig { @Autowired private JdbcProperties jdbcProperties; @Bean public DataSource getDruidDataSource () { DruidDataSource dataSource = new DruidDataSource (); dataSource.setUrl(jdbcProperties.getUrl()); dataSource.setDriverClassName(jdbcProperties.getDriverClassName()); dataSource.setUsername(jdbcProperties.getUsername()); dataSource.setPassword(jdbcProperties.getPassword()); return dataSource; } }
从配置类2：JdbcTemplate
package com.bamboo.spring.config;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.jdbc.core.JdbcTemplate;import javax.sql.DataSource;@Configuration public class JdbcTemplateConfig { @Autowired private DataSource dataSource; @Bean public JdbcTemplate jdbcTemplate () { return new JdbcTemplate (this .dataSource); } }
4. 统一测试 package com.bamboo.spring;import com.bamboo.spring.config.SpringConfig;import com.bamboo.spring.pojo.Emp;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.BeanPropertyRowMapper;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(classes = {SpringConfig.class}) public class JdbcTemplateTest { @Autowired private JdbcTemplate jdbcTemplate; @Test public void testUpdate () { String sql = "insert into t_emp values(null,?,?,?)" ; int result = jdbcTemplate.update(sql, "张三" , 23 , "男" ); System.out.println(result); } @Test public void testSelectObject () { String sql = "select * from t_emp where id=?" ; Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper <>(Emp.class),1 ); System.out.println(emp); } }
一、环境要求
二、基础依赖 <dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-context</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > <version > 5.3.1</version > </dependency > </dependencies >
三、Log4j2日志框架 Log4j2主要由几个重要的组件构成：
（1）日志信息的优先级 ，日志信息的优先级从高到低有TRACE < DEBUG < INFO < WARN < ERROR < FATAL
这些级别分别用来指定这条日志信息的重要程度；级别高的会自动屏蔽级别低的日志，也就是说，设置了WARN的日志，则INFO、DEBUG的日志级别的日志不会显示
（2）日志信息的输出目的地 ，日志信息的输出目的地指定了日志将打印到控制台 还是文件中 ；
（3）日志信息的输出格式 ，而输出格式则控制了日志信息的显示内容。
1. 引入Log4j2依赖 <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-core</artifactId > <version > 2.19.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-slf4j2-impl</artifactId > <version > 2.19.0</version > </dependency >
2. 加入日志配置文件 在类的根路径下提供log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下。
<?xml version="1.0" encoding="UTF-8" ?> <configuration > <loggers > <root level ="DEBUG" > <appender-ref ref ="spring6log" /> <appender-ref ref ="RollingFile" /> <appender-ref ref ="log" /> </root > </loggers > <appenders > <console name ="spring6log" target ="SYSTEM_OUT" > <PatternLayout pattern ="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n" /> </console > <File name ="log" fileName ="d:/spring6_log/test.log" append ="false" > <PatternLayout pattern ="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n" /> </File > <RollingFile name ="RollingFile" fileName ="d:/spring6_log/app.log" filePattern ="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz" > <PatternLayout pattern ="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n" /> <SizeBasedTriggeringPolicy size ="50MB" /> <DefaultRolloverStrategy max ="20" /> </RollingFile > </appenders > </configuration >
3. 程序中使用日志 public class HelloWorldTest { private Logger logger = LoggerFactory.getLogger(HelloWorldTest.class); @Test public void testHelloWorld () { ApplicationContext ac = new ClassPathXmlApplicationContext ("beans.xml" ); HelloWorld helloworld = (HelloWorld) ac.getBean("helloWorld" ); helloworld.sayHello(); logger.info("执行成功" ); } }
四、基于XML管理Bean 1. 环境搭建 1. 引入配置文件 beans.xml、log4j2.xml
2. 添加依赖 <dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-context</artifactId > <version > 6.0.3</version > </dependency > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > <version > 5.3.1</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-core</artifactId > <version > 2.19.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-slf4j2-impl</artifactId > <version > 2.19.0</version > </dependency > </dependencies >
注：根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个
2. 依赖注入 2.1 DI: set注入 <bean id ="studentOne" class ="com.atguigu.spring6.bean.Student" > <property name ="id" value ="1001" > </property > <property name ="name" value ="张三" > </property > <property name ="age" value ="23" > </property > <property name ="sex" value ="男" > </property > </bean >
2.2 DI: 构造器注入 <bean id ="studentTwo" class ="com.atguigu.spring6.bean.Student" > <constructor-arg value ="1002" > </constructor-arg > <constructor-arg value ="李四" > </constructor-arg > <constructor-arg value ="33" > </constructor-arg > <constructor-arg value ="女" > </constructor-arg > </bean >
注意：constructor-arg标签还有两个属性可以进一步描述构造器参数：
index属性：指定参数所在位置的索引（从0开始）
name属性：指定参数名
3. 特殊值处理 null值 <property name ="name" > <null /> </property >
xml实体 <property name ="expression" value ="a < b" />
CDATA节 <property name ="expression" > <value > <![CDATA[a < b]]></value > </property >
4. 引入外部属性文件 1. 加入依赖 <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 8.0.30</version > </dependency > <dependency > <groupId > com.alibaba</groupId > <artifactId > druid</artifactId > <version > 1.2.15</version > </dependency >
2. 创建外部属性文件 jdbc.properties
jdbc.user =root jdbc.password =atguigu jdbc.url =jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC jdbc.driver =com.mysql.cj.jdbc.Driver
3. 引入属性文件 <?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 http://www.springframework.org/schema/context/spring-context.xsd" > <context:property-placeholder location ="classpath:jdbc.properties" /> <bean id ="druidDataSource" class ="com.alibaba.druid.pool.DruidDataSource" > <property name ="url" value ="${jdbc.url}" /> <property name ="driverClassName" value ="${jdbc.driver}" /> <property name ="username" value ="${jdbc.user}" /> <property name ="password" value ="${jdbc.password}" /> </bean > </beans >
4. 测试 @Test public void testDataSource () throws SQLException { ApplicationContext ac = new ClassPathXmlApplicationContext ("spring-datasource.xml" ); DataSource dataSource = ac.getBean(DataSource.class); Connection connection = dataSource.getConnection(); System.out.println(connection); }
5. xml自动装配 <bean id ="userController" class ="com.atguigu.spring6.autowire.controller.UserController" autowire ="byType" > </bean > <bean id ="userService" class ="com.atguigu.spring6.autowire.service.impl.UserServiceImpl" autowire ="byType" > </bean > <bean id ="userDao" class ="com.atguigu.spring6.autowire.dao.impl.UserDaoImpl" > </bean >
五、基于注解管理Bean【重点】 Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。
Spring 通过注解实现自动装配的步骤如下：
引入依赖
开启组件扫描
使用注解定义 Bean
依赖注入
1. 环境搭建 1.1 建模块 搭建方式如：spring6-ioc-xml
1.2 引入配置文件 引入spring-ioc-xml模块日志log4j2.xml
1.3 添加依赖 <dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-context</artifactId > <version > 6.0.3</version > </dependency > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-core</artifactId > <version > 2.19.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-slf4j2-impl</artifactId > <version > 2.19.0</version > </dependency > </dependencies >
2. 开启组件扫描 Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。
<?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-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" > <context:component-scan base-package ="com.atguigu.spring6" > </context:component-scan > </beans >
注意：在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 中添加 context 相关的约束。
情况一：最基本的扫描方式
<context:component-scan base-package ="com.atguigu.spring6" > </context:component-scan >
情况二：指定要排除的组件
<context:component-scan base-package ="com.atguigu.spring6" > <context:exclude-filter type ="annotation" expression ="org.springframework.stereotype.Controller" /> </context:component-scan >
情况三：仅扫描指定组件
<context:component-scan base-package ="com.atguigu" use-default-filters ="false" > <context:include-filter type ="annotation" expression ="org.springframework.stereotype.Controller" /> </context:component-scan >
3. 使用注解定义 Bean Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。
相当于
<bean id ="userBean" class ="com.bamboo.pojo.User" > </bean >
注解
说明
@Component
该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。
@Repository
该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service
该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller
该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
4. @Autowired注入 单独使用@Autowired注解，默认根据类型装配 。【默认是byType】
4.1 源码分析 package org.springframework.beans.factory.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Autowired { boolean required () default true ; }
源码中有两处需要注意：
4.2 简单案例
UserDao接口
package com.atguigu.spring6.dao;public interface UserDao { public void print () ; }
创建UserDaoImpl实现
package com.atguigu.spring6.dao.impl;import com.atguigu.spring6.dao.UserDao;import org.springframework.stereotype.Repository;@Repository public class UserDaoImpl implements UserDao { @Override public void print () { System.out.println("Dao层执行结束" ); } }
创建UserService接口
package com.atguigu.spring6.service;public interface UserService { public void out () ; }
创建UserServiceImpl实现类
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
创建UserController类
package com.atguigu.spring6.controller;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;@Controller public class UserController { @Autowired private UserService userService; public void out () { userService.out(); System.out.println("Controller层执行结束。" ); } }
测试
package com.atguigu.spring6.bean;import com.atguigu.spring6.controller.UserController;import org.junit.jupiter.api.Test;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class UserTest { private Logger logger = LoggerFactory.getLogger(UserTest.class); @Test public void testAnnotation () { ApplicationContext context = new ClassPathXmlApplicationContext ("Beans.xml" ); UserController userController = context.getBean("userController" , UserController.class); userController.out(); logger.info("执行成功" ); } }
4.3 注入方式
属性注入
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao; @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
set注入
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { private UserDao userDao; @Autowired public void setUserDao (UserDao userDao) { this .userDao = userDao; } @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
构造方法注入
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { private UserDao userDao; @Autowired public UserServiceImpl (UserDao userDao) { this .userDao = userDao; } @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
形参注入
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { private UserDao userDao; public UserServiceImpl (@Autowired UserDao userDao) { this .userDao = userDao; } @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
只有一个构造函数，无注解
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { private UserDao userDao; public UserServiceImpl (UserDao userDao) { this .userDao = userDao; } @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
当有参数的构造方法只有一个时，@Autowired注解可以省略。
说明：有多个构造方法时呢？大家可以测试（再添加一个无参构造函数），测试报错
@Autowired注解和@Qualifier注解联合
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { @Autowired @Qualifier("userDaoImpl") private UserDao userDao; @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
总结
@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。
当带参数的构造方法只有一个，@Autowired注解可以省略。（）
@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。
5. @Resource注入 @Resource注解也可以完成属性注入。那它和@Autowired注解有什么区别？
@Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
@Autowired注解是Spring框架自己的。
@Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。 @Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。 @Resource注解用在属性上、setter方法上。
@Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。
@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。 】
<dependency > <groupId > jakarta.annotation</groupId > <artifactId > jakarta.annotation-api</artifactId > <version > 2.1.1</version > </dependency >
源码：
package jakarta.annotation;import java.lang.annotation.ElementType;import java.lang.annotation.Repeatable;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Repeatable(Resources.class) public @interface Resource { String name () default "" ; String lookup () default "" ; Class<?> type() default Object.class; Resource.AuthenticationType authenticationType () default Resource.AuthenticationType.CONTAINER; boolean shareable () default true ; String mappedName () default "" ; String description () default "" ; public static enum AuthenticationType { CONTAINER, APPLICATION; private AuthenticationType () { } } }
5.1 name注入 package com.atguigu.spring6.dao.impl;import com.atguigu.spring6.dao.UserDao;import org.springframework.stereotype.Repository;@Repository("myUserDao") public class UserDaoImpl implements UserDao { @Override public void print () { System.out.println("Dao层执行结束" ); } }
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import jakarta.annotation.Resource;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { @Resource(name = "myUserDao") private UserDao myUserDao; @Override public void out () { myUserDao.print(); System.out.println("Service层执行结束" ); } }
5.2 name未知注入 package com.atguigu.spring6.dao.impl;import com.atguigu.spring6.dao.UserDao;import org.springframework.stereotype.Repository;@Repository("myUserDao") public class UserDaoImpl implements UserDao { @Override public void print () { System.out.println("Dao层执行结束" ); } }
package com.atguigu.spring6.service.impl;import com.atguigu.spring6.dao.UserDao;import com.atguigu.spring6.service.UserService;import jakarta.annotation.Resource;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Service;@Service public class UserServiceImpl implements UserService { @Resource private UserDao myUserDao; @Override public void out () { myUserDao.print(); System.out.println("Service层执行结束" ); } }
当@Resource注解使用时没有指定name的时候，还是根据name进行查找，这个name是属性名。
总结：
@Resource注解：默认byName注入，没有指定name时把属性名当做name，根据name找不到时，才会byType注入。byType注入时，某种类型的Bean只能有一个
六、Spring全注解开发 全注解开发就是不再使用spring配置文件了，写一个配置类来代替配置文件。
package com.atguigu.spring6.config;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;@Configuration @ComponentScan("com.atguigu.spring6") public class Spring6Config {}
测试类
@Test public void testAllAnnotation () { ApplicationContext context = new AnnotationConfigApplicationContext (Spring6Config.class); UserController userController = context.getBean("userController" , UserController.class); userController.out(); logger.info("执行成功" ); }
七、原理——手写IOC 1. 回顾反射
Car类
package com.bamboo.reflect;public class Car { private String name; private int age; private String color; public Car () { } public Car (String name, int age, String color) { this .name = name; this .age = age; this .color = color; } private void run () { System.out.println("私有方法-run....." ); } 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; } public String getColor () { return color; } public void setColor (String color) { this .color = color; } @Override public String toString () { return "Car{" + "name='" + name + '\'' + ", age=" + age + ", color='" + color + '\'' + '}' ; } }
测试反射类
import com.bamboo.reflect.Car;import org.junit.jupiter.api.Test;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;public class TestCar { @Test public void test01 () throws Exception { Class clazz1 = Car.class; Class clazz2 = new Car ().getClass(); Class clazz3 = Class.forName("com.bamboo.reflect.Car" ); Car car = (Car)clazz3.getConstructor().newInstance(); System.out.println(car); } @Test public void test02 () throws Exception { Class clazz = Car.class; Constructor[] constructors = clazz.getDeclaredConstructors(); for (Constructor c:constructors) { System.out.println(c); System.out.println("方法名称：" +c.getName()+" 参数个数：" +c.getParameterCount()); } Constructor c2 = clazz.getDeclaredConstructor(String.class, int .class, String.class); c2.setAccessible(true ); Car car2 = (Car)c2.newInstance("捷达" , 15 , "白色" ); System.out.println(car2); } @Test public void test03 () throws Exception { Class clazz = Car.class; Car car = (Car)clazz.getDeclaredConstructor().newInstance(); Field[] fields = clazz.getDeclaredFields(); for (Field field:fields) { if (field.getName().equals("name" )) { field.setAccessible(true ); field.set(car,"五菱宏光" ); System.out.println(car); } System.out.println(field.getName()); } } @Test public void test04 () throws Exception { Car car = new Car ("奔驰" ,10 ,"黑色" ); Class clazz = car.getClass(); Method[] methods = clazz.getMethods(); for (Method m1:methods) { if (m1.getName().equals("toString" )) { String invoke = (String)m1.invoke(car); } } Method[] methodsAll = clazz.getDeclaredMethods(); for (Method m:methodsAll) { if (m.getName().equals("run" )) { m.setAccessible(true ); m.invoke(car); } } } }
2. 实现SpringIOC 2.1 搭建module 2.2 添加测试依赖 <dependencies > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > <version > 5.3.1</version > </dependency > </dependencies >
2.3 基本数据导入
UserDao
package com.bamboo.dao;public interface UserDao { public void print () ; }
UserDaoImpl
package com.bamboo.dao.impl;import com.bamboo.core.annotation.Bean;import com.bamboo.dao.UserDao;@Bean public class UserDaoImpl implements UserDao { @Override public void print () { System.out.println("Dao层执行结束" ); } }
UserService
package com.bamboo.service;public interface UserService { public void out () ; }
UserServiceImpl
package com.bamboo.service.impl;import com.bamboo.core.annotation.Bean;import com.bamboo.core.annotation.Di;import com.bamboo.dao.UserDao;import com.bamboo.service.UserService;@Bean public class UserServiceImpl implements UserService { @Di private UserDao userDao; @Override public void out () { userDao.print(); System.out.println("Service层执行结束" ); } }
2.4 手写注解
Bean注解
package com.bamboo.core.annotation;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Bean {}
Di注解
package com.bamboo.core.annotation;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface Di {}
2.5 手写ApplicationContext容器
ApplicationContext接口
package com.bamboo.core;public interface ApplicationContext { Object getBean (Class clazz) ; }
AnnotationApplicationContext实现类
package com.bamboo.core;import com.bamboo.core.annotation.Bean;import com.bamboo.core.annotation.Di;import java.io.File;import java.lang.reflect.Field;import java.net.URL;import java.net.URLDecoder;import java.util.Enumeration;import java.util.HashMap;import java.util.Map;public class AnnotationApplicationContext implements ApplicationContext { private HashMap<Class, Object> beanFactory = new HashMap <>(); private static String rootPath; @Override public Object getBean (Class clazz) { return beanFactory.get(clazz); } public AnnotationApplicationContext (String basePackage) { try { String packageDirName = basePackage.replaceAll("\\." , "\\\\" ); Enumeration<URL> dirs =Thread.currentThread().getContextClassLoader().getResources(packageDirName); while (dirs.hasMoreElements()) { URL url = dirs.nextElement(); String filePath = URLDecoder.decode(url.getFile(),"utf-8" ); rootPath = filePath.substring(0 , filePath.length()-packageDirName.length()); loadBean(new File (filePath)); } } catch (Exception e) { throw new RuntimeException (e); } loadDi(); } private void loadBean (File fileParent) { if (fileParent.isDirectory()) { File[] childrenFiles = fileParent.listFiles(); if (childrenFiles == null || childrenFiles.length == 0 ){ return ; } for (File child : childrenFiles) { if (child.isDirectory()) { loadBean(child); } else { String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1 ); if (pathWithClass.contains(".class" )) { String fullName = pathWithClass.replaceAll("\\\\" , "." ).replace(".class" , "" ); try { Class<?> aClass = Class.forName(fullName); if (!aClass.isInterface()){ Bean annotation = aClass.getAnnotation(Bean.class); if (annotation != null ){ Object instance = aClass.newInstance(); if (aClass.getInterfaces().length > 0 ) { System.out.println("正在加载【" + aClass.getInterfaces()[0 ] +"】,实例对象是：" + instance.getClass().getName()); beanFactory.put(aClass.getInterfaces()[0 ], instance); }else { System.out.println("正在加载【" + aClass.getName() +"】,实例对象是：" + instance.getClass().getName()); beanFactory.put(aClass, instance); } } } } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) { e.printStackTrace(); } } } } } } private void loadDi () { for (Map.Entry<Class,Object> entry : beanFactory.entrySet()){ Object obj = entry.getValue(); Class<?> aClass = obj.getClass(); Field[] declaredFields = aClass.getDeclaredFields(); for (Field field : declaredFields){ Di annotation = field.getAnnotation(Di.class); if ( annotation != null ){ field.setAccessible(true ); try { System.out.println("正在给【" +obj.getClass().getName()+"】属性【" + field.getName() + "】注入值【" + beanFactory.get(field.getType()).getClass().getName() +"】" ); field.set(obj,beanFactory.get(field.getType())); } catch (IllegalAccessException e) { e.printStackTrace(); } } } } } }
2.6 IoC测试 package com.bamboo.test;import com.bamboo.core.AnnotationApplicationContext;import com.bamboo.core.ApplicationContext;import com.bamboo.service.UserService;import org.junit.jupiter.api.Test;public class SpringIocTest { @Test public void testIoc () { ApplicationContext applicationContext = new AnnotationApplicationContext ("com.bamboo" ); UserService userService = (UserService) applicationContext.getBean(UserService.class); userService.out(); System.out.println("run success" ); } }
八、面向切面：AOP 1. 代理模式 ①介绍
二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接 调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦 。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。
②相关术语
代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
目标：被代理“套用”了非核心逻辑代码的类、对象、方法。
1.1 静态代理 public class CalculatorStaticProxy implements Calculator { private Calculator target; public CalculatorStaticProxy (Calculator target) { this .target = target; } @Override public int add (int i, int j) { System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j); int addResult = target.add(i, j); System.out.println("[日志] add 方法结束了，结果是：" + addResult); return addResult; } }
静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。
提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。
1.2 动态代理 生产代理对象的工厂类
public class ProxyFactory { private Object target; public ProxyFactory (Object target) { this .target = target; } public Object getProxy () { ClassLoader classLoader = target.getClass().getClassLoader(); Class<?>[] interfaces = target.getClass().getInterfaces(); InvocationHandler invocationHandler = new InvocationHandler () { @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable { Object result = null ; try { System.out.println("[动态代理][日志] " +method.getName()+"，参数：" + Arrays.toString(args)); result = method.invoke(target, args); System.out.println("[动态代理][日志] " +method.getName()+"，结果：" + result); } catch (Exception e) { e.printStackTrace(); System.out.println("[动态代理][日志] " +method.getName()+"，异常：" +e.getMessage()); } finally { System.out.println("[动态代理][日志] " +method.getName()+"，方法执行完毕" ); } return result; } }; return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler); } }
1.3 测试代理 @Test public void testDynamicProxy () { ProxyFactory factory = new ProxyFactory (new CalculatorLogImpl ()); Calculator proxy = (Calculator) factory.getProxy(); proxy.div(1 ,0 ); }
2. AOP相关 2.1 概述 AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2.2 相关术语 ①横切关注点 分散在每个各个模块中解决同一样的问题，如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。
从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。
这个概念不是语法层面的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。
②通知（增强） 增强，通俗说，就是你想要增强的功能，比如 安全，事务，日志等。
每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。
前置通知：在被代理的目标方法前 执行
返回通知：在被代理的目标方法成功结束 后执行（寿终正寝 ）
异常通知：在被代理的目标方法异常结束 后执行（死于非命 ）
后置通知：在被代理的目标方法最终结束 后执行（盖棺定论 ）
环绕通知：使用try…catch…finally结构围绕整个 被代理的目标方法，包括上面四种通知对应的所有位置
③切面 封装通知方法的类。
④目标 被代理的目标对象。
⑤代理 向目标对象应用通知之后创建的代理对象。
⑥连接点 这也是一个纯逻辑概念，不是语法定义的。
把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。通俗说，就是spring允许你使用通知的地方
⑦切入点 定位连接点的方式。
每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。
如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。
Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说，要实际去增强的方法
切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。
2.3 基于注解的AOP
动态代理分为JDK动态代理和cglib动态代理
当目标类有接口的情况使用JDK动态代理和cglib动态代理，没有接口时只能使用cglib动态代理
JDK动态代理动态生成的代理类会在com.sun.proxy包下，类名为$proxy1，和目标类实现相同的接口
cglib动态代理动态生成的代理类会和目标在在相同的包下，会继承目标类
动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口 （兄弟两个拜把子模式）。
cglib：通过继承被代理的目标类 （认干爹模式）实现代理，所以不需要目标类实现接口。
AspectJ：是AOP思想的一种实现。本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件 ，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。
①添加依赖 在IOC所需依赖基础上再加入下面依赖即可：
<dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-context</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-aop</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-aspects</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > <version > 5.3.1</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-core</artifactId > <version > 2.19.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-slf4j2-impl</artifactId > <version > 2.19.0</version > </dependency > </dependencies >
②添加log4j2.xml <?xml version="1.0" encoding="UTF-8" ?> <configuration > <loggers > <root level ="DEBUG" > <appender-ref ref ="spring6log" /> <appender-ref ref ="RollingFile" /> <appender-ref ref ="log" /> </root > </loggers > <appenders > <console name ="spring6log" target ="SYSTEM_OUT" > <PatternLayout pattern ="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n" /> </console > <File name ="log" fileName ="d:/spring6_log/test.log" append ="false" > <PatternLayout pattern ="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n" /> </File > <RollingFile name ="RollingFile" fileName ="d:/spring6_log/app.log" filePattern ="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz" > <PatternLayout pattern ="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n" /> <SizeBasedTriggeringPolicy size ="50MB" /> <DefaultRolloverStrategy max ="20" /> </RollingFile > </appenders > </configuration >
③被代理的目标资源 package com.bamboo.entity;public interface Calculator { int add (int i, int j) ; int sub (int i, int j) ; int mul (int i, int j) ; int div (int i, int j) ; }
package com.bamboo.entity.impl;import com.bamboo.entity.Calculator;import org.springframework.stereotype.Component;@Component public class CalculatorImpl implements Calculator { @Override public int add (int i, int j) { int result = i + j; System.out.println("方法内部 result = " + result); return result; } @Override public int sub (int i, int j) { int result = i - j; System.out.println("方法内部 result = " + result); return result; } @Override public int mul (int i, int j) { int result = i * j; System.out.println("方法内部 result = " + result); return result; } @Override public int div (int i, int j) { int result = i / j; System.out.println("方法内部 result = " + result); return result; } }
④创建切面类 package com.bamboo.aspect;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.*;import org.springframework.stereotype.Component;import java.util.Arrays;@Aspect @Component public class LogAspect { @Before("execution(public int com.bamboo.entity.impl.CalculatorImpl.*(..))") public void beforeMethod (JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println("Logger-->前置通知，方法名：" +methodName+"，参数：" +args); } @After("execution(* com.bamboo.entity.impl.CalculatorImpl.*(..))") public void afterMethod (JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->后置通知，方法名：" +methodName); } @AfterReturning(value = "execution(* com.bamboo.entity.impl.CalculatorImpl.*(..))", returning = "result") public void afterReturningMethod (JoinPoint joinPoint, Object result) { String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->返回通知，方法名：" +methodName+"，结果：" +result); } @AfterThrowing(value = "execution(* com.bamboo.entity.impl.CalculatorImpl.*(..))", throwing = "ex") public void afterThrowingMethod (JoinPoint joinPoint, Throwable ex) { String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->异常通知，方法名：" +methodName+"，异常：" +ex); } @Around("execution(* com.bamboo.entity.impl.CalculatorImpl.*(..))") public Object aroundMethod (ProceedingJoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); Object result = null ; try { System.out.println("环绕通知-->目标对象方法执行之前" ); result = joinPoint.proceed(); System.out.println("环绕通知-->目标对象方法返回值之后" ); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("环绕通知-->目标对象方法出现异常时" ); } finally { System.out.println("环绕通知-->目标对象方法执行完毕" ); } return result; } }
⑤添加application配置
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" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" > <context:component-scan base-package ="com.atguigu.aop.annotation" > </context:component-scan > <aop:aspectj-autoproxy /> </beans >
全注解开发
package com.bamboo.config;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;@Configuration @ComponentScan("com.bamboo") public class SpringConfiguration {}
⑥测试AOP import com.bamboo.config.SpringConfiguration;import com.bamboo.entity.Calculator;import org.junit.jupiter.api.Test;import org.junit.platform.commons.logging.Logger;import org.junit.platform.commons.logging.LoggerFactory;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class CalculatorTest { private Logger logger = LoggerFactory.getLogger(CalculatorTest.class); @Test public void testAdd () { ApplicationContext ac = new AnnotationConfigApplicationContext (SpringConfiguration.class); Calculator calculator = ac.getBean(Calculator.class); int add = calculator.add(1 , 1 ); logger.info(() -> "执行成功：" + add); } }
2.4 通知解析
前置通知：使用@Before注解标识，在被代理的目标方法前 执行
返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束 后执行（寿终正寝 ）
异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束 后执行（死于非命 ）
后置通知：使用@After注解标识，在被代理的目标方法最终结束 后执行（盖棺定论 ）
环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个 被代理的目标方法，包括上面四种通知对应的所有位置
各种通知的执行顺序：
Spring版本5.3.x以前：
Spring版本5.3.x以后：
2.5 切入点表达式
用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限
在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。
例如：*.Hello匹配com.Hello，不匹配com.atguigu.Hello
在包名的部分，使用“*..”表示包名任意、包的层次深度任意
在类名的部分，类名部分整体用*号代替，表示类名任意
在类名的部分，可以使用*号代替类名的一部分
例如：*Service匹配所有名称以Service结尾的类或接口
在方法名部分，可以使用*号表示方法名任意
在方法名部分，可以使用*号代替方法名的一部分
例如：*Operation匹配所有方法名以Operation结尾的方法
在方法参数列表部分，使用(..)表示参数列表任意
在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头
在方法参数列表部分，基本数据类型和对应的包装类型是不一样的
切入点表达式中使用 int 和实际方法中 Integer 是不匹配的
在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符
例如：execution(public int ..Service. (.., int)) 正确 int *..Service. (.., int)) 错误
2.6 重用切入点 ①声明
@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))") public void pointCut () {}
②在同一个切面中使用
@Before("pointCut()") public void beforeMethod (JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println("Logger-->前置通知，方法名：" +methodName+"，参数：" +args); }
③在不同切面中使用
@Before("com.atguigu.aop.CommonPointCut.pointCut()") public void beforeMethod (JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println("Logger-->前置通知，方法名：" +methodName+"，参数：" +args); }
2.7 获取通知的相关信息 ①获取连接点信息
获取连接点信息可以在通知方法的参数位置设置JoinPoint类型的形参
@Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))") public void beforeMethod (JoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); System.out.println("Logger-->前置通知，方法名：" +methodName+"，参数：" +args); }
②获取目标方法的返回值
@AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值
@AfterReturning(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result") public void afterReturningMethod (JoinPoint joinPoint, Object result) { String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->返回通知，方法名：" +methodName+"，结果：" +result); }
③获取目标方法的异常
@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常
@AfterThrowing(value = "execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex") public void afterThrowingMethod (JoinPoint joinPoint, Throwable ex) { String methodName = joinPoint.getSignature().getName(); System.out.println("Logger-->异常通知，方法名：" +methodName+"，异常：" +ex); }
2.8 环绕通知 @Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))") public Object aroundMethod (ProceedingJoinPoint joinPoint) { String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); Object result = null ; try { System.out.println("环绕通知-->目标对象方法执行之前" ); result = joinPoint.proceed(); System.out.println("环绕通知-->目标对象方法返回值之后" ); } catch (Throwable throwable) { throwable.printStackTrace(); System.out.println("环绕通知-->目标对象方法出现异常时" ); } finally { System.out.println("环绕通知-->目标对象方法执行完毕" ); } return result; }
2.9 切面的优先级 相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套 顺序。
使用@Order注解可以控制切面的优先级：
@Order(较小的数)：优先级高
@Order(较大的数)：优先级低
3. 基于XML的AOP <context:component-scan base-package ="com.atguigu.aop.xml" > </context:component-scan > <aop:config > <aop:aspect ref ="loggerAspect" > <aop:pointcut id ="pointCut" expression ="execution(* com.atguigu.aop.xml.CalculatorImpl.*(..))" /> <aop:before method ="beforeMethod" pointcut-ref ="pointCut" > </aop:before > <aop:after method ="afterMethod" pointcut-ref ="pointCut" > </aop:after > <aop:after-returning method ="afterReturningMethod" returning ="result" pointcut-ref ="pointCut" > </aop:after-returning > <aop:after-throwing method ="afterThrowingMethod" throwing ="ex" pointcut-ref ="pointCut" > </aop:after-throwing > <aop:around method ="aroundMethod" pointcut-ref ="pointCut" > </aop:around > </aop:aspect > </aop:config >
九、Spring整合单元测试：JUnit 在之前的测试方法中，几乎都能看到以下的两行代码：
ApplicationContext context = new ClassPathXmlApplicationContext ("xxx.xml" );Xxxx xxx = context.getBean(Xxxx.class);
这两行代码的作用是创建Spring容器，最终获取到对象，但是每次测试都需要重复编写。针对上述问题，我们需要的是程序能自动帮我们创建容器。我们都知道JUnit无法知晓我们是否使用了 Spring 框架，更不用说帮我们创建 Spring 容器了。Spring提供了一个运行器，可以读取配置文件（或注解）来创建容器。我们只需要告诉它配置文件位置就可以了。这样一来，我们通过Spring整合JUnit可以使程序创建spring容器了
1. 整合JUnit5 1.1 添加依赖 <dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-context</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-test</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > org.junit.jupiter</groupId > <artifactId > junit-jupiter-api</artifactId > <version > 5.9.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-core</artifactId > <version > 2.19.0</version > </dependency > <dependency > <groupId > org.apache.logging.log4j</groupId > <artifactId > log4j-slf4j2-impl</artifactId > <version > 2.19.0</version > </dependency > </dependencies >
1.2 添加bean.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 http://www.springframework.org/schema/context/spring-context.xsd" > <context:component-scan base-package ="com.bamboo" /> </beans >
copy日志文件：log4j2.xml
1.3 添加java类 package com.atguigu.spring6.bean;import org.springframework.stereotype.Component;@Component public class User { public User () { System.out.println("run user" ); } }
1.4 测试
import com.bamboo.User;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(locations = "classpath:beans.xml") public class SpringJUnit5Test { @Autowired private User user; @Test public void testUser () { System.out.println(user); } }
2. 整合JUnit4 2.1 添加依赖 <dependency > <groupId > junit</groupId > <artifactId > junit</artifactId > <version > 4.12</version > </dependency >
2.2 测试 import com.atguigu.spring6.bean.User;import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:beans.xml") public class SpringJUnit4Test { @Autowired private User user; @Test public void testUser () { System.out.println(user); } }
十、事务：transaction 1. JdbcTemplate 1.1 搭建 ①加入依赖
<dependencies > <dependency > <groupId > org.springframework</groupId > <artifactId > spring-jdbc</artifactId > <version > 6.0.2</version > </dependency > <dependency > <groupId > mysql</groupId > <artifactId > mysql-connector-java</artifactId > <version > 8.0.30</version > </dependency > <dependency > <groupId > com.alibaba</groupId > <artifactId > druid</artifactId > <version > 1.2.15</version > </dependency > </dependencies >
②创建jdbc.properties
jdbc.user =root jdbc.password =root jdbc.url =jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false jdbc.driver =com.mysql.cj.jdbc.Driver
③配置Spring的配置文件
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: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:property-placeholder location ="classpath:jdbc.properties" /> <bean id ="druidDataSource" class ="com.alibaba.druid.pool.DruidDataSource" > <property name ="url" value ="${jdbc.url}" /> <property name ="driverClassName" value ="${jdbc.driver}" /> <property name ="username" value ="${jdbc.user}" /> <property name ="password" value ="${jdbc.password}" /> </bean > <bean id ="jdbcTemplate" class ="org.springframework.jdbc.core.JdbcTemplate" > <property name ="dataSource" ref ="druidDataSource" /> </bean > </beans >
④准备数据库与测试表
CREATE DATABASE `spring`;use `spring`; CREATE TABLE `t_emp` ( `id` int (11 ) NOT NULL AUTO_INCREMENT, `name` varchar (20 ) DEFAULT NULL COMMENT '姓名' , `age` int (11 ) DEFAULT NULL COMMENT '年龄' , `sex` varchar (2 ) DEFAULT NULL COMMENT '性别' , PRIMARY KEY (`id`) ) ENGINE= InnoDB DEFAULT CHARSET= utf8mb4;
1.2 实现CRUD ①装配 JdbcTemplate 创建测试类，整合JUnit，注入JdbcTemplate
package com.atguigu.spring6;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(locations = "classpath:beans.xml") public class JDBCTemplateTest { @Autowired private JdbcTemplate jdbcTemplate; }
②测试增删改功能 @Test public void testUpdate () { String sql = "insert into t_emp values(null,?,?,?)" ; int result = jdbcTemplate.update(sql, "张三" , 23 , "男" ); }
③查询数据返回对象 public class Emp { private Integer id; private String name; private Integer age; private String sex; @Override public String toString () { return "Emp{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", sex='" + sex + '\'' + '}' ; } }
@Test public void testSelectObject () { String sql = "select * from t_emp where id=?" ; Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper <>(Emp.class),1 ); System.out.println(emp); }
④查询数据返回list集合 @Test public void testSelectList () { String sql = "select * from t_emp" ; List<Emp> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper <>(Emp.class)); System.out.println(list); }
⑤查询返回单个的值 @Test public void selectCount () { String sql = "select count(id) from t_emp" ; Integer count = jdbcTemplate.queryForObject(sql, Integer.class); System.out.println(count); }
2. 声明式事务概念 ①什么是事务 数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。
②事务的特性 A：原子性(Atomicity)
一个事务(transaction)中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
C：一致性(Consistency)
事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。
如果事务成功地完成，那么系统中所有变化将正确地应用，系统处于有效状态。
如果在事务中出现错误，那么系统中的所有变化将自动地回滚，系统返回到原始状态。
I：隔离性(Isolation)
指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。
D：持久性(Durability)
指的是只要事务成功结束，它对数据库所做的更新就必须保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。
2.1 编程式事务【jdbc常用】 事务功能的相关操作全部通过自己编写代码来实现：
Connection conn = ...; try { conn.setAutoCommit(false ); conn.commit(); }catch (Exception e){ conn.rollBack(); }finally { conn.close(); }
编程式的实现方式存在缺陷：
细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。
代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。
2.2 声明式事务【spring常用】 既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。
封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。
好处1：提高开发效率
好处2：消除了冗余的代码
好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化
所以，我们可以总结下面两个概念：
编程式 ：自己写代码 实现功能声明式 ：通过配置 让框架 实现功能
3. 基于注解的声明式事务 3.1 环境搭建 ①添加配置
在beans.xml添加配置
<context:component-scan base-package ="com.bamboo.spring" > </context:component-scan >
②创建表
CREATE TABLE `t_book` ( `book_id` int (11 ) NOT NULL AUTO_INCREMENT COMMENT '主键' , `book_name` varchar (20 ) DEFAULT NULL COMMENT '图书名称' , `price` int (11 ) DEFAULT NULL COMMENT '价格' , `stock` int (10 ) unsigned DEFAULT NULL COMMENT '库存（无符号）' , PRIMARY KEY (`book_id`) ) ENGINE= InnoDB AUTO_INCREMENT= 3 DEFAULT CHARSET= utf8; insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1 ,'斗破苍穹' ,80 ,100 ),(2 ,'斗罗大陆' ,50 ,100 );CREATE TABLE `t_user` ( `user_id` int (11 ) NOT NULL AUTO_INCREMENT COMMENT '主键' , `username` varchar (20 ) DEFAULT NULL COMMENT '用户名' , `balance` int (10 ) unsigned DEFAULT NULL COMMENT '余额（无符号）' , PRIMARY KEY (`user_id`) ) ENGINE= InnoDB AUTO_INCREMENT= 2 DEFAULT CHARSET= utf8; insert into `t_user`(`user_id`,`username`,`balance`) values (1 ,'admin' ,50 );
③创建组件
创建BookController：
package com.atguigu.spring6.controller;@Controller public class BookController { @Autowired private BookService bookService; public void buyBook (Integer bookId, Integer userId) { bookService.buyBook(bookId, userId); } }
创建接口BookService：
package com.atguigu.spring6.service;public interface BookService { void buyBook (Integer bookId, Integer userId) ; }
创建实现类BookServiceImpl：
package com.atguigu.spring6.service.impl;@Service public class BookServiceImpl implements BookService { @Autowired private BookDao bookDao; @Override public void buyBook (Integer bookId, Integer userId) { Integer price = bookDao.getPriceByBookId(bookId); bookDao.updateStock(bookId); bookDao.updateBalance(userId, price); } }
创建接口BookDao：
package com.atguigu.spring6.dao;public interface BookDao { Integer getPriceByBookId (Integer bookId) ; void updateStock (Integer bookId) ; void updateBalance (Integer userId, Integer price) ; }
创建实现类BookDaoImpl：
package com.atguigu.spring6.dao.impl;@Repository public class BookDaoImpl implements BookDao { @Autowired private JdbcTemplate jdbcTemplate; @Override public Integer getPriceByBookId (Integer bookId) { String sql = "select price from t_book where book_id = ?" ; return jdbcTemplate.queryForObject(sql, Integer.class, bookId); } @Override public void updateStock (Integer bookId) { String sql = "update t_book set stock = stock - 1 where book_id = ?" ; jdbcTemplate.update(sql, bookId); } @Override public void updateBalance (Integer userId, Integer price) { String sql = "update t_user set balance = balance - ? where user_id = ?" ; jdbcTemplate.update(sql, price, userId); } }
3.2 测试无事务情况 【错误事务修改了部分数据库数据】
①创建测试类
import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;@SpringJUnitConfig(locations = "classpath:beans.xml") public class TxByAnnotationTest { @Autowired private BookController bookController; @Test public void testBuyBook () { bookController.buyBook(1 , 1 ); } }
②模拟场景
用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额
假设用户id为1的用户，购买id为1的图书
用户余额为50，而图书价格为80
购买图书之后，用户的余额为-30，数据库中余额字段设置了无符号，因此无法将-30插入到余额字段
此时执行sql语句会抛出SQLException
③观察结果
因为没有添加事务，图书的库存更新了，但是用户的余额没有更新
显然这样的结果是错误的，购买图书是一个完整的功能，更新库存和更新余额要么都成功要么都失败
3.3 加入事务 【一个报错，全部rollback，不修改数据】
3.3.1 xml加入事务 ①添加事务配置 在spring配置文件中引入tx命名空间
<?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" xmlns:tx ="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" >
在Spring的配置文件中添加配置：
<bean id ="transactionManager" class ="org.springframework.jdbc.datasource.DataSourceTransactionManager" > <property name ="dataSource" ref ="druidDataSource" > </property > </bean > <tx:annotation-driven transaction-manager ="transactionManager" />
②添加事务注解 因为service层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在service层处理
在BookServiceImpl的buybook()添加注解@Transactional
③观察结果 由于使用了Spring的声明式事务，更新库存和更新余额都没有执行
3.3.2 注解加入事务
SpringConfig添加*@EnableTransactionManagement*
同时添加@Bean
@Configuration @EnableTransactionManagement @ComponentScan("com.bamboo.spring") @Import(value = {DruidDataSourceConfig.class, JdbcTemplateConfig.class}) public class SpringConfig { @Autowired private DataSource dataSource; @Bean public PlatformTransactionManager transactionManager () { return new DataSourceTransactionManager (dataSource); } }
在BookServiceImpl的buybook()添加注解@Transactional
@Service public class BookServiceImpl implements BookService { @Autowired private BookDao bookDao; @Override @Transactional public void buyBook (Integer bookId, Integer userId) { Integer price = bookDao.getPriceByBookId(bookId); bookDao.updateStock(bookId); bookDao.updateBalance(userId, price); } }
3.4 @Transactional注解标识的位置 @Transactional标识在方法上，则只会影响该方法
@Transactional标识的类上，则会影响类中所有的方法
3.5 事务属性：只读 ①介绍
对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。
②使用方式
@Transactional(readOnly = true) public void buyBook (Integer bookId, Integer userId) { Integer price = bookDao.getPriceByBookId(bookId); bookDao.updateStock(bookId); bookDao.updateBalance(userId, price); }
③注意
对增删改操作设置只读会抛出下面异常：
Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed
3.6 事务属性：超时 ①介绍
事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。
概括来说就是一句话：超时回滚，释放资源。
②使用方式
@Transactional(timeout = 3) public void buyBook (Integer bookId, Integer userId) { try { TimeUnit.SECONDS.sleep(5 ); } catch (InterruptedException e) { e.printStackTrace(); } Integer price = bookDao.getPriceByBookId(bookId); bookDao.updateStock(bookId); bookDao.updateBalance(userId, price); }
③观察结果
执行过程中抛出异常：
org.springframework.transaction.TransactionTimedOutException : Transaction timed out: deadline was Fri Jun 04 16:25:39 CST 2022
3.7 事务属性：回滚策略 ①介绍
声明式事务默认只针对运行时异常回滚，编译时异常不回滚。
可以通过@Transactional中相关属性设置回滚策略
rollbackFor属性：需要设置一个Class类型的对象
rollbackForClassName属性：需要设置一个字符串类型的全类名
noRollbackFor属性：需要设置一个Class类型的对象
rollbackFor属性：需要设置一个字符串类型的全类名
②使用方式
@Transactional(noRollbackFor = ArithmeticException.class) public void buyBook (Integer bookId, Integer userId) { Integer price = bookDao.getPriceByBookId(bookId); bookDao.updateStock(bookId); bookDao.updateBalance(userId, price); System.out.println(1 /0 ); }
③观察结果
虽然购买图书功能中出现了数学运算异常（ArithmeticException），但是我们设置的回滚策略是，当出现ArithmeticException不发生回滚，因此购买图书的操作正常执行
3.8 事务属性：隔离级别 ①介绍
数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。
隔离级别一共有四种：
读未提交：READ UNCOMMITTED
允许Transaction01读取Transaction02未提交的修改。
读已提交：READ COMMITTED、
要求Transaction01只能读取Transaction02已提交的修改。
可重复读：REPEATABLE READ
确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。
串行化：SERIALIZABLE
确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。
各个隔离级别解决并发问题的能力见下表：
隔离级别
脏读
不可重复读
幻读
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)
3.9 事务属性：传播行为 ①介绍
什么是事务的传播行为？
在service类中有a()方法和b()方法，a()方法上有事务，b()方法上也有事务，当a()方法执行过程中调用了b()方法，事务是如何传递的？合并到一个事务里？还是开启一个新的事务？这就是事务传播行为。
一共有七种传播行为：
REQUIRED：支持当前事务，如果不存在就新建一个(默认)【没有就新建，有就加入】
SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行【有就加入，没有就不管了】
MANDATORY：必须运行在一个事务中，如果当前没有事务正在发生，将抛出一个异常【有就加入，没有就抛异常】
REQUIRES_NEW：开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起【不管有没有，直接开启一个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起】
NOT_SUPPORTED：以非事务方式运行，如果有事务存在，挂起当前事务【不支持事务，存在就挂起】
NEVER：以非事务方式运行，如果有事务存在，抛出异常【不支持事务，存在就抛异常】
NESTED：如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于外层事务进行提交或回滚。如果外层事务不存在，行为就像REQUIRED一样。【有事务的话，就在这个事务里再嵌套一个完全独立的事务，嵌套的事务可以独立的提交和回滚。没有事务就和REQUIRED一样。】
②测试
创建接口CheckoutService：
package com.atguigu.spring6.service;public interface CheckoutService { void checkout (Integer[] bookIds, Integer userId) ; }
创建实现类CheckoutServiceImpl：
package com.atguigu.spring6.service.impl;@Service public class CheckoutServiceImpl implements CheckoutService { @Autowired private BookService bookService; @Override @Transactional public void checkout (Integer[] bookIds, Integer userId) { for (Integer bookId : bookIds) { bookService.buyBook(bookId, userId); } } }
在BookController中添加方法：
@Autowired private CheckoutService checkoutService;public void checkout (Integer[] bookIds, Integer userId) { checkoutService.checkout(bookIds, userId); }
在数据库中将用户的余额修改为100元
③观察结果
可以通过@Transactional中的propagation属性设置事务传播行为
修改BookServiceImpl中buyBook()上，注解@Transactional的propagation属性
@Transactional(propagation = Propagation.REQUIRED)，默认情况，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。经过观察，购买图书的方法buyBook()在checkout()中被调用，checkout()上有事务注解，因此在此事务中执行。所购买的两本图书的价格为80和50，而用户的余额为100，因此在购买第二本图书时余额不足失败，导致整个checkout()回滚，即只要有一本书买不了，就都买不了
@Transactional(propagation = Propagation.REQUIRES_NEW)，表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在buyBook()的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的buyBook()中回滚，购买第一本图书不受影响，即能买几本就买几本。
3.10 全注解配置事务 ①添加配置类
package com.atguigu.spring6.config;import com.alibaba.druid.pool.DruidDataSource;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.datasource.DataSourceTransactionManager;import org.springframework.transaction.annotation.EnableTransactionManagement;import javax.sql.DataSource;@Configuration @ComponentScan("com.atguigu.spring6") @EnableTransactionManagement public class SpringConfig { @Bean public DataSource getDataSource () { DruidDataSource dataSource = new DruidDataSource (); dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver" ); dataSource.setUrl("jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false" ); dataSource.setUsername("root" ); dataSource.setPassword("root" ); return dataSource; } @Bean(name = "jdbcTemplate") public JdbcTemplate getJdbcTemplate (DataSource dataSource) { JdbcTemplate jdbcTemplate = new JdbcTemplate (); jdbcTemplate.setDataSource(dataSource); return jdbcTemplate; } @Bean public DataSourceTransactionManager getDataSourceTransactionManager (DataSource dataSource) { DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager (); dataSourceTransactionManager.setDataSource(dataSource); return dataSourceTransactionManager; } }
②测试
import com.atguigu.spring6.config.SpringConfig;import com.atguigu.spring6.controller.BookController;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;public class TxByAllAnnotationTest { @Test public void testTxAllAnnotation () { ApplicationContext applicationContext = new AnnotationConfigApplicationContext (SpringConfig.class); BookController accountService = applicationContext.getBean("bookController" , BookController.class); accountService.buyBook(1 , 1 ); } }
3.11 基于XML的声明式事务 ① 场景模拟 参考基于注解的声明式事务
② 修改Spring配置文件 将Spring配置文件中去掉tx:annotation-driven 标签，并添加配置：
<aop:config > <aop:advisor advice-ref ="txAdvice" pointcut ="execution(* com.atguigu.spring.tx.xml.service.impl.*.*(..))" > </aop:advisor > </aop:config > <tx:advice id ="txAdvice" transaction-manager ="transactionManager" > <tx:attributes > <tx:method name ="get*" read-only ="true" /> <tx:method name ="query*" read-only ="true" /> <tx:method name ="find*" read-only ="true" /> <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 >
注意：基于xml实现的声明式事务，必须引入aspectJ的依赖
<dependency > <groupId > org.springframework</groupId > <artifactId > spring-aspects</artifactId > <version > 6.0.2</version > </dependency >
十一、资源操作：Resources 十二、国际化：i18n 十三、数据校验：Validation 十四、提前编译：AOT 