SSH综合项目实战（快递） -- day10 activeMQ、JQueryEasyUI行编辑功能

最新推荐文章于 2019-06-09 13:49:31 发布

DJTUDaker

最新推荐文章于 2019-06-09 13:49:31 发布

阅读量910

点赞数 1

分类专栏： ssh项目实战

本文链接：https://blog.csdn.net/wingzhezhe/article/details/77975249

版权

ssh项目实战专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、activeMQ使用

1、activeMQ安装

（1）、解压windows版本的ActiveMQ到非中文目录下

（2）、启动

（3）、浏览器访问

2、编写入门程序

（1）、创建java项目，导入jar包

（2）、编写生产者代码

package cn.itcast.activemq.test;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * 消息生产者
 * @author Administrator
 *
 */
public class JMSProducer {
	// 默认连接用户名
	private static final String USERNAME = ActiveMQConnection.DEFAULT_USER;
	// 默认连接密码
	private static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;
	// 默认连接地址
	private static final String BROKEURL = ActiveMQConnection.DEFAULT_BROKER_URL;
	// 发送的消息数量
	private static final int SENDNUM = 10;

	public static void main(String[] args) {
		// 连接工厂
		ConnectionFactory connectionFactory;
		// 连接
		Connection connection = null;
		// 会话 接受或者发送消息的线程
		Session session;
		// 消息的目的地
		Destination destination;
		// 消息生产者
		MessageProducer messageProducer;
		// 实例化连接工厂
		connectionFactory = new ActiveMQConnectionFactory(JMSProducer.USERNAME, JMSProducer.PASSWORD,
				JMSProducer.BROKEURL);

		try {
			// 通过连接工厂获取连接
			connection = connectionFactory.createConnection();
			// 启动连接
			connection.start();
			// 创建session
			session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
			// 创建一个名称为HelloWorld的消息队列
			destination = session.createQueue("HelloWorld");
			// 创建消息生产者
			messageProducer = session.createProducer(destination);
			// 发送消息
			sendMessage(session, messageProducer);

			session.commit();

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (connection != null) {
				try {
					connection.close();
				} catch (JMSException e) {
					e.printStackTrace();
				}
			}
		}

	}

	/**
	 * 发送消息
	 * 
	 * @param session
	 * @param messageProducer
	 *            消息生产者
	 * @throws Exception
	 */
	public static void sendMessage(Session session, MessageProducer messageProducer) throws Exception {
		for (int i = 0; i < JMSProducer.SENDNUM; i++) {
			// 创建一条文本消息
			TextMessage message = session.createTextMessage("ActiveMQ 发送消息" + i);
			System.out.println("发送消息：Activemq 发送消息" + i);
			// 通过消息生产者发出消息
			messageProducer.send(message);
		}

	}
}

（3）、编写消费者代码

package cn.itcast.activemq.test;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * 消息消费者
 * @author Administrator
 *
 */
public class JMSConsumer {
	private static final String USERNAME = ActiveMQConnection.DEFAULT_USER;// 默认连接用户名
	private static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;// 默认连接密码
	private static final String BROKEURL = ActiveMQConnection.DEFAULT_BROKER_URL;// 默认连接地址

	public static void main(String[] args) {
		ConnectionFactory connectionFactory;// 连接工厂
		Connection connection = null;// 连接

		Session session;// 会话 接受或者发送消息的线程
		Destination destination;// 消息的目的地

		MessageConsumer messageConsumer;// 消息的消费者

		// 实例化连接工厂
		connectionFactory = new ActiveMQConnectionFactory(JMSConsumer.USERNAME, JMSConsumer.PASSWORD,
				JMSConsumer.BROKEURL);

		try {
			// 通过连接工厂获取连接
			connection = connectionFactory.createConnection();
			// 启动连接
			connection.start();
			// 创建session
			session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
			// 创建一个连接HelloWorld的消息队列
			destination = session.createQueue("HelloWorld");
			// 创建消息消费者
			messageConsumer = session.createConsumer(destination);

			while (true) {
				TextMessage textMessage = (TextMessage) messageConsumer.receive(100000);
				if (textMessage != null) {
					System.out.println("收到的消息:" + textMessage.getText());
				} else {
					break;
				}
			}

		} catch (JMSException e) {
			e.printStackTrace();
		}

	}
}

（4）、直接启动提供者和消费者即可测试运行

（5）、编写消息监听器接收消息

package cn.itcast.activemq.test;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.junit.Test;

/**
 * 消息监听器测试类
 * @author Administrator
 *
 */
public class JMSConsumerListenerTest {
	@Test
	public void testConsumer() throws JMSException {
		ConnectionFactory connectionFactory;// 连接工厂
		Connection connection = null;// 连接

		Session session;// 会话 接受或者发送消息的线程
		Destination destination;// 消息的目的地

		MessageConsumer messageConsumer;// 消息的消费者

		// 实例化连接工厂
		connectionFactory = new ActiveMQConnectionFactory(BROKEURL);

		// 通过连接工厂获取连接
		connection = connectionFactory.createConnection();
		// 启动连接
		connection.start();
		// 创建session
		session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		// 创建一个连接HelloWorld的消息队列
		destination = session.createQueue("HelloWorld");
		// 创建消息消费者
		messageConsumer = session.createConsumer(destination);

		messageConsumer.setMessageListener(new MessageListener() {
			@Override
			public void onMessage(Message message) {
				try {
					System.out.println(((TextMessage) message).getText());
				} catch (JMSException e) {
					e.printStackTrace();
				}
			}
		});

		while (true) {

		}
	}

	private static final String USERNAME = ActiveMQConnection.DEFAULT_USER;// 默认连接用户名
	private static final String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;// 默认连接密码
	private static final String BROKEURL = ActiveMQConnection.DEFAULT_BROKER_URL;// 默认连接地址

}

3、spring整合activeMQ

（1）、创建jar包方式的maven工程，导入pom.xml中的jar包坐标

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.itheima.maven</groupId>
	<artifactId>activeMQ_spring</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.2.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>
		<dependency>  
            <groupId>org.apache.xbean</groupId>  
            <artifactId>xbean-spring</artifactId>  
            <version>4.2</version>  
        </dependency> 
	</dependencies>
</project>

（2）、编写生产者代码

queue方式：

package cn.itcast.activemq.producer.queue;

import java.util.Map;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

/**
 * 
 * @description 队列消息生产者，发送消息到队列
 * 
 */
@Component("queueSender")
public class QueueSender {

	@Autowired
	@Qualifier("jmsQueueTemplate")
	private JmsTemplate jmsTemplate;// 通过@Qualifier修饰符来注入对应的bean

	/**
	 * 发送一条消息到指定的队列（目标）
	 * 
	 * @param queueName
	 *            队列名称
	 * @param message
	 *            消息内容
	 */
	public void send(String queueName, final String message) {
		jmsTemplate.send(queueName, new MessageCreator() {
			@Override
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});
	}

	public void send(String queueName, final Map<String, String> map) {
		jmsTemplate.send(queueName, new MessageCreator() {
			@Override
			public Message createMessage(Session session) throws JMSException {
				MapMessage message = session.createMapMessage();
				for (String key : map.keySet()) {
					message.setString(key, map.get(key));
				}
				return message;
			}
		});
	}

}

topic方式：

package cn.itcast.activemq.producer.topic;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

/**
 * 
 * @description Topic生产者发送消息到Topic
 * 
 */

@Component("topicSender")
public class TopicSender {

	@Autowired
	@Qualifier("jmsTopicTemplate")
	private JmsTemplate jmsTemplate;

	/**
	 * 发送一条消息到指定的队列（目标）
	 * 
	 * @param queueName
	 *            队列名称
	 * @param message
	 *            消息内容
	 */
	public void send(String topicName, final String message) {
		jmsTemplate.send(topicName, new MessageCreator() {
			@Override
			public Message createMessage(Session session) throws JMSException {
				return session.createTextMessage(message);
			}
		});
	}

}

（3）、编写消费者代码

Queue方式：

package cn.itcast.activemq.consumer.queue;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.springframework.stereotype.Component;

/**
 * 
 * @description 队列消息监听器
 * 
 */
@Component
public class QueueReceiver1 implements MessageListener {

	@Override
	public void onMessage(Message message) {
		try {
			System.out.println("QueueReceiver1接收到消息:" + ((TextMessage) message).getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}
}

package cn.itcast.activemq.consumer.queue;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.springframework.stereotype.Component;

/**
 * 
 * @description 队列消息监听器
 * 
 */
@Component
public class QueueReceiver2 implements MessageListener {

	@Override
	public void onMessage(Message message) {
		try {
			System.out.println("QueueReceiver2接收到消息:" + ((TextMessage) message).getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

package cn.itcast.activemq.consumer.queue;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageListener;

import org.springframework.stereotype.Component;

/**
 * 
 * @description 队列消息监听器
 * 
 */
@Component
public class QueueReceiver3 implements MessageListener {

	@Override
	public void onMessage(Message message) {
		try {
			System.out.println("QueueReceiver3接收到消息:" + ((MapMessage) message).getString("company"));
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

Topic方式：

package cn.itcast.activemq.consumer.topic;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.springframework.stereotype.Component;

/**
 * 
 * @description Topic消息监听器
 * 
 */
@Component
public class TopicReceiver1 implements MessageListener {

	@Override
	public void onMessage(Message message) {
		try {
			System.out.println("TopicReceiver1接收到消息:" + ((TextMessage) message).getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

package cn.itcast.activemq.consumer.topic;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

import org.springframework.stereotype.Component;

/**
 * 
 * @description Topic消息监听器
 * 
 */
@Component
public class TopicReceiver2 implements MessageListener {

	@Override
	public void onMessage(Message message) {
		try {
			System.out.println("TopicReceiver2接收到消息:" + ((TextMessage) message).getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

（4）、编写spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
	xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms.xsd
		http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd ">
	
	<!-- 扫盲包 -->
	<context:component-scan base-package="cn.itcast.activemq" />
	
	<!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码-->
    <amq:connectionFactory id="amqConnectionFactory"
        brokerURL="tcp://localhost:61616" userName="admin" password="admin"  />
        
    <!-- 或者用以下创建工厂的方式 
    <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    	<constructor-arg index="0" value="admin"></constructor-arg>
    	<constructor-arg index="1" value="admin"></constructor-arg>
    	<constructor-arg index="2" value="tcp://localhost:61616"></constructor-arg>
    </bean>
	-->
	
	
    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    
     <!-- Spring JmsTemplate 的消息生产者 start-->

    <!-- 定义JmsTemplate的Queue类型 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅），即队列模式 -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 定义JmsTemplate的Topic类型 -->
    <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
         <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <constructor-arg ref="connectionFactory" />
        <!-- pub/sub模型（发布/订阅） -->
        <property name="pubSubDomain" value="true" />
    </bean>

    <!--Spring JmsTemplate 的消息生产者 end-->

    <!-- 消息消费者 start-->

    <!-- 定义Queue监听器 -->
    <jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
        <jms:listener destination="test.queue" ref="queueReceiver1"/>
        <jms:listener destination="test.queue" ref="queueReceiver2"/>
    </jms:listener-container>
    
    <jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
        <jms:listener destination="test.map" ref="queueReceiver3"/>
    </jms:listener-container>

    <!-- 定义Topic监听器 -->
    <jms:listener-container destination-type="topic" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
        <jms:listener destination="test.topic" ref="topicReceiver1"/>
        <jms:listener destination="test.topic" ref="topicReceiver2"/>
    </jms:listener-container>

    <!-- 消息消费者 end -->
    
    
</beans>

（5）、编写测试类

package cn.itcast.activemq.test;

import java.util.HashMap;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.activemq.producer.queue.QueueSender;
import cn.itcast.activemq.producer.topic.TopicSender;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext-mq.xml")
public class ActiveMQTest {
	@Autowired
	private QueueSender queueSender;

	@Autowired
	private TopicSender topicSender;

	@Test
	public void testMQ() {

		queueSender.send("test.queue", "Hello,Queue");
		topicSender.send("test.topic", "Hello,Topic");
		Map<String, String> map = new HashMap<>();
		map.put("company", "传智播客");
		queueSender.send("test.map", map);

		while (true) {
			// 持续执行 ，让监听器 有时间接收信息
		}
	}
}

二、重构客户注册功能，发短信功能分离

1、在common-parent项目中导入activeMQ相关jar包坐标

2、在bos_fore的spring配置文件中配置activeMQ的相关模版配置

	<!-- ----------------------------------activeMQ的相关配置---------------------------------- -->
	<!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码
    <amq:connectionFactory id="amqConnectionFactory"
        brokerURL="tcp://localhost:61616" userName="admin" password="admin"  />
        -->
    <!-- 或者用以下创建工厂的方式 -->
    <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    	<constructor-arg index="0" value="admin"></constructor-arg>
    	<constructor-arg index="1" value="admin"></constructor-arg>
    	<constructor-arg index="2" value="tcp://localhost:61616"></constructor-arg>
    </bean>
	

    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    
     <!-- Spring JmsTemplate 的消息生产者 start-->

    <!-- 定义JmsTemplate的Queue类型 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->  
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅），即队列模式 -->
        <property name="pubSubDomain" value="false" />
    </bean>
	<!-- ----------------------------------activeMQ的相关配置---------------------------------- -->

3、在CustomerAction中注入模版对象，并编写代码

三、开发消费者项目 -- 继承common-parent的war项目

1、创建mavne project

2、在web.xml中配置spring监听器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">
	<display-name>bos_sms</display-name>
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
		<welcome-file>default.html</welcome-file>
		<welcome-file>default.htm</welcome-file>
		<welcome-file>default.jsp</welcome-file>
	</welcome-file-list>
	<!-- 初始化spring容器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
</web-app>

3、编写spring核心配置文件，配置activeMQ工厂

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa" 
	xmlns:task="http://www.springframework.org/schema/task"
	xmlns:jaxws="http://cxf.apache.org/jaxws"
	xmlns:soap="http://cxf.apache.org/bindings/soap"
	xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:jms="http://www.springframework.org/schema/jms"
	xsi:schemaLocation="
						http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
						http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
						http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
						http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
						http://www.springframework.org/schema/data/jpa 
						http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
						http://cxf.apache.org/bindings/soap 
						http://cxf.apache.org/schemas/configuration/soap.xsd
						http://cxf.apache.org/jaxws 
						http://cxf.apache.org/schemas/jaxws.xsd
						http://activemq.apache.org/schema/core
        				        http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd
						http://www.springframework.org/schema/jms
				                http://www.springframework.org/schema/jms/spring-jms.xsd">
	
	<!-- ----------------------------------activeMQ的相关配置---------------------------------- -->
	<!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <!-- 如果连接网络：tcp://ip:61616；未连接网络：tcp://localhost:61616 以及用户名，密码 -->
    <bean id="amqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    	<constructor-arg index="0" value="admin"></constructor-arg>
    	<constructor-arg index="1" value="admin"></constructor-arg>
    	<constructor-arg index="2" value="tcp://localhost:61616"></constructor-arg>
    </bean>
	

    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->  
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->  
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>
    
</beans>

4、开发一个监听器类，监听消息队列中的消息

package com.itheima.consumer;

import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageListener;

/**
 * 消息监听类
 * @author Administrator
 *
 */
public class MsgConsumer implements MessageListener {

	//当监听到消息之后，onMessage方法会自动执行
	public void onMessage(Message message) {
		MapMessage mapMessage = (MapMessage) message;
		//从消息对象中获取数据
		try {
			String telephone = mapMessage.getString("telephone");
			String msg = mapMessage.getString("msg");
			System.out.println("成功的接收到了提供者发送的消息：" + telephone + "  :  " +msg);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

5、在spring配置文件中注册监听器

	<bean id="smsConsumer" class="com.itheima.consumer.MsgConsumer"></bean>
	<!-- 注册消息队列监听 -->
	<jms:listener-container destination-type="queue" container-type="default" 
				connection-factory="connectionFactory" acknowledge="auto">
		<!-- destination的值是提供者发布时自定义的地址名称,ref的值是消费者监听器对象 -->
		<jms:listener destination="sms_message" ref="smsConsumer"/>
	</jms:listener-container>

四、JQuery easyUI datagrid 行编辑功能使用方式

1、行编辑功能列属性的API

2、html代码

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="stylesheet" type="text/css" href="../js/easyui/themes/default/easyui.css">
<link rel="stylesheet" type="text/css" href="../js/easyui/themes/icon.css">
<script type="text/javascript" src="../js/jquery-1.8.3.js"></script>
<script type="text/javascript" src="../js/easyui/jquery.easyui.min.js"></script>
<script type="text/javascript" src="../js/easyui/locale/easyui-lang-zh_CN.js"></script>
<script type="text/javascript">
</script>
</head>
<body>
	<hr>
	<!-- 使用datagrid，只需要提供一个URL地址，表格对象会自动发送ajax请求，加载json数据 -->
	<table id="mytable">
	</table>
	
	<script type="text/javascript">
		$(function(){
			var myIndex;//全局变量，记录当前选中行的索引
			//调用easyUI提供的API在页面中动态创建一个datagrid
			$("#mytable").datagrid({
				//定义表格表头所有的列
				columns:[[
				          {id:'id',title:'编号',field:'id',checkbox:true},//每个json对象表示一列
				          {width:100,id:'name',title:'姓名',field:'name',
													editor:{
															type:'validatebox',
															options:{
																required:true
																	}
															}},
				          {width:100,id:'age',title:'年龄',field:'age',editor:{
								type:'datebox',
									options:{}
								 }},
				          {width:100,id:'address',title:'地址',field:'address',
				        	  editor:{
									type:'numberbox',
									options:{}
								 }}
				          ]],
				//指定ajax的请求地址
				url:'../data/datagrid.json',
				rownumbers:true,//显示行号
				singleSelect:true,//是否可以单选,
				
				//结束编辑后触发的事件
				onAfterEdit:function(rowIndex,rowData,changes){
					//发送ajax请求，将改后的数据提交到服务器，修改数据库
					$.post("xx.action",rowData,function(){
						
					});
				},
				
				//定义表格的工具栏
				toolbar:[
				         	{text:'添加',iconCls:'icon-add',handler:function(){
				         		//添加一行
				         		$("#mytable").datagrid("insertRow",{
				         			index:0,//在第一行插入
				         			row:{}//空行
				         		});
				         		myIndex = 0;
				         		//开启编辑
				         		$("#mytable").datagrid("beginEdit",0);
				         	}},//每个json表示一个按钮
				         	{text:'删除',iconCls:'icon-remove',handler:function(){
				         		//获得当前选中行的索引
				         		var rows = $("#mytable").datagrid("getSelections");
				         		if(rows.length == 1){
				         			var row = rows[0];
				         			myIndex = $("#mytable").datagrid("getRowIndex",row);
					         		//删除行
					         		$("#mytable").datagrid("deleteRow",myIndex);
				         		}
				         	}},
				         	{text:'保存',iconCls:'icon-save',handler:function(){
				         		//结束编辑
				         		$("#mytable").datagrid("endEdit",myIndex);
				         	}},
				         	{text:'修改',iconCls:'icon-edit',handler:function(){
				         		//获得当前选中行的索引
				         		var rows = $("#mytable").datagrid("getSelections");
				         		if(rows.length == 1){
				         			var row = rows[0];
				         			myIndex = $("#mytable").datagrid("getRowIndex",row);
					         		$("#mytable").datagrid("beginEdit",myIndex);
				         		}
				         	}}
				         ],
				pagination:true//显示分页条
			});
		});
	</script>
</body>
</html>

五、使用datagrid的行编辑功能实现运单快速录入功能

1、完善waybill_quick.html中结束编辑时触发的事件

2、编写Action代码

package com.itheima.bos.web.action.take_delivery;

import java.io.IOException;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.itheima.bos.domain.take_delivery.WayBill;
import com.itheima.bos.service.take_delivery.WayBillService;
import com.itheima.bos.web.action.common.CommonAction;

/**
 * 工单动作类
 * @author Administrator
 *
 */
@Controller
@Namespace("/")
@ParentPackage("struts-default")
@Scope("prototype")
public class WayBillAction extends CommonAction<WayBill> {

	@Autowired
	private WayBillService service;
	
	@Action(value="waybillAction_save")
	public String save() throws Exception{
		String flag = "1";
		try {
			service.save(model);
		} catch (Exception e) {
			e.printStackTrace();
			flag = "0";
		}
		HttpServletResponse response = ServletActionContext.getResponse();
		response.setContentType("text/html;charset=utf-8");
		response.getWriter().print(flag);
		return NONE;
	}
}

3、编写Service层代码

package com.itheima.bos.service.take_delivery.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.itheima.bos.dao.take_delivery.WayBillDao;
import com.itheima.bos.domain.take_delivery.WayBill;
import com.itheima.bos.service.take_delivery.WayBillService;

@Service
@Transactional
public class WayBillServiceImpl implements WayBillService {

	@Autowired
	private WayBillDao dao;
	public void save(WayBill model) {
		dao.save(model);
	}

}

4、编写Dao层代码

package com.itheima.bos.dao.take_delivery;

import org.springframework.data.jpa.repository.JpaRepository;

import com.itheima.bos.domain.take_delivery.WayBill;

public interface WayBillDao extends JpaRepository<WayBill, Integer> {

}

DJTUDaker

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
SSH综合项目实战（快递） -- day10 activeMQ、JQueryEasyUI行编辑功能

一、activeMQ使用1、activeMQ安装（1）、解压windows版本的ActiveMQ到非中文目录下（2）、启动（3）、浏览器访问2、编写入门程序（1）、创建java项目，导入jar包（2）、编写生产者代码package cn.itcast.activemq.test;import javax.jms.Conne
复制链接

扫一扫