我的springboot学习【2】

最新推荐文章于 2024-02-22 11:21:01 发布

lxchen0507

最新推荐文章于 2024-02-22 11:21:01 发布

阅读量400

点赞数

分类专栏：自学springboot 文章标签：学习 java spring boot spring

本文链接：https://blog.csdn.net/lxchen0507/article/details/126026955

版权

自学springboot 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

今天是我重新整合学习springboot框架的第二天，老规矩废话少说直入主题。

昨天学到了Controller传参中的Get传参，今天继续来看Post请求传参。这里我使用的是Apipost工具来辅助检测。提到Post传参，我第一个想到的就是利用form表单操作，代码和测试结果如下：

@PostMapping("/postTest1")
public User postTest1(User user){
    return user;
}

第二种Post 传参是json传参，这里涉及到另一个注解@RequestBody。代码和执行结果如下

@PostMapping("/postTest2")
public User postTest2(@RequestBody User user){
    return user;
}

关于Controller传参就到此为止，其他的方式并不常用在此不多涉及。下面要学习的是拦截器的部分。在SpringMVC中提供了HandlerInterceptor接口，这个接口中提供了preHandle、postHandle、afterCompletion三个方法，实现这三个方法就能实现我们定义的拦截器的功能。首先看preHandle函数，该函数是controller执行前的逻辑，要返回一个boolean类型的值。返回true则请求继续执行，false则相反，这是拦截器最重要的方法，一般用于校验携带的token。postHandle方法在controller执行之后，视图解析之前，可向ModelAndView中添加数据。afterCompletion方法在整个请求结束之后，返回数据之前，能获取到响应数据及异常。在实现这三个方法后拦截器并不会立即生效，需要一个“将拦截器添加到项目”的操作才行，即注入到适配器。

了解了基本方法之后我们开始写一个拦截器。整个拦截器的逻辑如下：获取header中携带过来的token数据，若无数据则拦截，若有则进行比对，符合条件则放行，否则拦截。我在项目下新建interceptor包，新建TokenInterceptor类继承HandlerInterceptor接口，目的是过滤除了login以外的全部请求。具体代码如下：

package com.lxc.interceptor;

import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TokenInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("token");
        return StringUtils.hasLength(token);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("controller执行结束");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("获取到返回结果"+response);
        System.out.println("请求结束");
    }
}

定义好类之后，需要实现注入适配器，那么我们在config包下新增配置类解决，代码如下：

package com.lxc.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.lxc.interceptor.TokenInterceptor;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }
}

重新启动项目试着拿到张三的信息，可以发现拦截器已经起了作用，我们是不能直接进行访问的！我们在header中加入token时成功拿到了想要的信息，结果如下:

接下来我们来验证是否能够通过login来访问，涉及到的代码以及访问结果如下：

package com.lxc.haveFun;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {

    @GetMapping("/login")
    public String login(){
        return "请求成功！";
    }
}

由此可见，之前设置的过滤器完成了设定的目的。

接下来我遇到的是跨域问题。当一个请求url的协议、域名以及端口号有一个不同时，就是一个跨域问题。随着前后端分离的出现，出现了这种跨域问题，因为不再是跟以前一样前后端一起部署了。这里一般有四种解决方案。①JSONP解决，简单实用兼容性好，是前端实现跟后端关系不大，只支持get请求不支持post请求。②Nginx反向代理，最简单的解决方案，只需修改nginx配置就能达到需求，支持session，不需要修改任何代码且不会影响服务器性能。③webpack本地代理，相对于前端模拟nginx功能。④CORS，属于跨源AJAX请求的根本解决方案。这里我主要学的是第四种方案在springboot的实现。

用这种方案也有两种解决方法。首先是利用之前的拦截器配置类，这里会涉及到两个新的注解。@Configuration注解表明某个类是配置类（之前就用过忘说了），@Bean注解用来修饰方法，使得项目在启动时直接调用方法，并将方法的取值放入IOC容器中。@Configuration注解包含一个属性，默认为true，即采用代理模式生成一个代理对象，每次调用方法其实是调用代理对象的方法。当为false时，关闭代理模式，每次调用时都会产生一个新对象。

言归正传，CORS解决跨域问题有两种方式，我只考虑第一种，是在之前的配置类中继续编写，代码如下

package com.lxc.config;

import org.apache.catalina.filters.CorsFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.lxc.interceptor.TokenInterceptor;

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/login");
    }

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", buildConfig());
        return new CorsFilter();
    }

    private CorsConfiguration buildConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");

        return corsConfiguration;
    }
}

根据我参考的springboot博客，在未来集成了Swagger后，过滤器会合swagger发生冲突。这个问题以后我会解决。

接下来是统一结果封装的问题，为的是解决不同开发人员之间协同合作，让大家都返回统一的数据格式，也方便前端人员进行调用。这里我只做一个简单的例子，总共涉及到code（接口的状态）、message（提示信息）、data（核心数据）三个字段，其中data字段显然要用Object类型。这类直接创建泛型类。由于现在暂时用不到，我把它放到后面解决。

我觉得已经接触springboot一部分了，为了尽快培养兴趣，将直接开始搞一下JdbcTemplate，虽然现在使用起来据说比不上mybatis和JPA，但是总算也能玩起来。这里觉得之前搞的拦截器挺烦的，索性新建一个项目，数据库采用MySQL。

首先就是删除默认配置文件，新建yml配置文件，然后来导入jdbc和mysql依赖。导入的依赖如下，导入后及时更新maven依赖。

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

接下来书写配置文件

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_learning        //springboot_learning是库名
    username: root
    password: root

我们创建一个user表来进行测试

CREATE TABLE `springboot_learning`.`t_user` (
	`id` INT ( 20 ) NOT NULL auto_increment COMMENT 'id',
	`name` VARCHAR ( 40 ) NOT NULL COMMENT '姓名',
	`age` INT ( 20 ) NULL COMMENT '年龄',
	`address` VARCHAR ( 100 ) NULL COMMENT '地址',
	`create_time` datetime ( 0 ) NULL COMMENT '创建时间',
	`update_time` datetime ( 0 ) NULL COMMENT '更新时间',
	PRIMARY KEY ( `id` ) 
);

创建entity文件夹，并创建实体类User。这里为了保证代码简洁，我们加入lombok依赖，使用@Data注解。为了避免版本冲突引起500报错的问题，我们直接在User类的开头引入注解，并利用IDEA的解决爆红功能引入正确版本的lombok。lombok依赖引入之后，可以省去大量的get、set函数以及toString（）等等。User实体类代码如下：

package entity;

import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String address;
    private Date createTime;
    private Date updateTime;
}

创建提供多种数据库操作函数的接口，这里我们只写基本功能也就是增删改查，涉及根据id查询、获取全部用户、更新用户以及删除用户，代码如下：

package entity;

import java.util.List;

public interface UserDao {
    //根据id查询
    User getUserById(Integer id);

    //查询全部用户
    List<User> listUser();

    //保存用户
    int save(User user);

    //更新用户
    int update(User user);

    //删除用户
    int delete(Integer id);
}

这里有了接口，也有spring提供的JdbcTemplate接口，我们就可以开始写具体函数了。其中，@Autowired注解可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作.

package entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.*;
@Repository
public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public User getUserById(Integer id) {
        User user = jdbcTemplate.queryForObject("select * from t_user where id = ?", new BeanPropertyRowMapper<>(User.class), id);
        return user;
    }

    @Override
    public List<User> listUser() {
        List<User> users = jdbcTemplate.query("select * from t_user", new BeanPropertyRowMapper<>(User.class));
        return users;
    }

    @Override
    public int save(User user) {
        return jdbcTemplate.update("insert into t_user(name,age,address,create_time,update_time) value (?,?,?,?,?)", user.getName(), user.getAge(), user.getAddress(), new Date(), new Date());
    }

    @Override
    public int update(Integer id, User user) {
        return jdbcTemplate.update("update t_user set name=?, age=?, address=?, update_time=? where id=?", user.getName(), user.getAge(), user.getAddress(), new Date(), id);
    }

    @Override
    public int delete(Integer id) {
        return jdbcTemplate.update("delete from t_user where id=?", id);
    }
}

到此为止实现了之前定下的全部基本功能，下面我要进行的是Service层的开发和Controller的测试。注意这里已经实现了分层开发。与之前的UserDao相对，Service层的接口是UserService，代码内容完全一致。与此前不同的是，这是服务层，所以不再注入JdbcMvcTemplate，而是直接注入UserDao。接口和服务层类代码如下：

package entity;

import java.util.List;

public interface UserService {
    //根据id查询
    User getUserById(Integer id);

    //查询全部用户
    List<User> listUser();

    //保存用户
    int save(User user);

    //更新用户
    int update(Integer id, User user);

    //删除用户
    int delete(Integer id);
}

package entity;

import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;

public class UserServiceImpl implements UserService{

    @Autowired
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }

    @Override
    public User getUserById(Integer id) {
        return userDao.getUserById(id);
    }

    @Override
    public List<User> listUser() {
        return userDao.listUser();
    }

    @Override
    public int save(User user) {
        return userDao.save(user);
    }

    @Override
    public int update(Integer id, User user) {
        return userDao.update(id, user);
    }

    @Override
    public int delete(Integer id) {
        return userDao.delete(id);
    }
}

现在一切都准备好了，可以开发Controller来进行测试了。Controller类代码如下：

package entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/jdbc")
public class JdbcController {

    @Autowired
    private UserService userService;

    public JdbcController(){}
    public JdbcController(UserService userService){
        this.userService = userService;
    }

    @PostMapping("/save")
    public String save(@RequestBody User user){
        userService.save(user);
        return "已存入数据库";
    }

    @PostMapping("/update")
    public String update(@RequestBody User user){
        userService.update(user.getId(), user);
        return "数据库内容已更新";
    }

    @GetMapping("/get/{id}")
    public User getById(@PathVariable Integer id){
        User user = userService.getUserById(id);
        return user;
    }
    
    //剩下的也类似不多写了
}

遇到点小问题，没调试出结果，刚刚跟老师交流了一下，明天继续干。今天先写到这

lxchen0507

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
我的springboot学习【2】

下面要学习的是拦截器的部分。返回true则请求继续执行，false则相反，这是拦截器最重要的方法，一般用于校验携带的token。@Configuration注解表明某个类是配置类（之前就用过忘说了），@Bean注解用来修饰方法，使得项目在启动时直接调用方法，并将方法的取值放入IOC容器中。整个拦截器的逻辑如下获取header中携带过来的token数据，若无数据则拦截，若有则进行比对，符合条件则放行，否则拦截。言归正传，CORS解决跨域问题有两种方式，我只考虑第一种，是在之前的配置类中继续编写，代码如下。..
复制链接

扫一扫