com.alacoder.lion.rpc.springsupport.ServiceConfigBean.java Source code

Introduction

Here is the source code for com.alacoder.lion.rpc.springsupport.ServiceConfigBean.java

Source

/*
 *  Copyright 2009-2016 Weibo, Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

package com.alacoder.lion.rpc.springsupport;

import java.util.ArrayList;
import java.util.Arrays;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

import com.alacoder.common.exception.LionErrorMsgConstant;
import com.alacoder.common.exception.LionFrameworkException;
import com.alacoder.lion.common.LionConstants;
import com.alacoder.lion.common.utils.CollectionUtil;
import com.alacoder.lion.common.utils.MathUtil;
import com.alacoder.lion.config.BasicServiceInterfaceConfig;
import com.alacoder.lion.config.ProtocolConfig;
import com.alacoder.lion.config.RegistryConfig;
import com.alacoder.lion.config.ServiceConfig;
import com.alacoder.lion.rpc.springsupport.namespace.handler.LionNamespaceHandler;
import com.alacoder.lion.rpc.utils.LionFrameworkUtil;

public class ServiceConfigBean<T> extends ServiceConfig<T> implements BeanPostProcessor, BeanFactoryAware,
        InitializingBean, DisposableBean, ApplicationListener<ContextRefreshedEvent> {

    private static final long serialVersionUID = -7247592395983804440L;

    private transient BeanFactory beanFactory;

    @Override
    public void destroy() throws Exception {
        unexport();
    }

    @Override
    public void afterPropertiesSet() throws Exception {

        // ?:basicConfig????basicConfig?
        checkAndConfigBasicConfig();
        checkAndConfigExport();
        checkAndConfigRegistry();

        // spring???export?
        // export();
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    // serviceBean
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (!getExported().get()) {
            export();
        }
    }

    /**
     * ?basicConfig
     */
    private void checkAndConfigBasicConfig() {
        if (getBasicServiceConfig() == null) {
            if (LionNamespaceHandler.basicServiceConfigDefineNames.size() == 0) {
                if (beanFactory instanceof ListableBeanFactory) {
                    ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
                    String[] basicServiceConfigNames = listableBeanFactory
                            .getBeanNamesForType(BasicServiceInterfaceConfig.class);
                    LionNamespaceHandler.basicServiceConfigDefineNames
                            .addAll(Arrays.asList(basicServiceConfigNames));
                }
            }
            for (String name : LionNamespaceHandler.basicServiceConfigDefineNames) {
                BasicServiceInterfaceConfig biConfig = beanFactory.getBean(name, BasicServiceInterfaceConfig.class);
                if (biConfig == null) {
                    continue;
                }
                if (LionNamespaceHandler.basicServiceConfigDefineNames.size() == 1) {
                    setBasicServiceConfig(biConfig);
                } else if (biConfig.isDefault() != null && biConfig.isDefault().booleanValue()) {
                    setBasicServiceConfig(biConfig);
                }
            }
        }
    }

    /**
     * ???exportbasicConfig
     */
    private void checkAndConfigExport() {
        if (StringUtils.isBlank(getExport()) && getBasicServiceConfig() != null
                && !StringUtils.isBlank(getBasicServiceConfig().getExport())) {
            setExport(getBasicServiceConfig().getExport());
            if (getBasicServiceConfig().getProtocols() != null) {
                setProtocols(new ArrayList<ProtocolConfig>(getBasicServiceConfig().getProtocols()));
            }
        }
        if (CollectionUtil.isEmpty(getProtocols()) && StringUtils.isNotEmpty(getExport())) {
            int port = MathUtil.parseInt(export, 0);
            if (port > 0) {
                export = LionConstants.PROTOCOL_LION + ":" + export;
                setProtocol(LionFrameworkUtil.getDefaultProtocolConfig());
            }
        }
        if (StringUtils.isEmpty(getExport()) || CollectionUtil.isEmpty(getProtocols())) {
            throw new LionFrameworkException(
                    String.format("%s ServiceConfig must config right export value!", getInterface().getName()),
                    LionErrorMsgConstant.FRAMEWORK_INIT_ERROR);
        }
    }

    /**
     * ?registry
     */
    private void checkAndConfigRegistry() {
        if (CollectionUtil.isEmpty(getRegistries()) && getBasicServiceConfig() != null
                && !CollectionUtil.isEmpty(getBasicServiceConfig().getRegistries())) {
            setRegistries(getBasicServiceConfig().getRegistries());
        }
        if (CollectionUtil.isEmpty(getRegistries())) {
            for (String name : LionNamespaceHandler.registryDefineNames) {
                RegistryConfig rc = beanFactory.getBean(name, RegistryConfig.class);
                if (rc == null) {
                    continue;
                }
                if (LionNamespaceHandler.registryDefineNames.size() == 1) {
                    setRegistry(rc);
                } else if (rc.isDefault() != null && rc.isDefault().booleanValue()) {
                    setRegistry(rc);
                }
            }
        }
        if (CollectionUtil.isEmpty(getRegistries())) {
            setRegistry(LionFrameworkUtil.getDefaultRegistryConfig());
        }
    }

}