Spring

一.Ioc&DI

1.类的五种控制反转注解

这五个注解作用都一样，只是意义不一样，用来提高代码的可读性。

@Controller：控制层，接收请求，对请求进⾏处理，并进⾏响应。

@Servie：业务逻辑层，处理具体的业务逻辑。

@Repository：数据访问层，也称为持久层，负责数据访问操作。

@Configuration：配置层，处理项⽬中的⼀些配置信息。

@Component：其他

2.bean对象

①bean对象的获取

// 定义bean对象
@Component
public class Text {@Bean(name = {"a1","a2"}) //1.对bean对象进行重命名，2.同一个对象多个名称public UserInof user1(){UserInof user1 = new UserInof();user1.setName("zhangsan");user1.setAge(18);return user1;}
}

@SpringBootTest
class SpringbootDemo3ApplicationTests {// 先获取Spring的上下文对象@Autowiredpublic ApplicationContext applicationContext;@Testpublic void lala(){//根据bean类型, 从Spring上下⽂中获取对象UserInof userinof1 = applicationContext.getBean(UserInof.class);//根据bean名称, 从Spring上下⽂中获取对象UserInof userinof2 = (UserInof)applicationContext.getBean("a1");//根据bean类型+名称, 从Spring上下⽂中获取对象UserInof userinof3 = applicationContext.getBean("a1",UserInof.class);System.out.println("userinof1"+userinof1);System.out.println("userinof2"+userinof2);System.out.println("userinof3"+userinof3);}}

还有其它方式获取bean对象，这里就不过多写了，可以自己看源码。

②bean的命名约定

如果我们用上面的五大注解没有对bean进行命名：如果类是大驼峰bean对象的名字就是小驼峰(注意：当有多个字符并且第⼀个和第⼆个字符都是⼤写时, 将保留原始的⼤⼩写)

类名: UserController, Bean的名称为: userController
类名: UController, Bean的名称为: UController 

3.方法注解@bean

作用：

@Bean 注解的主要作用是告诉 Spring 框架，某个方法会返回一个对象（即一个 Bean），并将这个对象注册到 Spring 的应用上下文中，由 Spring 容器管理。Spring 容器会负责这个 Bean 的生命周期，包括创建、初始化、依赖注入和销毁。

①使用场景

1. 使⽤外部包⾥的类, 没办法添加类注解

2. ⼀个类, 需要多个对象, ⽐如多个数据源

②@bean的基础使用（这里就拿上面写过的代码进行描述）

// 定义bean对象
@Component // 这里必须添加控制反转的注解
public class Text {// 如果这里不对bean对象进行重命名那么bean的名字就是方法的名字@Bean(name = {"a1","a2"}) //1.对bean对象进行重命名，2.同一个对象多个名称public UserInof user1(){UserInof user1 = new UserInof();user1.setName("zhangsan");user1.setAge(18);return user1;}
}

注意事项：

1.@bean注解要配合类注解使⽤（这里的类注解就是必须要实用控制反转的注解）

2.可以给一个类定义多个bean对象

4.扫描路径

我们定义的bean想要生效就需要被spring扫描到，spring默认的扫描路径是：SpringBoot启动类所在包及其⼦包，如果不在我们可以通过添加@ComponentScan来增加我们的扫描路径，但是我们一般不会使用因为很麻烦，我们只需要把@SpringBootApplication的类放好位置即可。

5.DI

①依赖注入的三种方式：

属性注入，构造方法注入，Setter注入：目前最常用的方法是属性注入

1.交给spring管理的对象

@Service
public class UserService {public void sayHi() {System.out.println("Hi,UserService");}
}

2.属性注入（常用）

@Controller
public class UserController {@Autowiredprivate UserService userService;public void sayHi(){System.out.println("hi,UserController...");userService.sayHi();//使用被注入的对象}
}

3.构造方法注入

@Controller
public class UserController2 {private UserService userService;@Autowired//最高加上这个注解来指定用的这个构造方法进行的注入public UserController2(UserService userService) {this.userService = userService;}public void sayHi(){System.out.println("hi,UserController2...");userService.sayHi();//使用被注入的对象}
}

4.Setter方法注入

@Controller
public class UserController3 {private UserService userService;@Autowiredpublic void setUserService(UserService userService) {this.userService = userService;}public void sayHi(){System.out.println("hi,UserController3...");userService.sayHi();}
}

②@Autowired存在的问题

当一个类出现了多个bean对象的时候只使用Autowired注入就会出现问题。

所以有三种解决方案：@Primary，@Qualifier，@Resource

1.@Primary当存在多个相同类型的Bean注⼊时，加上@Primary注解，来确定默认注入是哪一个。

// 用法就像下面一样
@Component
public class BeanConfig {@Primary //指定该bean为默认bean的实现@Bean("u1")public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}@Beanpublic User user2() {User user = new User();user.setName("lisi");user.setAge(19);return user;}
}

2.使⽤@Qualifier注解：指定当前要注⼊的bean对象。 在@Qualifier的value属性中，指定注⼊的bean的名称。

@Controller
public class UserController {@Qualifier("user2") //指定bean名称@Autowiredprivate User user;public void sayHi(){System.out.println("hi,UserController...");System.out.println(user);}
}

注意事项：@Qualifier注解不能单独使⽤，必须配合@Autowired使⽤

3.使⽤@Resource注解：是按照bean的名称进⾏注⼊。通过name属性指定要注⼊的bean的名称。

@Controller
public class UserController {@Resource(name = "user2")private User user;public void sayHi(){System.out.println("hi,UserController...");System.out.println(user);}
}

 ③补充概念梳理：

@Autowird 与 @Resource的区别：

• @Autowired 是spring框架提供的注解，⽽@Resource是JDK提供的注解

• @Autowired 默认是按照类型注⼊，⽽@Resource是按照名称注⼊.

Autowired的装配顺序：

二.AOP

1.添加依赖

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

2.aop的代码案例

@Slf4j
@Aspect  // 标识这是⼀个切⾯类
@Component
public class TimeAspect {/*** 记录⽅法耗时*/@Around("execution(* com.example.demo.controller.*.*(..))")public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {//记录⽅法执⾏开始时间long begin = System.currentTimeMillis();//执⾏原始⽅法Object result = pjp.proceed();//记录⽅法执⾏结束时间long end = System.currentTimeMillis();//记录⽅法执⾏耗时log.info(pjp.getSignature() + "执⾏耗时: {}ms", end - begin);return result;}
}

解释：

1. @Aspect: 标识这是⼀个切⾯类

2. @Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强.

3. ProceedingJoinPoint.proceed() 让原始⽅法执⾏

3.Spring Aop核心概念

①连接点：JoinPoint，可以被AOP控制的方法

②通知：Advice，指定哪些重要的选择，也就其实把功能（最终体现在一个方法）

③切入点：PointCut，匹配连接点的条件，通知道会在切入点方法支持执行的被见用

④切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

⑤目标对象：Target，通短所应用的的对象

4.通知类型（通知的方式）

@Around(感觉这个最常用): 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏

@Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏

@After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏

@AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏

@AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

代码案例：

@Slf4j
@Aspect
@Component
public class AspectDemo {//前置通知@Before("execution(* com.example.demo.controller.*.*(..))")public void doBefore() {log.info("执⾏ Before ⽅法");}//后置通知@After("execution(* com.example.demo.controller.*.*(..))")public void doAfter() {log.info("执⾏ After ⽅法");}//返回后通知@AfterReturning("execution(* com.example.demo.controller.*.*(..))")public void doAfterReturning() {log.info("执⾏ AfterReturning ⽅法");}//抛出异常后通知@AfterThrowing("execution(* com.example.demo.controller.*.*(..))")public void doAfterThrowing() {log.info("执⾏ doAfterThrowing ⽅法");}//添加环绕通知@Around("execution(* com.example.demo.controller.*.*(..))")public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {log.info("Around ⽅法开始执⾏");Object result = joinPoint.proceed();log.info("Around ⽅法结束执⾏");return result;}
}

5.@PointCut

这个代码可以用于定义一个公共的切点，需要⽤到时引⽤该切⼊点表达式即可，这就可以用于解决重复的代码

@Slf4j
@Aspect
@Component
public class AspectDemo {//定义切点(公共的切点表达式)@Pointcut("execution(* com.example.demo.controller.*.*(..))")private void pt(){}//前置通知@Before("pt()")public void doBefore() {//...代码省略}//后置通知@After("pt()")public void doAfter() {//...代码省略}// 后面的代码就不多写了
}

当切点定义使⽤private修饰时，仅能在当前切⾯类中使⽤，当其他切⾯类也要使⽤当前切点定义时，就需要把private改为public。引⽤⽅式为：全限定类名.⽅法名()

@Slf4j
@Aspect
@Component
public class AspectDemo2 {//前置通知@Before("com.example.demo.aspect.AspectDemo.pt()") // 但是我觉得这种写法应该很少public void doBefore() {log.info("执⾏ AspectDemo2 -> Before ⽅法");}
}

6.切面优先级 @Order

在多个切面类同是对一个方法使用 @Before,@After...... 时我们无法判断是那个@Before先执行，这里我们便需要设计切面的优先级，这里我们需要使用的注解是 @Order

@Aspect
@Component
@Order(2)
public class AspectDemo2 {//...代码省略
}@Aspect
@Component
@Order(1)
public class AspectDemo3 {//...代码省略
}@Aspect
@Component
@Order(3)
public class AspectDemo4 {//...代码省略
}

7.切点表达式（这也是Spring AOP的实现⽅式）

①使用execution表达式

语法格式：

execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>)

其中: 访问修饰符和异常可以省略

1. * ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)

        a. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)

        b. 类名使⽤ * 表⽰任意类

        c. 返回值使⽤ * 表⽰任意返回值类型

        d. ⽅法名使⽤ * 表⽰任意⽅法

        e. 参数使⽤ * 表⽰⼀个任意类型的参数

2. .. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数

        a. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包

        b. 可以使⽤ .. 配置参数，任意个任意类型的参数

注意：使用execution表达式更适⽤有规则的，如果没有规则则可以使用下面自定义注解的方式。

②使用@annotation注解

第一步：编写自定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}

对上面两注解的解释

1. @Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅.

        常⽤取值：

        ElementType.TYPE: ⽤于描述类、接⼝(包括注解类型) 或enum声明         ElementType.METHOD: 描述⽅法

        ElementType.PARAMETER: 描述参数

        ElementType.TYPE_USE: 可以标注任意类型

2,@Retention 指Annotation被保留的时间长短，标明注解的生命周期

        @Retention 的取值有三种：

        1.RetentionPolicy.SOURCE：表示注解仅仅存在于源代码中，编译成字节码后会忽略该注解。返回时着 在运行时无法通过反射获取该注解的信息，只能在编译时使用。比如 @SuppressWarnings，以及 lombok提供的注解 @Data，@Slf4j。

        2.RetentionPolicy.CLASS：编译时注解，表示注解存在于字节码文件中，但是在运行时会忽略 该注解。返回时着在编译时和字节码中可以通过通过反射获取到该注解的信息，但在实际运行时无法获取 。通常用手一些框架和工具的具体操作。

        3.RetentionPolicy.RUNTIME：运行时注解，表示注解存在于字节码中，字节码和运行时中都可以 着在编译时，字节码中和运行时都可以通过反射获取到该注解的信息。通常用于一些需要 在运行时处理的具体，如Spring的 @Controller @ResponseBody。

第二步：使⽤ @annotation 表达式来描述切点

@Slf4j
@Component
@Aspect
public class MyAspectDemo {//前置通知@Before("@annotation(com.example.demo.aspect.MyAspect)")public void before(){log.info("MyAspect -> before ...");}//后置通知@After("@annotation(com.example.demo.aspect.MyAspect)")public void after(){log.info("MyAspect -> after ...");}
}

第三步：在连接点的⽅法上添加⾃定义注解

@MyAspect
@RequestMapping("/t1")
public String t1() {return "t1";
}