假注入

转自一个项目中的框架

 

package jp.co.sony.semicon.arx.common.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.UnavailableException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import jp.co.sony.semicon.arx.common.constants.ArxConst;
import jp.co.sony.semicon.arx.common.factory.ArxActionFactory;
import jp.co.sony.semicon.arx.common.factory.ArxDaoFactory;
import jp.co.sony.semicon.arx.common.factory.ArxLogicFactory;
import jp.co.sony.semicon.arx.common.logging.ArxLogComposer;
import jp.co.sony.semicon.arx.common.logging.ArxLogger;
import jp.co.sony.semicon.arx.common.processor.ArxStrutsRequestProcessor;

import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.RequestProcessor;
import org.apache.struts.config.ModuleConfig;
import org.apache.struts.util.ModuleUtils;
import org.apache.struts.util.RequestUtils;

/**
 * strutsのActionServletを拡張したサーブレットクラス.
 * <p>
 *
 * @author Sony
 * @version 1.0.0 2008/10/16 新規
 */
public class ArxActionServlet extends ActionServlet {

 /** バージョン. */
 private static final long serialVersionUID = -105398968564316958L;

 /** ロガー. */
 private static final ArxLogger logger = ArxLogComposer.getLogger(ArxActionServlet.class);

 /**
  * サーブレットの初期化.
  *
  * @exception ServletException
  *                サーブレット異常
  */
 public void init() throws ServletException {
  logger.debug("ArxActionServlet.init -------------------- Start");

  super.init();

  try {
   // Daoを作成する
   ArxDaoFactory arxDaoFactory = ArxDaoFactory.getInstance();
   arxDaoFactory.init(getServletContext().getRealPath(""));

   // ロジックを作成する
   ArxLogicFactory arxLogicFactory = ArxLogicFactory.getInstance();
   arxLogicFactory.init(getServletContext().getRealPath(""));

   // Actionを作成する
   ArxActionFactory arxActionFactory = ArxActionFactory.getInstance(this);
   arxActionFactory.init();

  } catch (Exception e) {
   throw new ServletException(e);
  }

  logger.debug("ArxActionServlet.init -------------------- End");
 }

 /**
  * サーブレットを破棄する.
  *
  */
 @SuppressWarnings("static-access")
 public void destroy() {
  logger.debug("ArxActionServlet.destroy -------------------- Start");

  // Actionを破棄する
  ArxActionFactory arxActionFactory = ArxActionFactory.getInstance();
  arxActionFactory.destroy();
  arxActionFactory = null;

  // ロジックを破棄する
  ArxLogicFactory arxLogicFactory = ArxLogicFactory.getInstance();
  arxLogicFactory.destroy();
  arxLogicFactory = null;

  // Daoを破棄する
  ArxDaoFactory arxDaoFactory = ArxDaoFactory.getInstance();
  arxDaoFactory.destroy();
  arxDaoFactory = null;

  logger.debug("ArxActionServlet.destroy -------------------- End");
 }

 /**
  * サーブレットの前処理を実行する.
  *
  * @param request
  *            リクエスト
  * @param response
  *            レスポンス
  * @exception IOException
  *                異常
  * @exception ServletException
  *                サーブレット異常
  */
 protected void process(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {

  // エンコードを設定する
  request.setCharacterEncoding(ArxConst.CHARACTERENCODING);

  ModuleUtils.getInstance().selectModule(request, getServletContext());
  ModuleConfig config = getModuleConfig(request);

  // 前処理を行う
  ArxStrutsRequestProcessor processor = getRequestProcessor(config);
  processor.process(request, response);
 }

 /**
  * リクエストの処理オブジェクトを取得する.
  *
  * @param config
  *            Configオブジェクト
  * @return E2StrutsRequestProcessor 処理オブジェクト
  * @exception ServletException
  *                サーブレット異常
  */
 protected synchronized ArxStrutsRequestProcessor getRequestProcessor(ModuleConfig config) throws ServletException {

  ArxStrutsRequestProcessor processor = getProcessorForModule(config);
  if (processor == null) {
   try {
    RequestProcessor requestProcessor = (RequestProcessor) RequestUtils.applicationInstance(config.getControllerConfig().getProcessorClass());
    processor = new ArxStrutsRequestProcessor(requestProcessor);

   } catch (Exception e) {
    throw new UnavailableException("Cannot initialize RequestProcessor of class " + config.getControllerConfig().getProcessorClass() + ": " + e);
   }

   processor.init(this, config);
   String key = "org.apache.struts.action.REQUEST_PROCESSOR" + config.getPrefix();
   getServletContext().setAttribute(key, processor);
  }

  return processor;
 }

 /**
  * リクエストの処理オブジェクトを取得する.
  *
  * @param config
  *            Configオブジェクト
  * @return E2StrutsRequestProcessor 処理オブジェクト
  */
 private ArxStrutsRequestProcessor getProcessorForModule(ModuleConfig config) {
  String key = "org.apache.struts.action.REQUEST_PROCESSOR" + config.getPrefix();
  return (ArxStrutsRequestProcessor) getServletContext().getAttribute(key);
 }
}

 

 

 

 

 

package jp.co.sony.semicon.arx.common.factory;

import java.io.File;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import jp.co.sony.semicon.arx.common.constants.ArxConst;
import jp.co.sony.semicon.arx.common.logging.ArxLogComposer;
import jp.co.sony.semicon.arx.common.logging.ArxLogger;
import jp.co.sony.semicon.arx.common.logic.ArxLogic;

import org.apache.commons.collections.FastHashMap;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * ロジックを生成するファクトリークラス.
 * <p>
 *
 * @author Sony
 * @version 1.0.0 2008/11/26 新規
 */
@SuppressWarnings("unchecked")
public class ArxLogicFactory {
 /** ロガー. */
 private static final ArxLogger logger = ArxLogComposer.getLogger(ArxLogicFactory.class);

 /** ロジックを保持するマップ */
 private static Map<String, ArxLogic> logicMap = null;

 /** 該当クラスのインスタンス */
 private static ArxLogicFactory instance = null;

 static {
  instance = new ArxLogicFactory();
  logicMap = new FastHashMap();
 }

 /**
  * プライベートなコンストラクタ.
  *
  */
 private ArxLogicFactory() {

 }

 /**
  * 該当クラスのインスタンスを取得する.
  *
  * @return ArxLogicFactory 該当クラスのインスタンス
  */
 public static ArxLogicFactory getInstance() {

  if (instance == null) {
   instance = new ArxLogicFactory();
   logicMap = new FastHashMap();
  }

  return instance;
 }

 /**
  * 初期化処理.
  *
  * @param realPath
  *            プロジェクトのアブソルートパス
  * @throws DocumentException
  *             ドキュメント異常
  * @throws InstantiationException
  *             例示化異常
  * @throws IllegalAccessException
  *             不法なアクセス異常
  */
 public void init(String realPath) throws DocumentException, InstantiationException, IllegalAccessException {
  logger.debug("LogicFactory.init -------------------- Start");

  // 新規作成
  synchronized (logicMap) {
   logicMap.clear();
  }

  // ロジックの配置ファイルパスを取得する
  StringBuffer path = new StringBuffer();
  path.append(realPath);
  path.append(ArxConst.FILE_SEPARATOR + "WEB-INF");
  path.append(ArxConst.FILE_SEPARATOR + "mappings");
  path.append(ArxConst.FILE_SEPARATOR + "logic-mappings.xml");

  // SAXReaderを利用して、XMLファイルを解析する
  Document doc = new SAXReader().read(new File(path.toString()));

  // 該当ドキュメントのルートノードを取得する
  Element root = doc.getRootElement();

  // 該当配置ファイルを読み込む
  List<Element> el = root.elements();
  for (Iterator<Element> it = el.iterator(); it.hasNext();) {
   Element em = (Element) it.next();
   String id = em.attributeValue("name");
   String className = em.attributeValue("type");

   try {
    ArxLogic logic = (ArxLogic) Class.forName(className).newInstance();
    logicMap.put(id, logic);

    logger.debug(id + " -------------------- load");
   } catch (Exception e) {

    logger.error("ロジック作成異常", e);
   }
  }

  logger.debug("LogicFactory.init -------------------- End");
 }

 /**
  * ロジックを破棄する.
  *
  */
 public static void destroy() {
  synchronized (logicMap) {
   logicMap.clear();
  }
 }

 /**
  * 指定する名称に相応なロジックを取得する.
  * @param <T> クラス
  * @param logicName
  *            ロジック名称
  * @return AppLogic 相応なロジックの対象
  */
 public <T extends ArxLogic> T getLogic(String logicName) {
        return (T) logicMap.get(logicName);
    }
}

 

 

 

package jp.co.sony.semicon.arx.common.factory;

import java.io.File;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import jp.co.sony.semicon.arx.common.constants.ArxConst;
import jp.co.sony.semicon.arx.common.dao.ArxDao;
import jp.co.sony.semicon.arx.common.logging.ArxLogComposer;
import jp.co.sony.semicon.arx.common.logging.ArxLogger;

import org.apache.commons.collections.FastHashMap;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * Daoを生成するファクトリークラス.
 * <p>
 *
 * @author Sony
 * @version 1.0.0 2008/11/26 新規
 */
@SuppressWarnings("unchecked")
public class ArxDaoFactory {

 /** ロガー. */
 private static final ArxLogger logger = ArxLogComposer.getLogger(ArxDaoFactory.class);

 /** Daoを保持するマップ */
 private static Map<String, ArxDao> daoMap = null;

 /** 該当クラスのインスタンス */
 private static ArxDaoFactory instance = null;

 static {
  instance = new ArxDaoFactory();
  daoMap = new FastHashMap();
 }

 /**
  * プライベートなコンストラクタ.
  *
  */
 private ArxDaoFactory() {

 }

 /**
  * 該当クラスのインスタンスを取得する.
  *
  * @return DaoFactory 該当クラスのインスタンス
  */
 public static ArxDaoFactory getInstance() {
  if (instance == null) {
   instance = new ArxDaoFactory();
   daoMap = new FastHashMap();
  }

  return instance;
 }

 /**
  * 初期化処理.
  *
  * @param realPath
  *            プロジェクトのアブソルートパス
  * @throws DocumentException
  *             ドキュメント異常
  * @throws InstantiationException
  *             例示化異常
  * @throws IllegalAccessException
  *             不法なアクセス異常
  */
 public void init(String realPath) throws DocumentException, InstantiationException, IllegalAccessException {
  logger.debug("DaoFactory.init -------------------- Start");

  // 新規作成
  synchronized (daoMap) {
   daoMap.clear();
  }

  // Daoの配置ファイルパスを取得する
  StringBuffer path = new StringBuffer();
  path.append(realPath);
  path.append(ArxConst.FILE_SEPARATOR + "WEB-INF");
  path.append(ArxConst.FILE_SEPARATOR + "mappings");
  path.append(ArxConst.FILE_SEPARATOR + "dao-mappings.xml");

  // SAXReaderを利用して、XMLファイルを解析する
  Document doc = new SAXReader().read(new File(path.toString()));

  // 該当ドキュメントのルートノードを取得する
  Element root = doc.getRootElement();

  // DB類型を取得する
  String dbType = root.attributeValue("currentType");

  // 該当配置ファイルを読み込む
  List<Element> el = root.elements();
  for (Iterator<Element> it = el.iterator(); it.hasNext();) {
   Element em = it.next();
   String id = em.elementTextTrim("dao-name");
   String impl = em.elementTextTrim("dao-class");

   List<Element> implList = em.elements("dao-class");
   for (Iterator<Element> implIt = implList.iterator(); implIt.hasNext();) {
    Element implEm = implIt.next();
    if (dbType.equals(implEm.attributeValue("type"))) {
     impl = implEm.getTextTrim();
     break;
    }
   }

   try {
    ArxDao dao = (ArxDao) Class.forName(impl).newInstance();
    daoMap.put(id, dao);

    logger.debug(id + " -------------------- load");
   } catch (Exception e) {

    logger.error("Dao作成異常", e);
   }
  }

  logger.debug("DaoFactory.init -------------------- End");
 }

 /**
  * Daoを破棄する.
  *
  */
 public static void destroy() {
  synchronized (daoMap) {
   daoMap.clear();
  }
 }

 /**
  * 指定する名称に相応なDaoを取得する.
  *
  * @param <T> クラス
  * @param daoName
  *            Dao名称
  * @return ArxDao 相応なDaoの対象
  */
 public <T extends ArxDao> T getDao(String daoName) {
  return (T)daoMap.get(daoName);
 }
}

 

package jp.co.sony.semicon.arx.common.factory;

import java.io.File;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import jp.co.sony.semicon.arx.common.action.ArxAction;
import jp.co.sony.semicon.arx.common.constants.ArxConst;
import jp.co.sony.semicon.arx.common.logging.ArxLogComposer;
import jp.co.sony.semicon.arx.common.logging.ArxLogger;
import jp.co.sony.semicon.arx.common.servlet.ArxActionServlet;

import org.apache.commons.collections.FastHashMap;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * Actionを生成するファクトリークラス.
 * <p>
 *
 * @author Sony
 * @version 1.0.0 2008/11/26 新規
 */
@SuppressWarnings("unchecked")
public class ArxActionFactory {
 /** ロガー. */
 private static final ArxLogger logger = ArxLogComposer.getLogger(ArxActionFactory.class);

 /** Actionを保持するマップ. */
 private static Map<String, ArxAction> actionMap = null;

 /** 該当クラスのインスタンス. */
 private static ArxActionFactory instance = null;

 /** サーブレット. */
 private static ArxActionServlet arxActionServlet = null;

 static {
  instance = new ArxActionFactory();
  actionMap = new FastHashMap();
 }

 /**
  * プライベートなコンストラクタ.
  *
  */
 private ArxActionFactory() {

 }

 /**
  * 該当クラスのインスタンスを取得する.
  *
  * @return ArxActionFactory 該当クラスのインスタンス
  */
 public static ArxActionFactory getInstance() {

  if (instance == null) {
   instance = new ArxActionFactory();
   actionMap = new FastHashMap();
  }

  return instance;
 }

 /**
  * 該当クラスのインスタンスを取得する.
  *
  * @param servlet
  *            サーブレット
  * @return ArxActionFactory 該当クラスのインスタンス
  */
 public static ArxActionFactory getInstance(ArxActionServlet servlet) {

  if (instance == null) {
   instance = new ArxActionFactory();
  }
  arxActionServlet = servlet;

  return instance;
 }

 /**
  * 初期化処理.
  *
  * @throws DocumentException
  *             ドキュメント異常
  * @throws InstantiationException
  *             例示化異常
  * @throws IllegalAccessException
  *             不法なアクセス異常
  */
 public void init() throws DocumentException, InstantiationException, IllegalAccessException {
  logger.debug("ActionFactory.init -------------------- Start");

  // 新規作成
  synchronized (actionMap) {
   actionMap.clear();
  }

  // Actionの配置ファイルパスを取得する
  StringBuffer path = new StringBuffer();
  path.append(arxActionServlet.getServletContext().getRealPath(""));
  path.append(ArxConst.FILE_SEPARATOR + "WEB-INF");
  path.append(ArxConst.FILE_SEPARATOR + "mappings");
  path.append(ArxConst.FILE_SEPARATOR + "action-mappings.xml");

  // SAXReaderを利用して、XMLファイルを解析する
  Document doc = new SAXReader().read(new File(path.toString()));

  // 該当ドキュメントのルートノードを取得する
  Element root = doc.getRootElement();

  // 該当配置ファイルを読み込む
  List<Element> el = root.elements();
  for (Iterator<Element> it = el.iterator(); it.hasNext();) {
   Element em = (Element) it.next();

   String className = em.attributeValue("type");

   try {
    ArxAction action = (ArxAction) Class.forName(className).newInstance();
    action.setServlet(arxActionServlet);
    action.setLogic();

    actionMap.put(className, action);

    logger.debug(className.substring(className.lastIndexOf(".") + 1) + " -------------------- load");
   } catch (Exception e) {

    logger.error("Action作成異常", e);
   }
  }

  logger.debug("ActionFactory.init -------------------- End");
 }

 /**
  * Actionを破棄する.
  *
  */
 public static void destroy() {
  synchronized (actionMap) {
   ArxAction action;
   for (Iterator<ArxAction> actions = actionMap.values().iterator(); actions.hasNext(); action.setServlet(null)) {
    action = actions.next();
   }

   actionMap.clear();
  }
  arxActionServlet = null;
 }

 /**
  * 指定する名称に相応なActionを取得する.
  *
  * @param <T>
  *            クラス
  * @param actionName
  *            Action名称
  * @return ArxAction
  * @throws Exception
  *             異常
  */
 public <T extends ArxAction> T getAction(String actionName) throws Exception {
  ArxAction instance = null;

  synchronized (actionMap) {
   instance = actionMap.get(actionName);
   if (instance != null) {
    return (T) instance;
   }

   instance = (ArxAction) Class.forName(actionName).newInstance();
   instance.setServlet(arxActionServlet);
   instance.setLogic();
   actionMap.put(actionName, instance);

   return (T) instance;
  }
 }
}