首页手记 Java主流架构入门：基础知识与实践指南

Java主流架构入门：基础知识与实践指南

标签：

Java 架构

概述

本文深入介绍了Java主流架构入门的相关知识，包括客户端-服务器架构、分层架构、分布式架构和微服务架构等类型及其特点。文章还探讨了选择合适架构的原则与考虑因素，并通过具体示例代码和实战项目进行了详细说明，帮助读者全面了解和掌握Java主流架构入门。

Java架构概览

Java架构简介

Java架构是指在Java技术栈中构建应用程序时采用的结构和设计模式。Java架构的目标是实现高效、可扩展、可维护的应用程序。Java架构通常涵盖从网络协议到数据库访问，再到前端展示的各个层面。Java架构的设计直接影响到应用的性能、可扩展性和安全性。

Java架构主要分为客户端-服务器架构、分层架构、分布式架构和微服务架构等类型。选择合适的架构不仅能够提高应用程序的性能和可维护性，还能降低开发成本和维护成本。

Java主流架构类型及特点

客户端-服务器架构（Client-Server Architecture）
- 特点：客户端和服务器端分离，客户端负责请求处理，服务器端负责响应处理和数据存储。
- 优点：易于维护和扩展，客户端和服务器端可以独立开发和部署。
- 缺点：对网络带宽有较高要求，服务器端负载可能较高。
分层架构（Layered Architecture）
- 特点：将应用划分为多个层次，如表示层、业务逻辑层、数据访问层等。
- 优点：提高了模块化程度，简化了开发和维护。
- 缺点：增加了系统复杂性，需要更多的协调工作。
分布式架构（Distributed Architecture）
- 特点：应用分布在多个计算机上，通过网络进行通信。
- 优点：提高了系统的可伸缩性和可靠性。
- 缺点：增加了网络延迟，需要处理分布式事务和数据一致性问题。
微服务架构（Microservices Architecture）
- 特点：将应用拆分为多个小型服务，每个服务独立开发、部署和扩展。
- 优点：提高了系统的灵活性和可维护性，便于团队协作。
- 缺点：引入了大量的复杂性，如服务通信、服务发现、容错处理等。

选择合适架构的原则与考虑因素

选择合适的Java架构需要考虑以下几个因素：

应用需求：应用的规模、性能要求、响应时间等。
团队能力：团队的技术水平、经验、资源等。
维护成本：架构的复杂性、维护难度、开发周期等。
扩展性：架构是否易于扩展，是否支持水平扩展。
安全性：应用的安全性要求，如数据加密、身份认证等。

例如，对于小型应用，可以采用简单的分层架构来快速开发和部署。对于大型分布式系统，可以采用分布式架构或微服务架构来提高系统的可伸缩性和可靠性。对于需要灵活扩展的应用，可以选择微服务架构来提高系统的灵活性和可维护性。

示例代码

Java客户端-服务器架构示例

// 客户端代码
import java.io.OutputStream;
import java.io.InputStream;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 8080);
        OutputStream out = socket.getOutputStream();
        out.write("Hello Server".getBytes());
        InputStream in = socket.getInputStream();
        byte[] buffer = new byte[1024];
        in.read(buffer);
        String response = new String(buffer);
        System.out.println("Server Response: " + response);
        socket.close();
    }
}

// 服务器端代码
import java.io.OutputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        Socket socket = serverSocket.accept();
        InputStream in = socket.getInputStream();
        byte[] buffer = new byte[1024];
        int length = in.read(buffer);
        String request = new String(buffer, 0, length);
        System.out.println("Client Request: " + request);
        OutputStream out = socket.getOutputStream();
        out.write("Hello Client".getBytes());
        socket.close();
    }
}

Spring框架入门

Spring框架简介

Spring框架是一个开源的Java应用开发框架，由Rod Johnson创建。Spring框架的核心思想是依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）。Spring框架旨在简化Java企业级应用开发，降低组件间的耦合度，提高应用的可测试性和可维护性。

Spring框架的主要组件包括：

Spring Core：提供了依赖注入、IoC容器等核心特性。
Spring Web：提供了集成Web应用的支持，如MVC框架、RESTful服务等。
Spring Data：提供了对数据访问和存储的技术抽象层，支持ORM、JDBC、MongoDB等。
Spring Security：提供了安全管理功能，如身份认证、访问控制等。
Spring Boot：基于Spring框架，简化了Spring应用的开发和部署，提供了大量的自动化配置。

Spring Boot简化开发

Spring Boot旨在简化Spring应用的开发，通过提供默认配置和自动配置，使得开发人员可以快速搭建功能完整的应用。Spring Boot的核心特性包括：

自动配置：Spring Boot可以根据应用类型自动配置Spring容器中的bean。
起步依赖：通过引入特定的依赖，可以快速配置应用的依赖关系，如Web应用、JPA、Redis等。
命令行接口：Spring Boot提供了Spring CLI，可以快速创建新的Spring Boot应用。
嵌入式Servlet容器：Spring Boot集成了Tomcat、Jetty和Undertow等嵌入式Servlet容器。
内置健康检查和监控：Spring Boot提供了健康检查和监控功能，如Actuator等。

实战：Spring Boot项目搭建与配置

创建Spring Boot项目

使用Spring Initializr（https://start.spring.io/）或者Maven/Gradle模板创建一个新的Spring Boot项目。
选择相应的Maven/Gradle依赖，如Spring Web、Spring Data JPA等。
配置应用的基本信息，如Spring Boot版本、Java版本、项目名称等。
生成项目文件并导入到IDE中，如IntelliJ IDEA或Eclipse。

Hello Spring Boot示例

创建一个新的Spring Boot应用，选择Web依赖。
在src/main/java目录下创建一个新的Java类，如HelloController.java。
```
package com.example.demo;
```

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}

@RestController
class HelloController {
@GetMapping("/")
public String hello() {
return "Hello, Spring Boot!";
}
}

3. 在`src/main/resources`目录下创建一个新的配置文件，如`application.properties`。
```properties
server.port=8080

运行Spring Boot应用，访问http://localhost:8080/可以查看应用的响应。

配置数据库连接

在pom.xml中引入Spring Data JPA和H2数据库依赖。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>

在application.properties中配置数据库连接信息。

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

创建一个新的数据模型类，如User.java。
```
package com.example.demo.model;
```

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
private String email;

// 省略getter和setter方法

}

4. 创建一个新的数据访问层类，如`UserRepository.java`。
```java
package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

创建一个新的控制器类，如UserController.java。
```
package com.example.demo.controller;
```

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {
@Autowired
private UserRepository userRepository;

@GetMapping("/users")
public List<User> getUsers() {
    return userRepository.findAll();
}

}

6. 运行Spring Boot应用，访问`http://localhost:8080/users`可以查看应用的响应。

## MyBatis入门
### MyBatis基础概念
MyBatis是基于Java的持久层框架，提供了持久化对象、SQL映射和缓存机制。MyBatis的主要特性包括：

1. **XML映射文件**：通过XML文件来定义SQL语句和结果映射。
2. **动态SQL**：支持动态生成SQL语句，如条件判断、循环等。
3. **缓存机制**：支持一级缓存和二级缓存，可以提高查询性能。
4. **延迟加载**：支持对象关系的延迟加载，可以减少数据库查询次数。
5. **插件扩展**：支持通过插件扩展MyBatis的功能，如分页插件等。

### MyBatis的工作原理
MyBatis的工作原理如下：

1. **配置解析**：MyBatis解析配置文件，构建SqlSessionFactory对象。
2. **SqlSessionFactory**：SqlSessionFactory对象用于创建SqlSession对象。
3. **SqlSession**：SqlSession对象用于执行SQL语句、提交事务等。
4. **映射文件**：MyBatis通过映射文件将SQL语句映射到Java对象。
5. **缓存机制**：MyBatis通过缓存机制减少数据库查询次数，提高查询性能。
6. **动态SQL**：MyBatis通过动态SQL生成器生成SQL语句。

### 实战：使用MyBatis进行数据库操作
#### 创建MyBatis应用
1. 创建一个新的Java项目，引入MyBatis依赖。
```xml
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.23</version>
</dependency>

创建一个新的配置文件，如mybatis-config.xml。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
            <property name="username" value="root"/>
            <property name="password" value="password"/>
        </dataSource>
    </environment>
</environments>
<mappers>
    <mapper resource="com/example/demo/mapper/UserMapper.xml"/>
</mappers>
</configuration>

创建一个新的映射文件，如UserMapper.xml。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
<select id="selectUsers" resultType="com.example.demo.model.User">
    SELECT id, name, email FROM users
</select>
</mapper>

创建一个新的数据模型类，如User.java。
```
package com.example.demo.model;
```

public class User {
private Long id;
private String name;
private String email;

// 省略getter和setter方法

}

5. 创建一个新的映射接口，如`UserMapper.java`。
```java
package com.example.demo.mapper;

import com.example.demo.model.User;
import java.util.List;

public interface UserMapper {
    List<User> selectUsers();
}

创建一个新的主类，如DemoApplication.java。
```
package com.example.demo;
```

import com.example.demo.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class DemoApplication {
public static void main(String[] args) throws Exception {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
try (SqlSession session = sqlSessionFactory.openSession()) {
UserMapper mapper = session.getMapper(UserMapper.class);
List<User> users = mapper.selectUsers();
for (User user : users) {
System.out.println(user.getName());
}
}
}
}

#### 运行MyBatis应用
1. 运行`DemoApplication`类，可以查看数据库中`users`表的数据。
```java
package com.example.demo;

import com.example.demo.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class DemoApplication {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            List<User> users = mapper.selectUsers();
            for (User user : users) {
                System.out.println(user.getName());
            }
        }
    }
}

分布式架构基础

分布式系统概念

分布式系统是指由多个独立计算机组成的系统，通过网络进行通信和协调，共同完成一个任务。分布式系统的主要特点包括：

独立性：每个计算机节点独立运行，不受其他节点影响。
并行性：多个节点可以并行处理任务，提高系统的整体性能。
透明性：用户不需要关心分布式系统的内部结构，只需要使用系统的接口。
可靠性：分布式系统可以通过备份和容错机制提高系统的可靠性。
可扩展性：分布式系统可以通过增加节点来提高系统的处理能力和存储能力。

分布式架构设计原则

分布式架构设计需要遵循以下原则：

模块化：将应用划分为多个模块，每个模块负责一个特定的功能。
松耦合：模块之间尽可能松耦合，减少依赖关系。
可扩展性：设计可扩展的架构，支持水平和垂直扩展。
容错性：设计容错机制，提高系统的可靠性和可用性。
安全性：设计安全机制，保护系统的数据和资源。

实战：分布式系统简单实现

创建分布式应用

创建一个新的Java项目，引入必要的依赖。

<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.6.3</version>
</dependency>
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>4.3.0</version>
</dependency>

创建一个新的主类，如DistributedApplication.java。
```
package com.example.demo;
```

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class DistributedApplication {
public static void main(String[] args) throws Exception {
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("localhost:2181")
.sessionTimeoutMs(30000)
.retryPolicy(new ExponentialBackoffRetry(1000, 3))
.build();
client.start();
System.out.println("Distributed Application started");
}
}

3. 创建一个新的服务类，如`DataService.java`。
```java
package com.example.demo;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;

public class DataService {
    private CuratorFramework client;

    public DataService(String host, int port) throws Exception {
        client = CuratorFrameworkFactory.builder()
                .connectString(host + ":" + port)
                .sessionTimeoutMs(30000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
    }

    public void saveData(String key, String value) throws Exception {
        client.create().forPath("/data/" + key, value.getBytes());
    }

    public String getData(String key) throws Exception {
        byte[] data = client.getData().storingStatIn(null).forPath("/data/" + key);
        return new String(data);
    }
}

创建一个新的客户端类，如ClientApplication.java。
```
package com.example.demo;
```

import com.example.demo.DataService;

public class ClientApplication {
public static void main(String[] args) throws Exception {
DataService dataService = new DataService("localhost", 2181);
dataService.saveData("key1", "value1");
String value = dataService.getData("key1");
System.out.println(value);
}
}

#### 运行分布式应用
1. 运行`DistributedApplication`类，启动分布式系统。
2. 运行`ClientApplication`类，向分布式系统中写入数据，并读取数据。
```java
package com.example.demo;

import com.example.demo.DataService;

public class ClientApplication {
    public static void main(String[] args) throws Exception {
        DataService dataService = new DataService("localhost", 2181);
        dataService.saveData("key1", "value1");
        String value = dataService.getData("key1");
        System.out.println(value);
    }
}

微服务架构入门

微服务简介

微服务架构是一种将一个大型应用拆分为多个小型服务的架构模式，每个服务负责一个特定的功能。微服务架构的主要特点包括：

独立开发：每个微服务可以独立开发、部署和扩展。
轻量级通信：微服务之间通过API进行通信，通信协议简单高效。
松耦合：微服务之间尽可能松耦合，降低系统的复杂性。
可扩展性：微服务架构支持水平和垂直扩展，提高系统的灵活性。
容错性：微服务架构可以通过冗余和备份机制提高系统的可靠性。

微服务架构的优势与挑战

优势

灵活性：微服务架构可以快速响应业务变化，快速开发和部署新功能。
可扩展性：微服务架构可以独立扩展，提高系统的整体性能。
可维护性：微服务架构可以独立维护，降低系统维护成本。
可测试性：微服务架构可以独立测试，提高应用的可测试性。

挑战

复杂性：微服务架构引入了大量的复杂性，如服务发现、服务通信等。
安全性：微服务架构需要处理大量的安全问题，如身份认证、数据加密等。
运维成本：微服务架构需要处理大量的运维工作，如监控、日志、备份等。

实战：搭建第一个微服务应用

创建微服务应用

创建一个新的Java项目，引入Spring Boot依赖。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

创建一个新的主类，如DemoApplication.java。
```
package com.example.demo;
```

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}

3. 创建一个新的控制器类，如`UserController.java`。
```java
package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users")
    public String getUsers() {
        return "Hello, Microservices!";
    }
}

创建一个新的应用配置文件，如application.properties。
```
server.port=8080
```

运行微服务应用

运行DemoApplication类，启动微服务应用。
访问http://localhost:8080/users可以查看应用的响应。
```
package com.example.demo;
```

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}



## 实际案例分析与总结
### 常见Java架构项目案例分析
#### 电商系统案例
电商系统是典型的分布式系统，需要支持大量的并发访问和高可用性。以下是一些常用的架构方案：

1. **分层架构**：将系统划分为前端、后端、数据库等层次，提高系统的模块化和可维护性。
2. **分布式缓存**：使用Redis、Memcached等分布式缓存提高系统的性能和响应速度。
3. **分布式消息队列**：使用Kafka、RabbitMQ等分布式消息队列提高系统的异步处理能力。
4. **微服务架构**：将系统划分为多个独立的服务，支持水平和垂直扩展。

#### 社交平台案例
社交平台是典型的微服务系统，需要支持大量的并发访问和高可用性。以下是一些常用的架构方案：

1. **微服务架构**：将系统划分为多个独立的服务，支持水平和垂直扩展。
2. **分布式缓存**：使用Redis、Memcached等分布式缓存提高系统的性能和响应速度。
3. **分布式消息队列**：使用Kafka、RabbitMQ等分布式消息队列提高系统的异步处理能力。
4. **API网关**：使用API网关统一管理系统的API接口，提高系统的安全性。

#### 实战示例
1. **电商系统实现**
   - 创建一个简单的电商系统，包括商品展示、购物车、订单处理等功能。
   - 使用Spring Boot框架搭建应用，使用MyBatis进行数据库操作。
   - 使用Redis作为分布式缓存，提高应用的性能和响应速度。
   - 使用RabbitMQ作为分布式消息队列，实现异步处理功能。
   - 使用分层架构实现应用的模块化，提高系统的可维护性。

2. **社交平台实现**
   - 创建一个简单的社交平台，包括用户注册、登录、好友列表等功能。
   - 使用微服务架构实现应用的模块化，提高系统的灵活性和可维护性。
   - 使用Redis作为分布式缓存，提高应用的性能和响应速度。
   - 使用RabbitMQ作为分布式消息队列，实现异步处理功能。
   - 使用API网关统一管理系统的API接口，提高系统的安全性。

### 学习总结与未来发展方向
学习Java架构需要掌握以下技能：

1. **Java基础**：掌握Java语言的基本语法、面向对象编程等。
2. **Java框架**：掌握Spring、MyBatis、Hibernate等Java框架。
3. **分布式系统**：掌握分布式系统的基本概念和设计原则。
4. **微服务架构**：掌握微服务架构的设计原则和实现方法。
5. **安全性**：掌握Java应用的安全性设计和实现方法。

未来Java架构的发展方向包括：

1. **云原生**：云原生架构将成为主流，支持容器化、微服务、DevOps等技术。
2. **Serverless**：Serverless架构将成为新的趋势，支持无服务器计算和事件驱动架构。
3. **AI/ML**：AI和机器学习将成为新的热点，支持数据驱动和智能决策。

未来Java架构的学习方向包括：

1. **云原生技术**：学习云原生架构和技术，如Kubernetes、Docker、Istio等。
2. **Serverless技术**：学习Serverless架构和技术，如AWS Lambda、Azure Functions等。
3. **AI/ML技术**：学习AI和机器学习技术，如TensorFlow、Keras等。

可以通过慕课网（https://www.imooc.com/）等在线学习平台，学习这些新技术和新架构。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

月关宝盒

手记
篇

粉丝

105

获赞与收藏

673

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340913 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java主流架构入门：基础知识与实践指南

Java架构简介

Java主流架构类型及特点

选择合适架构的原则与考虑因素

示例代码

Java客户端-服务器架构示例

Spring框架简介

Spring Boot简化开发

实战：Spring Boot项目搭建与配置

创建Spring Boot项目

Hello Spring Boot示例

配置数据库连接

分布式系统概念

分布式架构设计原则

实战：分布式系统简单实现

创建分布式应用

微服务简介

微服务架构的优势与挑战

优势

挑战

实战：搭建第一个微服务应用

创建微服务应用

运行微服务应用

阅读免费教程