Java 场景的最佳设计模式

我们有一个名为Variable的类，它表示单值或复合值。例如，它可以保存整数、布尔值或字符串等。。。（单值）或一些复合值，可以是字符串、整数或其他变量的列表

我们序列化这些对象，在流中，所有这些值都表示为字符串。无论何时序列化或反序列化，都会发生类型转换

还有一些可选功能或方法可以在这些变量中填充值。例如，您可以定义要从网页填充的变量-对于给定的变量，我们查询缓存以了解它是否应该从网页填充。每当有人对变量执行getValue（）时，我们就会填充该值

我们还想跟踪一些变量的变化。例如，每当读取或更改变量的值时，我可以选择录制或执行某些操作

正如您所看到的，这是一个层次结构，因为变量可以包含其他变量。我们想找到解决这个问题的最佳方法

目前我们只有一个名为Variable的类，它有很多if/else条件，代码非常复杂。 例如，getValue（）代码执行以下操作：

if（查询缓存以查看是否需要从网页填充） 做点什么 else（---） 做点什么 else（如果应记录读取，则从缓存中查找） 做点什么

---

是否有任何模式可以设计我的类，使我的所有填充从网页逻辑可以进入一个类，跟踪其他类中的逻辑，在其他类中的类型转换逻辑等。。。为了让它更具可读性。

我不确定这是否回答了您的问题，但是，这可能会带来一些新的想法，以下是我在类似情况下的想法：

• 我给这些动态变量命名。动态变量可以有默认值，也可以由lamda（java8）/匿名内部类（java8之前）计算
• 每个变量都有一个评估上下文，只能在上下文中进行评估，即会话上下文或全局上下文。上下文相互回退并创建层次结构，即会话上下文回退到全局上下文。因此，默认变量常量或lambda值可以被上下文中定义的lambda或常量隐藏。在实例中，当在会话中访问全局变量时，会话作用域变量会隐藏全局变量

这似乎是一种非常灵活的方法——我甚至通过引入

InjectionContext

实现了一个微不足道的依赖项注入，这是一个线程安全的上下文，包含一个正在连接的对象

您可能想看看我目前正在开发的一个部署工具。配置管理和共享应用程序逻辑是基于这些变量构建的。代码在包中，但目前它相当原始。

组合中的每个链式元素都可以完成它的工作，但您必须花一些时间来配置运行时结构

可能只是getValue（）场景的合成或观察者（但在我看来更像合成）

编辑：

有人可能会说，下面的实现实际上是“责任链”的一种情况，因为一个复合变量将把设置值的责任委托给它的子变量

结束编辑

下面是一个使用Observer和Composite的简单示例。不是为了给你解决方案的总体感觉而测试的

我还没有实现序列化/反序列化之类的功能

在这个解决方案中，您有复合值和原子值，并且您可以在设置值之前添加一些要执行的观察者

package dk.asj.variables;

public abstract class VariableBase {

    public interface Observer {
        void onSet(final Value val, final VariableBase var);
    }

    private Observer obs = null;

    public void setObserver(final Observer obs) {
        this.obs = obs;
    }

    public void setValue(final Value val) {
        if (obs != null) {
            obs.onSet(val, this);
        }
        internalSetValue(val);
    }

    protected abstract void internalSetValue(final Value val);

    public abstract Value getValue();

}

package dk.asj.variables;

import java.util.List;

public interface Value {

    int getIntValue();

    String getStringValue();

    List<Value> getCompositeValue();

}

package dk.asj.variables;

public class SimpleVariable extends VariableBase {

    private Value val = null;

    @Override
    protected void internalSetValue(final Value val) {
        this.val = val;
    }

    @Override
    public Value getValue() {
        return val;
    }


}

package dk.asj.variables;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class CompoundVariable extends VariableBase {

    final List<VariableBase> children = new LinkedList<VariableBase>();

    public void addChild(final VariableBase c) {
        children.add(c);
    }

    @Override
    protected void internalSetValue(final Value val) {
        for (int i = 0; i < val.getCompositeValue().size(); ++i) {
            children.get(i).setValue(val.getCompositeValue().get(i));
        }
    }

    @Override
    public Value getValue() {
        final List<Value> res = new ArrayList<Value>(children.size());
        for (final VariableBase var : children) {
            res.add(var.getValue());
        }
        return new Value() {

            @Override
            public int getIntValue() {
                throw new RuntimeException("This is a composite value");
            }

            @Override
            public String getStringValue() {
                throw new RuntimeException("This is a composite value");
            }

            @Override
            public List<Value> getCompositeValue() {
                return res;
            }

        };
    }


}

包dk.asj.variables；
公共抽象类VariableBase{
公共接口观察员{
无效起始值（最终值val、最终变量BASE var）；
}
私有观察者obs=null；
公共观察员（最终观察员obs）{
this.obs=obs；
}
公共无效设置值（最终值val）{
如果（obs！=null）{
obs.发病（val，this）；
}
内部设定值（val）；
}
受保护的抽象无效内部设置值（最终值val）；
公共抽象值getValue（）；
}
包dk.asj.variables；
导入java.util.List；
公共接口值{
int getIntValue（）；
字符串getStringValue（）；
列出getCompositeValue（）；
}
包dk.asj.variables；
公共类SimpleVariable扩展了VariableBase{
私有值val=null；
@凌驾
受保护的无效内部设置值（最终值val）{
this.val=val；
}
@凌驾
公共值getValue（）{
返回val；
}
}
包dk.asj.variables；
导入java.util.ArrayList；
导入java.util.LinkedList；
导入java.util.List；
公共类CompoundVariable扩展了VariableBase{
最终列表子项=新建LinkedList（）；
公共void addChild（最终变量base c）{
添加（c）；
}
@凌驾
受保护的无效内部设置值（最终值val）{
对于（int i=0；i

这对我来说似乎更有用。你能详细说明一下这个请求吗