设计模式-组团学

1、单例设计模式

单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。

单例设计模式八种方式

1) 饿汉式**(静态常量)**

2) 饿汉式（静态代码块）

3) 懒汉式(线程不安全)

4) 懒汉式(线程安全，同步方法)

5) 懒汉式(线程安全，同步代码块)

6) 双重检查

7) 静态内部类

8) 枚举

饿汉式（静态常量）

饿汉式（静态常量）应用实例步骤如下：

构造器私有化 (防止 new )
类的内部创建对象
向外暴露一个静态的公共方法。getInstance

代码实现

package com.atguigu.singleton.type1;

public class SingletonTest01 {

	public static void main(String[] args) {
		//测试
		Singleton instance = Singleton.getInstance(); 
        Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode()); 		System.out.println("instance2.hashCode=" + 													instance2.hashCode());
	}
}

//饿汉式(静态变量) 
class Singleton {
	//1. 构造器私有化,  外部不能  new 
    private Singleton() {}
	//2.本类内部创建对象实例
	private final static Singleton instance = new Singleton();
	//3. 提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance() { 
        return instance;
	}
}

优缺点说明

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果
结论：这种单例模式可用，可能造成内存浪费

饿汉式（静态代码块）

代码演示：

public class SingletonTest02 {
	public static void main(String[] args) {
	//测试
		Singleton instance = Singleton.getInstance(); 
        Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true
		System.out.println("instance.hashCode=" + instance.hashCode()); 		System.out.println("instance2.hashCode=" + 								instance2.hashCode());
	}
}

//饿汉式(静态变量) 
class Singleton {
//1.构造器私有化,  外部能 new 
    private Singleton() {
	}
//2.本类内部创建对象实例
	private	static Singleton instance;
	static { 
        // 在静态代码块中，创建单例对象
		instance = new Singleton();
	}
//3. 提供一个公有的静态方法，返回实例对象
	public static Singleton getInstance() { 
        return instance;
	}
}

优缺点说明

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
结论：这种单例模式可用，但是可能造成内存浪费

懒汉式(线程不安全)

代码演示：

public class SingletonTest03 {
 
    public static void main(String[] args) {
        System.out.println("懒汉式 1 ， 线程不安全~"); 
        Singleton instance = Singleton.getInstance(); 
        Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode()); 		System.out.println("instance2.hashCode=" + 											instance2.hashCode());
    }
}


class Singleton {
    private static Singleton instance;
    private Singleton() {}

    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton getInstance() { 
        if(instance == null) {
    		instance = new Singleton();
    	}
    	return instance;
    }
}

优缺点说明:

起到了 Lazy Loading 的效果，但是只能在单线程下使用。
如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
结论：在实际开发中，不要使用这种方式.

懒汉式(线程安全，同步方法)

代码演示：

public class SingletonTest04 {
    public static void main(String[] args) {
        System.out.println("懒汉式 2 ， 线程安全~"); 
        Singleton instance = Singleton.getInstance(); 
        Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode()); 		System.out.println("instance2.hashCode=" + 												instance2.hashCode());
    }
}
// 懒汉式(线程安全，同步方法) 
class Singleton {
		private static Singleton instance;
		private Singleton() {}

		//提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
		//即懒汉式
		public static synchronized Singleton getInstance() { 					if(instance == null) {
				instance = new Singleton();
			}
			return instance;
		}
}

优缺点说明:

解决了线程安全问题
效率太低了，每个线程在想获得类的实例时候，执行 getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。方法进行同步效率太低
结论：在实际开发中，不推荐使用这种方式

**懒汉式(**线程安全，同步代码块)

不推荐使用

双重检查

代码演示

public class SingletonTest06 {

    public static void main(String[] args) {
        System.out.println("双重检查");
        Singleton instance = Singleton.getInstance(); 
        Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + 												instance2.hashCode());
    }
}
// 懒汉式(线程安全，同步方法) 
class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static synchronized Singleton getInstance() { 
        if(instance == null) {
    		synchronized (Singleton.class) { 
                if(instance == null) {
    				instance = new Singleton();
    			}
    		}
    	}
    	return instance;
    }
}

优缺点说明

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步.
线程安全；延迟加载；效率较高
结论：在实际开发中，推荐使用这种单例设计模式

静态内部类

代码演示：

package com.atguigu.singleton.type7;


public class SingletonTest07 {

	public static void main(String[] args) {  
    	System.out.println("使用静态内部类完成单例模式"); 
        Singleton instance = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance(); 						System.out.println(instance == instance2); // true 
        System.out.println("instance.hashCode=" + instance.hashCode()); 		System.out.println("instance2.hashCode=" + 											instance2.hashCode());

	}
}

// 静态内部类完成， 推荐使用
class Singleton {
	private static volatile Singleton instance;
	//构造器私有化
    private Singleton() {}
	//写一个静态内部类,该类中有一个静态属性 
    Singleton private static class SingletonInstance {
		private static final Singleton INSTANCE = new Singleton();
	}

	//提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton 	getInstance() {
		return SingletonInstance.INSTANCE;
	}
}

优缺点说明：

这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
结论：推荐使用.

枚举

代码演示

public class SingletonTest08 {
	public static void main(String[] args) { 
        Singleton instance = Singleton.INSTANCE;
		Singleton instance2 = Singleton.INSTANCE; 							System.out.println(instance == instance2);
		System.out.println(instance.hashCode()); 							System.out.println(instance2.hashCode());
		instance.sayOK();
	}
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
	INSTANCE; //属性
	public void sayOK() { 
        System.out.println("ok~");
	}
}

优缺点说明：

这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式
结论：推荐使用

单例模式注意事项和细节说明

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new

单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

2、策略设计模式

基本介绍

策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以
互相替换，此模式让算法的变化独立于使用算法的客户
这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来；
第二、针对接口编程而不是具体类（定义了策略接口）；第三、多用组合/ 聚合，
少用继承（客户通过组合方式使用策略

策略模式的原理类图

说明：从上图可以看到，客户context 有成员变量strategy或者其他的策略接口
,至于需要使用到哪个策略，我们可以在构造器/set方法中指定.

编写鸭子项目，从代码中感受策略模式解决问题比传统继承方式解决问题的好处

传统方式解决鸭子问题分析和解决方案
传统的方式实现的问题分析和解决方案

其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的
上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改
动，会影响其他部分。会有溢出效应
为了改进1问题，我们可以通过覆盖fly 方法来解决 => 覆盖解决
问题又来了，如果我们有一个玩具鸭子ToyDuck, 这样就需要ToyDuck去覆盖Duck
的所有实现的方法 => 解决思路策略模式 (strategy pattern)

Duck.java

public abstract class Duck {

	public Duck() {
	
	}

	public abstract void display();//显示鸭子信息
	
	public void quack() {
		System.out.println("鸭子嘎嘎叫~~");
	}
	
	public void swim() {
		System.out.println("鸭子会游泳~~");
	}
	
	public void fly() {
		System.out.println("鸭子会飞翔~~~");
	}
	
}

PekingDuck.java

public class PekingDuck extends Duck {

	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println("~~北京鸭~~~");
	}
	
	//因为北京鸭不能飞翔，因此需要重写fly
	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("北京鸭不能飞翔");
	}

}

ToyDuck.java

public class ToyDuck extends Duck{

	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println("玩具鸭");
	}

	//需要重写父类的所有方法
	
	public void quack() {
		System.out.println("玩具鸭不能叫~~");
	}
	
	public void swim() {
		System.out.println("玩具鸭不会游泳~~");
	}
	
	public void fly() {
		System.out.println("玩具鸭不会飞翔~~~");
	}
}

WildDuck.java

public class WildDuck extends Duck {

	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println(" 这是野鸭 ");
	}

}

Client.java

public class Client {

	public static void main(String[] args) {
		
	}

}

策略模式解决鸭子问题

思路分析(类图)
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体
设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模
式让行为的变化独立于算法的使用者

FlyBehavior.java

public interface FlyBehavior {
	
	void fly(); // 子类具体实现
}

GoodFlyBehavior.java

public class GoodFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println(" 飞翔技术高超 ~~~");
	}

}

NoFlyBehavior.java

public class NoFlyBehavior implements FlyBehavior{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println(" 不会飞翔  ");
	}

}

BadFlyBehavior.java

public class BadFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println(" 飞翔技术一般 ");
	}
}

Duck.java

public abstract class Duck {

	//属性, 策略接口
	FlyBehavior flyBehavior;
	
	
	public Duck() {
	
	}

	public abstract void display();//显示鸭子信息
		
	public void fly() {
		//改进
		if(flyBehavior != null) {
			flyBehavior.fly();
		}
	}

	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}
}

PekingDuck.java

public class PekingDuck extends Duck {

	
	//假如北京鸭可以飞翔，但是飞翔技术一般
	public PekingDuck() {
		// TODO Auto-generated constructor stub
		flyBehavior = new BadFlyBehavior();
		
	}
	
	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println("~~北京鸭~~~");
	}
	
	

}

ToyDuck.java

public class ToyDuck extends Duck{

	
	public ToyDuck() {
		// TODO Auto-generated constructor stub
		flyBehavior = new NoFlyBehavior();
	}
	
	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println("玩具鸭");
	}

	
}

WildDuck.java

public class WildDuck extends Duck {

	
	//构造器，传入FlyBehavor 的对象
	public  WildDuck() {
		// TODO Auto-generated constructor stub
		flyBehavior = new GoodFlyBehavior();
	}
	
	
	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println(" 这是野鸭 ");
	}

}

Client.java

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WildDuck wildDuck = new WildDuck();
		wildDuck.fly();//
		
		ToyDuck toyDuck = new ToyDuck();
		toyDuck.fly();
		
		PekingDuck pekingDuck = new PekingDuck();
		pekingDuck.fly();
		
		//动态改变某个对象的行为, 北京鸭 不能飞
		pekingDuck.setFlyBehavior(new NoFlyBehavior());
		System.out.println("北京鸭的实际飞翔能力");
		pekingDuck.fly();
	}

}

策略模式的注意事项和细节

策略模式的关键是：分析项目中变化部分与不变部分
策略模式的核心思想是：多用组合/聚合少用继承；用行为类组合，而不是行为的继承。更有弹性
体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if…else if…else）
提供了可以替换继承关系的办法：策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展
需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞

3、观察者模式

观察者模式原理

观察者模式类似订牛奶业务
奶站/气象局：Subject
用户/第三方网站：Observer

Subject：登记注册、移除和通知

registerObserver 注册
removeObserver 移除
notifyObservers() 通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施推送，看具体需求定

Observer：接收输入

观察者模式：对象之间多对一依赖的一种设计方案，被依赖的对象为 Subject，依赖的对象为 Observer，Subject通知 Observer 变化,比如这里的奶站是 Subject，是 1 的一方。用户是Observer，是多的一方。

不用观察者解决天气预报问题、和用观察者解决天气预报问题的对比

(1)、不用观察者解决天气预报问题

传统的设计方案

代码实现

public class Client {
    public static void main(String[] args) {
        //创建接入方 currentConditions
        CurrentConditions currentConditions = new CurrentConditions();
        //创建WeatherData并将接入方currentConditions 传递到 WeatherData 中
        WeatherData weatherData = new WeatherData(currentConditions);
        //更新天气情况weatherData.setData(30, 150, 40);
        //天气情况变化
        System.out.println("============天气情况变化=============");
        weatherData.setData(40, 160, 20);
    }
}

/**
*	显示当前天气情况（可以理解成是气象站自己的网站）
*	@author Administrator
*
*/
public class CurrentConditions {
	// 温度，气压，湿度
    private float temperature; 
    private float pressure; 
    private float humidity;
	//更新 天气情况，是由 WeatherData 来调用，我使用推送模式
	public void update(float temperature, float pressure, float humidity) { 
        this.temperature = temperature;
		this.pressure = pressure; 
        this.humidity = humidity; display();
	}

	//显示
	public void display() {
		System.out.println("***Today mTemperature: " + temperature + "***"); 
        System.out.println("***Today mPressure: " + pressure + "***"); 			System.out.println("***Today mHumidity: " + humidity + "***");
	}
}

/**
*	类是核心
*	1. 包含最新的天气情况信息
*	2. 含有 CurrentConditions 对象
*	3.  当数据有更新时，就主动的调用	CurrentConditions 对象 update 方法(含 display),  这样他们（接入方）就看到最新的信息
*	@author Administrator
*
*/
public class WeatherData { 
    private float temperatrue; 
    private float pressure; 
    private float humidity;
	private CurrentConditions currentConditions;
	//加入新的第三方
	public WeatherData(CurrentConditions currentConditions) { 				this.currentConditions = currentConditions;
	}

	public float getTemperature() { 
        return temperatrue;
	}
 
	public float getPressure() { 
        return pressure;
	}


	public float getHumidity() { 
        return humidity;
	}

	public void dataChange() {
		//调用 接入方的 update
		currentConditions.update(getTemperature(), getPressure(), 				getHumidity());
	}

	//当数据有更新时，就调用 setData
	public void setData(float temperature, float pressure, float humidity) { 
        this.temperatrue = temperature;
		this.pressure = pressure; 
        this.humidity = humidity;
		//调用 dataChange， 将最新的信息 推送给 接入方 currentConditions
		dataChange();
	}
}

问题分析

其他第三方接入气象站获取数据的问题
无法在运行时动态的添加第三方 (新浪网站)
违反 ocp 原则=>观察者模式

//在 WeatherData 中，当增加一个第三方，都需要创建一个对应的第三方的公告板对象，并加入到 dataChange, 不利于维护，也不是动态加入

public void dataChange() {
	currentConditions.update(getTemperature(), getPressure(), 				getHumidity());
}

(2)用观察者解决天气预报的问题

类图说明

代码实现

public class BaiduSite implements Observer {
	// 温度，气压，湿度
	private float temperature; 
	private float pressure; 
	private float humidity;

	//  更新  天气情况，是由  WeatherData  来调用，我使用推送模式
	public void update(float temperature, float pressure, float humidity) {
		this.temperature = temperature;
		this.pressure = pressure; 
		this.humidity = humidity; display();
	}

	// 显 示
	public void display() {
		System.out.println("===百度网站====");
		System.out.println("***百度网站 气温 : " + temperature + "***");
		System.out.println("***百度网站 气压: " + pressure + "***");
		System.out.println("***百度网站 湿度: " + humidity + "***");
	}
}

public class Client {
	public static void main(String[] args) {
		//创建一个 WeatherData
		WeatherData weatherData = new WeatherData();
		//创建观察者
		CurrentConditions currentConditions = new CurrentConditions();
		BaiduSite baiduSite = new BaiduSite();

		// 注 册 到 weatherData
        weatherData.registerObserver(currentConditions); 					weatherData.registerObserver(baiduSite);

		// 测 试  
        System.out.println("通知各个注册的观察者, 看看信息"); 					weatherData.setData(10f, 100f, 30.3f);

		weatherData.removeObserver(currentConditions);
		//测试System.out.println();
		System.out.println("通知各个注册的观察者, 看看信息"); 					weatherData.setData(10f, 100f, 30.3f);
	}
}

public class CurrentConditions implements Observer {

	// 温度，气压，湿度
	private float temperature;
	private float pressure; 
    private float humidity;

	// 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
	public void update(float temperature, float pressure, float humidity) { 
        this.temperature = temperature;
		this.pressure = pressure; 
        this.humidity = humidity; display();
	}

	// 显 示
	public void display() {
		System.out.println("***Today mTemperature: " + temperature + "***"); 
        System.out.println("***Today mPressure: " + pressure + "***"); 		   System.out.println("***Today mHumidity: " + humidity + "***");
	}
}

	//观察者接口，有观察者来实现 
	public interface Observer {
		public void update(float temperature, float pressure, float 			humidity);
	}
 

//接口, 让 WeatherData 来实现
public interface Subject {
	public void registerObserver(Observer o); 
    public void removeObserver(Observer o); 
    public void notifyObservers();
}

/**
*	类是核心
*	1. 包含最新的天气情况信息
*	2. 含有观察者集合，使用 ArrayList 管理
*	3. 当数据有更新时，就主动的调用ArrayList, 通知所有的（接入方）就看到最新的信息
*	@author Administrator
*/
public class WeatherData implements Subject { 
    private float temperatrue;
	private float pressure;
	private float humidity;
	//观察者集合
	private ArrayList<Observer> observers;
	//加入新的第三方
    public WeatherData() {
		observers = new ArrayList<Observer>();
	}

	public float getTemperature() { 
   		return temperatrue;
	}

	public float getPressure() { 
    	return pressure;
	}

	public float getHumidity() { 
    	return humidity;
	}

	public void dataChange() {
		//调用 接入方的 update
		notifyObservers();
	}

	//当数据有更新时，就调用 setData
	public void setData(float temperature, float pressure, float humidity) { 
        this.temperatrue = temperature;
		this.pressure = pressure; 
        this.humidity = humidity;
		//调用 dataChange， 将最新的信息 推送给 接入方 currentConditions
		dataChange();
	}

	//注册一个观察者 @Override
	public void registerObserver(Observer o) {
		// TODO Auto-generated method stub 
        observers.add(o);
	}

	//移除一个观察者 
    @Override
	public void removeObserver(Observer o) {
		// TODO Auto-generated method stub 
        if(observers.contains(o)) {
			observers.remove(o);
		}
	}
	//遍历所有的观察者，并通知 
    @Override
	public void notifyObservers() {
		// TODO Auto-generated method stub 
        for(int i = 0; i < observers.size(); i++) {
			observers.get(i).update(this.temperatrue, this.pressure, 			this.humidity);
		}
	}
}

观察者模式的好处

观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。
这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类 WeatherData 不会修改代码，遵守了 ocp 原则。

4、代理设计模式

代理模式(Proxy)的基本介绍

代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。

2)被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象

代理模式有不同的形式, 主要有三种静态代理、**动态代理 (JDK 代理、接口代理)**和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴) 。
代理模式示意图

静态代理

静态代理模式的基本介绍

静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类

应用实例

具体要求

定义一个接口:ITeacherDao
目标对象 TeacherDAO 实现接口 ITeacherDAO
使用静态代理方式,就需要在代理对象 TeacherDAOProxy 中也实现 ITeacherDAO
调用的时候通过调用代理对象的方法来调用目标对象.
特别提醒：代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法

思路分析图解(类图)

代码实现

public class Client {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建目标对象(被代理对象)
        TeacherDao teacherDao = new TeacherDao();
        //创建代理对象, 同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new 																TeacherDaoProxy(teacherDao);
        //通过代理对象，调用到被代理对象的方法
        //即：执行的是代理对象的方法，代理对象再去调用目标对象的方法
        teacherDaoProxy.teach();
    }
}

//接口
public interface ITeacherDao {
	void teach(); // 授课的方法
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        // TODO Auto-generated method stub 
        System.out.println(" 老师授课中	。。。。。");
    }
}

//代理对象,静态代理
public class TeacherDaoProxy implements ITeacherDao{
    private ITeacherDao target; // 目标对象，通过接口来聚合

    //构造器
    public TeacherDaoProxy(ITeacherDao target) { 
        this.target = target;
    }


    @Override
    public void teach() {
    	// TODO Auto-generated method stub
    	System.out.println("开始代理	完成某些操作。。。。。 ");//方法
        target.teach();
    	System.out.println("提交。。。。。");//方法
    }
}

静态代理优缺点

优点：在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
一旦接口增加方法,目标对象与代理对象都要维护

动态代理

动态代理模式的基本介绍

代理对象,不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
代理对象的生成，是利用 JDK 的 API，动态的在内存中构建代理对象
动态代理也叫做：JDK 代理、接口代理

JDK 中生成代理对象的 API

代理类所在包:java.lang.reflect.Proxy
JDK 实现代理只需要使用 newProxyInstance 方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

动态代理应用实例

应用实例要求

将前面的静态代理改进成动态代理模式(即：JDK 代理模式)

思路图解(类图)

代码实现

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        ITeacherDao target = new TeacherDao();
        //给目标对象，创建代理对象, 可以转成 ITeacherDao
        ITeacherDao proxyInstance = (ITeacherDao)new 								ProxyFactory(target).getProxyInstance();
        // proxyInstance=class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
        System.out.println("proxyInstance=" + 												proxyInstance.getClass());
        //通过代理对象，调用目标对象的方法
        //proxyInstance.teach();
        proxyInstance.sayHello(" tom ");
    }
}

//接口
public interface ITeacherDao {
    void teach(); // 授课方法
    void sayHello(String name);
}

package com.atguigu.proxy.dynamic;

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method;
 

import java.lang.reflect.Proxy;


public class ProxyFactory {

	//维护一个目标对象 , Object 
    private Object target;
	//构造器 ， 对 target  进行初始化
	public ProxyFactory(Object target) {
		this.target = target;
	}
	//给目标对象生成一个代理对象
	public Object getProxyInstance() {

//说明
/*
*	public static Object newProxyInstance(ClassLoader loader,
							Class<?>[] interfaces, 
							InvocationHandler h)

//1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
//2. Class<?>[] interfaces:  目标对象实现的接口类型，使用泛型方法确认类型
//3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行
的目标对象方法作为参数传入
*/
		return 																	Proxy.newProxyInstance(target.getClass().getClassLoader(), 								target.getClass().getInterfaces(),
			new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method, 					Object[] args) throws Throwable {
					// TODO Auto-generated method stub
					System.out.println("JDK 代理开始~~");
					//反射机制调用目标对象的方法
					Object returnVal = method.invoke(target, args);
					System.out.println("JDK 代理提交"); return returnVal;
				}
			});
	}
}

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println(" 老师授课中.... ");
    }
    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

Cglib 代理

Cglib 代理模式的基本介绍

静态代理和 JDK 代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是 Cglib 代理
Cglib 代理也叫作子类代理**,**它是在内存中构建一个子类对象从而实现对目标对象功能扩展, 有些书也将Cglib 代理归属到动态代理。
Cglib 是一个强大的高性能的代码生成包,它可以在运行期扩展 java 类与实现 java 接口.它广泛的被许多 AOP 的框架使用,例如 Spring AOP，实现方法拦截
在 AOP 编程中如何选择代理模式：

1.目标对象需要实现接口，用 JDK 代理

2.目标对象不需要实现接口，用 Cglib 代理

Cglib 包的底层是通过使用字节码处理框架 ASM 来转换字节码并生成新的类

Cglib 代理模式实现步骤

(1)需要引入 cglib 的 jar 文件

(2)在内存中动态构建子类，注意代理的类不能为 final，否则报错 java.lang.IllegalArgumentException:

(3)目标对象的方法如果为 final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法

Cglib 代理模式应用实例

应用实例要求

将前面的案例用 Cglib 代理模式实现

思路图解(类图)

代码实现

public class Client {
	public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建目标对象
        TeacherDao target = new TeacherDao();
        //获取到代理对象，并且将目标对象传递给代理对象
        TeacherDao proxyInstance = (TeacherDao)new 									ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法，触发 intecept  方法，从而实现 对目标对象的调用
        String res = proxyInstance.teach(); 
        System.out.println("res=" +res);
    }
}

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor; 
import net.sf.cglib.proxy.MethodProxy;
public class ProxyFactory implements MethodInterceptor {
	//维护一个目标对象 
    private Object target;
	//构造器，传入一个被代理的对象
    public ProxyFactory(Object target) {
		this.target = target;
	}
	//返回一个代理对象:	是 target  对象的代理对象
	public Object getProxyInstance() {
		//1. 创建一个工具类
		Enhancer enhancer = new Enhancer();
		//2. 设置父类
		enhancer.setSuperclass(target.getClass());
		//3. 设置回调函数
		enhancer.setCallback(this);
		//4. 创建子类对象，即代理对象
		return enhancer.create();
	}
	//重写	intercept 方法，会调用目标对象的方法
	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("Cglib 代理模式 ~~ 开始"); 
        Object returnVal = method.invoke(target, args); 					System.out.println("Cglib 代理模式 ~~ 提交"); 
        return returnVal;
	}
}

public class TeacherDao {
	public String teach() {
		System.out.println(" 老师授课中,我是 cglib 代理，不需要实现接口 "); 
        return "hello";
	}
}

几种常见的代理模式介绍— 几种变体

防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

缓存代理

比如：当请求图片文件等资源时，先到缓存代理取，如果取到资源则 ok,如果取不到资源，再到公网或者数据库取，然后缓存。

远程代理

远程对象的本地代表，通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息。

同步代理：主要使用在多线程编程中，完成多线程间同步工作同步代理：主要使用在多线程编程中，完成多线程间同步工作。

5、工厂设计模式

看一个具体的需求

一个披萨的项目：要便于披萨种类的扩展，要便于维护

披萨的种类很多(比如 GreekPizz、CheesePizz 等)
披萨的制作有 prepare，bake, cut, box
完成披萨店订购功能。

使用传统的方式来完成

思路分析(类图)

编写 OrderPizza.java 去订购需要的各种 Pizza

public class OrderPizza {
 	//构造器
	public OrderPizza() {
	Pizza pizza = null;
	String orderType; //订购披萨的类型
	do {
        orderType = getType();
        if (orderType.equals("greek")) {
        	pizza = new GreekPizza();
        	pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) {
        	pizza = new CheesePizza();
        	pizza.setName(" 奶酪披萨 ");
        } else if (orderType.equals("pepper")) {
        	pizza = new PepperPizza();
        	pizza.setName("胡椒披萨");
        } else {
        	break;
        }
        //输出 pizza 制作过程
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
	} while (true);
}

传统的方式的优缺点

优点是比较好理解，简单易操作。

2)缺点是违反了设计模式的 ocp 原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码

3)比如我们这时要新增加一个 Pizza 的种类**(Pepper** 披萨**)**，我们需要做如下修改. 如果我们增加一个 Pizza 类，只要是订购 Pizza 的代码都需要修改

改进的思路分析

分析：修改代码可以接受，但是如果我们在其它的地方也有创建 Pizza 的代码，就意味着，也需要修改，而创建 Pizza

的代码，往往有多处。

思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类就可，其它有创建到 Pizza

对象的代码就不需要修改了.-> 简单工厂模式

基本介绍

1)简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式

2)简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

3)在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

使用简单工厂模式

简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类，封装创建对象的代码。

2)看代码演示

//简单工厂类
public class SimpleFactory {
    //更加 orderType 返回对应的 Pizza 对象
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式"); 
        if (orderType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName(" 希腊披萨 ");
        } else if (orderType.equals("cheese")) { 
            pizza = new CheesePizza();
            pizza.setName(" 奶酪披萨 ");
        } else if (orderType.equals("pepper")) { 
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
	}

	//简单工厂模式 也叫 静态工厂模式
	public static Pizza createPizza2(String orderType) {
		Pizza pizza = null;
		System.out.println("使用简单工厂模式 2"); 
        if (orderType.equals("greek")) {
			pizza = new GreekPizza();
			pizza.setName(" 希腊披萨 ");
		} else if (orderType.equals("cheese")) { 
            pizza = new CheesePizza();
			pizza.setName(" 奶酪披萨 ");
		} else if (orderType.equals("pepper")) { 
            pizza = new PepperPizza();
			pizza.setName("胡椒披萨");
		}
		return pizza;
	}
}

//OrderPizza.java
import java.io.BufferedReader;
import java.io.IOException; 
import java.io.InputStreamReader;
public class OrderPizza {
    // 构造器
    //	public OrderPizza() {
    //	Pizza pizza = null;
    //	String orderType; //  订购披萨的类型
    //	do {
    //	orderType = getType();
    //	if (orderType.equals("greek")) {
    //	pizza = new GreekPizza();
    //	pizza.setName(" 希腊披萨 ");
    //	} else if (orderType.equals("cheese")) {
    //	pizza = new CheesePizza();
    //	pizza.setName(" 奶酪披萨 ");
    //	} else if (orderType.equals("pepper")) {
    //	pizza = new PepperPizza();
    //	pizza.setName("胡椒披萨");
    //	} else {
    //	break;
    //	}


    //	//输出 pizza 制作过程
    //	pizza.prepare();
    //	pizza.bake();
    //	pizza.cut();
    //	pizza.box();
    //
    //	} while (true);
    //	}

	//定义一个简单工厂对象
    SimpleFactory simpleFactory; 
    Pizza pizza = null;

	//构造器
	public OrderPizza(SimpleFactory simpleFactory) { 						setFactory(simpleFactory);
	}

	public void setFactory(SimpleFactory simpleFactory) {
		String orderType = ""; //用户输入的
		this.simpleFactory = simpleFactory; //设置简单工厂对象do {
		orderType = getType();
		pizza = this.simpleFactory.createPizza(orderType);
 
		//输出 pizza
		if(pizza != null) { //订购成功
			pizza.prepare(); pizza.bake();
			pizza.cut();
			pizza.box();
		} else {
			System.out.println(" 订购披萨失败 "); 
            break;
		}
		}while(true);
	}

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() { 
        try {
			BufferedReader strin = new BufferedReader(new 							InputStreamReader(System.in)); 
            System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) { 
            e.printStackTrace(); 
            return "";
		}
	}
}

工厂方法模式

看一个新的需求

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

思路 1

使用简单工厂模式，创建不同的简单工厂类，比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等.从当前这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别好

思路 2

使用工厂方法模式

工厂方法模式介绍

工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

工厂方法模式应用案例

披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza

2)思路分析图解

看老师代码实现

//OrderPizza.java 类
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader;
public abstract class OrderPizza {
    //定义一个抽象方法，createPizza ,  让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    // 构造器
    public OrderPizza() { 
        Pizza pizza = null;
        String orderType; //  订购披萨的类型
        do {
            orderType = getType();
            pizza = createPizza(orderType); //抽象方法，由工厂子类完成
            //输出 pizza 制作过程
            pizza.prepare(); 
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() { 
        try {
			BufferedReader strin = new BufferedReader(new 							InputStreamReader(System.in)); 									System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) { 
            e.printStackTrace(); return "";
		}
	}
}

public class BJOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null; 
        if(orderType.equals("cheese")) {
        	pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")) { 
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

public class LDOrderPizza extends OrderPizza {
	@Override
	Pizza createPizza(String orderType) {
        Pizza pizza = null; 
        if(orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) { 
            pizza = new LDPepperPizza();
        }
        return pizza;
	}
}

抽象工厂模式

基本介绍

抽象工厂模式：定义了一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
将工厂抽象成两层，AbsFactory(抽象工厂) 和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
类图

抽象工厂模式应用实例

使用抽象工厂模式来完成披萨项目.

//一个抽象工厂模式的抽象层(接口) 
public interface AbsFactory {
	//让下面的工厂子类来 具体实现
	public Pizza createPizza(String orderType);
}
//这是工厂子类
public class BJFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        // TODO Auto-generated method stub 
        Pizza pizza = null; 
        if(orderType.equals("cheese")) {
        	pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")){ 
            pizza = new BJPepperPizza();
        }
        return pizza;
	}
}
public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
    	System.out.println("~使用的是抽象工厂模式~"); 
        Pizza pizza = null;
    	if (orderType.equals("cheese")) { 
            pizza = new LDCheesePizza();
    	} else if (orderType.equals("pepper")) { 
            pizza = new LDPepperPizza();
    	}
    	return pizza;
	}
}

//OrderPizza.java
import java.io.BufferedReader;
import java.io.IOException; 
import java.io.InputStreamReader;
public class OrderPizza {
	AbsFactory factory;

	// 构造器
	public OrderPizza(AbsFactory factory) { 
        setFactory(factory);
	}

	private void setFactory(AbsFactory factory) { 
        Pizza pizza = null;
		String orderType = ""; //  用户输入
		this.factory = factory; 
        do {
			orderType = getType();
			// factory  可能是北京的工厂子类，也可能是伦敦的工厂子类
			pizza = factory.createPizza(orderType); 
            if (pizza != null) { // 订 购 ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
			} else {
				System.out.println("订购失败"); 
                break;
			}
		} while (true);
	}

	// 写一个方法，可以获取客户希望订购的披萨种类
	private String getType() { 
        try {
			BufferedReader strin = new BufferedReader(new 							InputStreamReader(System.in)); 									System.out.println("input pizza 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) { 
            e.printStackTrace(); 
            return "";
		}
	}
}

工厂模式小结

工厂模式的意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。

三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)
设计模式的依赖抽象原则

4)创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。

5)不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)

6)不要覆盖基类中已经实现的方法。

6、装饰者模式

装饰设计模式概述
装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案
优点
使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能
缺点
正因为可以随意组合，所以就可能出现一些不合理的逻辑

装饰者模式图解

interface Phone {
	public abstract void call();
}

class IPhone implements Phone {
	@Override
	public void call() {
		System.out.println("手机可以打电话了");
	}
}

public abstract class PhoneDecorate implements Phone {

	private Phone p;

	public PhoneDecorate(Phone p) {
		this.p = p;
	}

	@Override
	public void call() {
		this.p.call();
	}
}

public class MusicPhoneDecorate extends PhoneDecorate {

	public MusicPhoneDecorate(Phone p) {
		super(p);
	}

	@Override
	public void call() {
		super.call();
		System.out.println("手机可以听音乐");
	}
}

public class RingPhoneDecorate extends PhoneDecorate {

	public RingPhoneDecorate(Phone p) {
		super(p);
	}

	@Override
	public void call() {
		System.out.println("手机可以听彩铃");
		super.call();
	}
}

class PhoneDemo {
	public static void main(String[] args) {
		Phone p = new IPhone();
		p.call();
		System.out.println("------------");

		// 需求：我想在接电话前，听彩铃
		PhoneDecorate pd = new RingPhoneDecorate(p);
		pd.call();
		System.out.println("------------");

		// 需求：我想在接电话后，听音乐
		pd = new MusicPhoneDecorate(p);
		pd.call();
		System.out.println("------------");

		// 需求：我要想手机在接前听彩铃，接后听音乐
		// 自己提供装饰类，在打电话前听彩铃，打电话后听音乐
		pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
		pd.call();
		System.out.println("----------");
		// 想想我们在IO流中的使用
		// InputStream is = System.in;
		// InputStreamReader isr = new InputStreamReader(is);
		// BufferedReader br = new BufferedReader(isr);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(
				System.out)));

		Scanner sc = new Scanner(System.in);
	}
}