从追MM谈Java的23种设计模式
|
|
||||||||
|
|
从追MM谈Java的23种设计模式 |
|||||||
|
|
|
|||||||
|
|
||||||||
|
|
||||||||
|
|
|
设计模式之工厂模式
参考：http://www.cnblogs.com/mypm/archive/2011/02/09/1950130.html
参考：http://www.cnblogs.com/poissonnotes/archive/2010/12/01/1893871.html
参考：http://www.iteye.com/topic/903228
参考：http://www.iteye.com/topic/651027
参考：http://792881908-qq-com.iteye.com/blog/1447954
参考：http://love05160104.iteye.com/blog/1493330
参考：http://zhaoimpulse.iteye.com/blog/1150483
工厂模式的作用是负责实例化同一个接口的多个类。
工厂模式的意义是定义一个创建产品对象的工厂类，由该工厂统一创建继承了同一个接口的多个产品对象。
所有的产品抽象出一个基类，所有工厂抽象出一个基类，
工厂模式目的就是解耦。解耦目的是为了一个类的开发不影响其依赖类的开发。当依赖类开发需要被依赖的类的时候，就去工厂里面生产一个。工厂里面提供了响应的方法和事例。工厂得到依赖类是通过配置文件获取的，所以工厂类中没任何被依赖类的信息。这样就达到了解耦的目的。
工厂方法模式是完全符合开闭原则的。
使用工厂方法模式足以应付我们可能遇到的大部分业务需求。但是当产品种类非常多时，就会出现大量的与之对应的工厂类，这不应该是我们所希望的。
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
分类：
1）简单工厂模式（Simple Factory）：不利于产生系列产品；
2）工厂方法模式（Factory Method）：又称为多形性工厂；
3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品； 。
一、简单工厂模式
简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化。
组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
工厂角色
public class CarFactory {
private static final String BENZ = "Benz";
private static final String BMW = "BMW";
public static Car getCar(String carType) {
switch (carType) {
case BENZ:
return new Benz();
case BMW:
return new BMW();
default:
return null;
}
}
}
抽象产品角色
public interface Car {
void drive();
void stop();
}
具体产品角色
public class Benz implements Car {
@Override
public void drive() {
System.out.println("Benz drive");
}
@Override
public void stop() {
System.out.println("Benz stop");
}
}
public class BMW implements Car {
@Override
public void drive() {
System.out.println("BMW drive");
}
@Override
public void stop() {
System.out.println("BMW stop");
}
}
测试调用
public class Test {
public static void main(String[] args) {
Car benz = CarFactory.getCar("Benz");
benz.drive();
benz.stop();
Car bmw = CarFactory.getCar("BMW");
bmw.drive();
bmw.stop();
}
}
二、工厂方法模式
工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
组成：
1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
抽象工厂角色
public interface CarFactory {
Car getCar();
}
具体工厂角色
public class BenzFactory implements CarFactory {
@Override
public Car getCar() {
return new Benz();
}
}
public class BMWFactory implements CarFactory {
@Override
public Car getCar() {
return new BMW();
}
}
抽象产品角色
public interface Car {
void drive();
void stop();
}
具体产品角色
public class Benz implements Car {
@Override
public void drive() {
System.out.println("Benz drive");
}
@Override
public void stop() {
System.out.println("Benz stop");
}
}
public class BMW implements Car {
@Override
public void drive() {
System.out.println("BMW drive");
}
@Override
public void stop() {
System.out.println("BMW stop");
}
}
调用测试
public class Test {
public static void main(String[] args) {
CarFactory benzFactory = new BenzFactory();
Car benz = benzFactory.getCar();
benz.drive();
benz.stop();
CarFactory bmwFactory = new BMWFactory();
Car bmw = bmwFactory.getCar();
bmw.drive();
bmw.stop();
}
}
三、抽象工厂模式
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
抽象工厂角色
public interface CarFactory {
Benz getBenz();
BMW getBMW();
}
具体工厂角色
public class DefaultCarFactory implements CarFactory {
@Override
public Benz getBenz() {
return new Benz();
}
@Override
public BMW getBMW() {
return new BMW();
}
}
抽象产品角色
public interface Car {
void drive();
void stop();
}
具体产品角色
public class Benz implements Car {
@Override
public void drive() {
System.out.println("Benz drive");
}
@Override
public void stop() {
System.out.println("Benz stop");
}
}
public class BMW implements Car {
@Override
public void drive() {
System.out.println("BMW drive");
}
@Override
public void stop() {
System.out.println("BMW stop");
}
}
调用测试
public class Test {
public static void main(String[] args) {
CarFactory factory = new DefaultCarFactory();
Benz benz = factory.getBenz();
benz.drive();
benz.stop();
BMW bmw = factory.getBMW();
bmw.drive();
bmw.stop();
}
}
总结：
（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。
工厂模式：
（1）简单工厂模式：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体静态类实现。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。
（2）工厂方法模式：去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。
1) 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。
2) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3) 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中一般有抽象类或者接口来实现。
4) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在 java 中由具体的类来实现。
（3）抽象工厂模式：和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。组成和工厂模式差不多。
1）抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象而且使用抽象工厂模式还要满足一下条件：
a) 系统中有多个产品族，而系统一次只可能消费其中一族产品。
b) 同属于同一个产品族的产品以其使用。
设计模式之JDK中的设计模式
Structural（布局模式）
Adapter:
把一个接口或是类变成别的一种。
java.util.Arrays＃asList（）
javax.swing.JTable（TableModel）
java.io.InputStreamReader（InputStream）
java.io.OutputStreamWriter（OutputStream）
javax.xml.bind.annotation.adapters.XmlAdapter＃marshal（）
javax.xml.bind.annotation.adapters.XmlAdapter＃unmarshal（）
Bridge:
把抽象和实现解藕，于是接口和实现可在完全自力开来。
AWT （供给了抽象层映射于实际的操纵体系）
JDBC
Composite:
让应用者把零丁的对象和组合对象混用。
javax.swing.JComponent＃add（Component）
java.awt.Container＃add（Component）
java.util.Map＃putAll（Map）
java.util.List＃addAll（Collection）
java.util.Set＃addAll（Collection）
Decorator:
为一个对象动态的加上一系列的动作，而不须要因为这些动作的不合而产生多量的持续类。这个模式在JDK中几乎无处不在，所以，下面的列表只是一些典范的。
java.io.BufferedInputStream（InputStream）
java.io.DataInputStream（InputStream）
java.io.BufferedOutputStream（OutputStream）
java.util.zip.ZipOutputStream（OutputStream）
java.util.Collections＃checked[List|Map|Set|SortedSet|SortedMap]（）
Facade:
用一个简单的接口包状一组组件，接口，抽象或是子体系。
java.lang.Class
javax.faces.webapp.FacesServlet
Flyweight:
有效力地存储多量的小的对象。
java.lang.Integer＃valueOf（int）
java.lang.Boolean＃valueOf（boolean）
java.lang.Byte＃valueOf（byte）
java.lang.Character＃valueOf（char）
Proxy:
用一个简单的对象来庖代一个错杂的对象。
java.lang.reflect.Proxy
RMI
Creational（创建模式）
Abstract factory:
创建一组有接洽关系的对象实例。这个模式在JDK中也是相当的常见，还有很多的framework例如Spring。我们很轻易找到如许的实例。
java.util.Calendar＃getInstance（）
java.util.Arrays＃asList（）
java.util.ResourceBundle＃getBundle（）
java.sql.DriverManager＃getConnection（）
java.sql.Connection＃createStatement（）
java.sql.Statement＃executeQuery（）
java.text.NumberFormat＃getInstance（）
javax.xml.transform.TransformerFactory＃newInstance（）
Builder:
首要用来简化一个错杂的对象的创建。这个模式也可以用来实现一个 Fluent Interface。
java.lang.StringBuilder＃append（）
java.lang.StringBuffer＃append（）
java.sql.PreparedStatement
javax.swing.GroupLayout.Group＃addComponent（）
Factory:
简单来说，遵守需求返回一个类型的实例。
java.lang.Proxy＃newProxyInstance（）
java.lang.Object＃toString（）
java.lang.Class＃newInstance（）
java.lang.reflect.Array＃newInstance（）
java.lang.reflect.Constructor＃newInstance（）
java.lang.Boolean＃valueOf（String）
java.lang.Class＃forName（）
Prototype:
应用本身的实例创建另一个实例。有时辰，创建一个实例然后再把已有实例的值拷贝畴昔，是一个很错杂的动作。所以，应用这个模式可以避免如许的错杂性。
java.lang.Object＃clone（）
java.lang.Cloneable
Singleton:
只容许一个实例。在 Effective Java中建议应用Emun.
java.lang.Runtime＃getRuntime（）
java.awt.Toolkit＃getDefaultToolkit（）
java.awt.GraphicsEnvironment＃getLocalGraphicsEnvironment（）
java.awt.Desktop＃getDesktop（）
Behavioral（行动模式）
Chain of responsibility:
把一个对象在一个链接传递直到被处理惩罚。在这个链上的所有的对象有雷同的接口（抽象类）但却有不合的实现。
java.util.logging.Logger＃log（）
javax.servlet.Filter＃doFilter（）
Command:
把一个或一些号令封装到一个对象中。
java.lang.Runnable
javax.swing.Action
Interpreter:
一个语法申明器的模式。
java.util.Pattern
java.text.Normalizer
java.text.Format
Iterator:
供给一种一致的办法来次序遍历一个容器中的所有元素。
java.util.Iterator
java.util.Enumeration
Mediator:
用来削减对象单的直接通信的依附关系。应用一个中心类来经管消息的标的目标。
java.util.Timer
java.util.concurrent.utor＃execute（）
java.util.concurrent.utorService＃submit（）
java.lang.reflect.Method＃invoke（）
Memento:
给一个对象的状况做一个快照。Date类在内部应用了一个long型来做这个快照。
java.util.Date
java.io.Serializable
Null Object:
这个模式用来解决若是一个Collection中没有元素的景象。
java.util.Collections＃emptyList（）
java.util.Collections＃emptyMap（）
java.util.Collections＃emptySet（）
Observer:
容许一个对象向所有的侦听的对象广播本身的消息或事务。
java.util.EventListener
javax.servlet.http.HttpSessionBindingListener
javax.servlet.http.HttpSessionAttributeListener
javax.faces.event.PhaseListener
State:
这个模式容许你可以在运行时很轻易地按照自身内部的状况改变对象的行动。
java.util.Iterator
javax.faces.lifecycle.LifeCycle＃execute（）
Strategy:
定义一组算法，并把其封装到一个对象中。然后在运行时，可以灵活的应用此中的一个算法。
java.util.Comparator＃compare（）
javax.servlet.http.HttpServlet
javax.servlet.Filter＃doFilter（）
Template method:
容许子类重载项目组父类而不须要完全重写。
java.util.Collections＃sort（）
java.io.InputStream＃skip（）
java.io.InputStream＃read（）
java.util.AbstractList＃indexOf（）
Visitor:
感化于某个对象群中各个对象的操纵. 它可以使你在不改变这些对象本身的景象下，定义感化于这些对象的新操纵.
javax.lang.model.element.Element 和javax.lang.model.element.ElementVisitor
javax.lang.model.type.TypeMirror 和javax.lang.model.type.TypeVisitor
在Struts2中，其拦截器结构的设计，是一个典型的责任链模式的应用。首先将整个执行划分成若干相同类型的元素，每个元素具备不同的逻辑责任，并将他们纳入到一个链式的数据结构中（我们可以把堆栈结构也看作是一个递归的链式结构），而每个元素又有责任负责链式结构中下一个元素的执行调用。
这样的设计，从代码重构的角度来看，实际上是将一个复杂的系统，分而治之，从而使得每个部分的逻辑能够高度重用并具备高度可扩展性。所以，Interceptor结构实在是Struts2/Xwork设计中的精华之笔。
Struts2拦截器执行机理如下：
1. 整个结构就如同一个堆栈，除了Action以外，堆栈中的其他元素是Interceptor
2. Action位于堆栈的底部。由于堆栈"先进后出"的特性，如果我们试图把Action拿出来执行，我们必须首先把位于Action上端的Interceptor拿出来执行。这样，整个执行就形成了一个递归调用
3. 每个位于堆栈中的Interceptor，除了需要完成它自身的逻辑，还需要完成一个特殊的执行职责。这个执行职责有3种选择：
1) 中止整个执行，直接返回一个字符串作为resultCode
2) 通过递归调用负责调用堆栈中下一个Interceptor的执行
3) 如果在堆栈内已经不存在任何的Interceptor，调用Action
Struts2的设计模式:MVC模式:
1，web应用程序启动时就会加载并初始化ActionServler。
2，用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，
3，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果 Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。
4，Execute（）从 ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，
5，ActionServlet再把客户请求转发给 ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象
当ActionServlet接收到一个客户请求时,将执行如下流程.
-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象,就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
为什么要用struts：
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件.
相关推荐
FPGA设计实现OV5640 摄像头采集数据VGA显示输出Verilog设计逻辑Quartus工程源码文件，FPGA型号Cyclone4E系列中的EP4CE10F17C8，Quartus版本18.0。 module ov5640_rgb565_1024x768_vga( input sys_clk , //系统...
基于C51单片机+DS18B20+LCD1602显示智能温度检测控制系统设计软件源码 sbit k3=P3^2; //设置温度上下限 sbit k1=P3^4; //加 sbit k2=P3^5; //减 sbit led=P2^4; //报警指示灯 sbit beep=P1^5; //蜂鸣器...
verilog实现I2C通信的slave模块源码状态机设计可做I2C接口的仿真模型,module I2C_slv ( input [6:0] slv_id, input RESET, input scl_i, //I2C clk input sda_i, //I2C data in input [7:0] I2C_RDDATA, ///////////...
MVC软件设计架构，软件体系结构，用到设计模式
Design Pattern Example for Software
C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计模式(23种设计模式)C_设计...
基于STC90C51单片机+XPT2046设计的室内空气净化系统软件DEMO软件例程源码资料 #include #include "XPT2046.h" typedef unsigned char uint8; typedef unsigned int uint16; sbit rs=P2^6; // 数据命令选择 sbit rw...
这个是我的数据库的课程设计:超市商品数据管理系统的设计,,采用面向C/S模式的通用开发工具Delphi设计其前台的操作，数据库系统的开发环境使用SQL SERVER2000.
设计模式是一套被重复使用的代码设计经验的总结，本书面向有一定Java语言基础和一定编程经验的读者。旨在培养读者良好的设计模式思维方式，加强对面向对象思想的理解。全书共分12章，首先强调了接口和抽象类在设计...
基于B/S模式的图书在线销售系统的设计与实现
AJAX_设计模式 AJAX_设计模式 AJAX_设计模式 AJAX_设计模式
AD7705源程序 #ifndef _AD7705_H #define _AD7705_H //通讯寄存器地址定义 #define WR_SETUP_REG 0x10 //选中写设置寄存器 #define RD_SETUP_REG 0x18 //选中写...#define SYS_FULL_CALI 0xC0 //系统满量程校准模式
数据库课程设计 ...设计题目：C/S模式下的学籍管理系统开发“学生信息管理”模块 二.课程设计环境：基于Windows操作系统环境的C/S模式的Delphi7开发工具, MS SQL Server2000数据库, 截图软件，ODBC数据源管理器。
C设计模式_程序设计.rar C设计模式_程序设计.rar C设计模式_程序设计.rar C设计模式_程序设计.rar C设计模式_程序设计.rar
C# 设计模式.pdf 文档。无论您是新手，还是老手，本教程都值得一读。对于那些具有丰富的开发经验的开发人员，学习设计模式有助于了解在软件开发过程中所面临的问题的最佳解决方案；对于那些经验不足的开发人员，学习...
23种设计模式讲解 设计模式解析 设计模式学习
《C++设计模式》免费提供给大家阅读，我只推荐好的，不推荐一般的。^_^
FPGA设计 6位8通道同步采集AD芯片MAX11046 Verilog驱动源码： /* * @Description: MAX11046 divider */ module max11046_dev( input clk, input rst_n, input en, //开始采集信号 input ...
综合实例——Bug管理系统 （3）设计模式样例（24个讲解样例程序） pattern/src/principle/liskovsubstitution//10.3.2里氏代换原则 pattern/src/creation/factorymethod //11.1工厂方法模式 pattern/src/creation/...
// 设置串口的工作模式 SM1=1; //方式1 REN=0; // 不允许串口接收数据 ES=0; // 串口中断不允许 EA=1; // 开启中断总开关 } void SendASC(uchar d) { SBUF=d; while(!TI); TI=0; }