标签: loose-coupling

我正在使用Silverlight在后端实现一个基于Web的应用程序,该应用程序将显示应用程序将显示的所有数据.我想确保应用程序可以轻松扩展,我觉得这样做的方向是使数据库松散耦合,而不是将所有内容与外键绑定.我试过寻找一些例子,但无济于事.

有没有人有任何信息或良好的起点/样品/例子来帮助我开始这个？

非常感谢.

亲切的问候,

我目前正在使用Ninject作为我的DI工作的MVC 3项目,业务对象存储在一个单独的程序集中.我遇到了控制器参数的问题,当回发CRUD操作时,我收到错误"无法创建接口的实例".我知道你不能创建一个接口的实例,但似乎我可以解决的唯一方法是使用自定义模型绑定器并通过FormCollection.这看起来非常混乱,我想尽可能多地保留项目中特定类型的代码 - 因此在任何地方接口和Ninject到DI的混凝土.自定义模型绑定不仅看起来很乱 - 我不会丢失我的DataAnnotations吗？

一些代码来描述我的内容:

public ActionResult Create()
{
    // I'm thinking of using a factory pattern for this part
    var objectToCreate = new ConcereteType();
    return (objectToEdit);
}

[HttpPost]
public ActionResult Create(IRecord record)
{
    // check model and pass to repository
    if (ModelState.IsValue)
    {
        _repository.Create(record);
        return View();
    }

    return View(record);
}

有没有人遇到过这个？你是怎么克服它的？

谢谢!

interface Bank {
    void connect();
}

class SBI implements Bank {
    static{
        System.out.println("Hello from SBI static");
    }   
    public void connect() {
        System.out.println("Connected to SBI");
    }
}

class LooseCouplingTest {
    public static void main(String... args)throws Exception {
        String className = args[0];
        Class.forName(className);
    }
}

上面代码的输出似乎是
Hello from SBI static

我应该添加什么来代码和Y来also打印语句
Connected to SBI

详细解释非常感谢

PS Noob在这里

我意识到这个问题已经被解决了,但我仍在努力,可以做一些具体的帮助.

我的目标是在某种可观察的(可以说是狗)和某种倾听者(比如所有者)之间实现一个简单的观察者模式.

最终,所有者将成为MVC范例中的"视图"和"狗"模型.我正在使用Dog和Owner来尝试简化这里的事情.

我试图使用Java内置的Observer/Observable类,但已经意识到Observers update()方法有多糟糕 - 它接收到POJO,我需要在update()方法中检查/转换该POJO.我更愿意让我的'update()'方法收到它可以期待的东西.

所以,我遵循了一些教程,包括使用Dog/Owner作为示例的教程:

http://www.youtube.com/watch?v=qw0zZAte66A

在这里,我已经展示了如何滚动我自己的Observer/Observed类.在伪代码中,我现在拥有的是:

Dog/Model {

    List listeners;

    public fireDogHungryEvent() {

        foreach listener {
            listener.onDogHungry(this);
        }
    }

    public fireDogPeeEvent() {

        foreach listener {
            listener.onDogNeedsToPee(this);
        }
    }

    public getHungerLevel() { return hungerLevel; }
    public getBladderCapacity() { return bladderCapacity; }
}

Owner/View {

    public onDogHungry(model) {
        println(model.getHungerLevel());
    }

    public onDogNeedsToPee(model) {
        println(model.getBladderCapacity());
    }
}

所以现在而不是一个update()方法,我有处理特定事件的方法.辉煌.我目前对所有者/视图类感到满意.它知道Dog/model的方法,这很好(我认为).

我不喜欢的是Dog/model引用了Owner/view中的方法.我已经阅读过无数次并且完全同意模型不应该与其视图紧密耦合,例如它似乎在上面.我也不热衷于狗/模型中的所有'火'方法几乎做同样的事情; 循环遍及其所有侦听器,并在每个侦听器上调用不同的方法.

是否有可能进一步解除这种关系,而不是具有Dog/model调用特定方法？如果是这样,将狗/模型数据接收到所有者/视图并适当地使用它的最佳方法是什么？

谢谢

根据下一个例子:

class InvoiceGenerator
{
   function create(Invoice $invoice)
   {
      $invoice->create();
   }
}



class InvoiceGenerator
{
   function create($invoiceData)
   {
      $invoice = new Invoice();
      $invoice->create($invoiceData);
   }
}

第一个示例在InvoiceGenerator和Invoice类之间的耦合较少,因为InvoiceGenerator不需要Invoice类.此外,它不仅可以处理一个类,而且可以处理几乎没有修改的整个界面.我已多次读过这样的原则:接口代码,而不是实现.这种情况的缺点是我被迫在客户端代码中实例化Invoice类.

第二个有更多的封装.实例化和创建发票的所有过程都委托给InvoiceGenerator类.尽管两个类都是耦合的,但这是有道理的,因为"发票生成器"在没有发票的情况下不会做任何事情.

您认为哪种最合适？或者两者之间的平衡设计的关键点是什么？

您是否为域模型中的每个公共类实现了一个接口？优点和缺点？

更新:如果存储库接口和域模型类在单独的程序集中定义,如果我们不为每个域类定义接口,则不会存在循环依赖关系.

当我在做TDD时,它迫使我采用依赖注入原则,最后我得到松散耦合的代码.

有人告诉我,理解松散耦合代码的应用程序更难.

你能告诉我松耦合代码的优缺点吗？

我们有这个用于编码标准的应用程序，称为声纳。我有一个返回 ArrayList 的函数，声纳说“java 松散耦合避免使用像 'ArrayList' 这样的实现类型；改用接口”

例如，如果我这样做，声纳会给出该错误。

    public ArrayList<String> test()
       {
       ArrayList<String> testing = new ArrayList<String>();
        return testing;
        }

我不确定如何更正声纳消息以使用接口。

任何建议都会有所帮助。

我写了一些代码来获取数据pySerial，如下所示。
我的班级依赖于不符合“松散耦合”规则的串行班级。
我应该使用接口来解耦我的类吗？
非常感谢您的指导。

import serial

class ArduinoConnect:  

    def __init__(self):
        pass

    def serial_connect(self, serial_port, serial_baudrate):

        self._serial_port = serial_port
        try:
           self.ser = serial.Serial(
                port=self._serial_port,
                baudrate=serial_baudrate,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                bytesize=serial.EIGHTBITS,
            )
        except serial.serialutil.SerialException, e:
            print str(e)

    def serial_disconnect(self):
        self.ser.close()

    def get_quaternion(self, number_of_data=50):

        buff = []
        self.ser.write('q')
        self.ser.write(chr(number_of_data))
        for j in range(number_of_data):
            in_string = self.ser.readline()
            buff_line = in_string.split(",")
            buff_line.pop()
            buff_line = self.hex_to_quaternion(buff_line)
            buff.append(list(buff_line))
        return buff

    def hex_to_quaternion(self, list_of_hex=None):
        #......
        pass

arduino = ArduinoConnect()
arduino.serial_connect(serial_port="COM5", serial_baudrate=115200)
print arduino.get_quaternion()
arduino.serial_disconnect()

我按照建议调整了我的代码。
DI有助于分离串行过程，工厂方法有助于封装DI过程。
我还能做些什么来满足“松散耦合”规则？
谢谢你的帮助。 …

我正在使用ASP.NET MVC3和SQL Server中的数据库开发Web应用程序项目.还有一个移动应用程序通过REST服务使用来自同一数据库的数据.以下是我的应用程序的一些层:

• Model - ADO.NET数据模型,使用Entity Framework

• 数据访问层 - 具有查询以从数据库中检索数据的存储库

• Web应用程序 - MVC3项目,使用存储库,使用Structure Map和DI进行松散耦合,数据库上下文在HttpRequest结束时处理

• 核心 - DAL和服务层之间的另一层,使用存储库并将数据公开给服务层.业务逻辑层的排序.

• 服务层 - REST服务,了解Core层但不了解DAL.将数据映射到DTO并公开给客户端

我在这种应用程序架构中遇到的问题是服务层上的松散耦合.服务层引用了Core层.核心层引用了数据访问层并使用其存储库.但是,存储库没有默认构造函数.他们期望1个参数及其数据库对象上下文(一次性对象).

直接在我的网站上使用存储库不是问题.我正在使用结构图和DI使它松散耦合.每个上下文都在HttpRequest的末尾处理.

问题是服务层和核心层.我想在那里松耦合,但不知道如何实现它？如何将数据上下文注入其中并确保在某个时刻处置？我想听听一些关于如何将它们放在一起的建议.