HttpServlet设置平台启动项

一、web.xml中load-on-startup的作用

我们在web.xml中配置servlet的时候会有个属性<load-on-startup></load-on-startup>

load-on-startup 元素标记容器是否应该在web应用程序启动的时候就加载这个servlet，(实例化并调用其init()方法)。
它的值必须是一个整数，表示servlet被加载的先后顺序。
如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，值越小，servlet的优先级越高，就越先被加载。值相同时，容器就会自己选择顺序来加载。

  <servlet>
    <servlet-name>StartupServlet</servlet-name>
    <servlet-class>com.platform.core.web.StartupServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

Servlet的框架的核心是javax.servlet.Servlet接口,所有的Servlet都必须实现这一接口.在Servlet接口中定义了5个方法,其中有3个方法代表了Servlet的声明周期:

init方法,负责初始化Servlet对象
service方法,负责相应客户的请求
destory方法,当Servlet对象退出声明周期时,负责释放占有的资源

五个方法:

1) destroy()
2) getServletConfig()
3) getServletInfo()
4) init(ServletConfig arg0)
5) service(ServletRequest arg0, ServletResponse arg1)

当Web容器接收到某个Servlet请求时,Servlet把请求封装成一个HttpServletRequest对象,然后把对象传给Servlet的对应的服务方法.

init 方法的执行时刻其实与 servlet 的配置有关，可以看到以下代码的load-on-startup结点，如果结点的值大于等于 0，则在 Servlet 实例化的时候执行，间隔时间由具体的值决定，值越大，则越迟执行。如果小于 0 或者没有配置，则在第一次请求的时候才同步执行，注意 init 方法只执行一次

init 方法是随 Servlet 实例化而被调用的，因为 load-on-startup 就是用来设置 Servlet 实例化时间的。

因此，init 方法执行的时刻有两种：

（1） load-on-startup 的值大于等于0，则伴随 Servlet 实例化后执行。

（2） load-on-startup 的值小于0 或者不配置，则在第一次 Servlet 请求的时候执行。

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import com.platform.core.AppMgr;

/**
 * 启动Servlet，用于平台初始化
 */
public class StartupServlet extends HttpServlet {
    /** serialize uid */
    private static final long serialVersionUID = -8845384595031323226L;

    /**
     * {@inheritDoc}
     * @param config ServletConfig
     * @throws ServletException
     */
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        AppMgr mgr = AppMgr.getInstance();
        mgr.setHome(config.getServletContext().getRealPath("/"));
        mgr.start();
    }

    /**
     * {@inheritDoc}
     */
    public void destroy() {
        AppMgr.getInstance().stop();
    }
}

二、HttpServlet的功能

HttpServlet首先必须读取Http请求的内容。Servlet容器负责创建HttpServlet对象，并把Http请求直接封装到HttpServlet对象中，大大简化了HttpServlet解析请求数据的工作量。HttpServlet容器响应Web客户请求流程如下：

1）Web客户向Servlet容器发出Http请求；

2）Servlet容器解析Web客户的Http请求；

3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；

4）Servlet容器创建一个HttpResponse对象；

5）Servlet容器调用HttpServlet的service方法，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；

6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；

7）HttpServlet调用HttpResponse的有关方法，生成响应数据；

8）Servlet容器把HttpServlet的响应结果传给Web客户。

创建HttpServlet的步骤——“四部曲”

1）扩展HttpServlet抽象类；
2）覆盖HttpServlet的部分方法，如覆盖doGet()或doPost()方法；
3）获取HTTP请求信息。通过HttpServletRequest对象来检索HTML表单所提交的数据或URL上的查询字符串；
4）生成HTTP响应结果。通过HttpServletResponse对象生成响应结果，它有一个getWriter()方法，该方法返回一个PrintWriter对象。

package cn.leo.soft;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class HelloServlet extends HttpServlet//第一步：扩展HttpServlet抽象类
{
 //第二步：覆盖doGet()方法
 public void doGet(HttpServletRequest request,
  HttpServletResponse response)throws IOException,ServletException{
  //第三步：获取HTTP请求中的参数信息
  String clientName=request.getParameter("clientName");
  if(clientName!=null)
   clientName=new String(clientName.getBytes("ISO-8859-1"),"GB2312");
  else
   clientName="我的朋友";

  //第四步：生成HTTP响应结果
  PrintWriter out;
  String title="HelloServlet";
  String heading1="HelloServlet的doGet方法的输出：";
  //set content type
  response.setContentType("text/html;charset=GB2312");
  //write html page
  out=response.getWriter();
  out.print("<HTML><HEAD><TITLE>"+title+"</TITLE>");
  out.print("</HEAD><BODY>");
  out.print(heading1);
  out.println("<h1><p>"+clientName+":您好</h1>");
  out.print("</BODY></HTML>");

  out.close();
 }
}

<servlet>
   <servlet-name>HelloServlet</servlet-name>
   <servlet-class>mypack.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
   <servlet-name>HelloServlet</servlet-name>
   <url-pattern>/hello</url-pattern>
</servlet-mapping>

通过URL访问HelloServlet:

注意：

实现service方法。Servlet的主要功能是接受从浏览器发送过来的HTTP请求（request），并返回HTTP响应（response）。这个工作是在service方法中完成的。service方法包括从request对象获得客户端数据和向response对象创建输出。如果一个Servlet从javax.servlet.http.HttpServlet继承，实现了doPost或doGet方法，那么这个Servlet只能对POST或GET做出响应。如果开发人员想处理所有类型的请求（request），只要简单地实现service方法即可（但假如选择实现service方法，则不必实现doPost或doGet方法，除非在service方法的开始调用super.service()）。

三、平台启动项设置

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.platform.core.base.Bean;
import com.platform.core.base.IBean;
import com.platform.core.exception.CoreException;
import com.platform.core.job.JobMgr;
import com.platform.core.start.DataSourceMgr;
import com.platform.core.start.Log4j;
import com.platform.core.start.PlatformCacheMgr;
import com.platform.core.start.PlatformConfig;
import com.platform.core.start.PlatformListenerItem;
import com.platform.core.start.StartItem;
import com.platform.core.util.Debug;
import com.platform.core.web.Request;

/**
 * 应用管理器
 */
public class AppMgr {
    private static final String module = AppMgr.class.getName();

    /**
     * 构造器
     */
    private AppMgr() {
        innerStartItems = new ArrayList<StartItem>();
        innerStartItems.add(new Log4j());
        innerStartItems.add(new PlatformConfig());
        innerStartItems.add(new PlatformCacheMgr());
        innerStartItems.add(DataSourceMgr.getInstance());
        innerStartItems.add(new PlatformListenerItem());
        innerStartItems.add(JobMgr.getInstance());
    }

    /**
     * 实例
     */
    private static AppMgr appMgr = new AppMgr();

    /**
     * 获取实例
     * @return 实例
     */
    public static AppMgr getInstance() {
        return appMgr;
    }

    /**
     * 版本号
     * @return 版本号
     */
    public String getVersion() {
        return VERSION;
    }

    /**
     * 版本号
     */
    private static final String VERSION = "6.0.0";
    /**
     * 是否启动标志
     */
    private boolean bstart = false;
    /**
     * 内置启动项，强制启动
     */
    private ArrayList<StartItem> innerStartItems;

    /**
     * 应用初始化 配置、日志、数据库、缓存、计划任务等
     */
    public void start() {
        if (!bstart) {
            Debug.logInfo("Leopard" + VERSION + "启动开始", module);
            for (int i = 0; i < innerStartItems.size(); i++) {
                StartItem item = (StartItem) innerStartItems.get(i);

                try {
                    item.start();
                } catch (Exception e) {
                    Debug.logError("启动" + item.getName() + "...[failed]-->>>>>" + e.getMessage(), module);
                    break;
                }
                Debug.logInfo("启动" + item.getName() + "...[success]", module);
            }
            Debug.logInfo("Leopard" + VERSION + "启动完成", module);
            bstart = true;
        }
    }

    /**
     * 停止
     */
    public void stop() {
        if (bstart) {
            Debug.logInfo("Leopard" + VERSION + "开始关闭", module);
            // 启动
            StartItem item;
            for (int i = innerStartItems.size() - 1; i >= 0; i--) {
                item = (StartItem) innerStartItems.get(i);
                Debug.logInfo("关闭" + item.getName() + "...", module);
                try {
                    item.stop();
                } catch (Exception e) {
                    Debug.logInfo(CoreException.getStackTraceMsg(e), module);
                }
            }
            Debug.logInfo("Leopard" + VERSION + "关闭完成", module);
        }
    }

    /**
     * 全局变量
     */
    private Bean varBean = new Bean();

    /**
     * 获取全局变量
     * @param key 键值
     * @return 全局变量
     */
    public Object var(String key) {
        return varBean.get(key);
    }

    /**
     * 设置全局变量
     * @param key 键值
     * @param obj varObj
     */
    public void setVar(String key, Object obj) {
        varBean.set(key, obj);
    }

    /**
     * 获取session变量
     * @param key key
     * @return rtnObj rtnObj
     */
    public static Object sessionVar(String key) {
        return Request.getSession(true).getAttribute(key);
    }

    /**
     * 获取session变量
     * @param key key
     * @param obj objInst
     */
    public static void setSessionVar(String key, Object obj) {
        Request.getSession(true).setAttribute(key, obj);
    }

    /**
     * 获取
     * @param key key
     * @param funcCode String
     * @return rtnObj rtnObj
     */
    public static Object sessionFVar(String funcCode, String key) {
        Map map = (Map) Request.getSession(true).getAttribute(funcCode);
        if (map == null) {
            map = new HashMap();
        }
        return map.get(key);
    }

    /**
     * @param funcCode
     * @param key
     * @param obj
     */
    public static void setSessionFVar(String funcCode, String key, Object obj) {
        Map map = (Map) Request.getSession(true).getAttribute(funcCode);
        if (map == null) {
            map = new HashMap();
            Request.getSession(true).setAttribute(funcCode, map);
        }
        map.put(key, obj);
    }

    /**
     * 参数BEAN键
     */
    public static final String KEY_PARAM_BEAN = "$PARAM_BEAN";

    /**
     * 参数值
     * @param key
     * @return Object
     */
    public static Object paramVar(String key) {
        IBean bean = (IBean) threadVar(KEY_PARAM_BEAN);
        if (bean != null) {
            return bean.get(key);
        } else {
            return null;
        }
    }

    /**
     * 获取
     * @param key key
     * @return rtnObj rtnObj
     */
    public static Object sessionFVar(String key) {
        return sessionFVar((String) paramVar("func"), key);
    }

    /**
     * @param key
     * @param obj
     */
    public static void setSessionFVar(String key, Object obj) {
        setSessionFVar((String) paramVar("func"), key, obj);
    }

    /**
     * 线程级变量
     */
    private static final ThreadLocal TL = new ThreadLocal();

    /**
     * 获取线程级实例对象
     * @return rtnBean rtnBean
     */
    private static Bean threadBean() {
        Bean bean = (Bean) TL.get();
        if (bean == null) {
            bean = new Bean();
            TL.set(bean);
        }
        return bean;
    }

    /**
     * 获取线程级实例对象中某参数值
     * @param key key
     * @return rtnObj rtnObj
     */
    public static Object threadVar(String key) {
        return threadBean().get(key);
    }

    /**
     * 设置线程级实例对象中某参数值
     * @param key key
     * @param obj setter objInst
     */
    public static void setThreadVar(String key, Object obj) {
        threadBean().set(key, obj);
    }

    /**
     * WEB应用主目录应用地址
     */
    private String home = "";

    /**
     * 设置WEB应用主目录地址
     * @param path path
     */
    public void setHome(String path) {
        home = path;
    }

    /**
     * 获取WEB应用主目录地址
     * @return rtnHomeStr rtnHomeStr
     */
    public String getHome() {
        return home;
    }
}

import java.io.File;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import com.platform.core.AppMgr;
import com.platform.core.exception.CoreException;
import com.platform.util.XMLUtils;

/**
 * 系统参数配置
 */
public class PlatformConfig implements StartItem {
    public final static String MODULE = PlatformConfig.class.getName();
    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#getName()
     */
    public String getName() {
        return "系统参数配置";
    }

    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#start()
     */
    public void start() throws CoreException {
        // 加载leopard.xml
        String filePath = AppMgr.getInstance().getHome().concat("WEB-INF/leopard.xml");
        Document docInst = doLoadConfFile(filePath);
        AppMgr.getInstance().setVar(MODULE+"$PLATFORM_CONFIG$", XMLUtils.toBean4Xml(docInst.getRootElement()));
    }

    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#stop()
     */
    public void stop() {

    }

    /**
     * 加载配置文件
     * @param filePath filePath
     * @return docInst docInst
     */
    private Document doLoadConfFile(String filePath) {
        File fileInst = new File(filePath);
        SAXReader saxRInst = new SAXReader();
        Document docInst = null;
        try {
            docInst = saxRInst.read(fileInst);
        } catch (DocumentException e) {
            throw new CoreException(e);
        }
        return docInst;
    }
}

import com.platform.core.cache.core.CacheManager;
import oracle.core.lmx.CoreException;

/**
 * 系统缓存组件
 */
public class PlatformCacheMgr implements StartItem {

    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#getName()
     */
    public String getName() {
        return "系统缓存组件";
    }

    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#start()
     */
    public void start() throws CoreException {
        CacheManager.getInstance();
    }

    /*
     * (non-Javadoc)
     * @see com.platform.core.start.StartItem#stop()
     */
    public void stop() {
    }

}

import com.platform.core.cache.core.CacheManager;
import com.platform.core.cache.core.api.CacheKeyFactory;
import com.platform.core.cache.core.impl.CacheKey;
import com.platform.core.cache.model.ModelCacheKeyFactory;

/**
 * 实体缓存管理工厂 类
 */
public class ModelCacheManager {
    /** cacheManager 缓存管理器 */
    protected CacheManager cacheManager;

    /** cacheKeyFactory 缓存主键工厂 类 */
    private final CacheKeyFactory cacheKeyFactory;

    /**
     * 构造函数
     * @param cacheManager 缓存管理器
     */
    public ModelCacheManager(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
        this.cacheKeyFactory = new ModelCacheKeyFactory();
    }
    private static ModelCacheManager manager = null;
    /**
     * 构造函数
     */
    public ModelCacheManager() {
        this.cacheManager = CacheManager.getInstance();
        this.cacheKeyFactory = new ModelCacheKeyFactory();
    }
    public static ModelCacheManager getInstance(){
        if(manager==null){
            manager = new ModelCacheManager();
        }

        return manager;
    }

    /**
     * 保存实体缓存数据
     * @param dataKey 数据主键
     * @param modelClass 实体类包路径
     * @param model void 存储实体
     */
    public void saveCache(String dataKey, String modelClass, Object model) {
        CacheKey ckey = cacheKeyFactory.createCacheKey(dataKey, modelClass);
        cacheManager.putObject(ckey, model);
    }

    /**
     * 获取缓存数据
     * @param dataKey String
     * @param modelClass String
     * @return Object
     */
    public Object getCache(String dataKey, String modelClass) {
        CacheKey ckey = cacheKeyFactory.createCacheKey(dataKey, modelClass);
        return cacheManager.fetchObject(ckey);
    }

    /**
     * 删除缓存数据
     * @param dataKey String
     * @param modelClass String
     */
    public void removeCache(String dataKey, String modelClass) {
        CacheKey ckey = cacheKeyFactory.createCacheKey(dataKey, modelClass);
        cacheManager.removeObject(ckey);
    }

    /**
     * 删除所有主键编码为dataKey的缓存数据
     * @param dataKey String
     */
    public void removeCache(String dataKey) {
        cacheManager.removeObject(dataKey);
    }

    public void clearCache() {
        cacheManager.clear();
    }
}

import java.util.ArrayList;
import java.util.List;
import com.platform.core.AppMgr;
import com.platform.core.Metadata.FuncDao;
import com.platform.core.base.Bean;
import com.platform.core.base.IBean;
import com.platform.core.cache.ModelCacheManager;
import com.platform.core.config.vo.Config;
import com.platform.core.start.PlatformConfig;

/**
 * 系统内部全局配置
 */
public class ContextConfig {
    /** modelType TODO */
    private final String modelType = Config.class.getName();
    /** modelCacheManager TODO */
    private final ModelCacheManager modelCacheManager;

    /** singleton instance */
    private static ContextConfig ccInst = null;

    /**
     * Constructor
     */
    private ContextConfig() {
        modelCacheManager = new ModelCacheManager();
        IBean iBean = (IBean) AppMgr.getInstance().var(PlatformConfig.MODULE + "$PLATFORM_CONFIG$");
        for (String key : iBean.getKeys()) {
            IBean tmpBean = new Bean();
            tmpBean.set("CONF_CODE", key);
            tmpBean.set("CONF_VALUE", iBean.get(key));
            modelCacheManager.saveCache(
                key, modelType, new Config(tmpBean));
        }
    }

    /**
     * 取得全局配置
     * @return ccInst 配置实例
     */
    public static ContextConfig getInstance() {
        if (null == ccInst) {
            ccInst = new ContextConfig();
        }
        return ccInst;
    }

    /**
     * 取得配置数据
     * @param key key
     * @param defV 默认值
     * @return rtnObj rtnObj/defV
     */
    public String getConf(String key, String defV) {
        Object rtnVal = getConf(key);
        return rtnVal != null ? String.valueOf(rtnVal) : defV;
    }

    /**
     * 取得配置数据
     * @param key key
     * @return rtnValue rtnValue/null
     */
    public Object getConf(String key) {
        Config config = getConfig(key);
        return config != null ? config.getValue() : null;
    }

    /**
     * 获取参数配置
     * @param key 参数编码
     * @return Config
     */
    public Config getConfig(String key) {
        Config config = (Config) modelCacheManager.getCache(key, modelType);

        if (config == null) {
//            IBean tmpBean = new EntityDAO("SY_CONFIG").byId(key);
        	 IBean tmpBean = new FuncDao("SY_CONFIG").byId(key);
        	 
            if (tmpBean != null) {
                config = new Config(tmpBean);
                if (!config.isFlag()) {
                    config = null;
                } else {
                    modelCacheManager.saveCache(key, modelType, config);
                }
            }
        }
        return config;
    }

    /**
     * 取得list格式存储的数据
     * @param key key
     * @return rtnList rtnList/null
     */
    public List getListConf(String key) {
        final Object tmpObj = getConf(key);
        List rtnList = null == tmpObj ? null : tmpObj instanceof List ? (List) tmpObj : new ArrayList() {
            /** inner serialize */
            private static final long serialVersionUID = 1L;
            {
                add(tmpObj);
            }
        };
        return rtnList;
    }

    /**
     * 清除缓存
     * @param key void
     */
    public void clear(String key) {
        modelCacheManager.removeCache(key, modelType);
    }
}

HttpServlet设置平台启动项

猜你喜欢