SpringBoot项目中各层介绍总结

花小智

已于 2024-08-12 16:58:23 修改

阅读量252

点赞数 8

于 2024-08-12 16:24:31 首次发布

本文链接：https://blog.csdn.net/m0_51974644/article/details/141135077

版权

一、SpringBoot项目中model层、Dao层、Mapper层、controller层、service层、entity层作用

1、model（entity）

model是模型的意思，与entity、domain、pojo类似，是存放实体的类，类中定义了多个类属性，并与数据库表的字段保持一致，一张表对应一个model类。主要用于定义与数据库对象应的属性，提供get/set方法,tostring方法,有参无参构造函数。

2、dao（mapper）

又被成为mapper层，叫数据持久层，先设计接口，然后在配置文件中进行配置其实现的关联。 dao层的作用为访问数据库，向数据库发送sql语句，完成数据的增删改查任务。数据持久化操作就是指，把数据放到持久化的介质中，同时提供增删改查操作，比如数据通过hibernate插入到数据库中

3、service

业务逻辑层，完成功能的设计和dao层一样都是先设计接口，再创建要实现的类，然后在配置文件中进行配置其实现的关联。接下来就可以在service层调用dao层的接口进行业务逻辑应用的处理。 service的impl是把mapper和service进行整合的文件封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。

4、controller

控制层，控制业务逻辑service，控制请求和响应，负责前后端交互 controller层主要调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行

5、概览

在这里插入图片描述

二、Spring Boot项目中的层级结构

一个完整的Spring Boot项目主要包括Controller层、Service层、Mapper层和Entity层组成。
在这里插入图片描述

各层详解

（一）Controller层（控制层）

Controller层主要负责接收前端请求并返回响应，它是应用程序的入口点。在Spring Boot中，Controller层通常使用@RestController或@Controller注解来标识。Controller层的主要作用是接收客户端请求，将请求参数传递给Service层进行处理，并将处理结果以适当的形式返回给客户端。

UserController类

package com.itxinian.controller;
 
import com.itxinian.entity.Result;
import com.itxinian.entity.User;
import com.itxinian.service.UserService;
import com.itxinian.utils.JwtUtil;
import com.itxinian.utils.Md5Util;
import jakarta.validation.constraints.Pattern;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.HashMap;
import java.util.Map;
 
@RestController
@RequestMapping("/user")
@Validated
public class UserController {
 
    @Autowired
    private UserService userService;
 
    @PostMapping("/register")
    public Result register(@Pattern(regexp = "^\\S{5,16}$") String username,@Pattern(regexp = "^\\S{5,16}$") String password) {
        User u = userService.findByUserName(username);
        if(u == null){
            userService.register(username,password);
            return Result.success();
        }else{
            return Result.error("用户名已被使用");
        }
    }
 
    @PostMapping("/login")
    public Result<String> login(@Pattern(regexp = "^\\S{5,16}$") String username,@Pattern(regexp = "^\\S{5,16}$")String password){
        User loginUser = userService.findByUserName(username);
 
        if(loginUser == null){
            return Result.error("用户名错误");
        }
 
 
        if(Md5Util.getMD5String(password).equals(loginUser.getPassword())){
            Map<String,Object> claims = new HashMap<>();
            claims.put("id",loginUser.getId());
            claims.put("username",loginUser.getUsername());
            String token = JwtUtil.genToken(claims);
            return Result.success(token);
        }
        return Result.error("密码错误");
    }
}

（二）Service层（业务逻辑层）

Service层通常位于Controller层和数据访问层之间，负责处理应用程序的业务逻辑。Service层负责执行业务规则、数据验证、数据处理等操作。它接收来自Controller层的请求，调用Mapper层的方法进行数据操作，并将结果返回给Controller层。Service层的设计使得业务逻辑与数据访问逻辑分离，提高了代码的可维护性和可重用性。

UserService接口，主要用于定义接口（业务逻辑）

package com.itxinian.service;
 
import com.itxinian.entity.User;
 
public interface UserService {
    User findByUserName(String username);
 
    void register(String username, String password);
}

UserServiceImpl类，主要用于实现UserService接口

package com.itxinian.service.impl;
 
import com.itxinian.mapper.UserMapper;
import com.itxinian.entity.User;
import com.itxinian.service.UserService;
import com.itxinian.utils.Md5Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class Userserviceimpl implements UserService {
    @Autowired
    private UserMapper userMapper;
    @Override
    public User findByUserName(String username) {
        User u = userMapper.findByUserName(username);
        return u;
    }
 
    @Override
    public void register(String username, String password) {
        String md5String = Md5Util.getMD5String(password);
 
        userMapper.add(username,md5String);
    }
}

（三）Mapper层（数据访问层）

Mapper层也称为Dao层或Repository层，它是数据持久层的组件。Mapper层的主要作用是访问数据库，执行数据的增删改查操作。它通常包含一些基本的SQL语句或使用ORM框架提供的API来执行数据库操作。Mapper层的设计使得数据访问逻辑与业务逻辑分离，提高了代码的可维护性和可重用性。

UserMapper接口

package com.itxinian.mapper;
 
import com.itxinian.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
 
@Mapper
public interface UserMapper {
    @Select("select * from user where username=#{username}")
    User findByUserName(String username);
    @Insert("insert into user(username,password,create_time,update_time)" +
            " values(#{username},#{password},now(),now())")
    void add(String username, String password);
}

（四）Entity层（实体层）

Entity层是存放实体的类，类中定义了多个属性，并且与数据库表的字段保持一致。Entity层的定义主要用于定义与数据库对象对应的属性，提供get/set方法、toString方法以及有参无参构造函数等。一个数据库表通常对应了一个Entity类，使得开发人员可以更加方便地操作数据库表中的数据。
User类

package com.itxinian.entity;
 
 
 
import lombok.Data;
 
import java.time.LocalDateTime;
 
@Data
public class User {
    private Integer id;//主键ID
    private String username;//用户名
    private String password;//密码
    private String nickname;//昵称
    private String email;//邮箱
    private String userPic;//用户头像地址
    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间
}

三、解读controller层,service层,mapper层,entity层的作用与联系

controller层,service层,mapper层,entity层作用与联系

在这里插入图片描述

1.controller层

controller层是用来接受前台数据和返回页面请求信息的，

Controller层是不允许直接操作数据库的！它就像一个服务员，哪桌客人需要点菜了，就喊一声服务员！

对应的，外界需要完成什么样的业务，就通过Controller去调用不同的Service，需要记住的是Controller只是一个中间者或者转发者，不应该在Controller里暴露Service的业务逻辑，而应该直接转发Service的业务处理结果！

控制层，负责具体模块的业务流程控制，需要调用service逻辑设计层的接口来控制业务流程。

controller通过接收前端H5或者App传过来的参数进行业务操作，再将处理结果返回到前端。

@RestController
@RequestMapping("/user")
public class UserController {
 
    @Autowired
    private UserMapper userMapper;
    
    @GetMapping("/select")
    public List<User> index(){
        List<User> all = userMapper.findAll();
        return all;
    }
 
    @Autowired
    private UserService userService;
    @PostMapping("/insert")
    public boolean save(@RequestBody User user){
        return userService.saveUser(user);
    }
 
    @DeleteMapping("/{id}")
    public Integer delete(@PathVariable Integer id){
        return userMapper.deleteById(id);
    }

2.servie层

service层接受controller层信息，用于业务处理和逻辑判断。Service 用于处理业务逻辑，会调用mapper层的API；

Service层是业务逻辑层，在该层进行复杂的业务逻辑处理，对在多个mapper层查到的数据进行组装、处理，然后将结果返回给Controller，因此，一般情况下，一个Controller中可能包括多个Service，而一个Service中又或许包含多个mapper。

（举例）controller层是饭店经理，service是服务员，mapper层是厨房仓库。

业务service层，给controller层的类提供接口进行调用。一般就是自己写的方法封装起来，就是声明一下，具体实现在serviceImpl中。

public class UserService extends ServiceImpl<UserMapper, User> {
        public boolean saveUser(User user) {
            if(user.getId() == null){
            return save(user);//mybatis-plus提供的方法，表示插入数据。
            }else{
            return updateById(user);
        }
}

3.mapper层

mapper层（数据持久化层，专门用来跟数据库打交道的）。

mapper层用于和数据库交互，想要访问数据库并且操作，只能通过mapper层向数据库发送sql语句，将这些结果通过接口传给service层，对数据库进行数据持久化操作，他的方法语句是直接针对数据库操作的，

主要实现一些增删改查操作，在mybatis中方法主要与与xxx.xml内相互一一映射。

@Mapper
@Repository
public interface UserMapper extends BaseMapper<User> {//数据库查询接口，专门用来跟数据库交互用的
    @Select("SELECT * from sys_user")
    public List<User> findAll();
 
    List<User> findAll1();
    @Insert("INSERT into sys_user(username,password,nickname,email,phone,address)VALUES(#{username},#{password},#{nickname}," +
            "#{email},#{phone},#{address});")
    public int insert(User user);
 
    public int updateUser(User user);
 
    @Delete("delete from sys_user where id = #{id}")
    public Integer deleteById(@Param("id") Integer id);

4.entity层

entity层创建实体类，和数据库表里面属性值一一对应。

实体层，用于存放我们的实体类，与数据库中的属性值基本保持一致，实现set和get的方法或者使用注解的方式。

@Data//Data注解代替了get和set方法
@TableName(value = "sys_user")
public class User {
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String username;
    private String password;
    private String nickname;
    private String email;
    private String phone;
    private String address;
}

四、Spring Boot项目中的Controller、Service、Mapper和Entity层的作用与联系

（一）、Controller层

 
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
 
    /**
     * 查询用户列表
     */
    @RequiresPermissions("user:list")
    @GetMapping("/list")
    public JSONObject listUser(HttpServletRequest request) {
        return userService.listUser(CommonUtil.request2Json(request));
    }
 
    @RequiresPermissions("user:add")
    @PostMapping("/addUser")
    public JSONObject addUser(@RequestBody JSONObject requestJson) {
        CommonUtil.hasAllRequired(requestJson, "username, password, nickname, roleIds");
        return userService.addUser(requestJson);
    }
 
    @RequiresPermissions("user:update")
    @PostMapping("/updateUser")
    public JSONObject updateUser(@RequestBody JSONObject requestJson) {
        CommonUtil.hasAllRequired(requestJson, " nickname, roleIds, deleteStatus, userId");
        return userService.updateUser(requestJson);
    }
 
    @RequiresPermissions(value = {"user:add", "user:update"}, logical = Logical.OR)
    @GetMapping("/getAllRoles")
    public JSONObject getAllRoles() {
        return userService.getAllRoles();
    }

Controller层是Spring Boot应用程序的入口点，通常处用于理请求的输入和输出，并负责验证输入数据的有效性。它将http请求参数传递给Service层，然后将Service层的处理结果封装成适当的响应返回给客户端。

1.2Controller层重要注解：

@Controller
@RequestMapping
@ResponseBody
@RestController
@GetMapping
@PostMapping

1.3@Controller

当Spring检测到@Controller注解时，将其自动注册为Controller对象

1.4@RequestMapping

（1）基础用法

@RequestMapping 注解用于将任意HTTP 请求映射到控制器方法上，可以在控制器类上和控制器类中的方法上使用。

 @RequiresPermissions("user:list")
    @GetMapping("/list")
    public JSONObject listUser(HttpServletRequest request) {
        return userService.listUser(CommonUtil.request2Json(request));
    }

如上述代码所示，到 /user：list的请求会由 listUser(HttpServletRequest request)方法来处理，

用于将任意HTTP 请求映射到控制器方法上。

（2）用 @RequestMapping 处理 HTTP 的各种方法

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

@RestController
@RequestMapping("/home")
public class IndexController {
    @RequestMapping(method = RequestMethod.GET)
    String get() {
        return "Hello from get";
    }
    @RequestMapping(method = RequestMethod.DELETE)
    String delete() {
        return "Hello from delete";
    }
    @RequestMapping(method = RequestMethod.POST)
    String post() {
        return "Hello from post";
    }
    @RequestMapping(method = RequestMethod.PUT)
    String put() {
        return "Hello from put";
    }
    @RequestMapping(method = RequestMethod.PATCH)
    String patch() {
        return "Hello from patch";
    }
}

@RequestMapping 注解中的 method 元素声明了 HTTP 请求的 HTTP 方法的类型。

（二）、Service层

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
 
    /**
     * 用户列表
     */
    public JSONObject listUser(JSONObject jsonObject) {
        CommonUtil.fillPageParam(jsonObject);
        int count = userDao.countUser(jsonObject);
        List<JSONObject> list = userDao.listUser(jsonObject);
        return CommonUtil.successPage(jsonObject, list, count);
    }

Service层不应该直接与数据库交互，它接收Controller层传递过来的请求，并调用相应的Mapper层方法来操作数据库。

后端service层一般需要做以下几件事情：

（1）定义service层的接口和实现类，接口中声明业务方法，实现类中编写业务逻辑。
（2）注入dao层或mapper层的对象，调用它们的方法来操作数据库或执行sql语句。
（3）处理异常情况，例如捕获sql异常，抛出自定义异常等。
（4）添加事务管理注解，保证数据的一致性和完整性。

如何通过service层调用dao：

在bean属性中配置每一个service与dao，例如：

添加配置属性：

       <context:annotation-config/>
       <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
       
       <bean id="loginService" class="com.springmvc.service.LoginService">
         <property name="loginDao" ref="loginDao"/>
       </bean>
       <bean id="loginDao" class="com.springmvc.dao.LoginDao" />

id=“loginService” 与注解@Resource的name保持一致

service层：

@Service
public class LoginService {
	
	@Autowired
	private LoginDao loginDao = null;
	
	@Resource(name="loginDao")
	public void setLoginDao(LoginDao loginDao) {
		this.loginDao = loginDao;
	}
	
	public User getUserInfo() {
		return loginDao.getUserInfo();
	}
}

@Autowired可以标注在属性上、方法上和构造器上，按by type自动装配。

@Resource和@Autowired注解都是用来实现依赖注入的。@Resource默认按byName自动注入。

（三）、Mapper层

<?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.heeexy.example.dao.UserDao">
 
    <select id="countUser" resultType="Integer">
        SELECT count(0)
        FROM sys_user u
        WHERE u.delete_status = '1'
    </select>
 
    <resultMap id="userMap" type="com.heeexy.example.util.model.One2Many">
        <id column="userId" property="userId"/>
        <result column="username" property="username"/>
        <result column="nickname" property="nickname"/>
        <result column="createTime" property="createTime"/>
        <result column="updateTime" property="updateTime"/>
        <result column="deleteStatus" property="deleteStatus"/>
        <collection property="roles" ofType="com.alibaba.fastjson.JSONObject">
            <id column="roleId" property="roleId"/>
            <result column="roleName" property="roleName"/>
        </collection>
    </resultMap>

1.1 @Repository

它用来标注访问层的类（Dao层），它表示一个仓库，主要用于封装对于数据库的访问，配合 @MapperScan 注解一起使用。

1.2 @Mapper

package com.example.mapper;
 
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
 
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(int id);
}

单独使用，通过xml里面的namespace里面的接口地址，生成了Bean后注入到Service层中。

Mapper层定义了各种数据库操作方法的接口，并由ORM框架自动实现。它将数据库操作细节封装起来，对上层提供简洁的接口，让开发人员能够更专注于业务逻辑的实现。

它还提供了一组方法用于对数据库进行增删改查等操作。例如：mybits…

<select id="listUser" resultMap="userMap">
        SELECT u.*,
               r.id        roleId,
               r.role_name roleName
        FROM (
                 SELECT id                                      userId,
                        username                                username,
                        nickname                                nickname,
                        delete_status                           deleteStatus,
                        DATE_FORMAT(create_time, '%Y.%m.%d %T') createTime,
                        DATE_FORMAT(update_time, '%Y.%m.%d %T') updateTime
                 FROM sys_user
                 WHERE delete_status = '1'
                 ORDER BY id
                 LIMIT #{offSet}, #{pageRow}
             ) u
                 LEFT JOIN sys_user_role ur on ur.user_id = u.userId
                 LEFT JOIN sys_role r ON r.id = ur.role_id
        ORDER BY u.userId, r.id
    </select>

（四）、Entity层

Entity层（也称为Model层）表示与数据库表对应的实体类。它的作用是映射数据库表结构，定义数据的结构和属性。它是与数据库交互的核心，将数据库表中的记录映射为Java对象。

package com.heeexy.example.util.model;
 
import com.alibaba.fastjson.JSONObject;
 
import java.util.List;
import java.util.Set;
 
/**
 * @author: heeexy
 * @description: MyBatis的一对多JSON返回对象
 * <p>
 * 处理嵌套查询结果时，MyBatis会根据bean定义的属性类型来初始化嵌套的成员变量，
 * 主要看其是不是Collection
 * 如果这里不定义，那么嵌套返回结果里就只能返回一对一的结果，而不是一对多的
 * <p>
 * 参见MyBatis  DefaultResultSetHandler.instantiateCollectionPropertyIfAppropriate()
 * @date: 2017/10/24 10:17
 */
public class One2Many extends JSONObject {
    private Set<String> roleList;
    private Set<String> menuList;
    private Set<String> permissionList;
    private Set<Integer> permissionIds;
    private List<JSONObject> picList;
    private List<JSONObject> menus;
    private List<JSONObject> users;
    private List<JSONObject> permissions;
    private List<JSONObject> roles;
}

（五）、关系与联系

这四个层次之间存在着紧密的联系，它们共同协作以实现应用程序的功能。通过分层框架，将不同职责分离，提高了代码的可维护性和可测试性。

1.Controller层接收来自客户端的请求，将请求参数传递给Service层，并将Service层的处理结果封装成适当的响应返回给客户端。
2.Service层负责实现具体的业务功能，它接收Controller层传递过来的请求，并调用Mapper层的方法来操作数据库。
3.Mapper层负责与数据库交互，通过ORM框架来简化数据库操作。它将数据库操作细节封装起来，为Service层提供简洁的接口。
4.Entity层表示与数据库表对应的实体类，它映射数据库表的结构和属性，并负责与数据库进行数据的转换和映射。

花小智

关注

8
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot项目中各层介绍总结

业务逻辑层，完成功能的设计和dao层一样都是先设计接口，再创建要实现的类，然后在配置文件中进行配置其实现的关联。model是模型的意思，与entity、domain、pojo类似，是存放实体的类，类中定义了多个类属性，并与数据库表的字段保持一致，一张表对应一个model类。控制层，控制业务逻辑service，控制请求和响应，负责前后端交互 controller层主要调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行。
复制链接

扫一扫