FreeMarker工具类，用来根据模板文件生成html文件，html字符串等

----使用FreeMarker来生成

1、静态Htm文件

2、Html字符串

3、html的response响应流

4、控制台输出流

package com.XX.XX.freemarker;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.util.Map;
import java.util.Properties;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;

import freemarker.cache.MultiTemplateLoader;
import freemarker.cache.TemplateLoader;
import freemarker.cache.WebappTemplateLoader;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;

public class Freemarker {
	  private HttpServletRequest request;
	  private HttpServletResponse response;
	  private ServletContext context;
	  
	  private String ftlName;//模板名称
	  
	  private String generatedFilePath;//待生成的静态文件存放的位置(默认“/site/generated”)
	  
	  private String generatedFileName;//待生成的静态文件名称
	  
	  private Map map;//Freemarker数据模型
	  
	  private String templatePath;//模板存放的位置(默认“/WEB-INF/templates”)
	  
	  private String encoding;//编码格式(默认“gbk”)
	  
	  private String articleTemplatePath;//文章模板存放的位置，动态设置
	  
	  public String getArticleTemplatePath() {
		return articleTemplatePath;
	}

	public void setArticleTemplatePath(String articleTemplatePath) {
		this.articleTemplatePath = articleTemplatePath;
	}

	public String getEncoding() {
		return encoding;
	}

	public void setEncoding(String encoding) {
		this.encoding = encoding;
	}

	public String getFtlName() {
		return ftlName;
	}

	public void setFtlName(String ftlName) {
		this.ftlName = ftlName;
	}

	public String getGeneratedFileName() {
		return generatedFileName;
	}

	public void setGeneratedFileName(String generatedFileName) {
		this.generatedFileName = generatedFileName;
	}

	public String getGeneratedFilePath() {
		return generatedFilePath;
	}

	public void setGeneratedFilePath(String generatedFilePath) {
		this.generatedFilePath = generatedFilePath;
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

	public String getTemplatePath() {
		return templatePath;
	}

	public void setTemplatePath(String templatePath) {
		this.templatePath = templatePath;
	}

	public Freemarker()
	  {
	  }

	  public Freemarker(ServletContext context)
	  {
	    this.context = context;
	  }

	  public void init(HttpServletRequest request, HttpServletResponse response) {
	    this.request = request;
	    this.response = response;
	  }

	  public void init(HttpServletRequest request, HttpServletResponse response, ServletContext context)
	  {
	    this.request = request;
	    this.response = response;
	    this.context = context;
	  }

	  /**
	   * 
	   * @param ftl 模板名称,包括后缀名----必传
	   * @param htmlPath 待生成的HTML存在服务器的位置
	   * @param htmlFileName 待生成的HTML文件名----必传
	   * @param map 模板数据----必传
	   * @param templatePath 模板存放在位置
	   * @param encode 编码格式
	   * @return string 生成的HTML文件的相对路径 不带contextPath
	   * @throws IOException
	   * @throws TemplateException
	   */
	  public String process(String ftl,String htmlPath,String htmlFileName, Map map, String templatePath, String encode)
	  {
	    BufferedWriter buff = null;
		Writer out = null;
		String generatedFile = "";
		try 
		{
			Configuration freemarkerCfg = new Configuration();
			//生成的HTML文件存放的位置
			if (StringUtils.isBlank(htmlPath))
			{
				htmlPath = this.request.getContextPath() + "/generated";
			}
			else if (!htmlPath.startsWith("/"))
			{
				htmlPath = "/" + htmlPath;
			}
			if (StringUtils.isBlank(templatePath))
			{
				templatePath = this.request.getContextPath() + "/templates/default";
			}
			else if (!templatePath.startsWith("/"))
			{
				templatePath = "/" + templatePath;
			}
			if (StringUtils.isBlank(encode))
			{
				encode = "UTF-8";
			}
			if (-1 == ftlName.lastIndexOf('.'))
			{
				ftlName = ftlName + ".ftl";
			}
			if (-1 == generatedFileName.lastIndexOf('.'))
			{
				generatedFileName = generatedFileName + ".html";
			}
			//加载模板所在路径
			WebappTemplateLoader loader1 = new WebappTemplateLoader(this.context, templatePath); 
			WebappTemplateLoader loader2 = null;
			if (StringUtils.isNotBlank(articleTemplatePath))
			{
				loader2 = new WebappTemplateLoader(this.context, articleTemplatePath);
			}
			else
			{
				loader2 = new WebappTemplateLoader(this.context, "/dj/sharedtemplates/");
			}
			MultiTemplateLoader multiTemplateLoader = new MultiTemplateLoader(new TemplateLoader[] {loader1,loader2});
			freemarkerCfg.setTemplateLoader(multiTemplateLoader);
	        Properties p = new Properties();   
	        try {
				p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("freemarker.properties"));   
				freemarkerCfg.setSettings(p);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (TemplateException e) {
				e.printStackTrace();
			}  


			Template template = freemarkerCfg.getTemplate(ftl);
			template.setEncoding(encode);
			this.request.setCharacterEncoding(encode);
			this.response.setContentType("text/html; charset=" + encode);
			String path = this.context.getRealPath("/" + htmlPath);
			File dir = new File(path);
			if (!dir.exists())
			{
				dir.mkdirs();
			}
			buff = new BufferedWriter(new FileWriter(path + htmlFileName));
			File htmlFile = new File(path + File.separator + htmlFileName);
			out = new BufferedWriter(new OutputStreamWriter(
			  new FileOutputStream(htmlFile), encode));
			template.process(map, out);
			generatedFile = htmlPath + "/" + htmlFileName;
		} 
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		} 
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		} 
		catch (TemplateException e)
		{
			e.printStackTrace();
		}
		finally
		{
		    try 
		    {
		    	if (null != buff)
		    	{
		    		buff.close();
		    	}
		    	if (null != out)
		    	{
					out.flush();
					out.close();
		    	}
			} 
		    catch (IOException e)
		    {
				e.printStackTrace();
			}
		}
	    return generatedFile;
	  }
	  
	  /**
	   * 处理模板文件并生成静态文件
	   * @return 生成文件的路径
	   */
	  public String process()
	  {
	    BufferedWriter buff = null;
		Writer out = null;
		String generatedFile = "";
		try 
		{
			Configuration freemarkerCfg = new Configuration();
			//生成的HTML文件存放的位置
			if (StringUtils.isBlank(generatedFilePath))
			{
				generatedFilePath = this.request.getContextPath() + "/generated/";
			}
			else if (!generatedFilePath.startsWith("/"))
			{
				generatedFilePath = "/" + generatedFilePath;
			}
			if (StringUtils.isBlank(templatePath))
			{
				templatePath = this.request.getContextPath() + "/templates/default";
			}
			else if (!templatePath.startsWith("/"))
			{
				templatePath = "/" + templatePath;
			}
			if (StringUtils.isBlank(encoding))
			{
				encoding = "GBK";
			}
			if (-1 == ftlName.lastIndexOf('.'))
			{
				ftlName = ftlName + ".ftl";
			}
			if (-1 == generatedFileName.lastIndexOf('.'))
			{
				generatedFileName = generatedFileName + ".html";
			}
			//加载模板所在路径(使用多模板加载器加载模板文件)
			WebappTemplateLoader loader1 = new WebappTemplateLoader(this.context, templatePath); 
			WebappTemplateLoader loader2 = null;
			if (StringUtils.isNotBlank(articleTemplatePath))
			{
				loader2 = new WebappTemplateLoader(this.context, articleTemplatePath);
			}
			else
			{
				loader2 = new WebappTemplateLoader(this.context, "/dj/sharedtemplates/");
			}
			MultiTemplateLoader multiTemplateLoader = new MultiTemplateLoader(new TemplateLoader[] {loader1,loader2});
			freemarkerCfg.setTemplateLoader(multiTemplateLoader);
	        Properties p = new Properties();   
	        try {
				p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("freemarker.properties"));   
				freemarkerCfg.setSettings(p);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (TemplateException e) {
				e.printStackTrace();
			}  

			Template template = freemarkerCfg.getTemplate(ftlName);
			template.setEncoding(encoding);
			this.request.setCharacterEncoding(encoding);
			this.response.setContentType("text/html; charset=" + encoding);
			String path = this.context.getRealPath(generatedFilePath);
			File dir = new File(path);
			if (!dir.exists())
			{
				dir.mkdirs();
			}
			buff = new BufferedWriter(new FileWriter(path + generatedFileName));
			File htmlFile = new File(path + File.separator + generatedFileName);
			out = new BufferedWriter(new OutputStreamWriter(
			  new FileOutputStream(htmlFile), encoding));
			template.process(map, out);
			out.flush();
			generatedFile = generatedFilePath + generatedFileName;
		} 
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		} 
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		} 
		catch (TemplateException e)
		{
			e.printStackTrace();
		}
		finally
		{
		    try 
		    {
		    	if (null != buff)
		    	{
		    		buff.close();
		    	}
		    	if (null != out)
		    	{
					out.flush();
					out.close();
		    	}
			} 
		    catch (IOException e)
		    {
				e.printStackTrace();
			}
		}
	    return generatedFile;
	  }
	  
	  /**
	   * 处理模板文件并输出到响应端的流中
	   */
	  public void processUsingResponse()
	  {
		try 
		{
			Configuration freemarkerCfg = new Configuration();
			if (StringUtils.isBlank(templatePath))
			{
				templatePath = this.request.getContextPath() + "/templates/default";
			}
			else if (!templatePath.startsWith("/"))
			{
				templatePath = "/" + templatePath;
			}
			if (StringUtils.isBlank(encoding))
			{
				encoding = "GBK";
			}
			if (-1 == ftlName.lastIndexOf('.'))
			{
				ftlName = ftlName + ".ftl";
			}
			//加载模板所在路径
			WebappTemplateLoader loader1 = new WebappTemplateLoader(this.context, templatePath); 
			WebappTemplateLoader loader2 = null;
			if (StringUtils.isNotBlank(articleTemplatePath))
			{
				loader2 = new WebappTemplateLoader(this.context, articleTemplatePath);
			}
			else
			{
				loader2 = new WebappTemplateLoader(this.context, "/dj/sharedtemplates/");
			}
			MultiTemplateLoader multiTemplateLoader = new MultiTemplateLoader(new TemplateLoader[] {loader1,loader2});
			freemarkerCfg.setTemplateLoader(multiTemplateLoader);
	        Properties p = new Properties();   
	        try {
				p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("freemarker.properties"));   
				freemarkerCfg.setSettings(p);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (TemplateException e) {
				e.printStackTrace();
			}  

			Template template = freemarkerCfg.getTemplate(ftlName);
			template.setEncoding(encoding);
			this.request.setCharacterEncoding(encoding);
			this.response.setContentType("text/html; charset=" + encoding);
			PrintWriter out = response.getWriter();
			template.process(map, out);
		} 
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		} 
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		} 
		catch (TemplateException e)
		{
			e.printStackTrace();
		}
	  }
	  
	  
	  /**
	   * 处理模板文件并输出到控制台中
	   */
	  public void processUsingSysout()
	  {
		try 
		{
			Configuration freemarkerCfg = new Configuration();
			if (StringUtils.isBlank(templatePath))
			{
				templatePath = "/WEB-INF/templates";
			}
			else if (!templatePath.startsWith("/"))
			{
				templatePath = "/" + templatePath;
			}
			if (StringUtils.isBlank(encoding))
			{
				encoding = "GBK";
			}
			if (-1 == ftlName.lastIndexOf('.'))
			{
				ftlName = ftlName + ".ftl";
			}
			//加载模板所在路径
			WebappTemplateLoader loader1 = new WebappTemplateLoader(this.context, templatePath); 
			WebappTemplateLoader loader2 = null;
			if (StringUtils.isNotBlank(articleTemplatePath))
			{
				loader2 = new WebappTemplateLoader(this.context, articleTemplatePath);
			}
			else
			{
				loader2 = new WebappTemplateLoader(this.context, "/dj/sharedtemplates/");
			}
			MultiTemplateLoader multiTemplateLoader = new MultiTemplateLoader(new TemplateLoader[] {loader1,loader2});
			freemarkerCfg.setTemplateLoader(multiTemplateLoader);

			Template template = freemarkerCfg.getTemplate(ftlName);
			template.setEncoding(encoding);
			this.request.setCharacterEncoding(encoding);
			this.response.setContentType("text/html; charset=" + encoding);
			template.process(map, new PrintWriter(System.out));
		} 
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		} 
		catch (FileNotFoundException e)
		{
			e.printStackTrace();
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		} 
		catch (TemplateException e)
		{
			e.printStackTrace();
		}
	  }

/**
    * 处理模板文件并将解析的后html内容以字符串方式返回给调用者
    */
   public String processReturnString()
   {
  try 
  {
   Configuration freemarkerCfg = new Configuration();
   if (StringUtils.isBlank(templatePath))
   {
    templatePath = "/WEB-INF/templates";
   }
   else if (!templatePath.startsWith("/"))
   {
    templatePath = "/" + templatePath;
   }
   if (StringUtils.isBlank(encoding))
   {
    encoding = "GBK";
   }
   if (-1 == ftlName.lastIndexOf('.'))
   {
    ftlName = ftlName + ".ftl";
   }
   //加载模板所在路径
   freemarkerCfg.setServletContextForTemplateLoading(this.context, templatePath);
         Properties p = new Properties();   
         try {
    p.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("freemarker.properties"));   
    freemarkerCfg.setSettings(p);
   } catch (IOException e) {
    e.printStackTrace();
   } catch (TemplateException e) {
    e.printStackTrace();
   }  
   
   Template template = freemarkerCfg.getTemplate(ftlName);
   template.setEncoding(encoding);
   this.request.setCharacterEncoding(encoding);
   this.response.setContentType("text/html; charset=" + encoding);
   StringWriter sw = new StringWriter();
   template.process(map, new PrintWriter(sw));
   return sw.toString();
  } 
  catch (UnsupportedEncodingException e)
  {
   e.printStackTrace();
  } 
  catch (FileNotFoundException e)
  {
   e.printStackTrace();
  } 
  catch (IOException e) 
  {
   e.printStackTrace();
  } 
  catch (TemplateException e)
  {
   e.printStackTrace();
  }
  return "";
   }

}

使用方法为：

			Freemarker free = new Freemarker(context);//实例化模板类
			free.init(getRequest(), getResponse());//初始化请求和响应
			free.setFtlName(info.getIndexFtl());//设置模板的文件名
			free.setGeneratedFileName("index.html");//设置生成的静态html文件的名称
			free.setGeneratedFilePath(info.getGeneratedPath());//设置模板文件生成静态文件的路径
			free.setTemplatePath(info.getTemplatePath());//设置模板的加载路径
			free.setMap(root);//设置模板的数据模型
			String indexPath = free.process();//开始处理，返回结果，这里返回的就是静态html的相对路径