spring 复习

1# Spring复习

1.了解Spirng

spirng->spring mvc ->spring boot ->spring cloud


层层递进--


2.IOC -Di 了解

由分层解耦引出的依赖注入 以及依赖反转


如图 ->当我们想更改对象name->时 改动过大->

Ioc->控制反转
使用对象--由主动new-改为外部提供对象->对象控制器转移到外部

spring提供容器->ioc容器 ->提供了对象存储

依赖注入


IOC->容器管理Bean

DI->将具有依赖关系的Bean进行关系绑定

3.加入IOC 容器

1.配置Bean


2.获取Bean


当我们配置bean的时候--容器内就保存了我们的对象地址->单例->谁需要就给予

2.依赖注入




set容器执行->最后还是容器将Bean给予了

spring->编译 --自动找set 依赖方法注入

4.Bean配置




spring->默认的Bean是单例的

如果需要多例 就需要修改配置


为什么bean要单例--
开对象->耗费内存

由于是单例->需要改变的数据就不能加入spring管理->除非开多例

5.Bean实例化

1.无参构造


给接口内->一个构造->通过xml解析出 需要构造的对象->通过反射 ->创建出对象返回->默认单例

通过类名动态加载类的方法

在使用 Class.forName() 方法时，情况会根据加载的类是否已存在而有所不同：

1. 类已存在：
   • 如果使用 Class.forName() 加载的类在类路径中已经存在，则会返回对应的 Class 对象，而不会创建新的对象。这意味着它只是获取已加载类的引用，不会触发类的初始化和实例化。
2. 类不存在：
   • 如果要加载的类在类路径中不存在，则会抛出 ClassNotFoundException 异常，而不会创建新的类对象。在这种情况下，不会创建新的类对象，因为类根本就没有被加载到内存中

2.工厂模式

工厂模式 ->由一个类中的静态方法->返回对象的引用




3.实例工厂-

1.实例工厂-需要指定Bean

2.FactoryBean


指定类-扫描

6.Bean生命周期

1.生命周期配置

1.配置法


2.接口法



2.bean销毁时间

为了体现生命周期->我们提前销毁bean


7.依赖注入

1.了解依赖注入

有Bean关系的类进行自动注入 ---向类传递数据方式-set 传递 --构造传参

---

参数--引用类型和简单类型

2.引用注入 setter注入


3.构造器注入




4.依赖注入方式选择


5.依赖自动装配

IOC容器根据bean所依赖的资源在容器中自动查找并注入到bena的过程称为自动装配

1.按类型

2.按名称

3.按构造方法

4.不启用自动装配


更改自动装配为按照类型

比如bookServcice依赖BookDao--我们不需要描述其关系 程序会自动根据名字找到对应类的bean

8.集合注入

1.数组


2.list


3.Set

<p>
<set>

</set>
</p>

4.Map


5.Properties


9.案例分析-bean注入

我们要拿到druid的连接

1.配置bean -注入参数


我们就可以进行拿取

Set注入--进行注入传普通参数

10.加载properties文件


加载模式


11.容器

1.容器的创建


2.bean获取


3.容器接口分析


4.BeanFactory初始化


IOC DI Bean总结



------------------------------------------------------------------------------------

12.注解

1.@声明为Bean

将一个类声明为Bean


为了适配MVC->故此还有 @Controller @Service @Repository

2.纯注解配置



3.依赖注入



简单类型注入


4.加载properties文件



5.第三方bean管理例子

1.注册为bean


2.加入管理-导入式


扫描式


简单依赖注入

---连接池配置


XML与注解 配置区别


13.aop

1.Aop基础

1.原理

AOP的原理主要是通过使用代理对象来实现，在Spring中，AOP通过代理对象包装目标对象（被代理的对象），在代理对象中插入切面（aspect），实现对目标对象方法的增强。Spring AOP主要采用动态代理技术来实现AOP，其中包括JDK动态代理和CGLIB动态代理两种方式。

---

再框架中添加了个拦截器->依据正则过滤

2.场景

1. 日志记录：记录方法的调用、参数、返回值等信息。
2. 事务管理：管理事务的开始、提交、回滚等操作。
3. 安全性：实现权限控制、加密解密等安全相关功能。
4. 性能监控：统计方法的执行时间、次数等性能指标。

3.连接点 切面 切入点 通知

---

切面 @Aspect

定义一个类为切面类 -通知和切入点

@Aspect注解标识一个类为切面类，Spring会在扫描到这个注解的类时，自动创建代理对象，并将切面逻辑织入到目标方法中。

通知

@Before和@After

切入点

execution(* Calculator.divide(..))

-谁会被AOP管理

---

连接点

连接点是代码执行过程中的具体位置，可以被切面（Aspect）拦截并注入相应的增强逻辑。

---

@Before("execution(* Calculator.add(..))")

通知+切入点

代表了 Calculator类的add方法上执行增强操作

在Spring AOP中，切入点用于定义在哪些连接点上应用通知，连接点则代表实际的程序执行点。通常情况下，切入点通过切入点表达式来指定，而连接点表示实际执行的方法调用或事件发生的地方。

接点是由execution表达式指定的，它表示了切入点的具体位置，允许切面在这些位置执行通知。而切入点则是通过execution表达式来定义的，以确定在哪些连接点上应用通知。

案例代码

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int divide(int a, int b) {
        return a / b;
    }
}

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* Calculator.add(..))")
    public void logBeforeAdd(JoinPoint joinPoint) {
        System.out.println("Logging before the add method is called");
    }

    @After("execution(* Calculator.divide(..))")
    public void logAfterDivide(JoinPoint joinPoint) {
        System.out.println("Logging after the divide method is called");
    }
}

<aop:aspectj-autoproxy/>
<context:component-scan base-package="com.example"/>

2.Aop进阶

1.通知类型

1. 前置通知（Before Advice）：在目标方法执行之前调用通知方法。

   对应注解：@Before

2. 后置通知（After Returning Advice）：在目标方法成功执行之后调用通知方法。

   对应注解：@AfterReturning

3. 后置异常通知（After Throwing Advice）：在目标方法抛出异常后调用通知方法。

    @AfterThrowing
   

4. 后置通知（After (finally) Advice）：无论目标方法是否成功执行，都会调用通知方法。

   @After
   

5. 环绕通知（Around Advice）：在目标方法之前和之后执行通知方法，可以控制目标方法的执行过程。

   对应注解：@Around

6. 引入通知（Introduction Advice）：向现有的对象添加新的方法或属性。

7. 织入通知（AspectJ Advice）：在AOP中指定切点和通知的组合。

---

案例

1. 前置通知（Before Advice）：在用户进行结账操作时，检查用户的权限，确保用户具有足够的权限进行结账操作。

2. 后置通知（After Returning Advice）：在用户提交订单成功后，记录订单信息到日志中，或者发送确认邮件给用户。

3. 后置异常通知（After Throwing Advice）：如果订单处理过程中出现异常，比如库存不足，就发送通知给相关人员进行处理。

4. 后置最终通知（After (finally) Advice）：无论订单处理成功与否，都需要关闭数据库连接或释放其他资源。

5. 环绕通知（Around Advice）：在处理订单之前和之后记录订单处理时间，以及性能监控等功能。

6. 引入通知（Introduction Advice）：向订单类引入一个新的接口，比如可追踪变更历史的接口。

7. 织入通知（AspectJ Advice）：定义一个切面，将上述的各种通知类型织入到订单处理的流程中。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@Aspect
public class LoggingAspect {

@Before("execution(* com.example.service.OrderService.processOrder(..))")
public void beforeProcessOrder() {
    System.out.println("Before processing order...");
}

@AfterReturning(pointcut = "execution(* com.example.service.OrderService.processOrder(..))", returning = "result")
public void afterProcessOrder(Object result) {
    System.out.println("After processing order. Result: " + result);
}

@AfterThrowing(pointcut = "execution(* com.example.service.OrderService.processOrder(..))", throwing = "exception")
public void afterThrowingProcessOrder(Exception exception) {
    System.out.println("Exception thrown during order processing: " + exception.getMessage());
}

@After("execution(* com.example.service.OrderService.processOrder(..))")
public void afterProcessOrderCompletion() {
    System.out.println("After processing order completion...");
}

@Around("execution(* com.example.service.OrderService.processOrder(..))")
public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long endTime = System.currentTimeMillis();
    System.out.println("Order processing time: " + (endTime - startTime) + " milliseconds");
    return result;
}

2.通知顺序

当多个切面匹配到同一个类时，可以按照切入点所在类的字母顺序来决定通知方法的执行顺序

1.类字母

按照匹配到的切入点的类字母决定先后顺讯

1.前置-字母排名靠前的先执行

2.后置-字母排名靠前的后执行

2.@Order

可以使用@Order注解来控制多个通知方法的执行顺序。通过@Order注解可以指定通知方法的执行顺序，数值越小的通知方法优先执行。

具体步骤如下：

1. 在定义通知方法的类上添加@Component或其他相关注解，使其成为Spring容器中的Bean。
2. 在通知方法上添加@Order注解，并指定执行顺序的数值，数值越小优先级越高。

@Component
public class MyAspect {

    @Before("execution(* com.example.service.MyService.*(..))")
    @Order(1)
    public void beforeAdvice() {
        // 前置通知的实现
    }

    @AfterReturning("execution(* com.example.service.MyService.*(..))")
    @Order(2)
    public void afterReturningAdvice() {
        // 后置通知的实现
    }
}

目标前-数字小的先执行

目标后-数字小的后执行

3.切入点

1.execution




2.@annotation

代码案例

首先，定义一个自定义注解CustomAnnotation：

@Target(ElementType.METHOD)
//@Target(ElementType.METHOD)：表示该注解可以用于方法上。这意味着CustomAnnotation只能用于方法的声明中，而不能用于其他地方，比如类、字段等。
@Retention(RetentionPolicy.RUNTIME)
///@Retention(RetentionPolicy.RUNTIME)：表示该注解在运行时可以被反射读取。这意味着在运行时，我们可以通过Java的反射机制来获取并处理带有CustomAnnotation注解的方法。
public @interface CustomAnnotation {
    String value();
}
这两个元数据的设定确保了CustomAnnotation注解的使用方式和其在程序运行期间的可见性，使其可以被AOP或其他机制所识别并进行相应的处理。

接着，在一个服务类中使用CustomAnnotation注解：

@Service
public class MyService {

    @CustomAnnotation("Custom Annotation Example")
    public void myMethod() {
        // 方法实现
    }
}

在@CustomAnnotation("Custom Annotation Example")这个注解中，双引号里面的参数是注解的属性值。在定义自定义注解时，可以为注解定义属性，并在使用注解时为这些属性赋值。

在这个示例中，自定义注解CustomAnnotation定义了一个名为value的属性，因此在使用这个注解时，需要为value属性赋值。双引号中的内容 "Custom Annotation Example" 就是为value属性赋的具体数值。

当在切面类中通过反射获取带有CustomAnnotation注解的方法时，可以通过访问注解的属性值来获取这里传入的参数值，从而实现根据不同的属性值执行不同的逻辑处理。

---

然后，在切面类中使用@annotation注解匹配带有CustomAnnotation注解的方法：

@Aspect
public class MyAspect {

    @Pointcut("@annotation(customAnnotation)")
    public void annotatedMethod(CustomAnnotation customAnnotation) {}

    @Before("annotatedMethod(customAnnotation)")
    public void beforeAnnotatedMethod(CustomAnnotation customAnnotation) {
        System.out.println("Before advice for method with custom annotation: " + customAnnotation.value());
    }
}

，切面类MyAspect中的beforeAnnotatedMethod方法使用@annotation注解来匹配带有CustomAnnotation注解的方法，并在匹配到的方法执行前执行相应的通知逻辑。

4.连接点



14.事务

1.事务入门 -例子



1.接口上加入事务--事务会自动加入-


--管理事务



解决方法


2.事务管理员 事务协调员

例子事务



3.事务配置



4.事务加入-规则


例子



如图-都加入同一事务-一旦有异常-日志也会回滚



解决


事务传播行为


0.1 Spring 整合mybatis


->将该注册为Bean



如图--以上配置全部进行修改




收纳



0.2 Spring整合测试

设定类运行器

整合spring运行器