1.redis
这个项目用数据库存储用户的注册,登录数据,确保用户可以登录,和成功注册。
用redis短期存储用户的在线状态,保持用户的在线状态。即在用户登录期间(redis信息不过期)情况下,可以得到用户的状态信息。只要用户登录,或者注册成功,它们的信息就会通过JWT加密后放到redis中
2.jwt
一种加密技术,目前也不太清楚,这是JWT工具类,对用户信息进行加密,这样从redis获取的信息便是加密过的用户信息。
public class JWTUtils {
private static final String jwtToken = "123456Mszlu!@#$$";
public static String createToken(Long userId){
Map<String,Object> claims = new HashMap<>();
claims.put("userId",userId);
JwtBuilder jwtBuilder = Jwts.builder()
.signWith(SignatureAlgorithm.HS256, jwtToken) // 签发算法,秘钥为jwtToken
.setClaims(claims) // body数据,要唯一,自行设置
.setIssuedAt(new Date()) // 设置签发时间
.setExpiration(new Date(System.currentTimeMillis() + 24 * 60 * 60 * 60 * 1000));// 一天的有效时间
String token = jwtBuilder.compact();
return token;
}
//用户验证,看看内部是否存在
public static Map<String, Object> checkToken(String token){
try {
Jwt parse = Jwts.parser().setSigningKey(jwtToken).parse(token);
return (Map<String, Object>) parse.getBody();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
3.多线程,线程池
更改数据库时,会加入写锁,在读取数据库时需要等锁解掉才能执行下一步,为了节省时间,也为防止更改出错造成下一步无法执行,采用多线程操作,读取数据库和更改数据库做到同时操作,非常给力。
4.mp框架
使用它,必须先在boot中写它的配置信息
package com.mzlu.blog.config;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
//扫包,将此包下的接口生成代理实现类,并且注册到spring容器中
@MapperScan("com.mszlu.blog.dao")
public class MybatisPlusConfig {
//分页插件
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return interceptor;
}
}
加了一个分页插件,并且确认mp的扫描对象所处位置,方便后面做mapper映射
4.1用mp框架进行更新时,确保后端映射对象的类型为非引用类型
以免出现进行更新操作时的BUG
如下
//错误示范
int count;
//正确示范
Integer count;
这两者有区别,int类型默认初始值为0;Integer默认的初始值为null,在用mybatis-plus进行更新操作时,方法如下
public void updataArticleViewCount(ArticleMapper articleMapper, Article article) {
Article articleUpdate = new Article();
articleUpdate.setViewCounts(article.getViewCounts() + 1);
//MP的知识,得去学啊
LambdaQueryWrapper<Article> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(Article::getId,article.getId());
queryWrapper.eq(Article::getViewCounts,article.getViewCounts());
//等价于
// UPDATE ms_article SET comment_counts=?, view_counts=?, weight=? WHERE (id = ? AND view_counts = ?)
articleMapper.update(articleUpdate,queryWrapper);
try {
//睡眠5秒 证明不会影响主线程的使用
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
这里我本意只是想让变量getViewCounts +1,但我article对象和articleVo对象内属性类型有引用类型int,他的初始值是0,这一波操作把要操作的对象属性为引用类型的值全变成0,非常痛苦。
等价的MYSQL语句为
UPDATE ms_article SET comment_counts=?, view_counts=?, weight=? WHERE (id = ? AND view_counts = ?)
将引用类型的参数全更新成0了,这可不行
将参数全改成非引用类型Integer,如下所示
package com.mzlu.blog.dao.pojo;
import lombok.Data;
@Data
public class Article {
public static final int Article_TOP = 1;
public static final int Article_Common = 0;
private Long id;
private String title;
private String summary;
private Integer commentCounts;
private Integer viewCounts;
/**
* 作者id
*/
private Long authorId;
/**
* 内容id
*/
private Long bodyId;
/**
*类别id
*/
private Long categoryId;
/**
* 置顶
*/
private Integer weight;
/**
* 创建时间
*/
private Long createDate;
}
类代码
package com.mzlu.blog.vo;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import java.util.List;
@Data
public class ArticleVo {
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
private String title;
private String summary;
private Integer commentCounts;
private Integer viewCounts;
private Integer weight;
/**
* 创建时间
*/
private String createDate;
private String author;
private ArticleBodyVo body;
private List<TagVo> tags;
private CategoryVo category;
}
这样它们的初始值便是null,在mp框架进行操作时,不会对这些属性进行更新
等价SQL语句变成
UPDATE ms_article SET view_counts=? WHERE (id = ? AND view_counts = ?)
这样子就做到了只对指定属性进行更新了
4.2 LambdaQueryWrapper工具
这块主要就是mybatis-plus框架的操作,跟着教程学了一些,批量添加,删除,编辑,升降序排列模糊查询等基本操作,支持单表的增删改查
package com.wc.mybatispulstest;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wc.mybatispulstest.mapper.UserMapper;
import com.wc.mybatispulstest.pojo.User;
import org.junit.jupiter.api.Test;
import org.junit.platform.commons.util.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
import java.util.Map;
@SpringBootTest
public class MybatisPlusWrapperTest {
/**
* queryWrapper的使用,条件构造器模糊查询
*/
@Autowired
private UserMapper userMapper;
@Test
public void test01() {
//条件构造器
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//模糊查询,查询name有‘w’的,年龄0-9之间的,邮箱不为空的数据
queryWrapper.like("name", "w").between("age", 0, 9).isNotNull("email");
List<User> list = userMapper.selectList(queryWrapper);
for (User user : list) {
System.out.println(user);
}
}
/**
* queryWrapper排序
* 查询用户信息,按照年龄的降序排序,若年龄相同,则按照年龄的升序排序
*/
@Test
public void test02() {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("age").orderByAsc("id");
List<User> list = userMapper.selectList(queryWrapper);
for (User user : list) {
System.out.println(user);
}
}
/**
* 进行删除操作
*/
@Test
public void test03() {
//删除邮箱地址为null的用户信息
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("email");
int result = userMapper.delete(queryWrapper);
}
/**
* 进行修改操作
* 将年龄大于5并且用户名种包含有a 或邮箱为null的用户信息修改
*/
@Test
public void test04() {
//删除邮箱地址为null的用户信息
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//条件判断,筛选出哪些数据是需要更新的,gt是大于
queryWrapper.gt("age", 5).like("name", "w").or().isNull("email");
//设置要更新的内容
User user = new User();
user.setName("小明");
userMapper.update(user, queryWrapper);
int result = userMapper.delete(queryWrapper);
}
/**
* 将用户名中包含有w并且(邮箱为空或年龄大于20)的用户信息修改
* 用到lambda表达式
*/
@Test
public void test05() {
QueryWrapper<User>queryWrapper=new QueryWrapper<>();
queryWrapper.like("name","w").
and(i->i.gt("age",20).or().isNull("email"));
//设置要更新的内容
User user = new User();
user.setName("小明");
userMapper.update(user, queryWrapper);
userMapper.update(user,queryWrapper);
}
@Test
public void test06() {
//查询用户的用户名、年龄、邮箱信息
QueryWrapper<User>queryWrapper=new QueryWrapper<>();
//设置自己想查询的字段
queryWrapper.select("name","age","email");
List<Map<String,Object>>list=userMapper.selectMaps(queryWrapper);
list.forEach(System.out::println);
}
/**
* updatewrapper更新
* 操作
*/
@Test
public void test07() {
//查询id小于100的数据
UpdateWrapper<User>userUpdateWrapper=new UpdateWrapper<>();
//设置自己想查询的字段
userUpdateWrapper.like("name","w");
userUpdateWrapper.set("name","小黑").set("email","123");
userMapper.update(null,userUpdateWrapper);
}
/**
* LambdaQueryWrapper操作
*/
public void test08(){
String name="w";
Integer ageBegin=null;
Integer ageEnd=30;
LambdaQueryWrapper<User>lambdaQueryWrapper=new LambdaQueryWrapper<>();
/**
* 参数为 判断条件 操作的对象属性(要变成特定的写法 如 User::getName)设置的值
*/
lambdaQueryWrapper.like(StringUtils.isNotBlank(name),User::getName,name).
ge(ageBegin!=null,User::getAge,ageBegin).
le(ageEnd!=null,User::getAge,ageEnd);
}
/**
*
*/
}
4.3 mybatisX插件使用
【【尚硅谷】2022版MyBatisPlus教程(一套玩转mybatis-plus)-哔哩哔哩】 https://b23.tv/VfOMLmw
第54集开始有详细描述
5.AOP
这里用到@Aspect注解
嘴巴说不定清,上代码体会一下
设置日志注解
package com.mzlu.blog.common.aop;
import java.lang.annotation.*;
/**
* 日志注解
*/
//Type代表可以放在类上面,Method代表可以放在方法上
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAnnotation {
String module() default "";
String operation() default "";
}
对应设置方法输出日志
@PostMapping("view/{id}")
@LogAnnotation(module="文章",operation="获取文章列表")
public Result findArticleById(@PathVariable("id") Long articleId) {
ArticleVo articleVo = articleService.findArticleById(articleId);
return Result.success(articleVo);
}
设置切点切面,不然上述的注解都不生效,扫描指定包,使之生效,这块目前不太会,后面学源码补全。
package com.mzlu.blog.common.aop;
import com.alibaba.fastjson.JSON;
import com.mzlu.blog.utils.HttpContextUtils;
import com.mzlu.blog.utils.IpUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
/**
* AOP的应用
*/
@Component
@Aspect//切面。定义了切面和切顶的关系(这块并不是很懂,得回头看)
@Slf4j
public class LogAspect {
@Pointcut("@annotation(com.mzlu.blog.common.aop.LogAnnotation)")
public void logPointCut() {
}
@Around("logPointCut()")
public Object around(ProceedingJoinPoint point) throws Throwable {
long beginTime = System.currentTimeMillis();
//执行方法
Object result = point.proceed();
//执行时长(毫秒)
long time = System.currentTimeMillis() - beginTime;
//保存日志
recordLog(point, time);
return result;
}
private void recordLog(ProceedingJoinPoint joinPoint, long time) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
LogAnnotation logAnnotation = method.getAnnotation(LogAnnotation.class);
log.info("=====================log start================================");
log.info("module:{}",logAnnotation.module());
log.info("operation:{}",logAnnotation.operation());
//请求的方法名
String className = joinPoint.getTarget().getClass().getName();
String methodName = signature.getName();
log.info("request method:{}",className + "." + methodName + "()");
//请求的参数,如果无参,会报错,无参为null,无法获取args[0]
Object[] args = joinPoint.getArgs();
String params = JSON.toJSONString(args[0]);
log.info("params:{}",params);
//获取request 设置IP地址
HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
log.info("ip:{}", IpUtils.getIpAddr(request));
log.info("excute time : {} ms",time);
log.info("=====================log end================================");
}
}
IPutils工具类
package com.mzlu.blog.utils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import javax.servlet.http.HttpServletRequest;
/**
* 获取Ip
*
*/
@Slf4j
public class IpUtils {
/**
* 获取IP地址
* <p>
* 使用Nginx等反向代理软件, 则不能通过request.getRemoteAddr()获取IP地址
* 如果使用了多级反向代理的话,X-Forwarded-For的值并不止一个,而是一串IP地址,X-Forwarded-For中第一个非unknown的有效IP字符串,则为真实IP地址
*/
public static String getIpAddr(HttpServletRequest request) {
String ip = null, unknown = "unknown", seperator = ",";
int maxLength = 15;
try {
ip = request.getHeader("x-forwarded-for");
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (StringUtils.isEmpty(ip) || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
} catch (Exception e) {
log.error("IpUtils ERROR ", e);
}
// 使用代理,则获取第一个IP地址
if (StringUtils.isEmpty(ip) && ip.length() > maxLength) {
int idx = ip.indexOf(seperator);
if (idx > 0) {
ip = ip.substring(0, idx);
}
}
return ip;
}
/**
* 获取ip地址
*
* @return
*/
public static String getIpAddr() {
HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
return getIpAddr(request);
}
}
HttpContextUtils工具类
package com.mzlu.blog.utils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
/**
* HttpServletRequest
*
*/
public class HttpContextUtils {
public static HttpServletRequest getHttpServletRequest() {
return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
}
}
总结:
1.jwt+redis令牌的登陆方式,访问认证速度快,session共享,进行了加密处理,有安全性
2.redis做了令牌(token)和用户信息的对应管理,进一步增强了安全性 登陆用户做了缓存,存在redis中并设置过期时间,在过期时间内保持登陆状态,过期后自动离线。
3.用threadlocal保存用户信息,在请求的线程之内,可以随时获取登陆的用户,做了线程隔离,不会影响其他用户
4.使用完ThreadLocal之后,做了value的删除,防止内存的泄漏
5.线程安全 update table set value=newValue where id=1 and value=oldvalue,保证原有旧值的基础上进行更新,防止因为多线程更新出错的问题
6.线程池 应用很广
7.权限系统 配置拦截器,不登陆就无法进行操作
8.统一日志记录,统一缓存处理