运用springboot搭建并部署web项目的示例

下面是运用Spring Boot搭建并部署web项目的完整攻略，包含两个示例。

1. 搭建Spring Boot项目

1.1 安装Maven

首先，我们需要安装Maven，来管理项目依赖和构建。安装方法可以参考Maven官方文档。

1.2 创建Spring Boot项目

使用Maven创建一个Spring Boot项目，可以先在命令行中执行以下命令：

$ mvn archetype:generate -DgroupId=com.example -DartifactId=myproject -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

这会创建一个名为“myproject”的项目，其中已经包含了一个简单的Spring Boot应用程序的基本结构。

1.3 编写Controller类

在src/main/java/com/example/myproject包中，创建一个名为“GreetingController”的类，代码如下：

package com.example.myproject;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @RequestMapping("/greeting")
    public String greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        return "Hello, " + name + "!";
    }
}

1.4 编写应用程序主类

在src/main/java/com/example/myproject包中创建一个名为“Application”的类，作为应用程序的主类，并添加以下内容：

package com.example.myproject;

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

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

1.5 运行应用程序

确保在项目根目录下执行以下命令：

$ mvn spring-boot:run

这将启动应用程序，并在浏览器中访问http://localhost:8080/greeting?name=User。你会看到“Hello, User!”的输出。

2. 部署Spring Boot项目

2.1 配置War插件

默认情况下，Spring Boot应用是作为独立的可执行jar包运行的。但是，为了能够部署到应用服务器（如Tomcat），我们需要将其打包成一个war包。为此，我们需要在项目的pom.xml文件中添加以下内容：

<packaging>war</packaging>

同时，我们还需要在pom.xml的build节点中添加以下内容：

<plugins>
    <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
    <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
    </plugin>
</plugins>

这会配置Maven来支持War打包。

2.2 打包并部署

打包

执行以下命令打包项目：

$ mvn clean package

这将生成“myproject-0.0.1-SNAPSHOT.war”文件。

部署

将“myproject-0.0.1-SNAPSHOT.war”文件复制到Tomcat的webapps目录下，并启动Tomcat服务器。接着，在浏览器中访问：http://localhost:8080/myproject-0.0.1-SNAPSHOT/greeting?name=User。你将看到“Hello, User!”的输出。

示例一

介绍如何开发一个Spring Boot中的Web应用程序，该程序通过REST服务与客户端进行通信。

1. 创建Spring Boot项目

$ mvn archetype:generate -DgroupId=com.example -DartifactId=rest-service -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

2. 安装所需依赖

在pom.xml文件中添加以下依赖：

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

3. 创建一个Controller类

在src/main/java/com/example/restservice目录下创建一个名为“GreetingController”的类，具体代码如下：

package com.example.restservice;

import java.util.concurrent.atomic.AtomicLong;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @RequestMapping("/greeting")
    public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }
}

4. 定义一个POJO

在src/main/java/com/example/restservice目录下创建一个名为“Greeting”的POJO类，具体代码如下：

package com.example.restservice;

public class Greeting {
    private final long id;
    private final String content;

    public Greeting(long id, String content) {
        this.id = id;
        this.content = content;
    }

    public long getId() {
        return id;
    }

    public String getContent() {
        return content;
    }
}

5. 运行应用程序

$ mvn spring-boot:run

在浏览器中访问http://localhost:8080/greeting?name=User。你会看到“Hello, User!”的输出。

示例二

介绍如何使用Spring Boot和JDBC来访问数据库，并展示如何编写一个具有REST API的简单Web应用程序。

1. 创建Spring Boot项目

$ mvn archetype:generate -DgroupId=com.example -DartifactId=jdbc-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

2. 安装所需依赖

在pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

3. 配置数据库

在application.properties文件中添加以下内容：

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

其中，“mydatabase”是您要连接的实际数据库。

4. 创建DAO

在src/main/java/com/example/jdbcdemo目录下创建一个名为“Customer”的POJO类，同时创建一个名为“CustomerDAO”的接口和一个名为“JdbcCustomerDAO”的实现类（实现JdbcTemplate来访问数据库），代码如下：

package com.example.jdbcdemo;

public class Customer {
    private long id;
    private String firstName;
    private String lastName;

    public Customer() {}

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    // getters/setters省略
}

public interface CustomerDAO {
    List<Customer> list();
    void create(Customer customer);
    void delete(long id);
}

@Repository
public class JdbcCustomerDAO implements CustomerDAO {

    private JdbcTemplate jdbcTemplate;

    @Autowired
    public JdbcCustomerDAO(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public List<Customer> list() {
        String sql = "SELECT id, first_name, last_name FROM customers";
        List<Customer> customers = new ArrayList<>();
        jdbcTemplate.query(sql, (rs, rowNum) -> new Customer(rs.getLong("id"), rs.getString("first_name"), rs.getString("last_name")))
                .forEach(customer -> customers.add(customer));
        return customers;
    }

    @Override
    public void create(Customer customer) {
        String sql = "INSERT INTO customers (first_name, last_name) VALUES (?, ?)";
        jdbcTemplate.update(sql, customer.getFirstName(), customer.getLastName());
    }

    @Override
    public void delete(long id) {
        String sql = "DELETE FROM customers WHERE id = ?";
        jdbcTemplate.update(sql, id);
    }
}

5. 创建Controller

在src/main/java/com/example/jdbcdemo目录下创建一个名为“CustomerController”的类，代码如下：

package com.example.jdbcdemo;

@RestController
@RequestMapping("/customers")
public class CustomerController {

    private final CustomerDAO dao;

    @Autowired
    CustomerController(CustomerDAO dao) {
        this.dao = dao;
    }

    @GetMapping("/")
    public List<Customer> listCustomers() {
        return dao.list();
    }

    @PostMapping("/")
    public void createCustomer(@RequestBody Customer customer) {
        dao.create(customer);
    }

    @DeleteMapping("/{id}")
    public void deleteCustomer(@PathVariable long id) {
        dao.delete(id);
    }
}

6. 运行应用程序

$ mvn spring-boot:run

在浏览器中访问http://localhost:8080/customers。你将看到一个空白数组，因为没有客户数据。接着，在Postman中发送POST请求，调用createCustomer方法，请求数据如下：

{
    "firstName" : "John",
    "lastName" : "Doe"
}

然后，在Postman中发送GET请求，调用listCustomers方法，你将看到添加的客户列表。