java设计模型 解析工厂模式、proxy-agent模式、templete模式

1、Factory Design pattern

工厂设计模式的优点

(1)工厂设计模式提供了接口而不是实现的代码方法。

(2)工厂模式从客户端代码中删除实际实现类的实例化。工厂模式使我们的代码更健壮,耦合更少,易于扩展。例如,我们可以轻松更改PC类实现,因为客户端程序不知道这一点。

(3)工厂模式通过继承提供实现和客户端类之间的抽象。

JDK中工厂设计模式实列

java.util.Calendar,ResourceBundle和NumberFormat getInstance()方法使用Factory模式。

valueOf() 包装类中的方法,如Boolean,Integer等。

代码示例:https://github.com/journaldev/journaldev/tree/master/java-design-patterns/Factory-Design-Pattern

2、Prototype example

Employees.java

 1 package com.journaldev.design.prototype;
 2
 3 import java.util.ArrayList;
 4 import java.util.List;
 5
 6 public class Employees implements Cloneable{
 7
 8     private List<String> empList;
 9
10     public Employees(){
11         empList = new ArrayList<String>();
12     }
13
14     public Employees(List<String> list){
15         this.empList=list;
16     }
17     public void loadData(){
18         //read all employees from database and put into the list
19         empList.add("Pankaj");
20         empList.add("Raj");
21         empList.add("David");
22         empList.add("Lisa");
23     }
24
25     public List<String> getEmpList() {
26         return empList;
27     }
28
29     @Override
30     public Object clone() throws CloneNotSupportedException{
31             List<String> temp = new ArrayList<String>();
32             for(String s : this.getEmpList()){
33                 temp.add(s);
34             }
35             return new Employees(temp);
36     }
37
38 }

PrototypePatternTest.java

 1 package com.journaldev.design.test;
 2
 3 import java.util.List;
 4
 5 import com.journaldev.design.prototype.Employees;
 6
 7 public class PrototypePatternTest {
 8
 9     public static void main(String[] args) throws CloneNotSupportedException {
10         Employees emps = new Employees();
11         emps.loadData();
12
13         //Use the clone method to get the Employee object
14         Employees empsNew = (Employees) emps.clone();
15         Employees empsNew1 = (Employees) emps.clone();
16         List<String> list = empsNew.getEmpList();
17         list.add("John");
18         List<String> list1 = empsNew1.getEmpList();
19         list1.remove("Pankaj");
20
21         System.out.println("emps List: "+emps.getEmpList());
22         System.out.println("empsNew List: "+list);
23         System.out.println("empsNew1 List: "+list1);
24     }
25
26 }

结果:

emps List: [Pankaj, Raj, David, Lisa]
empsNew List: [Pankaj, Raj, David, Lisa, John]
empsNew1 List: [Raj, David, Lisa]

3、Proxy模式

Proxy Design Pattern – Main Class

CommandExecutor.java

1 package com.journaldev.design.proxy;
2
3 public interface CommandExecutor {
4
5     public void runCommand(String cmd) throws Exception;
6 }

CommandExecutorImpl.java

 1 package com.journaldev.design.proxy;
 2
 3 import java.io.IOException;
 4
 5 public class CommandExecutorImpl implements CommandExecutor {
 6
 7     @Override
 8     public void runCommand(String cmd) throws IOException {
 9                 //some heavy implementation
10         Runtime.getRuntime().exec(cmd);
11         System.out.println("‘" + cmd + "‘ command executed.");
12     }
13
14 }

Proxy Design Pattern – Proxy Class

CommandExecutorProxy.java

 1 package com.journaldev.design.proxy;
 2
 3 public class CommandExecutorProxy implements CommandExecutor {
 4
 5     private boolean isAdmin;
 6     private CommandExecutor executor;
 7
 8     public CommandExecutorProxy(String user, String pwd){
 9         if("Pankaj".equals(user) && "[email protected]$v".equals(pwd)) isAdmin=true;
10         executor = new CommandExecutorImpl();
11     }
12
13     @Override
14     public void runCommand(String cmd) throws Exception {
15         if(isAdmin){
16             executor.runCommand(cmd);
17         }else{
18             if(cmd.trim().startsWith("rm")){
19                 throw new Exception("rm command is not allowed for non-admin users.");
20             }else{
21                 executor.runCommand(cmd);
22             }
23         }
24     }
25
26 }

ProxyPatternTest.java

 1 package com.journaldev.design.test;
 2
 3 import com.journaldev.design.proxy.CommandExecutor;
 4 import com.journaldev.design.proxy.CommandExecutorProxy;
 5
 6 public class ProxyPatternTest {
 7
 8     public static void main(String[] args){
 9         CommandExecutor executor = new CommandExecutorProxy("Pankaj", "wrong_pwd");
10         try {
11             executor.runCommand("ls -ltr");
12             executor.runCommand(" rm -rf abc.pdf");
13         } catch (Exception e) {
14             System.out.println("Exception Message::"+e.getMessage());
15         }
16
17     }
18
19 }

output

‘ls -ltr‘ command executed.
Exception Message::rm command is not allowed for non-admin users.

4、Singleton模式

(1)Singleton模式限制了类的实例化,并确保java虚拟机中只存在该类的一个实例。

(2)单例类必须提供一个全局访问点来获取类的实例。

(3)单例模式用于日志记录 ,驱动程序对象,缓存和线程池 。

(4)Singleton设计模式也用于其他设计模式,如Abstract Factory , Builder , Prototype , Facade等。

Singleton设计模式也用于核心java类,例如java.lang.Runtimejava.awt.Desktop

Java Singleton模式

为了实现Singleton模式,我们有不同的方法,但它们都有以下常见概念。

(1)私有构造函数,用于限制其他类的实例化。

(2)同一类的私有静态变量,它是该类的唯一实例。

(3)返回类实例的公共静态方法,这是外部世界获取单例类实例的全局访问点。

参考链接:https://www.journaldev.com/1827/java-design-patterns-example-tutorial

     https://www.cnblogs.com/yuanchao-blog/p/10779576.html

原文地址:https://www.cnblogs.com/lijianxuan/p/10808215.html

时间: 2024-10-04 01:19:06

java设计模型 解析工厂模式、proxy-agent模式、templete模式的相关文章

Java内存模型解析

一.java内存模型的诞生原因以及作用 1.诞生原因 java虚拟机中规范定义的一种内存模型,来屏蔽调各种硬件和操作系统之间的内存访问差异,为了实现java程序在各种平台都能达到一致的内存访问效果.这是它诞生的缘由. 2.作用 其实这个内存模型主要就是去定义程序中各个变量的访问规则,即在虚拟机中将变量存储到内存和从内存中取出来的底层细节,这里的变量,是指实例字段,静态字段,数组等,不包括局部变量和方法参数. 二.内存模型概述 1.主内存 所以的变量都存在主内存,这里的内存也就是虚拟机的内存,就是

Java设计模型应用——过滤器模式

storm引擎计算出一批中间告警结果,会发送一条kafka消息给告警入库服务,告警入库服务接收到kafka消息后读取中间告警文件,经过一系列处理后把最终告警存入mysql中. 实际上,中间告警结果可能有重复告警.错误告警.无用告警,告警入库服务会过滤,压缩中间告警,把用户关心的告警存入数据库.过滤的步骤较多,并且客户关心的告警可能会随时变化,写死的告警过滤很快就无法满足应用场景,这种场景下使用过滤器模式则很好满足业务上的不确定性欲扩展性. 告警入库服务涉及消息过滤和告警过滤,下面我们以消息过滤器

analysed of J-SON/XML processing model Extend to java design model (J-SON/XML处理模型分析 扩展到Java设计模型 )

一.JSON和XML 1.JSON JSON(JavaScript Object Notation)一种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性.可在不同平台之间进行数据交换.JSON采用兼容性很高的.完全独立于语言文本格式,同时也具备类似于C语言的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)体系的行为.这些特性使JSON成为理想的数据交换语言. 2.XML 扩展标记语言 (Extensible Markup Language

JSON/xml、Processing 以及收集Java的设计模型

JSON简介: 1.基本介绍 JSON(JavaScriptObject Notation, JS 对象简谱) 是一种轻量级的数据交换格式.它基于ECMAScript(欧洲计算机协会制定的js规范)的一个子集,采用完全独立于编程语言的文本格式来存储和表示数据.简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言. 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率. 2.JSON语法 在 JS 语言中,一切都是对象.因此,任何支持的类型都可以通过 JSON 来表示,例如字

Java设计模式3:工厂方法模式

工厂方法模式 工厂方法模式是类的创建模式.工厂方法模式的用意是定义一个创建产品对象的工厂接口,将实际创建工厂推迟到子类中. 工厂方法模式 工厂方法模式是对简单工厂模式进一步抽象的结果. 假如是不使用反射的工厂方法模式,那么所有的if... else if...else都放在工厂类中,势必造成工厂类的无限臃肿 这时候就需要工厂方法模式来处理这个问题了.工厂方法模式中,核心的工厂类不再负责所有对象的创建,而是将具体的创建工作交给子类去做.这个类则摇身一变变成了一个抽象工厂角色,仅仅负责给出具体工厂子

java设计模式2--抽象工厂模式(Abstract Factory)

本文地址:http://www.cnblogs.com/archimedes/p/java-abstract-factory-pattern.html,转载请注明源地址. 抽象工厂模式(别名:配套) 提供一个创建一系列(相互依赖)对象的接口,而无需指定它们具体的类. 概述 当系统准备为用户提供一系列相关的对象,又不想让用户代码和创建这些对象的类形成耦合时,就可以使用抽象工厂方法模式来设计系统.抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法,这些抽象方法分别返回某个类的实例,该抽象类或

Java设计模式之二工厂模式

在上一篇中我们学习了单例模式,介绍了单例模式创建的几种方法以及最优的方法.本篇则介绍设计模式中的工厂模式,主要分为简单工厂模式.工厂方法和抽象工厂模式. 简单工厂模式 简单工厂模式是属于创建型模式,又叫做静态工厂方法模式.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.调用只需要告诉工厂类所需要的类型,工厂类就会返回需要的产品类工厂的子类. 可以说是工厂模式中最简单的一种. 打个比方,我们在电脑经常玩游戏,我们只需要告诉电脑我们要玩什么游戏,电脑就会打开这个游戏,我们并不需要关心游戏是

(1)java设计模式之简单工厂模式

一:简单工厂模式的优点          --->在阎宏博士的<JAVA与模式>一书中开头是这样描述简单工厂模式的:简单工厂模式是类的创建模式,又叫做静态工厂方法(Static Factory Method)模式.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例. --->模式的核心是工厂类.这个类含有必要的逻辑判断,可以决定在什么时候创建哪一个登录验证类的实例,而调用者则可以免除直接创建对象的责任.简单工厂模式通过这种做法实现了对责任的分割,当系统引入新的登录方式的时候无

java常用设计模式之 工厂模式

工厂模式: 定义 一个用于创建对象的接口,让子类决定实例化哪一个类. 一句话概括: 是一个类的实例化延迟到其子类.     适用于 以下情况: ①:当一个类 ,不知道它所必须创建的对象的类的时候. ②:当一个类,希望由它的子类来指定它所创建的对象的时候. ③:当类将创建对象的职责给多个帮助子类中的一个,并且希望将哪一个帮助子类是代理这一信息局部化的时候. 说明: ① Product :定义工厂方法所创建的对象的接口. ② ConcreteProduct:实现Product 接口. ③ Creat