java Spring中使用到的设计模式

单例模式

单例模式(Singleton Pattern)是java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
（1）单例类只能有一个实例。
（2）单例类必须自己创建自己的唯一实例。
（3）单例类必须给所有其他对象提供这一实例。

优点：
（1）在内存里面只有一个实例，减少了内存的开销，尤其是平凡创建和销毁实例。
（2）避免对文件的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：
（1）要求生产唯一序列号。
（2）Web中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
（3）创建的一个对象需要消耗的资源过多，比如I/O与数据库的链接等。

注意事项：getInstance()方法中需要使用同步锁synchronized(Singleton.class)防止多线程同时进入造成instance被多次实例化。

实现：

	public class SingleObject {
		//创建SingleOject的一个对象
		private static SingleObject instance = new SingleObject();
		
		//让构造器函数为private，这样类就不会被实例化
		private SingleObject(){};

		//获取唯一可用的对象
		public static SingleObject getInstance(){
			return instance;
	}
		public void showMessage(){
			System.out.println("aaaa");
		}
}
	

Spring中定义的bean默认为单例模式，保证每一个类中仅有一个实例，并提供一个访问它的全局访问点。spring中的单例模式提供了全局访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是任意的java对象。

单例模式的几种实现方式

（1）懒汉式，线程不安全
这种方式是最基本的实现方式，这种实现的最大的问题就是不支持多线程。因为没有加锁synchronized，所以严格意义上不算单例模式。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

（2）懒汉式，线程安全
能够在多线程中很好的工作，但是效率很低，99%的情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加synchronized才能保证单例，但加锁会影响效率。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

（3）饿汉式
这种方法比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

（4）双检索/双重校验锁（DCL，即double-checked locking）
这种方式采用双锁机制，安全且在多线程情况下保持高性能。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

（5）登记式/静态内部类
这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应该使用这种方式而不是双检锁方式。
这种方式同样使用了classLoader机制来保证初始化instace时只有一个线程，它跟第三种方式不同的是：第3种方式只要Singleton类被装载了，那么instance就会被实例化，而这种方式是Singleton类被撞在了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有通过显式调用getInstance方法时，才会显式装载Singleton类，从而实例化instance。

public class Singleton {
	private static class SingletonHolder {
		private static finale Singleton INSTANCE = new Singleton(); 
	}

	private Singleton (){};
	public static final Singleton getInstance(){
		return SingletonHolder.INSTANCE;
	}
}

（6）枚举
这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，防止被多次实例化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

总结：一般情况下，不建议使用第一种和第二种懒汉方式，建议使用第三种饿汉方式，只有在明确要实现lazy loading 效果时，才会使用第五种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第六种枚举方式。

工厂模式

工厂模式（Factory Pattern）是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式。它提供了一种创建对象的最佳模式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且通过使用一个共同的接口来指向新创建的对象。

优点：
（1）一个调用者想创建一个对象，只要知道其名称就可以了。
（2）扩展性高，如果想要增加一个产品，只要扩展一个工厂类就可以了。
（3）屏蔽产品的具体实现，调用者只关心产品的接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。如果使用工程模式，就需要引入一个工厂类，会增加系统的复杂度。

使用场景：
（1）日志记录器：记录可以记录到本地磁盘、系统事件、远程服务器等，用户可以选择日志记录到什么地方。
（2）数据库访问，当用户不知道最后系统采用哪一类数据库时，以及数据库可能有变化时。
（3）设计一个连接服务器的框架，需要三个协议，“POP3”,“IMAP”,“HTTP”，可以把三个作为产品类，实现同一个接口。

Spring中使用工厂模式通过BeanFactory、ApplicationContext创建Bean对象。

实现方式：
我们创建一个Shape接口和实现Shape接口的实体类。下一步是定义工厂类ShapeFactory。
FactoryPatternDemo类使用ShapeFactory来获取Shape对象。它将向ShapeFactory传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

步骤一：创建一个接口

public insterface Shape{
	void draw();
}

步骤二：创建实现接口的实体类

public class Rectangle implements Shape{
	@Override
	public void draw() {
		System.out.println("Inside Rectangle::draw() method.");
	}
}

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤三：创建一个工厂，生成基于给定信息的实体类的对象

public class ShapeFactory{
	//使用getShape方法获取形状类型的对象
	public Shape getShape(String shapeType) {
		if (shapeType == null) {
			return null;
		}
 		if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
    	} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      	} else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      	}
      	return null;
	}
}

步骤四：使用该工厂，通过传递

public class FactoryPatternDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
 
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式地指定它们的类，每个生成的工厂都能按照工厂模式提供对象。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的Creator里加代码，又要在具体的里面加代码。

使用场景：
（1）QQ换皮肤，一整套一起换
（2）生成不同操作系统的程序

注意事项：
产品族难扩展， 产品等级易扩展

策略模式

在策略模式中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的context对象。策略对象改变context对象的执行算法。

意图：定义一系列的算法，把他们一个个封装起来，并且使他们可相互替换。
主要解决：在多种算法相似的情况下，使用if…else所带来的复杂和难以维护。
何时使用：一个系统有许多类，而区分它们的只是他们直接的行为。
如何解决：将这些算法封装成一个一个的类，任意的替换。

优点：
（1）算法可以自由切换。
（2）避免使用多重条件判断。
（3）扩展性良好。

缺点：
（1）策略类会增多。
（2）所有策略类都需要对外暴露。

Spring中资源访问接口Resource的设计是一种经典的策略模式。Resource接口是所有资源访问类所实现的接口，Resource接口就代表资源访问策略，但具体采用哪种策略实现，Resource接口并不理会。客户端程序只和Resource接口耦合，并不知道底层采用何种资源访问策略，这样客户端可以再不同的资源访问策略之间自由切换。

实现方法：
创建一个定义活动的Strategy接口和实现了Strategy

步骤一:

创建一个接口：

public interface Strategy {
   public int doOperation(int num1, int num2);
}

步骤二

创建接口的实现类

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubtract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

步骤三

创建Context类

public class Context {
   private Strategy strategy;
 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

步骤四

使用Context来 查看当它改变策略Strategy时的行为变化

public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

代理模式

在代理模式中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。