# read_project

**Repository Path**: linlilover/read_project

## Basic Information

- **Project Name**: read_project
- **Description**: read project
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-07-11
- **Last Updated**: 2024-07-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## 1.创建项目
![](/Users/ivan/Downloads/Snip20240709_1.png)
## 2.引入依赖
![](/Users/ivan/Downloads/Snip20240709_2.png)
![](/Users/ivan/Downloads/Snip20240709_3.png)
## 3.创建目录
![](/Users/ivan/Downloads/Snip20240709_4.png)
## 4.数据库设置
```yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/big_event
    username: root
    password: root

```
```sql
create database big_event;
use big_event;
create table user
(
    id          int unsigned primary key auto_increment comment 'ID',
    username    varchar(20) not null unique comment '用户名',
    password    varchar(32) comment '密码',
    nickname    varchar(10)  default '' comment '昵称',
    email       varchar(128) default '' comment '邮箱',
    user_pic    varchar(128) default '' comment '头像',
    create_time datetime    not null comment '创建时间',
    update_time datetime    not null comment '修改时间'
) ENGINE=InnoDB DEFAULT charset=utf8 comment '用户表';
create table category
(
    id             int unsigned primary key auto_increment comment 'ID',
    category_name  varchar(32) not null comment '分类名称',
    category_alias varchar(32) comment '分类别名',
    create_time    datetime    not null comment '创建时间',
    update_time    datetime    not null comment '修改时间',
    user_id int  unsigned default null,
    key fk_category_user(user_id),
    constraint fk_category_user foreign key (user_id) references user (id)
)ENGINE=InnoDB DEFAULT charset=utf8 comment '分类表';
# alter table category engine=innodb;

create table article
(
    id          int unsigned primary key auto_increment comment 'ID',
    title       varchar(30)    not null comment '文章标题',
    content     varchar(10000) not null comment '文章内容',
    cover_img   varchar(128)   not null comment '文章封面',
    state       varchar(3) default '草稿' comment '文章状态已发布，草稿',
    category_id int unsigned comment '文章分类id',
    create_user int unsigned   not null comment '创建人id',
    create_time datetime       not null comment '创建时间',
    update_time datetime       not null comment '修改时间',
    cate_id int unsigned default null,
    key fk_article_category(cate_id),
    user_id int  unsigned default null,
    key fk_article_user(user_id),
    constraint fk_article_category foreign key (cate_id) references category (id),
    constraint fk_article_user foreign key (user_id) references user (id)
)ENGINE=InnoDB DEFAULT charset=utf8 comment '文章表';
```

## 5.业务代码编写
```java
//1.实体类
@Data
public class User {
    private Integer id;
    private String username;
    private String password;
    private String nickname;
    private String email;
    private String userPic;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@NoArgsConstructor
@AllArgsConstructor
@Data
public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    public static <E> Result<E> success(E data){
        return new Result<>(0,"操作成功",data);
    }
    public static Result success(){
        return new Result(0,"操作成功",null);
    }
    public static Result error(String message){
        return new Result(1,message,null);
    }
}
//2.controller
@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 user=userService.findByUserName(username);
        if(user==null){
            userService.register(username,password);
            return Result.success();
        }else{
            return Result.error("用户名已被占用");
        }
    }
}
//3.service
public interface UserService {

    User findByUserName(String username);

    void register(String username, String password);
}


@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 s = Md5Utils.encrypt3ToMd5(password);
        userMapper.register(username,s);
    }
}
//4.mapper
@Mapper
public interface UserMapper {
    @Insert("insert into user(username,password,create_time,update_time)" +
            " values(#{username},#{password},now(),now())")
    void register(String username, String password);

    @Select("select * from user where username=#{username}")
    User findByUserName(String username);
}
//5.异常处理
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e){
        e.printStackTrace();
        return Result.error(StringUtils.hasLength(e.getMessage())?e.getMessage():"操作失败");
    }
}
//6.工具类
public class Md5Utils {
    public static String encrypt3ToMd5(String str) {
        return org.springframework.util.DigestUtils.md5DigestAsHex(str.getBytes(StandardCharsets.UTF_8));
    }
}
```



## 1.获取用户信息
```java
        @GetMapping("/userInfo")
        //    @RequestHeader(name = "Authorization") String token
        public Result<User> userInfo(){
        //   Map<String, Object> map = JwtUtil.parseToken(token);
            Map<String,Object> map = ThreadLocalUtil.get();
    
            String username =(String) map.get("username");
            User user = userService.findByUserName(username);
            return Result.success(user);
        }

        User findByUserName(String username);
        @Override
        public User findByUserName(String username) {
            User u=userMapper.findByUserName(username);
            return u;
        }

        @Select("select * from user where username=#{username}")
        User findByUserName(String username);
    
```
## 2.更新用户信息

```java

   @PutMapping("/update")
    public Result update(@RequestBody @Validated User user){
        userService.update(user);
        return Result.success();
    }

    void update(User user);
   @Override
   public void update(User user) {
           user.setUpdateTime(LocalDateTime.now());
           userMapper.update(user);
   }
   @Update("update user set nickname=#{nickname},email=#{email},update_time=#{updateTime} where id=#{id}")
    void update(User user);
```

## 3.更新头像
```java
  @PatchMapping("/updateAvatar")
    public Result updateAvatar(@RequestParam @URL String url){
        userService.updateAvatar(url);
        return Result.success();
    }
        void updateAvatar(String url);
@Override
public void updateAvatar(String url) {
        Map<String,Object> o = ThreadLocalUtil.get();
        Integer id =(Integer) o.get("id");
        userMapper.updateAvatar(url,id) ;
        }

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


```
## 4.更新密码

```java

   @PatchMapping("/updatePwd")
    public Result updatePwd(@RequestBody Map<String,String> params){
        String oldPwd = params.get("old_pwd");
        String newPwd = params.get("new_pwd");
        String rePwd = params.get("re_pwd");
        if(!StringUtils.hasLength(oldPwd) ||
        !StringUtils.hasLength(newPwd)||
        !StringUtils.hasLength(rePwd)){
            return Result.error("缺少必要参数");
        }
        Map<String,Object> map = ThreadLocalUtil.get();
        String username = (String) map.get("username");
        User user = userService.findByUserName(username);
        if(!user.getPassword().equals(Md5Utils.encrypt3ToMd5(oldPwd))){
            return Result.error("原密码填写不正确");
        }
        if(!rePwd.equals(newPwd)){
            return Result.error("两次填写的密码不一致");
        }
        userService.updatePwd(newPwd);
        return Result.success();
    }
    void updatePwd(String newPwd);
   @Override
   public void updatePwd(String newPwd) {
           Map<String,Object> map = ThreadLocalUtil.get();
           Integer id = (Integer) map.get("id");
           userMapper.updatePwd(Md5Utils.encrypt3ToMd5(newPwd),id);
   }
   @Update("update user set password=#{s},update_time=now() where id=#{id}")
    void updatePwd(String s,Integer id);
```


## 1.添加文章信息
```java
    @PostMapping
    public Result add(@RequestBody @Validated Article article){
        articleService.add(article);
        return Result.success();
    }
        void add(Article article);
@Override
public void add(Article article) {
        article.setCreateTime(LocalDateTime.now());
        article.setUpdateTime(LocalDateTime.now());
        Map<String,Object> map = ThreadLocalUtil.get();
        Integer id =(Integer) map.get("id");
        article.setUserId(id);
        articleMapper.add(article);
        }

@Insert("insert into article(title,content,cover_img,state,cate_id," +
        "create_time,update_time,user_id)" +
        " values (#{title},#{content},#{coverImg},#{state},#{cateId}," +
        "#{createTime},#{updateTime},#{userId})")
    void add(Article article);


```
## 2.查询文章信息
```java

 @GetMapping
    public Result<PageBean<Article>> list(
            Integer pageNum,
            Integer pageSize,
            @RequestParam(required = false) Integer cateId,
            @RequestParam(required = false) String state

    ){
        PageBean<Article> pb=articleService.list(pageNum,pageSize,cateId,state);
        return Result.success(pb);
    }

         PageBean<Article> list(Integer pageNum, Integer pageSize, Integer cateId, String state);

 @Override
 public PageBean<Article> list(Integer pageNum, Integer pageSize, Integer cateId, String state) {
         PageBean<Article> pageBean = new PageBean<>();
         PageHelper.startPage(pageNum,pageSize);
         Map<String,Object> map = ThreadLocalUtil.get();
         Integer id = (Integer) map.get("id");
         List<Article> as=articleMapper.list(id,cateId,state);
         Page<Article> p=(Page<Article>) as;
         pageBean.setTotal(p.getTotal());
         pageBean.setItems(p.getResult());
         return pageBean;
         }


         List<Article> list(Integer userId, Integer cateId, String state);

 @Data
 public class Article {
     private Integer id;
     @NotEmpty
     @Pattern(regexp = "^\\S{1,10}$")
     private String title;
     @NotEmpty
     private String content;
     @NotEmpty
     @URL
     private String coverImg;
     @State
     private String state;
     private Integer userId;
     @NotNull
     private Integer cateId;
     private LocalDateTime createTime;
     private LocalDateTime updateTime;
 }
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 public class PageBean <T>{
     private Long total;
     private List<T> items;
 }

 @Documented
 @Constraint(
         validatedBy = {StateValidation.class}
 )
 @Target({ ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface State {
     String message() default "state参数的值只能是已经发布或者草稿";

     Class<?>[] groups() default {};

     Class<? extends Payload>[] payload() default {};
 }


 public class StateValidation implements ConstraintValidator<State,String> {

     @Override
     public boolean isValid(String var1, ConstraintValidatorContext var2){
         if(var1==null)return false;
         if(var1.equals("已发布")||var1.equals("草稿"))return true;
         return false;
     }
 }

```

## 3.配置分页
```xml
   <dependency>
          <groupId>com.github.pagehelper</groupId>
          <artifactId>pagehelper-spring-boot-starter</artifactId>
          <version>1.4.6</version>
      </dependency>

```
## 4.redis使用存储token
```xml
    <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
      </dependency>
```
```yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/big_event
    username: root
    password: root
  data:
    redis:
      host: localhost
      port: 6379
```
```java

    @PatchMapping("/updatePwd")
    public Result updatePwd(@RequestBody Map<String,String> params,@RequestHeader("Authorization")String token){
        String oldPwd = params.get("old_pwd");
        String newPwd = params.get("new_pwd");
        String rePwd = params.get("re_pwd");
        if(!StringUtils.hasLength(oldPwd) ||
        !StringUtils.hasLength(newPwd)||
        !StringUtils.hasLength(rePwd)){
            return Result.error("缺少必要参数");
        }
        Map<String,Object> map = ThreadLocalUtil.get();
        String username = (String) map.get("username");
        User user = userService.findByUserName(username);
        if(!user.getPassword().equals(Md5Utils.encrypt3ToMd5(oldPwd))){
            return Result.error("原密码填写不正确");
        }
        if(!rePwd.equals(newPwd)){
            return Result.error("两次填写的密码不一致");
        }
        userService.updatePwd(newPwd);
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
        operations.getOperations().delete(token);
        return Result.success();
    }

    @PostMapping("/login")
    public Result<String> login(@Pattern(regexp = "^\\S{4,16}$") String username,
    @Pattern(regexp = "^\\S{5,16}$") String password){
            User loginUser = userService.findByUserName(username);
            if(loginUser==null){
            return Result.error("用户名错误");
            }
            if(Md5Utils.encrypt3ToMd5(password).equals(loginUser.getPassword())){
            Map<String, Object> map = new HashMap<>();
            map.put("id",loginUser.getId());
            map.put("username",loginUser.getUsername());
            String s = JwtUtil.genToken(map);
            ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
            operations.set(s,s,1, TimeUnit.HOURS);
            return Result.success(s);
            }
            return Result.error("密码错误");

            }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            String token = request.getHeader("Authorization");
            try {
            ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
            String s = operations.get(token);
            if(s==null){
            throw new RuntimeException();
            }

            Map<String, Object> map = JwtUtil.parseToken(token);
            ThreadLocalUtil.set(map);
            return true;
            }catch (Exception e){
            response.setStatus(401);
            return false;
            }
            }
```