Spring注解驱动开发(二)

注：此笔记为尚硅谷Spring注解驱动教程(雷丰阳源码级讲解)学习笔记，并同时参考[https://blog.csdn.net/xjhqre/article/details/123264069]博主文章，其中包含个人的笔记和理解，仅做学习笔记之用。

8、Bean生命周期

简述：

1、实例化一个Bean－－也就是我们常说的new；

2、按照Spring上下文对实例化的Bean进行配置－－也就是IOC注入；

3、如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String)方法，此处传递的就是Spring配置文件中Bean的id值

4、如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory(setBeanFactory(BeanFactory)传递的是Spring工厂自身（可以用这个方式来获取其它Bean，只需在Spring配置文件中配置一个普通的Bean就可以）；

5、如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文（同样这个方式也可以实现步骤4的内容，但比4更好，因为ApplicationContext是BeanFactory的子接口，有更多的实现方法）；

6、如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术；

7、如果Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。

8、如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法、；

注：以上工作完成以后就可以应用这个Bean了，那这个Bean是一个Singleton的，所以一般情况下我们调用同一个id的Bean会是在内容地址相同的实例，当然在Spring配置文件中也可以配置非Singleton，这里我们不做赘述。

9、当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用那个其实现的destroy()方法；

10、最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

以下为详细介绍：

bean从创建 ----> 初始化 -----> 销毁的过程

容器管理bean的生命周期

我们可以自定义初始化和销毁方法

构造(对象创建)

​ 单实例：在容器启动的时候创建对象
​ 多实例：在每次获取的时候创建对象
初始化

• 对象完成创建，并赋值好后，调用初始化方法

销毁

• 单实例：在容器关闭的时候销毁
• 多实例：容器不会管理这个bean，所以不会调用销毁方法

初始化和销毁方法：

先查看源码，再调用API

1.通过@Bean注解指定init-method和destroy-method
2.实现InitializingBean和DisposableBean接口，重写里面的destroy和afterPropertiesSet方法
3.使用@PostConstruct和@PreDestroy注解
4.BeanPostProcessor：接口，bean后置处理器，在bean初始化前后进行一些处理

初始化和销毁方法：

先查看源码，再调用API

1.通过@Bean注解指定init-method和destroy-method
2.实现InitializingBean和DisposableBean接口，重写里面的destroy和afterPropertiesSet方法
3.使用@PostConstruct和@PreDestroy注解
4.BeanPostProcessor：接口，bean后置处理器，在bean初始化前后进行一些处理

8.1、自定义初始化和销毁方法

最原始在bean.xml中自定义的bean初始化和销毁方法

通过@Bean注解指定init-method和destroy-method

8.1.1、创建Car类

@Component
public class Car {
	public Car(){
		System.out.println("car constructor...");
	}
	
	public void init(){
		System.out.println("car ... init...");
	}
	
	public void detory(){
		System.out.println("car ... detory...");
	}
}

8.1.2、创建配置文件

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre")
public class MainConfig5 {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

8.1.3、测试

@Test
public void test6() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig5.class);
    applicationContext.close();
}

8.2、InitializingBean和DisposableBean

通过让bean实现InitializingBean接口来定义初始化逻辑

通过让bean实现DisposableBean接口来定义销毁逻辑

在InitializingBean中有一个方法afterPropertiesSet，该方法在bean创建并赋值后调用

8.2.1、创建Cat类

public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("创建猫对象");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("销毁猫对象");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化猫对象");
    }
}

8.2.2、创建配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre.pojo")
public class MainConfig6 {

    @Bean
    public Cat cat() {
        return new Cat();
    }
}

8.2.3、测试

@Test
public void test7() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig6.class);
    applicationContext.close();
}

8.3、@PostConstruct和@PreDestroy

@PostConstruct：在bean创建完成并且属性赋值完成后进行初始化

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PostConstruct {
}

@PreDestroy：在容器销毁bean之前执行

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
}

8.3.1、创建Dog类

public class Dog {

    public Dog() {
        System.out.println("创建狗对象");
    }

    @PostConstruct
    public void init() {
        System.out.println("初始化狗对象");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("销毁狗对象");
    }
}

8.3.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre.pojo")
public class MainConfig7 {

    @Bean
    public Dog dog() {
        return new Dog();
    }
}

8.3.3、测试

@Test
public void test8() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig7.class);
    applicationContext.close();
}

8.4、BeanPostProcessor

BeanPostProcessor接口中有两个方法：

• postProcessBeforeInitialization：在初始化之前执行
• postProcessAfterInitialization：在初始化之后执行

8.4.1、编写MyBeanPostProcessor

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * @param bean 刚创建好的实例
     * @param beanName 实例的id
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("id为" + beanName + "的bean对象：" + bean + "执行postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("id为" + beanName + "的bean对象：" + bean + "postProcessAfterInitialization");
        return bean;
    }
}

8.4.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre.pojo")
public class MainConfig7 {

    @Bean
    public Dog dog() {
        return new Dog();
    }
}

8.4.3、测试

@Test
public void test8() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig7.class);
    applicationContext.close();
}

8.4.4、BeanPostProcessor执行过程

执行populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
开始initializeBean初始化bean
先执行applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);，遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
然后执行invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
最后执行applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

9、@Value注解

使用**@Value赋值**，赋值方法：

1. 直接在@Value中写基本数值
2. 使用SpEL表达式：#{}
3. 使用${}：取出配置文件中的值（在运行环境变量里的值）

9.1、修改Person类

public class Person {

    @Value("kdz")
    private String name;

    @Value("#{20-2}")
    private Integer age;

    @Value("${person.email}")
    private String email;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

9.2、配置类

@PropertySource(value = {"classpath:/person.properties"})
@ComponentScan(value = "com.kdz.pojo")
public class MainConfig9 {

    @Bean
    public Person person() {
        return new Person();
    }
}

9.3、测试类

@Test
public void test9() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig9.class);
    Person person = applicationContext.getBean(Person.class);
    System.out.println(person);

    // 也可以使用环境变量取出
    ConfigurableEnvironment environment = applicationContext.getEnvironment();
    String property = environment.getProperty("person.email");
    System.out.println(property);
}

10、自动装配

Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值

10.1、@AutoWired

给属性自动注入值

默认优先按照类型去容器中找对应的组件，找到就赋值。

如果该类型的组件有多个，再将属性名作为组件的id去容器中查找

@AutoWired可以在构造器、参数、方法、属性上标注

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

   boolean required() default true;

}

10.1.1、required属性

@AutoWired可以给required属性赋值，类型为boolean，默认为true。表示该组件是否必须。

当required=false时，表示这个组件不是必须的，在调用getBean方法时如果找不到对应的组件时不会直接抛出异常，而是返回一个null

10.1.2、标注在方法上

标注在方法上，Spring容器创建当前对象，就会调用方法，完成赋值

方法使用的参数，自定义类型的值从IOC容器中获取

@Autowired
public void setCar(Car car) {
    this.car = car;
}

10.1.3、标注在构造器上

默认加在IOC容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作

我们可以在有参构造函数上标注@Autowired，让IOC容器创建组件时调用该类的有参构造方法

如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略

@Autowired
public Boss(Car car) {
    this.car = car;
}

10.1.3、标注在参数上

public Boss(@Autowired Car car) {
    this.car = car;
}

@Bean标注的方法创建对象的时候，方法参数的值从容器中获取

// 参数car会从IOC容器中获取,可以省略Car前的@Autowired
@Bean
public Color color(Car car) {
    return new Color();
}

10.2、@Qualifier

使用@Qualifier指定需要装配的组件的id，而不是用属性名

@Qualifier需要和@AutoWired一起使用

10.3、@Primary

该注解可以让Spring进行自动装配的时候，默认使用首选的bean

也可以继续使用@Qualifier指定需要装配的bean的名字

无论是否有依赖注入，@Primary标注的bean都会被容器创建

/**
 * 指示当多个候选者有资格自动装配单值依赖项时，应优先考虑 bean。如果候选中恰好存在一个“主”bean，则它将是自动装配的值。
 * 这个注解在语义上等同于 Spring XML 中<bean>元素的primary属性。
 * 可用于任何直接或间接使用@Component注释的类或使用Bean注释的方法。
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}

10.4、@Resource

可以和@Autowired一样实现自动装配功能，但默认是按组件名称进行装配

可以给属性name赋值，自定义组件名称

@Resource(name="bookDao2")
private BookDao bookDao;

但该注解没有支持@Primary、@Autowired(require=false)的功能

10.5、@Inject

需要导入javax.inject依赖

和@Autowired功能一样，但没有required=false的功能

@Inject
private BookDao bookDao;

三种注入方式的小结

构造器需要对象直接从容器中获取

默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作

11、使用Spring容器底层组件

自定义组件想要使用Spring容器底层的一些组件（ApplicationContext、BeanFactory），需要自定义组件实现xxxAware接口

在创建对象的时候，会调用接口规定的方法，注入相关的组件

Aware的子接口

11.1、编写Red类

@Component
public class Red implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

    // 获取IOC容器
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("IOC容器：" + applicationContext);
        this .applicationContext = applicationContext;
    }

    // 获取当前bean对象的名称
    @Override
    public void setBeanName(String name) {
        System.out.println("当前bean的名字：" + name);
    }

    // 解析String语句中的占位符 $ 或 #
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String s = resolver.resolveStringValue("你好${os.name}， 我是#{20*18}");
        System.out.println("解析的字符串：" + s);
    }
}

11.2、配置类

@Configuration // 告诉Spring这是一个配置类
@ComponentScan(value = "com.xjhqre.pojo")
public class MainConfig10 {
}

11.3、测试

@Test
public void test10() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig9.class);
}

11.4 Aware小结

每一个xxxAware都有一个对应的xxxAwareProcessor(后置处理器)，用来处理相关逻辑

以ApplicationContextAwareProcessor为例

遍历所有的processor

利用后置处理器processor判断Aware的类型，注入对应的ApplicationContext

12、@Profile注解

@Profile注解是Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能

例子：在不同环境下使用不同的数据源，在开发环境下使用A数据源，在测试环境下使用B数据源，在生产环境下使用C数据源

需要导入c3p0依赖C3p0:JDBC DataSources/Resource Pools和数据库驱动依赖MySQL Connector

12.1、编写db.properties

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456

12.2、编写配置类

@Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定的话在任何环境下都能注册这个组件

加了环境标识的bean，只有在这个环境被激活的时候才能注册到容器中，默认环境为default，即@Profile("default")

@Profile注解写在类上时，只有当指定的环境被激活时，整个类才会被注册

@Configuration // 告诉Spring这是一个配置类
@PropertySource("classpath:/db.properties")
public class MainConfig11 implements EmbeddedValueResolverAware {

    @Value("${jdbc.username}")
    private String user;

    private StringValueResolver valueResolver;

    // 测试数据库
    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    // 开发数据库
    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/atguigu?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    // 生产数据库
    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${jdbc.password}")String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true");
        String driverClass = valueResolver.resolveStringValue("${jdbc.driverClassName}");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
    }
}

12.3、环境激活方式

激活运行环境方式：

1.命令行方式，在虚拟机选项中输入：-Dspring.profiles.active=test

2.使用代码方式：

1)使用无参构造器创建application，AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
2)设置需要激活的环境：applicationContext.getEnvironment().setActiveProfiles("test", "dev");
3)注册主配置类：applicationContext.register(MainConfig11.class);
4)刷新容器：applicationContext.refresh();

12.4、测试

测试中使用代码方式激活环境

@Test
public void test11() {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    applicationContext.getEnvironment().setActiveProfiles("test", "dev");
    applicationContext.register(MainConfig11.class);
    applicationContext.refresh();
    String[] dataSources = applicationContext.getBeanNamesForType(DataSource.class);
    for (String dataSource : dataSources) {
        System.out.println(dataSource);
    }
}

只能使用无参构造的方式创建容器的原因

Spring注解驱动开发(二)的学习笔记到此完结，笔者归纳、创作不易，大佬们给个3连再起飞吧文章来源地址https://www.toymoban.com/news/detail-770972.html

到了这里，关于Spring注解驱动开发(二)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！