Java Design Patterns（2）

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

 package com.journaldev.design.prototype;

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

 public class Employees implements Cloneable{

     private List<String> empList;

     public Employees(){
         empList = new ArrayList<String>();
     }

     public Employees(List<String> list){
         this.empList=list;
     }
     public void loadData(){
         //read all employees from database and put into the list
         empList.add("Pankaj");
         empList.add("Raj");
         empList.add("David");
         empList.add("Lisa");
     }

     public List<String> getEmpList() {
         return empList;
     }

     @Override
     public Object clone() throws CloneNotSupportedException{
             List<String> temp = new ArrayList<String>();
             for(String s : this.getEmpList()){
                 temp.add(s);
             }
             return new Employees(temp);
     }

 }

PrototypePatternTest.java

 package com.journaldev.design.test;

 import java.util.List;

 import com.journaldev.design.prototype.Employees;

 public class PrototypePatternTest {

     public static void main(String[] args) throws CloneNotSupportedException {
         Employees emps = new Employees();
         emps.loadData();

         //Use the clone method to get the Employee object
         Employees empsNew = (Employees) emps.clone();
         Employees empsNew1 = (Employees) emps.clone();
         List<String> list = empsNew.getEmpList();
         list.add("John");
         List<String> list1 = empsNew1.getEmpList();
         list1.remove("Pankaj");

         System.out.println("emps List: "+emps.getEmpList());
         System.out.println("empsNew List: "+list);
         System.out.println("empsNew1 List: "+list1);
     }

 }

结果：

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

 package com.journaldev.design.proxy;

 public interface CommandExecutor {

     public void runCommand(String cmd) throws Exception;
 }

CommandExecutorImpl.java

 package com.journaldev.design.proxy;

 import java.io.IOException;

 public class CommandExecutorImpl implements CommandExecutor {

     @Override
     public void runCommand(String cmd) throws IOException {
                 //some heavy implementation
         Runtime.getRuntime().exec(cmd);
         System.out.println("'" + cmd + "' command executed.");
     }

 }

Proxy Design Pattern – Proxy Class

CommandExecutorProxy.java

 package com.journaldev.design.proxy;

 public class CommandExecutorProxy implements CommandExecutor {

     private boolean isAdmin;
     private CommandExecutor executor;

     public CommandExecutorProxy(String user, String pwd){
         if("Pankaj".equals(user) && "J@urnalD$v".equals(pwd)) isAdmin=true;
         executor = new CommandExecutorImpl();
     }

     @Override
     public void runCommand(String cmd) throws Exception {
         if(isAdmin){
             executor.runCommand(cmd);
         }else{
             if(cmd.trim().startsWith("rm")){
                 throw new Exception("rm command is not allowed for non-admin users.");
             }else{
                 executor.runCommand(cmd);
             }
         }
     }

 }

ProxyPatternTest.java

 package com.journaldev.design.test;

 import com.journaldev.design.proxy.CommandExecutor;
 import com.journaldev.design.proxy.CommandExecutorProxy;

 public class ProxyPatternTest {

     public static void main(String[] args){
         CommandExecutor executor = new CommandExecutorProxy("Pankaj", "wrong_pwd");
         try {
             executor.runCommand("ls -ltr");
             executor.runCommand(" rm -rf abc.pdf");
         } catch (Exception e) {
             System.out.println("Exception Message::"+e.getMessage());
         }

     }

 }

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.Runtime ， java.awt.Desktop 。

Java Singleton模式

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

（1）私有构造函数，用于限制其他类的实例化。

（2）同一类的私有静态变量，它是该类的唯一实例。

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

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