springboot（Restful风格）

Web开发的两种方式

一 前后端不分离

以前在没有互联网时，我们做的大部分应用都是前后端不分的，比如 Jsp 或者 thymeleaf灯后端分离模版，在这种架构应用中，数据基本上都是在后端熏染好，返回给前端展示的，也就是说后端控制前端展示，耦合度很高

二 前后端分离

在前后端分离的应用模式中，后端进返回前端所需要的数据，不再渲染HTML页面，不再控制前端的效果。至于前端用户看到什么效果，从后端请求的数据如何加载到前端，都是有前端自己决定的，网页有网页的处理方式，App 有 App 的处理方式，但无论哪种前端，所需的数据基本相同，后端仅需开发一套逻辑对外提供数据即可。

在前后端分离应用模式中。前端 与 后端的耦合度 相对较低。

我们将后端开发的每一个视图都称为接口，或者API，前端通过访问接口来对数据进行增删改查

什么是 RESTFUL

​ 简单来说，就是 接口实现的规范 。 目前 市面上 开发人员使用的接口服务架构主要有： restful，rpc

REST：

他是一种架构风格，这种风格的规则时服务web应用的，也就是url定位资源，

用 HTTP 动词（GET，POST，DELETE，PUT）描述操作

用HTTP Status Code 返回结果状态的哦这种client 和 server的交互方式。

实现 看URL就知道要什么，

看http 方法就知道干什么

看http status code就知道结果如何

RESTFul：

RESTful 是一种定义Web API接口的设计风格，尤其适用于前后端分离的应用模式。

RestFul就是为了实现REST这种交互方式而制定的一套约束条件与规则，符合这些约束条件和原则的应用程序或设计就是RESTful。

这种风格的理念认为后端开发任务就是提供数据的，对外提供的是数据资源的访问接口，所以在定义接口时，客户端访问的URL路径就表示这种要操作的数据资源。

​ 简单的实例

domain

@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties(value = { "hibernateLazyInitializer"})
@Entity(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(name = "name")
    private String name;
    @Column(name = "pwd")
    private String pwd;
}

mapper

public interface UserMapper extends JpaRepository<User,Integer> {

}

service

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> selectStudents(){
        return userMapper.findAll();
    }
    public User addStudent(User user){
        return userMapper.save(user);
    }
    public void updateStudent(User user){
       userMapper.save(user);

    }
    public void deleteStudentBySid(Integer sid){
        userMapper.deleteById(sid);
    }
}

controller

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> findUsers(){
        return userService.selectStudents();
    }
    @RequestMapping("/users")
    public User addUser(User user){
        return userService.addStudent(user);
    }
    @PutMapping("/users")
    public void update(User user){
        userService.updateStudent(user);
    }

    @DeleteMapping("/users/{sid}")
    public void deleteUserBySid(@PathVariable("sid") Integer sid){
        userService.deleteStudentBySid(sid);
    }
}

封装响应数据

ResponResult

@Data
@NoArgsConstructor
@AllArgsConstructor
public class ResponseResult<T>{
    private Integer statusCode;
    private String msg;
    private T data;
}

Response

public class Response {
    public static <T> ResponseResult<T> createOkResp(T data){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(200);
        tResponseResult.setMsg("success");
        tResponseResult.setData(data);
        return tResponseResult;
    }
    public static <T> ResponseResult<T> createFailResp(){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(405);
        tResponseResult.setMsg("fail");
        tResponseResult.setData(null);
        return tResponseResult;
    }
    public static <T> ResponseResult<T> createFailResp(T data){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(405);
        tResponseResult.setMsg("fail");
        tResponseResult.setData(data);
        return tResponseResult;
    }
}

controller

@RestController
@RequestMapping("/user1")
public class UserController1 {
    @Autowired
    private UserMapper userMapper;
    @GetMapping("/users")
    public ResponseResult<List<User>> selectUsers(){
        ResponseResult<List<User>> listResponseResult = Response.createOkResp(userMapper.findAll());
        return listResponseResult;
    }
    @GetMapping("/users/{id}")
    public ResponseResult<User> selectUserById(@PathVariable("id") Integer id){
        ResponseResult<User> okResp = Response.createOkResp(userMapper.getById(id));
        return okResp;
    }

    @RequestMapping("/users")
    public ResponseResult<User> addUser(User user){
        try {
            User save = userMapper.save(user);
            ResponseResult<User> okResp = Response.createOkResp(save);
            System.out.println(10/0);
            return okResp;
        }catch (Exception e){
            User user1 = new User();
            ResponseResult<User> failResp = Response.createFailResp(user1);
            return failResp;
        }
    }
}

再次封装

public enum StatusCode {
    SUCCESS(200), FAIL(444);
    int code;
    StatusCode(int code){
        this.code = code;
    }
}

public class Response {
    public static <T> ResponseResult<T> createOkResp(T data){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(StatusCode.SUCCESS.code);
        tResponseResult.setMsg("success");
        tResponseResult.setData(data);
        return tResponseResult;
    }
    public static <T> ResponseResult<T> createFailResp(){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(StatusCode.FAIL.code);
        tResponseResult.setMsg("fail");
        tResponseResult.setData(null);
        return tResponseResult;
    }
    public static <T> ResponseResult<T> createFailResp(T data){
        ResponseResult<T> tResponseResult = new ResponseResult<>();
        tResponseResult.setStatusCode(StatusCode.FAIL.code);
        tResponseResult.setMsg("fail");
        tResponseResult.setData(data);
        return tResponseResult;
    }
}