java web 站内信详解编程语言

package com.alphajuns.junit; 
 
import com.alphajuns.ssm.service.MessageService; 
import org.junit.Test; 
import org.springframework.beans.factory.annotation.Autowired; 
 
import java.util.HashMap; 
import java.util.Map; 
 
public class MessageTest extends SuperJunitTest { 
 
    @Autowired 
    private MessageService messageService; 
 
    @Test 
    public void saveMessageTest() { 
        // 封装发送消息 
        // { sender:"AlphaJunS", topic: "ceshi", body:"message body" , url:"http://www.baidu.com" ,receivers:"zhangsan,lisi" } 
        Map<String, String> mailMap = new HashMap<String, String>(); 
        mailMap.put("sender", "AlphaJunS"); 
        mailMap.put("topic", "通知"); 
        mailMap.put("body", "message body"); 
        mailMap.put("url", "http://www.baidu.com"); 
        mailMap.put("receivers", "zhangsan,lisi"); 
        messageService.createMessage(mailMap); 
    } 
 
} 

package com.alphajuns.ssm.service; 
 
import java.util.List; 
import java.util.Map; 
 
public interface MessageService { 
 
    public List<Map<String,?>> invoke(String methodName, Map<String,?> param) throws ReflectiveOperationException; 
 
    public void deleteMessageByReceiver(Map<String,?> param); 
 
    public void createMessage(Map<String,?> param); 
 
    void createMessageByUserList(Map<String, ?> param); 
 
} 

package com.alphajuns.ssm.service.impl; 
 
import com.alphajuns.ssm.mybatis.MessageMapper; 
import com.alphajuns.ssm.service.MessageService; 
import com.alphajuns.ssm.util.MyBatisBatchHelper; 
import org.apache.ibatis.session.SqlSession; 
import org.apache.ibatis.session.SqlSessionFactory; 
import org.apache.log4j.Logger; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
 
import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
 
@Service 
public class MessageServiceImpl implements MessageService { 
 
    private static Logger logger = Logger.getLogger(MessageServiceImpl.class); 
 
    @Autowired 
    private MessageMapper messageMapper; 
 
    @Autowired 
    private SqlSessionFactory sqlSessionFactoryBiz; 
 
    @SuppressWarnings("unchecked") 
    public List<Map<String,?>> invoke(String methodName, Map<String,?> param) throws ReflectiveOperationException { 
        List<Map<String,?>> returnList = null; 
        Class clazz = messageMapper.getClass(); 
        try { 
            Method m = clazz.getDeclaredMethod(methodName, Map.class); 
            Object returnObj = m.invoke(messageMapper, param); 
            if(returnObj instanceof List<?>){ 
                returnList = (List<Map<String, ?>>) returnObj; 
                //调用post方法来继续处理某些负责情况 
                Class serviceClazz = this.getClass(); 
                Method[] methods = serviceClazz.getDeclaredMethods(); 
                boolean hasPostMethod = false; 
                for(Method method : methods){ 
                    logger.debug(serviceClazz.getCanonicalName()+"method:"+method); 
                    if(method.getName().contains(methodName+"Post")){ 
                        hasPostMethod = true; 
                        Object newReturnObj = method.invoke(this, param,returnList); 
                        if(newReturnObj instanceof List<?>){ 
                            returnList = (List<Map<String, ?>>) newReturnObj; 
                        } 
                    } 
                } 
                if(!hasPostMethod){ 
                    logger.warn("You could add ["+methodName+"Post] to class "+serviceClazz.getCanonicalName()); 
                } 
            } 
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
            throw e; 
        } 
        return returnList; 
    } 
 
    /** 
     * deleteMessageByReceiver 
     * @param param(receiver, msgId) 
     * @return 
     */ 
    @Override 
    public void deleteMessageByReceiver(Map<String, ?> param) { 
        messageMapper.deleteMessageByReceiver(param); 
        int count = messageMapper.countMessageUserByMsgId(param); 
        if (count == 0) { 
            messageMapper.deleteMessageByMsgId(param); 
        } 
    } 
 
    /** 
     * createMessage 
     * @param param { sender:"xiazj", topic: "ceshi", body:"sdfsdf" , url:"http://www.baidu.com" ,receivers:"gengjw,Devin" } 
     * 
     * @return 
     */ 
    @Override 
    public void createMessage(Map<String, ?> param) { 
        messageMapper.insertMessage(param); 
        int msgId = (Integer) param.get("id"); 
 
        String receivers = (String) param.get("receivers"); 
        String[] receiverArr = receivers.split(","); 
        Map<String, Object> tmpParam = new HashMap<String, Object>(); 
        tmpParam.put("msgId", msgId); 
        for (String receiver : receiverArr) { 
            tmpParam.put("receiver", receiver); 
            messageMapper.insertMessageInbox(tmpParam); 
        } 
    } 
 
    @SuppressWarnings("unchecked") 
    @Override 
    public void createMessageByUserList(Map<String, ?> param) { 
        SqlSession sqlSession = MyBatisBatchHelper.openSession(sqlSessionFactoryBiz); 
        MessageMapper batchMessageMapper = sqlSession.getMapper(MessageMapper.class); 
        try{ 
            batchMessageMapper.insertMessage(param); 
            int msgId = (Integer) param.get("id"); 
            List<String> receiverList = (List<String>) param.get("receiverList"); 
            Map<String, Object> tmpParam = new HashMap<String, Object>(); 
            tmpParam.put("msgId", msgId); 
            if(receiverList!=null){ 
                for (String receiver : receiverList) { 
                    tmpParam.put("receiver", receiver); 
                    batchMessageMapper.insertMessageInbox(tmpParam); 
                } 
            } 
        }catch(Exception e){ 
            MyBatisBatchHelper.rollback(sqlSession); 
        } 
        MyBatisBatchHelper.commit(sqlSession); 
        MyBatisBatchHelper.close(sqlSession); 
    } 
 
} 

package com.alphajuns.ssm.mybatis; 
 
import org.apache.ibatis.annotations.Param; 
 
import java.util.List; 
import java.util.Map; 
 
public interface MessageMapper { 
 
    /** 
     * deleteMessageByReceiver 
     * @param param 
     * @return 
     */ 
    public abstract void deleteMessageByReceiver(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * countMessageUserByMsgId 
     * @param param 
     * @return 
     */ 
    public abstract int countMessageUserByMsgId(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * deleteMessageByMsgId 
     * @param param 
     * @return 
     */ 
    public abstract void deleteMessageByMsgId(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * insertMessage 
     * @param param 
     * @return 
     */ 
    public abstract void insertMessage(Map<String,?> param); 
 
    /** 
     * insertMessageInbox 
     * @param param 
     * @return 
     */ 
    public abstract void insertMessageInbox(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * queryUnreadMessageNum 
     * @param param 
     * @return 
     */ 
    public abstract List<Map<String,?>> queryUnreadMessageNum(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * updateMessageStatus 
     * @param param 
     * @return 
     */ 
    public abstract void updateMessageStatus(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * queryMessageDetail 
     * @param param 
     * @return 
     */ 
    public abstract List<Map<String,?>> queryMessageDetail(@Param("paramMap") Map<String,?> param); 
 
    /** 
     * queryMessageList 
     * @param param 
     * @return 
     */ 
    public abstract List<Map<String,?>> queryMessageList(@Param("paramMap") Map<String,?> param); 
 
    /**查询类似的消息 
     * querySameContentMsg 
     * @param param 
     * @return 
     */ 
    public abstract List<Map<String,?>> querySameContentMsg(@Param("paramMap") Map<String,?> param); 
 
} 

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > 
<mapper namespace="com.alphajuns.ssm.mybatis.MessageMapper" > 
 
    <!-- 删除用户消息 --> 
    <delete id="deleteMessageByReceiver" parameterType="map"> 
         delete from message_inbox 
         where receiver = #{paramMap.receiver,jdbcType=VARCHAR} 
         and msg_id = #{paramMap.msgId, jdbcType=INTEGER} 
    </delete> 
 
    <!-- 查询消息用户数 --> 
    <select id="countMessageUserByMsgId" resultType="java.lang.Integer" parameterType="map"> 
	  	SELECT count(1) 
	  	FROM message_inbox 
	  	WHERE msg_id = #{paramMap.msgId, jdbcType=INTEGER} 
    </select> 
 
    <!-- 删除消息 --> 
    <delete id="deleteMessageByMsgId" parameterType="map"> 
         delete from message 
         where msg_id = #{paramMap.msgId, jdbcType=INTEGER} 
    </delete> 
 
    <!-- 创建消息 --> 
    <insert id="insertMessage" parameterType="map"  > 
        <selectKey resultType="java.lang.Integer" order="AFTER" keyProperty="id"> 
            SELECT LAST_INSERT_ID() 
        </selectKey> 
        insert into message (msg_id, sender, topic, body, url, msg_date) 
        values (#{id, jdbcType=INTEGER}, #{sender, jdbcType=VARCHAR}, #{topic, jdbcType=VARCHAR}, 
        #{body, jdbcType=VARCHAR},#{url, jdbcType=VARCHAR}, now()) 
    </insert> 
 
    <!-- 新建消息收件人关系--> 
    <insert id="insertMessageInbox" parameterType="map" > 
      insert into message_inbox (msg_id,receiver,flag) 
      values (#{paramMap.msgId, jdbcType=INTEGER}, #{paramMap.receiver, jdbcType=VARCHAR}, '0') 
    </insert> 
 
    <!-- 查询未读消息数 --> 
    <select id="queryUnreadMessageNum" resultType="map" parameterType="map"> 
	  	SELECT count(1) as count 
	  	FROM MESSAGE_INBOX 
	  	WHERE receiver = #{paramMap.receiver, jdbcType=VARCHAR} 
	  	AND flag = '0' 
    </select> 
 
    <!-- 更新消息状态 --> 
    <update id="updateMessageStatus" parameterType="map" > 
      update message_inbox 
      set    flag = #{paramMap.flag, jdbcType=VARCHAR} 
      where  receiver = #{paramMap.receiver, jdbcType=VARCHAR} 
      and	 msg_id = #{paramMap.msgId, jdbcType=INTEGER} 
    </update> 
 
    <!-- 查询消息--> 
    <select id="queryMessageDetail" resultType="map" parameterType="map"> 
	  	SELECT T1.FLAG, T2.MSG_ID, T2.TOPIC, T2.BODY, T2.MSG_DATE, T2.URL, NVL(T6.FULL_NAME,T2.SENDER) AS SENDER, TO_CHAR(WMSYS.WM_CONCAT (t5.FULL_NAME)) AS RECEIVERS 
		FROM (SELECT * FROM TM_MESSAGE_INBOX 
				WHERE MSG_ID = #{paramMap.msgId, jdbcType=INTEGER} AND RECEIVER = #{paramMap.receiver,jdbcType=VARCHAR} 
			) T1 
		LEFT JOIN TM_MESSAGE T2 ON T1.MSG_ID = T2.MSG_ID 
		LEFT JOIN TM_USER T6 ON T2.SENDER = T6.USER_ACCOUNT 
		LEFT JOIN ( SELECT T4.FULL_NAME, T3.MSG_ID 
					FROM (SELECT RECEIVER, MSG_ID FROM TM_MESSAGE_INBOX 
							WHERE MSG_ID = #{paramMap.msgId, jdbcType=INTEGER} 
						) T3 
					LEFT JOIN TM_USER t4 ON T3.RECEIVER = T4.USER_ACCOUNT ) T5 ON T1.MSG_ID = T5.MSG_ID 
		GROUP BY T1.flag, T2.MSG_ID, T2.TOPIC, T2.BODY, T2.MSG_DATE, T2.URL, NVL(T6.FULL_NAME,T2.SENDER) 
    </select> 
 
    <!-- 查询消息列表 --> 
    <select id="queryMessageList" resultType="map" parameterType="map"> 
	  	SELECT T1.MSG_ID, T1.FLAG, T2.SENDER, T2.TOPIC, T2.MSG_DATE, NVL(T3.FULL_NAME, T2.SENDER) as SENDER_NAME 
	  	FROM (select MSG_ID, FLAG from TM_MESSAGE_INBOX where RECEIVER = #{paramMap.receiver, jdbcType=VARCHAR}) T1 
		LEFT JOIN TM_MESSAGE T2 ON T1.MSG_ID = T2.MSG_ID 
		LEFT JOIN TM_USER T3 ON T2.SENDER = T3.USER_ACCOUNT 
    </select> 
 
    <!-- 查询是否有相同的内容--> 
    <select id="querySameContentMsg" resultType="map" parameterType="map"> 
        SELECT count(1) as count 
        FROM TM_MESSAGE 
        WHERE TOPIC like '%' || '${paramMap.topicTemplate}' || '%' 
        and BODY like '%' || '${paramMap.bodyContent}' || '%' 
        <if test="paramMap.limitTime!=null"> 
            and (sysdate>Cast(MSG_DATE As Date))<![CDATA[<]]>3 
        </if> 
    </select> 
 
</mapper>