Springboot+websocket+定时器实现消息推送

由于最近有个需求,产品即将到期(不同时间段到期)时给后台用户按角色推送,功能完成之后在此做个小结

1. 在启动类中添加注解@EnableScheduling

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@MapperScan("com.siwei.insurance.*.dao")
@EnableScheduling //该注解是开启定时任务的支持
public class lifeInsuranceApplication extends SpringBootServletInitializer {

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
		return builder.sources(lifeInsuranceApplication.class);
	}

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

}

2. 写定时器

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import com.siwei.insurance.entity.ExpirePushMsg;
import com.siwei.insurance.helper.TotalConstant;
import com.siwei.insurance.permission.dao.RolePermissionDao;
import com.siwei.insurance.productManage.dao.ExpirePushMsgMapper;
import com.siwei.insurance.productManage.service.ProductService;
import com.siwei.insurance.until.DateUtil;

@Component
public class ProductExpireTask {
	
	@Autowired
	private RolePermissionDao rolePermissionDao;
	
	@Autowired
	private ProductService productService;
	
	@Autowired
	private ExpirePushMsgMapper expirePushMsgMapper;
	
    //每天早上0点执行
	@Scheduled(cron = "0 0 0 1/1 * ?")
	public void productExpire() {
        //距离到期还有一个月提醒
		String oneMonthExpireDate = DateUtil.addOneMonth();
		dealExpireProduct(oneMonthExpireDate);
		
        //距离到期还有一天提醒 
		String oneDayExpireDate = DateUtil.addOneDay();
		dealExpireProduct(oneDayExpireDate);
		
        //距离到期还有一周提醒
		String oneWeekExpireDate = DateUtil.addFewDays(7);
		dealExpireProduct(oneWeekExpireDate);
	}
	
	private void dealExpireProduct(String expireDate) {
		List<Map<String, Object>> expireProductMapList = productService.findExpireProducts(expireDate);
		if(expireProductMapList != null && !expireProductMapList.isEmpty()) {
			// 根据路径查询需要推送的角色
			List<String> needPushRoleIds = rolePermissionDao.findNeedPushRoleIdByUrl(TotalConstant.PRODUCT_PUSH_URL);
			List<ExpirePushMsg> expirePushMsgs = new ArrayList<>();
			for (Map<String, Object> expireProductMap : expireProductMapList) {
				ExpirePushMsg expirePushMsg = new ExpirePushMsg();
				expirePushMsg.setNeedPushEntityId((int)expireProductMap.get("id"));
				expirePushMsg.setNeedPushEntityNo((String)expireProductMap.get("insuranceNo"));
				String productName = (String)expireProductMap.get("insuranceName");
				expirePushMsg.setNeedPushEntityName(productName);
                //设置此推送消息的到期时间
				expirePushMsg.setExpireDate(DateUtil.stringToDate(DateUtil.addOneDay()));
				expirePushMsg.setPushType(2);
				StringBuffer needPushRoleIdString = new StringBuffer();
				needPushRoleIds.forEach(e -> needPushRoleIdString.append(e + ";"));
				expirePushMsg.setPushRoleId(needPushRoleIdString.toString().trim());
				String productExpireDateString = DateUtil.dateToShotString((Date)expireProductMap.get("expiryDate"));
				expirePushMsg.setPushMsg("您的产品:" + productName + ",将于" + productExpireDateString + "即将过期,请及时处理!");
				expirePushMsgs.add(expirePushMsg);
			}
			expirePushMsgMapper.insertAll(expirePushMsgs);
		}
	}
	
	@Scheduled(cron = "0 0 0 1/1 * ?")
	public void pushMsgExpire() {
		String oneDayExpireDate = DateUtil.getZeroTime(DateUtil.addOneDay());
        //推送消息只存在一天,根据到期时间将数据删除
		expirePushMsgMapper.deleteByExpireDate(oneDayExpireDate);
	}
}

DateUtil工具类

package com.siwei.insurance.until;

import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.StringUtils;

/**
 * @Description 时间处理工具类 
 * @author linxiunan
 * @date 2018年9月3日
 */
public class DateUtil {

	private static final SimpleDateFormat dayOfDateFormat = new SimpleDateFormat("yyyy-MM-dd");
	
	private static final SimpleDateFormat secondOfDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	/**
	 * @return 当天时间加一天,返回"yyyy-MM-dd"格式
	 */
	public static String addOneDay() {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.DAY_OF_MONTH, 1);
		return dayOfDateFormat.format(calendar.getTime());
	}
	
	/**
	 * @return 当天时间加一月,返回"yyyy-MM-dd"格式
	 */
	public static String addOneMonth() {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.MONTH, 1);
		return dayOfDateFormat.format(calendar.getTime());
	}
	
	/**
	 * @param dayNumber 加的天数
	 * @return 返回当天时间添加几天之后的时间,返回"yyyy-MM-dd"格式
	 */
	public static String addFewDays(int dayNumber) {
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.DAY_OF_MONTH, dayNumber);
		return dayOfDateFormat.format(calendar.getTime());
	}
	
	/**
	 * @param dateString 需要转换成时间格式的日期字符串
	 * @return 返回字符串转换成的时间
	 */
	public static Date stringToDate(String dateString) {
		ParsePosition parsePosition = new ParsePosition(0);
		if(dateString.contains(" ")) {
			return secondOfDateFormat.parse(dateString, parsePosition);
		}else {
			return dayOfDateFormat.parse(dateString, parsePosition);
		}
	}
	
	/**
	 * @param date 需要转换成字符串格式的日期
	 * @return 返回"yyyy-MM-dd"格式的转换后的字符串
	 */
	public static String dateToShotString(Date date) {
		return dayOfDateFormat.format(date);
	}
	
	/**
	 * @param date 需要转换成字符串格式的日期
	 * @return 返回"yyyy-MM-dd HH:mm:ss"格式的转换后的字符串
	 */
	public static String dateToLongString(Date date) {
		return secondOfDateFormat.format(date);
	}
	
	/**
	 * @param dateString 需要获取0点的时间字符串,如果获取当天0点,传null即可
	 * @return 返回"yyyy-MM-dd HH:mm:ss"格式的某天0点字符串
	 */
	public static String getZeroTime(String dateString) {
		if(StringUtils.isBlank(dateString)) {
			Calendar calendar = Calendar.getInstance();
			calendar.set(Calendar.HOUR_OF_DAY, 0);
			calendar.set(Calendar.MINUTE, 0);
			calendar.set(Calendar.SECOND, 0);
			return secondOfDateFormat.format(calendar.getTime());
		}else {
			Date date = stringToDate(dateString);
			return dateToLongString(date);
		}
	}
}

3. 引入websocket所需jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

4. 配置websocket

编写MyEndpointConfigure类

import javax.websocket.server.ServerEndpointConfig;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class MyEndpointConfigure extends ServerEndpointConfig.Configurator implements ApplicationContextAware {
	private static volatile BeanFactory context;

	@Override
	public <T> T getEndpointInstance(Class<T> clazz) throws InstantiationException {
		return context.getBean(clazz);
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		MyEndpointConfigure.context = applicationContext;
	}
}

websocket配置类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

import com.siwei.insurance.websocket.MyEndpointConfigure;

@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
	    return new ServerEndpointExporter();
    }
	
    @Bean
    public MyEndpointConfigure newConfigure() {
        return new MyEndpointConfigure();
    }
}

这里需要重点说明一下,在websocket配置类中,第一个配置是因为使用springboot内置容器,自己开发时需要配置,如果有独立的容器需要将其注释掉,也就意味着,如果将项目打成WAR包,部署到服务器,使用Tomcat启动时,需要注释掉ServerEndpointExporter配置;MyEndpointConfigure配置是因为我的需求需要,需要在websocket类中注入service层或者dao层的接口,MyEndpointConfigure配置就是为了解决websocket无法注入的问题,如果没有需要可以不用配置

5. websocket类

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArraySet;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.siwei.insurance.permission.dao.UserRoleDao;
import com.siwei.insurance.productManage.dao.ExpirePushMsgMapper;

@Component
@ServerEndpoint(value = "/productWebSocket/{userId}", configurator = MyEndpointConfigure.class)
public class ProductWebSocket {
	
	// 静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
	private static int onlineCount = 0;

	// concurrent包的线程安全Set,用来存放每个客户端对应的ProductWebSocket对象。
	private static CopyOnWriteArraySet<ProductWebSocket> webSocketSet = new CopyOnWriteArraySet<ProductWebSocket>();

	// 与某个客户端的连接会话,需要通过它来给客户端发送数据
	private Session session;
	
	@Autowired
	private UserRoleDao userRoleDao;
	
	@Autowired
	private ExpirePushMsgMapper expirePushMsgMapper;
	
	private Logger log = LoggerFactory.getLogger(ProductWebSocket.class);

	/**
	 * 连接建立成功调用的方法
	 */
	@OnOpen
	public void onOpen(@PathParam("userId")String userId, Session session) {
		log.info("新客户端连入,用户id:" + userId);
		this.session = session;
		webSocketSet.add(this); // 加入set中
		addOnlineCount(); // 在线数加1
		
        //相关业务处理,根据拿到的用户ID判断其为那种角色,根据角色ID去查询是否有需要推送给该角色的消息,有则推送
		if(StringUtils.isNotBlank(userId)) {
			List<String> roleIds = userRoleDao.findRoleIdByUserId(userId);
			List<String> totalPushMsgs = new ArrayList<String>();
			for (String roleId : roleIds) {
				List<String> pushMsgs = expirePushMsgMapper.findPushMsgByRoleId(roleId);
				if(pushMsgs != null && !pushMsgs.isEmpty())
					totalPushMsgs.addAll(pushMsgs);
			}
			if(totalPushMsgs != null && !totalPushMsgs.isEmpty()) {
				totalPushMsgs.forEach(e -> sendMessage(e));
			}
		}
		
	}

	/**
	 * 连接关闭调用的方法
	 */
	@OnClose
	public void onClose() {
		log.info("一个客户端关闭连接");
		webSocketSet.remove(this); // 从set中删除
		subOnlineCount(); // 在线数减1
	}

	/**
	 * 收到客户端消息后调用的方法
	 *
	 * @param message
	 *            客户端发送过来的消息
	 */
	@OnMessage
	public void onMessage(String message, Session session) {
		
	}

	/**
	 * 发生错误时调用
	 */
	@OnError
	public void onError(Session session, Throwable error) {
		log.error("websocket出现错误");
		error.printStackTrace();
	}

	public void sendMessage(String message) {
		try {
			this.session.getBasicRemote().sendText(message);
			log.info("推送消息成功,消息为:" + message);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 群发自定义消息
	 */
	public static void sendInfo(String message) throws IOException {
		for (ProductWebSocket productWebSocket : webSocketSet) {
			productWebSocket.sendMessage(message);
		}
	}

	public static synchronized int getOnlineCount() {
		return onlineCount;
	}

	public static synchronized void addOnlineCount() {
		ProductWebSocket.onlineCount++;
	}

	public static synchronized void subOnlineCount() {
		ProductWebSocket.onlineCount--;
	}
}

这样后台的功能基本上就算是写完了,前端配合测试一下

6. 前端测试

写一个页面,代码如下

<!DOCTYPE HTML>
<html>
<head>
    <title>My WebSocket</title>
</head>
 
 
<body>
Welcome<br/>
<input id="text" type="text" /><button onclick="send()">Send</button>    <button onclick="closeWebSocket()">Close</button>
<div id="message">
</div>
</body>
 
 
<script type="text/javascript">
    var websocket = null;
 
 
    //判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        websocket = new WebSocket("ws://localhost:8080/productWebSocket/001");
    }
    else{
        alert('Not support websocket')
    }
 
 
    //连接发生错误的回调方法
    websocket.onerror = function(){
        setMessageInnerHTML("error");
    };
 
 
    //连接成功建立的回调方法
    websocket.onopen = function(event){
        setMessageInnerHTML("open");
    }
 
 
    //接收到消息的回调方法
    websocket.onmessage = function(event){
        setMessageInnerHTML(event.data);
    }
 
 
    //连接关闭的回调方法
    websocket.onclose = function(){
        setMessageInnerHTML("close");
    }
 
 
    //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
    window.onbeforeunload = function(){
        websocket.close();
    }
 
 
    //将消息显示在网页上
    function setMessageInnerHTML(innerHTML){
        document.getElementById('message').innerHTML += innerHTML + '<br/>';
    }
 
 
    //关闭连接
    function closeWebSocket(){
        websocket.close();
    }
 
 
    //发送消息
    function send(){
        var message = document.getElementById('text').value;
        websocket.send(message);
    }
</script>
</html>

项目启动之后,打开页面

open下方就是我添加的消息,可以看出已经成功推送,到此该功能就算完成结束了

参考地址:https://www.cnblogs.com/bianzy/p/5822426.html

 

展开阅读全文

没有更多推荐了,返回首页