Spring常用接口和类

一、ApplicationContextAware接口

当一个类需要获取ApplicationContext实例时，可以让该类实现ApplicationContextAware接口。代码展示如下：

public class Animal implements ApplicationContextAware, BeanNameAware{

    private String beanName;

    private ApplicationContext applicationContext;

    public void setBeanName(String name) {

        this.beanName = name;

    }

    /**

     * @param applicationContext 该参数将由Spring容器自动赋值

     */

    public void setApplicationContext(ApplicationContext applicationContext)throws BeansException {

        this.applicationContext = applicationContext;

    }

    public void run(){

        System.out.println(beanName);

        //发布自定义事件

        AnimalEvent event = new AnimalEvent(this, "老虎");

        applicationContext.publishEvent(event);

    }

}

通过@Autowired注解可以自动装配一些常用对象实例：

@Autowired

private MessageSource messageSource; 

@Autowired

private ResourceLoader resourceLoader; 

@Autowired

private ApplicationContext applicationContext;

二、ApplicationEvent抽象类

当需要创建自定义事件时，可以新建一个继承自ApplicationEvent抽象类的类。代码展示如下：

/**

 * 自定义事件

 */

public class AnimalEvent extends ApplicationEvent {

    private String name;

    public String getName() {

        return name;

    }

    /**

     * @param source 事件源对象

     */

    public AnimalEvent(Object source){

        super(source);

    }

    public AnimalEvent(Object source, String name){

        super(source);

        this.name = name;

    }

}

三、ApplicationListener接口

当需要监听自定义事件时，可以新建一个实现ApplicationListener接口的类，并将该类配置到Spring容器中。代码展示如下：

/**

 * 自定义事件监听器

 */

public class CustomEventListener implements ApplicationListener {

    public void onApplicationEvent(ApplicationEvent event) {

        if(event instanceof AnimalEvent){

            AnimalEvent animalEvent = (AnimalEvent)event;

            System.out.println("触发自定义事件：Animal name is " + animalEvent.getName());

        }

    }

}

<!-- 自定义事件监听器：Spring容器自动注册它 -->

<bean id="customEventListener" class="com.cjm.spring.CustomEventListener"/>

要发布自定义事件，需要调用ApplicationContext的publishEvent方法，具体用法请看Animal类的源码。

四、BeanNameAware接口

当bean需要获取自身在容器中的id/name时，可以实现BeanNameAware接口。

五、InitializingBean接口

当需要在bean的全部属性设置成功后做些特殊的处理，可以让该bean实现InitializingBean接口。效果等同于bean的init-method属性的使用或者@PostContsuct注解的使用。三种方式的执行顺序：先注解，然后执行InitializingBean接口中定义的方法，最后执行init-method属性指定的方法。

六、DisposableBean接口当需要在bean销毁之前做些特殊的处理，可以让该bean实现DisposableBean接口。效果等同于bean的destroy-method属性的使用或者@PreDestory注解的使用。三种方式的执行顺序：先注解，然后执行DisposableBean接口中定义的方法，最后执行destroy-method属性指定的方法

七、BeanPostProcessor接口

当需要对受管bean进行预处理时，可以新建一个实现BeanPostProcessor接口的类，并将该类配置到Spring容器中。

实现BeanPostProcessor接口时，需要实现以下两个方法：

postProcessBeforeInitialization 在受管bean的初始化动作之前调用

postProcessAfterInitialization 在受管bean的初始化动作之后调用容器中的每个Bean在创建时都会恰当地调用它们。代码展示如下：

public class CustomBeanPostProcessor implements BeanPostProcessor {

    /**

     * 初始化之前的回调方法

     */

    public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {

        System.out.println("postProcessBeforeInitialization: " + beanName);

        return bean;

    }

    /**

     * 初始化之后的回调方法

     */

    public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {

        System.out.println("postProcessAfterInitialization: " + beanName);

        return bean;

    }

}

<!-- 自定义受管Bean的预处理器：Spring容器自动注册它 -->

<bean id="customBeanPostProcessor" class="com.cjm.spring.CustomBeanPostProcessor"/>

八、BeanFactoryPostProcessor接口

当需要对Bean工厂进行预处理时，可以新建一个实现BeanFactoryPostProcessor接口的类，并将该类配置到Spring容器中。代码展示如下：

public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        System.out.println(beanFactory.getClass().getSimpleName());

    }

}

<!-- 自定义Bean工厂的预处理器：Spring容器自动注册它 -->

<bean id="customBeanFactoryPostProcessor" class="com.cjm.spring.CustomBeanFactoryPostProcessor"/>

Spring内置的实现类：

1、PropertyPlaceholderConfigurer类

用于读取Java属性文件中的属性，然后插入到BeanFactory的定义中。

<bean id="propertyPlaceholderConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

    <property name="locations">

        <list>

            <value>jdbc.properties</value>

        </list>

    </property>

</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

    <property name="driverClassName"><value>${jdbc.driverClassName}</value></property>

    <property name="url"><value>${jdbc.url}</value></property>

    <property name="username"><value>${jdbc.username}</value></property>

    <property name="password"><value>${jdbc.password}</value></property>

</bean>

PropertyPlaceholderConfigurer的另一种精简配置方式（context命名空间）：

<context:property-placeholder location="classpath:jdbc.properties, classpath:mails.properties"/>

Java属性文件内容：

jdbc.driverClassName=oracle.jdbc.driver.OracleDriver

jdbc.url=jdbc:oracle:thin:@localhost:1521:orcl

jdbc.username=qycd

jdbc.password=qycd

除了可以读取Java属性文件中的属性外，还可以读取系统属性和系统环境变量的值。

读取系统环境变量的值：${JAVA_HOME}

读取系统属性的值：${user.dir}

2、PropertyOverrideConfigurer类

用于读取Java属性文件中的属性，并覆盖XML配置文件中的定义，即PropertyOverrideConfigurer允许XML配置文件中有默认的配置信息。

Java属性文件的格式：

beanName.property=value

beanName是属性占位符企图覆盖的bean名，property是企图覆盖的数姓名。

<bean id="propertyOverrideConfigurer" class="org.springframework.beans.factory.config.PropertyOverrideConfigurer">

    <property name="locations">

        <list>

            <value>jdbc.properties</value>

        </list>

    </property>

</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

    <property name="driverClassName" value="11"/>

    <property name="url" value="22"/>

    <property name="username" value="33"/>

    <property name="password" value="44"/>

</bean>

Java属性文件内容：
                dataSource.driverClassName=oracle.jdbc.driver.OracleDriver
                dataSource.url=jdbc:oracle:thin:@localhost:1521:orcl
                dataSource.username=qycd
                dataSource.password=qycd

九、ResourceBundleMessageSource类

提供国际化支持，bean的名字必须为messageSource。此处，必须存在一个名为jdbc的属性文件。

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">

    <property name="basenames">

        <list>

            <value>jdbc</value>

        </list>

    </property>

</bean>

jdbc.properties属性文件的内容：

welcome={0}, welcome to guangzhou!

AbstractApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");

ctx.getMessage("welcome", new String[]{"张三"}, "", Locale.CHINA);

十、FactoryBean接口

用于创建特定的对象，对象的类型由getObject方法的返回值决定。

public class MappingFactoryBean implements FactoryBean {

    /**

     * 获取mapping配置对象

     * @return mapping配置

     */

    public Object getObject() throws Exception {

        List<String> configs = ApplicationContext.getContext().getApplication().getMappingConfigs();

        return configs.toArray(new String[configs.size()]);

    }

    /**

     * 返回Bean的类型

     * @return Bean的类型

     */

    public Class<?> getObjectType() {

        return String[].class;

    }

    /**

     * 返回Bean是否是单例的

     * @return true表示是单例的

     */

    public boolean isSingleton() {

        return true;

    }

}

public class MappingAutowiring implements BeanPostProcessor {

    /**

     * 映射配置

     */

    private String[] mappingResources;

    /**

     * 获取映射配置信息

     * @return 映射配置

     */

    public String[] getMappingResources() {

        return mappingResources;

    }

    /**

     * 设置映射配置信息

     * @param mappingResources 映射配置

     */

    public void setMappingResources(String[] mappingResources) {

        this.mappingResources = mappingResources;

    }

    /**

     * 自动装配

     * @param bean Spring容器托管的bean

     * @param beanName Bean名称

     * @return 装配了映射文件后的对象

     */

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        if (bean instanceof LocalSessionFactoryBean) {

            ((LocalSessionFactoryBean) bean).setMappingResources(mappingResources);

        }

        return bean;

    }

    public Object postProcessAfterInitialization(Object bean, String beanName)

            throws BeansException {

        return bean;

    }

}

<bean id="mappingAutowiring" class="com.achievo.framework.server.core.deploy.MappingAutowiring">

    <property name="mappingResources" ref="mappingResources" />

</bean>

<bean id="mappingResources" class="com.achievo.framework.server.core.deploy.MappingFact
oryBean" />

一、CustomEditorConfigurer类

CustomEditorConfigurer可以读取实现java.beans.PropertyEditor接口的类，将字符串转为指定的类型。更方便的可以使用PropertyEditorSupport。PropertyEditorSupport实现PropertyEditor接口，必须重新定义setAsText。

public class Hello {

    private String message;

    private User user;

    public String getMessage() {

        return message;

    }

    public void setMessage(String message) {

        this.message = message;

    }

    public User getUser() {

        return user;

    }

    public void setUser(User user) {

        this.user = user;

    }

}

自定义属性编辑器继承PropertyEditorSupport类，重写setAsText方法。

public class UserEditor extends PropertyEditorSupport{

    @Override

    public void setAsText(String text) throws IllegalArgumentException {

        //类型为User的变量声明了自定义属性编辑器，其值规定为逗号分割的字符串

        String[] arr = text.split(",");

        Integer age = new Integer(arr[1]);

        User user = new User();

        user.setName(arr[0]);

        user.setAge(age);

        setValue(user);

    }

}

bean配置

<bean id="configBean"

class="org.springframework.beans.factory.config.CustomEditorConfigurer">

    <property name="customEditors">

        <map>

            <!-- 类型为User的变量都通过UserEditor间接设值 -->

            <entry key="User">

                <bean id="userEditor" class="UserEditor"/>

            </entry>

        </map>

    </property>

</bean> 

<bean id="hello" class="Hello">

    <property name="message" value="hello" />

    <property name="user" value="chenjumin,20"/><!-- 类型为User的变量声明了自定义属性编辑器，其值规定为逗号分割的字符串 -->

</bean>

巴特西

Spring常用接口和类

最新文章

热门文章