spring&&springboot

鲁般一号

于 2023-02-17 11:26:52 发布

阅读量89

点赞数

文章标签： spring spring boot java

本文链接：https://blog.csdn.net/wwssuu/article/details/128817116

版权

常用注解

@Bean

@Bean只能存在于配置类中，当配置类中的方法存在这个注解时，这个注解会将方法的返回值放入ioc容器中去。当@Bean标注的方法中有参数的时候，会去ioc容器中寻找该类型的bean 作为参数注入进该方法中。

实际开发中，经常会遇到在 Bean 使用之前或使用之后做些必要的操作，我们可以通过 @Bean 注解的 initMethod 和 destroyMethod 进行指定 Bean 在初始化和销毁时需要调用相应的方法。@Bean(initMethod="init", destroyMethod="destroy")

@Bean 注解默认作用域为单例 singleton 作用域。

默认情况下 Bean 名称就是方法名，@Bean 注解支持设置别名。比如下面除了主名称 myBean 外，还有个别名 myBean1（两个都可以使用） @Bean("myBean1")

一、作用在类上：

使用@Component、@Repository、@Service、@Controller等注解创建bean时

如果不指定bean名称，bean名称的默认规则是类名的首字母小写，如UserService->userService

如果类名前两个或以上个字母都是大写，那么bean名称与类名一样，如RBACUser - >RBACUser

二、作用在方法上：

@Bean 作用于方法上创建bean

如果不指定bean名称，bean名称的默认规则是 “方法名(首字母小写)”的配置方式

@DependsOn 注解：表示在当前 Bean 创建之前需要先创建特定的其他 Bean

@Scope

指定bean的作用域,@Scope可以用在类上和方法上

参数：value和scopeName效果一样，用来指定bean作用域名称，如：singleton、prototype

@Autowired

默认情况下按照类型在spring容器中查找对应的组件；

如果容器中有多个可以类型可以与之匹配，则自动切换为以属性的名称作为组件名称byName装配；

如果@Qualifier指定了一个bean的名字，是根据指定名称来进行注入的；

⽆论⽤哪⼀种⽅式，必须保证容器中提供了可⾃动装配的组件，否则会报

NoSuchBeanDefinitionException异常。如果没有匹配的组件不想报异常，需要添加@Autowired(required=false)

@Autowired 作用于属性上。如果被注入的对象是Collection类型的，可以指定泛型的类型，然后会按照上面的方式查找所有满足泛型类型所有的bean；如果被注入的对象是Map类型的，可以指定泛型的类型，key通常为String类型，value为需要查找的bean的类型，然后会按照上面方式查找所有注入value类型的bean，将bean的name作为key，bean对象作为value，放在HashMap中，然后注入。

@Autowired查找候选者可以简化为，先按类型找，然后按名称找

按类型找->通过限定符@Qualifier过滤->@Primary->@Priority->根据名称找（字段名称或者方法名称）

@Resource

和@Autowired注解类似，也是用来注入依赖的对象的，spring容器会对bean中所有字段、方法进行遍历，标注有@Resource注解的，都会进行注入。这个注解是javax中定义的，并不是spring中定义的注解。从定义上可以见，这个注解可以用在任何类型上面、字段、方法上面。注意用在方法上的时候，方法参数只能有一个。

@Resource查找候选者可以简化为，先按名称找，然后按类型找

先按Resource的name值作为bean名称找->按名称（字段名称、方法名称、set属性名称）找->按类型找->通过限定符@Qualifier过滤->@Primary->@Priority->根据名称找（字段名称或者方法参数名称）

@Lazy

Spring在应用程序上下文启动时去创建所有的单例bean对象；

当@Lazy 放在类上，表示在启动的时候不会创建bean对象，当使用的时候才会创建；

当@Lazy 放在@Bean注解的方法上，表示在启动的时候不会创建bean对象，当使用的时候才会创建；

当@Lazy 放在@Autowired注解的属性上，并不会直接给属性赋上真正的值，只是会赋值一个代理对象，当真正使用到这个属性的时候，才回去容器中找到一个符合的对象。在使用的时候，也会先执行代理对象的逻辑，然后再是真正bean对象的逻辑；

使用场景：循环依赖的时候可以在循环依赖的对象加上@Lazy注解；写在方法或者方法参数前面上，效果和写在属性上是一样的，开始注入的只是代理对象，当真正调用的时候才会调用对应对象的逻辑；

@Configuration

用于定义配置类，可替换XML配置文件，被注解的类内部包含一个或多个@Bean注解方法。可以被AnnotationConfigApplicationContext或者AnnotationConfigWebApplicationContext 进行扫描。用于构建bean定义以及初始化Spring容器。

@Configration 注解：声明当前类是一个配置类，相当于 Spring 中的一个 XML 文件
@Bean 注解：作用在方法上，声明当前方法的返回值是一个 Bean

@ImportResource

配置类中导入bean定义的配置文件，有些项目，前期可能采用xml的方式配置bean，后期可能想采用spring注解的方式来重构项目，spring为了方便在注解方式中兼容老的xml的方式，提供了@ImportResource注解来引入bean定义的配置文件。

spring配置文件加载

@Value

使用方法

步骤一：在配置类上使用@PropertySource注解来引入配置文件

步骤二：使用@Value注解来引用配置文件中的值

数据来源

如果我们想改变@Value数据的来源，可以将配置信息放在db或者其他存储介质中，容器启动的时候，只需要将配置信息包装为PropertySource对象，丢到Environment中MutablePropertySources内部就可以了。

动态刷新

springboot中使用@RefreshScope实现了@Value动态刷新。

实现原理：当自定义的Scope中proxyMode=ScopedProxyMode.TARGET_CLASS的时候，会给这个bean创建一个代理对象，调用代理对象的任何方法，都会调用这个自定义的作用域实现类（上面的BeanMyScope）中get方法来重新来获取这个bean对象。

@ConfigurationProperties

1.可以搭配@bean使用，将配置文件中的相关配置和类里面的属性进行绑定。

2.可以将属性转换成bean对象，这里如果不用@component修饰，则在容器无法获取。如果只使用@ConfigurationProperties需要结合@EnableConfigurationProperties(PropertisInject.class)将其注册到spring容器中。

@Value 和 @ConfigurationProperties 区别

	@ConfigurationProperties	@Value
功能	批量注入配置文件中的属性	一个个指定属性
松散绑定	支持	不支持
SPEL(计算式)	不支持	支持
JSR303数据校验	支持	不支持
复杂类型	支持	不支持

@PropertySource

@PropertySource注解引入配置文件

将@PropertySource放在类上面，如下

@PropertySource({"配置文件路径1","配置文件路径2"...})
@PropertySource注解有个value属性，字符串数组类型，可以用来指定多个配置文件的路径。

spring多线程

@Async

基于@Async标注的方法，称之为异步方法；这些方法将在执行的时候，将会在独立的线程中被执行。@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为SimpleAsyncTaskExecutor。

在SpringBoot环境中，要使用@Async注解，我们需要先在启动类上加上@EnableAsync注解。

上面介绍了Spring默认的线程池simpleAsyncTaskExecutor，但是Spring更加推荐我们开发者使用ThreadPoolTaskExecutor类来创建线程池，其本质是对java.util.concurrent.ThreadPoolExecutor的包装。

Spring提供了xml来配置ThreadPoolTaskExecutor线程池，使用SpringBoot开发项目，直接上yaml或者properties配置即可，或者也可以使用@Configuration配置。

Mockito常用注解

@Mock && @InjectMocks

mock测试框架Mockito提供的注解。

@Mock: 创建一个Mock.

@InjectMocks: 创建一个实例，简单的说是这个Mock可以调用真实代码的方法，其余用@Mock（或@Spy）注解创建的mock将被注入到用该实例中。

注意：必须使用@RunWith(MockitoJUnitRunner.class) 或 Mockito.initMocks(this)进行mocks的初始化和注入。

LOMBOK常用注解

注解	作用
@Getter	类注解，代替 getter 方法。
@Setter	类注解，代替 setter 方法。
@ToString	类注解，生成 toString 方法。
@ToString.Exclude	字段注解，排除不需要在 toString 中出现的字段。
@ToString.Include	字段注解，标记需要出现在 toString 中的字段。
构造器相关注解
@NoArgsConstructor	类注解，生成无参构造方法。
@AllArgsConstructor	类注解，生成除static字段之外带有各参数的构造方法。
@RequiredArgsConstructor	作用于类，生成包含 final 和 @NonNull 注解的成员变量的构造方法。
@EqualsAndHashCode	根据类所拥有的非静态字段自动重写 equals() 方法和 hashCode() 方法。
@EqualsAndHashCode.Exclude	排除字段在重写的 equals 方法和 hashCode 方法中。
@EqualsAndHashCode.Include	指定字段在重写的 equals 方法和 hashCode 方法中。
@Data	类注解，综合注解，包含：@Getter, @Setter, @ToString , @RequiredArgsConstructor, @EqualsAndHashCode。
@Value	类注解，综合注解，包含：@Getter, @ToString, @RequiredArgsConstructor, @EqualsAndHashCode。
@Builder	生成当前类的字段构建方法。生成 builder() 方法，并且直接根据字段名称方法进行字段赋值，最后使用 build() 方法构建出一个实体对象。
@Singular	作用于集合字段，需要配合 @Builder 使用。
@SuperBuilder	生成父类的字段构建方法。
@Synchronized	作用于方法，可以替换 synchronized 关键字或 lock 锁。
@SneakyThrows	在没有 throws 关键字的情况下，隐蔽地抛出受检查异常。
@val	作用于类、变量，主要用于声明变量的类型，注解将从初始化程序表达式中推断类型，生成的变量是 final 类型。
@var	和 @val 一样，作用于类、变量，主要用于声明变量的类型，注解将从初始化程序表达式中推断类型，两者区别在于 var 不加 final。
@With	作用于类、变量，生成构造方法以及with + 变量名的方法，返回当前对象。
@WithBy	只作用于类，只生成with + 变量名的方法，返回当前对象。
@Generated	用于标记类、变量、方法是自动生成的，没什么大用。
@Cleanup	标记需要释放清理操作的资源对象变量，标记之后资源对象使用完毕后，就会被自动关闭和清理。
日志注解
@CommonsLog	org.apache.commons.logging.Log
@Flogger	com.google.common.flogger.FluentLogger
@JBosLog	org.jboss.logging.Logger
@Log	java.util.logging.Logger
@Log4j	org.apache.log4j.Logger
@Log4j2	org.apache.logging.log4j.Logger
@Slf4j	org.slf4j.Logger
@XSlf4j	org.slf4j.ext.XLogger
实验性注解
@Accessors	类似于 @Builder 支持链式调用，需要配合 @Setter、@Getter 等注解使用，作用于类、变量。
@Delegate	作用于容器变量，为该变量生成一堆常用的方法，这些方法都是容器中的方法。
@ExtensionMethod	作用于类，向类添加方法，无需创建新的子类。
@FieldDefaults	作用于类，定义变量的访问修饰符，以及是否设置为 final。
@FieldNameConstant	作用于类，生成一个包含所有成员变量的内部类或者内部枚举，内部类中每个字段值即为字段名并且值不可变。
@Helper	作用于方法内部类，使内部类中的方法暴露在外面可以被直接调用，不建议使用。
@NonFinal	作用于类、变量，表示变量不加 final。
@PackagePrivate	作用于类和变量，相当于访问修饰符的 default，没什么用。
@SuperBuilder	支持对于基类成员变量赋值，算是 @Builder 的升级版。
@Tolerate	实现对冲突的兼容，作用于方法上，没什么大用，可以配合 @Builder 使用。
@UtilityClass	作用于类，将类标记为 final，并且类、内部类中的方法、字段都标记为 static。
@StandardException	自定义异常类。

spring基础

InitializingBean

InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。spring初始化bean的时候，如果bean实现了InitializingBean接口，会自动调用afterPropertiesSet方法。

自定义注解

常用元注解

Target:注解修饰的对象范围

METHOD：用于描述方法
PACKAGE：用于描述包
PARAMETER：用于描述方法变量
TYPE：用于描述类、接口或enum类型

Retention:注解保留时间长短

SOURCE：在源文件中有效，编译过程中会被忽略
CLASS：随源文件一起编译在class文件中，运行时忽略
RUNTIME：在运行时有效

自定义注解定义

注解的定义和我们常见的类、接口类似，只是注解使用@interface来定义


public @interface MyAnnotation {
}

注解有没有参数都可以，定义参数如下：

public @interface 注解名称{
    [public] 参数类型 参数名称1() [default 参数默认值];
    [public] 参数类型 参数名称2() [default 参数默认值];
    [public] 参数类型 参数名称n() [default 参数默认值];
}

注解中可以定义多个参数，参数的定义有以下特点：

访问修饰符必须为public，不写默认为public

该元素的类型只能是基本数据类型、String、Class、枚举类型、注解类型（体现了注解的嵌套效果）以及上述类型的一位数组

该元素的名称一般定义为名词，如果注解中只有一个元素，请把名字起为value（后面使用会带来便利操作）

参数名称后面的()不是定义方法参数的地方，也不能在括号中定义任何参数，仅仅只是一个特殊的语法

default代表默认值，值必须和第2点定义的类型一致

如果没有默认值，代表后续使用注解时必须给该类型元素赋值

Spring 自定义切面注解总的来说分为三步：

一、对自定义注解进行声明；

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

二、对自定义切面进行声明，在自定义切面类中对注解切入时执行的方法进行业务编写；

@Aspect // 1.表明这是一个切面类
@Component
public class MyLogAspect {

    // 2. PointCut表示这是一个切点，@annotation表示这个切点切到一个注解上，后面带该注解的全类名
    // 切面最主要的就是切点，所有的故事都围绕切点发生
    // logPointCut()代表切点名称
    @Pointcut("@annotation(me.zebin.demo.annotationdemo.aoplog.MyLog)")
    public void logPointCut(){};

    // 3. 环绕通知
    @Around("logPointCut()")
    public void logAround(ProceedingJoinPoint joinPoint){
        // 获取方法名称
        String methodName = joinPoint.getSignature().getName();
        // 获取入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for(Object o : param){
            sb.append(o + "; ");
        }
        System.out.println("进入[" + methodName + "]方法,参数为:" + sb.toString());

        // 继续执行方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println(methodName + "方法执行结束");

    }
}

三.使用注解