SpringBoot项目开发学习-后端

黑马的big_event

1、lombok工具

在编译阶段,为实体类自动生成setter,getter,toString,hashCode,equals方法

1.在pom中引入依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

2.在实体类上添加注解

        提供setter,getter,toString等方法@Data

        提供构造方法@NoArgsConstructor @AllArgsConstructor

1、用户模块

1、注册功能开发

1、三层架构

1.UserController

接收用户请求->调用Service处理业务->将处理结果返回给前端

判断用户名是否已被占用->注册

1)添加类注解
@RestController
@RequestMapping("/user")

3)注入Service对象
@Autowired
private UserService userService;


3)编写方法及注解
    //注册
    @PostMapping("/register")
    public Result register(@Pattern(regexp = "^\\S{5,16}$") String username,@Pattern(regexp = "^\\S{5,16}$") String password){

        //查询用户
        User user = userService.findByUserName(username);
        if (user==null){
            //没有占用
            //注册
            userService.register(username,password);
            return Result.success();
        }else {
            //占用
            return Result.error("用户名已被占用");
        }

    }

2.UserService

处理业务

根据用户名查询用户->注册

1)创建UserService接口

2)实现UserService类,给类添加上@Service注解,让Service注册到容器中

3)类中创建UserMapper对象,能调用UserMapper的方法
    @Autowired
    private UserMapper userMapper;

4)实现Service类的方法
    @Override
    public User findByUserName(String username) {
        User user = userMapper.findByUserName(username);
        return user;
    }

    @Override
    public void register(String username, String password) {
        //密码加密处理
        String md5String = Md5Util.getMD5String(password);
        //添加
        userMapper.add(username,md5String);
    }

3.UserMapper

与数据库交互

查询->插入

1)创建UserMapper类

2)给类添加@Mapper注解,注入容器

3)给接口写方法,方法上直接写SQL语句
    @Select("select * from user where username = #{username}")
    User findByUserName(String username);

    //now()是数据库函数,获取当前时间
    @Insert("insert into user(username,password,create_time,update_time)" +
            " values(#{username},#{password},now(),now())")
    void add(String username, String password);

2、功能测试

使用PostMan测试,发送请求,测试成功

3、参数校验

1.使用Spring提供的Validation参数校验框架，使用注解完成校验

        1)引入Spring Validation 起步依赖

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

        2)在参数前面添加@Pattern(regexp="")注解,内写正则表达式

        3)在Controller类上添加@Validated注解

2.参数校验失败异常处理

        1)创建全局异常处理器类GlobalExceptionHandler

        2)创建方法handleException,给方法添加注解@ExceptionHandler(Exception.class)

@RestController
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e){
        e.printStackTrace();
        return Result.error(StringUtils.hasLength(e.getMessage())? e.getMessage() : "操作失败");
    }
}

2、登录功能开发

1、功能实现

在UserController中实现login方法

    //登录
    @PostMapping("/login")
    public Result<String> login(@Pattern(regexp = "^\\S{5,16}$") String username,@Pattern(regexp = "^\\S{5,16}$") String password){
        //根据用户名查询User
        User user = userService.findByUserName(username);
        //判断是否查询到
        if (user==null){
            return Result.error("没有此用户");
        }
        //判断密码是否正确
        //数据库中存储的是加密后的密码,需要将用户输入的密码加密后再与数据库中比对
        if (Md5Util.getMD5String(password).equals(user.getPassword())){
            //正确,登录成功
            return Result.success("此处应返回jwt token令牌");
        }

        return Result.error("密码错误");
    }

2、登录认证

使用Jwt令牌(头.有效载荷.签名)

UserController调用login生成->用户浏览器->ArticleController验证

1.引入依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.3.0</version>
        </dependency>

2.引入工具类

public class JwtUtil {

    private static final String KEY = "Dioker";
	
	//接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 12))
                .sign(Algorithm.HMAC256(KEY));
    }

	//接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

}

3.编写拦截器

1)创建interceptors包

2)创建LoginInterceptor类,给类添加Component注解,将拦截器注入到IOC容器中

3)实现HandlerInterceptor接口,重写preHandle方法

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //令牌验证
        String token = request.getHeader("Authorization");
        //验证token
        try {
            Map<String,Object> claims = JwtUtil.parseToken(token);
            //把业务数据存储到ThreadLocal中
            ThreadLocalUtil.set(claims);
            //放行
            return true;
        }catch (Exception e){
            //http响应状态码为401
            //不放行
            response.setStatus(401);
            return false;
        }
    }

4)配置拦截器

        1创建WebConfig类,实现WebMvcConfigurer接口,添加@Configuration注解,注入到IOC容器

        2创建LoginInterceptor对象,添加@Autowired注解

        3重写addInterceptors方法

        

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //登录和注册接口不拦截,放行
        registry.addInterceptor(loginInterceptor).excludePathPatterns("/user/login","/user/register");
    }

3、功能测试

1.先用登录测试获取Jwt

2.使用Jwt时可以正确得到数据

3.不使用Jwt时返回401异常

4.可以给测试统一添加上token

3、获取用户详细信息

1、功能实现

1.在UserController中写UserInfo方法,添加注解@GetMapping("/userInfo")

    //获取用户数据
    @GetMapping("/userInfo")
    public Result<User> userInfo(){
        Map<String,Object> claims = ThreadLocalUtil.get();
        User user = userService.findByUserName((String) claims.get("username"));
        return Result.success(user);
    }

2.由用户名获取登录后的用户数据,用户名不需要传入,直接从token中获取,结果返回User对象

    //获取用户数据
    @GetMapping("/userInfo")
    public Result<User> userInfo(@RequestHeader(name = "Authorization") String token){
        Map<String,Object> claims = JwtUtil.parseToken(token);
        User user = userService.findByUserName((String) claims.get("username"));
        return Result.success(user);
    }

3.直接查询获取的用户对象返回的JSON数据中有password,应该排除;

在User类上的password参数上添加注解@JsonIgnore,让SpringMVC把当前对象转换成JSON字符串时忽略password,最终JSON字符串中就没有password这个参数了

4.查询时没有查出createTime和updateTime;

因为在数据库中是下划线命名,而User类中是驼峰命名,需要在yml配置文件中添加一个配置项camel,设置值为true

mybatis:
  configuration:
    map-underscore-to-camel-case: true #开启驼峰命名和下划线命名的转换

2、代码优化

使用ThreadLocal提高代码复用性(1.线程隔离2.共享数据)

1.在拦截器中获取到用户数据后,直接存到ThreadLocal中ThreadLocalUtil.set(claims);

2.在运行完后使用拦截器清除数据

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //清空ThreadLocal中的用户数据,防止内存泄漏
        ThreadLocalUtil.remove();
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }

4、更新用户基本信息

1、功能实现

1.在UserConTroller写update方法，添加@PutMapping("/update")注解

    //更新用户基本信息
    @PutMapping("/update")
    public Result update(@RequestBody @Validated User user){
        userService.update(user);
        return Result.success();
    }

2.方法传递的参数User使用@RequestBody注解

        (@RequestBody用来接收前端传递给后端的json字符串中的数据(请求体中的数据的))

    //更新用户基本信息
    @PutMapping("/update")
    public Result update(@RequestBody User user){
        userService.update(user);
        return Result.success();
    }

3.UserService接口中写update方法,UserServiceImpl中实现方法

4.实现方法中直接更新User对象中的数据,更新时也直接传递新的user对象

    @Override
    public void update(User user) {
        user.setUpdateTime(LocalDateTime.now());
        userMapper.update(user);
    }

5.UserMapper接口中写update方法,方法上添加注解SQL

    @Update("update user set nickname=#{nickname},email=#{email},update_time=#{updateTime} where id=#{id}")
    void update(User user);

2、参数校验

因为update方法传递的是User对象,不能直接在参数前使用@Pattern注解;

使用Validation提供的另一种方法

1.在实体类内的参数上添加注解

(@NotNull:值不为null,@NotEmpty:值不为null且不为空,@Email满足邮箱格式)

@Data
public class User {

    @NonNull
    private Integer id;//主键ID

    private String username;//用户名

    @JsonIgnore//让SpringMVC把当前对象转换成JSON字符串时忽略password,最终JSON字符串中就没有password这个属性了
    private String password;//密码

    @NotEmpty
    @Pattern(regexp = "^\\S{1,10}$")
    private String nickname;//昵称

    @Email
    private String email;//邮箱

    private String userPic;//用户头像地址

    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间

    public User() {
    }
}

        此处出现了报错  com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.xxx.ins.smp.tpa.domain.CommonResponseHead` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

        原因是json转换的时候发生反序列化错误,因为缺少无参构造方法,添加上即可

2.在update方法的实体类参数User前添加@Validated注解

5、更新用户头像

1.在UserConTroller写updateAvatar方法，添加@PatchMapping("/updateAvatar")注解(@PutMapping修改的是整个对象,@PatchMapping进行对象的局部更新)

2.方法传递头像的URL为参数,使用@RequestParam注解(将请求参数区域的数据映射到控制层方法的参数);添加@URL注解保证参数的格式

    //更新用户头像
    @PatchMapping("/updateAvatar")
    public Result updateAvatar(@RequestParam @URL String avatarUrl){
        userService.updateAvatar(avatarUrl);
        return Result.success();
    }

3.UserService接口中写update方法,UserServiceImpl中实现方法
​

    @Override
    public void updateAvatar(String avatarUrl) {
        //从token中获取到的用户数据被存到了ThreadLocal中了
        //从ThreadLocal中直接获取后再传给Mapper层即可
        Map<String,Object> claims = ThreadLocalUtil.get();
        Integer id = (Integer) claims.get("id");
        userMapper.updateAvatar(avatarUrl,id);
    }

4.UserMapper接口中写updateAvatar方法,方法上添加注解SQL

  @Update("update user set user_pic=#{avatarUrl},update_time=now() where id=#{id}")
    void updateAvatar(String avatarUrl,Integer id);

6、更新用户密码

1.在UserConTroller写updatePwd方法，添加@PatchMapping("/updatePwd")注解

2.方法的参数从请求体中获取(旧密码和两次输入的新密码),使用@RequestBody注解(将请求参数区域的数据映射到控制层方法的参数);将新密码传出到UserService(使用Md5加密后的)

@RequestParam->请求中的一般参数(String)
@RequestBody->请求体中的JSON数据

    //更新用户密码
    @PatchMapping("/updatePwd")
    public Result updatePwd(@RequestBody Map<String,String> params){
        //参数校验
        String oldPwd = params.get("oldPwd");
        String newPwd = params.get("newPwd");
        String rePwd = params.get("rePwd");
        if (!StringUtils.hasLength(oldPwd)||!StringUtils.hasLength(newPwd)||!StringUtils.hasLength(rePwd)) {
            return Result.error("输入不能为空");
        }

        //拦截器中把用户数据从token中提取出来,放到了ThreadLocalUtil中,可以直接调用
        Map<String,Object> claims = ThreadLocalUtil.get();
        User user = userService.findByUserName((String) claims.get("username"));

        if (Md5Util.getMD5String(oldPwd).equals(user.getPassword())) {
            if (!oldPwd.equals(newPwd)) {
                if (newPwd.equals(rePwd)) {
                    userService.updatePwd(Md5Util.getMD5String(newPwd));
                    return Result.success();
                } else {
                    return Result.error("两次密码不一致");
                }
            }else {
                return Result.error("新密码不能与原密码一致");
            }
        }else {
            return Result.error("密码错误");
        }
    }

3.UserService接口中写update方法,UserServiceImpl中实现方法

从token中获取到的用户数据被存到了ThreadLocal中了
从ThreadLocal中直接获取后再传给Mapper层即可

    @Override
    public void updatePwd(String newPwd) {
        Map<String,Object> claims = ThreadLocalUtil.get();
        Integer id = (Integer) claims.get("id");
        userMapper.updatePwd(newPwd,id);
    }

4.UserMapper接口中写updatePwd方法,方法上添加注解SQL

    @Update("update user set password=#{newPwd},update_time=now() where id=#{id}")
    void updatePwd(String newPwd,Integer id);

2、文章分类

1、新增文章分类

1.创建CategoryController类

        1)添加注解@RestController,@RequestMapping("/category"),@Validated

        2)创建CategoryService对象,添加@Autowired注解

        3)添加add方法,添加@PostMapping注解

        4)给方法的参数添加@Validated注解

        5)在Category类中的必要参数添加@NotEmpty注解,实现参数校验

    @PostMapping
    public Result add(@RequestBody @Validated Category category){
        categoryService.add(category);
        return Result.success();
    }

2.创建CategoryService接口,添加add方法

3.创建CategoryServiceImpl类,实现CategoryService接口

        1)添加注解@Service

        2)创建CategoryMapper对象,添加@Autowired注解

        3)实现add方法,利用ThreadLocal从token中获取数据,获得用户ID后添加给Category对象

    @Override
    public void add(Category category) {
        Map<String,Object> claims = ThreadLocalUtil.get();
        Integer id = (Integer) claims.get("id");
        category.setCreateUser(id);
        categoryMapper.add(category);
    }

4.创建CategoryMapper接口,添加add方法,添加SQL语句注解

    @Insert("insert into category " +
            "(category_name,category_alias,create_user,create_time,update_time) values " +
            "(#{categoryName},#{categoryAlias},#{createUser},now(),now())")
    void add(Category category);

数据库内容成功插入,但是返回了错误,同时后台报错

Circular view path [category]: would dispatch back to the current handler URL [/category] again. Check your ViewResolver setup! (Hint: This may be the result of an unspecified view, due to default view name generation.)

修改后数据库内容仍能成功插入,但是开始报404异常

原因:忘了在Controller类上添加@RestController注解(添加错注解了,记错了,添加成了@Controller)

2、文章分类列表

1.在CategoryController类添加list方法,返回参数为Result<List<Category>>,添加@GetMapping注解

    @GetMapping
    public Result<List<Category>> list(){
        return Result.success(categoryService.list());
    }

2.在CategoryService接口添加list方法;CategoryServiceImpl类中实现方法

        从ThreadLocal中获取用户ID传给CategoryMapper

    @Override
    public List<Category> list() {
        Map<String,Object> claims = ThreadLocalUtil.get();
        List<Category> list = categoryMapper.list((Integer) claims.get("id"));
        return list;
    }

3.在CategoryMapper接口添加list方法,添加SQL语句注解

    @Select("select * from category where create_user = #{createUser}")
    List<Category> list(Integer createUser);

4.给返回的时间自定义格式

        在Category类中的createTime和updateTime上添加注解

                @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")

5.给ID添加@NotNull注解之后,新增出现问题,因为在向数据库中插入数据时ID一定为null

        分组校验

        1.定义分组

                在Category类中创建对应接口

    public interface Add{

    }

    public interface Update{

    }

        2.定义校验项时指定归属的分组

                在@NotNull注解内传递groups参,同一校验项可以指定多个分组

    @NotNull(groups = Update.class)
    private Integer id;//主键ID

    @NotEmpty(groups = {Add.class,Update.class})
    @Pattern(regexp = "^\\S{1,10}$")
    private String categoryName;//分类名称

    @NotEmpty(groups = {Add.class,Update.class})
    private String categoryAlias;//分类别名

        3.校验时指定要校验的分组

                在@Validated注解内添加参数,以接口名选择分组

                //如果某个校验项没有指定分组，默认属于Default分组

                //分组之间可以继承，A extends B 那么A中拥有B中所有的校验项

    public Result add(@RequestBody @Validated(Category.Add.class) Category category){

    public Result update(@RequestBody @Validated(Category.Update.class) Category category){

3、获取文章分类详情

​1.在CategoryController类添加query方法,添加@GetMapping("/detail")注解

    @GetMapping("/detail")
    public Result<Category> query(Integer id){
        Category category = categoryService.queryById(id);
        if (category != null) {
            return Result.success(category);
        }else {
            return Result.error("没有此文章分类");
        }
    }

2.在CategoryService接口添加queryById方法;CategoryServiceImpl类中实现方法
        从ThreadLocal中获取用户ID传给CategoryMapper

    @Override
    public Category queryById(Integer id) {
        return categoryMapper.queryById(id);
    }

3.在CategoryMapper接口添加queryById方法,添加SQL语句注解

    @Select("select * from category where id = #{id}")
    Category queryById(Integer id);

4、更新文章分类

​1.在CategoryController类添加update方法,添加@PutMapping注解,向CategoryService传递        Category对象作为参数,修改需要参数校验,在参数前添加@Validated注解

        @NotNull和@NotEmpty的区别:

                @NotNull保证不能为空 

                @NotEmpty保证不能为空,且为字符串时还不能为空字符串

    @PutMapping
    public Result update(@RequestBody @Validated Category category){
        categoryService.update(category);
        return Result.success();
    }

2.在CategoryService接口添加update方法;CategoryServiceImpl类中实现方法

    @Override
    public void update(Category category) {
        categoryMapper.update(category);
    }

3.在CategoryMapper接口添加update方法,添加SQL语句注解

    @Update("update category set category_name=#{categoryName},category_alias=#{categoryAlias},update_time=now()" +
            " where id=#{id}")
    void update(Category category);

5、删除文章分类

​1.在CategoryController类添加delete方法,添加@DeleteMapping注解,传递分类ID作为参数

    @DeleteMapping
    public Result delete(@RequestParam Integer id){
        if (id == null) {
            return Result.error("输入不能为空");
        }
        if(categoryMapper.queryById(id)==null){
            return Result.error("该分类不存在");
        }
        categoryService.deleteById(id);
        return Result.success();
    }

2.在CategoryService接口添加deleteById方法;CategoryServiceImpl类中实现方法

    @Override
    public void deleteById(Integer id) {
        categoryMapper.deleteById(id);
    }

3.在CategoryMapper接口添加deleteById方法,添加SQL语句注解

    @Delete("delete from category where id=#{id}")
    void deleteById(Integer id);

3、文章

1、新增文章

1.创建ArticleController类
        1)添加注解@RestController,@RequestMapping("/article"),@Validated
        2)创建ArticleService对象,添加@Autowired注解
        3)添加add方法,添加@PostMapping注解
        4)给方法的参数添加@Validated注解
        5)在Article类中的必要参数添加@NotEmpty注解,实现参数校验

    @PostMapping
    public Result add(@RequestBody @Validated(Article.Add.class) Article article){
        articleService.add(article);
        return Result.success();
    }

2.创建ArticleService接口,添加add方法

3.创建ArticleServiceImpl类,实现ArticleService接口
        1)添加注解@Service
        2)创建ArticleMapper对象,添加@Autowired注解
        3)实现add方法,利用ThreadLocal从token中获取数据,获得用户ID后添加给Article对象

    @Override
    public void add(Article article) {
        Map<String,Object> claims = ThreadLocalUtil.get();
        article.setCreateUser((Integer) claims.get("id"));
        articleMapper.add(article);
    }

4.创建CategoryMapper接口,添加add方法,添加SQL语句注解

    @Insert("insert into article(title,content,cover_img,state,category_id,create_user,create_time,update_time)" +
            " values(#{title},#{content},#{coverImg},#{state},#{categoryId},#{createUser},now(),now())")
    void add(Article article);

自定义校验

1.自定义注解

        创建anno包,在包内创建注解,添加元注解和至少包含的三个属性message、groups、payload

@Documented//元注解
@Target({ElementType.FIELD})//元注解
@Retention(RetentionPolicy.RUNTIME)//元注解
@Constraint(validatedBy = {StateValidation.class})//指定提供校验规则的类
public @interface State {

    //提供校验失败后的提示信息
    String message() default "{state参数的值只能是已发布或草稿}";

    //指定分组
    Class<?>[] groups() default {};

    //负载 获取到state注解的附加信息
    Class<? extends Payload>[] payload() default {};
}

2.自定义校验数据的类实现ConstraintValidator接口

        创建validation包,创建StateValidation类,实现ConstraintValidator接口

//<给哪个注解提供校验规则,校验的数据类型>
public class StateValidation implements ConstraintValidator<State,String> {

    /*
    * @param value 将来要校验的数据
    * @param context
    *
    * @return 如果返回false,则校验不通过,如果返回true,则校验通过
    * */
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        //提供校验规则
        if (value == null) {
            return false;
        }
        return value.equals("已发布") || value.equals("草稿");
    }
}

3.在需要校验的地方使用自定义注解

        给Article类的参数State上添加@State注解

忘了在Controller类中方法中需要校验的参数前添加@Validated(Article.Add.class)注解

导致注解没有起作用

2、文章列表

条件分页

使用PageHelper插件完成分页,在Service层实现
        Controller层返回的参数为自定义的分页对象

1)创建PageBean对象

2)开启分页查询

3)调用Mapper层获取数据

4)Page中提供了方法,可以获取PageHelper分页查询后 得到的总记录条数和当前页数

5)把数据填充到PageBean中

功能实现

1.创建PageBean对象,用于返回结果对象

        参数为 总条数total和当前页数据集合List<T> items

​2.在ArticleController类添加query方法,添加@GetMapping注解

        传递参数PageNum,PageSize,CategoryId,state

        返回值为Result<PageBean<Article>>

因为categoryId和state是非必要的
        1)需要在注解@RequestParam中修改参数(required=false),不然若参数为空会报错
        2)参数不知道是否传递,SQL语句不能写死,只能使用动态SQL语句,使用Mapper映射文件

    @GetMapping
    public Result<PageBean<Article>> query
            (@RequestParam Integer pageNum, @RequestParam Integer pageSize,
             @RequestParam(required = false) Integer categoryId, @RequestParam(required = false) String state){
        PageBean<Article> articles = articleService.query(pageNum,pageSize,categoryId,state);
        return Result.success(articles);
    }

3.在ArticleService接口添加query方法;CategoryServiceImpl类中实现方法

        返回参数为PageBean<Article>

    @Override
    public PageBean<Article> query(Integer pageNum, Integer pageSize, Integer categoryId, String state) {
        //创建PageBean对象
        PageBean<Article> pageBean = new PageBean<>();
        //开启分页查询
        PageHelper.startPage(pageNum,pageSize);
        //调用Mapper层获取数据
        Map<String,Object> claims = ThreadLocalUtil.get();
        Integer userId = (Integer) claims.get("id");
        List<Article> articles = articleMapper.query(userId,categoryId,state);

        //Page中提供了方法,可以获取PageHelper分页查询后 得到的总记录条数和当前页数
        Page<Article> page = (Page<Article>) articles;
        //把数据填充到PageBean中
        pageBean.setTotal(page.getTotal());
        pageBean.setItems(page.getResult());

        return pageBean;
    }

4.在ArticleMapper接口添加query方法,因为参数不知道是否传递,SQL语句不能写死,只能使用动态SQL语句,使用Mapper映射文件

1)在resources创建中Mapper文件

        注意resources中的包路径和文件名要完全一致

2)namespace写对应的Mapper文件

3)id对应方法名

<mapper namespace="com.bigevent.mapper.ArticleMapper">
    <select id="query" resultType="com.bigevent.pojo.Article">
        select * from article
        <where>
            <if test="categoryId!=null">
                category_id=#{categoryId}
            </if>
            <if test="state!=null">
                and state=#{state}
            </if>

            and create_user=#{userId}
        </where>
    </select>
</mapper>

3、获取文章详情

​1.在ArticleController类添加detail方法,添加@GetMapping注解,传递分类ID作为参数

    @GetMapping("/detail")
    public Result<Article> detail(@RequestParam Integer id){
        Article article = articleService.detail(id);
        if (article == null) {
            return Result.error("文章不存在");
        }
        return Result.success(article);
    }

2.在ArticleService接口添加detailById方法;CategoryServiceImpl类中实现方法

    @Override
    public Article detail(Integer id) {
        return articleMapper.detail(id);
    }

3.在ArticleMapper接口添加detailById方法,添加SQL语句注解

    @Select("select * from article where id=#{id}")
    Article detail(Integer id);

4、更新文章

​1.在ArticleController类添加update方法,添加@PutMapping注解,传递分类ID作为参数

因为更新的外键问题,需要检查文章类型的id是否存在,在ArticleController里新建CategoryService对象,使用相应方法完成

    @PutMapping
    public Result update(@RequestBody @Validated(Article.Update.class) Article article){
        if (categoryController.query(article.getCategoryId()).getData() == null) {
            return Result.error("文章类型不存在");
        }
        if(articleService.detail(article.getId())==null){
            return Result.error("文章id不存在");
        }
        articleService.update(article);
        return Result.success();
    }

2.在ArticleService接口添加updateById方法;CategoryServiceImpl类中实现方法

    @Override
    public void update(Article article) {
        articleMapper.update(article);
    }

3.在ArticleMapper接口添加updateById方法,添加SQL语句注解

    @Update("update article set title=#{title},content=#{content},cover_img=#{coverImg}" +
            ",state=#{state},category_id=#{categoryId} where id=#{id}")
    void update(Article article);

5、删除文章

​1.在ArticleController类添加delete方法,添加@DeleteMapping注解,传递分类ID作为参数

    @DeleteMapping
    public Result delete(@RequestParam Integer id){
        if (articleService.detail(id) == null) {
            return Result.error("文章不存在");
        }
        articleService.delete(id);
        return Result.success();
    }

2.在ArticleService接口添加deleteById方法;CategoryServiceImpl类中实现方法

    @Override
    public void delete(Integer id) {
        articleMapper.delete(id);
    }

3.在ArticleMapper接口添加deleteById方法,添加SQL语句注解

    @Delete("delete from article where id=#{id}")
    void delete(Integer id);

4、文件上传

项目启动时出现了报错""Public Key Retrieval is not allowed""

解决:

        在application.yml文件的数据库连接中得名url后添加"&allowPublicKeyRetrieval=true"

1.创建FileUploadController,新建upload方法,添加@PostMapping("/upload")注解

        将数据上传到阿里云OSS上,并返回url

    @PostMapping("/upload")
    public Result<String> upload(MultipartFile file) throws Exception {
        //把文件内容存储到本地磁盘上
        String originalFilename = file.getOriginalFilename();
        //保证文件名字是唯一的,防止发送内容覆盖
        String filename = UUID.randomUUID().toString()+originalFilename.substring(originalFilename.lastIndexOf("."));
        //file.transferTo(new File("D:\\6\\bigevent\\files"+filename));
        String url = AliOssUtil.uploadFile(filename,file.getInputStream());
        return Result.success(url);
    }

5、登录优化

使用Redis对登录进行优化,在用户修改密码后将旧密码获取的旧令牌主动失效

令牌主动失效机制

1.登录成功后，给浏览器响应令牌的同时，把该令牌存储到redis中

2.LoginInterceptor拦截器中，需要验证浏览器携带的令牌，并同时需要获取到redis中存储的与之相同的令牌

3.当用户修改密码成功后，删除redis中存储的旧令牌

1、SpringBoot集成Redis

1.在pom文件中引入依赖

2.在yml配置文件中配置Redis属性

spring:
  data:
    redis:
      host: localhost
      port: 6379

3.测试

1)在测试类上添加注解@SpringBootTest,让测试类可以获取到Spring容器中的对象

2)创建StringRedisTemplate对象,添加@Autowired注解

3)测试方法

    @Test
    public void testSet(){
        //测试存储键值对
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
        operations.set("username","zhangsan");
        operations.set("id","1");

    }

    @Test
    public void testGet(){
        //测试存储键值对
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
        System.out.println(operations.get("username"));
    }

2、使用Redis实现登录优化

1)修改UserController中的login方法

        在登录成功后将token存入到Redis中,直接将键名和键值都设为token;验证时只需要使用token作为键名看是否能获取到数据

            //把token存储到Redis中
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            operations.set(token,token,1,TimeUnit.HOURS);

2)修改LoginInterceptor中的preHandle方法

        从Redis中获取相同的token,如果Redis中获取的数据为空则说明token失效,登录失败

            //从Redis中获取相同的token
            ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
            String redisToken = operations.get(token);
            if (redisToken==null){
                //token已经失效了
                throw new RuntimeException();
            }

3)修改UserController中的updatePwd方法

        在验证修改密码成功时通过token作为键名将Redis中存储的token删除,之后用户将无法再通过此token进行操作

                    //删除Redis中对应的token
                    ValueOperations<String, String> operations = redisTemplate.opsForValue();
                    operations.getOperations().delete(token);

6、多开发环境

需要设置多个开发环境时

1、单配置文件中配置

1)使用---分隔不同配置

#通用信息,,指定生效的环境

spring:
  profiles:
    active: dev
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/big_event?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT&allowPublicKeyRetrieval=true
    username: root
    password: password
  mvc:
    servlet:
      load-on-startup: 1
  data:
    redis:
      host: localhost
      port: 6379

mybatis:
  configuration:
    map-underscore-to-camel-case: true #开启驼峰命名和下划线命名的转换

---
#开发环境

spring:
  config:
    activate:
      on-profile: dev


server:
  port: 8080

---
#测试环境

spring:
  config:
    activate:
      on-profile: test

server:
  port: 8081

2、多配置文件中配置

1.

开发->application-dev.yml

测试->application-test.yml

生产->application-pro.yml        (-后的环境名称可自定义)

再在application.yml中指定配置环境(也可以配置共性环境)

2.

将文件进一步按照功能进一步细分

服务器->application-devServer.yml

数据源->application-devDB.yml

自定义->application-devSelf.yml

再在application.yml中指定配置环境处添加组

spring:
  profiles:
    active: dev
    group: devServer,devDB,devSelf