ids = new ArrayList<>();
if (letterList != null) {
for (Message message : letterList) {
if (hostHolder.getUser().getId() == message.getToId() && message.getStatus() == 0) {
ids.add(message.getId());
}
}
}
return ids;
}
/**
* 私信发送操作
* @param toName
* @param content
* @return
*/
@RequestMapping(path = "/letter/send", method = RequestMethod.POST)
@ResponseBody
public String sendLetter(String toName, String content) {
User target = userService.findUserByName(toName);
if (target == null) {
return CommunityUtil.getJSONString(1, "目标用户不存在!");
}
// 开始构建会话消息对象
Message message = new Message();
message.setFromId(hostHolder.getUser().getId());
message.setToId(target.getId());
if (message.getFromId() < message.getToId()) {
message.setConversationId(message.getFromId() + "_" + message.getToId());
} else {
message.setConversationId(message.getToId() + "_" + message.getFromId());
}
message.setContent(content);
message.setCreateTime(new Date());
messageService.addMessage(message);
return CommunityUtil.getJSONString(0);
}
}
```
## 9. 全局异常捕获与处理
### 404页面展示
### 错误页面展示
### 统一异常处理
> 相关注解介绍
* `@ControllerAdvice`
* 用于==修饰类==，表示该类是**Controller** 的全局适配类。
* 在此类中，可以对**Controller** 进行如下三种全局配置：
* :aerial_tramway: 异常处理方案
* :baby: 绑定数据方案
* :baby_chick: 绑定参数方案
* `@ExceptionHandler`(我们实例中使用则个注解修饰方法)
* 用于==修饰方法==，该方法会在**Controller** 出现异常后被调用，用于处理捕获到的异常。
* `@ModelAttribute`
* 用于==修饰方法==，该方法回在**Controller** 方法执行前被调用，用于为**Model** 对象绑定参数。
* `@DataBinder`
* 用于==修饰方法==，该方法回在**Controller** 方法执行前被调用，用于绑定参数的转换器。
> 实例代码
```java
/**
* @Auther: csp1999
* @Date: 2020/11/26/20:39
* @Description: 异常通知类
*/
// 所有带 @Controller 注解的类都会被扫描到
@ControllerAdvice(annotations = Controller.class)
public class ExceptionAdvice {
// 声明日志工厂
private static final Logger logger = LoggerFactory.getLogger(ExceptionAdvice.class);
/**
* 自定义异常处理器,覆盖spring boot原来的异常处理器
* @param e 异常对象
* @param request 请求
* @param response 响应
* @throws IOException
*/
@ExceptionHandler({Exception.class})// 标识该方法是用来做异常处理的，处理的异常级别为Exception
public void handleException(Exception e, HttpServletRequest request,
HttpServletResponse response) throws IOException {
// 记录异常信息
logger.error("请求 URL : {} , 异常信息 : {}",request.getRequestURL(),e);
// 逐条记录错误日志
for (StackTraceElement element : e.getStackTrace()) {
logger.error(element.toString());
}
String xRequestedWith = request.getHeader("x-requested-with");
if ("XMLHttpRequest".equals(xRequestedWith)) {
response.setContentType("application/plain;charset=utf-8");
PrintWriter writer = response.getWriter();
writer.write(CommunityUtil.getJSONString(1, "服务器异常!"));
} else {
response.sendRedirect(request.getContextPath() + "/error");
}
}
}
```
### 切面统一记录日志
```java
/**
* @Auther: csp1999
* @Date: 2020/11/26/21:12
* @Description: 自定义日志处理组件
*/
@Component
@Aspect
public class ServiceLogAspect {
// 获取日志工厂
private static final Logger logger = LoggerFactory.getLogger(ServiceLogAspect.class);
/**
* 切入点
*/
@Pointcut("execution(* com.haust.community.service.*.*(..))")
public void pointcut() {
}
/**
* 前置通知,在切面之前执行
*
* @param joinPoint
*/
@Before("pointcut()")
public void before(JoinPoint joinPoint) {
// 用户[1.2.3.4],在[xxx],访问了[com.nowcoder.community.service.xxx()].
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
String ip = request.getRemoteHost();
String now = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
String target = joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName();
logger.info(String.format("用户[%s],在[%s],访问了[%s].", ip, now, target));
}
/**
* 后置通知,在切面之后执行
*/
@After("pointcut()")
public void doAfter() {
logger.info("----------doAfter----------");
}
/**
* 切入点拦截的方法执行结束后，捕获返回内容
*
* @param result
*/
@AfterReturning(returning = "result", pointcut = "pointcut()")
public void doAfterRuturn(Object result) {
logger.info("捕获返回内容 : {}", result);
}
}
```
## 10. Redis 实现点赞/关注/粉丝列表
#### 生成Redis Key的工具类:
```java
/**
* @Auther: csp1999
* @Date: 2020/11/27/20:34
* @Description: Redis Key的工具类
*/
public class RedisKeyUtil {
private static final String SPLIT = ":";
private static final String PREFIX_ENTITY_LIKE = "like:entity";
private static final String PREFIX_USER_LIKE = "like:user";
private static final String PREFIX_FOLLOWEE = "followee";// 关注某人
private static final String PREFIX_FOLLOWER = "follower";// 某人关注我
private static final String PREFIX_KAPTCHA = "kaptcha";// 验证码key的前缀
private static final String PREFIX_TICKET = "ticket";// 登录凭证key的前缀
private static final String PREFIX_USER = "user";// 登录用户key的前缀
/**
* 某个实体赞的key
*
* key ---> like:entity:entityType:entityId -> set(userId)
*
* @param entityType
* @param entityId
* @return
*/
public static String getEntityLikeKey(int entityType, int entityId) {
return PREFIX_ENTITY_LIKE + SPLIT + entityType + SPLIT + entityId;
}
/**
* 某个用户累计的赞的key
*
* key ---> like:user:userId -> int
*
* @param userId
* @return
*/
public static String getUserLikeKey(int userId) {
return PREFIX_USER_LIKE + SPLIT + userId;
}
/**
* 某个用户关注某个实体的集合key
*
* key
* ---> followee:userId:entityType
* ---> zset(entityId,now),zset为有序集合,以now作为排序分数
* now表示当前时间的时间数,可以根据时间大小排序
*
*
* @param userId
* @param entityType
* @return
*/
public static String getFolloweeKey(int userId, int entityType) {
return PREFIX_FOLLOWEE + SPLIT + userId + SPLIT + entityType;
}
/**
* 某个实体拥有的粉丝集合key
*
* key ---> follower:entityType:entityId -> zset(userId,now)
*
* @param entityType
* @param entityId
* @return
*/
public static String getFollowerKey(int entityType, int entityId) {
return PREFIX_FOLLOWER + SPLIT + entityType + SPLIT + entityId;
}
/**
* 登录验证码的key
*
* @param owner 验证码所属者
* @return
*/
public static String getKaptchaKey(String owner) {
return PREFIX_KAPTCHA + SPLIT + owner;
}
/**
* 登录的凭证的key
*
* @param ticket
* @return
*/
public static String getTicketKey(String ticket) {
return PREFIX_TICKET + SPLIT + ticket;
}
/**
* 用户的key
*
* @param userId
* @return
*/
public static String getUserKey(int userId) {
return PREFIX_USER + SPLIT + userId;
}
}
```
#### Service层：
**LikeService**.java
```java
/**
* @Auther: csp1999
* @Date: 2020/11/27/20:39
* @Description: 点赞Service 存入Redis 缓存
*/
@Service
public class LikeService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 点赞操作
*
* @param userId 点赞用户的id
* @param entityType 点赞实体的类型
* @param entityId 点赞实体的id
* @param entityUserId 被点赞实体的用户id
*/
public void like(int userId, int entityType, int entityId, int entityUserId) {
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations operations) throws DataAccessException {
// 某帖子实体点赞集合的key
String entityLikeKey = RedisKeyUtil.getEntityLikeKey(entityType, entityId);
// 某个用户累计的赞的key
String userLikeKey = RedisKeyUtil.getUserLikeKey(entityUserId);
// 查询entityLikeKey对应的集合中是否已经存在当前userId
boolean isMember = operations.opsForSet().isMember(entityLikeKey, userId);
// 开启redis事务
operations.multi();
// userId 已经存在，即当前用户已经为该帖子点过赞
if (isMember) {
// 取消这个赞
operations.opsForSet().remove(entityLikeKey, userId);
// 被点赞用户获赞数减少1
operations.opsForValue().decrement(userLikeKey);
} else {
// userId 不存在，即当前用户还没为该帖子点过赞，直接点赞即可
operations.opsForSet().add(entityLikeKey, userId);
// 被点赞用户获赞数增加1
operations.opsForValue().increment(userLikeKey);
}
// 执行redis事务
return operations.exec();
}
});
}
/**
* 查询某帖子实体点赞的数量
*
* @param entityType
* @param entityId
* @return
*/
public long findEntityLikeCount(int entityType, int entityId) {
// 某帖子实体点赞集合的key
String entityLikeKey = RedisKeyUtil.getEntityLikeKey(entityType, entityId);
// 统计该帖子实体的点赞集合中的数据数量，即点赞数
return redisTemplate.opsForSet().size(entityLikeKey);
}
/**
* 查询某人对某帖子实体的点赞状态
* 0未点赞/1已点赞
*
* @param userId
* @param entityType
* @param entityId
* @return
*/
public int findEntityLikeStatus(int userId, int entityType, int entityId) {
// 某帖子实体点赞集合的key
String entityLikeKey = RedisKeyUtil.getEntityLikeKey(entityType, entityId);
return redisTemplate.opsForSet().isMember(entityLikeKey, userId) ? 1 : 0;
}
/**
* 查询某个用户累计获得的赞
*
* @param userId
* @return
*/
public int findUserLikeCount(int userId) {
String userLikeKey = RedisKeyUtil.getUserLikeKey(userId);
Integer count = (Integer) redisTemplate.opsForValue().get(userLikeKey);
return count == null ? 0 : count.intValue();
}
}
```
**FollowService**.java
```java
/**
* @Auther: csp1999
* @Date: 2020/11/28/9:41
* @Description: 关注Service 存入Redis 缓存
*/
@Service
public class FollowService implements CommunityConstant {
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private UserService userService;
/**
* 用户关注了某个实体
*
* @param userId
* @param entityType
* @param entityId
*/
public void follow(int userId, int entityType, int entityId) {
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations operations) throws DataAccessException {
// 某个用户所关注的实体的集合key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
// 某个实体拥有的粉丝集合key
String followerKey = RedisKeyUtil.getFollowerKey(entityType, entityId);
// 开启redis事务
operations.multi();
// 用户所关注的实体的集合新增一条关注数据
operations.opsForZSet().add(followeeKey, entityId, System.currentTimeMillis());
// 实体拥有的粉丝集合新增一个粉丝
operations.opsForZSet().add(followerKey, userId, System.currentTimeMillis());
// 执行redis事务
return operations.exec();
}
});
}
/**
* 用户取消关注了某个实体
*
* @param userId
* @param entityType
* @param entityId
*/
public void unfollow(int userId, int entityType, int entityId) {
redisTemplate.execute(new SessionCallback() {
@Override
public Object execute(RedisOperations operations) throws DataAccessException {
// 某个用户所关注的实体的集合key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
// 某个实体拥有的粉丝集合key
String followerKey = RedisKeyUtil.getFollowerKey(entityType, entityId);
// 开启redis事务
operations.multi();
// 用户关注所关注的实体的集合减少一条关注数据
operations.opsForZSet().remove(followeeKey, entityId);
// 实体拥有的粉丝集合减少一个粉丝
operations.opsForZSet().remove(followerKey, userId);
// 执行redis事务
return operations.exec();
}
});
}
/**
* 查询关注的实体的数量
*
* @param userId
* @param entityType
* @return
*/
public long findFolloweeCount(int userId, int entityType) {
// 某个用户所关注的实体的集合key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
return redisTemplate.opsForZSet().zCard(followeeKey);
}
/**
* 查询实体的粉丝的数量
*
* @param entityType
* @param entityId
* @return
*/
public long findFollowerCount(int entityType, int entityId) {
// 某个实体拥有的粉丝集合key
String followerKey = RedisKeyUtil.getFollowerKey(entityType, entityId);
return redisTemplate.opsForZSet().zCard(followerKey);
}
/**
* 查询当前用户是否已关注该实体
*
* @param userId
* @param entityType
* @param entityId
* @return
*/
public boolean hasFollowed(int userId, int entityType, int entityId) {
// 某个用户所关注的实体的集合key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, entityType);
return redisTemplate.opsForZSet().score(followeeKey, entityId) != null;
}
/**
* 查询某用户关注的人
*
* @param userId
* @param offset
* @param limit
* @return
*/
public List> findFollowees(int userId, int offset, int limit) {
// 某个用户所关注的用户集合key
String followeeKey = RedisKeyUtil.getFolloweeKey(userId, ENTITY_TYPE_USER);
// 分页
Set targetIds =
redisTemplate.opsForZSet().reverseRange(followeeKey, offset, offset + limit - 1);
// 判空
if (targetIds == null) {
return null;
}
// 结果拼接封装成list
List> list = new ArrayList<>();
for (Integer targetId : targetIds) {
Map map = new HashMap<>();
User user = userService.findUserById(targetId);
// 存入用户信息
map.put("user", user);
Double score = redisTemplate.opsForZSet().score(followeeKey, targetId);
System.out.println(score+"=====================================================");
// 存入时间(score中 存入的是日期毫秒数,Double类型)
map.put("followTime", new Date(score.longValue()));
list.add(map);
}
return list;
}
/**
* 查询某用户的粉丝
*
* @param userId
* @param offset
* @param limit
* @return
*/
public List> findFollowers(int userId, int offset, int limit) {
// 某个实体拥有的粉丝集合key
String followerKey = RedisKeyUtil.getFollowerKey(ENTITY_TYPE_USER, userId);
// 分页
Set targetIds =
redisTemplate.opsForZSet().reverseRange(followerKey, offset, offset + limit - 1);
// 判空
if (targetIds == null) {
return null;
}
// 结果拼接封装成list
List> list = new ArrayList<>();
for (Integer targetId : targetIds) {
Map map = new HashMap<>();
User user = userService.findUserById(targetId);
map.put("user", user);
Double score = redisTemplate.opsForZSet().score(followerKey, targetId);
map.put("followTime", new Date(score.longValue()));
list.add(map);
}
return list;
}
}
```
#### controller层：
**LikeController**.java
```java
/**
* @Auther: csp1999
* @Date: 2020/11/27/20:59
* @Description: 点赞controller
*/
@Controller
public class LikeController {
@Autowired
private LikeService likeService;
@Autowired
private HostHolder hostHolder;
/**
* 用户点赞操作
* @param entityType 帖子实体类型
* @param entityId 帖子实体id
* @param entityUserId 被点赞实体的用户id
* @return
*/
@RequestMapping(path = "/like", method = RequestMethod.POST)
@ResponseBody
public String like(int entityType, int entityId, int entityUserId) {
// 获取登录用户
User user = hostHolder.getUser();
// 进行点赞
likeService.like(user.getId(), entityType, entityId, entityUserId);
// 点赞的数量
long likeCount = likeService.findEntityLikeCount(entityType, entityId);
// 点赞的状态
int likeStatus = likeService.findEntityLikeStatus(user.getId(), entityType, entityId);
// 返回的结果
Map map = new HashMap<>();
map.put("likeCount", likeCount);
map.put("likeStatus", likeStatus);
return CommunityUtil.getJSONString(0, null, map);
}
}
```
**FllowController**.java
```java
/**
* @Auther: csp1999
* @Date: 2020/11/28/9:48
* @Description: 关注Controller
*/
@Controller
public class FollowController implements CommunityConstant {
@Autowired
private FollowService followService;
@Autowired
private HostHolder hostHolder;
@Autowired
private UserService userService;
/**
* 关注操作
*
* @param entityType
* @param entityId
* @return
*/
@RequestMapping(path = "/follow", method = RequestMethod.POST)
@ResponseBody
public String follow(int entityType, int entityId) {
// 获取当前用户
User user = hostHolder.getUser();
// 关注
followService.follow(user.getId(), entityType, entityId);
return CommunityUtil.getJSONString(0, "已关注!");
}
/**
* 取消关注操作
*
* @param entityType
* @param entityId
* @return
*/
@RequestMapping(path = "/unfollow", method = RequestMethod.POST)
@ResponseBody
public String unfollow(int entityType, int entityId) {
// 获取当前用户
User user = hostHolder.getUser();
// 取消关注
followService.unfollow(user.getId(), entityType, entityId);
return CommunityUtil.getJSONString(0, "已取消关注!");
}
/**
* 查询"我"关注的人
*
* @param userId
* @param page
* @param model
* @return
*/
@RequestMapping(path = "/followees/{userId}", method = RequestMethod.GET)
public String getFollowees(@PathVariable("userId") int userId, Page page, Model model) {
// 查询用户信息
User user = userService.findUserById(userId);
if (user == null) {
throw new RuntimeException("该用户不存在!");
}
// user 存入 model
model.addAttribute("user", user);
page.setLimit(5);
page.setPath("/followees/" + userId);
page.setRows((int) followService.findFolloweeCount(userId, ENTITY_TYPE_USER));
// 查询用户关注的人的 list 列表
List> userList =
followService.findFollowees(userId, page.getOffset(), page.getLimit());
// 循环list 并拼接每条用户信息
if (userList != null) {
for (Map map : userList) {
User u = (User) map.get("user");
// 判断当前用户是否已经关注了某个用户
map.put("hasFollowed", hasFollowed(u.getId()));
}
}
// userList 存入 model
model.addAttribute("users", userList);
return "/site/followee";
}
/**
* 查询关注"我"的人(粉丝)
*
* @param userId
* @param page
* @param model
* @return
*/
@RequestMapping(path = "/followers/{userId}", method = RequestMethod.GET)
public String getFollowers(@PathVariable("userId") int userId, Page page, Model model) {
// 查询用户信息
User user = userService.findUserById(userId);
if (user == null) {
throw new RuntimeException("该用户不存在!");
}
// user 存入 model
model.addAttribute("user", user);
page.setLimit(5);
page.setPath("/followers/" + userId);
page.setRows((int) followService.findFollowerCount(ENTITY_TYPE_USER, userId));
// 查询用户粉丝的 list 列表
List> userList =
followService.findFollowers(userId, page.getOffset(), page.getLimit());
// 循环list 并拼接每条用户信息
if (userList != null) {
for (Map map : userList) {
User u = (User) map.get("user");
// 判断当前用户是否已经关注了某个用户
map.put("hasFollowed", hasFollowed(u.getId()));
}
}
// userList 存入 model
model.addAttribute("users", userList);
return "/site/follower";
}
// 判断当前用户是否已经关注了某个用户
private boolean hasFollowed(int userId) {
// 判断当前用户是否登录
if (hostHolder.getUser() == null) {
return false;
}
// 判断当前用户是否已经关注了某个用户
return followService.hasFollowed(hostHolder.getUser().getId(), ENTITY_TYPE_USER, userId);
}
}
```
## 11. Kafka 构建异步消息系统(消息发送和通知)
**Kafka** 的下载与安装，参考 [Linux环境下Kafka的安装与使用](https://csp1999.blog.csdn.net/article/details/110310012)
效果如图：
## 12. ElasticSearch 实现社区全局搜索功能
### 12.1 ES 介绍
* 官网地址：[https://www.elastic.co/cn/](https://www.elastic.co/cn/)
* 官方文档地址：[https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html](https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html)
* 下载地址：[https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-6-1](https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-6-1)
ES 入门参考文章：[Linux环境下ElasticSearch的安装与使用(SpringBoot整合云服务器上的ElasticSearch)](https://csp1999.blog.csdn.net/article/details/110392198)
### 12.2 论坛搜索的功能实现
### 12.3 效果展示
## 13. Spring Security 权限控制
### 13.1 简介
[Spring Security官方文档](https://spring.io/projects/spring-security)
* 入门参考文章：[SpringBoot2.3整合SpringSecurity](https://blog.csdn.net/fangchao2011/article/details/106501059)
* 进阶参考文章：[http://www.spring4all.com/article/428][http://www.spring4all.com/article/428]
* 案例Demo参考文章：[SpringBoot整合SpringSecurity做认证和权限控制案例(含Demo代码)](https://csp1999.blog.csdn.net/article/details/110497775)
### 13.2 项目中的权限控制介绍
### 13.3 使用Spring Security 替代原来的登录拦截器
#### 13.3.1 pom.xml 中新增相关依赖
```xml
org.springframework.boot
spring-boot-starter-security
```
#### 13.3.2 SecurityConfig 配置类
首先先从**WebMvcConfig.java** 中 注释掉原来自定义的登录拦截器注册：**LoginRequiredInterceptor**
然后再进行**Spring Security** 相关配置：
```java
/**
* @Auther: csp1999
* @Date: 2020/12/03/9:57
* @Description: Spring Security 配置类
*/
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter implements CommunityConstant {
/**
* 对要拦截的目标资源进行配置
*
* @param web
* @throws Exception
*/
@Override
public void configure(WebSecurity web) throws Exception {
// 忽略拦截 resources 下的所有静态资源
web.ignoring().antMatchers("/resources/**");
}
/**
* 用于对授权进行处理(核心)
*
* @param http
* @throws Exception
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
// 授权
http.authorizeRequests()
// 对于以下列出的所有路径
.antMatchers(
"/user/setting",// 用户设置
"/user/upload",// 用户文件上传
"/discuss/add",// 帖子发布
"/comment/add/**",// 评论发布
"/letter/**",// 私信相关内容
"/notice/**",// 通知相关内容
"/like",// 点赞
"/follow",// 加关注
"/unfollow"// 取消关注
)
// 只要有以下相关权限,都可以访问
.hasAnyAuthority(
AUTHORITY_USER,// 权限: 普通用户
AUTHORITY_ADMIN,// 权限: 管理员
AUTHORITY_MODERATOR// 权限: 版主
)
// 对于以下列出的所有路径
.antMatchers(
"/discuss/top",
"/discuss/wonderful"
)
// 只有具有以下列出的权限才可以访问
.hasAnyAuthority(
AUTHORITY_MODERATOR// 权限: 版主
)
// 对于以下列出的所有路径
.antMatchers(
"/discuss/delete",
"/data/**"
)
// 只有具有以下列出的权限才可以访问
.hasAnyAuthority(
AUTHORITY_ADMIN
)
// 除了以上列出的权限限制约定外，其他请求路径都放行
.anyRequest().permitAll()
//
.and().csrf().disable();
// 如果权限不够时的处理
http.exceptionHandling()
// 没有登录时的处理
.authenticationEntryPoint(new AuthenticationEntryPoint() {
// 没有登录
@Override
public void commence(HttpServletRequest request,
HttpServletResponse response,
AuthenticationException e)
throws IOException, ServletException {
// 如果请求x-requested-with 中头包含XMLHttpRequest 说明是异步请求
String xRequestedWith = request.getHeader("x-requested-with");
if ("XMLHttpRequest".equals(xRequestedWith)) {
// 设置响应体是json 格式(因为是异步请求,所以返回内容要是json格式)
response.setContentType("application/plain;charset=utf-8");
// 拿到输出流,输出返回内容给前端页面
PrintWriter writer = response.getWriter();
writer.write(CommunityUtil.getJSONString(403, "你还没有登录哦!"));
} else {// 不是异步请求
// 重定向到登录页面
response.sendRedirect(request.getContextPath() + "/login");
}
}
})
// 拒绝访问(权限不足时的处理)
.accessDeniedHandler(new AccessDeniedHandler() {
// 权限不足
@Override
public void handle(HttpServletRequest request,
HttpServletResponse response,
AccessDeniedException e)
throws IOException, ServletException {
String xRequestedWith = request.getHeader("x-requested-with");
if ("XMLHttpRequest".equals(xRequestedWith)) {
// 设置响应体是json 格式(因为是异步请求,所以返回内容要是json格式)
response.setContentType("application/plain;charset=utf-8");
// 拿到输出流,输出返回内容给前端页面
PrintWriter writer = response.getWriter();
writer.write(CommunityUtil.getJSONString(403, "你没有访问此功能的权限!"));
} else {// 不是异步请求
// 重定向到没有权限页面
response.sendRedirect(request.getContextPath() + "/denied");
}
}
});
// Security底层默认会拦截/logout请求,进行退出处理.
// 覆盖它默认的逻辑,才能执行我们自己的退出代码.
http.logout().logoutUrl("/securitylogout");
}
}
```
## 14. 帖子的置顶、加精、删除
技术介绍：**Thymleaf Extras SpringSecurity5**
### 14.1 引入依赖
```java
org.thymeleaf.extras
thymeleaf-extras-springsecurity5
3.0.4.RELEASE
```
### 14.2 DiscussPostController 中新增三个接口
对应Mapper 和 Service 层的修改直接看完整代码即可！
```java
/**
* 帖子置顶操作
*
* @param id
* @return
*/
@RequestMapping(path = "/top", method = RequestMethod.POST)
@ResponseBody
public String setTop(int id) {
discussPostService.updateType(id, 1);
// 触发发帖事件
// 帖子帖子后，触发事件：将刚帖子帖子的消息通知订阅的消费者
// 消费者在消费帖子类型事件时，会将帖子信息 传递到 ES 服务器存储/更新数据
Event event = new Event()
.setTopic(TOPIC_PUBLISH)// 主题: 发帖
.setUserId(hostHolder.getUser().getId())// 登录用户id
.setEntityType(ENTITY_TYPE_POST)// 实体类型: 帖子
.setEntityId(id);// 实体id
eventProducer.fireEvent(event);
return CommunityUtil.getJSONString(0);
}
/**
* 帖子加精操作
*
* @param id
* @return
*/
@RequestMapping(path = "/wonderful", method = RequestMethod.POST)
@ResponseBody
public String setWonderful(int id) {
discussPostService.updateStatus(id, 1);
// 触发发帖事件
// 加精帖子后，触发事件：将刚加精帖子的消息通知订阅的消费者
// 消费者在消费帖子类型事件时，会将帖子信息 传递到 ES 服务器存储/更新数据
Event event = new Event()
.setTopic(TOPIC_PUBLISH)// 主题: 发帖
.setUserId(hostHolder.getUser().getId())// 登录用户id
.setEntityType(ENTITY_TYPE_POST)// 实体类型: 帖子
.setEntityId(id);// 实体id
eventProducer.fireEvent(event);
return CommunityUtil.getJSONString(0);
}
/**
* 帖子删除操作
*
* @param id
* @return
*/
@RequestMapping(path = "/delete", method = RequestMethod.POST)
@ResponseBody
public String setDelete(int id) {
discussPostService.updateStatus(id, 2);
// 触发删帖事件
// 删除帖子后，触发事件：将刚删除帖子的消息通知订阅的消费者
// 消费者在消费帖子类型事件时，会将帖子信息 传递到 ES 服务器存储/更新数据
Event event = new Event()
.setTopic(TOPIC_DELETE)// 主题: 删帖
.setUserId(hostHolder.getUser().getId())// 登录用户id
.setEntityType(ENTITY_TYPE_POST)// 实体类型: 帖子
.setEntityId(id);// 实体id
eventProducer.fireEvent(event);
return CommunityUtil.getJSONString(0);
}
```
### 14.3 效果展示
## 15. 网站数据统计
> 声明：**HyperLogLog** 和 **Bitmap** 都是 Redis 中的高级数据类型！
### 15.1 RedisKeyUtil 中添加行营的key 和方法
```java
private static final String PREFIX_UV = "uv";// 独立访客(通过用户IP地址排重统计)
private static final String PREFIX_DAU = "dau";// 日活跃用户(通过ID排重统计)
/**
* 获取单日UV集合(HyperLogLog)的key
* @param date
* @return
*/
public static String getUVKey(String date) {
return PREFIX_UV + SPLIT + date;
}
/**
* 获取区间UV(两个日期之间统计的UV)集合(HyperLogLog)的key
* @param startDate
* @param endDate
* @return
*/
public static String getUVKey(String startDate, String endDate) {
return PREFIX_UV + SPLIT + startDate + SPLIT + endDate;
}
/**
* 获取单日活跃用户集合(Bitmap)的key
* @param date
* @return
*/
public static String getDAUKey(String date) {
return PREFIX_DAU + SPLIT + date;
}
/**
* 获取区间活跃用户(两个日期之间统计的活跃用户)集合(Bitmap)的key
* @param startDate
* @param endDate
* @return
*/
public static String getDAUKey(String startDate, String endDate) {
return PREFIX_DAU + SPLIT + startDate + SPLIT + endDate;
}
```
### 15.2 DataService
```java
/**
* @Auther: csp1999
* @Date: 2020/12/03/18:05
* @Description: 网站数据统计相关的Service
*/
@Service
public class DataService {
@Autowired
private RedisTemplate redisTemplate;
private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
/**
* 将指定的IP计入UV
*
* @param ip
*/
public void recordUV(String ip) {
// 获取单日UV集合(HyperLogLog)的key
String redisKey = RedisKeyUtil.getUVKey(simpleDateFormat.format(new Date()));
// 将数据记录到指定redisKey的HyperLogLog中
redisTemplate.opsForHyperLogLog().add(redisKey, ip);
}
/**
* 统计指定日期时间段范围内的UV
*
* @param start
* @param end
* @return
*/
public long calculateUV(Date start, Date end) {
if (start == null || end == null) {
throw new IllegalArgumentException("参数不能为空!");
}
// keyList 用于整理该日期范围内的key
List keyList = new ArrayList<>();
// Calendar 用于对日期进行运算
Calendar calendar = Calendar.getInstance();
calendar.setTime(start);
// !calendar.getTime().after(end) 当前时间的不晚于 end的时间时,进行while循环
while (!calendar.getTime().after(end)) {
// 获取单日UV集合(HyperLogLog)的key
String key = RedisKeyUtil.getUVKey(simpleDateFormat.format(calendar.getTime()));
// 将key 存入集合
keyList.add(key);
// 日期时间向后推一天
calendar.add(Calendar.DATE, 1);
}
// 获取区间UV(两个日期之间统计的UV)集合(HyperLogLog)的key
String redisKey = RedisKeyUtil.getUVKey(simpleDateFormat.format(start), simpleDateFormat.format(end));
// 合并redisKey对应的HyperLogLog集合和keyList集合
redisTemplate.opsForHyperLogLog().union(redisKey, keyList.toArray());
// 返回HyperLogLog中统计的数量
return redisTemplate.opsForHyperLogLog().size(redisKey);
}
/**
* 将指定用户计入DAU
*
* @param userId
*/
public void recordDAU(int userId) {
// 获取单日活跃用户集合(Bitmap)的key
String redisKey = RedisKeyUtil.getDAUKey(simpleDateFormat.format(new Date()));
// 将数据记录到指定redisKey的Bitmap中,第三个参数表示是否活跃,true表示活跃
redisTemplate.opsForValue().setBit(redisKey, userId, true);
}
/**
* 统计指定日期范围内的DAU
*
* @param start
* @param end
* @return
*/
public long calculateDAU(Date start, Date end) {
if (start == null || end == null) {
throw new IllegalArgumentException("参数不能为空!");
}
// keyList 用于整理该日期范围内的key
List keyList = new ArrayList<>();
// Calendar 用于对日期进行运算
Calendar calendar = Calendar.getInstance();
calendar.setTime(start);
// !calendar.getTime().after(end) 当前时间的不晚于 end的时间时,进行while循环
while (!calendar.getTime().after(end)) {
// 获取单日活跃用户集合(Bitmap)的key
String key = RedisKeyUtil.getDAUKey(simpleDateFormat.format(calendar.getTime()));
// 将key 存入集合(参数为key的byte数组)
keyList.add(key.getBytes());
// 日期时间向后推一天
calendar.add(Calendar.DATE, 1);
}
// 进行OR运算
return (long) redisTemplate.execute(new RedisCallback() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
String redisKey = RedisKeyUtil.getDAUKey(simpleDateFormat.format(start),
simpleDateFormat.format(end));
connection.bitOp(RedisStringCommands.BitOperation.OR,
redisKey.getBytes(), keyList.toArray(new byte[0][0]));
return connection.bitCount(redisKey.getBytes());
}
});
}
}
```
### 15.3 使用DataInterceptor拦截器来做访客统计
```java
/**
* @Auther: csp1999
* @Date: 2020/12/03/18:34
* @Description: 访问统计UV(独立访客)/DAI(日活跃用户)的拦截器
*/
@Component
public class DataInterceptor implements HandlerInterceptor {
@Autowired
private DataService dataService;
@Autowired
private HostHolder hostHolder;
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
// 统计UV(独立访客)
// 获得访客的IP
String ip = request.getRemoteHost();
// 将指定的IP计入UV
dataService.recordUV(ip);
// 统计DAU(日活跃用户)
// 获取登录用户对象
User user = hostHolder.getUser();
if (user != null) {
// 将指定用户计入DAU
dataService.recordDAU(user.getId());
}
return true;
}
}
```
拦截器写好后，将其注册的 **WebMvcConfig** 中去！
## 16. 任务执行和任务调度
> 实现方式可以选择以下三种方式
* **JDK** 线程池
* `ExecutorService`
* `ScheduledExecutorService`
* **Spring** 线程池
* `ThreadPoolTaskExecutor`
* `ThreadPoolTaskScheduler`
* 分布式定时任务
* `Spring Quartz`
### 16.1 数据库sql
```sql
DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;
CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(190) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SIMPROP_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
STR_PROP_1 VARCHAR(512) NULL,
STR_PROP_2 VARCHAR(512) NULL,
STR_PROP_3 VARCHAR(512) NULL,
INT_PROP_1 INT NULL,
INT_PROP_2 INT NULL,
LONG_PROP_1 BIGINT NULL,
LONG_PROP_2 BIGINT NULL,
DEC_PROP_1 NUMERIC(13,4) NULL,
DEC_PROP_2 NUMERIC(13,4) NULL,
BOOL_PROP_1 VARCHAR(1) NULL,
BOOL_PROP_2 VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(190) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;
CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(190) NULL,
JOB_GROUP VARCHAR(190) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;
CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;
CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
commit;
```
### 16.2 application.properties 中配置 quartz
```properties
# QuartzProperties
# quartz 分布式定时任务调度相关配置
spring.quartz.job-store-type=jdbc
spring.quartz.scheduler-name=communityScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=5
```
### 16.3 PostScoreRefreshJob定时任务类
```java
/**
* @Auther: csp1999
* @Date: 2020/12/04/16:08
* @Description: 定时任务类(要实现Job接口)
*/
/**
* @Auther: csp1999
* @Date: 2020/12/04/16:08
* @Description: 定时任务类(要实现Job接口)
*/
public class AlphaJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println(Thread.currentThread().getName() + ": execute a quartz job...");
}
}
```
### 16.4 QuartzConfig 配置类
```java
/**
* @Auther: csp1999
* @Date: 2020/12/04/16:05
* @Description: quartz 分布式定时任务调度相关配置类
*
* 作用：
* 1. -> 仅仅当第一次访问时读取该配置
* 2. -> 并将该配置封装的信息初始化到数据库数据库
* 3. -> 以后每次quartz是访问数据去调用,而不再访问该配置类！
*/
@Configuration
public class QuartzConfig {
/**
* FactoryBean可简化Bean的实例化过程:
*
* 1.通过FactoryBean封装Bean的实例化过程.
* 2.将FactoryBean装配到Spring容器里.
* 3.将FactoryBean注入给其他的Bean.
* 4.该Bean得到的是FactoryBean所管理的对象实例.
*/
// 配置JobDetail
@Bean
public JobDetailFactoryBean alphaJobDetail() {
JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
factoryBean.setJobClass(AlphaJob.class);
factoryBean.setName("alphaJob");
factoryBean.setGroup("alphaJobGroup");
factoryBean.setDurability(true);
factoryBean.setRequestsRecovery(true);
return factoryBean;
}
// 配置Trigger(SimpleTriggerFactoryBean, CronTriggerFactoryBean)
@Bean
public SimpleTriggerFactoryBean alphaTrigger(JobDetail alphaJobDetail) {
SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
factoryBean.setJobDetail(alphaJobDetail);
factoryBean.setName("alphaTrigger");
factoryBean.setGroup("alphaTriggerGroup");
factoryBean.setRepeatInterval(3000);
factoryBean.setJobDataMap(new JobDataMap());
return factoryBean;
}
}
```
## 17. 热帖排行
### 17.1 PostScoreRefreshJob
```java
/**
* @Auther: csp1999
* @Date: 2020/12/04/18:48
* @Description: 作用：定时对帖子分数进行刷新
*/
public class PostScoreRefreshJob implements Job, CommunityConstant {
private static final Logger logger = LoggerFactory.getLogger(PostScoreRefreshJob.class);
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private DiscussPostService discussPostService;
@Autowired
private LikeService likeService;
@Autowired
private ElasticSearchService elasticSearchService;
// 牛客纪元(常量)
private static final Date epoch;
// 静态代码块，随着类的加载而加载
static {
try {
epoch = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2020-11-11 00:00:00");
} catch (ParseException e) {
throw new RuntimeException("初始化牛客纪元失败!", e);
}
}
/**
* 定时任务：定时对帖子分数进行刷新
* @param context
* @throws JobExecutionException
*/
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
// 获取帖子分数集合的key
String redisKey = RedisKeyUtil.getPostScoreKey();
BoundSetOperations operations = redisTemplate.boundSetOps(redisKey);
if (operations.size() == 0) {
logger.info("[任务取消] 没有需要刷新的帖子!");
return;
}
logger.info("[任务开始] 正在刷新帖子分数: " + operations.size());
while (operations.size() > 0) {
// 批量从 operations 弹出帖子id,并刷新计算帖子的分数,直到operations=0结束
this.refresh((Integer) operations.pop());
}
logger.info("[任务结束] 帖子分数刷新完毕!");
}
// 刷新计算帖子分数的方法
private void refresh(int postId) {
DiscussPost post = discussPostService.findDiscussPostById(postId);
if (post == null) {
logger.error("该帖子不存在: id = " + postId);
return;
}
// 是否精华
boolean wonderful = post.getStatus() == 1;
// 评论数量
int commentCount = post.getCommentCount();
// 点赞数量
long likeCount = likeService.findEntityLikeCount(ENTITY_TYPE_POST, postId);
// 计算权重
double w = (wonderful ? 75 : 0) + commentCount * 10 + likeCount * 2;
// 分数 = 帖子权重 + 距离牛客纪元的天数
double score = Math.log10(Math.max(w, 1))
+ (post.getCreateTime().getTime() - epoch.getTime()) / (1000 * 3600 * 24);
// 更新帖子分数
discussPostService.updateScore(postId, score);
// 同步ES中的搜索数据
post.setScore(score);
elasticSearchService.saveDiscussPost(post);
}
}
```
## 18.生成长图
* 使用工具：**tkhtmltopdf**
* 官网下载地址：[https://wkhtmltopdf.org/downloads.html](https://wkhtmltopdf.org/downloads.html)
* 入门介绍参考文章：[wkhtmltopdf工具将网站转换成pdf或图片](https://csp1999.blog.csdn.net/article/details/110716381)
### 18.1 ShareController
```java
/**
* @Auther: csp1999
* @Date: 2020/12/05/19:41
* @Description: 图片生成并分享
*/
@Controller
public class ShareController implements CommunityConstant {
private static final Logger logger = LoggerFactory.getLogger(ShareController.class);
@Autowired
private EventProducer eventProducer;
// 项目域名
@Value("${community.path}")
private String path;
// 项目名称
@Value("${server.servlet.context-path}")
private String contextPath;
// 图片存储地址
@Value("${wk.image.storage}")
private String wkImageStorage;
/**
* 分享操作
* @param htmlUrl
* @return
*/
@RequestMapping(path = "/share", method = RequestMethod.GET)
@ResponseBody
public String share(String htmlUrl) {
// 文件名
String fileName = CommunityUtil.generateUUID();
// kafka 消息生产者通知消息消费者异步生成长图
Event event = new Event()
.setTopic(TOPIC_SHARE)
.setData("htmlUrl", htmlUrl)
.setData("fileName", fileName)
.setData("suffix", ".png");
eventProducer.fireEvent(event);
// 返回的访问路径放入map
Map map = new HashMap<>();
map.put("shareUrl", path + contextPath + "/share/image/" + fileName);
return CommunityUtil.getJSONString(0, null, map);
}
/**
* 获取长图
* @param fileName
* @param response
*/
@RequestMapping(path = "/share/image/{fileName}", method = RequestMethod.GET)
public void getShareImage(@PathVariable("fileName") String fileName, HttpServletResponse response) {
if (StringUtils.isBlank(fileName)) {
throw new IllegalArgumentException("文件名不能为空!");
}
response.setContentType("image/png");
File file = new File(wkImageStorage + "/" + fileName + ".png");
try {
OutputStream os = response.getOutputStream();
FileInputStream fis = new FileInputStream(file);
byte[] buffer = new byte[1024];
int b = 0;
while ((b = fis.read(buffer)) != -1) {
os.write(buffer, 0, b);
}
} catch (IOException e) {
logger.error("获取长图失败: " + e.getMessage());
}
}
}
```
### 18.2 在Kafka 事件消费者中添加如下代码
```java
// wk 工具的路径(生成图片)
@Value("${wk.image.command}")
private String wkImageCommand;
// 图片存储位置
@Value("${wk.image.storage}")
private String wkImageStorage;
/**
* 消费图片分享事件
*
* @param record
*/
@KafkaListener(topics = TOPIC_SHARE)
public void handleShareMessage(ConsumerRecord record) {
if (record == null || record.value() == null) {
logger.error("消息的内容为空!");
return;
}
Event event = JSONObject.parseObject(record.value().toString(), Event.class);
if (event == null) {
logger.error("消息格式错误!");
return;
}
String htmlUrl = (String) event.getData().get("htmlUrl");
String fileName = (String) event.getData().get("fileName");
String suffix = (String) event.getData().get("suffix");
// cmd 命令
String cmd = wkImageCommand + " --quality 75 "
+ htmlUrl + " " + wkImageStorage + "/" + fileName + suffix;
try {
// 操作系统执行cmd 命令
Runtime.getRuntime().exec(cmd);
logger.info("生成长图成功: " + cmd);
} catch (IOException e) {
logger.error("生成长图失败: " + e.getMessage());
}
}
```
### 18.3 测试生成长图
我们测试执行：[http://localhost:8080/community/share?htmlUrl=https://www.baidu.com]()，得到如下结果：
我们通过访问该返回的图片路径测试，可以得到该图片：
本地目录中查看生成的图片：
## 19. 项目性能优化
### 19.1 pom.xml导入caffeine依赖
```java
com.github.ben-manes.caffeine
caffeine
2.7.0
```
### 19.2 application.properties 配置文件中添加配置
```properties
# caffeine 本地缓存相关配置
# 缓存的帖子列表(max-size:表示本地缓存空间内最多能缓存的数据条数 15条)
caffeine.posts.max-size=15
# 缓存的帖子列表(expire-seconds:表示本地缓存数据的过期时间 180s)
caffeine.posts.expire-seconds=180
```
### 19.3 优化Service层相关的代码
为Service层相关的代码加上本地缓存：
**DiscussPostService** 中添加缓存相关代码
```java
@Value("${caffeine.posts.max-size}")
private int caffeineCacheMaxSize;// 最大本地缓存数据的条数
@Value("${caffeine.posts.expire-seconds}")
private int caffeineCacheExpireSeconds;// 本地缓存数据的过期时间
/**
* Caffeine 核心接口：Cache , LoadingCache , AsyncLoadingCache
*/
// 帖子列表缓存
private LoadingCache> discussPostListCache;
// 帖子总数缓存
private LoadingCache discussPostRowsCache;
/**
* 当该类被实例化或者被调用时,
* 该init() 方法在构造函数以及@Autowired 之后执行
*/
@PostConstruct
public void init() {
// 初始化帖子列表缓存
discussPostListCache = Caffeine.newBuilder()
// 最大本地缓存数据的条数
.maximumSize(caffeineCacheMaxSize)
// 本地缓存数据的过期时间
.expireAfterWrite(caffeineCacheExpireSeconds, TimeUnit.SECONDS)
.build(new CacheLoader>() {
@Override
public @Nullable List load(@NonNull String key) throws Exception {
// 判断获取缓存的key 是否为空
if (key == null || key.length() == 0) {
throw new IllegalArgumentException("key为空...");
}
// 分割key 获得参数(limit 和 offset)
String[] params = key.split(":");
if (params == null || params.length != 2) {
throw new IllegalArgumentException("参数错误...");
}
int offset = Integer.valueOf(params[0]);
int limit = Integer.valueOf(params[1]);
// 扩展：可以自己再加一个二级缓存 Redis -> Mysql
// 从数据库查数据,获取后将数据放入本地缓存
logger.info("从DB中获取帖子列表数据...");
return discussPostMapper.selectDiscussPosts(0, offset, limit, 1);
}
});
// 初始化帖子总数缓存
discussPostRowsCache = Caffeine.newBuilder()
// 最大本地缓存数据的条数
.maximumSize(caffeineCacheMaxSize)
// 本地缓存数据的过期时间
.expireAfterWrite(caffeineCacheExpireSeconds, TimeUnit.SECONDS)
.build(new CacheLoader() {
@Override
public @Nullable Integer load(@NonNull Integer key) throws Exception {
// 从数据库查数据,获取后将数据放入本地缓存
logger.info("从DB中获取帖子总数量...");
return discussPostMapper.selectDiscussPostRows(key);
}
});
}
/**
* 查询用户发布的所有帖子(分页)
*
* @param userId 用户id
* @param offset 起始位置
* @param limit 每一页的数量
* @return
*/
public List findDiscussPosts(int userId, int offset, int limit,
// 当用户id为0 且 orderMode为1即热门帖子
if (userId == 0 && orderMode == 1) {
String cacheKey = offset + ":" + limit;
// 从本地缓存中获取数据
return discussPostListCache.get(cacheKey);
}
// 不满足以上条件,则从数据库查数据
logger.info("从DB中获取帖子列表数据...");
return discussPostMapper.selectDiscussPosts(userId, offset, limit, order
}
/**
* 根据userid 查询该用户发布的所有帖子数量
*
* @param userId 用户id
* @return
*/
public int findDiscussPostRows(int userId) {
// 当用户id为0时
if (userId == 0) {
Integer cacheKey = userId;
// 从本地缓存中获取数据
return discussPostRowsCache.get(cacheKey);
}
// 不满足以上条件,则从数据库查数据
logger.info("从DB中获取帖子数据的总数量...");
return discussPostMapper.selectDiscussPostRows(userId);
}
```
### 19.4 jemeter 压力测试
我们使用测试工具，测试缓存是否生效，访问首页的热门帖子：
我们模仿100个线程访问[http://localhost:8080/community/index?orderMode=1]() 接口，可以看到控制台只有第一次访问的时候打印sql（从DB中查询数据），其他时候都是走本地缓存获取数据！这样就能提高热点页面访问速度！
## 20. 项目部署
### 20.1 服务器配置要求(我用的阿里云服务器)
* 2核4G(或者2个1核1G)
* CentOS 7.X
### 20.2 需要部署的内容
* MySQL
* Redis
* Kafka
* ElasticSearch
* Wktmltopdf
* Nginx
* Tomcat
* JDK8
* 项目压缩包