12. 事务管理 & AOP
12.1 事务管理
12.1.1 事务回顾
- 概念:事务时一组操作的集合,它是一个不可分割的工作单位,这些操作 要么同时成功,要么同时失败
- 操作:
- 开启事务(一组操作开始前,开启事务):start transaction / begin ;
- 提交事务(这组操作全部完成后,提交事务): commit ;
- 回滚事务(中间任何一个操作出现异常,回滚事务): rollback ;
12.1.2 Spring 事务管理
@Overridepublic void delete(Integer id) {
deptMapper.deleteById(id); //根据id删除部门数据
/*如果这里出现异常,即时异常抛出,下面代码也不会执行,员工归属部门会出现问题
* 需要把这个整体代码封装到一个事务当中,来解决,使用 @Transactional 注解 */
empMapper.deleteByDeptId(id); //根据部门id删除该部门下的员工
}
- 注解:@Transactional
- 位置:业务(service)层的 方法上、类上、接口上(多数都加在业务层进行多次增删改数据访问的方法上)
- 作用:将当前方法交给 spring 进行事务管理,方法执行前,开启事务;成功执行完毕,提交事务;出现异常,回滚事务
#spring事务管理日志
logging:
level:
org.springframework.jdbc.support.JdbcTransactionManager: debug
@Transactional //spring 事务管理@Overridepublic void delete(Integer id) {
deptMapper.deleteById(id); //根据id删除部门数据
empMapper.deleteByDeptId(id); //根据部门id删除该部门下的员工
}
12.1.3 事务进阶
rollbackFor 异常回滚属性
默认情况下,只有出现 RuntimeException(运行时异常) 才回滚异常。rollbackFor 属性用于控制出现何种异常类型,回滚事务。
@Transactional(rollbackFor = Exception.class) //所有异常都会进行回滚操作
propagation 事务传播行为
- 事务传播行为:指的是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行事务控制。
属性值 | 含义 |
REQUIRED | 【默认值】需要事务,有则加入,无则创建新事务 |
REQUIRES_NEW | 需要新事务,无论有无,总是创建新事务 |
SUPPORTS | 支持事务,有则加入,无则在无事务状态中运行 如果调用b方法时有事务,就加入到这个事务中,如果调用b方法时没事务,就再现有的方法中运行 |
NOT_SUPPORTED | 不支持事务,在无事务状态下运行,如果当前存在已有事务,则挂起当前事务 如果调用 b 方法的时候已经发现存在事务了,会把事务先挂起再执行b方法 |
MANDATORY | 必须有事务,否则抛异常 |
NEVER | 必须没事务,否则抛异常 |
… |
@Transactional
public void a() {
// ...
userService.b(); //如果b方法支持事务(有@Transactional注解)
// ...
}
@Transactional(propagation = Propagtion.REQUIRED)
public void b(){
// ...
}
案例:
需求:解散部门时,无论是成功还是失败,都要记录操作日志
@Transactional(rollbackFor = Exception.class) //spring 事务管理@Overridepublic void delete(Integer id) {
try {
deptMapper.deleteById(id); //根据id删除部门数据int i = 1/0;
empMapper.deleteByDeptId(id); //根据部门id删除该部门下的员工
} finally {
DeptLog log = new DeptLog();
log.setCreateTime(LocalDateTime.now());
log.Descrtption("执行了解散部门操作,此次解散的是" + id + "号的部门");
deptLogService.insert(log); //记录操作日志
}
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Overide
public void insert(DeptLog deptLog) {
deptLogMapper.insert(deptLog);
}
- REQUIRED:大部分情况下都是用该传播行为即可
- REQUIRES_NEW:当我们不希望事务之间相互影响时,可以使用该传播行为。比如:下订单前需要记录日志,不论订单保留成功与否,都需要保证日志记录能够记录成功。
12.1.4 核心概念
- 连接点:JoinPoint,可以被 AOP 控制的方法(暗含方法执行时的相关信息)
//这个类里面的所有方法
@Service
public class DeptServiceImpl implements DeptService {
@Autowiredprivate DeptMapper deptMapper;
@Overridepublic List<Dept> list() {
List<Dept> deptList = deptMapper.list();
return deptList;
}
@Overridepublic void delete(Integer id) {
deptMapper.delete(id);
}
@Overridepublic void save(Dept dept) {
dept.setCreateTime(LocalDateTime.now());
dept.setUpdateTime(LocalDateTime.now());
deptMapper.save(dept);
}
- 通知:Advice,指哪些重复的逻辑,也就是共性功能(最终体现为一个方法)
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
/*1. 记录开始时间*/long begin = System.currentTimeMillis();
/*2. 调用原始方法运行*/Object result = joinPoint.proceed();
/*3. 记录结束时间, 计算方法执行耗时*/long end = System.currentTimeMillis();
log.info(joinPoint.getSignature()+"方法执行耗时: {}ms", end-begin);
//joinPoint.getSignature()拿到方法的签名
return result;
}
- 切入点:PointCut,匹配连接点的条件,通知仅会在切入点方法执行时被应用
@Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))"
- 切面:Aspect,描述通知与切入点的对应关系(通知 + 切入点)
//切面
@Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))") //切入点表达式public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
long begin = System.currentTimeMillis();
Object result = joinPoint.proceed();
long end = System.currentTimeMillis();
log.info(joinPoint.getSignature()+"方法执行耗时: {}ms", end-begin);
return result;
}
- 目标对象:Target,通知所应用的对象
@Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
- 里面的 DeptServiceImpl
12.2 AOP 基础
12.2.1 概述
- AOP:面向切面编程、面向方面编程,其实就是面向特定方法编程
- 场景:案例部分功能运行缓慢,定位执行耗时较长的业务方法,此时需要统计每一个业务方法的执行耗时
用方法运行结束时间 —— 方法运行开始时间 ==== 运行原始方法时间
- 实现:动态代理是面向切面编程最主流的实现。而 SpringAOP 是 Spring 框架的高级技术,旨在管理 bean 对象的过程中,主要通过底层的动态代理机制,对特定的方法进行编程
12.2.2 快速入门
- 导入依赖:在 pom.xml 中导入 AOP 的依赖
<!--AOP--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>
- 编写 AOP 程序:针对于特定方法根据业务需要进行编程
@Slf4j
@Component //将当前类交给ioc容器管理
@Aspect //AOP类
public class TimeAspect {
@Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))") //切入点表达式public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
/*1. 记录开始时间*/long begin = System.currentTimeMillis();
/*2. 调用原始方法运行*/Object result = joinPoint.proceed();
/*3. 记录结束时间, 计算方法执行耗时*/long end = System.currentTimeMillis();
log.info(joinPoint.getSignature()+"方法执行耗时: {}ms", end-begin);
//joinPoint.getSignature()拿到方法的签名
return result;
}
}
- 场景:
- 记录操作日志
- 权限控制
- 事务管理
- 优势:
- 代码无侵入
- 减少重复代码
- 提高开发效率
- 维护方便
12.3 AOP 进阶
12.3.1 通知类型
- @Around:环绕通知,此注解标注的通知方法在目标方法前、后都被执行
- @Before:前置通知,此注解标注的通知方法在目标方法前被执行
- @After:后置通知,此注解标注的通知方法在目标方法后被执行,无论是否有异常都会被执行
- @AfterReturning:返回后通知,此注解标注的通知方法在目标方法后被执行,有异常不会执行
- @AfterThrowing:异常后通知,此注解标注的通知方法发生异常后执行
@Slf4j
@Component
@Aspect
public class MyAspect1 {
@Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")public void pt(){}
@Before("pt()")public void before(){
log.info("before ...");
}
@Around("pt()")public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
log.info("around before ...");
//调用目标对象的原始方法执行Object result = proceedingJoinPoint.proceed();
log.info("around after ...");
return result;
}
@After("pt()")public void after(){
log.info("after ...");
}
@AfterReturning("pt()")public void afterReturning(){
log.info("afterReturning ...");
}
@AfterThrowing("pt()")public void afterThrowing(){
log.info("afterThrowing ...");
}
}
- 注意:
- @Around 环绕通知需要自己调用 ProceedingJoinPoint.procees() 来让原始方法执行,其他通知不需要考虑目标方法执行
- @Around 环绕通知方法的返回值,必须指定为 Object,来接收原始方法的返回值
- @PointCut
- 该注解的作用是将公共的切点表达式抽取出来,需要用到时引用该切点表达式即可。
@Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
public void pt(){}
//public:在其他外部的切面类中也可以引用该表达式 //privite:仅能在当前切面类中引用该表达式 @Before("pt()")
public void before(){
log.info("before ...");
}
12.3.2 通知顺序
当有多个切面的切入点都匹配到了目标方法,目标方法运行时,多个通知方法都会被执行
- 执行顺序:
- 不同切面类中,默认按照切面类的 类名字母排序:
- 目标方法前的通知方法:字母排名靠前的先执行
- 目标方法后的通知方法:字母排名靠前的后执行
- 用 @Order(数字) 加在切面类上来控制顺序:
- 目标方法前的通知方法:数字小的先执行
- 目标方法后的通知方法:数字小的后执行
@Order(1)
@Slf4j
@Component
@Aspect
public class MyAspect4 {
@Before("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
public void before(){
log.info("before ...4");
}
@After("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
public void after(){
log.info("after ...4");
}
}
12.3.3 切入点表达式
- 描述切入点方法的一种表达式
- 作用:主要用来决定项目中的哪些方法需要加入通知
- 常见形式:
- execution ( ... ... ):根据方法的签名来匹配
- @annotation( ... ... ):根据注解匹配
切入点表达式——execution
- execution 主要根据方法的返回值、包名、类名、方法名、方法参数 等信息来匹配,语法为:
- execution(访问修饰符? 返回值 包名.类名.?方法名(方法参数) throws 异常?)
- 其中带?的表示可以省略的部分
- 访问修饰符:可省略(比如:public、protected)
- 包名.类名:可省略
- throws 异常:可省略(注意是方法上声明抛出的异常,不是实际抛出的异常)
- @Pointcut("execution(public void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")
- 可以使用通配符描述切入点:
- * :单个独立的任意符合,可以统配任意返回值 、包名、类名、方法名、任意类型的一个参数,也可以通配包、类、方法名的一部分
- execution(* com.*.service.*.update*(*))
- . . :多个连续的任意符号,可以通配任意层级的包,或任意类型、任意个数的参数
- execution(* com.itheima..DeptService.*(..))
- 根据业务需要,可以使用 且(&&)、或( || )、非( ! )来组合比较复杂的切入点表达式。
- @Pointcut("execution(* com.itheima.service.DeptService.list()) || " + "execution(* com.itheima.service.DeptService.delete(java.lang.Integer))")
- 书写建议:
- 所有业务 方法名 在 命名 时尽量 规范 ,方便切入点表达式快速匹配。如:查询类方法都是 find 开头,更新类方法都是 update 开头
- 描述切入点方法通常 基于接口描述 ,而不是直接描述实现类, 增强拓展性
- 在满足业务需要的前提下, 尽量缩小切入点的匹配范围 。如:包名匹配尽量不使用 .. ,使用 * 匹配单个包
切入点表达式——@annotation
- @annotation 切入点表达式,用于匹配标识有特定注解的方法
- @annotation(com.itheima.anno.Log)
- 定义注解:
- @Retention(RetentionPolicy.RUNTIME) //描述什么时候生效(运行时有效) @Target(ElementType.METHOD) //描述标注什么方法的(生效在方法上) public @interface MyLog { }
- 根据指定的注解匹配切入点方法:
- @Pointcut("@annotation(com.itheima.aop.MyLog)") //定义注解的全类名 private void pt(){} @Before("pt()") public void before(){ log.info("MyAspect7 ... before ..."); }
12.3.4 连接点
就是可以被 AOP 控制的方法
- 在 Spring 中用 JoinPoint 抽象了连接点,用它可以获得方法执行时的相关信息,如目标类名、方法名、方法参数等。
- 对于 @Around 通知,获取连接点信息只能使用 ProceedingJoinPoint
@Around("pt()")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("MyAspect8 around before ...");
//1. 获取 目标对象的类名 .String className = joinPoint.getTarget().getClass().getName();
log.info("目标对象的类名:{}", className);
//2. 获取 目标方法的方法名 .String methodName = joinPoint.getSignature().getName();
log.info("目标方法的方法名: {}",methodName);
//3. 获取 目标方法运行时传入的参数 .
Object[] args = joinPoint.getArgs();
log.info("目标方法运行时传入的参数: {}", Arrays.toString(args));
//4. 放行 目标方法执行 .Object result = joinPoint.proceed();
//5. 获取 目标方法运行的返回值 .
log.info("目标方法运行的返回值: {}",result); //前置通知拿不到返回值
log.info("MyAspect8 around after ...");
return result;
}
- 对于其他四种通知,获取连接点信息只能使用 JoinPoint , 它是 ProceedingJoinPoint 的父类类型
@Before("pt()")public void before(JoinPoint joinPoint){
log.info("MyAspect8 ... before ...");
}
12.4 AOP 案例
将案例中 增、删、改 相关接口的操作日志记录到数据库表中
- 准备:
- 在案例工程中引用 AOP 的起步依赖
- 导入表结构,并引用对应的实体类
- 编码:
- 自定义注解 @Log
- 定义切面类,完成记录操作日志的逻辑
@Slf4j
@Component
@Aspect //切面类
public class LogAspect {
@Autowiredprivate HttpServletRequest request;
@Autowiredprivate OperateLogMapper operateLogMapper;
@Around("@annotation(com.itheima.anno.Log)") //匹配方法上加有 Log 注解的方法public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
/*操作人 ID——当前登录人的ID*///获取请求头的 jwt 令牌,解析令牌String jwt = request.getHeader("token");
Claims claims = JwtUtils.parseJWT(jwt);
Integer operateUser = (Integer) claims.get("id");
/*操作时间*/LocalDateTime operateTime = LocalDateTime.now();
/*操作类类名*/// 目标对象 类对象 目标类类名String className = joinPoint.getTarget().getClass().getName();
/*操作方法名*/// 方法签名 方法名String methodName = joinPoint.getSignature().getName();
/*操作方法参数*/
Object[] args = joinPoint.getArgs();
String methodParams = Arrays.toString(args);
long begin = System.currentTimeMillis();
/*调用原始目标方法运行*/Object result = joinPoint.proceed();
long end = System.currentTimeMillis();
/*方法返回值*/String returnValue = JSONObject.toJSONString(result);
/*操作耗时*/long costTime = end - begin;
/*记录操作日志*/OperateLog operateLog = new OperateLog(null, operateUser, operateTime, className, methodName, methodParams, returnValue, costTime);
operateLogMapper.insert(operateLog);
log.info("AOP记录操作日志:{}", operateLog);
return result;
}
}
- 获取当前登录用户:
- 获取 request 对象,从请求头重获取到 jwt 令牌,解析令牌获取出当前用户的 id
13. Web后端开发原理
13.1 配置优先级
配置:
- SpringBoot 中支持三种格式的配置文件:
- server.port=8081
- server: port:8082
- server: port:8083
- 优先级:properties > yml > yaml
- 注意事项:虽然 springboot 支持多种格式配置文件,但是在项目开发时,推荐统一使用一种格式的配置(yml是主流)
SpringBoot 除了支持配置文件属性配置,还支持 Java系统属性 和 命令行参数 的方式进行属性配置
- Java 系统属性-Dserver.port=9000
- 命令行参数--server.port=10010
- 如果操作的是已经打包好的
- 执行 maven 打包指令 package
- 执行 Java 指令,运行 jar 包
- java -Deserver.port=9000 -jar tlias-web-managemment-0.0.1-SNAPSHOT.jar --server.port-10010
- 注意:Springboot 项目进行打包时,需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目,会自动添加该插件)
13.2 Bean 管理
13.2.1 获取 bean
- 默认情况下,Spring 项目启动时,会把 bean 都创建好放在 IOC 容器中,如果想要主动获取这些 bean,可以通过如下方式:(需要注入 ApplicationContext对象,调用 getBean 方法)
- 根据 name 获取 bean:
- Object getBean(String name)
- 根据类型获取 bean:
- <T> T getBean (Class<T> requiredType)
- 根据 name 获取 bean(带类型转换):
- <T> T getBean (String name, Class<T> requiredType)
- 注意:【Spring 项目启动时,会把其中的 bean 都创建好】还会受到作用域及延迟初始化影响,这里主要针对于 默认的单例非延迟加载的 bean 而言
//获取bean对象
@Test
public void testGetBean(){
//根据bean的名称获取
DeptController bean1 = (DeptController) applicationContext.getBean("deptController");//类名首字母小写
System.out.println(bean1);
//根据bean的类型获取
DeptController bean2 = applicationContext.getBean(DeptController.class);
System.out.println(bean2);
//根据bean的名称 及 类型获取
DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
System.out.println(bean3);
}
13.2.2 bean 作用域
- Spring 支持五种作用域,后三种在 web 环境才生效
作用域 | 说明 |
singleton | 容器内同 名称 的 bean 只有一个实例(单例)(默认) |
prototype | 每次使用该 bean 时会创建新的实例(非单例) |
request | 每个请求范围内会创建新的实例(web环境中) |
session | 每个请求范围内会创建新的实例(web环境中) |
application | 每个请求范围内会创建新的实例(web环境中) |
- 可以通过 @Scope 注解来进行配置作用域:
- //@Lazy //延迟初始化,延迟到第一次使用时 @Scope("prototype") //设置作用域为非单例的 @RestController @RequestMapping("/depts") public class DeptController { }
- 注意:
- 默认 singleton 的 bean,在容器启动时被创建,可以使用 @Lazy 注解来延迟初始化(延迟到第一次使用时)
- prototype 的 bean,每一次使用该 bean 的时候都会创建一个新的实例
- 实际开发中,绝大部分的 Bean 是单例的,也就是说绝大部分 Bean 不需要配置 scope 属性
13.2.3 第三方 bean
- @Bean:如果要管理的 bean 对象来自于第三方(不是自定义的),是无法用 @Component 及衍生注解声明 bean 的,就需要用到 @Bean 注解。
- 若要管理的第三方 bean 对象,建议对这些 bean 进行集中分类配置,可以通过 @Configuration 注解声明一个配置类
@SpringBootApplication
public class SpringbootWebConfig2Application {
//声明第三方bean@Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器beanpublic SAXReader saxReader(){
return new SAXReader();
}
}
//写在启动类,不建议
- 建议定义一个配置类,配置类中定义一个方法,在方法上加 @Bean 注解
@Configuration //配置类
public class CommonConfig {
//声明第三方bean@Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean//通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名public SAXReader reader(DeptService deptService){
System.out.println(deptService);
return new SAXReader();
}
}
- 注意:
- 通过 @Bean 注解的 name 或 value 属性可以声明 bean 的名称,如果不指定,默认 bean 的名称就是方法名
- 如果第三方 bean 需要依赖其他 bean 对象,直接在 bean 定义方法中设置形参即可,容器会根据类型自动装配
13.3 SpringBoot 原理
13.3.1 起步依赖
- Spring是目前世界上最流行的Java框架,它可以帮助我们更加快速、更加容易的来构建Java项目。而在Spring家族当中提供了很多优秀的框架,而所有的框架都是基于一个基础框架的SpringFramework(也就是Spring框架)。而前面我们也提到,如果我们直接基于Spring框架进行项目的开发,会比较繁琐。
- 这个繁琐主要体现在两个地方:
- 在pom.xml中依赖配置比较繁琐,在项目开发时,需要自己去找到对应的依赖,还需要找到依赖它所配套的依赖以及对应版本,否则就会出现版本冲突问题。
- 在使用Spring框架进行项目开发时,需要在Spring的配置文件中做大量的配置,这就造成Spring框架入门难度较大,学习成本较高。
maven 的依赖传递
13.3.2 自动配置
- SpringBoot 的自动配置就是当 spring 容器启动后,一些配置类、bean 对象就自动存入到了 IOC 容器中,不需要我们手动去声明,从而简化了开发,省去了繁琐的配置操作。
自动配置原理
- SpringBoot项目中的@SpringBootApplication注解,具有包扫描的作用,但是它只会扫描启动类所在的当前包以及子包。
- 当前包:com.itheima, 第三方依赖中提供的包:com.example(扫描不到)
- 解决方法:
- 方案1:
@ComponentScan
组件扫描 - 方案2:
@Import
导入(使用@Import导入的类会被Spring加载到IOC容器中) @ComponentScan
组件扫描- @SpringBootApplication @ComponentScan({"com.itheima","com.example"}) //指定要扫描的包 public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
- 使用繁琐,性能低
@Import
导入,使用@Import
导入的类会被 Spring 加载到 IOC 容器中- 导入形式主要有以下几种:
- 导入普通类
- 导入配置类
- 导入 ImportSelector 接口实现类
- 使用第三方依赖提供的 @EnableXxxxx 注解
- 使用
@Import
导入普通类: - @Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
- 使用
@Import
导入配置类: - 配置类
- @Configuration public class HeaderConfig { @Bean public HeaderParser headerParser(){ return new HeaderParser(); } @Bean public HeaderGenerator headerGenerator(){ return new HeaderGenerator(); } }
- 启动类
- @Import(HeaderConfig.class) //导入配置类 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
- 测试类
- @SpringBootTest public class AutoConfigurationTests { @Autowired private ApplicationContext applicationContext; @Test public void testHeaderParser(){ System.out.println(applicationContext.getBean(HeaderParser.class)); } @Test public void testHeaderGenerator(){ System.out.println(applicationContext.getBean(HeaderGenerator.class)); } //省略其他代码... }
- 使用
@Import
导入ImportSelector
接口实现类: ImportSelector
接口实现类- public class MyImportSelector implements ImportSelector { public String[] selectImports(AnnotationMetadata importingClassMetadata) { //返回值字符串数组(数组中封装了全限定名称的类) return new String[]{"com.example.HeaderConfig"}; } }
- 启动类
- @Import(MyImportSelector.class) //导入ImportSelector接口实现类 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
- 使用第三方依赖提供的
@EnableXxxxx
注解 - 第三方依赖中提供的注解
- @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类 public @interface EnableHeaderConfig { }
- 在使用时只需在启动类上加上
@EnableXxxxx
注解即可 - @EnableHeaderConfig //使用第三方依赖提供的Enable开头的注解 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
源码跟踪
@SpringBootApplication
该注解标识在 SpringBoot 工程引导类上,是 SpringBoot 中最重要的注解,该注解由三个部分组成:@SpringBootConfiguration
:该注解与@Configuration
注解作用相同,用来声明当前也是一个配置类@EnableAutoConfiguration
:SpringBoot 实现自动化配置的核心注解@ComponentScan
:组件扫描,默认扫描当前引导类所在包及其子包
自动配置原理:
@Conditional
作用:按照一定的条件进行判断,在满足给定条件后才会注册对应的 bean 对象到 Spring IOC 容器中- 位置:方法、类
@Conditional
本身是一个父注解,派生出大量的子注解@ConditionalOnClass
:判断环境中是否有对应字节码文件,才注册 bean 到 IOC 容器@ConditionalOnMissingBean
:判断环境中没有对应的 bean (类型 或 名称),才注册 bean 到 IOC 容器@ConditionalOnProperty
:判断配置文件中有对应属性和值,才注册 bean 到 IOC 容器- @Bean @ConditionalOnClass(name = "io.jsonwebtoken.Jwts") //当前环境存在指定的这个类时,才声明该 bean public HeaderParser haderParser(){...}
- @Bean @ConditionalOnMissingBean //当不存在当前类型的 bean 时,才声明该 bean public HeaderParser haderParser(){...}
- @Bean @ConditionalOnProperty(name = "name", havingValue = "itheima") //配置文件中存在对应的属性和值,才注册 bean 到 IOC 容器 public HeaderParser haderParser(){...}
SpringBoot 会根据 @Conditional 注解条件装配
案例(自定义 stater)
- 在实际开发中,经常会定义一些公共组件,提供给各个项目团队使用。而在 SpringBoot 的项目中,一般会将这些公共组件封装为 SpringBoot 的 starter
14. Maven高级
14.1 分模块设计与开发
- 如果项目不分模块,也就意味着所有的业务代码是不是都写在这一个 Java 项目当中。随着这个项目的业务扩张,项目当中的业务功能可能会越来越多。
- 不方便项目的维护和管理、项目中的通用组件难以复用。
- 分模块设计:
- 将项目按照功能拆分成若干个子模块,方便项目的管理维护、扩展,也方便模块间的相互调用,资源共享。
- 注意:
- 分模块开发需要先针对模块功能进行设计,再进行编码。不会先将工程开发完毕,然后再进行拆分
14.2 继承与聚合
14.2.1 继承
- 概念:继承 描述的是两个工程间的关系,与Java中的继承相似,子工程可以继承父工程中的配置信息,常见于依赖关系的继承
- 作用:简化依赖配置、、统一管理依赖
- 实现:
<parent> ... </parent>
- 继承关系实现
- 创建 maven 模块 tlias-parent,该工程为父工程,设置打包方式为 pom(默认 jar)。 <packaging>pom</packaging>
- jar:普通模块打包,springboot 项目基本都是 jar 包(内嵌 tomcat 运行)
- war:普通 web 程序打包,需要部署在外部的 tomcat 服务器中进行
- pom:父工程或聚合工程,该模块不写代码,仅进行依赖管理
- 在 子工程 的 pom.xml 文件中,配置继承关系
- <parent> <groupId>com.itheima</groupId> <artifactId>tlias-parent</artifactId> <version>1.0-SNAPSHOT</version> <relativePath>../tlias-parent/pom.xml</relativePath> <!-- 父工程的相对路径 --> </parent>
- 注意:
- 在子工程中,配置了继承关系之后,坐标中的 groupId 是可以省略的,因为会自动继承父工程的
- relativePath 指定父工程的 pom 文件的相对位置(如果不指定,将从本地仓库 / 远程仓库查找该工程)
- 在父工程中配置各个工程共有的依赖(子工程会自动继承父工程的依赖)
- <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>${lombok.version}</version> </dependency>
- 注意:若父子工程都配置了同一个依赖的不同版本,以子工程的为准
14.2.2 版本锁定
- 在 maven 中,可以在父工程的 pom 文件中通过
<dependencyManagement>
来统一管理依赖版本 - 父工程中配置各个依赖的版本时,子工程不需要配置版本
<dependencyManagement><dependencies><!--JWT令牌--><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>0.9.0</version></dependency></dependencies></dependencyManagement>
- 子工程中
<dependencies><!--JWT令牌--><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId></dependency></dependencies>
自定义属性 / 引用属性
<properties><maven.compiler.source>11</maven.compiler.source><maven.compiler.target>11</maven.compiler.target>
<lombok.version>1.18.24</lombok.version><jjwt.version>0.9.1</jjwt.version><aliyun.oss.version>3.15.1</aliyun.oss.version><jaxb.version>2.3.1</jaxb.version><activation.version>1.1.1</activation.version><jaxb.runtime.version>2.3.3</jaxb.runtime.version></properties><dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version></dependency></dependencies><!--统一管理依赖版本--><dependencyManagement><dependencies><!--JWT令牌--><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>${jjwt.version}</version></dependency>
<!--阿里云OSS--><dependency><groupId>com.aliyun.oss</groupId><artifactId>aliyun-sdk-oss</artifactId><version>${aliyun.oss.version}</version></dependency><dependency><groupId>javax.xml.bind</groupId><artifactId>jaxb-api</artifactId><version>${jaxb.version}</version></dependency><dependency><groupId>javax.activation</groupId><artifactId>activation</artifactId><version>${activation.version}</version></dependency><!-- no more than 2.3.3--><dependency><groupId>org.glassfish.jaxb</groupId><artifactId>jaxb-runtime</artifactId><version>${jaxb.runtime.version}</version></dependency></dependencies></dependencyManagement>
在 maven 中,可以在父工程的 pom 文件中通过<dependencyManagement>
来统一管理依赖版本,在子工程中就不用指定 version 版本号了
</dependencies>
:是直接依赖,在父工程配置了依赖,子工程会直接继承下来<dependencyManagement>
:是统一管理依赖版本,不会直接依赖,还需要在子工程中引入所需依赖(无需指定版本)
14.2.3 聚合
- 聚合:
- 将多个模块组织成一个整体,同时进行项目的构建
- 聚合工程:(父工程一般也是聚合工程)
- 一个不具有业务功能的 “空” 工程(有且仅有一个 pom 文件)
- 作用:
- 快速构建项目(无需根据依赖关系手动构建,直接在聚合工程上构建即可)
- maven 中可以通过
<modules>
设置当前聚合工程所包含的子模块名称
<!--聚合其他模块--><modules><module>../tlias-pojo</module> <!--要和模块名平级--><module>../tlias-utils</module><module>../tlias-web-management</module></modules>
- 注意:聚合工程中所包含的模块,在构建时,会自动根据模块间的依赖关系设置构建顺序,与聚合工程中模块的配置书写位置无关
14.2.4 继承与聚合
- 作用:
- 聚合用于快速构建项目
- 继承用于简化依赖配置、统一管理依赖
- 相同点:
- 聚合与继承的 pom.xml 文件打包方式均为 pom,可以将两种关系制作到同一个 pom 文件中
- 聚合与继承均属于设计型模块,并无实际的模块内容
- 不同点:
- 聚合是在聚合工程中配置关系,聚合可以感知到参与聚合的模块有哪些
- 继承是在子模块中配置关系,父模块无法感知哪些子模块继承了自己
系列文章
嘎嘎基础的JavaWeb(下)