包装类是一种设计模式吗？

Question

我是一位有用的助手，可以为您翻译文本。

我是设计模式新手，现在正在处理一个开源代码：我试图理解代码的架构：层次结构，使用的设计模式...

所以我发现了一个包含名为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;
}
}

那么包装类有什么作用，它是一种设计模式吗？

- Amira

---

我会说是组合或委托模式，但从你的代码中很难确定：没有任何@ Override注释。此外，设计模式并不是一成不变的，即使存在许多经典的、经过验证的配方。 - fge

https://dev59.com/3nNA5IYBdhLWcg3wn_U1 - Frank van Puffelen

Answer 1

我看不到ActionWrapper包装的内容，对我来说它只是DataWrapper接口的实现。

有三种“类型”的包装器设计模式：

1. 外观模式 = 取很多类/接口，在内部执行一些逻辑并输出小接口。例如，“汽车启动”封装在内部：打开汽车，放置钥匙，设置DVD，调整座椅，点火。

2. 装饰器模式 = 获取一些带有行为的类，并使其能够在运行时添加行为。例如，您可以使用new LCDDecorator(new DVDDecorator(TurboDecorator(new car)))代替执行CarWithLCDWithDVDWithTurbo类。

3. 适配器模式 = 获取一些新接口并将其适配到某些已知接口。

- zzfima

---

仅考虑GOF模式，我会将代理模式添加到列表中，因为它可以与装饰器以相同的方式实现，只是目的不同。 - nansen

Answer 2

事实上，以Wrapper结尾并不意味着它就是一个包装器。要成为包装器，它必须包裹某些东西。也就是说，它必须封装一个或多个组件，可能是整个第三方API。

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

您的代码没有封装任何其他组件，因此对我来说它不是一个包装器。

- lontivero

---

在了解了数据传输对象（Data Transfer Object）的相关知识后，我们知道它代表一个包含 getter 和 setter 的类，是在不同应用程序层之间传输对象的解决方案。因此，我们可以说 ActionWrapper 是一个 DTO。 - Amira

Answer 3

把某物称为“包装器”并不意味着它就是一个包装器。基本上，它需要封装或包装某些东西，无论你如何称呼它。

- Daniel Uribe