嘎嘎基础的JavaWeb(下)

Java
200
0
0
2024-03-27
标签   Java基础

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))")
  • 书写建议:
  1. 所有业务 方法名命名 时尽量 规范 ,方便切入点表达式快速匹配。如:查询类方法都是 find 开头,更新类方法都是 update 开头
  2. 描述切入点方法通常 基于接口描述 ,而不是直接描述实现类, 增强拓展性
  3. 在满足业务需要的前提下, 尽量缩小切入点的匹配范围 。如:包名匹配尽量不使用 .. ,使用 * 匹配单个包

切入点表达式——@annotation

  • @annotation 切入点表达式,用于匹配标识有特定注解的方法
  • @annotation(com.itheima.anno.Log)
  1. 定义注解:
  • @Retention(RetentionPolicy.RUNTIME) //描述什么时候生效(运行时有效) @Target(ElementType.METHOD) //描述标注什么方法的(生效在方法上) public @interface MyLog { }
  1. 根据指定的注解匹配切入点方法:
  • @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
  • 如果操作的是已经打包好的
  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容器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框架进行项目的开发,会比较繁琐。
  • 这个繁琐主要体现在两个地方:
  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:父工程或聚合工程,该模块不写代码,仅进行依赖管理
  1. 子工程 的 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 文件的相对位置(如果不指定,将从本地仓库 / 远程仓库查找该工程)
  1. 在父工程中配置各个工程共有的依赖(子工程会自动继承父工程的依赖)
  • <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(上)  

嘎嘎基础的JavaWeb(中)  

嘎嘎基础的JavaWeb(下)