简介
将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式。
结构型模式分为：代理模式、适配器模式、装饰模式、桥接模式、外观模式、享元模式、组合模式
结构型模式分类
(1) 代理模式
说明：给某对象提供一个代理以控制对该对象的访问。访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
优点：
在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
将客户端与目标对象分离，降低了系统的耦合度；
缺点：
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；
1 ) 静态代理实现
目标接口代码
package com.threadtest.designpattern;
public interface Subject {
void request();
}
目标接口实现类代码
package com.threadtest.designpattern;
public class RealSubject implements Subject {
@Override
public void request() {
System.out.println("执行了目标类请求!");
}
}
代理类实现代码
package com.threadtest.designpattern;
public class SubjectProxy implements Subject {
private RealSubject realSubject;
@Override
public void request() {
if(realSubject == null) {
realSubject = new RealSubject();
}
preRequest();
realSubject.request();
postRequest();
}
private void preRequest() {
System.out.println("执行目标对象前执行的业务！");
}
public void postRequest() {
System.out.println("执行目标对象后执行的业务!");
}
}
代理执行源码
package com.threadtest.designpattern;
public class ProxyTest {
public static void main(String[] args) {
SubjectProxy proxy = new SubjectProxy();
proxy.request();
}
}
2 ) 动态代理实现
a. JDK动态代理
package com.threadtest.designpattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class SubjectInvocationHandler implements InvocationHandler {
private RealSubject realSubject;
public SubjectInvocationHandler(RealSubject realSubject) {
this.realSubject = realSubject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("执行目标代码前业务执行...！");
method.invoke(realSubject, args);
System.out.println("执行目标代码后业务执行...！");
return null;
}
}
代理执行源码
package com.threadtest.designpattern;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
Subject subject = (Subject) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), new Class[]{Subject.class}, new SubjectInvocationHandler(new RealSubject()));
subject.request("李白");
subject.request2();
}
}
b. Cglib动态代理
向pom.xml引入cglib包
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
目标类源码
package com.design;
public class RealSubject {
public void request(String name) {
System.out.println(name + " 执行了目标类请求!");
}
public void request2() {
System.out.println("执行了目标类请求2!");
}
}
定义拦截器源码
package com.design;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class SubjectMethodInterceptor implements MethodInterceptor {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("执行目标类前的业务!");
Object result = methodProxy.invokeSuper(o, objects);
return result;
}
}
定义动态代理工厂
package com.design;
import net.sf.cglib.proxy.Enhancer;
public class ProxyFactory {
public static Object getCglibDynProxy(Object target) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new SubjectMethodInterceptor());
return enhancer.create();
}
}
定义具体执行类
package com.design;
public class ProxyTest {
public static void main(String[] args) {
RealSubject realSubject = (RealSubject) ProxyFactory.getCglibDynProxy(new RealSubject());
realSubject.request("陶渊明");
realSubject.request2();
}
}
(2) 适配器模式
说明：将一个类的接口转换成客户希望的另外一个接口，使不兼容的接口在一起工作。
1 ) 类适配器模式
目标接口源码
package com.design;
public interface Bird {
void sayBirdLanguage();
}
适配者类源码
package com.design;
public class Pig {
public void sayPigLanguage() {
System.out.println("我是猪，所以我说猪语!");
}
}
适配器类源码
package com.design;
public class ClassLanguageAdapter extends Pig implements Bird {
public void sayBirdLanguage() {
System.out.println("转化为鸟语!");
sayPigLanguage();
}
}
适配器执行源码
package com.design;
public class LanguageTest {
public static void main(String[] args) {
Bird bird = new ClassLanguageAdapter();
bird.sayBirdLanguage();
}
}
2 ) 对象适配器模式
适配器源码
package com.design;
public class ObjectLanguageAdapter implements Bird {
private Pig pig;
public ObjectLanguageAdapter(Pig pig) {
this.pig = pig;
}
public void sayBirdLanguage() {
System.out.println("转化为鸟语!");
pig.sayPigLanguage();
}
}
配置器执行代码
package com.design;
public class LanguageTest {
public static void main(String[] args) {
Bird bird = new ObjectLanguageAdapter(new Pig());
bird.sayBirdLanguage();
}
}
(3) 桥接模式
说明：用组合关系将抽象与实现分离，使它们可以独立变化。
优点：
由于抽象与实现分离，所以扩展能力强；
其实现细节对客户透明。
缺点
由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，这增加了系统的理解与设计难度。
实现化角色源码
package com.design;
public interface Fruit {
void taste();
}
具体实现化角色源码
package com.design;
public class Apple implements Fruit {
public void taste() {
System.out.println("我的味道有点苦涩!");
}
}
抽象化角色源码
package com.design;
public abstract class AbstractShop {
protected Fruit fruit;
public AbstractShop(Fruit fruit) {
this.fruit = fruit;
}
protected abstract void sale();
}
扩展抽象化角色源码
package com.design;
public class AppleShop extends AbstractShop {
public AppleShop(Fruit fruit) {
super(fruit);
}
protected void sale() {
System.out.println("我们这里卖的是苹果!");
fruit.taste();
}
}
(4) 装饰模式
说明：在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
优点：
采用装饰模式扩展对象的功能比采用继承方式更加灵活。
可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。
缺点
装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。
抽象构建角色源码
package com.design;
public interface Person {
void work();
}
具体构建角色源码
package com.design;
public class Woman implements Person {
public void work() {
System.out.println("我的工作是文员！");
}
}
抽象装饰角色源码
package com.design;
public class DecoratorPerson implements Person {
private Person person;
public DecoratorPerson(Person person) {
this.person = person;
}
public void work() {
person.work();
}
}
具体装饰角色源码
package com.design;
public class DecoratorPersonTraffic extends DecoratorPerson {
public DecoratorPersonTraffic(Person person) {
super(person);
}
public void work() {
super.work();
backHome();
}
public void backHome() {
System.out.println("下班回家!");
}
}
装饰器测试执行源码
package com.design;
public class DecoratorTest {
public static void main(String[] args) {
Person person = new Woman();
person.work();
Person person1 = new DecoratorPersonTraffic(person);
person1.work();
}
}
(5) 外观模式
说明：通过为多个复杂的子系统提供一个一致的统一的接口，降低程序复杂度，提高代码可维护性。
优点
降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。
降低了大型软件系统中的编译依赖性，简化了系统在不同平台之间的移植过程，因为编译一个子系统不会影响其他的子系统，也不会影响外观对象。
缺点
不能很好地限制客户使用子系统类。
增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。
外观角色源码
package com.design;
public class LunchPlan {
private FruitNeed fruitNeed = new FruitNeed();
private MeatNeed meatNeed = new MeatNeed();
private TeaNeed teaNeed = new TeaNeed();
public void eating() {
fruitNeed.eat();
meatNeed.taste();
teaNeed.drink();
}
}
子系统角色源码
package com.design;
public class FruitNeed {
public void eat() {
System.out.println("用餐时需要吃水果!");
}
}
package com.design;
public class MeatNeed {
public void taste() {
System.out.println("用餐时，需要品尝牛肉的味道!");
}
}
package com.design;
public class TeaNeed {
public void drink() {
System.out.println("用晚餐，还需要喝点奶茶!");
}
}
外观执行源码
package com.design;
public class FacadeTest {
public static void main(String[] args) {
LunchPlan lunchPlan = new LunchPlan();
lunchPlan.eating();
}
}
(6) 享元模式
说明：通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销。
优点
相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
缺点：
为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。
抽象享元角色源码
package com.design;
public interface Transport {
public void operate(UnSharedCustomer unSharedCustomer);
}
具体享元角色源码
package com.design;
public class Airplane implements Transport {
private String basicInfo;
public Airplane(String info) {
this.basicInfo = info;
}
public void operate(UnSharedCustomer unSharedCustomer) {
System.out.println("我是飞机，我已经在运营了!");
if(unSharedCustomer.availuableUse()) {
System.out.println("登机成功!");
System.out.println(String.format("乘客信息, 姓名： %s, 年龄: %s", unSharedCustomer.getUserName(), unSharedCustomer.getAge()));
} else {
System.out.println("未满18岁不能登机!");
}
}
}
非享元角色源码
package com.design;
public class CustomerInfo implements UnSharedCustomer {
private String userName;
private int age;
public CustomerInfo(String userName, int age) {
this.userName = userName;
this.age = age;
}
@Override
public String getUserName() {
return userName;
}
@Override
public int getAge() {
return age;
}
@Override
public boolean availuableUse() {
if(age >= 18) {
return true;
}
return false;
}
}
享元工厂角色源码
package com.design;
import java.util.HashMap;
import java.util.Map;
public class TransportFactory {
private TransportFactory(){}
private static final TransportFactory factory = new TransportFactory();
public final Map<String, Airplane> transportMap = new HashMap<>();
public static Transport getTransport(String name) {
Airplane airplane = factory.transportMap.get(name);
if(airplane == null) {
airplane = new Airplane(name);
factory.transportMap.put(name, airplane);
}
return airplane;
}
}
享元执行源码
package com.design;
public class FlyweightTest {
public static void main(String[] args) {
Transport transport = TransportFactory.getTransport("hb546333");
UnSharedCustomer unSharedCustomer = new CustomerInfo("黎明", 52);
UnSharedCustomer unSharedCustomer1 = new CustomerInfo("李白", 14);
transport.operate(unSharedCustomer);
transport.operate(unSharedCustomer1);
}
}
(7) 组合模式
网友评论