包装类是它的设计模式

我是新来设计模式，现在我正在打开的商品代码：所以我想了解代码的体系结构：图层，使用的设计模式.. 。包装类是它的设计模式

所以，我发现了一个名为包含这里EntityWrapper.java类包是一个例子：

包装类：

package org.objectweb.salome_tmf.api.data; 

/** 
    * @author marchemi 
    */ 
public class ActionWrapper extends DataWrapper{ 
String awaitedResult; 
int orderIndex; 
int idTest; 
/** 
* @return Returns the orderIndex. 
*/ 
public int getOrderIndex() { 
    return orderIndex; 
} 
/** 
* @param orderIndex The orderIndex to set. 
*/ 
public void setOrderIndex(int orderIndex) { 
    this.orderIndex = orderIndex; 
} 
/** 
* @return Returns the waitedResult. 
*/ 
public String getAwaitedResult() { 
    return awaitedResult; 
} 
/** 
* @param waitedResult The waitedResult to set. 
*/ 
public void setAwaitedResult(String awaitedResult) { 
    this.awaitedResult = awaitedResult; 
} 
/** 
* @return Returns the idTest. 
*/ 
public int getIdTest() { 
    return idTest; 
} 
/** 
* @param idTest The idTest to set. 
*/ 
public void setIdTest(int idTest) { 
    this.idTest = idTest; 
} 
}

实体类：

package org.objectweb.salome_tmf.data; 

import java.io.File; 
import java.io.Serializable; 
import java.util.Enumeration; 
import java.util.HashSet; 
import java.util.Hashtable; 
import java.util.Iterator; 
import java.util.Vector; 

import org.objectweb.salome_tmf.api.Api; 
import org.objectweb.salome_tmf.api.ApiConstants; 
import org.objectweb.salome_tmf.api.Util; 
import org.objectweb.salome_tmf.api.data.ActionWrapper; 
import org.objectweb.salome_tmf.api.data.FileAttachementWrapper; 
import org.objectweb.salome_tmf.api.data.ParameterWrapper; 
import org.objectweb.salome_tmf.api.data.SalomeFileWrapper; 
import org.objectweb.salome_tmf.api.data.UrlAttachementWrapper; 
import org.objectweb.salome_tmf.api.sql.ISQLAction; 

public class Action extends WithAttachment { 
static ISQLAction pISQLAction = null; 

private String awaitedResult; 
public String getAwaitedResult() { 
    return awaitedResult; 
} 

public void setAwaitedResult(String awaitedResult) { 
    this.awaitedResult = awaitedResult; 
} 

private int orderIndex; 
private Hashtable parameterHashTable; 
private Test pTest = null; 

public Action(Test pTest, String name, String description) { 
    super(name, description); 
    awaitedResult = ""; 
    orderIndex = 0; 
    parameterHashTable = new Hashtable(); 
    this.pTest = pTest; 
    if (pISQLAction == null){ 
     pISQLAction = Api.getISQLObjectFactory().getISQLAction(); 
    } 
} 

public Action(ActionWrapper pAction, Test pTest) { 
    this(pTest, pAction.getName(), pAction.getDescription()); 
    awaitedResult = pAction.getAwaitedResult(); 
    orderIndex = pAction.getOrderIndex(); 
    idBdd = pAction.getIdBDD(); 
} 

public Action(Action pAction, Test pTest) { 
    this(pTest, pAction.getNameFromModel(), pAction.getDescriptionFromModel()); 
    awaitedResult = pAction.getAwaitedResultFromModel(); 
} // Fin du constructeur Action/1 


protected void reloadBaseFromDB() throws Exception { 
    if (isInBase()) { 
     throw new Exception("Action " + name + " is already in BDD"); 
    } 
    ActionWrapper pActionWrapper = pISQLAction.getActionWrapper(idBdd); 
    awaitedResult = pActionWrapper.getAwaitedResult(); 
    orderIndex = pActionWrapper.getOrderIndex(); 
    name = pActionWrapper.getName(); 
    description = pActionWrapper.getDescription(); 
} 


public void reloadFromDB(boolean base, Hashtable paramsInModel, boolean attach) 
    throws Exception { 
    int transNuber = -1; 
    try { 
     transNuber = Api.beginTransaction(101, ApiConstants.LOADING); 
     if (base){ 
      reloadBaseFromDB(); 
     } 
     reloadUsedParameterFromDB(paramsInModel); 
     if (attach){ 
      reloadAttachmentDataFromDB(false); 
     } 
     Api.commitTrans(transNuber); 
    } catch (Exception e){ 
     Api.forceRollBackTrans(transNuber); 
     throw e; 
    } 
} 

public void clearCache() { 
    /* TODO ClearAttachement */ 

} 
/******************************************************************************/ 
/**        ACCESSEURS ET 
    MUTATEURS      ***/ 
/******************************************************************************/ 

public String getAwaitedResultFromModel() { 
    return awaitedResult; 
} 

public void setAwaitedResultInModel(String string) { 
    awaitedResult = string; 
} 


public int getOrderIndexFromModel() { 
    return orderIndex; 
} 

public void setOrderIndex(int i) { 
    orderIndex = i; 
} 

public Test getTest(){ 
    return pTest; 
} 

/////////////////////////////// Basic Operation ///////////////////////// 

/* Used by Manuel Test */ 
void addInDB(Test pTest) throws Exception { 
    //boolean needUpdate = false; 
    if (isInBase()) { 
     throw new Exception("Action " + name + " is already in BDD"); 
    } 
    if (!pTest.isInBase()){ 
     throw new Exception("Test " + pTest.getNameFromModel() + " is not in BDD"); 
    } 
    int id = pISQLAction.insert(pTest.getIdBdd(), name, description, awaitedResult); 
    setIdBdd(id); 
    orderIndex = pISQLAction.getActionWrapper(id).getOrder(); 
    /*if (orderIndex != rowCount){ 
     needUpdate = true; 
    } 
    return needUpdate;*/ 
    Project.pCurrentProject.notifyChanged(ApiConstants.INSERT_ACTION ,this); 

} 

/* Used by Manuel Test */ 
void addInModel(Test pTest){ 
    this.pTest = pTest; 
} 

/* Used by Manuel Test */ 
void addInDBAndModel(Test pTest)throws Exception { 
    //boolean res; 
    addInDB(pTest); 
    addInModel(pTest); 
    //return res; 
} 



public void updateInDB(String newActionName, String newActionDesc, String newActionResAttendu) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    pISQLAction.update(idBdd, newActionName, newActionDesc, newActionResAttendu); 
    Project.pCurrentProject.notifyChanged(ApiConstants.UPDATE_ACTION ,this, new String(name), newActionName); 

} 

public void updateInModel(String newActionName, String newActionDesc, String newActionResAttendu) { 
    setNameInModel(newActionName); 
    updateDescriptionInModel(newActionDesc); 
    setAwaitedResultInModel(newActionResAttendu); 
} 

public void updateInDBAndModel(String newActionName, String newActionDesc, String newActionResAttendu) throws Exception { 
    updateInDB(newActionName, newActionDesc, newActionResAttendu); 
    updateInModel(newActionName, newActionDesc, newActionResAttendu); 
} 

public void updateInDBAndModel(String newName, String newDesc) throws Exception { 
    updateInDB(newName, newDesc, awaitedResult); 
    updateInModel(newName, newDesc, awaitedResult); 
} 

public void updateOrderInDBAndModel(boolean inc) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    orderIndex = pISQLAction.updateOrder(idBdd, inc);  
} 

/* Used by Manuel Test */ 
void deleteInDB() throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    pISQLAction.delete(idBdd); 
    Project.pCurrentProject.notifyChanged(ApiConstants.DELETE_ACTION ,this); 
} 

/* Used by Manuel Test */ 
void deleteInModel(){ 
    pTest=null; 
    parameterHashTable.clear(); 
    clearAttachInModel(); 
} 

/* Used by Manuel Test */ 
void deleteInDBAndModel() throws Exception { 
    deleteInDB(); 
    deleteInModel(); 
} 

//////////////// PARAMETERS //////////////////////// 


public void setParameterHashSetInModel(HashSet set) { 
    parameterHashTable.clear(); 
    for (Iterator iter = set.iterator(); iter.hasNext();) { 
     Parameter param = (Parameter)iter.next(); 
     parameterHashTable.put(param.getNameFromModel(), param); 
    } 

} 
public void setParameterHashtableInModel(Hashtable table) { 
    parameterHashTable.clear(); 
    parameterHashTable = table; 
} 

public Hashtable getCopyOfParameterHashTableFromModel(){ 
    Hashtable copyParameter = new Hashtable(); 
    Enumeration enumKey = parameterHashTable.keys(); 
    while (enumKey.hasMoreElements()){ 
     Object key = enumKey.nextElement(); 
     copyParameter.put(key, parameterHashTable.get(key)); 
    } 
    return copyParameter; 
} 

public void reloadUsedParameterFromDB(Hashtable parametersInModel) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    ParameterWrapper[] paramActionArray = pISQLAction.getParamsUses(idBdd); 
    for (int i = 0; i < paramActionArray.length; i++) { 
     Parameter param = null; 
     ParameterWrapper pParameterWrapper = paramActionArray[i]; 
     if (parametersInModel != null){ 
      param = (Parameter)parametersInModel.get(pParameterWrapper.getName()); 
      if (param == null){ 
       param = new Parameter(pParameterWrapper); 
      } 
     } 
     setUseParamInModel(param); 
    } 
} 

public void setUseParamInModel(Parameter pParam) { 
    parameterHashTable.put(pParam.getNameFromModel(), pParam); 
    if (pTest != null) { 
     if (pTest.getUsedParameterFromModel(pParam.getNameFromModel()) == null){ 
      pTest.setUseParamInModel(pParam); 
     } 
    } 
} 

public void setUseParamInDB(int paramId) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    pISQLAction.addUseParam(idBdd,paramId); 
} 

public void setUseParamInDBAndModel(Parameter pParam) throws Exception { 
    //DB 
    setUseParamInDB(pParam.getIdBdd()); 
    //model 
    setUseParamInModel(pParam); 
} 

public void deleteUseParamInDB(int paramId) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    pISQLAction.deleteParamUse(idBdd, paramId); 
} 

public void deleteUseParamInDBAndModel(Parameter pParam) throws Exception { 
    deleteUseParamInDB(pParam.getIdBdd()); 
    deleteUseParamInModel(pParam); 
} 

public void deleteUseParamInModel(Parameter pParam) { 
    // Clean Action 
    String newDesc = null ; 
    if (getDescriptionFromModel()!=null) 
     newDesc = clearStringOfParameter(getDescriptionFromModel(), pParam); 
    String newResult = null; 
    if (getAwaitedResultFromModel()!=null) 
     newResult = clearStringOfParameter(getAwaitedResultFromModel(), pParam); 
    description = newDesc; 
    awaitedResult = newResult; 
    Object o= parameterHashTable.remove(pParam.getNameFromModel()); 
    Util.log("[Action->deleteUseParamInModel] Delete Use Parameter " + pParam + ", in Action " + name + " res is " +o); 

} 



public Parameter getParameterFromModel(String name) { 
    Enumeration paramList = parameterHashTable.elements(); 
    while (paramList.hasMoreElements()){ 
     Parameter param = (Parameter)paramList.nextElement(); 
     if (param.getNameFromModel().equals(name)) { 
      return param; 
     } 
    } 
    return null; 
} 

public Parameter getParameterFromDB(String name) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    HashSet result = getParameterHashSetFromDB(); 
    for (Iterator iter = result.iterator(); iter.hasNext();) { 
     Parameter param = (Parameter)iter.next(); 
     if (param.getNameFromModel().equals(name)) { 
      return param; 
     } 
    } 
    return null; 
} 

public HashSet getParameterHashSetFromDB() throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    HashSet result = new HashSet(); 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    ParameterWrapper[] listParamWrapper = pISQLAction.getParamsUses(idBdd); 
    for (int i = 0; i < listParamWrapper.length; i++){ 
     result.add(new Parameter(listParamWrapper[i])); 
    } 
    return result; 
} 

public Vector getParameterVectorFromDB() throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    Vector result = new Vector(); 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    ParameterWrapper[] listParamWrapper = pISQLAction.getParamsUses(idBdd); 
    for (int i = 0; i < listParamWrapper.length; i++){ 
     result.add(new Parameter(listParamWrapper[i])); 
    } 
    return result; 
} 
public Hashtable getParameterHashSetFromModel() { 
    return parameterHashTable; 
} 

////////////// ATTACHEMENT /////////////////////// 

public void addAttachementInDB (Attachment attach)throws Exception { 
    if (attach instanceof FileAttachment) { 
     addAttachFileInDB((FileAttachment) attach); 
    } else { 
     addAttachUrlInDB((UrlAttachment) attach); 
    } 
} 

void addAttachFileInDB(FileAttachment file) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    File f = file.getLocalFile(); 
    int id = pISQLAction.addFileAttach(idBdd,new SalomeFileWrapper(f),file.getDescriptionFromModel()); 
    file.setIdBdd(id); 
} 

void addAttachUrlInDB(UrlAttachment url) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    int id = pISQLAction.addUrlAttach(idBdd, url.getNameFromModel(),url.getDescriptionFromModel()); 
    url.setIdBdd(id); 
} 


public void deleteAttachementInDB(int attachId) throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    pISQLAction.deleteAttachment(idBdd, attachId); 
} 




public void deleteAttachementInDBAndModel(Attachment attach)throws Exception { 
    deleteAttachementInDB(attach.getIdBdd()); 
    deleteAttachmentInModel(attach); 

} 

public Vector getAttachFilesFromDB() throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    FileAttachementWrapper[] fawArray = pISQLAction.getAllAttachFile(idBdd); 
    Vector result = new Vector(); 
    for(int i = 0; i < fawArray.length; i++) { 
     result.add(fawArray[i]); 
    } 
    return result; 
} 


public Vector getAttachUrlsFromDB() throws Exception { 
    if (!isInBase()) { 
     throw new Exception("Action " + name + " is not in BDD"); 
    } 
    UrlAttachementWrapper[] uawArray = pISQLAction.getAllAttachUrl(idBdd); 
    Vector result = new Vector(); 
    for(int i = 0; i < uawArray.length; i++) { 
     result.add(uawArray[i]); 
    } 
    return result; 
} 


//////// PROTECTED ////////////// 
protected String clearStringOfParameter(String prtString, Parameter pParam) { 
    String result = prtString; 
    result = result.replaceAll("[$]" + pParam.getNameFromModel() + "[$]", ""); 
    return result; 
} 

public static boolean isInBase(Test pTest, String actionName) { 
    try { 
     int id = pISQLAction.getID(pTest.getIdBdd(), actionName); 
     if (id > 0){ 
      return true; 
     } 
     return false; 
    } catch (Exception e) { 

    } 
    return false; 
} // Fin de la methode isInBase/1 

public boolean existeInBase() throws Exception { 
    if (!isInBase()) { 
     return false; 
    } 
    return pISQLAction.getID(pTest.getIdBdd(), name) == idBdd; 
} 
}

那么什么是包装类的实用工具，是一种设计模式吗？

来源

2012-12-23 AmiraGL

我会说构图或委托模式，但是很难从你的代码中说出：根本没有@Override注释。此外，尽管存在许多经典的，经过验证的配方，但设计模式并非一成不变。 – fge

http://stackoverflow.com/questions/889160/what-is-a-wrapper-class –

的东西与包装字结束的事实doesn't使它的包装。要成为一个包装，它必须包装一些东西。这是，它必须封装一个或多个组件，可能是整个第三方API。

@zzfima说有不同类型的包装。是的，代理在某些情况下可能是包装，也可能是桥接。

您的代码doesn't封装任何其他组件，然后，它不是一个包装（至少对我来说）

来源

2012-12-23 22:00:50 lontivero

在阅读了Data Transfer对象之后，它代表了一个包含getter和setter的类，它是一个在不同应用程序层之间传递对象的解决方案。我们可以确定ActionWrapper是一个DTO。 – AmiraGL

我看不出，ActionWrapper的包装，对我来说只是DataWrapper接口的实现。

还有的包装设计模式3“种”：

门面设计模式=采取了大量的类/接口，里面做一些逻辑，走出小接口。例如“汽车启动”封装在里面：打开车，放钥匙，放置DVD，改正椅子，点火。
修饰器设计模式=带一些具有行为的类，并能够在运行时添加行为。例如，您可以使用新的LCDDecorator（新的DVDDecorator（TurboDecorator（新车）））而不是CarWithLCDWithDVDWithTurbo类。
适配器设计模式=采取一些新的接口，并适应一些已知的接口。

来源

2012-12-23 15:33:35 zzfima

考虑到GOF模式，我只会将代理模式添加到列表中，因为它可以像装饰器一样只用一个记住不同的目的。 – nansen

调用一些“包装”并不能使它的包装。基本上它需要封装一些东西或者包装什么东西，不管你怎么称呼它

来源

2013-01-05 18:49:55

包装类是它的设计模式

回答

相关问题