概述

由於之前一直使用Struts2+Spring開發專案，整合Freemarker時頁面如果想直接呼叫靜態方法，可以使用<#assign a= stack.findValue(‘@[email protected]’)>的方式獲取靜態方法呼叫的返回值，現在使用SpringMVC+Freemarker來開發專案時，由於慣性思維的緣故，也想在頁面上直接呼叫靜態方法，來獲取靜態方法的返回值。

• 現有方案
  在網上找了一部分的相關資料，只找到類似的方案：http://www.cnblogs.com/yqweber/p/3992513.html，仔細閱讀這個方案，大致的思路是會在專案resources下新建一個staticClass.properties檔案，在檔案內配置所有需要使用的靜態類，然後新建一個FreemarkerStaticModels類繼承HashMap，用於將所有的靜態類配置封裝成<靜態類名，TemplateHashModel >的形式，然後在Spring配置檔案中的對FreeMarkerViewResolver的attributeMap配置成這個FreemarkerStaticModels物件，完成靜態方法的配置，頁面上可以直接使用靜態類名+靜態方法名的方法來訪問靜態方法了。

• 該方法的明顯不足
  1、如果每次我需要新建一個靜態類，就需要在配置檔案中新增一個配置，感覺特別麻煩；
  2、如果我在配置檔案中配置的靜態類包名不正確，會導致該靜態方法載入異常；
  3、如果靜態類特別多，這個檔案會新增很多配置，這樣看起來也不是特別舒服，查詢起來也不方便。

新的思路

所以就在原有的基礎上進行了修改，大致思路是考慮掃描相關的靜態類所處的包，然後將所有的靜態類在FreemarkerStaticModels裡面進行封裝，而不去進行手動的配置，這樣大大減少了手動配置的麻煩，同時也簡化了開發，當然也會有一些問題，下面也會進行討論。

具體實現

• 編寫FreemarkerStaticModels類
  
  該類是對上面FreemarkerStaticModels類的改造，通過包掃描方式來載入靜態資源，這個類裡面使用了懶載入模式，包掃描，後置處理器等一些常用的操作，具體實現如下：

import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.BeansException;
import
 
 org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.ui.ModelMap;
import org.springframework.util.ClassUtils;
import org.springframework.util.SystemPropertyUtils;

import freemarker.ext.beans.BeansWrapper;
import freemarker.template.TemplateHashModel;
import freemarker.template.TemplateModelException;

public class FreemarkerMap extends ModelMap implements BeanFactoryPostProcessor{

    private static final long serialVersionUID = -4675940717727748450L;
    private List<String> locations;
    private static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
    private static Logger log = Logger.getLogger(FreemarkerMap.class);

    public List<String> getLocations() {
        return locations;
    }

    public void setLocations(List<String> locations) {
        this.locations = locations;
    }

    private FreemarkerMap(){}

    private static volatile FreemarkerMap instance;

    /**
    * 懶載入模式
    */
    public static FreemarkerMap getInstance(){
        if(instance == null){
            synchronized (FreemarkerMap.class) {
                if(instance == null){
                    instance = new FreemarkerMap();
                }
            }
        }
        return instance;
    }   

    /**
    * 後置處理器重新postProcessBeanFactory方法，載入靜態類的配置
    */
    public void postProcessBeanFactory(
            ConfigurableListableBeanFactory beanFactory) throws BeansException {
        loadCheckClassMethods(locations);
    }

    /**
     * 根據掃描包的配置
     * 載入需要檢查的方法
     */
    private static void loadCheckClassMethods(List<String> scanPackages) {
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourcePatternResolver);
        for (String basePackage : scanPackages) {
            if (StringUtils.isBlank(basePackage)) {
                continue;
            }
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                ClassUtils.convertClassNameToResourcePath(SystemPropertyUtils.resolvePlaceholders(basePackage)) + "/" + DEFAULT_RESOURCE_PATTERN ;
            try {
                Resource[] resources = resourcePatternResolver.getResources(packageSearchPath);
                for (Resource resource : resources) {
                    loadClassMethod(metadataReaderFactory, resource);
                }
            } catch (Exception e) {
                log.error("初始化SensitiveWordInterceptor失敗", e);
            }

        }
    }

    /**
     * 載入資源，判斷裡面的方法
     *
     * @param metadataReaderFactory spring中用來讀取resource為class的工具
     * @param resource              這裡的資源就是一個Class
     * @throws IOException
     */
    private static void loadClassMethod(MetadataReaderFactory metadataReaderFactory, Resource resource) throws IOException {
        try {
            if (resource.isReadable()) {
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
                if (metadataReader != null) {
                    String className = metadataReader.getClassMetadata().getClassName();
                    try {
                        tryCacheMethod(className);
                    } catch (ClassNotFoundException e) {
                        log.error("檢查" + className + "是否含有需要資訊失敗", e);
                    }
                }
            }
        } catch (Exception e) {
            log.error("判斷類中的方法實現需要檢測xxx失敗", e);
        }
    }

    /**
     * 把action下面的所有method遍歷一次，標記他們是否需要進行xxx驗證
     * 如果需要，放入cache中
     *
     * @param fullClassName
     * @throws TemplateModelException 
     */
    private static void tryCacheMethod(String fullClassName) throws ClassNotFoundException, TemplateModelException {
        Class<?> clz = Class.forName(fullClassName);
        Method[] methods = clz.getDeclaredMethods();
        for (Method method : methods) {
            int mod = method.getModifiers();
            if (Modifier.isStatic(mod)&&Modifier.isPublic(mod)) {
                BeansWrapper beansWrapper = BeansWrapper.getDefaultInstance();
                TemplateHashModel model = beansWrapper.getStaticModels();
                log.debug("已載入"+clz.getName());
                instance.put(clz.getSimpleName(), (TemplateHashModel)model.get(clz.getName()));
                break;
            }
        }
    }
}

該方法會掃描locations指定路徑包及子包下的所有類，同時也支援模糊包匹配，如果該類下面有靜態方法，則會將該類加入FreemarkerMap中，如果沒有則會跳過，掃描包時會做限制掃描指定路徑下的包，而不會全域性掃描，防止因為專案太大，掃描時會比較慢，導致專案啟動變慢，同時該方法也支援列舉內靜態方法的呼叫。

• Spring配置FreemarkerMap
  locations指定掃描包的路徑：

    <bean id="freemarkerMap" class="com.test.freemarker.FreemarkerMap" factory-method="getInstance">
        <property name="locations">
            <list>
                <value>com.test.common.*.b</value>
                <value>com.test.util.*.a</value>
            </list>
        </property>
    </bean>

• 配置FreeMarkerViewResolver
  attributeMap指定freemarkerMap的引用

<!-- 要求檢視使用FreeMarker模板，指定controller層返回的頁面在webapp目錄下進行訪問，且為html頁面-->  
    <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">  
        <property name="prefix">  
            <value>/</value>  
        </property>  
        <property name="suffix">  
            <value>.html</value>
        </property>  
        <!-- 此處需要宣告為utf-8編碼，否則即使頁面是utf-8編碼，中文還是不能正常顯示 -->  
        <property name="contentType" value="text/html;charset=UTF-8"></property> 
        <property name="attributesMap" ref="freemarkerMap"/>   
    </bean>

• 頁面讀取方式
  頁面直接使用類似於${(StaticUtil.get().name)!”}的讀取方式來獲取就行了，由於get()方法可以返回一個物件，freemarker可以直接.屬性來獲取對應屬性的值，非常方便。

不足與改進

• 不足
  其實這種實現方案自然不是最優的，肯定也會存在一些不足之處：
  1、如果一個包下只有一個靜態類，要掃描整個包感覺會很笨；
  2、如果專案很龐大，包掃描時很有可能會有遺漏，除非有非常明確的包及分層結構；
  3、如果專案很龐大，包掃描可能也會導致專案啟動變得很慢。

• 優化
  可以考慮將原始的版本和目前版本進行整合，如果有的包下只有一個靜態類，那麼我把這個靜態類放到配置檔案中進行配置，如果明確某一個包下大部的類都是靜態的，比如列舉包，那麼可以直接將這個包通過包掃描的方式進行載入，整合之後也可以有效的解決兩種方案上的不足。