Spring boot 项目结构介绍and实现基础增删改查功能

CV工程师!!

已于 2023-08-08 18:13:19 修改

阅读量355

点赞数 1

于 2023-08-08 18:12:54 首次发布

本文链接：https://blog.csdn.net/m0_65607651/article/details/132171684

版权

JAVA 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

最近开始入坑java 在这简单纪录一下进度有啥不对请斧正 (第一次写)

一. 搭建项目

搭建springboot项目
笔者是从maven项目开始搭建的，然后手打成springboot项目，其实二者区别就是依赖的建立问题，maven项目的依赖是空的，springboot在创建的过程中有勾选的选项，就不用手动输入依赖了这一步大家就看看其他博主吧照猫画虎吧

项目结构 :(我也是第一次写不知道大家伙都一样不一样)

MyBatis Mapper 接口 com.umbra.mapper.TestMapper：在这个接口中，定义了对数据库进行操作的方法。你可以在这里声明各种查询、插入、更新和删除方法，并使用 MyBatis 的注解来编写 SQL 查询语句。

MyBatis XML 配置文件 resources/mapper/TestMapper.xml：这个文件用于存放 MyBatis Mapper 接口中定义的方法对应的 SQL 查询语句。你可以在这里使用 XML 格式编写 SQL 查询语句，通过 select, insert, update 和 delete 标签来定义对应的 SQL 操作。

在 Model 层的 Test 类中，你需要定义与数据库表对应的字段，并提供相应的 getter 和 setter 方法使用了 Lombok 注解 @Data 来自动生成 getter 和 setter 方法，简化了代码的书写。同时，我们使用了 @ApiModel 和 @ApiModelProperty 注解来为类和属性添加描述信息，这对于生成 API 文档非常有用

Service 层接口 com.umbra.service.TestService：在这个接口中，定义了业务逻辑的接口。你可以在这里声明各种业务逻辑的方法，然后在实现类中实现具体的业务逻辑。在 Service 层中，通常会调用 MyBatis Mapper 接口中的方法来访问数据库，并进行业务逻辑的处理。

Service 层实现类 com.umbra.service.impl.TestServiceImpl：在这个类中，你需要实现 Service 层接口中定义的方法，并在方法中调用 MyBatis Mapper 接口中的方法来访问数据库，然后进行业务逻辑的处理。在这个实现类中，你可以使用 @Autowired 注解来自动注入 MyBatis Mapper 接口的实例。

Controller 层 com.umbra.controller.TestController：在这个类中，定义了各个接口的访问入口。你可以使用 Spring 的注解来定义接口方法，例如 @GetMapping、@PostMapping 等。在接口方法中，你可以调用 Service 层的方法来获取数据，并将数据返回给前端。

总的来说，MyBatis Mapper 接口负责与数据库进行交互，Service 层负责处理业务逻辑，Controller 层负责定义接口和数据交互。通过这样的分层架构，可以使代码更加清晰、模块化，并方便维护和扩展。

最重要的是搭建

controller（控制层）,

mapper（接口层）,

service（数据服务接口层）Service Implements(数据服务接口实现层),

entity 我这里是model（实体层）四个包，

然后还有1. templates(视图模板目录用于存放jsp、thymeleaf等模板文件)，2. static(静态资源目录用于存放html、css、js、图片等资源), 3. application.properties(项目配置文件)，等这几个文件，但我这只用了一个application.properties文件大家看情况

1.1

controller
控制层，用于实现最终的逻辑代码，在这里面实现提供给前端后端的逻辑接口
model (entity)
实体类层，用于定义改实体类应该有的属性，建议和数据库的字段一样，省去后期的麻烦
mapper
接口层，用于操作数据库，sql语句就是在这里实现的
service
业务层，实现和mapper的对接的方法，然后提供给controller层，各位可以自行慢慢理解
建议各个包里面的东西名字以实体类为起点，
它们之间的关系为：mapper层注入到service层，service层注入到controller层，层层嵌套

二.在pom.xml文件中导入依赖

<?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>
    <!-- 父项目信息 -->
    <parent>
        <artifactId>umbra-cloud</artifactId>
        <groupId>com.umbra</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <!-- 项目信息 -->
    <artifactId>umbra-demo</artifactId>
    <groupId>org.apache.maven.plugins</groupId>
    <!-- 项目属性 -->
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <!-- 项目依赖 -->
    <dependencies>
        <!--引入springboot web项目依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 引入PostgreSQL数据库连接-->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
        </dependency>
        <!-- 引入动态数据源依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        </dependency>
        <!-- 引入 HikariCP 数据库连接池依赖 -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP-java7</artifactId>
            <version>2.4.13</version>
            <optional>true</optional>
        </dependency>
        <!-- 引入 Mybatis Plus 持久层依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.4</version>
            <optional>true</optional>
        </dependency>
        <!--引入redis 依赖 -->
        <dependency>
            <groupId>com.umbra</groupId>
            <artifactId>umbra-common-redis</artifactId>
            <version>1.0.1-SNAPSHOT</version>
        </dependency>
        <!--引入swagger 依赖 -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

注释都有了不懂拿去c百度我尽力了

三.在resources的application.properties 下配置项目运行信息 redis配置以及数据库链接

#项目运行端口
server.port=8009
#项目名称
spring.application.name=umbra-project

#redis配置
# 主机地址(如果你在本地启动就是127.0.0.1，如果在虚拟机就填你虚拟机的地址)
spring.redis.host=127.0.0.1
#redis端口（默认6379）
spring.redis.port=6379
#redsi服务器密码（如果没有密码默认为空）
spring.redis.password=admin
#连接池最大连接数
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间（-1表示没有限制）
spring.redis.lettuce.pool.max-wait=-1
#最大空闲连接
spring.redis.lettuce.pool.min-idle=10
#最小空闲连接
spring.redis.jedis.pool.min-idle=5
#连接超时时间ms
spring.redis.timeout=30000

#数据库连接池配置
spring.datasource.dynamic.HikariCP.auto-commit=true
spring.datasource.dynamic.HikariCP.pool-name=HikariConnectionPool
spring.datasource.dynamic.HikariCP.maximum-pool-size=50
spring.datasource.dynamic.HikariCP.minimum-idle=20
spring.datasource.dynamic.HikariCP.idle-timeout=180000 
spring.datasource.dynamic.HikariCP.max-lifetime=1800000
spring.datasource.dynamic.HikariCP.connection-timeout=10000
spring.datasource.dynamic.HikariCP.connection-test-query=SELECT 1
#数据源配置
spring.datasource.dynamic.primary=master
spring.datasource.dynamic.datasource.master.username=postgres
spring.datasource.dynamic.datasource.master.password=123456
spring.datasource.dynamic.datasource.master.driver-class-name=org.postgresql.Driver
spring.datasource.dynamic.datasource.master.url=jdbc:postgresql://127.0.0.1:5432/test

#swagger全局配置
#是否开启Swagger
knife4j.enable=true
#进入界面是否需要账号密码
knife4j.basic.enable=true
knife4j.basic.username=admin
knife4j.basic.password=123456

四在实体类中定义 model.Test.java 包含setter，getter方法

package com.umbra.model;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
import lombok.Getter;
import lombok.Setter;

@Data
@ApiModel(value="Test",description="测试实体类")
public class Test {
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getSalary() {
        return salary;
    }

    public void setSalary(String salary) {
        this.salary = salary;
    }

    @ApiModelProperty(value = "id",required = true)
    private String id;
    @ApiModelProperty(value = "name",required = true)
    private String name;
    @ApiModelProperty(value = "age",required = true)
    private int age;
    @ApiModelProperty(value = "address",required = true)
    private String address;
    @ApiModelProperty(value = "salary",required = true)
    private String salary;
}

五. 在数据服务接口层定义方法数据服务接口是实现层实现方法

接口层

package com.umbra.service;

import com.umbra.model.Test;

import java.util.List;

/**
 * @Author: Administrator
 * @createTime: 2023/02/28 13:50
 * @lastModify: Administrator
 * @lastModifyTime: 2023/02/28 13:50
 * @group:
 * @Description:
 */
public interface TestService {
    /**
     *
     * @param msg
     * @return
     */
    //获取所有信息
    List<Test> test(String msg);
    //删除
    int delete(String id);
    // 添加新方法，用于插入数据
    int insert(Test test);

    // 添加新方法，根据名称模糊搜索
    List<Test> searchByName(String name);

    // 添加新方法，根据名称精准搜索
    List<Test> searchByExactName(String name);

//    根据 id修改数据
    int update(Test test);

    //    分页获取
    List<Test> getPageList(int currentPage, int pageSize);
    //    获取条数
    long getTotalCount();
}

实现层

package com.umbra.service.impl;

import cn.hutool.core.util.IdUtil;
import com.umbra.mapper.TestMapper;
import com.umbra.model.Test;
import com.umbra.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import java.awt.print.Pageable;
import java.util.List;

/**
 * @Author: Administrator
 * @createTime: 2023/02/28 13:52
 * @lastModify: Administrator
 * @lastModifyTime: 2023/02/28 13:52
 * @group:
 * @Description:
 */
@Service
public class TestServiceImpl implements TestService {

    @Autowired
    private TestMapper testMapper;
    /**
     * @param msg
     * @return
     */
//获取所有数据
    @Override
    public List<Test> test(String msg) {
        //
        return testMapper.test();
    }
//分页获取数据
    @Override
    public List<Test> getPageList(int pageNum, int pageSize) {
        int offset = (pageNum - 1) * pageSize;
        return testMapper.getPageList(offset, pageSize);
    }
//获取条数
    @Override
    public long getTotalCount() {
        return testMapper.getTotalCount();
    }

//删除数据
    @Override
    public int delete(String id) {
        return testMapper.delete(id);
    }
//添加数据
    @Override
    public int insert(Test test) {
//id自增
        test.setId(IdUtil.simpleUUID());
        return testMapper.insert(test);
    }
    @Override
    public List<Test> searchByName(String name) {
        // 调用Mapper层进行名称模糊搜索
        return testMapper.searchByName(name);
    }
//搜索
    @Override
    public List<Test> searchByExactName(String name) {
        // 调用Mapper层进行名称精准搜索
        return testMapper.searchByExactName(name);
    }
//根据id修改
    @Override
    public int update(Test test) {
        return testMapper.update(test);
    }


}

六.然后到我们的接口层这里面书写sql语句

package com.umbra.mapper;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.umbra.model.Test;
import org.apache.ibatis.annotations.*;

import java.awt.print.Pageable;
import java.util.List;

/**
 * @Author: Administrator
 * @createTime: 2023/02/28 13:54
 * @lastModify: Administrator
 * @lastModifyTime: 2023/02/28 13:54
 * @group:
 * @Description:
 */
@Mapper
public interface TestMapper {
    /**
     *
     */
//    查询所有
    @Select("select id,name,age,address,salary from company")
    List<Test> test();

//    分页查询
    @Select("SELECT id, name, age, address, salary FROM company ORDER BY id LIMIT #{pageSize} OFFSET #{offset}")
    List<Test> getPageList(@Param("offset") int offset, @Param("pageSize") int pageSize);
    //删除
//@Update("update test set is_del = true where id = #{id}")
    @Update("delete from company where id = #{id}")
        int delete(@Param("id")String id);

//新增
    @Insert("INSERT INTO company ( id,name,age,address,salary) VALUES ( #{id},#{name},#{age}, #{address}, #{salary})")
    int insert(Test test);

    // 根据名称模糊搜索
    @Select("SELECT * FROM company WHERE name LIKE CONCAT('%', #{name}, '%')")
    List<Test> searchByName(@Param("name") String name);

    // 根据名称精准搜索
    @Select("SELECT * FROM company WHERE name = #{name}")
    List<Test> searchByExactName(@Param("name") String name);

    // 根据id修改
    @Update("UPDATE company SET name = #{name}, age = #{age}, address = #{address}, salary = #{salary} WHERE id = #{id}")
    int update(Test test);
    //所有条数
    @Select("SELECT COUNT(*) FROM company")
    int getTotalCount();

}

七.最后到控制层，用于实现最终的逻辑代码，在这里面实现提供给前端后端的逻辑接口

package com.umbra.controller;

import com.umbra.common.core.entity.Response;
import com.umbra.model.Test;
import com.umbra.service.TestService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: Administrator
 * @createTime: 2023/02/28 13:43
 * @lastModify: Administrator
 * @lastModifyTime: 2023/02/28 13:43
 * @group:
 * @Description: 测试
 */
@Api(tags = "测试demo接口")
@RestController
//指定映射接口 http://127.0.0.1:8009/test/XXXX
@RequestMapping("/test")
public class TestController {

    @Resource
    private TestService testService;

    /**
     * @return
     */
    @ApiOperation("测试获取所有数据")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "消息", name = "msg")
    })
    @GetMapping("/test")
    public Response test(
            @RequestParam(value = "msg", required = false) String msg) {
           List<Test> msgR = testService.test(msg);
            return Response.ok(msgR);
    }

    @ApiOperation("分页查询数据")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "当前页码", defaultValue = "1", dataType = "int"),
            @ApiImplicitParam(name = "pageSize", value = "每页显示条数", defaultValue = "10", dataType = "int")
    })
    @GetMapping("/getPageList")
    public Response getPageList(@RequestParam(value = "pageNum", defaultValue = "1") int pageNum,
                                @RequestParam(value = "pageSize", defaultValue = "10") int pageSize) {
        List<Test> result = testService.getPageList(pageNum, pageSize);
        long totalCount = testService.getTotalCount();
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("data", result);
        resultMap.put("total", totalCount);
        return Response.ok(resultMap);
    }


    @ApiOperation("删除数据根据id")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "id", name = "id")
    })
    @GetMapping("/delete")
    public Response delete( @RequestParam(value = "id", required = false) String id) {
        int result = testService.delete(id);
        if (result > 0) {
            return Response.ok("删除成功");
        } else {
            return Response.fail("删除失败");
        }
//            return Response.ok("ok",testService.delete(id));
    }

    @ApiOperation("新增数据")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "test对象", name = "test")
    })
    @PostMapping("/add")
    public Response insert(@RequestBody Test test) {
        int result = testService.insert(test);
        if (result > 0) {
            return Response.ok("新增成功");
        } else {
            return Response.fail("新增失败");
        }
    }


    @ApiOperation("根据名称模糊搜索")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "名称关键字", name = "name")
    })
    @GetMapping("/searchByName")
    public Response searchByName(@RequestParam(value = "name", required = false) String name) {
        List<Test> result = testService.searchByName(name);
        return Response.ok(result);
    }

    @ApiOperation("根据名称精准搜索")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "名称", name = "name")
    })
    @GetMapping("/searchByExactName")
    public Response searchByExactName(@RequestParam(value = "name", required = false) String name) {
        List<Test> result = testService.searchByExactName(name);
        return Response.ok(result);
    }

    @ApiOperation("根据ID修改数据")
    @PostMapping("/update")
    public Response update(@RequestBody Test test) {
        // 检查id字段是否为空
        if (test.getId() == null || test.getId().isEmpty()) {
            return Response.fail("id不能为空");
        }
        int result = testService.update(test);
        if (result > 0) {
            return Response.ok("修改成功");
        } else {
            return Response.fail("修改失败");
        }
    }


}

现在的话我们就能通过在application.properties中设置的端口号加上我们本机地址访问

http://127.0.0.1:8009/test/XXX   //XXX是上面controller中@PostMapping("/add")定义的

我们可以在postman中测试 (这个是test 获取全部数据的接口)

结束 :这里面好有好多常用注解解释我也都统计好了等下一期在写一版

CV工程师!!

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring boot 项目结构介绍and实现基础增删改查功能

Spring boot 项目结构介绍and实现基础增删改查功能
复制链接

扫一扫

专栏目录

Spring boot 项目结构介绍and实现基础增删改查功能

一. 搭建项目

1.1

二.在pom.xml文件中导入依赖

三.在resources的application.properties 下配置项目运行信息 redis配置 以及数据库链接

四 在实体类中定义 model.Test.java 包含setter，getter方法

五. 在数据服务接口层 定义方法 数据服务接口是实现层实现方法

六.然后到我们的接口层 这里面书写sql语句