黑马头条平台管理实战

Capricornus Gold Snake

已于 2025-01-08 16:33:45 修改

阅读量1.1k

点赞数 17

CC 4.0 BY-SA版权

文章标签： java

于 2025-01-06 17:19:24 首次发布

本文链接：https://blog.csdn.net/weixin_54101103/article/details/144746157

黑马头条 08平台管理

1.开始准备和开发思路
- 1.1.开发网关
- 1.2编写admin-gateway 代码
2.开发登录微服务
- 2.1编写登录微服务
3.频道管理
4.敏感词管理
5.用户认证审核
6.自媒体文章人工审核
99. 最后开发中碰到的问题汇总

程序源码会以压缩包形式放在这需要的可以取用
需求和接口文档
https://javazhang.lan删zn.com/ix除9CG2k4exxc

https://javazhang.la删nzn.com/iJau除e2k4eyid
全部代码
htt删ps://javazhang.lan除zn.com/iPTju2kcaenc
密码:i6it

1.开始准备和开发思路

（1）发现有登录请求都需要一个网关作为支撑，所以先解决网关问题

1.1.开发网关

待完成项

nacos 写一套配置
完成网关类编写

学习nacos 配置中学到了 CORS（跨域资源共享），它是一种安全机制，可以指定哪些外部来源（域、协议或端口）可以访问其资源，当一个网页尝试从不同于他的源（即域名、协议或端口号不同）加载资源，浏览器会检查是否允许这种跨域请求
初步nacos配置

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]': #匹配所有请求都处理ocrs跨域问题
            allowerdOrigins: "*"  #跨域处理哪些请求会被允许 
            allowedMethods:   #可以跨域请求的方法
             - GET
             - POST
             - PUT
             - DELETE

编写网关配置类
routes: 下的是每一个微服务，只有编写微服务才有对应的uri 等配置
网关类看懂后，参考完成的类复制粘贴即可
一共需要网关配一套 nacos 微服务也有一套nacos 网关中nacos 嵌套微服务的地址，达到转发的目的

1.2编写admin-gateway 代码

在这里插入图片描述
过滤器和工具类可以从wemedia 网关中拷贝一份
AuthorizeFilter 类

package com.heima.admin.gateway.filter;

import com.heima.admin.gateway.util.AppJwtUtil;
import io.jsonwebtoken.*;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;

public class AuthorizeFilter implements Ordered, GlobalFilter {
   
   

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
   
   
        //1.获取request 和 response 对象
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //2.判断是否是登陆
        //uri 是完整路径   path 是从完整路径里取到路径
        if (request.getURI().getPath().contains("/login")){
   
   
            //放行
            return chain.filter(exchange);

        }
        //3.获取token
        String tocken = request.getHeaders().getFirst("token");
        //4.判断token是否岑在
        if (StringUtils.isBlank(tocken)){
   
   
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //5.判断token是否有效
        try {
   
   
            Claims claimsBody = AppJwtUtil.getClaimsBody(tocken);
            //判断是否过期
            int i = AppJwtUtil.verifyToken(claimsBody);
            if (i ==1 || i== 2){
   
   
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.setComplete();
            }
            //获取用户信息存入hader中
            Object userId = claimsBody.get("id");
            ServerHttpRequest serverHttpRequest = request.mutate().headers(httpHeaders -> {
   
   
                httpHeaders.add("userId", userId + "");
            }).build();
            //重置请求
            exchange.mutate().request(serverHttpRequest);

        }catch (Exception e){
   
   
            e.printStackTrace();
        }
        //6.放行
        return chain.filter(exchange);
    }


    /**
     * 优先级设置 值越小 优先级越大
     * @return
     */
    @Override
    public int getOrder() {
   
   
        return 0;
    }

    }

AppJwtUtil 类

package com.heima.admin.gateway.util;

import io.jsonwebtoken.*;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.*;

public class AppJwtUtil {
   
   

    //TOKEN的有效期一天
    private static final int TOKEN_TIME_OUT = 24 * 60 * 60;
    //加密KEY
    private static final String TOKEN_ENCRY_KEY="MDk4ZjZiY2Q0NjIxZDM3M2NhZGU0ZTgzMjYyN2I0ZjY";
    //最小刷新间隔S
    private static final int REFRESH_TIME = 300;

    //生产ID
    public static String getToken(Long id){
   
   
        Map<String , Object> claimMaps = new HashMap<>();
        long currentTime = System.currentTimeMillis();
        claimMaps.put("id",id);
        return Jwts.builder()
                .setId(UUID.randomUUID().toString())
                .setIssuedAt(new Date(currentTime)) //签发时间
                .setSubject("system")
                .setAudience("app")
                .compressWith(CompressionCodecs.GZIP)
                .signWith(SignatureAlgorithm.HS512 , generalKey())
                .setExpiration(new Date(currentTime + TOKEN_TIME_OUT * 1000))//过期时间戳
                .addClaims(claimMaps)
                .compact();
    }

    /**
     * 获取token中的claims信息
     *
     * @param token
     * @return
     */
    private static Jws<Claims> getJws(String token) {
   
   
        return Jwts.parser()
                .setSigningKey(generalKey())
                .parseClaimsJws(token);
    }
    /**
     * 获取payload body信息
     *
     * @param token
     * @return
     */
    public static Claims getClaimsBody(String token) {
   
   
        try {
   
   
            return getJws(token).getBody();
        }catch (ExpiredJwtException e){
   
   
            return null;
        }
    }
    /**
     * 获取hearder body信息
     *
     * @param token
     * @return
     */
    public static JwsHeader getHeaderBody(String token) {
   
   
        return getJws(token).getHeader();
    }

    /**
     * 是否过期
     *
     * @param claims
     * @return -1：有效，0：有效，1：过期，2：过期
     */
    public static int verifyToken(Claims claims) {
   
   
        if(claims==null){
   
   
            return 1;
        }
        try {
   
   
            claims.getExpiration()
                    .before(new Date());
            // 需要自动刷新TOKEN
            if((claims.getExpiration().getTime()-System.currentTimeMillis())>REFRESH_TIME*1000){
   
   
                return -1;
            }else {
   
   
                return 0;
            }
        } catch (ExpiredJwtException ex) {
   
   
            return 1;
        }catch (Exception e){
   
   
            return 2;
        }
    }
    /**
     * 由字符串生成加密key
     *
     * @return
     */
    public static SecretKey generalKey() {
   
   
        byte[] encodedKey = Base64.getEncoder().encode(TOKEN_ENCRY_KEY.getBytes());
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }
    public static void main(String[] args) {
   
   
       /* Map map = new HashMap();
        map.put("id","11");*/
        System.out.println(AppJwtUtil.getToken(1102L));
        Jws<Claims> jws = AppJwtUtil.getJws("eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAADWLQQqEMAwA_5KzhURNt_qb1KZYQSi0wi6Lf9942NsMw3zh6AVW2DYmDGl2WabkZgreCaM6VXzhFBfJMcMARTqsxIG9Z888QLui3e3Tup5Pb81013KKmVzJTGo11nf9n8v4nMUaEY73DzTabjmDAAAA.4SuqQ42IGqCgBai6qd4RaVpVxTlZIWC826QA9kLvt9d-yVUw82gU47HDaSfOzgAcloZedYNNpUcd18Ne8vvjQA");
        Claims claims = jws.getBody();
        System.out.println(claims.get("id"));

    }
}

主启动类 AdminWebGatewayAplication

package com.heima.admin.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;


@SpringBootApplication
@EnableDiscoveryClient
public class AdminWebGatewayAplication {
   
   

    public static void main(String[] args) {
   
   
        SpringApplication.run(AdminWebGatewayAplication.class,args);
    }
}

配置文件

server:
  port: 6001
spring:
  application:
    name: leadnews-admin-web-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.200.130:8848
      config:
        server-addr: 192.168.200.130:8848
        file-extension: yml

Nacos 配置

spring:
  cloud:
    gateway:
      globalcors:
        add-to-simple-url-handler-mapping: true
        corsConfigurations:
          '[/**]':
            allowedHeaders: "*"
            allowedOrigins: "*"
            allowedMethods:
              - GET
              - POST
              - DELETE
              - PUT
              - OPTION

2.开发登录微服务

别忘记按照要求导入pojo类
在这里插入图片描述

2.1编写登录微服务

创建对应模块
在这里插入图片描述

LoginController 代码

package com.heima.adminWeb.controller.v1;

import com.heima.adminWeb.service.AwUserService;
import com.heima.model.admin.web.dto.AdminLoginDto;
import com.heima.model.common.dtos.ResponseResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/login")
@Slf4j
public class LoginController {
   
   

    @Autowired
    private AwUserService awUserService;
    @PostMapping("/in")
    public ResponseResult login(@RequestBody AdminLoginDto dto){
   
   
            log.info("dto{}",dto);
      return   awUserService.login(dto);

    }
}

AwUserMapper代码

package com.heima.adminWeb.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.heima.model.admin.web.pojo.AdUser;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface AwUserMapper extends BaseMapper<AdUser> {
   
   
}

service 和 impl 实现类

package com.heima.adminWeb.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.heima.model.admin.web.dto.AdminLoginDto;
import com.heima.model.admin.web.pojo.AdUser;
import com.heima.model.common.dtos.ResponseResult;


public interface AwUserService extends IService<AdUser> {
   
   
     ResponseResult login( AdminLoginDto dto);
}

package com.heima.adminWeb.service.impl;


import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heima.adminWeb.mapper.AwUserMapper;
import com.heima.adminWeb.service.AwUserService;
import com.heima.model.admin.web.dto.AdminLoginDto;
import com.heima.model.admin.web.pojo.AdUser;
import com.heima.model.common.dtos.ResponseResult;

import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.utils.common.AppJwtUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import java.util.HashMap;

@Service
public class AwUserServiceImpl  extends ServiceImpl<AwUserMapper , AdUser> implements AwUserService {
   
   


    /**
     * @param dto
     * @return
     */
    @Override
    public ResponseResult login(AdminLoginDto dto) {
   
   
        //1.检查参数
        if (StringUtils.isBlank(dto.getName()) || StringUtils.isBlank(dto.getPassword()) ){
   
   
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        //检查用户是否存在
        AdUser adUser = getOne(Wrappers.<AdUser>lambdaQuery().eq(AdUser::getName, dto.getName()));
        if (adUser == null){
   
   
            return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST);
        }
        //验证密码
        String salt = adUser.getSalt();
        String password = dto