嘎嘎基础的JavaWeb(下)

原创

xiao李

修改于 2024-01-10 22:34:22

1100

修改于 2024-01-10 22:34:22

文章被收录于专栏：我吃香菜青椒不挑食我吃香菜青椒不挑食

12. 事务管理 & AOP

12.1 事务管理

12.1.1 事务回顾

概念：事务时一组操作的集合，它是一个不可分割的工作单位，这些操作 要么同时成功，要么同时失败
操作：
- 开启事务（一组操作开始前，开启事务）：start transaction / begin ;
- 提交事务（这组操作全部完成后，提交事务）： commit ;
- 回滚事务（中间任何一个操作出现异常，回滚事务）： rollback ;

12.1.2 Spring 事务管理

@Override
    public 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 事务管理
    @Override
    public 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 事务管理
    @Override
    public 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 {
    @Autowired
    private DeptMapper deptMapper;
    @Override
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        return deptList;
    }
    @Override
    public void delete(Integer id) {
        deptMapper.delete(id);
    }
    @Override
    public 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))")
书写建议：
1. 所有业务 方法名 在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是 update 开头
2. 描述切入点方法通常 基于接口描述 ，而不是直接描述实现类， 增强拓展性
3. 在满足业务需要的前提下， 尽量缩小切入点的匹配范围 。如：包名匹配尽量不使用 .. ，使用 * 匹配单个包

切入点表达式——@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 {

    @Autowired
    private HttpServletRequest request;
    @Autowired
    private 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
如果操作的是已经打包好的
1. 执行 maven 打包指令 package
2. 执行 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容器bean
    public 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框架进行项目的开发，会比较繁琐。
这个繁琐主要体现在两个地方：
1. 在pom.xml中依赖配置比较繁琐，在项目开发时，需要自己去找到对应的依赖，还需要找到依赖它所配套的依赖以及对应版本，否则就会出现版本冲突问题。
2. 在使用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 容器中
- 导入形式主要有以下几种：
  1. 导入普通类
  2. 导入配置类
  3. 导入 ImportSelector 接口实现类
  4. 使用第三方依赖提供的 @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>
继承关系实现
1. 创建 maven 模块 tlias-parent，该工程为父工程，设置打包方式为 pom（默认 jar）。 <packaging>pom</packaging>
  - jar：普通模块打包，springboot 项目基本都是 jar 包（内嵌 tomcat 运行）
  - war：普通 web 程序打包，需要部署在外部的 tomcat 服务器中进行
  - pom：父工程或聚合工程，该模块不写代码，仅进行依赖管理
2. 在 子工程 的 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 文件的相对位置（如果不指定，将从本地仓库 / 远程仓库查找该工程）
3. 在父工程中配置各个工程共有的依赖（子工程会自动继承父工程的依赖）
  - <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 文件中
- 聚合与继承均属于设计型模块，并无实际的模块内容
不同点：
- 聚合是在聚合工程中配置关系，聚合可以感知到参与聚合的模块有哪些
- 继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

后端

前后端分离

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

后端

前后端分离