文档章节

Java经典设计模式(2):七大结构型模式

飓风2000
 飓风2000
发布于 2017/02/10 11:57
字数 4438
阅读 5
收藏 0

总体来说设计模式分为三大类:创建型模式、结构型模式和行为型模式。

博主的上一篇文章已经提到过创建型模式,此外该文章还有设计模式概况和设计模式的六大原则。设计模式的六大原则是设计模式的核心思想,详情请看博主的另外一篇文章: Java经典设计模式之五大创建模式(附实例和详解)

接下来我们看看结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中适配器模式主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。其中的对象的适配器模式是各种结构型模式的起源。

一、适配器模式

适配器模式主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。

适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。有点抽象,我们来看看详细的内容。

1.1、类的适配器模式

类的适配器模式核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口是Targetable,通过Adapter类,将Source的功能扩展到Targetable里。

1

2

3

4

5

6

7

package com.model.structure;

 

public class Source {

    public void method1() { 

        System.out.println("this is original method!"); 

    

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public interface Targetable {

    /* 与原类中的方法相同 */

    public void method1();

 

    /* 新类的方法 */

    public void method2();

}

1

2

3

4

5

6

7

package com.model.structure;

 

public class Adapter extends Source implements Targetable {

    public void method2() {

        System.out.println("this is the targetable method!");

    }

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class AdapterTest {

    public static void main(String[] args) {

        Targetable target = new Adapter();

        target.method1();

        target.method2();

    }

}

AdapterTest的运行结果:

这里写图片描述

1.2、对象的适配器模式

对象的适配器模式的基本思路和类的适配器模式相同,只是将Adapter类作修改成Wrapper,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

package com.model.structure;

 

public class Wrapper implements Targetable {

 

    private Source source;

 

    public Wrapper(Source source) {

        super();

        this.source = source;

    }

 

    @Override

    public void method2() {

        System.out.println("this is the targetable method!");

    }

 

    @Override

    public void method1() {

        source.method1();

    }

}

1

2

3

4

5

6

7

8

9

10

package com.model.structure;

 

public class AdapterTest {

    public static void main(String[] args) {

        Source source = new Source();

        Targetable target = new Wrapper(source);

        target.method1();

        target.method2();

    }

}

运行结果跟类的适配器模式例子的一样。

1.3、接口的适配器模式

接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行了。

这里看文字描述已经试够清楚的了,因此就不贴代码实例了。

二、装饰模式

装饰模式:在不必改变原类文件和使用继承的情况下,动态地扩展一个对象的功能。它是通过创建一个包装对象,也就是装饰来包裹真实的对象。

装饰模式的特点:

(1) 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
(2) 装饰对象包含一个真实对象的引用(reference)
(3) 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
(4) 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时,不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中,通常是通过继承来实现对给定类的功能扩展。继承不能做到这一点,继承的功能是静态的,不能动态增删。

具体看看代码实例

1

2

3

4

5

package com.model.structure;

 

public interface Sourceable {

    public void method();

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class Source implements Sourceable {

 

    @Override

    public void method() {

        System.out.println("the original method!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

package com.model.structure;

 

public class Decorator implements Sourceable {

 

    private Sourceable source;

 

    public Decorator(Sourceable source) {

        super();

        this.source = source;

    }

 

    @Override

    public void method() {

        System.out.println("before decorator!");

        source.method();

        System.out.println("after decorator!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

package com.model.structure;

 

public class DecoratorTest {

 

    public static void main(String[] args) {

        //(1) 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。

        //(2) 装饰对象包含一个真实对象的引用(reference)

        //(3) 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。

        //(4) 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时,不用修改给定对象的结构就可以在外部增加附加的功能。

        //    在面向对象的设计中,通常是通过继承来实现对给定类的功能扩展。

        //    继承不能做到这一点,继承的功能是静态的,不能动态增删。

        Sourceable source = new Source();

        Sourceable obj = new Decorator(source);

        obj.method();

    }

}

运行结果:

1

2

3

before decorator!

the original method!

after decorator!

三、代理模式

代理模式就是多一个代理类出来,替原对象进行一些操作。代理类就像中介,它比我们掌握着更多的信息。

具体看看代码实例。

1

2

3

4

5

package com.model.structure;

 

public interface Sourceable {

    public void method();

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class Source implements Sourceable {

 

    @Override

    public void method() {

        System.out.println("the original method!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

package com.model.structure;

 

public class Proxy implements Sourceable {

 

    private Source source;

 

    public Proxy() {

        super();

        this.source = new Source();

    }

 

    @Override

    public void method() {

        before();

        source.method();

        atfer();

    }

 

    private void atfer() {

        System.out.println("after proxy!");

    }

 

    private void before() {

        System.out.println("before proxy!");

    }

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class ProxyTest {

 

    public static void main(String[] args) {

        Sourceable source = new Proxy();

        source.method();

    }

}

运行结果:

1

2

3

before proxy!

the original method!

after proxy!

四、外观模式

外观模式是为了解决类与类之间的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中没有涉及到接口。

我们以一个计算机的启动过程为例,看看如下的代码:

1

2

3

4

5

6

7

8

9

10

11

12

package com.model.structure;

 

public class CPU {

 

    public void startup() {

        System.out.println("cpu startup!");

    }

 

    public void shutdown() {

        System.out.println("cpu shutdown!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

package com.model.structure;

 

public class Disk {

 

    public void startup() {

        System.out.println("disk startup!");

    }

 

    public void shutdown() {

        System.out.println("disk shutdown!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

package com.model.structure;

 

public class Memory {

 

    public void startup() {

        System.out.println("memory startup!");

    }

 

    public void shutdown() {

        System.out.println("memory shutdown!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

package com.model.structure;

 

public class Computer {

 

    private CPU cpu;

    private Memory memory;

    private Disk disk;

 

    public Computer() {

        cpu = new CPU();

        memory = new Memory();

        disk = new Disk();

    }

 

    public void startup() {

        System.out.println("start the computer!");

        cpu.startup();

        memory.startup();

        disk.startup();

        System.out.println("start computer finished!");

    }

 

    public void shutdown() {

        System.out.println("begin to close the computer!");

        cpu.shutdown();

        memory.shutdown();

        disk.shutdown();

        System.out.println("computer closed!");

    }

}

1

2

3

4

5

6

7

8

9

10

package com.model.structure;

 

public class User {

 

    public static void main(String[] args) {

        Computer computer = new Computer();

        computer.startup();

        computer.shutdown();

    }

}

运行结果:

1

2

3

4

5

6

7

8

9

10

start the computer!

cpu startup!

memory startup!

disk startup!

start computer finished!

begin to close the computer!

cpu shutdown!

memory shutdown!

disk shutdown!

computer closed!

五、桥接模式

在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化,而又不引入额外的复杂度?这就要使用Bridge模式。

在提出桥梁模式的时候指出,桥梁模式的用意是”将抽象化(Abstraction)与实现化(Implementation)脱耦,使得二者可以独立地变化”。这句话有三个关键词,也就是抽象化、实现化和脱耦。

抽象化:存在于多个实体中的共同的概念性联系,就是抽象化。作为一个过程,抽象化就是忽略一些信息,从而把不同的实体当做同样的实体对待。
实现化:抽象化给出的具体实现,就是实现化。
脱耦:所谓耦合,就是两个实体的行为的某种强关联。而将它们的强关联去掉,就是耦合的解脱,或称脱耦。在这里,脱耦是指将抽象化和实现化之间的耦合解脱开,或者说是将它们之间的强关联改换成弱关联。

下面我们来看看代码实例:

1

2

3

4

5

package com.model.structure;

 

public interface Driver { 

    public void connect(); 

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class MysqlDriver implements Driver {

 

    @Override

    public void connect() {

        System.out.println("connect mysql done!");

    }

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class DB2Driver implements Driver {

 

    @Override

    public void connect() {

        System.out.println("connect db2 done!");

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

package com.model.structure;

 

public abstract class DriverManager {

 

    private Driver driver;

 

    public void connect() {

        driver.connect();

    }

 

    public Driver getDriver() {

        return driver;

    }

 

    public void setDriver(Driver driver) {

        this.driver = driver;

    }

 

}

1

2

3

4

5

6

7

8

9

package com.model.structure;

 

public class MyDriverManager extends DriverManager {

 

    public void connect() {

        super.connect();

    }

 

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

package com.model.structure;

 

public class Client {

 

    public static void main(String[] args) {

 

        DriverManager driverManager = new MyDriverManager();

        Driver driver1 = new MysqlDriver();

        driverManager.setDriver(driver1);

        driverManager.connect();

 

        Driver driver2 = new DB2Driver();

        driverManager.setDriver(driver2);

        driverManager.connect();

 

    }

}

执行结果:

1

2

connect mysql done!

connect db2 done!

如果看完代码实例还不是很理解,我们想想如下两个维度扩展:(1)假设我想加一个OracleDriver,这是一个维度,很好理解,不多解释。(2)假设我们想在连接前后固定输出点什么,我们只需要加一个MyDriverManager2,代码如下:

1

2

3

4

5

6

7

8

9

10

11

package com.model.structure;

 

public class MyDriverManager2 extends DriverManager {

 

    public void connect() {

        System.out.println("before connect");

        super.connect();

        System.out.println("after connect");

    }

 

}

再将Client代码中的MyDriverManager 改成 MyDriverManager2 ,执行结果如下:

1

2

3

4

5

6

before connect

connect mysql done!

after connect

before connect

connect db2 done!

after connect

六、组合模式

组合模式,将对象组合成树形结构以表示“部分-整体”的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。掌握组合模式的重点是要理解清楚 “部分/整体” 还有 ”单个对象“ 与 “组合对象” 的含义。

组合模式让你可以优化处理递归或分级数据结构。

《设计模式》:将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

涉及角色:

Component:是组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

Leaf:在组合中表示叶子结点对象,叶子结点没有子结点。

Composite:定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关操作,如增加(add)和删除(remove)等。

比如现实中公司内各部门的层级关系,请看代码:

Component:是组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

package com.model.structure;

 

public abstract class Company {

 

    private String name;

 

    public Company() {

    }

 

    public Company(String name) {

        super();

        this.name = name;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    protected abstract void add(Company company);

 

    protected abstract void romove(Company company);

 

    protected abstract void display(int depth);

 

}

Composite:定义有枝节点行为,用来存储子部件,在Component接口中实现与子部件有关操作,如增加(add)和删除(remove)等。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

package com.model.structure;

 

import java.util.ArrayList;

import java.util.List;

 

public class ConcreteCompany extends Company {

 

    private List<Company> cList;

 

    public ConcreteCompany() {

        cList = new ArrayList();

    }

 

    public ConcreteCompany(String name) {

        super(name);

        cList = new ArrayList();

    }

 

    @Override

    protected void add(Company company) {

        cList.add(company);

    }

 

    @Override

    protected void display(int depth) {

 

        StringBuilder sb = new StringBuilder("");

        for (int i = 0; i < depth; i++) {

            sb.append("-");

        }

        System.out.println(new String(sb) + this.getName());

        for (Company c : cList) {

            c.display(depth + 2);

        }

    }

 

    @Override

    protected void romove(Company company) {

        cList.remove(company);

    }

}

Leaf:在组合中表示叶子结点对象,叶子结点没有子结点。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

package com.model.structure;

 

public class HRDepartment extends Company {

    public HRDepartment(String name) {

        super(name);

    }

 

    @Override

    protected void add(Company company) {

    }

 

    @Override

    protected void display(int depth) {

        StringBuilder sb = new StringBuilder("");

        for (int i = 0; i < depth; i++) {

            sb.append("-");

        }

        System.out.println(new String(sb) + this.getName());

    }

 

    @Override

    protected void romove(Company company) {

    }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

package com.model.structure;

 

public class FinanceDepartment extends Company {

    public FinanceDepartment(String name) {

        super(name);

    }

 

    @Override

    protected void add(Company company) {

    }

 

    @Override

    protected void display(int depth) {

        StringBuilder sb = new StringBuilder("");

        for (int i = 0; i < depth; i++) {

            sb.append("-");

        }

        System.out.println(new String(sb) + this.getName());

    }

 

    @Override

    protected void romove(Company company) {

    }

}

Client:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

package com.model.structure;

 

public class Client {

    public static void main(String[] args) {

        Company root = new ConcreteCompany();

        root.setName("北京总公司");

        root.add(new HRDepartment("总公司人力资源部"));

        root.add(new FinanceDepartment("总公司财务部"));

        Company shandongCom = new ConcreteCompany("山东分公司");

        shandongCom.add(new HRDepartment("山东分公司人力资源部"));

        shandongCom.add(new FinanceDepartment("山东分公司账务部"));

        Company zaozhuangCom = new ConcreteCompany("枣庄办事处");

        zaozhuangCom.add(new FinanceDepartment("枣庄办事处财务部"));

        zaozhuangCom.add(new HRDepartment("枣庄办事处人力资源部"));

        Company jinanCom = new ConcreteCompany("济南办事处");

        jinanCom.add(new FinanceDepartment("济南办事处财务部"));

        jinanCom.add(new HRDepartment("济南办事处人力资源部"));

        shandongCom.add(jinanCom);

        shandongCom.add(zaozhuangCom);

        Company huadongCom = new ConcreteCompany("上海华东分公司");

        huadongCom.add(new HRDepartment("上海华东分公司人力资源部"));

        huadongCom.add(new FinanceDepartment("上海华东分公司账务部"));

        Company hangzhouCom = new ConcreteCompany("杭州办事处");

        hangzhouCom.add(new FinanceDepartment("杭州办事处财务部"));

        hangzhouCom.add(new HRDepartment("杭州办事处人力资源部"));

        Company nanjingCom = new ConcreteCompany("南京办事处");

        nanjingCom.add(new FinanceDepartment("南京办事处财务部"));

        nanjingCom.add(new HRDepartment("南京办事处人力资源部"));

        huadongCom.add(hangzhouCom);

        huadongCom.add(nanjingCom);

        root.add(shandongCom);

        root.add(huadongCom);

        root.display(0);

    }

}

运行结果:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

北京总公司

--总公司人力资源部

--总公司财务部

--山东分公司

----山东分公司人力资源部

----山东分公司账务部

----济南办事处

------济南办事处财务部

------济南办事处人力资源部

----枣庄办事处

------枣庄办事处财务部

------枣庄办事处人力资源部

--上海华东分公司

----上海华东分公司人力资源部

----上海华东分公司账务部

----杭州办事处

------杭州办事处财务部

------杭州办事处人力资源部

----南京办事处

------南京办事处财务部

------南京办事处人力资源部

七、享元模式

享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。

一提到共享池,我们很容易联想到Java里面的JDBC连接池,想想每个连接的特点,我们不难总结出:适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接池来说,url、driverClassName、username、password及dbname,这些属性对于每个连接来说都是一样的,所以就适合用享元模式来处理,建一个工厂类,将上述类似属性作为内部数据,其它的作为外部数据,在方法调用时,当做参数传进来,这样就节省了空间,减少了实例的数量。

看下数据库连接池的代码:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

package com.model.structure;

 

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.Vector;

 

public class ConnectionPool {

 

    private Vector<Connection> pool;

 

    /* 公有属性 */

    private String url = "jdbc:mysql://localhost:3306/test";

    private String username = "root";

    private String password = "root";

    private String driverClassName = "com.mysql.jdbc.Driver";

 

    private int poolSize = 100;

    private static ConnectionPool instance = null;

    Connection conn = null;

 

    /* 构造方法,做一些初始化工作 */

    private ConnectionPool() {

        pool = new Vector<Connection>(poolSize);

 

        for (int i = 0; i < poolSize; i++) {

            try {

                Class.forName(driverClassName);

                conn = DriverManager.getConnection(url, username, password);

                pool.add(conn);

            } catch (ClassNotFoundException e) {

                e.printStackTrace();

            } catch (SQLException e) {

                e.printStackTrace();

            }

        }

    }

 

    /* 返回连接到连接池 */

    public synchronized void release() {

        pool.add(conn);

    }

 

    /* 返回连接池中的一个数据库连接 */

    public synchronized Connection getConnection() {

        if (pool.size() > 0) {

            Connection conn = pool.get(0);

            pool.remove(conn);

            return conn;

        } else {

            return null;

        }

    }

}

通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能!

本文转载自:

共有 人打赏支持
飓风2000
粉丝 37
博文 328
码字总数 136046
作品 0
浦东
高级程序员
私信 提问
设计模式之适配器模式(结构型)

@[toc] 模式定义 适配器模式(Adapter Pattern):将一个接口转换成客户希望的接口,适配器模式使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式...

smileNicky
03/08
0
0
java 23种设计模式 深入理解

以下是学习过程中查询的资料,别人总结的资料,比较容易理解(站在各位巨人的肩膀上,望博主勿究) 创建型 抽象工厂模式 http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html ...

wc_飞豆
2018/03/16
0
0
PHP设计模式(一):简介及创建型模式

我们分三篇文章来总结一下设计模式在PHP中的应用,这是第一篇创建型模式。 一、设计模式简介 首先我们来认识一下什么是设计模式: 设计模式是一套被反复使用、容易被他人理解的、可靠的代码设...

juhenj
2014/05/15
228
2
练就Java24章真经—你所不知道的工厂方法

前言 最近一直在Java方向奋斗《终于,我还是下决心学Java后台了》,今天抽空开始学习Java的设计模式了 。计划有时间就去学习,你这么有时间,还不来一起上车吗? 之所以要学习Java模式,是因...

codeGoogle
2018/10/30
0
0
java中23种设计模式(上)

参考网址:http://blog.csdn.net/zhangerqing 资源:http://download.csdn.net/detail/zhangerqing/4835830 设计模式(Design Patterns) 设计模式(Design pattern)是一套被反复使用、多数...

青涩的梦
2018/06/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Spring Boot 集成 Swagger,生成接口文档就这么简单!

之前的文章介绍了《推荐一款接口 API 设计神器!》,今天栈长给大家介绍下如何与优秀的 Spring Boot 框架进行集成,简直不能太简单。 你所需具备的基础 告诉你,Spring Boot 真是个牛逼货! ...

Java技术栈
25分钟前
3
0
一个简单的js作用域题目(原创)

var name = 'nnmm' var obj = { name: 'name1', func: () => { console.log(this.name) }, func1: function (){ console.log(this.name) }, son: { ......

boogoogle
27分钟前
2
0
SSM整合activeMQ/activeMQ配置

一、引入依赖 <!-- xbean 如<amq:connectionFactory /> -->    <dependency>        <groupId>org.apache.xbean</groupId>        <artifactId>xbean-spring</artifac......

嘴角轻扬30
31分钟前
2
0
小公司出身的程序员,面试咋这么难?!

小公司出身,被大厂竞争者 KO 以下是一个非常真实的案例,是一个大厂工程师和一个小公司工程师同时求职一个独角兽公司的职位的经历。 一个是985本科学历,出身互联网大厂,四五年经验的样子。...

编程SHA
37分钟前
2
0
揭秘:蚂蚁金服bPaaS究竟是什么?

摘要: 分布式金融核心套件,蚂蚁金服bPaaS究竟是什么东东? 文/图 孙浩峰 去年9月,蚂蚁金服在杭州云栖ATEC发布了分布式金融核心套件bPaaS( Business Platform As a Service ),对外开放自...

阿里云官方博客
38分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部