【spring-应用】

一、给容器注入组件方法

1、@ComponentScan

包扫描，默认扫描当前包下的所有包含@Component的组件，即：@Controller/@Service/@Repository/@Component

2、@Bean

@Bean和@Configuration结合使用，@Bean使用在方法上，用于导入第三方包的组件

3、@Import注入

• @Import({xxx.class})导入相关的类，使用全包名作为名称
• @Import({ImportSelector.class}) 实现ImportSelector的类中方法String[] selectImports(AnnotationMetadata var1)，用于导入String[]包定义
• @Import({ImportBeanDefinitionRegistrar.class}) 实现ImportBeanDefinitionRegistrar的类中方法void registerBeanDefinitions(AnnotationMetadata var1, BeanDefinitionRegistry var2)，用于注册导入信息

4、FactoryBean

• @Bean和实现FactoryBean接口的类整合使用
• 默认获取到的是getObject创建的对象
• 要获取工厂本身，加上前缀&

public interface FactoryBean {
    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class getObjectType();

  // 是否单例模式，true：单例模式，false：多例模式
    default boolean isSingleton() {
        return true;
    }
}

class ColorFactoryBean Implement FactoryBean{
....
}

@Bean
public ColorFactoryBean colorFacotryBean(){
  return new ColorFactoryBean();
}

二、bean的生命周期

bean的生命周期：创建-初始化-销毁

1、 指定初始化和销毁时调用方法

• 创建： 单实例 在容器每次启动时创建对象；多实例 在每次获取的时候创建对象
• 初始化：对象创建好，并赋值好的时候调用初始化方法
• 销毁：单实例 容器关闭的时候；多实例：容器不管理这个Bean，容器不会调用销毁方法

方法一：使用@Bean的属性值

// initMethod : 初始化调用；destroyMethod：销毁时调用
@Bean(initMethod = "",destroyMethod = "")

方法二：通过Bean实现InitializingBean和DisposableBean接口实现afterPropertiesSet()和destroy()方法

invokeInitMethods中执行。

public class Car implements InitializingBean, DisposableBean {

    public Car(){

    }
    
    @Override
    public void afterPropertiesSet() throws Exception {

    }

    @Override
    public void destroy() throws Exception {

    }


}

方法三：使用@PostConstrust和@PreDestroy注解

本质是在初始化前/后（beanProcessor）通过LifecycleMetadata注解信息注入，即在applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization进行。

@Component
public class Car  {

    public Car(){

    }
    
    @PostConstruct
    public void init(){

    }

    @PreDestroy
    public void destroy() {

    }
}

方法四：使用实现BeanPostProcessor 的类执行器

// 对所有的bean实例实现以下执行器
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    // 初始化方法之前
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    
    // 初始化方法之后
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

方法一二是初始化时执行，方法三四是后置处理器在初始化前后执行

三、值注入

spring_@Value/@PropertySource..

• @value：可以赋值给指定的属性，配合使用@Configuration可以获得文件中的值，默认会获得系统默认的application.properties，使用@Value("${id}")可以访问properties文件的key-value，也可以通过@PropertySource("classpath:applicaiton.yml")自定义设置，如果使用@Component导入，如果异常可采用@ConfigurationProperties(prefix="")注解定义前缀获得。

• @PropertySource()：在configuration类中指定使用的环境文件

• @Autowired：注入容器，优先按照类型注入，如果存在多个同类型，按照属性名称相同注入

• @Qualifier("xxx")：指定需要装配的组件id，而不是属性名，使用在@Autowired上面，对@Autowired注入进行筛选，选择组件id符合Qulifier的组件注入

• @Primary：与@Component组件一起，说明此组件优先注入，优先级小于@Quealifier

@Resource

不支持spring上述注解，基于java规范JSR-250

@Inject

需要导入Javax.inject

四、@profile

使用profile切换环境配置，将@profile("dev")添加到组件的注解上，表示该组件在dev环境时会创建使用，默认是default，即所有环境都会使用。

启动1：命令行

// dev为自己在配置文件中定义的环境名称
java -jar -Dspring.profiles.active=dev xxx.jar

启动2：配置文件设置

// 在配置文件例如：application.properties
spring.profile.active=dev

// 或者如果是application.yml
spring:
    profile:
      active: dev

spring-boot的profile

在application.yml(application.properties)中设置active，即采用第二种启动方式

spring:
  profiles:
    active: dev

在application.yml同级目录创建application-dev.yml，即在环境运行时，自动导入的是application.yml和application-dev.yml配置。同时可以设置application-prod.yml生产环境。在不同环境设置数据库信息，以备切换不同环境使用。

五、spring aop

1、定义切面类

@Aspect
@Component
public class LogAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void pointcut(){};

    @Before("execution(public void com.example.service.RunService.start())")
    public void logStart(JoinPoint joinPoint){
        System.out.println("AOP切入————Before————"+joinPoint.getSignature().getName()+"————"+ Arrays.asList(joinPoint.getArgs()));
    }

    @After("pointcut()")
    public void logAfter(JoinPoint joinPoint){
        System.out.println("AOP切入————After————"+joinPoint.getSignature().getName()+"————"+ Arrays.asList(joinPoint.getArgs()));
    }

    @AfterReturning(value = "pointcut()",returning = "result")
    public void logReturn(JoinPoint joinPoint, Object result){
        System.out.println("AOP切入————Return————"+result+"————"+joinPoint.getSignature().getName()+"————"+ Arrays.asList(joinPoint.getArgs()));
    }

    @AfterThrowing(value = "pointcut()",throwing = "exception")
    public void logException(JoinPoint joinPoint,Exception exception){
        System.out.println("AOP切入————Exception————"+exception+"————"+joinPoint.getSignature().getName());
    }

    @Around("pointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("AOP切入————Around1————");
        Object proceed = joinPoint.proceed();
        System.out.println("AOP切入————Around2————");
        return proceed;
    }
}

2、开启代理

@EnableAspectJAutoProxy
@Configuration
public class MainConfig {

}

@Conditional