ssm笔记二（IoC二）

最新推荐文章于 2023-04-22 17:46:57 发布

Red Chrysanthemum

最新推荐文章于 2023-04-22 17:46:57 发布

阅读量103

点赞数

分类专栏： java ssm

本文链接：https://blog.csdn.net/qq_43537412/article/details/105609705

版权

java 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

ssm

5 篇文章 0 订阅

订阅专栏

容器扩展点

通常，应用程序开发人员不需要为ApplicationContext实现子类。相反，Spring IoC容器可以通过插件来实现扩展。

使用BeanPostProcessor定制Beans

BeanPostProcessor接口定义了一些回调方法，开发者可以通过实现它来提供自己的实例化逻辑。

可以配置多个BeanPostProcessor。通过设置他们的order属性来决定它们执行顺序，前提是BeanPostProcessor实现了Ordered接口。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;
import org.springframework.lang.Nullable;

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

当实现BeanPostProcessor接口的类注册为容器的后置处理器（post-processor）时，创建每个bean实例都会调用后置处理器的方法。

注册BeanPostProcessor实例的方法：
1、通过ApplicationContext自动发现（推荐）。
2、编程式注册。通过 ConfigurableBeanFactory 的 addBeanPostProcessor 方法。

用BeanFactoryPostProcessor自定义配置元数据

和BeanPostProcessor类似，主要区别是BeanFactoryPostProcessor操作的是bean配置元数据。

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

@FunctionalInterface
public interface BeanFactoryPostProcessor {

	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
	
}

Spring提供了一些现成的bean factory post-processors，例如 PropertyOverrideConfigurer 和 PropertySourcesPlaceholderConfigurer。

通过FactoryBean自定义实例化逻辑

package org.springframework.beans.factory;

import org.springframework.lang.Nullable;

public interface FactoryBean<T> {

	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

	@Nullable
	T getObject() throws Exception;

	@Nullable
	Class<?> getObjectType();
	
	default boolean isSingleton() {
		return true;
	}

}

基于注解的容器配置

注解注入在XML注入之前，因此XML的配置可以重写注解的配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

<context:annotation-config/>查找注解。

隐式注册的后置处理器包括：AutowireAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor。

@Required（5.1之后deprecated）

适用于bean属性的setter方法。如果被注解的属性未被注入则会抛出异常。

public class Example {
	private int test;
	
	@Required
	public void setTest(int test) {
		this.test = test;
	}

	//...
}

@Autowired

自动装配。

适用于构造器。如果只有一个构造器则不是必须的。

public class MovieRecommender {

    private final CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}

适用于setter方法。

public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Autowired
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // ...
}

适用于属性。

public class MovieRecommender {
    @Autowired
    private MovieCatalog movieCatalog;

    // ...
}

适用于容器，bean可以实现 @Order 或 @Priority 来指定顺序，否则按注册顺序。

public class MovieRecommender {

    private Set<MovieCatalog> movieCatalogs;

    @Autowired
    public void setMovieCatalogs(Set<MovieCatalog> movieCatalogs) {
        this.movieCatalogs = movieCatalogs;
    }

    // ...
}

可以使用 @Autowired(required = false) 或 java.util.Optional 或 @Nullable 表明不是必须。与@Nullable相反的是@NonNull。

@Primary

使用后，同类型时@Autowired将首先使用该bean。

@Qualifier

指明注入时使用哪个bean。

public class MovieRecommender {

    @Autowired
    @Qualifier("main")
    private MovieCatalog movieCatalog;

    // ...
}

public class MovieRecommender {

    private MovieCatalog movieCatalog;

    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public void prepare(@Qualifier("main") MovieCatalog movieCatalog,
            CustomerPreferenceDao customerPreferenceDao) {
        this.movieCatalog = movieCatalog;
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean class="example.SimpleMovieCatalog">
        <qualifier value="main"/> 

        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <qualifier value="action"/> 

        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

可以自定义@Qualifier。

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Genre {

    String value();
}

public class MovieRecommender {

    @Autowired
    @Genre("Action")
    private MovieCatalog actionCatalog;

    private MovieCatalog comedyCatalog;

    @Autowired
    public void setComedyCatalog(@Genre("Comedy") MovieCatalog comedyCatalog) {
        this.comedyCatalog = comedyCatalog;
    }

    // ...
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean class="example.SimpleMovieCatalog">
        <qualifier type="Genre" value="Action"/>
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <qualifier type="example.Genre" value="Comedy"/>
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean id="movieRecommender" class="example.MovieRecommender"/>

</beans>

在xml中qualifier标签使用type属性指明注解。

自定义的注解中可以含有多个属性。

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface MovieQualifier {

    String genre();

    Format format();
}

public enum Format {
    VHS, DVD, BLURAY
}

public class MovieRecommender {

    @Autowired
    @MovieQualifier(format=Format.VHS, genre="Action")
    private MovieCatalog actionVhsCatalog;

    @Autowired
    @MovieQualifier(format=Format.VHS, genre="Comedy")
    private MovieCatalog comedyVhsCatalog;

    @Autowired
    @MovieQualifier(format=Format.DVD, genre="Action")
    private MovieCatalog actionDvdCatalog;

    @Autowired
    @MovieQualifier(format=Format.BLURAY, genre="Comedy")
    private MovieCatalog comedyBluRayCatalog;

    // ...
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean class="example.SimpleMovieCatalog">
        <qualifier type="MovieQualifier">
            <attribute key="format" value="VHS"/>
            <attribute key="genre" value="Action"/>
        </qualifier>
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <qualifier type="MovieQualifier">
            <attribute key="format" value="VHS"/>
            <attribute key="genre" value="Comedy"/>
        </qualifier>
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <meta key="format" value="DVD"/>
        <meta key="genre" value="Action"/>
        <!-- inject any dependencies required by this bean -->
    </bean>

    <bean class="example.SimpleMovieCatalog">
        <meta key="format" value="BLURAY"/>
        <meta key="genre" value="Comedy"/>
        <!-- inject any dependencies required by this bean -->
    </bean>

</beans>

使用 CustomAutowireConfigurer：
CustomAutowireConfigurer是BeanFactoryPostProcessor的一个实现类，它可以注册自定义的qualifier注解类型，无需指定@Qualifier注解。

<bean id="customAutowireConfigurer"
        class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer">
    <property name="customQualifierTypes">
        <set>
            <value>example.CustomQualifier</value>
        </set>
    </property>
</bean>

AutowireCandidateResolver 通过以下方式确定自动注入候选者：
每个bean定义的autowire-candidate值。
在<beans/>元素上使用任何default-autowire-candidates模式。
存在@Qualifier注解和注册到CustomAutowireConfigurer的任何注解。

@Resource

利用名称注入，如果没有显式指定名称，则默认名称将从字段名或setter方法派生，如果是字段，则使用字段名。对于setter方法，它采用bean属性名。

public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Resource(name="myMovieFinder") 
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

@Value

注入外部的值。可以用 @PropertySource 注解指定导入的文件。

@Component
public class MovieRecommender {

    private final String catalog;

    public MovieRecommender(@Value("${catalog.name}") String catalog) {
        this.catalog = catalog;
    }
}

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig { }

如果不存在catalog.name的值，将会把字符串"${catalog.name}"注入，如果对不存在的值保持严格控制，则应声明 PropertySourcesPlaceholderConfigurer bean。

@Configuration
public class AppConfig {

     @Bean
     public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
           return new PropertySourcesPlaceholderConfigurer();
     }
}

一个Spring的BeanPostProcessor使用 ConversionService 来转换@value的值到目标类型，可以增加自定义的ConversionService。

@Configuration
public class AppConfig {
    @Bean
    public ConversionService conversionService() {
        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        conversionService.addConverter(new MyCustomConverter());
        return conversionService;
    }
}

@PostConstruct 和 @PreDestroy

public class CachingMovieLister {

    @PostConstruct
    public void populateMovieCache() {
        // populates the movie cache upon initialization...
    }

    @PreDestroy
    public void clearMovieCache() {
        // clears the movie cache upon destruction...
    }
}

Red Chrysanthemum

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ssm笔记二（IoC二）

容器扩展点通常，应用程序开发人员不需要为ApplicationContext实现子类。相反，Spring IoC容器可以通过插件来实现扩展。使用BeanPostProcessor定制BeansBeanPostProcessor接口定义了一些回调方法，开发者可以通过实现它来提供自己的实例化逻辑。可以配置多个BeanPostProcessor。通过设置他们的order属性来决定它们执行顺序，前...
复制链接

扫一扫