设计模式

星哥玩云

发布于 2022-09-14 20:39:46

3050

发布于 2022-09-14 20:39:46

文章被收录于专栏：开源部署开源部署

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);
	}
}

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法