结构型模式

1.适配器模式

2.装饰器模式

3.代理模式

4.外观模式(门面模式)

5.桥接模式

6.组合模式

7.享元模式

1.适配器模式

定义：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种。
- 类结构型模式适配器
- 对象结构型模式适配器
优点：
- 客户端通过适配器可以透明地调用目标接口。
- 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
- 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
主要角色：
- 目标接口（Target）：当前系统业务所期待的接口，它可以是抽象类或接口。
- 适配者类（Adaptee）：它是被访问和适配的现存组件库中的组件接口。
- 适配器类（Adapter）：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

实现：

类适配器:

//目标接口
interface Target
{
public void targetMethod();
}
//适配者类
class Adaptee
{
public void adapteeMethod()
{       
    System.out.println("适配者中的业务代码被调用！");
}
}
//类适配器类
class ClassAdapter extends Adaptee implements Target
{
public void targetMethod()
{
    adapteeMethod();
}
}
//客户端代码
public class ClassAdapterTest
{
public static void main(String[] args)
{
    System.out.println("类适配器模式测试：");
    Target target = new ClassAdapter();
    target.request();
}
}

对象适配器：

//对象适配器类
class ObjectAdapter implements Target
{
private Adaptee adaptee;

public ObjectAdapter(Adaptee adaptee)
{
    this.adaptee=adaptee;
}
public void adapterMethod()
{
    adaptee.adapteeMethod();
}
}
//客户端代码
public class ObjectAdapterTest
{
public static void main(String[] args)
{
    System.out.println("对象适配器模式测试：");
    Adaptee adaptee = new Adaptee();
    Target target = new ObjectAdapter(adaptee);
    target.adapterMethod();
}
}

使用场景（LAP贷款适配平台）
- 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
- 使用第三方提供（全流程）的接口，但第三方接口定义和自己要求的接口定义不同。

2.装饰器模式

定义：装饰（Decorator）模式指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
优点：
- 采用装饰模式扩展对象的功能比采用继承方式更加灵活。
- 可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。
主要角色：
- 抽象构件（Component）：定义一个抽象接口以规范准备接收附加责任的对象。
- 具体构件（Concrete Component）：实现抽象构件，通过装饰角色为其添加一些职责。
- 抽象装饰（Decorator）：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
- 具体装饰（ConcreteDecorator）：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

实现：

//抽象构件角色
interface  Component
{
    public void operation();
}

//具体构件角色
class ConcreteComponent implements Component
{
    public ConcreteComponent()
    {
        System.out.println("创建具体构件角色");       
    }   
    public void operation()
    {
        System.out.println("调用具体构件角色的方法operation()");           
    }
}

//抽象装饰角色
class Decorator implements Component
{
    private Component component;   
    public Decorator(Component component)
    {
        this.component=component;
    }   
    public void operation()
    {
        component.operation();
    }
}
//具体装饰角色
class ConcreteDecorator extends Decorator
{
    public ConcreteDecorator(Component component)
    {
        super(component);
    }   
    public void operation()
    {
        super.operation();
        addedFunction();
    }
    public void addedFunction()
    {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");           
    }
}
//具体调用方法
Component p =new ConcreteComponent();
p.operation();
System.out.println("---------------------------------");
Component d =new ConcreteDecorator(p);
d.operation();

应用场景：Java中的流。例如：下面代码是为 FileReader 增加缓冲区而采用的装饰类 BufferedReader 的例子：
```
BufferedReader in=new BufferedReader(new FileReader("filename.txtn));
String s=in.readLine();
```

3.代理模式

定义：代理模式（Proxy Pattern）给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
主要角色：
- Subject: 抽象主题角色
- Proxy: 代理主题角色
- RealSubject: 真实主题角色

实现：

1.静态代理

//抽象主题
interface Subject {
void Request();
}
//真实主题
class RealSubject implements Subject {
public void Request() {
    System.out.println("访问真实主题方法...");
}
}
//代理
class Proxy implements Subject {
private RealSubject realSubject;
//也可以通过此方式
//private Subject subject;
//public Proxy(Subject subject){
//   this.subjcet=subject;
//}

public void Request() {
    if (realSubject == null) {
        realSubject = new RealSubject();
    }
    preRequest();
    realSubject.Request();
    postRequest();
}
public void preRequest() {
    System.out.println("访问真实主题之前的预处理。");
}
public void postRequest() {
    System.out.println("访问真实主题之后的后续处理。");
}
}
//具体调用方法
public class ProxyTest {
public static void main(String[] args) {
    Proxy proxy = new Proxy();
    //也可以通过此方式
    //RealSubject subject = new RealSubject();
    //Proxy proxy = new Proxy(subject);
    proxy.Request();
}
}

2.动态代理-JDK动态代理实现InvocationHandler方法（可用匿名内部类方式），重写invoke方法;通过Proxy.newInstance()生成代理类；代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理。

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

ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型

InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入,包括（Object proxy, Method method, Object[] args）

/**
* 创建动态代理对象
* 动态代理不需要实现接口,但是需要指定接口类型
*/
public class ProxyFactory{
    
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
    
//给目标对象生成代理对象
public Object getProxyInstance(){
return Proxy.newProxyInstance(
        target.getClass().getClassLoader(),
        target.getClass().getInterfaces(),
        new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("前置方法");
                //执行目标对象方法
                Object returnValue = method.invoke(target, args);
                System.out.println("后置方法");
                return returnValue;
            }
        }
);
}
        
//给目标对象生成代理对象（Lambda方式）
public Object getProxyInstance(){
return Proxy.newProxyInstance(
        target.getClass().getClassLoader(),
        target.getClass().getInterfaces(),
        (proxy, method, args) -> {
            System.out.println("前置方法");
            //执行目标对象方法
            Object returnValue = method.invoke(target, args);
            System.out.println("后置方法");
            return returnValue;
        }
);
}
}

//使用
Subject target = new RealSubject();
// 给目标对象，创建代理对象
Subject proxy = (Subject) new ProxyFactory(target).getProxyInstance();
// 【代理对象】执行方法   
proxy.Request();

3.动态代理-Cglib动态代理实现MethodInterceptor，重写intercept方法;通过Enhancer类（.create()方法)生成代理对象并设置回调方法（setCallBack）； Cglib动态代理也叫做子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。 JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现。

/**
* Cglib子类代理工厂
* 对RealSubject在内存中动态构建一个子类对象
*/
public class ProxyFactory implements MethodInterceptor {
//维护目标对象
private Object target;
    
public ProxyFactory(Object target) {
    this.target = target;
}
    
//给目标对象创建一个代理对象
public Object getProxyInstance(){
    //1.工具类
    Enhancer en = new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback(this);
    //4.创建子类(代理对象)
    return en.create();
}
    
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    System.out.println("前置处理...");
    //执行目标对象的方法
    Object returnValue = method.invoke(target, args);
    System.out.println("后置处理...");
    return returnValue;
}
}
//不实现MethodInterceptor，采用匿名内部类方式
public class ProxyFactory{
//维护目标对象
private Object target;
    
public ProxyFactory(Object target) {
    this.target = target;
}
    
//给目标对象创建一个代理对象
public Object getProxyInstance(){
    //1.工具类
    Enhancer en = new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("前置处理...");
            //执行目标对象的方法
            Object returnValue = method.invoke(target, args);
            System.out.println("后置处理...");
            return returnValue;
        }
    });
    //4.创建子类(代理对象)
    return en.create();
}
}
//不实现MethodInterceptor，采用匿名内部类-lambda方式
public class ProxyFactory{
//维护目标对象
private Object target;
    
public ProxyFactory(Object target) {
    this.target = target;
}
    
//给目标对象创建一个代理对象
public Object getProxyInstance(){
    //1.工具类
    Enhancer en = new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback((MethodInterceptor) (obj, method, args, methodProxy) -> {
        System.out.println("前置处理...");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("后置处理...");
        return returnValue;
    });
    //4.创建子类(代理对象)
    return en.create();
}
}

//使用
RealSubject target = new RealSubject();
// 给目标对象，创建代理对象
RealSubject proxy = (RealSubject) new ProxyFactory(target).getProxyInstance();
// 【代理对象】执行方法   
proxy.Request();

应用场景：SpringAOP
- @Aespect定义切面
- @Pointcut切入的包
- @Around环绕通知
- ProceedingJoinPoint连接点

4.外观模式(门面模式)

定义：外观（Facade）模式：隐藏系统的复杂性,并向客户提供了一个客户端可以访问系统的接口。

主要角色：

外观（Facade）：为多个子系统对外提供一个共同的接口。
子系统（Sub System）：实现系统的部分功能，客户可以通过外观角色访问它。

客户（Client）：通过一个外观角色访问各个子系统的功能。 -实现：

//外观角色
class Facade
{
private SubSystemA obj1=new SubSystemA();
private SubSystemB obj2=new SubSystemB();
private SubSystemC obj3=new SubSystemC();
public void method()
{
    obj1.methodA();
    obj2.methodB();
    obj3.methodC();
}
}
//子系统角色
class SubSystemA
{
public  void methodA()
{
    System.out.println("子系统A的methodA()被调用！");
}   
}
//子系统角色
class SubSystemB
{
public  void methodB()
{
    System.out.println("子系统B的methodB()被调用！");
}   
}
//子系统角色
class SubSystemC
{
public  void methodC()
{
    System.out.println("子系统C的methodC()被调用！");
}   
}
//使用
Facade f=new Facade();
f.method();

应用场景：Java三层模式

5.桥接模式

定义：将抽象化与实现化解耦，使得二者可以独立变化。它是用组合关系代替继承关系来实现。

主要角色：

抽象化（Abstraction）：定义抽象类，并包含一个对实现化对象的引用。
扩展抽象化（Refined Abstraction）：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用具体实现化角色中的业务方法。
实现化（Implementor）：定义实现化角色的接口，供扩展抽象化角色调用。

具体实现化（Concrete Implementor）：给出实现化角色接口的具体实现。 -实现：

//实现化角色
interface Implementor
{
public void OperationImpl();
}
//具体实现化角色
class ConcreteImplementorA implements Implementor
{
public void OperationImpl()
{
    System.out.println("具体实现化(Concrete Implementor)角色被访问" );
}
}
//抽象化角色
abstract class Abstraction
{
protected Implementor imple;
protected Abstraction(Implementor imple)
{
   this.imple=imple;
}
public abstract void Operation();   
}
//扩展抽象化角色
class ExpandedAbstraction extends Abstraction
{
protected ExpandedAbstraction(Implementor imple)
{
   super(imple);
}
public void Operation()
{
   System.out.println("扩展抽象化(Expanded Abstraction)角色被访问" );
   imple.OperationImpl();
}
}
//使用
Implementor imple=new ConcreteImplementorA();
Abstraction abs=new ExpandedAbstraction(imple);
abs.Operation();

应用场景：JDBC API链接数据库在不使用Spring、Hibernate等第三方库的情况下，直接通过原生JDBC API连接MySQL数据库，则有如下示例代码：
```
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://<host>:<port>/<database>");
```
Class.forName()方法加载的是一个类，也会执行类中包含的static { } 静态代码段
```
public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException{}
```
总结：，Class.forName()方法调用后，com.mysql.cj.jdbc.Driver类被加载，并执行static { } 静态代码段，将com.mysql.cj.jdbc.Driver类实例注册到DriverManager中。然后，客户端会调用DriverManager.getConnection()方法获取一个Connection数据库连接实例参考：https://www.cnblogs.com/kuluo/p/13038076.html

6.组合模式
定义：组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
主要角色：
- 抽象构件（Component）：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
- 树叶构件（Leaf）：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中声明的公共接口。
- 树枝构件（Composite）：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

实现：

透明式：

//抽象构件
interface Component
{
public void add(Component c);
public void remove(Component c);
public Component getChild(int i);
public void operation();
}
//树叶构件
class Leaf implements Component
{
private String name;
public Leaf(String name)
{
    this.name=name;
}
public void add(Component c){ }           
public void remove(Component c){ }   
public Component getChild(int i)
{
    return null;
}   
public void operation()
{
    System.out.println("树叶"+name+"：被访问！"); 
}
}
//树枝构件
class Composite implements Component
{
private ArrayList<Component> children=new ArrayList<Component>();   
public void add(Component c)
{
    children.add(c);
}   
public void remove(Component c)
{
    children.remove(c);
}   
public Component getChild(int i)
{
    return children.get(i);
}   
public void operation()
{
    for(Object obj:children)
    {
        ((Component)obj).operation();
    }
}    
}

安全式：略

应用场景：
- List、Set的addAll方法以及Map的putAll方法。

7.享元模式

定义：享元（Flyweight）模式运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。
主要角色：
- 抽象享元（Flyweight）:是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
- 具体享元（Concrete Flyweight）：实现抽象享元角色中所规定的接口。
- 非享元（Unsharable Flyweight)：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
- 享元工厂（Flyweight Factory）：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

实现：

//非享元角色
class UnsharedConcreteFlyweight
{
    private String info;
    UnsharedConcreteFlyweight(String info)
    {
        this.info=info;
    }
    public String getInfo()
    {
        return info;
    }
    public void setInfo(String info)
    {
        this.info=info;
    }
}
//抽象享元角色
interface Flyweight
{
    public void operation(UnsharedConcreteFlyweight state);
}
//具体享元角色
class ConcreteFlyweight implements Flyweight
{
    private String key;
    ConcreteFlyweight(String key)
    {
        this.key=key;
        System.out.println("具体享元"+key+"被创建！");
    }
    public void operation(UnsharedConcreteFlyweight outState)
    {
        System.out.print("具体享元"+key+"被调用，");
        System.out.println("非享元信息是:"+outState.getInfo());
    }
}
//享元工厂角色
class FlyweightFactory
{
    private HashMap<String, Flyweight> flyweights=new HashMap<String, Flyweight>();
    public Flyweight getFlyweight(String key)
    {
        Flyweight flyweight=(Flyweight)flyweights.get(key);
        if(flyweight!=null)
        {
            System.out.println("具体享元"+key+"已经存在，被成功获取！");
        }
        else
        {
            flyweight=new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
        }
        return flyweight;
    }
}
// 具体调用
FlyweightFactory factory=new FlyweightFactory();
Flyweight f01=factory.getFlyweight("a");
Flyweight f02=factory.getFlyweight("a");
Flyweight f03=factory.getFlyweight("a");
Flyweight f11=factory.getFlyweight("b");
Flyweight f12=factory.getFlyweight("b");       
f01.operation(new UnsharedConcreteFlyweight("第1次调用a。"));       
f02.operation(new UnsharedConcreteFlyweight("第2次调用a。"));       
f03.operation(new UnsharedConcreteFlyweight("第3次调用a。"));       
f11.operation(new UnsharedConcreteFlyweight("第1次调用b。"));       
f12.operation(new UnsharedConcreteFlyweight("第2次调用b。"));

结构型模式

结构型模式

1.适配器模式

2.装饰器模式

3.代理模式

4.外观模式(门面模式)

5.桥接模式

6.组合模式

7.享元模式

1.适配器模式

2.装饰器模式

3.代理模式

4.外观模式(门面模式)

5.桥接模式

6.组合模式

7.享元模式

See Also

最近文章

分类

标签