SpringBoot聚合工程的部署与深入讲解

什么是SpringBoot聚合工程？

SpringBoot聚合工程是指在一个工程中集成了多个模块，每个模块都是一个独立的SpringBoot项目。这些模块可以共享公共的代码和资源，同时也可以单独部署和运行。SpringBoot聚合工程的好处在于将多个关联的应用程序组合在一起，简化了项目的部署、维护和扩展。

如何创建SpringBoot聚合工程？

在创建SpringBoot聚合工程时，我们需要使用SpringBoot的Maven插件来创建一个父工程，然后再在其中创建多个子模块。以下是创建SpringBoot聚合工程的步骤：

打开Maven的POM文件，使用标签<packaging>pom</packaging>指定当前项目为父工程。

<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
    <module>module1</module>
    <module>module2</module>
</modules>

创建子模块，注意要在父工程的目录下创建子模块的目录。

mkdir module1
cd module1
mvn archetype:generate -DgroupId=com.example -DartifactId=module1 -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在子模块的POM中引入SpringBoot依赖。同时可以将公共的依赖放到父工程中，子模块可以通过继承来实现代码复用。

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

如何部署SpringBoot聚合工程？

在部署SpringBoot聚合工程时，我们需要先将父工程打包，然后部署各个子模块的jar包。以下是部署SpringBoot聚合工程的步骤：

在父工程的目录下执行mvn clean install命令，将父工程打包成一个jar包。

mvn clean install

进入每个子模块的目录，执行mvn clean package命令，将每个子模块打成独立的jar包。

cd module1
mvn clean package

使用java -jar命令启动每个子模块的jar文件。

java -jar module1/target/module1-1.0-SNAPSHOT.jar

示例一

我们现在要实现一个简单的blog系统，包含文章管理和用户管理两个模块，每个模块都是一个独立的SpringBoot项目。我们可以将这两个模块放到一个SpringBoot聚合工程中，以下是具体的步骤：

创建父工程。

mkdir blog
cd blog
mvn archetype:generate -DgroupId=com.example -DartifactId=blog -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在父工程的POM文件中指定子模块。

<modules>
    <module>article</module>
    <module>user</module>
</modules>

创建文章模块和用户模块。

cd blog
mkdir article
cd article
mvn archetype:generate -DgroupId=com.example.article -DartifactId=article -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

cd ../blog
mkdir user
cd user
mvn archetype:generate -DgroupId=com.example.user -DartifactId=user -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在每个子模块的POM中引入SpringBoot依赖。

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

分别在每个子模块的src/main/java目录下创建入口类，并在每个类上加上@SpringBootApplication注解。

@SpringBootApplication
public class ArticleApplication {

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

在每个子模块的src/main/resources目录下创建配置文件application.yml，配置数据库连接等信息。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db_article
    username: root
    password: root

在每个子模块的src/main/java目录下创建相应的Controller和Service类。

@RestController
@RequestMapping("/api/article")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @GetMapping("/{id}")
    public Article get(@PathVariable long id) {
        return articleService.getById(id);
    }
}

@Service
public class ArticleService {

    @Autowired
    private ArticleRepository articleRepository;

    public Article getById(long id) {
        return articleRepository.getOne(id);
    }
}

打包并运行

cd article
mvn clean package
cd ../user
mvn clean package
java -jar article/target/article-1.0-SNAPSHOT.jar
java -jar user/target/user-1.0-SNAPSHOT.jar

以上步骤就完成了一个简单的blog系统的创建和部署，我们可以通过访问不同的url来调用不同的模块。

示例二

在聚合工程中，一个子模块也可以作为另一个子模块的依赖，以实现代码复用和依赖管理的功能。下面我们以创建一个简单的用户认证系统为例，演示如何实现子模块之间的依赖管理。

创建父工程。

mkdir auth
cd auth
mvn archetype:generate -DgroupId=com.example -DartifactId=auth -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

在父工程的POM文件中指定子模块。

<modules>
    <module>auth-server</module>
    <module>auth-client</module>
</modules>

创建服务端和客户端模块。

cd auth
mkdir auth-server
cd auth-server
mvn archetype:generate -DgroupId=com.example.server -DartifactId=auth-server -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

cd ../auth
mkdir auth-client
cd auth-client
mvn archetype:generate -DgroupId=com.example.client -DartifactId=auth-client -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

关闭掉auth-client模块的入口类的自动运行功能，因为它是一个库模块，不需要运行入口类。

<build>
    <defaultGoal>install</defaultGoal>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                    <configuration>
                        <skip>true</skip>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

在服务端模块的POM文件中引入auth-client模块的依赖。

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>auth-client</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

在服务端模块的src/main/java目录下创建Controller和Service类。

@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public String login(@RequestBody User user) {
        if (userService.login(user.getUsername(), user.getPassword())) {
            return "success";
        } else {
            return "failure";
        }
    }
}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public boolean login(String username, String password) {
        User user = userMapper.getByUsername(username);
        if (user != null && user.getPassword().equals(password)) {
            return true;
        } else {
            return false;
        }
    }
}

在客户端模块的POM文件中引入auth-client模块的依赖。

<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>auth-client</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

在客户端模块的src/main/java目录下创建Controller类，并在Controller中调用服务端提供的API。

@RestController
@RequestMapping("/api")
public class AuthController {

    @Autowired
    private AuthClient authClient;

    @PostMapping("/login")
    public String login(@RequestBody User user) {
        return authClient.login(user);
    }
}

在auth-client模块的src/main/java目录下创建AuthClient接口，并在接口上加上@FeignClient注解来指定服务端的地址。

@FeignClient(name = "auth-server", url = "http://localhost:8080")
public interface AuthClient {

    @PostMapping("/api/user/login")
    String login(@RequestBody User user);
}

打包并运行

cd auth-server
mvn clean package
cd ../auth-client
mvn clean install
cd ../auth-server
mvn clean package
java -jar auth-server/target/auth-server-1.0-SNAPSHOT.jar
java -jar auth-client/target/auth-client-1.0-SNAPSHOT.jar

以上步骤我们成功实现了一个简单的用户认证系统，其中客户端模块通过@FeignClient注解来调用服务端模块的API，实现了子模块之间的依赖管理和代码复用。

阅读剩余 84%

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：springboot聚合工程的部署与深入讲解 - Python技术站

springboot聚合工程的部署与深入讲解

SpringBoot聚合工程的部署与深入讲解

什么是SpringBoot聚合工程？

如何创建SpringBoot聚合工程？

如何部署SpringBoot聚合工程？

示例一

示例二

相关文章

分享到: