JavaWeb：AOP、配置优先级、Bean管理、SpringBoot原理、Maven高级

1 AOP

1.1 基本语法

面向切面编程、面向方面编程，面向特定方法编程

在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程

应用：统计每一个业务方法的执行耗时

xml引入依赖

<!--        AOP-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

TimeAspect.java

@Slf4j
@Component
@Aspect//AOP类
public class TimeAspect {
//    第一个* 是方法返回值，第二个*是类名，第三个*是方法名
    @Around("execution(* com.itheima.service.*.*(..))")//切入点表达式
    public  Object   recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.记录开始时间
        long begin=System.currentTimeMillis();
//    2.运行原始方法
        //借助AOP提供的api
        Object result=joinPoint.proceed();

//    3.记录结束时间
        long end=System.currentTimeMillis();
        log.info(joinPoint.getSignature()+"方法耗时{}",end-begin);
        return result;
    }
}

连接点：被AOP控制的方法

通知：recordTime方法全部

切入点表达式："execution(* com.itheima.service.*.*(..))"

切入点：com.itheima.service下的所有类下的所有方法

切面：@Around+通知

切面类：被@Aspect标识的类

目标对象：通知应用的对象

@Pointcut：将公共的切点表达式抽取出来

public class TimeAspect {
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    public void pt(){}

    @Around("pt()")
    public  Object   recordTime(ProceedingJoinPoint joinPoint) throws Throwable {}
}

1.2 通知类型

环绕通知 @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行

前置通知 @Before：此注解标注的通知方法在目标方法前被执行

后置通知 @After：此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

异常通知 @AfterThrowing：在连接点抛出异常后执行

返回后通知@AfterReturning：此注解标注的通知方法在目标方法后被执行，有异常则不会执行

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

@Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值

1.3 通知顺序

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行

不同切面类中，默认按照切面类的类名字母排序：

目标方法前的通知方法：字母排名靠前的先执行

目标方法后的通知方法：字母排名靠前的后执行

@order（数字）数字越小越先执行

@Aspect
@Order(2)
public class TimeAspect2 {}
//假如{}都是相同切面，那么TimeAspect先执行
@Aspect
@Order(1)
public class TimeAspect {}

1.4 切入点表达式

execution(……)：根据方法的签名来匹配

//delete参数是Integer；delete如果抛出异常，那么切入点也要抛出异常
@Pointcut("execution(public void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")
    public void pt1(){}


//访问修饰符可以省略
@Pointcut("execution( void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")
    public void pt2(){}

//包名.类名可以省略，如果项目中有多个delete，那么会执行多次
@Pointcut("execution(public void delete(java.lang.Integer))")
    public void pt3(){}

//* ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分


//返回值任意，第二级包任意，service下的以pl结尾的类，Dept开头的类，方法任意，参数任意但必须有一个
@Pointcut("execution(* void com.*.service.*pl.Dept*.*(*))")
    public void pt4(){}


//.. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数，包括0个

//匹配com包下的所有的类所有的方法
@Pointcut("execution(* com..*.*(..))")
    public void pt5(){}

@annotation(……) ：根据注解匹配

ZhuJie.java

//指定注解什么时候生效，运行时有效
@Retention(RetentionPolicy.RUNTIME)
//当前注解可以作用在哪些地方，在方法上生效
@Target(ElementType.METHOD)
public @interface ZhuJie {
}

    //方法上有@ZhuJie的都可以生效
@Pointcut("@annotation(com.itheima.aop.ZhuJie)")
    public void pt1(){}

1.5 连接点

对于 @Around 通知，获取连接点信息只能使用 ProceedingJoinPoint

对于其他通知，获取连接点信息只能使用 JoinPoint

@Before("execution(* *.*(..))")
public void before(JoinPoint joinPoint) {
String className = joinPoint.getTarget().getClass().getName(); //获取目标类名
Signature signature = joinPoint.getSignature(); //获取目标方法签名
String methodName = joinPoint.getSignature().getName(); //获取目标方法名
Object[] args = joinPoint.getArgs(); //获取目标方法运行参数 
}

@Around("execution("* *.*(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
String className = joinPoint.getTarget().getClass().getName(); //获取目标类名
Signature signature = joinPoint.getSignature(); //获取目标方法签名
String methodName = joinPoint.getSignature().getName(); //获取目标方法名
Object[] args = joinPoint.getArgs(); //获取目标方法运行参数 
Object res = joinPoint.proceed(); //执行原始方法,获取返回值（环绕通知）
return res;
}

2 配置优先级

SpringBoot 中支持三种格式的配置文件：properties，yml，yaml，优先级依次递减

也可以指定JAVA系统属性和命令行参数，命令行参数优先级最高，JAVA系统属性第二，properties第三

JAVA系统属性：-Dserver.port=9000 在VM options配置

命令行参数：--server.port=10010 在Program arguments配置

项目打包后如何指定 JAVA系统属性和命令行参数

在xml文件加入

在本文件夹输入cmd，运行jar包

ctrl+c停掉

cmd中配置 JAVA系统属性和命令行参数

3 Bean管理

bean 是对象，由 Spring 中一个叫 IoC 的东西管理的

3.1 获取Bean

默认情况下，Spring项目启动时，会把bean都创建好放在IOC容器中

//IOC容器对象
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void TestGetBean(){
        //根据bean的名称获取
        EmpController e1= (EmpController) applicationContext.getBean("EmpController");
        //根据bean的类型获取
        EmpController e2=applicationContext.getBean(EmpController.class);
        //根据bean的类型与名称获取
        EmpController e3=applicationContext.getBean("EmpController",EmpController.class);

    }

3.2 bean作用域

//可以通过 @Scope 注解来进行配置作用域
@Scope("prototype")
public class A{}

3.3 第三方bean

如果要管理的bean对象来自于第三方（不是自定义的），是无法用 @Component 及衍生注解声明bean的，就需要用到 @Bean

@SpringBootApplicationpublic class SpringbootWebConfig2Application {
    @Bean //将方法返回值交给IOC容器管理,成为IOC容器的bean对象
    public SAXReader saxReader(){
       return new SAXReader();
    }
}

//声明一个配置类
@Configurationpublic class CommonConfig {
    @Bean
    public SAXReader saxReader(){
        return new SAXReader();
   }
}

如果第三方bean需要依赖其它bean对象，直接在bean定义方法中设置形参即可，容器会根据类型自动装配

@Lazy 注解：在 Spring 框架中，默认会在启动时会创建所有的 Bean 对象，但有些 bean 对象假如长时间不用，启动时就创建对象，会占用其内存资源，从而造成一定的资源浪费，此时我们可以基于懒加载策略延迟对象的创建。

4 SpringBoot原理

4.1 起步依赖

起步依赖原理就是maven依赖传递

A依赖B，B依赖C，那么ABC都引入进来

4.2 自动配置

SpringBoot的自动配置就是当spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作

类上加@Component不一定生效，注解需要被spring组件扫描到；@SpringBootApplication具有包扫描的作用，但范围只在当前包及其子包

4.2.1 扫描不是当前包及其子包的解决方案

方案一：@ComponentScan 组件扫描，性能低

//如果不加com.itheima会被覆盖掉
@ComponentScan({"com.example","com.itheima"})
@SpringBootApplication
public class SpringbootWebConfig2Application {
}

方案二：@Import 导入。使用@Import导入的类会被Spring加载到IOC容器中，导入普通类、配置类、ImportSelector 接口实现类

方案三：导入ImportSelector的实现类

底层代码：

ImportSelector接口：

ImportSelector实现类：

返回值封装的是全类名，将哪些类一次性封装给IOC容器管理

可以把要加载的类都定义一份文件中，将文件的字符串读取出来放入数组中，那这些类都会被加载到IOC容器中，即把HeaderConfig这个类给到IOC容器管理

@Enablexxx 注解(以Enable开头）让第三方依赖自己指定导入哪些bean和配置类

加上@@Enablexxx相当于加上了@Import注解导入了bean和配置类

4.2.3 源码跟踪

1.原理

自动配置核心是在@SpringBootApplication注解上，底层包含三个注解：@ComponentScan、@SpringBootConfiguration、@EnableAutoConfiguration。@EnableAutoConfiguration是自动配置的核心。@EnableAutoConfiguration封装了@Import，@Import中指定了一个类 AutoConfigurationImportSelector是ImportSelector接口的实现类，在这个实现类中实现SelectImports方法，这个方法返回值代表要将哪些类交给IOC容器管理，此时会读取两份配置文件： spring.factories、 org.springframework.boot.autoconfigure.AutoConfiguration.imports，后者会配置大量自动配置的类，这些自动配置的类的所有的bean不一定都加载到IOC容器，会根据以@Conditional开头的注解进行条件装配

2.源码

ctrl+左键@SpringBootApplication

@SpringBootConfiguration声明当前类是配置类4

@SpringBootApplication具有包扫描的作用，但范围只在当前包及其子包是因为封装了@ComponentScan

ctrl+左键@EnableAutoConfiguration，ctrl+左键

 AutoConfigurationImportSelector

AutoConfigurationImportSelector 的方法

spring在启动时，自动加载这两个文件配置的信息，加载完成后，封装到List集合中

再把封装到List集合中的内容封装到数组中，数组的数据是IOC容器的bean或者配置类

spring.factories（spring早期）

org.springframework.boot.autoconfigure.AutoConfiguration.imports（spring 2.7.x之后）

点开一个全报名：

@bean生成一个个bean对象，spring项目启动时候加载这个配置文件的配置类，然后封装到string[] selectImports的数组，通过@import全部加载到IOC容器

4.2.4 @Conditional

作用：按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring IOC容器中。

父注解@Conditional

子注解：

@ConditionalOnClass：判断环境中是否有对应字节码文件，才注册bean到IOC容器。

@ConditionalOnMissingBean：判断环境中没有对应的bean（类型或名称），才注册bean到IOC容器。指定类型用value，指定名称用name。如果用户声明了对应的bean，那就用用户的，不然用默认的

@ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。

    @Bean
    //spring容器在启动会自动判断有没有WebConfig这个类，存在这个类，才会注册到IOC容器
//    @ConditionalOnClass(name="com.itheima.config.WebConfig")
    @ConditionalOnMissingBean//不存在Result的bean，才会将该bean注入容器中
    public Result func(){
        return Result.success();
    }
    @Bean
    //配置文件中存在指定的名字和值，才会将该bean添加到IOC容器中
    @ConditionalOnProperty(name="name",havingValue = "pro")
    public Result func1(){
        return Result.success();
    }

4.3 自定义starter

将公共组件封装为SpringBoot 的 starter，starter即起步依赖

阿里云OSS需要引入依赖、配置文件、引入代码，繁琐。在公共组件把要配置的bean提前配置好，项目使用这个技术将组件坐标引入就可以使用。

5 Maven高级

5.1 分模块设计与开发

设计一个java项目，拆分成多个模块

分模块开发需要先针对模块功能进行设计，再进行编码

GroupId(Group):项目所属组织的唯一标识符，一般是公司官网域名反写或组织名

Artifacted：一般情况都是项目名称

Version：指定项目当前的版本，SNAPSHOT是不稳定的版本

Name：启动类类名

Packaging： 可选，maven会使用默认值jar，表示工程打包格式

jar：（默认）普通模块打包，springboot项目基本都是jar包（内嵌tomcat运行）

war：普通web程序打包，需要部署在外部的tomcat服务器中运行

pom：父工程或聚合工程，该模块不写代码，仅进行依赖管理

maven是一个构件（jar、war文件）库。构件都有自己的唯一坐标，这些坐标就是由上面几个元素构成。构件的坐标信息在项目的pom文件中

relativePath：父工程POM文件的相对路径

将tlias的pojo放入maven文件中，并引入相关依赖

最后检测是否可以正常运行

5.2 继承与聚合

5.2.1 继承

1. 继承关系

在maven中，一个子工程只能继承一个父工程

TLIAS-PARENT pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>tlias-parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>Archetype - tlias-parent</name>
  <url>http://maven.apache.org</url>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.5</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
<!--  在父工程配置各个工程共有的依赖，所有子工程都会继承lombok的依赖-->
  <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</project>

tlias-web-management pom.xml

    <parent>
        <groupId>com.itheima</groupId>
        <artifactId>tlias-parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../tlias-parent/tlias-parent/pom.xml</relativePath>
    </parent>

2. 版本锁定

在maven中，可以在父工程的pom文件中通过 <dependencyManagement> 来统一管理依赖版本

denpendencyManagement仅仅是统一管理依赖的版本，不会直接依赖，还需要在子工程中引入所需依赖(无需指定版本)。

dependencies是直接依赖，在父工程配置了依赖,子工程会直接继承下来

 <denpendencyManagement>
 <dependencies>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
 <denpendencyManagement>

子工程不需要加入版本号

<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
       <artifactId>jjwt</artifactId>
   </dependency></dependencies>

自定义属性/引用属性

原因：denpendencyManagement需要加入的依赖很多，不便于管理

<properties>
    <jjwt.version>0.9.0</jjwt.version>
</properties>

<dependencyManagement>
    <dependencies>
       <!--JWT令牌-->
        <dependency>
           <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jjwt.version}</version>
        </dependency>
   </dependencies></dependencyManagement>

5.2.2 聚合

1. 聚合代码

对某一个模块打包，必须将父模块和依赖的模块必须先按照顺序安装（maven的install）到本地仓库，然后才能对这个模块进行打包。

聚合：将多个模块（本身及子工程）组织成一个整体，同时进行项目的构建

聚合工程：一个不具有业务功能的“空”工程，一般是父工程

聚合工程作用：快速构建项目（无需根据依赖关系手动构建，直接在聚合工程上构建即可）

父工程：

<!--聚合，顺序无关-->
<modules>
    <module>../tlias-pojo</module>
    <module>../tlias-utils</module>
    <module>../tlias-web-management</module>
</modules>

执行任何一个操作，都是对父工程及其子工程的执行

2.继承与聚合

作用：

聚合用于快速构建项目

继承用于简化依赖配置、统一管理依赖

相同点：

聚合与继承的pom.xml文件打包方式均为pom，可以将两种关系制作到同一个pom文件中

聚合与继承均属于设计型模块，并无实际的模块内容

不同点：

聚合是在聚合工程中配置关系，聚合可以感知到参与聚合的模块有哪些

继承是在子模块中配置关系，父模块无法感知哪些子模块继承了自己

5.3 私服

dependency 先到本地仓库寻找依赖，再到中央仓库寻找依赖。中央仓库全球只有一个

私服是一种特殊的远程仓库，它是架设在公司局域网内的仓库服务，用来代理位于外部的中央仓库，用于解决团队内部的资源共享与资源同步问题。

依赖查找顺序：本地仓库、私服、中央仓库

项目版本：

RELEASE（发行版本）：功能趋于稳定、当前更新停止，可以用于发行的版本，存储在私服中的RELEASE仓库中

SNAPSHOT（快照版本）：功能不稳定、尚处于开发中的版本，即快照版本，存储在私服的SNAPSHOT仓库中

私服配置说明

## 私服配置说明



访问私服：http://192.168.150.101:8081

访问密码：admin/admin



使用私服，需要在maven的settings.xml配置文件中，做如下配置：

1. 需要在 **servers** 标签中，配置访问私服的个人凭证(访问的用户名和密码)

   ```xml
   <server>
       <id>maven-releases</id>
       <username>admin</username>
       <password>admin</password>
   </server>
       
   <server>
       <id>maven-snapshots</id>
       <username>admin</username>
       <password>admin</password>
   </server>
   ```

   

2. 在 **mirrors** 中只配置我们自己私服的连接地址(如果之前配置过阿里云，需要直接替换掉)

   ```xml
   <mirror>
       <id>maven-public</id>
       <mirrorOf>*</mirrorOf>
       <url>http://192.168.150.101:8081/repository/maven-public/</url>
   </mirror>
   ```

   

3.  需要在 **profiles** 中，增加如下配置，来指定snapshot快照版本的依赖，依然允许使用

   ```xml
   <profile>
       <id>allow-snapshots</id>
           <activation>
           	<activeByDefault>true</activeByDefault>
           </activation>
       <repositories>
           <repository>
               <id>maven-public</id>
               <url>http://192.168.150.101:8081/repository/maven-public/</url>
               <releases>
               	<enabled>true</enabled>
               </releases>
               <snapshots>
               	<enabled>true</enabled>
               </snapshots>
           </repository>
       </repositories>
   </profile>
   ```

   

4. 如果需要上传自己的项目到私服上，需要在项目的pom.xml文件中，增加如下配置，来配置项目发布的地址(也就是私服的地址)

   ```xml
   <distributionManagement>
       <!-- release版本的发布地址 -->
       <repository>
           <id>maven-releases</id>
           <url>http://192.168.150.101:8081/repository/maven-releases/</url>
       </repository>
       
       <!-- snapshot版本的发布地址 -->
       <snapshotRepository>
           <id>maven-snapshots</id>
           <url>http://192.168.150.101:8081/repository/maven-snapshots/</url>
       </snapshotRepository>
   </distributionManagement>
   ```

   

5. 发布项目，直接运行 deploy 生命周期即可 (发布时，建议跳过单元测试)