• 黑马头条项目经验&BUG

    文章目录

    项目经验

    bootstrap.yaml

    同样是配置文件，但与application.yml有所不同

    1. bootstrap.yml的加载比application.yml早
    2. bootstrap.yml作用范围更广，可以被多个应用程序共享（可以在每个服务的application.yml中配置spring: cloud: config: (name)url，从而配置bootstrap.yml的位置）
    3. bootstrap.yml具有更高的优先级，可以覆盖application.yml中相同的配置信息

    密码加盐加密

    加盐：是指给每个用户随机生成一个字符串，需要和password进行结合
    加密：md5由于每次对相同的明文生成的密文相同，因此对加盐后的密码再进行md5加密DigestUtils.md5DigestAsHex(password.getBytes()

    JWT

    JWT是token的一种具体实现方式

    token

    token用于身份验证阶段，由服务端签发给客户端；客户端再次登录时可将token加入请求头Header中，服务器可验证token，验证成功即可向客户端返回请求的数据。

    可使用拦截器Interceptor或过滤器Filter拦截请求，然后使用HttpServletRequest.addHeader(String name,String value)将token加入请求头
    示例：

    request.addHeader("Authorization", "Bearer " + token);

    • 1
    Interceptor
    //创建拦截器对象
public class TokenInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = "your_token_value"; // 替换为实际的Token值
        request.addHeader("Authorization", "Bearer " + token);
        return true;
    }
}

//在配置类中注册拦截器
@Configuration
public class AppConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor()).addPathPatterns("/**");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    Filter
    //创建过滤器对象
public class TokenFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String token = "your_token_value"; // 替换为实际的Token值
        request.addHeader("Authorization", "Bearer " + token);
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

//在配置类中注册过滤器
@Configuration
public class AppConfig {
    @Bean
    public FilterRegistrationBean<TokenFilter> tokenFilter() {
        FilterRegistrationBean<TokenFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new TokenFilter());
        registrationBean.addUrlPatterns("/**");
        return registrationBean;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    服务端则可使用request.getHeader("name")获取请求头中的对应字段信息进而解析token

    上述Filter基于FilterRegistrationBean实现，另一种方法是直接在Filter的实现类上加上@WebFilter(urlPatterns = "/**")的注解，省去了编写配置类的操作

    • Interceptor是Spring框架提供的一种机制，它可以直接与Spring的上下文和生命周期集成。
    • Filter是Java Servlet规范提供的一种机制，它是在Servlet容器级别进行请求和响应的过滤。

    jwt结构

    JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。在传输的时候，会将JWT的3部分分别进行Base64编码(可理解为一种加密方式)后用.进行连接形成最终传输的字符串

    1. Header
      JWT由3部分组成：标头(Header)、有效载荷(Payload)和签名(Signature)。
      在传输的时候，会将JWT的3部分分别进行Base64编码后 用.进行连接形成最终传输的字符串
    {
  "alg": "HS256",
  "typ": "JWT"
}

    • 1
    • 2
    • 3
    • 4
    1. Payload
      有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择
    iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    这些预定义的字段并不要求强制使用。
    除以上默认字段外，还可以自定义私有字段，一般会把包含用户信息的数据放到payload中

    {
  "sub": "1234567890",
  "name": "Helen",
  "admin": true
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    默认情况下JWT是未加密的，因为只是采用base64算法，拿到JWT字符串后可以转换回原本的JSON数据，任何人都可以解读其内容，因此不要构建隐私信息字段，比如用户的密码一定不能保存到JWT中，以防止信息泄露。JWT只是适合在网络中传输一些非敏感的信息

    1. Signature
      签名哈希部分是对上面两部分数据签名，需要使用base64编码后的header和payload数据，通过指定的算法生成哈希，以确保数据不会被篡改。首先，需要指定一个密钥（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用header中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名
    HMAC SHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

    • 1

    在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用.分隔，就构成整个JWT对象

    jwt的使用

    java-jwt

    1. 引入依赖
    <dependency>
    <groupId>com.auth0groupId>
    <artifactId>java-jwtartifactId>
    <version>3.10.3version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    1. 生成jwt的token
    public class JWTTest {
    @Test
    public void testGenerateToken(){
        // 指定token过期时间为10秒
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 10);

        String token = JWT.create()
                .withHeader(new HashMap<>())  // Header
                .withClaim("userId", 21)  // Payload
                .withClaim("userName", "baobao")
                .withExpiresAt(calendar.getTime())  // 过期时间
                .sign(Algorithm.HMAC256("!34ADAS"));  // 签名用的secret

        System.out.println(token);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    1. 解析JWT
    @Test
public void testResolveToken(){
    // 创建解析对象，使用的算法和secret要与创建token时保持一致
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("!34ADAS")).build();
    // 解析指定的token
    DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyTmFtZSI6ImJhb2JhbyIsImV4cCI6MTU5OTkyMjUyOCwidXNlcklkIjoyMX0.YhA3kh9KZOAb7om1C7o3vBhYp0f61mhQWWOoCrrhqvo");
    // 获取解析后的token中的payload信息
    Claim userId = decodedJWT.getClaim("userId");
    Claim userName = decodedJWT.getClaim("userName");
    System.out.println(userId.asInt());
    System.out.println(userName.asString());
    // 输出超时时间
    System.out.println(decodedJWT.getExpiresAt());
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    网关过滤器

    创建一个类，实现Ordered和GlobalFilter接口，并重写需要的方法

    • getOrder()：设置优先级，值越小，优先级越高
    • Mono filter(ServerWebExchange exchange，GatewayFilterChain chain)

    示例代码：

    public class AuthFilter implements Ordered,GlobalFilter{
	@Override
	public int getOrder(){
		return 0;
	}

	@Override
	public Mono<void> filter(ServerWebExchange exchange，GatewayFilterChain chain){
		//1.获取request和response对象
		ServerHttpRequest request = exchange.getRequest();
		ServerHttpResponse response = exchange.getResponse();
		//2.判断是否是登录
		if(request.getURI().getPath().contains("/login")){
			//放行
			return chain.filter(exchange);
		}
		//3.获取token
		//这里是需要在登录的时候将token加入请求头中
		String token = request.getHeaders().getFirst("token");
		// 4.判断token是否存在
		if(StringUtils.isBlank(token){
			response.setStatusCode(HttpStatus.UNAUTHORIZED);	//该状态码为401
			return response.setComplete();
		}
		// 5.判断token是否有效
		// TODO(这里需要根据token获取Claim，再根据Claim中的字段判断token是否有效)
		// 如果token无效，就类似步骤4的处理；如果有效就接步骤6放行
		// 6.放行
		return chain.filter(exchange);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    FreeMarker

    模板引擎
    在这里插入图片描述
    FreeMarker是一款模板引擎:即一种基于模板和要改变的数据，并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具。它不是面向最终用户的，而是一个Java类库，是一款程序员可以嵌入他们所开发产品的组件。

    FreeMarker的优势：性能好，强大的模板语言、轻量

    使用方法

    1. 导入依赖
    <dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-freemarkerartifactId>
dependency>

    • 1
    • 2
    • 3
    • 4
    1. 编写配置文件application.yaml
    server:
	port: 8881 #服务端口
spring:
	application:
		name : test-freemarker #指定服务名
	freemarker:
		cache: false	#关闭模板缓存，方便测试
		settings:
			template_update_delay: 0 #检查模板更新延迟时间，设置为o表示立即检查，如果时间大于o会有缓存不方便进行模板测试
		suffix : .ftl #指定Freemarker模板文件的后缀名（FreeMarker的默认配置是.ftlh）；html等文件格式也支持
		template-loader-path: classpath:/templates # 这也是FreeMarker的默认路径


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 在resources包下创建templates目录，作为freemarker的默认模板存放目录
    2. 在templates下创建01-basic.ftl模板
    DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title>Hello world !title>
head>
<body>
<b>普通文本String展示:b><br><br>
Hello ${name} <br>

<hr>

<b>对象Student中的数据展示:b><br/>
姓名: ${stu.name}<br/>
年龄: ${stu.age}
<hr>

body>html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    其中的${}内容为插值表达式，后续需要替换为需要的值

    1. 写方法对该模板处理

    freemarker作为springmvc一种视图格式，默认情况下SpringMVC支持freemarker视图格式。

    代码如下：

    @GetMapping("basic")
public String test(Model model) {
	//1.纯文本形式的参数
	model.addAttribute("name", "freemarker");
	//2.实体类相关的参数
	Student student = new Student();student.setName("小明");
	student.setAge(18);
	model.addAttribute("stu", student);
	return "01-basic";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    因为在导入FreeMarker的依赖后，其在spring.factories中完成了对FreeMarker的自动配置
    而FreeMaker基于SpringMVC，因此Controller能够自动获取Model并通过返回值构建对应的视图

    1. 生成静态文件
      在这里插入图片描述
    public class FreeMarker{
	//自动注入的是freemarker中的Configuration
	@Autowired
	private Configuration configuration

	public void test(){
		Template template = configuration.getTemplate("xxx.ftl")
		/**
	 	 * 合成方法
		 * 两个参数
		 * 第一个参数:模型数据
		 * 第二个参数:输出流
		 */
		template.process(getData() ,new Filewriter("d:/xxx.html"));
	}
	private Map getData(){
		Map map = new HashMap();
		//这里将步骤5中的Model改为Map
		//即用Map存数据，然后和模板中的内容进行转换
		return map;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    基本语法

    1. 注释：<#-- -->
    2. 插值：${}
    3. FTL指令：<# >... 示例：<#list>...
    4. 文本：纯文本（无注释），不处理，直接输出

    list集合

    <#list ListName as Entity>
	<tr>
		<td>${Entity_index}td> <#--获取元素下标，第一个元素为0-->
		<td>${Entity.property1}td>
		<td>${Entity.property2}td>
	tr>
#list>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    map集合

    1. 方式1：${MapName['KeyName'].property}即 使用model中attribute设置的Map名称获取到map对象，然后使用['KeyName']即在[]中添加键名称来获取Value值，如果Value是类，则可类似地获取属性。
    2. 方式2：${MapName.KeyName.property}
    3. 获取所有key：<#list MapName?keys as key>，即将所有的key封装为list

    if表达式

    <#if>
<#else>
#if>

    • 1
    • 2
    • 3

    freemarker中1个等于和2个等于作用相同
    尽量用lt和gt代替小于和大于，其他符号相同
    在变量后接两个问号，可判断该元素是否为空，比如ListName??
    在变量后接叹号再接值，能设定空值情况下的默认值，比如${name!'------'}，name为空返回'------'

    内建函数

    内建函数语法格式:变量+?+函数名称
    示例：
    ${ListName?size}
    ${today?datetime}
    ${today?string("yyyy年MM月")}

    MinIO

    分布式文件系统，容易实现扩容

    优点：

    1. 性能高，准硬件条件下它能达到55GB/s的读、35GB/s的写速率
    2. 部署自带管理界面
    3. MinIO.Inc运营的开源项目，社区活跃度高
    4. 提供了所有主流开发语言的SDK

    使用

    1. 环境配置

    ①拉取镜像

    docker pull minio/minio

    • 1

    ②运行容器

    docker run -p 9000:9000 --name minio -d --restart=always -e "MINO_ACCESS_KEY=minio" -e "MINTO_SECRET_KEY=minio123" -v /home/data:/data -v /home/config:/root/.minio minio/minio server /data

    • 1

    ③访问minio：http://192.168.133.128:9000

    1. 导入依赖
    <dependency>
	<groupId>io.miniogroupId>
	<artifactId>minioartifactId>
	<version>7.1.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    1. 实现代码
    try {
	FileInputStream fileInputStream = new FileInputStream("D:\\xxx.html");
	//1.获取minio的链接信息创建一个minio的客户端
	//其中包含用户名，密码，地址
	MinioClient minioClient = MinioClient.builder().credentials("minio", "minio123").endpoint("http://192.168.133.128:9000").build();
	//2.上传
	//这里其实也就是需要提供3个字符串类型的参数，对应bucketName、objectName、filePath、contentType
	PutObjectArgs putObjectArgs = PutObjectArgs.builder()
		.object("xxx.html")	//文件名称
		.contentType("text/html")	//文件类型
		.bucket("BucketName")	//桶名称 与minio管理界面创建的桶一致即可
		.stream(fileInputStream,fileInputstream.available(), -1).build();
	minioClient.putObject(putObjectArgs);
	//访问路径
	System.out.println("http://192.168.133.128:9000/BucketName/xxx.html");
}catch (Exception e) {
	e.printStackTrace();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    想从Minio获取文件操作类似，调用MinioClient的getObject()方法即可，参数少一个contentType
    获取到的文件存到FileOutputStream中，也是getObject()方法的一个参数

    在这里面也可以将其中的链接信息抽成配置文件

    minio: 
	accessKey: minio
	secretKey: minio123
	bucket: BucketName
	endpoint: http://192.168.133.128:9000
	readPath: http://192.168.133.128:9000

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    然后写一个实体类，用@ConfigurationProperties(prefix = "minio")去获取配置信息即可

    分布式ID

    1. redis
      生成全局连续递增的数字型主键（但必须保证redis可用）
    2. UUDI
      全局唯一（但由36个字符组成，占用空间较大）
    3. 雪花算法
      全局唯一，数字类型，存储占用小（但机器规模大于1024则无法使用）
      snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是:使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID)，12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生4096个 ID)，最后还有一个符号位，永远是0
        1. 在实体类的主键ID属性上加上注解@TableId(value = "id", type = IdType.ID_WORKER)
        1. 第二：在application.yml文件中配置数据中心id和机器id
    mybatis-plus:
	mapper-locations: classpath*:mapper/*.xml	# 设置别名包扫描路径，通过该属性可以给包中的类注册别名
	type-aliases-package: com.rainbow.model.article.pojos
	global-config:
		datacenter-id: 1
		workerId: 1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    异步调用

    1. 在需要异步调用的方法上用@Async注解
    2. 在启动类上用@EnableAysnc注解
      该异步调用底层是通过SpringBoot的AOP技术，通过创建代理对象的方式，拦截用@Async注解过的方法，然后将该方法交给线程池进行异步处理

    延迟任务

    1. DelayQueue
      JDK自带的延时获取元素的阻塞队列，内部采用优先队列存储元素，延迟期满时才从队列中获取任务进行处理。但是任务都存在内存中，如果程序挂了，消息便会丢失。
      在这里插入图片描述
    2. RabbitMQ
    • TTL：消息存活时间
    • 死信队列：Dead Letter Exchange，当消息成为Dead Message后，可以重新发送给另外一个交换机
    @Configuration
public class RabbitMQConfig {
    // 定义普通队列
    @Bean
    public Queue delayQueue() {
        return QueueBuilder.durable("delay.queue") // 队列名称
                .withArgument("x-dead-letter-exchange", "dead-letter-exchange") // 设置死信交换器
                .withArgument("x-dead-letter-routing-key", "dead-letter-routing-key") // 设置死信路由键
                .withArgument("x-message-ttl", 5000) // 设置消息的TTL（单位：毫秒）
                .build();
    }

    // 定义死信队列
    @Bean
    public Queue deadLetterQueue() {
        return QueueBuilder.durable("dead-letter.queue")
                .build();
    }

    // 定义死信交换器
    @Bean
    public DirectExchange deadLetterExchange() {
        return new DirectExchange("dead-letter-exchange");
    }

    // 绑定死信队列和死信交换器
    @Bean
    public Binding deadLetterBinding(Queue deadLetterQueue, DirectExchange deadLetterExchange) {
        return BindingBuilder.bind(deadLetterQueue)
                .to(deadLetterExchange)
                .with("dead-letter-routing-key");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    该配置中，delay.queue的消息TTL到后，将被发送到dead-letter-exchange绑定的dead-letter.queue中，然后只需要监听dead-letter.queue即可
    在这里插入图片描述
    3. redis
    zset数据类型：利用去重有序的特点去实现延迟任务。
    可以按时间顺序将任务进行排序，然后根据当前时间去获取队列中的任务进行处理

    在这里插入图片描述

    乐观锁

    在对数据修改时并不加锁，而是在最后存入数据库时检查版本号，如果版本号和预期相同则完成修改。

    1. 在数据库中加入version字段
    2. 在实体类中对应的version属性上加上@Version注解
    3. 在启动类中向容器中放入乐观锁的拦截器
    @Bean
public MybatisPlusInterceptor optimisticLockerInterceptor(){
	MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
	interceptor.addInnerInterceptor(new optimisticLockerInnerInterceptor());
	return interceptor;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    分布式锁

    redis的sexnx (SET if not exists)命令在指定的key不存在时，为key设置指定的值。
    在这里插入图片描述

    	//方式一
	RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
	Boolean result = connection.set(name.getBytes(),
			   						token-getBytes(),
			   						Expiration.from(expire,TimeUnit.MILLISECONDS),
			   						RediSstringCommands.SetOption.SET_IF_ABSENT);	//NX

	//方式二
	private static final String LOCK_KEY = "mylock";
    private static final long LOCK_EXPIRE_TIME = 30000; // 锁的过期时间，单位：毫秒
    
	@Autowired
    private RedisTemplate<String, String> redisTemplate;

    public boolean acquireLock() {
        // 使用 SETNX 命令尝试获取锁
        Boolean lockAcquired = redisTemplate.opsForValue().setIfAbsent(LOCK_KEY, "locked");
        if (lockAcquired != null && lockAcquired) {
            // 设置锁的过期时间，防止锁在持有者崩溃时一直存在
            redisTemplate.expire(LOCK_KEY, LOCK_EXPIRE_TIME);
            return true; // 获取到了锁
        }
        return false; // 锁已被其他进程持有
    }

    public void releaseLock() {
        // 释放锁，使用 DEL 命令删除锁的键
        redisTemplate.delete(LOCK_KEY);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    BUG

    Mybatis-plus使用getOne查询时抛出异常

    原因是在com.baomidou.mybatisplus.extension.service这个包下的getOne()方法:T getOne(Wrapper queryWrapper, boolean throwEx);其中第二个参数用于决定是否在查询到多个结果时抛出异常，默认情况是true

    解决办法：用list()方法去替代，然后根据需要去获取元素，如果无特殊要求获取第一个元素就行

    但使用mybatis-plus相关方法时，需要判断返回值是否为null，为null需要额外处理

  • 相关阅读:
    Java基础-对象序列化
    Linux 内存和SWAP使用
    用帆软报表FineReport打造公司数字化经营报表
    C++QT开发——多线程
    vue3Blog首页基础布局样式规划
    加法器—笔记
    进阶vue面试题总结
    LabVIEW 使用VISA Close真的关闭COM口了吗
    Android Studio 报错：AVD Pixel_3a_API_30_x86 is already running
    【Linux】yum 报错ModuleNotFoundError: No module named ‘dnf‘
  • 原文地址：https://blog.csdn.net/qq_57689612/article/details/132020092