精简：设计模式
Posted 雙馬程序猿
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了精简：设计模式相关的知识，希望对你有一定的参考价值。
1.设计模式概述
1.什么是设计模式
设计模式(Design Pattern)是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。
它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。
1995年，GoF (Gang of Four,四人组/四人帮)合作出版了《设计模式:可复用面向对象软件的基础》一书,共收录了23种设计模式,从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」
2.学习设计模式的意义
设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。
- 正确使用设计模式具有以下优点:
- 可以提高程序员的思维能力、编程能力和设计能力。
- 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
- 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。
3.23种设计模式
按照设计模式的作用可分为三种模式，创建型模式、结构型模式、行为型模式
| 设计模式类型 | 设计模式 |
|---|---|
| 创建型模式 | 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 |
| 结构型模式 | 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式 |
| 行为型模式 | 模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式 |
4.七大设计原则
| 七大原则 | 解释 |
|---|---|
| 开闭原则 | 对扩展开放，对修改关闭 |
| 里氏替换原则 | 在继承关系中子类可以拓展方法，不能修改父类原有方法的功能，降低需求变更带来的风险 |
| 依赖倒置原则 | 要面向接口编程,不要面向实现编程。高层模块不直接依赖低层模块，二者依赖其抽象 |
| 单一职责原则 | 控制类的粒度大小、将对象解耦、提高其内聚性。对于类/接口/方法，负责的功能单一 |
| 接口隔离原则 | 不使用单一的总接口 使用多个专门职责的接口，接口间产生隔离 |
| 迪米特法则 | 只与你的直接朋友交谈,不跟"陌生人”说话。其中一个类需要调用另一类的某一个方法的话，可以通过第三者转发这个调用。降低类与类之间的耦合 |
| 合成复用原则 | 尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。 |
2.创建者模式
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。
1.单例模式
保证一个类仅有一个实例，并提供一个访问它的全局访问点
主要解决：一个全局使用的类频繁地创建与销毁。
关键代码：构造函数是私有的，自己创建自己的唯一实例，公有的静态的方法
优点：
- 1.在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
- 2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
应用场景：WEB 中的计数器
饿汉式
一上来就把所有的东西加载进来，非常浪费空间
类加载时创建（不管使不使用都创建），天生线程安全
生命周期长
/**
* 饿汉式单例
*/
public class Hungry
/**
* 可能会浪费空间
*/
private byte[] data1=new byte[1024*1024];
private byte[] data2=new byte[1024*1024];
private byte[] data3=new byte[1024*1024];
private byte[] data4=new byte[1024*1024];
private Hungry()
private final static Hungry hungry = new Hungry();
public static Hungry getInstance()
return hungry;
懒汉式
第一次调用才初始化，避免内存浪费。
单线程安全，多线程不安全
生命周期短
public class Singleton
private static Singleton instance;
private Singleton ()
public static Singleton getInstance()
if (instance == null)
instance = new Singleton();
return instance;
这里可以给他加锁完成线程安全，但是就降低了效率
public class Singleton
private static Singleton instance;
private Singleton ()
public static synchronized Singleton getInstance()
if (instance == null)
instance = new Singleton();
return instance;
DCL懒汉式（双重校验（判定）锁）
这里new对象的时候会有原子性不一致的问题，就导致可能出现指令重排的问题，给LazyMan2的类对象加一个volatile保证指令重排的问题
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;
静态内部类
线程安全，功能和双重校验锁一样
public class Singleton
private static class SingletonHolder
private static final Singleton INSTANCE = new Singleton();
private Singleton ()
public static final Singleton getInstance()
return SingletonHolder.INSTANCE;
但是这时候出现了问题，反射可以破坏单例模式
枚举
它更简洁，自动支持序列化机制，绝对防止多次实例化。可以防止反射来破坏单例模式，因为反射破坏不了枚举类
public enum Singleton
INSTANCE;
public void whateverMethod()
2.工厂模式
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
- 三种模式：
- 简单工厂模式
- 用来生产同一等级结构中的任意产品(对于增加新的产品，需要扩展已有代码)
- 工厂方法模式
- 用来生产同一等级结构中的固定产品(支持增加任意产品)
- 抽象工厂模式
- 围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
- 简单工厂模式
- 小结：
- 简单工厂模式(静态工厂模式)
- 虽然某种程度上不符合设计原则，但实际使用最多!
- 工厂方法模式
- 不修改已有类的前提下，通过增加新的工厂类实现扩展。
- 抽象工厂模式
- 不可以增加产品，可以增加产品族!
- 简单工厂模式(静态工厂模式)
应用场景：JDBC中的Connection对象的获取、Spring中IOC容器创建管理bean对象、反射中Class对象的newInstance方法
简单工厂模式（静态工厂模式）
public interface Car
void name();
class Wuling implements Car
@Override
public void name()
System.out.println("五菱");
class Tesla implements Car
@Override
public void name()
System.out.println("特斯拉");
class CarFactory
public static Car getCar(String car)
if ("五菱".equals(car))
return new Wuling();
else if ("特斯拉".equals(car))
return new Tesla();
else
return null;
class Consumer
public static void main(String[] args)
//传统方式
//Car wuling = new Wuling();
//Car tesla = new Tesla();
//工厂模式
Car car = CarFactory.getCar("五菱");
Car car1 = CarFactory.getCar("特斯拉");
car.name();
car1.name();
这时我想要在加一辆车，那么车工厂就要增加一个大众类型的车，按照类型去寻找车
工厂方法
工厂方法，增加一层工厂的约束，对工厂去管理，要什么车就去什么工厂，然后工厂帮你找到车
public interface Car
void name();
class Wuling implements Car
@Override
public void name()
System.out.println("五菱");
class Tesla implements Car
@Override
public void name()
System.out.println("特斯拉");
interface CarFactory
Car getCar();
class TeslaFactory implements CarFactory
@Override
public Car getCar()
return new Tesla();
class WulingFactory implements CarFactory
@Override
public Car getCar()
return new Wuling();
class Consumer
public static void main(String[] args)
//传统方式
//Car wuling = new Wuling();
//Car tesla = new Tesla();
//工厂模式
//Car car = CarFactory.getCar("五菱");
//Car car1 = CarFactory.getCar("特斯拉");
//car.name();
//car1.name();
Car car = new WulingFactory().getCar();
Car car1 = new TeslaFactory().getCar();
car1.name();
car.name();
3.抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
注意事项：产品族难扩展，产品等级易扩展。
//手机接口
public interface IphoneProduct
void start();
void shutdown();
void callup();
void sendSMS();
//路由器接口
public interface IRouterProduct
void start();
void shutdown();
void openwife();
void setting();
//华为手机
public class HuaweiPhone implements IphoneProduct
@Override
public void start()
System.out.println("华为手机开机");
@Override
public void shutdown()
System.out.println("华为手机关机");
@Override
public void callup()
System.out.println("华为手机打电话");
@Override
public void sendSMS()
System.out.println("华为手机发短信");
//华为路由器
public class HuaweiRouter implements IRouterProduct
@Override
public void start()
System.out.println("开启华为路由器");
@Override
public void shutdown()
System.out.println("关闭华为路由器");
@Override
public void openwife()
System.out.println("开启华为wifi");
@Override
public void setting()
System.out.println("打开华为设置");
//小米手机
public class XiaomiPhone implements IphoneProduct
@Override
public void shutdown()
System.out.println("关闭小米手机");
@Override
public void callup()
System.out.println("小米手机打电话");
@Override
public void sendSMS()
System.out.println("小米手机发短信");
@Override
public void start()
System.out.println("开启小米手机");
//小米路由器
public class XiaomiRouter implements IRouterProduct
@Override
public void start()
System.out.println("开启小米路由器");
@Override
public void shutdown()
System.out.println("关闭小米路由器");
@Override
public void openwife()
System.out.println("开启小米wifi");
@Override
public void setting()
System.out.println("开启小米设置");
//生产路由器和手机的工厂
public interface IProductFactory
//生产手机
IphoneProduct iphoneProduct();
//生产路由器
IRouterProduct irouterproduct();
//生产华为系列路由器和手机的工厂
public class HuaweiFactory implements IProductFactory
@Override
public IphoneProduct iphoneProduct()
return new HuaweiPhone();
@Override
public IRouterProduct irouterproduct()
return new HuaweiRouter();
//生产小米系列路由器和手机的工厂
public class XiaomiFactory implements IProductFactory
@Override
public IphoneProduct iphoneProduct()
return new XiaomiPhone();
@Override
public IRouterProduct irouterproduct()
return new XiaomiRouter();
//主机，去找一个商品直接去该系列的工厂去寻找并使用
public class Clinet
public static void main(String[] args)
System.out.println("==========小米系列产品==========");
//小米工厂
XiaomiFactory xiaomiFactory = new XiaomiFactory();
IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
iphoneProduct.start();
iphoneProduct.shutdown();
System.out.println("==========华为系列产品==========");
//小米工厂
HuaweiFactory huaweiFactory = new HuaweiFactory();
iphoneProduct = huaweiFactory.iphoneProduct();
iphoneProduct.start();
iphoneProduct.shutdown();
4.建造者模式
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
与工厂模式的区别是：建造者模式更加关注与零件装配的顺序
优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
- 建造者与抽象工厂模式的比较：
- 与抽象工厂 模式相比,建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。
- 在抽象工厂模式中，客户端实例化工厂类,然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤,它侧重于一步步构造一 个复杂对象， 返回一个完整的对象。
- 如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车!
public abstract class Builder
abstract void builderA();//地基
abstract void builderB();//钢筋水泥
abstract void builderC();//铺电线
abstract void builderD();//粉刷
//完工:得到产品
abstract Product getproduct();
//产品：房子
public class Product
private String builderA;
private String builderB;
private String builderC;
private String builderD;
//get set tostring
//具体建造者：工人
public class Worker extends Builder
private Product product;
public Worker()
product = new Product();
@Override
void builderA()
product.setBuilderA("地基");
System.out.println("地基");
@Override
void builderB()
product.setBuilderB("钢筋水泥");
System.out.println("钢筋水泥");
@Override
void builderC()
product.setBuilderC("铺电线");
System.out.println("铺电线");
@Override
void builderD()
product.setBuilderD("粉刷");
System.out.println("粉刷");
@Override
Product getproduct()
return product;
//指挥：核心。负责构建一个工程，工程如何构建，由他决定。
public class Director
//指挥工人按照顺序建房子
public Product build(Builder builder)
builder.builderA();
builder.builderB();
builder.builderD();
builder.builderC();
return builder.getproduct();
public class Test
public static void main(String[] args)
Director director = new Director();
Product build = director.build(new Worker());
System.out.println(build);
5.原型模式
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
在运行期建立和删除原型。
利用已有的一个原型对象，快速地生成和原型对象一样的实例。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 4、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
public class Video implements Cloneable
private String name;
private Date createTime;
@Override
protected Object clone() throws CloneNotSupportedException
return super.clone();
//有参无参、getset、tostring
public class Blllllllllli
public static void main(String[] args) throws CloneNotSupportedException
//原型对象
Date date = new Date();
Video v1 = new Video("雙馬", date);
System.out.println("v1== " + v1);
System.out.println("v1.hash== " + v1.hashCode());
//我们这里想要一个和v1一样的对象
//有的人会想，在new一个呗，new的对象是初始化的，就需要将所有v1对象添加的属性全部重新操作一遍，
Video v2 = new Video("雙馬", date);
//通过克隆的方式,可以直接制造出一个和v1一样的副本，但是clone是一个浅拷贝操作，指向并没有变
Video v3 = (Video) v1.clone();
//这里我们会想那怎么看出来一样呢，进行输出和hash
System.out.println("v2== " + v2);
System.out.println("v2.hash== " + v2.hashCode());
System.out.println("v3== " + v3);
System.out.println("v3.hash== " + v3.hashCode());
3.结构型模式
这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。
1.适配器模式
将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的
优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。
缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。
使用场景：有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。
//要被适配的类:网线
public class Adaptee
public void requst()
System.out.println("连接网线上网");
//客户端类：电脑，想上网，但是插不上网线
public class Computer
public void net(NetToUSB adapter)
adapter.handleRequst();
public interface NetToUSB
void handleRequst();
public class Adapter extends Adaptee implements NetToUSB
@Override
public void handleRequst()
super.requst();
public class Test
public static void main(String[] args)
Computer computer = new Computer();//电脑
Adaptee adaptee = new Adaptee();//网线
Adapter adapter = new Adapter();//转接器
Adapter2 adapter2 = new Adapter2(adaptee);//转接器
computer.net(adapter);
使用的时候发现这个适配器是直接连接到网线的，而且这个适配器只能连接一个网线，因为只能单继承，所以我们要将适配器改进一下，改为组合使用
public class Adapter2 implements NetToUSB
private Adaptee adaptee;
public Adapter2(Adaptee adaptee)
this.adaptee = adaptee;
@Override
public void handleRequst()
adaptee.requst();
2.桥接模式
将抽象部分与实现部分分离，使它们都可以独立的变化
优点： 1、抽象和实现的分离。 2、优秀的扩展能力。 3、实现细节对客户透明。
缺点：桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。
//品牌
public interface Brand
void info();
//联想品牌
public class Lenovo implements Brand
@Override
public void info()
System.out.print("联想");
//苹果品牌
public class Apple implements Brand
@Override
public void info()
System.out.print("苹果");
//抽象的电脑类
public class Computer
protected Brand brand;
public Computer(Brand brand)
this.brand = brand;
public void info()
brand.info();//自带品牌
class Desktop extends Computer
public Desktop(Brand brand)
super(brand);
@Override
public void info()
super.info();
System.out.print("台式机");
class Laptop extends Computer
public Laptop(Brand brand)
super(brand);
@Override
public void info()
super.info();
System.out.println("笔记本");
public class Test
public static void main(String[] args)
Computer computer = new Laptop(new Apple());
computer.info();
3.代理模式
为其他对象提供一个代理以便控制这个对象的访问。
优点： 1、职责清晰。 2、高扩展性。 3、智能化。
缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
静态代理
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~
角色分析
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人！
房东只想出租房子，别的事情我不干，租房的其他事情交给中介去代理
//租房
public interface Rent
void rent();
//房东
public class Host implements Rent
@Override
public void rent()
System.out.println("房东要出租房子");
//代理角色
public class Proxy implements Rent
private Host host;
public Proxy(Host host)
this.host = host;
public Proxy()
@Override
public void rent()
seeHost();
host.rent();
hetong();
fare();
//看房
public void seeHost()
System.out.println("中介带你去看房");
//收中介费
public void fare()
System.out.println("收中介费");
//租房
public void hetong()
System.out.println("签租赁合同");
public class Client
public static void main(String[] args)
//房东
Host host = new Host();
//代理,中介帮房东租房子，但是呢，代理一般会有一些附属操作
Proxy proxy = new Proxy(host);
//你不用面对房东，直接找中介租房即可
proxy.rent();
public interface UserService
void add();
void delete();
void update();
void query();
public class UserServiceImpl implements UserService
@Override
public void add()
System.out.println("增加了一个用户");
@Override
public void delete()
System.out.println("删除了一个用户");
@Override
public void update()
System.out.println("修改了一个用户");
@Override
public void query()
System.out.println("查询了一个用户");
public class UserServiceProxy implements UserService
private UserServiceImpl userService;
public UserServiceProxy()
public void setUserService(UserServiceImpl userService)
this.userService = userService;
@Override
public void add()
log("add");
userService.add();
@Override
public void delete()
log("delete");
userService.delete();
@Override
public void update()
log("update");
userService.update();
@Override
public void query()
log("query");
userService.query();
public void log(String msg)
System.out.println("使用了"+msg+"方法");
public class Client
public static void main(String[] args)
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy proxy = new UserServiceProxy();
//proxy代理了userService
proxy.setUserService(userService);
proxy.delete();
动态代理
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
动态代理的使用：
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javassist
需要了解两个类：Proxy： 代理；InvocationHandler：调用处理程序。
//租房
public interface Rent
void rent();
//房东
public class Host implements Rent
@Override
public void rent()
System.out.println("房东要出租房子");
//我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler
//被代理的接口
private Rent rent;
public void setRent(Rent rent)
this.rent = rent;
//生成得到代理类
//newProxyInstance生成一个代理对象(getClassLoader(获取类在哪个位置)，要代理的接口是哪一个，InvocationHandler)
// 获取当前类的加载器，获取rent接口，获取当前类
public Object getProxy()
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
//动态代理的本质，就是使用反射机制实现！ invoke执行什么方法
Object result = method.invoke(rent, args);
seeHose();
fee();
return result;
public void seeHose()
System.out.println("中介带着看房子！");
public void fee()
System.out.println("中介收取费用！");
public class Client
public static void main(String[] args)
//真实角色
Host host = new Host();
//代理角色：现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象！
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy(); //这里的proxy就是动态生成的，我们并没有写
proxy.rent();
public interface UserService
void add();
void delete();
void update();
void query();
public class UserServiceImpl implements UserService
@Override
public void add()
System.out.println("增加了一个用户");
@Override
public void delete()
System.out.println("删除了一个用户");
@Override
public void update()
System.out.println("修改了一个用户");
@Override
public void query()
System.out.println("查询了一个用户");
//我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler //ProxyInvocationHandler生成动态代理实例 InvocationHandler调用处理代理实例，并返回结果
//被代理的接口
private Object target;
public void setTarget(Object target)
this.target = target;
//生成得到代理类
public Object getProxy()
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
log(method.getName());
Object result = method.invoke(target, args);
return result;
public void log(String msg)
System.out.println("使用了"+msg+"方法");
public class Client
public static void main(String[] args)
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色：现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService);//设置要代理的对象
//动态生成代理类 这里父类的类型必须是接口的类型
UserService proxy = (UserService) pih.getProxy();
proxy.add();
4.组合模式
将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
主要解决：在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。
结构：
- 抽象根节点：定义系统各层次对象的共有方法和属性,可以预先定义一些默认行为和属性。
- 树枝节点：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
- 叶子节点：叶子节点对象,其下再无分支，是系统层次遍历的最小单位。
优点： 1、高层模块调用简单。 2、节点自由增加。
- 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
- 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
- 在组合模式中增加新的树枝节点和叶子节点都很方便,无须对现有类库进行任何修改，符合“开闭原则”。
- 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构,但对树形结构的控制却非常简单。
缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。
案例：
//菜单组件，属于抽象根节点
public abstract class MenuComponent
//菜单组件的名称
protected String name;
//菜单组件的层级
protected int level;
//添加子菜单
public void add(MenuComponent menuComponent)
throw new UnsupportedOperationException();
//移除子菜单
public void remove(MenuComponent menuComponent)
throw new UnsupportedOperationException();
//获取指定的子菜单
public MenuComponent getChild(int index)
throw new UnsupportedOperationException();
//获取菜单或者菜单项的名称
public String getName()
return name;
//打印菜单名称的方法（包含子菜单和子菜单项）
public abstract void print();
//菜单类：属于树枝节点
public class Menu extends MenuComponent
//菜单可以有多个子菜单或子菜单项
private List<MenuComponent> menuComponentList=new ArrayList<MenuComponent>();
//构造方法
public Menu(String name,int level)
this.name=name;
this.level=level;
@Override
public void add(MenuComponent menuComponent)
menuComponentList.add(menuComponent);
@Override
public void remove(MenuComponent menuComponent)
menuComponentList.remove(menuComponent);
@Override
public MenuComponent getChild(int index)
return menuComponentList.get(index);
@Override
public void print()
//打印菜单名称
for (int i=0;i<level;i++)
System.out.print("--");
System.out.println(name);
//打印子菜单或者子菜单项名称
for (MenuComponent component : menuComponentList)
component.print();
//菜单项：叶子节点
public class MenuItem extends MenuComponent
public MenuItem(String name,int level)
this.name=name;
this.level=level;
@Override
public void print()
//打印菜单项的名称
for (int i=0;i<level;i++)
System.out.print("--");
System.out.println(name);
public class Client
public static void main(String[] args)
//创建菜单树
MenuComponent menu1= new Menu("菜单管理",2);
menu1.add(new MenuItem("页面访问",3));
menu1.add(new MenuItem("展开菜单",3));
menu1.add(new MenuItem("编辑菜单",3));
menu1.add(new MenuItem("删除菜单",3));
menu1.add(new MenuItem("新增菜单",3));
MenuComponent menu2= new Menu("权限管理",2);
menu2.add(new MenuItem("页面访问",3));
menu2.add(new MenuItem("提交保存",3));
MenuComponent menu3= new Menu("角色管理",2);
menu3.add(new MenuItem("页面访问",3));
menu3.add(new MenuItem("新增角色",3));
menu3.add(new MenuItem("修改角色",3));
//创建一级菜单
MenuComponent component=new Menu("系统菜单",1);
//将二级菜单添加到一级菜单中
component.add(menu1);
component.add(menu2);
component.add(menu3);
///打印菜单名称(如果有子菜单一块打印)
component.print();
以上是关于精简：设计模式的主要内容，如果未能解决你的问题，请参考以下文章