高内聚低耦合
高内聚低耦合法则实例解析
⾼内聚低耦合法则实例解析定义：⼀个对象应该对其他对象保持最少的了解。
问题由来：类与类之间的关系越来越密切，耦合度越来越⼤，当⼀个类发⽣改变时，对另外⼀个类的影响也越⼤.解决⽅案：尽量降低类与类之间的耦合.⾃从我们接触到编程开始，就知道了软件设计的总的原则，低耦合，⾼内聚，⽆论是⾯向对象或者⾯向过程，耦合度尽量低，才能提⾼代码的复⽤率。
但是编程怎么编程低耦合呢？⽆论逻辑怎么复杂，对于依赖的类来说，都尽量将逻辑封装在类的内部，对外除了提供的public⽅法，不对外泄露任何信息。
还有⼀个更加简单的定义：只与直接的朋友通信。
⾸先解释⼀下什么是直接的朋友；每个对象都会与其他对象发⽣耦合关系，我们就说这两个对象之间有耦合关系，我们就说这两个对象有朋友关系，耦合发⽣的⽅式有很多，依赖，关联，组合，聚合等等。
其中，我们称出现成员变量，⽅法参数，⽅法返回值的类称为直接的朋友，⽽出现在局部变量中的类为不是直接的朋友，也就是说，陌⽣的类最好不要作为局部变量的形式出现在类的内部；举⼀个例⼦，在⼀所学校，⾥⾯有⽼师若⼲名，依次编号。
下⾯有学⽣若⼲名，⼀次编号。
现在要求打印出所有的⽼师和学⽣的ID.先来违反低耦合⾼内聚原则代码如下。
package test1;import java.util.ArrayList;import java.util.List;class Teacher{privateString id;publicvoidsetId(String id){this.id=id;}publicString getId(){return id;}}class Student{private String id;public void setId(String id){this.id=id;}public String getId(){return id;}}class StudentManage{publicList<Student> getAllStudent(){List<Student> list=newArrayList<Student>();for (int i=0;i<100;i++){Student student=new Student();student.setId("学⽣学号是"+i);list.add(student);}return list;}}class TeacherManage{publicList<Teacher> getAllTeacher(){List<Teacher> list=newArrayList<Teacher>();for (inti=0;i<100;i++){Teacher teacher =new Teacher();teacher.setId("⽼师编号"+i);list.add(teacher);}return list;}public void printAllPerson(StudentManagestudentmanager){List<Student>list1=studentmanager.getAllStudent();for (Student s:list1){System.out.println(s.getId());}List<Teacher>list2=this.getAllTeacher();for (Teacher t:list2){System.out.println(t.getId());}}}public classClient {publicstaticvoidmain(String[] args) {TeacherManagetm=newTeacherManage();tm.printAllPerson(new StudentManage());}}现在这个设计的主要问题出现在TeacherManage类中，根据低耦合⾼内聚法则，只与直接的朋友进⾏通信，⽽Student类并不是TeacherManage类中的直接朋友，应避免类中出现这样⾮直接朋友关系的耦合。
什么是软件的内聚度和耦合度
什么是软件的内聚度和耦合度在软件开发领域中，内聚度和耦合度是两个非常重要的概念。
它们描述了软件模块内部的结构以及模块之间的关联程度。
本文将介绍什么是软件的内聚度和耦合度，并探讨它们对软件质量的影响。
一、内聚度内聚度是指一个模块内部各个元素之间相互联系的紧密程度。
在软件设计中，高内聚度意味着模块内的功能高度相关，模块内部的元素完成相似的任务或者在相同的领域中进行操作。
相反，低内聚度意味着模块内的元素之间关联较弱，功能职责分散。
高内聚度有助于提高软件的可维护性、可读性和可测试性。
因为相关的功能被集中在同一个模块中，开发人员可以更容易地理解和修改代码。
此外，高内聚度还有助于减少修改所需的代码的范围，从而降低引入错误的风险。
在软件开发过程中，可以通过以下方法提高模块的内聚度：1. 功能相关性：确保一个模块内的函数和数据项都与模块的目标和责任相关联。
2. 单一职责原则：一个模块应该只负责一项功能，避免将多个不相关的功能组合在一个模块中。
3. 抽象与封装：将相关的功能封装在一个独立的接口或类中。
二、耦合度耦合度是指模块之间互相依赖的程度。
高耦合度意味着模块之间的关联紧密，一个模块的变动可能会影响其他模块的行为。
相反，低耦合度意味着模块之间的关联较弱，模块的变化不会对其他模块产生太大的影响。
低耦合度有助于提高软件的灵活性、可重用性和可测试性。
当模块之间的依赖关系较弱时，更容易对模块进行单独的修改、重用和测试。
此外，低耦合度还可以提高软件的可扩展性，因为可以更容易地替换、添加或删除模块。
在软件开发过程中，可以通过以下方法降低模块的耦合度：1. 接口设计：定义清晰的接口规范，模块之间通过接口进行通信，而不是直接依赖于具体实现。
2. 解耦合模式：使用设计模式，例如观察者模式或中介者模式，将模块之间的依赖降低至最低。
3. 依赖注入：通过依赖注入将模块的依赖关系转移到外部配置中，从而减少模块之间的直接耦合。
总结：软件的内聚度和耦合度是评价软件质量的重要指标。
低耦合高聚合
低耦合高聚合低耦合高聚合是一种软件设计原则，旨在提高系统的可维护性和可扩展性。
低耦合指的是模块之间的依赖关系要尽量降低，模块间的耦合度越低，就越容易进行单独的模块开发和测试，也就是说，一个模块的修改不会影响到其他模块的功能。
高聚合则是指将具有相似功能或相互依赖的模块组织在一起，形成一个高内聚的模块，以提高系统的内聚度。
低耦合和高聚合是相辅相成的，低耦合可以减少模块间的依赖关系，提高系统的可维护性和可测试性，而高聚合则可以使系统更加模块化，提高系统的可扩展性和可重用性。
在实际的软件开发中，如何实现低耦合和高聚合呢？首先，可以通过定义清晰的接口来降低模块之间的耦合度。
模块之间通过接口进行通信，而不是直接依赖具体的实现。
这样，当一个模块的实现发生变化时，只需要修改接口的实现，而不会影响其他模块。
可以使用事件驱动的方式来实现低耦合和高聚合。
模块之间通过发布和订阅事件的方式进行通信，模块之间不直接依赖，而是通过事件来解耦。
这样，一个模块的改变不会影响到其他模块，每个模块只关心自己感兴趣的事件。
使用依赖注入的方式也可以实现低耦合和高聚合。
通过将依赖关系的创建和管理交给外部容器来处理，模块之间的依赖关系可以在运行时动态地进行绑定和解绑。
这样，模块之间的耦合度就可以降低，同时也方便了系统的扩展和测试。
低耦合和高聚合的好处是显而易见的。
首先，它可以提高系统的可维护性。
当一个模块需要修改或替换时，只需要关注该模块本身的实现，而不需要考虑其他模块的影响。
其次，它可以提高系统的可扩展性。
当需要新增功能或模块时，可以通过组合已有的模块来实现，而不需要修改已有的代码。
最后，它可以提高系统的可重用性。
模块之间的低耦合和高聚合可以使得模块更加独立和独立测试，从而可以更好地复用。
低耦合高聚合是一种重要的软件设计原则，可以提高系统的可维护性、可扩展性和可重用性。
在实际的软件开发中，我们应该尽量遵循这个原则，通过定义清晰的接口、使用事件驱动和依赖注入等方式来实现低耦合和高聚合。
什么是高内聚、低耦合？
什么是⾼内聚、低耦合？起因：模块独⽴性指每个模块只完成系统要求的独⽴⼦功能，并且与其他模块的联系最少且接⼝简单，两个定性的度量标准――耦合性和内聚性。
耦合性也称块间联系。
指软件系统结构中各模块间相互联系紧密程度的⼀种度量。
模块之间联系越紧密，其耦合性就越强，模块的独⽴性则越差。
模块间耦合⾼低取决于模块间接⼝的复杂性、调⽤的⽅式及传递的信息。
耦合性分类(低――⾼): ⽆直接耦合;数据耦合;标记耦合;控制耦合;公共耦合;内容耦合;1 ⽆直接耦合:2 数据耦合: 指两个模块之间有调⽤关系，传递的是简单的数据值，相当于⾼级语⾔的值传递;3 标记耦合: 指两个模块之间传递的是数据结构，如⾼级语⾔中的数组名、记录名、⽂件名等这些名字即标记，其实传递的是这个数据结构的地址;4 控制耦合: 指⼀个模块调⽤另⼀个模块时，传递的是控制变量（如开关、标志等），被调模块通过该控制变量的值有选择地执⾏块内某⼀功能;5 公共耦合: 指通过⼀个公共数据环境相互作⽤的那些模块间的耦合。
公共耦合的复杂程序随耦合模块的个数增加⽽增加。
6 内容耦合: 这是最⾼程度的耦合，也是最差的耦合。
当⼀个模块直接使⽤另⼀个模块的内部数据，或通过⾮正常⼊⼝⽽转⼊另⼀个模块内部。
内聚性⼜称块内联系。
指模块的功能强度的度量，即⼀个模块内部各个元素彼此结合的紧密程度的度量。
若⼀个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越⾼。
内聚性匪类(低――⾼): 偶然内聚;逻辑内聚;时间内聚;通信内聚;顺序内聚;功能内聚;1 偶然内聚: 指⼀个模块内的各处理元素之间没有任何联系。
2 逻辑内聚: 指模块内执⾏⼏个逻辑上相似的功能，通过参数确定该模块完成哪⼀个功能。
3 时间内聚: 把需要同时执⾏的动作组合在⼀起形成的模块为时间内聚模块。
4 通信内聚: 指模块内所有处理元素都在同⼀个数据结构上操作（有时称之为信息内聚），或者指各处理使⽤相同的输⼊数据或者产⽣相同的输出数据。
高内聚低耦合
高内聚低耦合1．什么是内聚什么是耦合内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。
它描述的是模块内的功能联系；耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。
耦合性也称块间联系。
指软件系统结构中各模块间相互联系紧密程度的一种度量。
模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。
模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。
2．内聚分为哪几类耦合分为哪几类内聚有如下的种类，它们之间的内聚度由弱到强排列如下：（1）偶然内聚。
模块中的代码无法定义其不同功能的调用。
但它使该模块能执行不同的功能，这种模块称为巧合强度模块。
（2）逻辑内聚。
这种模块把几种相关的功能组合在一起，每次被调用时，由传送给模块参数来确定该模块应完成哪一种功能（3）时间内聚：把需要同时执行的动作组合在一起形成的模块为时间内聚模块。
（4）过程内聚：构件或者操作的组合方式是，允许在调用前面的构件或操作之后，马上调用后面的构件或操作，即使两者之间没有数据进行传递。
（5）通信内聚：指模块内所有处理元素都在同一个数据结构上操作（有时称之为信息内聚），或者指各处理使用相同的输入数据或者产生相同的输出数据。
（6）顺序内聚：指一个模块中各个处理元素都密切相关于同一功能且必须顺序执行，前一功能元素输出就是下一功能元素的输入。
（7）功能内聚：这是最强的内聚，指模块内所有元素共同完成一个功能，缺一不可。
耦合可以分为以下几种，它们之间的耦合度由高到低排列如下：（1）内容耦合：如果发生下列情形，两个模块之间就发生了内容耦合一个模块直接访问另一个模块的内部数据一个模块不通过正常入口转到另一模块内部；两个模块有一部分程序代码重叠(只可能出现在汇编语言中)；一个模块有多个入口。
（2）公共耦合：若一组模块都访问同一个公共数据环境，则它们之间的耦合就称为公共耦合。
数仓建模高内聚低耦合原则
数仓建模高内聚低耦合原则一、什么是数仓建模高内聚低耦合原则呢？数仓建模里的高内聚低耦合原则就像是搭积木一样。
高内聚呢，就是把相关的东西都紧紧地放在一起，就像把同一种颜色或者同一种形状的积木放在一堆。
比如说在数仓里，把和销售数据有关的，像销售额、销售量、销售渠道这些数据都放在一个模块里，这样它们就像是一个小家庭一样，关系很紧密。
低耦合就是各个模块之间不要有太多复杂的联系，就好比不同的积木堆之间，虽然可能会有一些连接，但是不会互相干扰太多。
在数仓里，销售数据模块和库存数据模块虽然可能会有交互，但是它们各自有自己的功能和结构，不会因为一个模块的改变而让另一个模块完全乱套。
二、高内聚的好处1. 便于理解当数据按照高内聚的原则组织起来的时候，我们去看这个数仓就特别容易明白。
就像我们打开一个装满小盒子的大盒子，每个小盒子里的东西都很整齐，我们一看就知道这个小盒子是干嘛的。
比如在做数据分析的时候，如果销售数据都整整齐齐地在一个地方，我们就能很快找到想要的数据，然后进行分析，而不是在一堆乱乱的数据里到处找。
2. 方便维护如果某个部分的数据出了问题，因为高内聚，我们就知道去哪里找问题。
就像如果一堆同颜色的积木倒了，我们就直接去那一堆找原因就好了。
在数仓里，如果销售数据有错误，我们直接在销售数据模块里排查就可以，而不用在整个数仓里大海捞针。
三、低耦合的好处1. 灵活性每个模块相对独立，就可以灵活地进行改变或者升级。
就像我们可以单独把一个积木堆重新搭成一个新的形状，而不影响其他的积木堆。
比如说库存管理模块如果要换一种计算库存的算法，只要它和其他模块的接口不变，就不会影响销售模块或者其他模块的正常运行。
2. 可扩展性当我们想要给数仓添加新的功能的时候，低耦合就特别有用。
就像我们可以很轻松地在原来的积木堆旁边再添加一个新的积木堆。
如果要加一个新的数据分析功能模块，只要它和现有的模块之间的耦合度低，就可以很顺利地加进去，不会和原来的模块产生冲突。
内聚和耦合
内聚和耦合
内聚（Cohesion）指的是模块内部各个元素之间的联系紧密程度。
高内聚的模块表示模块内部各个元素紧密联系，完成的任务单一；低内聚的模块表示模块内部各个元素联系松散，完成的任务复杂多样。
高内聚的模块易于维护和重构，同时也能提高模块的复用性。
耦合（Coupling）指的是模块之间的联系紧密程度。
高耦合的模块表示模块之间联系紧密，一个模块的修改会影响到其他模块的功能；低耦合的模块表示模块之间联系松散，一个模块的修改不会对其他模块的功能造成影响。
低耦合的模块易于维护和重构，同时也能提高模块的复用性。
在软件开发中，要尽量使模块内部高内聚、模块之间低耦合，以便提高软件的可维护性、可重用性和可扩展性。
低耦合高内聚 数据耦合 标记耦合 控制耦合
低耦合高内聚数据耦合标记耦合控制耦合低耦合高内聚：数据耦合、标记耦合、控制耦合在软件开发领域中，低耦合高内聚是一种设计原则，旨在提高软件系统的可维护性和可扩展性。
低耦合指的是模块之间的依赖关系尽可能的松散，模块间的改动不会对其他模块造成太大的影响；高内聚则强调一个模块内的成员之间的关联性强，模块内功能相近的代码被集中在一起。
数据耦合是指模块之间通过共享数据进行通信的一种耦合方式。
当一个模块依赖于另一个模块的数据时，它们之间就存在数据耦合。
数据耦合可能导致代码的可读性和可维护性下降。
为了降低数据耦合，可以采用封装数据的方式，通过提供接口的方式访问数据，从而减少对数据的直接访问。
标记耦合是指模块之间通过特定的标记进行通信的一种耦合方式。
这种耦合方式常见于参数传递的情况，通过传递特定的标记来决定执行不同的逻辑。
然而，过多的标记耦合会导致代码的可读性和可维护性变差。
为了降低标记耦合，可以引入多态和继承的概念，通过不同的子类来实现不同的逻辑。
控制耦合是指一个模块对另一个模块的控制依赖的一种耦合方式。
当一个模块依赖于另一个模块的控制流程时，它们之间就存在控制耦合。
控制耦合可能导致模块之间的相互联系过于紧密，一旦其中一个模块发生改动，可能需要修改另一个模块的代码。
为了降低控制耦合，可以采用事件驱动的方式，通过事件的触发和处理来进行模块之间的通信。
低耦合高内聚是一种设计原则，通过降低模块之间的依赖关系及增强模块内部的关联性，来提高软件系统的可维护性和可扩展性。
在具体实现中，可以通过减少数据耦合、标记耦合和控制耦合来达到这一目标。
通过封装数据、使用多态和继承来降低数据耦合和标记耦合；通过使用事件驱动的方式来降低控制耦合。
也要注意在代码编写过程中，遵循软件设计的其他原则，如单一职责原则、开闭原则等，以确保系统具有良好的设计质量。
个人观点与理解上，低耦合高内聚是我认为非常重要的设计原则。
在实际开发中，我始终努力遵循这一原则，以提高代码的可维护性和可扩展性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
高内聚低耦合1．什么是内聚？什么是耦合？内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。
它描述的是模块内的功能联系；耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。
耦合性也称块间联系。
指软件系统结构中各模块间相互联系紧密程度的一种度量。
模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。
模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。
2．内聚分为哪几类？耦合分为哪几类？内聚有如下的种类，它们之间的内聚度由弱到强排列如下：（1）偶然内聚。
模块中的代码无法定义其不同功能的调用。
但它使该模块能执行不同的功能，这种模块称为巧合强度模块。
（2）逻辑内聚。
这种模块把几种相关的功能组合在一起，每次被调用时，由传送给模块参数来确定该模块应完成哪一种功能（3）时间内聚：把需要同时执行的动作组合在一起形成的模块为时间内聚模块。
（4）过程内聚：构件或者操作的组合方式是，允许在调用前面的构件或操作之后，马上调用后面的构件或操作，即使两者之间没有数据进行传递。
（5）通信内聚：指模块内所有处理元素都在同一个数据结构上操作（有时称之为信息内聚），或者指各处理使用相同的输入数据或者产生相同的输出数据。
（6）顺序内聚：指一个模块中各个处理元素都密切相关于同一功能且必须顺序执行，前一功能元素输出就是下一功能元素的输入。
（7）功能内聚：这是最强的内聚，指模块内所有元素共同完成一个功能，缺一不可。
耦合可以分为以下几种，它们之间的耦合度由高到低排列如下：（1）内容耦合：如果发生下列情形，两个模块之间就发生了内容耦合•一个模块直接访问另一个模块的内部数据•一个模块不通过正常入口转到另一模块内部；•两个模块有一部分程序代码重叠(只可能出现在汇编语言中)；•一个模块有多个入口。
（2）公共耦合：若一组模块都访问同一个公共数据环境，则它们之间的耦合就称为公共耦合。
公共的数据环境可以是全局数据结构、共享的通信区、内存的公共覆盖区等。
（3）外部耦合：一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4）控制耦合：如果一个模块通过传送开关、标志、名字等控制信息，明显地控制选择另一模块的功能，就是控制耦合（5）标记耦合：一组模块通过参数表传递记录信息，就是标记耦合。
这个记录是某一数据结构的子结构，而不是简单变量。
其实传递的是这个数据结构的地址；也就是地址传递。
（6）数据耦合：指两个模块之间有调用关系,传递的是简单的数据值，一个模块访问另一个模块时，彼此之间是通过简单数据参数(不是控制参数、公共数据结构或外部变量) 来交换输入、输出信息的,相当于高级语言的值传递。
（7）非直接耦合：两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
耦合强度，依赖于以下几个因素：（1）一个模块对另一个模块的调用；（2）一个模块向另一个模块传递的数据量；（3）一个模块施加到另一个模块的控制的多少；（4）模块之间接口的复杂程度。
1、耦合、内聚的评估标准是强度，耦合越弱越好，内聚越强越好；2、所谓过度指的是由于错误理解导致的效果相反的设计；3、耦合指的模块之间的关系，最弱的耦合设计是通过一个主控模块来协调n个模块之间的运作。
还是举一个我举过的例子：客户要求在界面上增加一个字段，你的项目要修改几个地方呢？如果你只要修改项目文档，那么你的开发构架就是最低强度的耦合，而这种设计成熟的开发团队都已经做到了，他们使用开发工具通过项目模型驱动数据库和各层次的代码，而不是直接修改那些代码；4、内聚指的是模块内部的功能，最强的内聚就是功能单一到不能拆分，也就是原子化，5、所以强内聚和弱耦合是相辅相成的，一个良好的设计是由若干个强内聚模块以弱耦合的方式组装起来的―――――――――――――――――――――――――――――――――――――――――――1. 低耦合（Low Coupling）“低耦合”这个词相信大家已经耳熟能详，我们在看spring的书籍、MVC的数据、设计模式的书籍，无处不提到“低耦合、高内聚”，它已经成为软件设计质量的标准之一。
那么什么是低耦合？耦合就是对某元素与其它元素之间的连接、感知和依赖的量度。
这里所说的元素，即可以是功能、对象（类），也可以指系统、子系统、模块。
假如一个元素A去连接元素B，或者通过自己的方法可以感知B，或者当B不存在的时候就不能正常工作，那么就说元素A与元素B耦合。
耦合带来的问题是，当元素B发生变更或不存在时，都将影响元素A的正常工作，影响系统的可维护性和易变更性。
同时元素A只能工作于元素B存在的环境中，这也降低了元素A的可复用性。
正因为耦合的种种弊端，我们在软件设计的时候努力追求“低耦合”。
低耦合就是要求在我们的软件系统中，某元素不要过度依赖于其它元素。
请注意这里的“过度”二字。
系统中低耦合不能过度，比如说我们设计一个类可以不与JDK耦合，这可能吗？除非你不是设计的Java程序。
再比如我设计了一个类，它不与我的系统中的任何类发生耦合。
如果有这样一个类，那么它必然是低内聚（关于内聚的问题我随后讨论）。
耦合与内聚常常是一个矛盾的两个方面。
最佳的方案就是寻找一个合适的中间点。
哪些是耦合呢？1．元素B是元素A的属性，或者元素A引用了元素B的实例（这包括元素A调用的某个方法，其参数中包含元素B）。
2．元素A调用了元素B的方法。
3．元素A直接或间接成为元素B的子类。
4．元素A是接口B的实现。
幸运的是，目前已经有大量的框架帮助我们降低我们系统的耦合度。
比如，使用struts我们可以应用MVC模型，使页面展现与业务逻辑分离，做到了页面展现与业务逻辑的低耦合。
当我们的页面展现需要变更时，我们只需要修改我们的页面，而不影响我们的业务逻辑；同样，我们的业务逻辑需要变更的时候，我们只需要修改我们的java程序，与我们的页面无关。
使用spring我们运用IoC（反向控制），降低了业务逻辑中各个类的相互依赖。
假如类A因为需要功能F而调用类B，在通常的情况下类A需要引用类B，因而类A就依赖于类B了，也就是说当类B不存在的时候类A就无法使用了。
使用了IoC，类A调用的仅仅是实现了功能F的接口的某个类，这个类可能是类B，也可能是另一个类C，由spring的配置文件来决定。
这样，类A就不再依赖于类B了，耦合度降低，重用性提高了。
使用hibernate则是使我们的业务逻辑与数据持久化分离，也就是与将数据存储到数据库的操作分离。
我们在业务逻辑中只需要将数据放到值对象中，然后交给hibernate，或者从hibernate那里得到值对象。
至于用Oracle、MySQL 还是SQL Server，如何执行的操作，与我无关。
但是，作为优秀的开发人员，仅仅依靠框架提供的降低软件耦合的方法是远远不够的。
根据我的经验，以下一些问题我们应当引起注意：1）根据可能的变化设计软件我们采用职责驱动设计，设计中尽力做到“低耦合、高内聚”的一个非常重要的前提是，我们的软件是在不断变化的。
如果没有变化我们当然就不用这么费劲了；但是如果有变化，我们希望通过以上的设计，使我们在适应或者更改这样的变化的时候，付出更小的代价。
这里提供了一个非常重要的信息是，我们努力降低耦合的是那些可能发生变更的地方，因为降低耦合是有代价的，是以增加资源耗费和代码复杂度为代价的。
如果系统中某些元素不太可能变更，或者降低耦合所付出的代价太大，我们当然就应当选择耦合。
有一次我试图将我的表现层不依赖于struts，但发现这样的尝试代价太大而失去意义了。
对于软件可能变更的部分，我们应当努力去降低耦合，这就给我们提出一个要求是，在软件设计的时候可以预判日后的变化。
根据以往的经验我认为，一个软件的业务逻辑和采用的技术框架往往是容易变化的2个方面。
客户需求变更是我们软件设计必须考虑的问题。
在RUP的开发过程中，为什么需要将分析设计的过程分为分析模型和设计模型，愚以为，从分析模型到设计模型的过程实际上是系统从满足直接的客户需求到优化系统结构、适应可预见的客户需求变更的一个过程。
这种客户需求的变更不仅仅指对一个客户需求的变更，更是指我们的软件从适应一个客户需求到适应更多客户需求的过程。
另一个方面，现在技术变更之快，EJB、hibernate、spring、ajax，一个一个的技术像走马灯一样从我们脑海中滑过，我们真不知道明天我在用什么。
在这样的情况下，适应变化就是我们最佳的选择。
2）合理的职责划分合理的职责划分，让系统中的对象各司其职，不仅是提高内聚的要求，同时也可以有效地降低耦合。
比如评审计划BUS、评审表BUS、评审报告BUS都需要通过评审计划DAO去查询一些评审计划的数据，如果它们都去直接调用评审计划DAO（如图A），则评审计划BUS、评审表BUS、评审报告BUS三个对象都与评审计划DAO耦合，评审计划DAO一旦变更将与这三个对象都有关。
在这个实例中，实际上评审计划BUS是信息专家（关于信息专家模式我将在后面讨论），评审表BUS和评审报告BUS如果需要获得评审计划的数据，应当向评审计划BUS提出需求，由评审计划BUS提供数据（如图B）。
经过这样的调整，系统的耦合度就降低了。
3）使用接口而不是继承通过对耦合的分析，我们不难发现，继承就是一种耦合。
如果子类A继承了父类B，不论是直接或间接的继承，子类A都必将依赖父类B。
子类A必须使用在存在父类B的环境中，父类B不存在子类A就不能使用，这样将影响子类A的可移植性。
一旦父类B发生任何变更，更改或去掉一个函数名，或者改变一个函数的参数，都将导致子类A不得不变更，甚至重写。
假如父类B的子类数十上百个，甚至贯穿这个项目各个模块，这样的变更是灾难性的。
这种情况最典型的例子是我们现在使用hibernate和spring 设计DAO对象的方式，具体的描述参见我写的《如何在struts + spring + hibernate的框架下构建低耦合高内聚的软件结构》一文。
总之，“低耦合”给软件项目带来的优点是：易于变更、易于重用2. 高内聚（High Cohesion）高内聚是另一个普遍用来评判软件设计质量的标准。
内聚，更为专业的说法叫功能内聚，是对软件系统中元素职责相关性和集中度的度量。
如果元素具有高度相关的职责，除了这些职责内的任务，没有其它过多的工作，那么该元素就具有高内聚性，反之则为低内聚性。
高内聚要求软件系统中的各个元素具有较高的协作性，因为在我们在完成软件需求中的一个功能，可能需要做各种事情，但是具有高内聚性的一个元素，只完成它职责内的事情，而把那些不在它职责内的事情拿去请求别人来完成。