java Spring boot web 服务项目搭建及简单的接口实现及简单的数据库查询

首先我们用的是idea来创建springboot项目

file >>  new >> Project   然后选择maven创建。这里说一下 maven最好是配置一下阿里云的镜像，这样下的比较快。或者用自己公司的私服也行。这里就先不介绍maven怎么配置了。选一下JDK的版本，目前大家用的都是1.8的，支持好多新特性，用起来比较爽，比如枚举中可以定义静态方法等。。。

点击Next，这里是存放项目的目录，名字大家可以自己定义，需是个空文件夹。

点击finish,这时，项目就已经创建好了，目录结构如下

首先介绍一下 pom.xml文件，这个文件是整个项目的依赖配置文件，就像是 nodejs中的package.json 包版本配置文件。

配置文件中详细介绍如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>ke-address</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 此项目继承的项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
        <relativePath />
    </parent>

    <properties>
        <!-- 编码格式 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <!-- 项目的依赖结构 -->
    <!--  spring-boot-starter springboot场景启动器，帮我们导入模块-->
    <dependencies>
        <!--新增：web应用基本环境配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--  此配置注解可以省略get、set等方法定义  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--  发http请求模块-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
        <!--  处理json -->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>

    </dependencies>
    <!--  打包时的配置-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.0.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                    <!--  运行时的入口类 -->
                    <mainClass>com.KentryClass</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

大家如果感兴趣 可以深入到dependencies里面去看一下 是如何控制依赖的版本的，这也是有时不写版本号也可以的原因。

dependencies 中的依赖大家看自己需求引入就行，maven会自动帮我们将依赖下载下来。如果没有下载，大家可以点一下右边Maven中的刷新按钮

OK，现在基本配置已经介绍完了现在开始编写代码

右键，创建一个package，我起名字为com，在里面创建一个ServerEntry类，作为我们的Spring Boot的启动类。

package com;

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

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 18:24
 * @Description: com
 * @version: 1.0
 */
@SpringBootApplication
public class ServerEntry {
    public static void main(String[] args) {
        SpringApplication.run(ServerEntry.class,args);
    }
}

@SpringBootApplication  这个注解代表这是一个springBoot应用。

OK 这样我们就创建完成了一个Spring boot 应用，运行一下项目，注意，服务启动默认端口为8080，如果有其他应用已经占用了端口，服务会启动失败。接下来介绍如何修改端口号

 

在resources中创建一个application.yml，内容如下： 注意一下   :   后面是有一个空格的，不要丢了否则不生效

server:
  port: 18888

OK 重新启动项目，显示tomcat服务启动了 监听端口为18888

接下来我们创建一个webServer应用，在上面提到的pom配置文件中加入以下依赖，如果maven没有自动引入，大家记得刷新一下maven

<!--新增：web应用基本环境配置 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

接下来我们来实现一个接口 getList , 我们来创建一个controller的包，在里面创建一个GetList类

内容如下：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 18:54
 * @Description: com.controller
 * @version: 1.0
 */
@Controller
public class GetList {

    @ResponseBody
    @GetMapping(value = "/getList")
    public String getList(){

        return "拿到数据了";
    }
}

@Controller 注解大家可以了解一下

@Controller 通常是被使用服务于web 页面的。默认，你的controller方法返回的是一个string 串，是表示要展示哪个模板页面或者是要跳转到哪里去。

@RestController 就是专门用在编写API的时候，特别那种返回一个JSON，或者是XML等等。然后方法返回的是可以是一个对象，是一个可以被序列化的对象。

当然了你也可以通过controller来实现返回JSON、XML这些。只是这里为了"REST"，得另立门户，这样会更加的清晰明了。

在Spring boot中，http method可以被用类似“*Mapping”的格式来表示：

@GetMapping

@PostMapping

@PutMapping

@PatchMapping

@DeleteMapping

当然上面的咱们也可以写成

@Controller
public class GetList {

    @ResponseBody
    @RequestMapping(value = "/getList",method = RequestMethod.GET)
    public String getList(){

        return "拿到数据了";
    }
}

ok 重启一下项目，在浏览器输入http://localhost:18888/getList，如下就说明我们的接口成功了。

现在是拿到了一个字符串，那如何返回一个前端想看到的json呢，首先我们创建一个model package，然后创建一个GoodsModel类

内容如下

package com.model;

import lombok.Data;

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 19:10
 * @Description: com.model
 * @version: 1.0
 */
@Data
public class GoodsModel {
    private String name="苹果";
    private int price=80;
    private String cTime = "2021-4-1 10:22:56";
}

@Data这个注解 大家自己查查 了解一下就行，我们接着写controller

package com.controller;

import com.model.GoodsModel;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 18:54
 * @Description: com.controller
 * @version: 1.0
 */
@Controller
public class GetList {

    @ResponseBody
    @RequestMapping(value = "/getList",method = RequestMethod.GET)
    public String getList(){
        return "拿到数据了";
    }

    @ResponseBody
    @GetMapping(value = "/getGoods")
    public GoodsModel getGoods(){
        GoodsModel goodsModel = new GoodsModel();
        return goodsModel;
    }
}

重启服务，在浏览器输入http://localhost:18888/getGoods，如下就成功了。

OK 那我们如何接收前端传过来的参数呢，我们来写个场景，前端传过来一个价格price 我们将价格设置给商品并返回这个商品

先修改一下GoodsModel类，增加一下构造函数，

package com.model;

import lombok.Data;

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 19:10
 * @Description: com.model
 * @version: 1.0
 */
@Data
public class GoodsModel {
    private String name="苹果";
    private int price=80;
    private String cTime = "2021-4-1 10:22:56";
    public GoodsModel(){}
    public GoodsModel(int p){
        this.price = p;
    }
}

再来修改一下controller

@ResponseBody
    @GetMapping(value = "/getGoods")
    public GoodsModel getGoods(@RequestParam(required = true) int price){

        GoodsModel goodsModel = new GoodsModel(price);
        return goodsModel;
    }

@RequestParam 这个注解 大家可以百度查一下了解一下，用法很多。

OK  重启服务 传一下参数试试 http://localhost:18888/getGoods?price=666

OK  说明参数也没问题了。

这只是简简单单的一些用法，接收参数，定义参数的方法有很多，大家可以按自己团队要求来。

大家有没有发现返给前端的数据会有一些正确或错误的响应码，如果每个接口都去自己定义会很麻烦，我们抽取出一个公共类用来做响应数据体，这样会方便很多。

我们创建一个respData包，创建两个类

RespData类

package com.respData;

import lombok.Data;

/**
 * @Auther: Xu
 * @Date: 2021/3/30 - 03 - 30 - 16:22
 * @Description: com.respData
 * @version: 1.0
 */
@Data
public class RespData<T> {
    /**
     * 状态码 200 成功
     */
    private int code;
    /**
     * 状态消息
     */
    private String message;

    private String flag;

    private T data;

    public RespData(){}

    public RespData(RespCode respCode){
        this.code = respCode.getCode();
        this.message = respCode.getMessage();
    }

    /**
     * 这是状态码和消息
     * @param respCode
     */
    public void setCodeMsg(RespCode respCode) {
        this.code = respCode.getCode();
        this.message = respCode.getMessage();
    }

    /**
     * 设置响应消息
     */
    public void setMsg(String str){
        this.message = str;
    }
    /**
     * 设置相应体
     */
    public void setData(T data){
        this.data = data;
    }
}

RespCode类

package com.respData;

import lombok.Getter;

/**
 * @Auther: Xu
 * @Date: 2021/3/30 - 03 - 30 - 16:25
 * @Description: com.respData
 * @version: 1.0
 */
@Getter
public enum RespCode {

    SUCCESS(200,"成功"),
    FAILED(500,"失败"),
    ERROR(400,"参数错误"),
    MISCODE(400),
    ERRCODE(500);
    private int code;
    private String message;
    private int missCode=400;
    private int errCode=500;

    RespCode(int code, String msg){
        this.code = code;
        this.message = msg;
    }
    RespCode(int code){
        this.code = code;
    }
}

OK  我们再来设定一个场景， 假如前端给的价格小于200，我们返回错误，大于200 我们返回正确，继续修改controller ，注意将这两个类引入，如果配置了idea自动导包，就会自动引入了。

@ResponseBody
    @GetMapping(value = "/getGoods")
    public RespData getGoods(@RequestParam(required = true) int price){

        //创建响应体
        RespData respData = new RespData(RespCode.SUCCESS);

        GoodsModel goodsModel = new GoodsModel(price);
        if(price<200){
            respData.setCodeMsg(RespCode.FAILED);
        }
        respData.setData(goodsModel);

        return respData;
    }

重启服务，验证一下

好了 达到我们的预期了。

接下来我们看看怎么连接数据库，这里我用的mongodb ，在application.yml 配置文件中添加配置，注意空格，我们采用uri的方式

****:****代表的是用户名和密码，goodsList对应的是collection 也叫表 ，数据库具体怎么用建议大家还是系统学习一下，可以下载这个可视化工具用来管理我们的数据库

ok继续添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

正常情况我们是需要封装dao层的，但是我们架构给我们封装好了可以直接用。现在我们自己弄一下，文件结构如下：

CommentsDao类：

package com.dao;

import com.modle.GoodsModel;
import org.springframework.data.mongodb.repository.MongoRepository;

/**
 * @Auther: Xu
 * @Date: 2021/3/29 - 03 - 29 - 17:20
 * @Description: com.dao
 * @version: 1.0
 */

public interface CommentsDao extends MongoRepository<GoodsModel,String> {

}

CommentsService类

package com.dao;

import com.modle.GoodsModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @Auther: Xu
 * @Date: 2021/3/29 - 03 - 29 - 17:32
 * @Description: com.dao
 * @version: 1.0
 */

@Service
//@Transactional
public class CommentsService {
    @Autowired
    private CommentsDao commentsDao;

    public List findAll(){
        System.out.println("查询所有");
        List<GoodsModel> list = commentsDao.findAll();
        System.out.println("查询所有"+list.toString());
        return list;
    }
    public GoodsModel findById(String id){
        GoodsModel goods = commentsDao.findOne(id);
        return goods;
    }
}

接下来就可以在controller中使用了，将CommentsService 导入

package com.controller;

import com.dao.CommentsService;
import com.model.GoodsModel;
import com.respData.RespCode;
import com.respData.RespData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Auther: Xu
 * @Date: 2021/4/1 - 04 - 01 - 18:54
 * @Description: com.controller
 * @version: 1.0
 */
@Controller
public class GetList {

    @Autowired
    private CommentsService commentsService;
    
    @ResponseBody
    @RequestMapping(value = "/getList",method = RequestMethod.GET)
    public String getList(){
        return "拿到数据了";
    }

    @ResponseBody
    @GetMapping(value = "/getGoods")
    public RespData getGoods(@RequestParam(required = true) int price){

        //创建响应体
        RespData respData = new RespData(RespCode.SUCCESS);


        List<GoodsModel> listAll = commentsService.findAll();
        respData.setData(listAll);
        
        return respData;
    }
}

其中的注解 大家百度查一下吧，最好点进去追踪一下原理

OK  这样就将数据查出来了。

在服务没停就关闭了idea，这时在打开idea重新启动服务的时候会发现端口被占用，下面是处理方式

感觉像是注解约定编程了，不过确实方便了很多