首页手记 JAVA主流架构教程：初学者必备指南

JAVA主流架构教程：初学者必备指南

标签：

Java

概述

本文介绍了Java主流架构模式及其应用，包括MVC、微服务、SOA和事件驱动架构等，并详细讲解了Spring框架、MyBatis基础操作、设计模式以及实战案例。通过这些内容，读者可以全面了解和掌握Java架构开发的关键技术和实践方法，为开发高效稳定的Java应用奠定坚实基础。

引入JAVA主流架构

在现代软件开发过程中，Java由于其平台无关性、安全性、稳定性和丰富的库支持，成为了许多企业级应用的首选编程语言。Java架构是指通过特定的设计模式和框架来组织、构建和维护Java应用程序的方法。以下是一些常用的Java架构模式及其优点和应用场景。

常用JAVA架构模式

MVC（Model-View-Controller）模式
- 简介：MVC是一种常用的设计模式，用于分离应用程序的不同组成部分。模型（Model）负责业务逻辑，视图（View）负责展示用户界面，控制器（Controller）负责控制用户输入并调用模型进行处理。
- 优点：使得代码更清晰，易于维护和扩展。
- 应用场景：Web应用开发，特别是需要前端和后端分离的场景。
- 示例代码：
```
package com.example.mvc;

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

@RestController
public class HelloController {

 @GetMapping("/hello")
 public String hello() {
     return "Hello, World!";
 }
}
```

微服务架构

简介：微服务架构是一种将大型应用拆分成多个小型独立服务的设计方法。每个服务负责一个特定的功能，可以独立开发、测试、部署和扩展。
优点：提高了应用的灵活性和可维护性，便于进行自动化测试和部署。
应用场景：大型分布式系统，需要高可用性和可伸缩性的场景。

示例代码：

package com.example.microservices;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

SOA（面向服务架构）

简介：SOA是一种将应用程序的不同功能单元通过接口进行连接的架构风格。每个功能单元都是一个服务，可以被其他服务或其他应用程序调用。
优点：提高了应用程序的灵活性和可重用性。
应用场景：企业内部系统集成、ERP系统等。

示例代码：

package com.example.soa;

public class ServiceA {
 public String serviceA() {
     return "Service A";
 }
}

public class ServiceB {
 public String serviceB() {
     return "Service B";
 }
}

public class ServiceConsumer {
 public String consumeServiceA() {
     ServiceA serviceA = new ServiceA();
     return serviceA.serviceA();
 }

 public String consumeServiceB() {
     ServiceB serviceB = new ServiceB();
     return serviceB.serviceB();
 }
}

事件驱动架构

简介：事件驱动架构是一种响应事件驱动的应用程序设计方式，系统中不同的组件根据接收到的事件进行响应。
优点：简化了应用程序的实现，提高了系统的响应速度。
应用场景：实时处理系统、物联网、金融交易系统等。

示例代码：

package com.example.eventdriven;

import java.util.EventListener;
import java.util.EventObject;
import java.util.ArrayList;
import java.util.List;

public interface EventListener {
 void handleEvent(EventObject event);
}

public class EventSource {
 private List<EventListener> listeners = new ArrayList<>();

 public void addEventListener(EventListener listener) {
     listeners.add(listener);
 }

 public void fireEvent(String event) {
     for (EventListener listener : listeners) {
         listener.handleEvent(new EventObject(event));
     }
 }
}

public class EventListenerExample {
 public static void main(String[] args) {
     EventSource eventSource = new EventSource();

     EventListener listener1 = event -> System.out.println("Listener 1 received event: " + event);
     EventListener listener2 = event -> System.out.println("Listener 2 received event: " + event);

     eventSource.addEventListener(listener1);
     eventSource.addEventListener(listener2);

     eventSource.fireEvent("Test event");
 }
}

了解主流架构的优点和应用场景

MVC模式：适用于构建复杂的用户界面，特别是需要前端和后端分离的Web应用。例如，使用Spring MVC框架构建的电商网站。
微服务架构：适用于构建大型分布式系统，需要高可用性和可伸缩性的场景。例如，使用Spring Boot和Spring Cloud构建的在线购物平台。
SOA：适用于企业内部系统集成，如ERP系统或大型企业系统。例如，使用Web服务技术实现的企业内部系统集成。
事件驱动架构：适用于需要实时处理的系统，例如金融交易系统或物联网系统。例如，使用Apache Kafka构建的实时数据处理系统。

Spring框架详解

Spring框架简介

Spring是一个开源的Java平台相关的企业级应用程序的开发框架。它通过提供一系列的特性，如依赖注入、面向切面编程、数据访问和事务管理等，简化了企业应用开发，提高了开发效率和代码可维护性。

Spring Boot快速入门

Spring Boot是Spring的子项目，提供了一种快速构建独立的、基于生产级的Spring应用的方式。它通过自动配置和约定优于配置的原则，使得开发者可以快速启动项目。

快速搭建一个Spring Boot应用

创建一个新的Spring Boot项目：
- 使用Spring Initializr或者Maven来创建新的Spring Boot项目。
- 例如，使用Spring Initializr创建一个简单的Web应用。

编写控制器（Controller）：

创建一个简单的控制器类，用于处理Web请求。

示例代码：

package com.example.demo;

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

@RestController
public class HelloController {

 @GetMapping("/hello")
 public String hello() {
     return "Hello, World!";
 }
}

运行Spring Boot应用：

使用Maven或Gradle构建并运行应用。

示例代码（Maven）：

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.4</version>
</parent>
<dependencies>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>
<build>
 <plugins>
     <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
     </plugin>
 </plugins>
</build>

Spring Cloud基础配置

Spring Cloud是一个基于Spring Boot构建的微服务框架，它提供了在分布式系统（如配置管理、服务发现、断路器、路由、微服务批量等）中实现基本操作的工具。

使用Spring Cloud配置服务发现

引入Spring Cloud依赖：

在项目中添加Spring Cloud Starter Eureka依赖。

示例代码：

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

配置Eureka服务注册中心：

配置文件application.yml：

server:
port: 8761
eureka:
instance:
 hostname: localhost
client:
 registerWithEureka: false
 fetchRegistry: false
 serviceUrl:
   defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

配置服务提供者和服务消费者：

服务提供者：

package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

服务消费者：

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

通过以上步骤，可以快速搭建一个基于Spring Cloud的服务发现和注册中心，实现服务的自动注册和发现。

MyBatis基础教程

MyBatis工作原理

MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis的核心组件包括SqlSessionFactory、SqlSession和Mapper接口。

SqlSessionFactory：用于创建SqlSession对象，它是线程不安全的，因此需要为每个线程创建一个新的SqlSessionFactory对象。
SqlSession：用于执行SQL语句并返回结果，可以执行增删改查操作。
Mapper接口：定义了SQL语句的映射，通过接口方法调用执行。

MyBatis环境搭建与基本操作

环境搭建：

添加MyBatis和数据库驱动依赖。
配置数据库连接信息。

示例代码（Maven）：

<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.25</version>
</dependency>

配置MyBatis配置文件：

配置数据库连接信息、映射文件位置等。

示例代码（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/mybatis/UserMapper.xml"/>
 </mappers>
</configuration>

编写映射文件：

定义SQL语句和对应的Java对象映射。

示例代码（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.mybatis.UserMapper">
 <select id="selectUser" resultType="com.example.mybatis.User">
     SELECT id, username, email FROM user WHERE id = #{id}
 </select>
</mapper>

编写Mapper接口：

定义SQL语句的映射方法。

示例代码：

package com.example.mybatis;

import java.util.List;

public interface UserMapper {
 User selectUser(int id);
 List<User> selectAllUsers();
}

编写业务代码：

使用SqlSessionFactory和SqlSession执行SQL语句。

示例代码：

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisExample {
 public static void main(String[] args) throws Exception {
     String resource = "mybatis-config.xml";
     SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
     SqlSession session = factory.openSession();
     UserMapper mapper = session.getMapper(UserMapper.class);
     User user = mapper.selectUser(1);
     System.out.println(user);
 }
}

MyBatis高级特性介绍

缓存：MyBatis支持一级缓存（SqlSession缓存）和二级缓存（Mapper级别的缓存）。
动态SQL：使用MyBatis的动态SQL标签（如<if>、<choose>等）构建复杂的SQL语句。
关联映射：处理多对一、一对多等关联关系。
自动映射：MyBatis可以自动将数据库表字段映射到Java对象属性，减少手动编写映射的繁琐工作。
插件：通过插件扩展MyBatis功能，例如分页插件。

使用MyBatis构建一个简单的RESTful服务

引入Spring Boot和MyBatis依赖：

在项目中添加Spring Boot和MyBatis Starter依赖。

示例代码（Maven）：

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>2.1.4</version>
</dependency>

配置MyBatis：

配置数据库连接信息，映射文件位置等。

示例代码（application.yml）：

spring:
datasource:
 url: jdbc:mysql://localhost:3306/mydb
 username: root
 password: password
 driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
mapper-locations: classpath:mapper/*.xml

编写Mapper接口和映射文件：

定义SQL语句和对应的Java对象映射。

示例代码（UserMapper.java）：

package com.example.webapp.mapper;

import com.example.webapp.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {
 @Select("SELECT * FROM user WHERE id = #{id}")
 User getUserById(int id);
}

编写业务代码：

使用Spring Boot的自动配置特性，注入Mapper接口并执行SQL语句。

示例代码（UserController.java）：

package com.example.webapp.controller;

import com.example.webapp.mapper.UserMapper;
import com.example.webapp.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

 @Autowired
 private UserMapper userMapper;

 @GetMapping("/user/{id}")
 public User getUserById(@PathVariable int id) {
     return userMapper.getUserById(id);
 }
}

设计模式与JAVA架构

常见设计模式简介

单例模式：

简介：确保一个类只有一个实例，并提供一个全局访问点。
应用场景：例如，数据库连接池、日志记录等。

示例代码：

public class Singleton {
 private static volatile Singleton instance;

 private Singleton() {}

 public static Singleton getInstance() {
     if (instance == null) {
         synchronized (Singleton.class) {
             if (instance == null) {
                 instance = new Singleton();
             }
         }
     }
     return instance;
 }
}

工厂模式：

简介：定义一个创建对象的接口，让子类决定实例化哪一个类。
应用场景：例如，创建不同类型的数据库连接对象。

示例代码：

public interface DatabaseConnection {
 void connect();
}

public class MySQLDatabase implements DatabaseConnection {
 @Override
 public void connect() {
     System.out.println("Connecting to MySQL database");
 }
}

public class OracleDatabase implements DatabaseConnection {
 @Override
 public void connect() {
     System.out.println("Connecting to Oracle database");
 }
}

public class DatabaseConnectionFactory {
 public static DatabaseConnection createDatabaseConnection(String type) {
     if ("mysql".equalsIgnoreCase(type)) {
         return new MySQLDatabase();
     } else if ("oracle".equalsIgnoreCase(type)) {
         return new OracleDatabase();
     }
     return null;
 }
}

观察者模式：

简介：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。
应用场景：例如，日志系统、事件监听器等。

示例代码：

import java.util.ArrayList;
import java.util.List;

public interface EventListener {
 void handleEvent(String event);
}

public class EventSource {
 private List<EventListener> listeners = new ArrayList<>();

 public void addEventListener(EventListener listener) {
     listeners.add(listener);
 }

 public void fireEvent(String event) {
     for (EventListener listener : listeners) {
         listener.handleEvent(event);
     }
 }
}

public class EventListenerExample {
 public static void main(String[] args) {
     EventSource eventSource = new EventSource();

     EventListener listener1 = event -> System.out.println("Listener 1 received event: " + event);
     EventListener listener2 = event -> System.out.println("Listener 2 received event: " + event);

     eventSource.addEventListener(listener1);
     eventSource.addEventListener(listener2);

     eventSource.fireEvent("Test event");
 }
}

适配器模式：

简介：将一个类的接口转换成客户端所期望的接口，使原本接口不兼容的类可以一起工作。
应用场景：例如，将不同的数据库驱动程序适配成统一的接口。

示例代码：

public interface OldDatabase {
 void connect();
}

public class OldMySQL implements OldDatabase {
 @Override
 public void connect() {
     System.out.println("Connecting to old MySQL database");
 }
}

public interface NewDatabase {
 void connect();
}

public class NewMySQL implements NewDatabase {
 @Override
 public void connect() {
     System.out.println("Connecting to new MySQL database");
 }
}

public class DatabaseAdapter implements NewDatabase {
 private OldDatabase oldDatabase;

 public DatabaseAdapter(OldDatabase oldDatabase) {
     this.oldDatabase = oldDatabase;
 }

 @Override
 public void connect() {
     oldDatabase.connect();
 }
}

public class AdapterExample {
 public static void main(String[] args) {
     OldDatabase oldDatabase = new OldMySQL();
     NewDatabase newDatabase = new DatabaseAdapter(oldDatabase);

     newDatabase.connect();
 }
}

设计模式在JAVA架构中的应用

单例模式在Java中的应用：

例如，使用线程安全的单例模式创建数据库连接池对象。

示例代码：

public class Singleton {
 private static volatile Singleton instance;

 private Singleton() {}

 public static Singleton getInstance() {
     if (instance == null) {
         synchronized (Singleton.class) {
             if (instance == null) {
                 instance = new Singleton();
             }
         }
     }
     return instance;
 }
}

工厂模式在Java中的应用：

例如，创建不同类型的数据库连接对象。

示例代码：

public interface DatabaseConnection {
 void connect();
}

public class MySQLDatabase implements DatabaseConnection {
 @Override
 public void connect() {
     System.out.println("Connecting to MySQL database");
 }
}

public class OracleDatabase implements DatabaseConnection {
 @Override
 public void connect() {
     System.out.println("Connecting to Oracle database");
 }
}

public class DatabaseConnectionFactory {
 public static DatabaseConnection createDatabaseConnection(String type) {
     if ("mysql".equalsIgnoreCase(type)) {
         return new MySQLDatabase();
     } else if ("oracle".equalsIgnoreCase(type)) {
         return new OracleDatabase();
     }
     return null;
 }
}

观察者模式在Java中的应用：

例如，实现一个简单的事件监听器。

示例代码：

import java.util.ArrayList;
import java.util.List;

public interface EventListener {
 void handleEvent(String event);
}

public class EventSource {
 private List<EventListener> listeners = new ArrayList<>();

 public void addEventListener(EventListener listener) {
     listeners.add(listener);
 }

 public void fireEvent(String event) {
     for (EventListener listener : listeners) {
         listener.handleEvent(event);
     }
 }
}

public class EventListenerExample {
 public static void main(String[] args) {
     EventSource eventSource = new EventSource();

     EventListener listener1 = event -> System.out.println("Listener 1 received event: " + event);
     EventListener listener2 = event -> System.out.println("Listener 2 received event: " + event);

     eventSource.addEventListener(listener1);
     eventSource.addEventListener(listener2);

     eventSource.fireEvent("Test event");
 }
}

使用设计模式优化架构结构

提高代码的复用性：例如，使用工厂模式创建不同类型的对象，避免重复代码。
降低代码的耦合性：例如，使用适配器模式将不同接口的对象适配成统一的接口。
提高代码的可维护性：例如，使用观察者模式将对象间的依赖关系解耦，便于维护和扩展。

实战案例

构建一个简单的WEB应用

创建一个新的Spring Boot项目：
- 使用Spring Initializr或者Maven创建一个新的Spring Boot项目。
- 示例代码（Maven）：
```
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```

编写控制器（Controller）：

创建一个简单的控制器类，用于处理Web请求。

示例代码：

package com.example.webapp;

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

@RestController
public class HelloController {

 @GetMapping("/")
 public String hello() {
     return "Hello, World!";
 }
}

使用Spring Boot和MyBatis开发RESTful服务

引入Spring Boot和MyBatis依赖：

在项目中添加Spring Boot和MyBatis Starter依赖。

示例代码（Maven）：

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>2.1.4</version>
</dependency>

配置MyBatis：

配置数据库连接信息，映射文件位置等。

示例代码（application.yml）：

spring:
datasource:
 url: jdbc:mysql://localhost:3306/mydb
 username: root
 password: password
 driver-class-name: com.mysql.cj.jdbc.Driver
mybatis:
mapper-locations: classpath:mapper/*.xml

编写Mapper接口和映射文件：

定义SQL语句和对应的Java对象映射。

示例代码（UserMapper.java）：

package com.example.webapp.mapper;

import com.example.webapp.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {
 @Select("SELECT * FROM user WHERE id = #{id}")
 User getUserById(int id);
}

编写业务代码：

使用Spring Boot的自动配置特性，注入Mapper接口并执行SQL语句。

示例代码（UserController.java）：

package com.example.webapp.controller;

import com.example.webapp.mapper.UserMapper;
import com.example.webapp.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

 @Autowired
 private UserMapper userMapper;

 @GetMapping("/user/{id}")
 public User getUserById(@PathVariable int id) {
     return userMapper.getUserById(id);
 }
}

构建微服务架构示例

创建一个新的Spring Boot项目：
- 使用Spring Initializr或者Maven创建一个新的Spring Boot项目，并添加Spring Cloud Starter Eureka依赖。
- 示例代码（Maven）：
```
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
```

配置Eureka服务注册中心：

配置Eureka服务注册中心的配置文件。

示例代码（application.yml）：

server:
port: 8761
eureka:
instance:
 hostname: localhost
client:
 registerWithEureka: false
 fetchRegistry: false
 serviceUrl:
   defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

创建服务提供者和服务消费者：

服务提供者：

package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

服务消费者：

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

通过以上步骤，可以构建一个简单的微服务架构，实现服务的自动注册和发现。

总结与展望

JAVA主流架构学习总结

通过本教程的学习，我们了解了Java主流架构模式及其应用，包括Spring框架的使用、MyBatis的基本操作和高级特性、设计模式在Java架构中的应用等。这些知识和技能对于开发企业级Java应用非常重要。

个人项目实践建议

在实际项目开发中，可以根据项目需求选择合适的架构模式和技术栈。通过实践项目，不仅可以加深对理论知识的理解，还可以提升实际开发能力。

JAVA架构未来发展趋势

随着技术的发展，Java架构也在不断演进。未来的Java架构可能会更加关注微服务的全面管理和自动化运维，以及与云原生技术的结合。例如，使用Kubernetes、Docker等容器技术实现更灵活的服务部署和管理。

通过不断学习和实践，相信你能够更好地掌握Java架构开发，开发出高效、稳定的企业级应用。希望本教程对你有所帮助，祝你学习顺利！

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

蝴蝶不菲

手记
篇

粉丝

81

获赞与收藏

381

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340953 3155

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

JAVA主流架构教程：初学者必备指南

常用JAVA架构模式

了解主流架构的优点和应用场景

Spring框架简介

Spring Boot快速入门

快速搭建一个Spring Boot应用

Spring Cloud基础配置

使用Spring Cloud配置服务发现

MyBatis工作原理

MyBatis环境搭建与基本操作

MyBatis高级特性介绍

使用MyBatis构建一个简单的RESTful服务

常见设计模式简介

设计模式在JAVA架构中的应用

使用设计模式优化架构结构

构建一个简单的WEB应用

使用Spring Boot和MyBatis开发RESTful服务

构建微服务架构示例

JAVA主流架构学习总结

个人项目实践建议

JAVA架构未来发展趋势

阅读免费教程