Java设计模式

Java设计模式

设计原则：

1. 开闭原则：对扩展开放，对修改关闭，就是在程序进行扩展的时候，不能去修改原有的代码

2. 里氏代换原则：任何基类可以出现的地方，子类一定可以出现

3. 依赖倒转原则：针对接口编程，依赖于抽象而不依赖于具体

4. 迪米特法则：一个实体应尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立

5. 接口隔离原则：使用多个隔离的接口，比使用单个的接口好，还有降低类之间的耦合度的意思：降低依赖，降低耦合。

6. 单一原则：每个类只负责单一的功能，该类尽量将一个功能做到极致。

设计模式

为什么使用设计模式？

设计模式可以改善系统的设计，增强系统的健壮性、可扩展性，方便之后的开发。

1. 工厂模式

简单工厂模式：将创建对象的逻辑判断放在了工厂类中(第三方类)，客户并不知道具体有哪些类，客户端需要什么商品只需要修改工厂类的调用而不需要修改客户端，降低了客户端与具体商品的依赖，但违背了开闭原则（在新增具体类的时候，必须修改工厂类）
  工厂方法模式：设置工厂接口，将实例化产品的操作延迟到工厂接口的子类中实行，符合开闭原则，但在客户端中必须创建对应的工厂接口的子类实例。横向扩展很方便，若有新的产品要生产，只需要创建对应的产品类与工厂类即可，不需要修改原有的代码。
  抽象工厂模式：进一步的扩展了工厂方法模式，使得一个工厂对应多个产品(一个产品组，相互之间存在依赖关系的产品的集合)，扩展比较灵活。

• 简单工厂模式
• • 根据参数的不同返回不同的实例
• • 优点：调用者想创建一个对象，直接向工厂请求即可，不需要知道具体的实现，以提高系统的可维护性，可扩展性。
• • 缺点：不够灵活，产品修改时，工厂也要修改，不符合开闭原则。

//
public class SingleFactory{
	public static Product creatProduct(String s){
		if(s.equals("A“))
			return new ProductA;
		else
			return new ProductB;
	}
}
abstract class Product{
}
class ProductA extends Product{
}
class ProductB extends Product{
}

• 工厂模式
• • 定义： 可以创建一个大类的对象，定义一个用于创建对象的接口，让其子类决定下实例化哪个类，工厂方法是一个类的实例化延迟到其子类
    

interface Collection{
}
class ArrayList implements Collection{
}
class LinkedList implements Collection{
}
interface Iterator{
	//创建List的抽象方法
}
class ListItr implements Iterator{
	//重写创建List的抽象方法
}
class Itr implements Iterator{
	//重写创建List的抽象方法
}

• 抽象工厂模式
• • 可以创建不同大类的对象，扩展比较灵活。

3. 单例模式

作用：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。

主要操作：
   ①构造方法私有化
   ②单例类提供一个静态对象
   ③单例类提供一个静态方法返回该唯一的静态对象
  分类：
   饿汉式：静态对象定义时完成实例化，写法简单，线程安全，没有达到Lazy Loading的效果，如果始终未使用该实例，则会造成内存浪费；
   懒汉式：第一次使用时才实例化，延迟加载，效率更高，存在线程安全问题，需要使用双重检验锁模式(两个if一个sync)+volatile禁止指令重排机制

• 保证一个类仅有一个实例，并提供该实例的全局访问函数。
• 特点：
• • 单例类只能有一个实例。
• • 单例类必须自己创建自己的唯一一个实例。
• • 单例类必须给所有的其他对象提供这个实例
• 分类：饿汉式和懒汉式

public class SingletonPattern{
	public static void main(String[] args){
	}
}
//懒汉模式
class Singleton{
//用volatile关键字修饰很有必要，因为singleton = new Singleton()会经过三步，并且会代码重排序，如不进行volatile修饰，在多线程环境可能导致获得还没初始化的线程。volatile可以禁止代码重排序。
	private vilatile static Singleton singleton;
	private Singleton(){
	}
	public static Singleton getInstance(){
		//双重检查锁
		if(singleton == null){
			synchronized(singleton.class){
				if(singleton == null)
					singleton = new Singleton();
			}
		}
		return singleton;
	}
}
//饿汉模式
class Singleton{
	private static Singleton singleton = new Singleton();;
	private Singleton(){
	}
	public static Singleton getInstance(){
		return singleton;
	}
}

3.代理模式

静态代理：通过代理实现被代理类相关功能的增强，代理类引用被代理类的对象（可通过构造方法），代理类与被代理类实现同一个接口，在代理类实现接口的方法中，调用被代理类实现接口的方法（真实业务）+在代理类中定义的其他用于辅助真实业务操作的方法（辅助方法）。eg：真实业务类（买房子的人），代理类（中介），中介与购房者都实现了买房的接口，中介为购房者提供购房前后的相关服务，增强了购房者买房子的功能。
  动态代理：动态代理本质和静态代理是一样的，都是在代理类中对实际业务类进行了功能上的拓展，只不过，动态代理的代理类是在运行时由系统产生，代替了静态代理一个一个创建代理类的方法。（invoke()->通过反射Method.invoke()调用被代理类的真实业务方法）
   动态代理流程：使用动态代理工厂生成动态代理类实例proxy->调用proxy中的方法->调用newProxyInstance的参数h的invoke()方法->根据invoke()方法中的逻辑调用其他方法->完成动态代理
   JDK动态代理：主要代理实现了接口的类，使用接口来定义好操作的规范，然后通过Proxy类产生的代理对象调用被代理对象的操作，这个操作被分发给InvocationHandler接口的invoke()方法具体执行。
   cgLib动态代理：Spring AOP的底层实现，可以代理没有实现接口的类，代理类通过实现MethodInterceptor接口中的intercept()方法，并在代理工厂类中通过Enhancer对象进行相关操作。

• 定义：代理模式为另一个对象提供一个替身或一个占位符，以控制对这个对象的访问
  静态代理：
• 动态代理流程：使用动态代理工厂生成动态代理类实例proxy->调用proxy中的方法->调用newProxyInstance的参数h的invoke()方法->根据invoke()方法中的逻辑调用其他方法->完成动态代理

public class StaticProxy{
	public static void main(String[] args){
		new Zhongjie(new You()).buy();
		//new Thread(线程对象).start();
	}
}
interface buyHouse{
	public void buy();
}
class You implements buyHouse{
	@Override
	public void buy(){
	}
}
class Zhongjie implements buyHouse{
	private buyHouse house;
	public Zhongjie(buyHouse house){
		this.house = house;
	}
	@Override
	public void buy(){
		ready();
		this.house.buy();
		after();
	}
}

生产者消费者模型

• 原理：生产消费者模式主要是将生产者与消费者解耦，通过一个容器来解决生产者和消费者的强耦合问题，生产者消费者彼此之间不直接通讯，而是通过阻塞队列来进行通讯。
• 流程：生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者也不找生产者要数据，而是直接从阻塞队列中取得，阻塞队列相当于一个缓冲区，平衡了生产者与消费者的处理能力，使得生产者与消费者是两个完全独立的并发主体。