(转)JMS简明学习教程
转:http://www.cnblogs.com/jjj250/archive/2012/08/08/2628552.html
基础篇
JMS是应用系统或组件之间相互通信的应用程序接口,利用它,我们可以轻易实现在不同JVM之间相互的远程通信。要实现远程通信,RPC同样也能做到,但RPC却不可避免地增加了不同系统之间的耦合度,JMS能极大地降低不同的应用系统之间的耦合。
要学习JMS,有几个概念必须要搞清楚:
l Messaging (消息通知、消息通信)
一种应用系统或组件之间相互通信的方式。
l Message (消息)
消息即为消息通信的载体,消息包括Message Headers, Message properties, Message bodies
l JMS有两种方式进行消息通信:Point-to-Point (P2P) 和 Publish/Subscriber (PUB/SUB)
P2P方式是一对一的,一条消息只有一个接收者,默认情况下是P2P消息是持久的,也就是说发送者(sender)产生的一条消息(message)发送到消息队列(queue)之上后,只有等到消息接收者(receiver)接收到它,才会从消息队列中删除,没有被接收的消息会一直存在JMS容器里。这种方式有点像邮政通信,信件只有一个接收者,信件在接收之前,会一直存放在信箱里。
PUB/SUB方式的工作流程,首先subscriber(订阅者)向JMS容器订阅(Listen to)自己感兴趣的topic(主题),多个订阅者可以同时对一个主题进行订阅,消息发布者发布一条消息,所有订阅了该主题的订阅者都能收到这个消息。默认情况下,pub/sub方式下的消息不是持久的,这意味着,消息一经发出,不管有没有人接收,都不会保存下来,而且订阅者只能接收到自已订阅之后发布者发出的消息。这种方式有点像订阅报刊杂志,一种报刊可以有多人同时订阅,但订阅者只能收到开始订阅之后的报社发行的期刊。
l JMS(Java Messaging Service)
是Java EE中的一种技术,它定义一套完整的接口,来实现不同系统或应用之间的消息通信。这意味着:我们针对JMS接口编写的应用程序(客户程序),在任何一个实现了标准JMS接口的容器下都能运行起来,我们的应用程序与容器实现了真正的解藕,这也就是面向接口编程的好处之一吧。这点类似JDBC编程。
l JMS提供者(JMS Provider)
JMS提供者,也叫JMS服务器或JMS容器,也就是JMS服务的提供者,主流的J2EE容器一般都提供JMS服务(比如JBoss,BEA WebLogic,IBM WebSphere,Oracle Application Server等都支持)
l 连接工厂(Connection Factories)
连接工厂是用来创建客户端到JMS容器之间JMS连接的工厂,连接工厂有两种:(QueueConnectionFactory和TopicConnectionFactory),分别用来创建QueueConnection 和 TopicConnection的。
Context ctx = new InitialContext();QueueConnectionFactory queueConnectionFactory = (QueueConnectionFactory) ctx.lookup("QueueConnectionFactory");TopicConnectionFactory topicConnectionFactory = (TopicConnectionFactory) ctx.lookup("TopicConnectionFactory");
l 目的地(Destinations)
目的地是消息生产者(producer)消息发住的目的地,也是消费者(consumer)接收消息的来源地,它有点像信箱,邮递员把信件投往信箱,收件人从信箱取信件。对P2P方式来说,目的地就是Queue,对pub/sub方式来说,目的地就是Topic。我们要得到这个目的地的引用,只能通过JNDI查找(lookup)的方式得到,因为目的地是注册在JMS服务器的(后面的章节会讲到如何注册一个目的地)
Topic myTopic = (Topic) ctx.lookup("MyTopic");Queue myQueue = (Queue) ctx.lookup("MyQueue");
l 连接(Connection)
这里说的连接是指客户端与JMS提供者(容器)之间的连接。连接也分两种:QueueConnection和TopicConnection,分别对应于P2P连接和Pub/Sub连接。
QueueConnection queueConnection = queueConnectionFactory.createQueueConnection();TopicConnection topicConnection = topicConnectionFactory.createTopicConnection();
连接用完之后必须记得关闭,否则连接资源不会被释放掉。关闭连接的同时会自动把会话、产生者、消费者都关闭掉。
l 会话(Session)
会话是用来创建消息产生者和消息消费者的单线程环境,你可以它来创建消息生产者、消费者、消息,用它来维持消息监听。
TopicSession topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);QueueSession queueSession = queueConnection.createQueueSession(true, 0);
l 消息生产者(Message Producers)
消息生产者也就是消息的产生者或发送者,在P2P方式下它是QueueSender
,在Pub/Sub方式下它是TopicPublisher
。
它是一个由session创建的,用来把把消息发送到目的地的对象。
QueueSender queueSender = queueSession.createSender(myQueue);TopicPublisher topicPublisher = topicSession.createPublisher(myTopic);
一旦你创建好生产者,你就可以用它来发送消息
queueSender.send(message);topicPublisher.publish(message);
l 消息消费者(Message Consumer)
消息消费者也就是消息的接收者或使用者,在P2P方式下这是QueueReceiver,在Pub/Sub方式下它是TopicSubscriber。这是一个由session来创建的,用来接收来自目的地消息的对象。JMS容器来负责把消息从目的地投递到注册了该目的地的消息消费者。
QueueReceiver queueReceiver = queueSession.createReceiver(myQueue);TopicSubscriber topicSubscriber = topicSession.createSubscriber(myTopic);
一旦创建好消息消费者,它就是活动的,你可以用它来接收消息,你也可以用close()方法来使它失效(Inactive)。当你调用Connection的start()方法之前,消费者是不会接收到任何消息的。两种接收者都有一个receive方法,这是一个同步的方法,也就是说程序执行到这个方法会被阻塞,直到收到消息为止。
queueConnection.start();Message m = queueReceiver.receive();
topicConnection.start();Message m = topicSubscriber.receive(1000); // time out after a second
如果我们不想它被阻塞,就需要异步的接收消息,这时我们得用消息临听器(Message Listener)了。
l 消息监听器(Message Listener)
消息监听器是一个充当消息的异步事件处理器的对象,它实现了MessageListener接口,这个接口只有一个方法onMessage,在这个方法里,你可以定义当接收到消息之后的要做的操作。你可以用setMessageListener方法为消息消费者注册一个监听器。
MessageListener listener = new MessageListener( {
public void onMessage(Message msg) { // }});
topicSubscriber.setMessageListener(listener); //注册监听topicConnection.start();
有一点要注意,如果你先调用Connection的start,然后再调用setMessageListener,消息很可能接收不到,正确的做法是先注册监听,再启动Connection。
注册监听之后,一旦JMS容器有消费投递过来,消息消费(接收)者就会自动调用监听器的onMessage方法。这个方法的带有一个参数Message,这就接收到的消息。
l 消息选择器(Message Selectors)
假如你只需要一个对滤器来过滤收到的消息,那么你可以使用消息选择器,它允许消费者指定只对特定的消息感兴趣。消息选择器只能是工作在JMS容器的,而不是我们的应用程序上。消息选择器是一个包含一个表达式的字符串,这个表达式的语法类似SQL的条件表达式,在createReceiver, createSubscriber这些方法里有一个参数让你指定一个消息选择器,由这些方法创建的消费者就只能收到与消息选择器匹配的消息了。
l 消息(Messages)
JMS消息包括三个部分:消息头(Header),属性(Properties),消息体(Body)
其中消息头是必须的,后两个是可选的。
1)消息头里你可以指定JMSMessageID,JMSCorrelationID, JMSReplyTo,JMSType等信息。
2)属性指定一些消息头没有包括的附加信息,比如可以在属性里指定消息选择器。
3)消息体是消息的内容,有5种消息类型:TextMessage,MapMessage,BytesMessage,StreamMessage,ObjectMessage=-
TextMessage message = queueSession.createTextMessage();message.setText(msg_text); // msg_text is a StringqueueSender.send(message);
在消费者端,接收到的总是一个通用的Message对象,你需要把它转型成特定的类型才能提取出里面的内容。
Message m = queueReceiver.receive();if (m instanceof TextMessage) { TextMessage message = (TextMessage) m; System.out.println("Reading message: " + message.getText());} else { // Handle error}
前面对JMS概念的作了一个基本介绍,下面我们看一个具体的例子程序
import javax.jms.JMSException;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicPublisher;
import javax.jms.TopicSession;
import javax.naming.InitialContext;
import javax.naming.NamingException;
TopicConnection topicConnection;// JMS连接,属于Pub/Sub方式的连接
TopicSession topicSession; //JMS会话,属于Pub/Sub方式的会话
TopicPublisher topicPublisher; //消息发布者
public HelloPublisher(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Hashtable<String, String> env = new Hashtable<String, String>();
//设置好连接JMS容器的属性,不同的容器需要的属性可能不同,需要查阅相关文档
env.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
env.put(Context.PROVIDER_URL, "localhost:1099");
env.put("java.naming.rmi.security.manager", "yes");
env.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");
Context context = new InitialContext(env);
//通过连接工厂的JNDI名查找ConnectionFactory
TopicConnectionFactory topicFactory =
(TopicConnectionFactory) context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(false,
topic = (Topic) context.lookup(topicJNDI);
topicPublisher = topicSession.createPublisher(topic);
public void publish(String msg) throws JMSException {
TextMessage message = topicSession.createTextMessage();
topicPublisher.publish(topic, message);//消息发送,发送到特定主题
public void close() throws JMSException {
topicSession.close();//关闭session
topicConnection.close();//关闭连接
public static void main(String[] args)
throws JMSException, NamingException {
new HelloPublisher("ConnectionFactory", "topic/testTopic");
for (int i = 1; i < 11; i++) {
String msg = "Hello World no. " + i;
System.out.println("Publishing message: " + msg);
publisher.close();//session和connection用完之后一定记得关闭
Publishing message: Hello World no. 1
Publishing message: Hello World no. 2
Publishing message: Hello World no. 3
Publishing message: Hello World no. 4
Publishing message: Hello World no. 5
Publishing message: Hello World no. 6
Publishing message: Hello World no. 7
Publishing message: Hello World no. 8
Publishing message: Hello World no. 9
Publishing message: Hello World no. 10
import javax.jms.JMSException;
import javax.jms.MessageListener;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.InitialContext;
import javax.naming.NamingException;
* pub/sub方式下的消息接收器。注意,这个消息接收器可以与上面的消息发送器可以工作
* 在不同的JVM中,只要保证它们各自能够连通JMS容器(JMS Provider)
public class HelloSubscriber implements MessageListener {
TopicConnection topicConnection;
TopicSubscriber topicSubscriber;
public HelloSubscriber(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Hashtable<String, String> env = new Hashtable<String, String>();
//设置好连接JMS容器的属性,不同的容器需要的属性可能不同,需要查阅相关文档
env.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
env.put(Context.PROVIDER_URL, "localhost:1099");
env.put("java.naming.rmi.security.manager", "yes");
env.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");
Context context = new InitialContext();
TopicConnectionFactory topicFactory =
(TopicConnectionFactory) context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);//创建session
topic = (Topic) context.lookup(topicJNDI);//查找到主题
topicSubscriber = topicSession.createSubscriber(topic);
//注册监听,这里设置的监听是自己,因为本类已经实现了MessageListener接口,
//一旦queueReceiver接收到了消息,就会调用本类的onMessage方法
topicSubscriber.setMessageListener(this);
System.out.println("HelloSubscriber subscribed to topic: "
topicConnection.start();//启动连接,这时监听器才真正生效
public void onMessage(Message msg) {
if (msg instanceof TextMessage) {
//把Message 转型成 TextMessage 并提取消息内容
String msgTxt = ((TextMessage) msg).getText();
System.out.println("HelloSubscriber got message: " +
System.err.println("Could not get text message: " + ex);
public void close() throws JMSException {
public static void main(String[] args) {
new HelloSubscriber("TopicConnectionFactory",
HelloSubscriber subscribed to topic: topic/testTopic
HelloSubscriber got message: Hello World no. 1
HelloSubscriber got message: Hello World no. 2
HelloSubscriber got message: Hello World no. 3
HelloSubscriber got message: Hello World no. 4
HelloSubscriber got message: Hello World no. 5
HelloSubscriber got message: Hello World no. 6
HelloSubscriber got message: Hello World no. 7
HelloSubscriber got message: Hello World no. 8
HelloSubscriber got message: Hello World no. 9
HelloSubscriber got message: Hello World no. 10
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueConnection;
import javax.jms.QueueSession;
import javax.jms.JMSException;
QueueConnection queueConnection; //queue方式的JMS连接
QueueSession queueSession; //queue会话
QueueSender queueSender; //queue消息发送者
public HelloQueue(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
props.put(Context.PROVIDER_URL, "localhost:1099");
props.put("java.naming.rmi.security.manager", "yes");
props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");
Context context = new InitialContext(props);
QueueConnectionFactory queueFactory =
(QueueConnectionFactory) context.lookup(factoryJNDI);
queueConnection = queueFactory.createQueueConnection();//创建连接
queueSession = queueConnection.createQueueSession(false,
Session.AUTO_ACKNOWLEDGE);//创建会话
queue = (Queue) context.lookup(topicJNDI);//lookup到特定的消息队列
queueSender = queueSession.createSender(queue);//创建队列消息的发送者
public void send(String msg) throws JMSException {
TextMessage message = queueSession.createTextMessage();
queueSender.send(queue, message);
public void close() throws JMSException {
public static void main(String[] args) {
HelloQueue queue = new HelloQueue("ConnectionFactory",
for (int i = 11; i < 21; i++) {
String msg = "Hello World no. " + i;
System.out.println("Hello Queue Publishing message: " + msg);
System.err.println("An exception occurred " +
"while testing HelloPublisher25: " + ex);
Hello Queue Publishing message: " Hello World no. 11
Hello Queue Publishing message: " Hello World no. 12
Hello Queue Publishing message: " Hello World no. 13
Hello Queue Publishing message: " Hello World no. 14
Hello Queue Publishing message: " Hello World no. 15
Hello Queue Publishing message: " Hello World no. 16
Hello Queue Publishing message: " Hello World no. 17
Hello Queue Publishing message: " Hello World no. 18
Hello Queue Publishing message: " Hello World no. 19
Hello Queue Publishing message: " Hello World no. 20
import javax.jms.JMSException;
import javax.jms.MessageListener;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSession;
import javax.jms.QueueReceiver;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class HelloRecvQueue implements MessageListener {
QueueConnection queueConnection;
public HelloRecvQueue(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Context context = new InitialContext();
QueueConnectionFactory queueFactory =
(QueueConnectionFactory) context.lookup(factoryJNDI);
queueConnection = queueFactory.createQueueConnection();
queueSession = queueConnection.createQueueSession(false,
queue = (Queue) context.lookup(topicJNDI);
queueReceiver = queueSession.createReceiver(queue);
queueReceiver.setMessageListener(this);
System.out.println("HelloReceQueue receiver to queue: " + topicJNDI);
public void onMessage(Message m) {
String msg = ((TextMessage) m).getText();
System.out.println("HelloReceQueue got message: " + msg);
System.err.println("Could not get text message: " + ex);
public void close() throws JMSException {
Public ovid main(String[] args) {
HelloReceQueue got message: Hello World no. 11
HelloReceQueue got message: Hello World no. 12
HelloReceQueue got message: Hello World no. 13
HelloReceQueue got message: Hello World no. 14
HelloReceQueue got message: Hello World no. 15
HelloReceQueue got message: Hello World no. 16
HelloReceQueue got message: Hello World no. 17
HelloReceQueue got message: Hello World no. 18
HelloReceQueue got message: Hello World no. 19
HelloReceQueue got message: Hello World no. 20
配置篇
下面我们来看看是JMS是在JBoss下如何配置的,首先JMS需要一个数据库来保存其持久化的消息,幸运的是JBoss自带有一个开源的JAVA数据库HSQL(www.hsqldb.org)
启动这个数据库有三种模式:Server模式、进程模式和内存模式,在Server模式下,你可以用下面的命令让它启动起来:
$cd %JBOSS_HOME%/server/default/lib
$ java -cp hsqldb.jar org.hsqldb.Server -database.0 mydb -dbname.0 demoDB
其中mydb是数据库名,demoDB是数据库别名,我们用JDBC连它是就用这个别名,用户名是sa,密码默认是空,我们下列语句就能创建表、插入数据了
insert into employee values(1, 'linyufa', 33, '2007-12-17')
insert into employee values(2, 'scott', 25, '2008-11-23')
insert into employee values(3, 'larry', 35, '2004-11-23')
想进一步了解HSQL的知识,网上有很多学习资料,好了,回到我们讨论的JMS话题,有了这个数据库,那我们就不必去找其他数据库了,JMS默认是用内存模式来启动它的,所以我们基本上不用去关心它是如何工作的。
1) 在 %JBOSS_HOME%/server/default/deploy/jms目录下,
打开hsqldb-jdbc-state-service.xml文件,
<depends optional-attribute-name="ConnectionManager">
jboss.jca:service= DataSourceBinding, name=DefaultDS
DefaultDS这个名字就是JMS连接数据库的数据源,可以让其保持默认值。
2) 再在同一目录打开hsqldb-jdbc2-service.xml 文件,
<depends optional-attribute-name="ConnectionManager">
jboss.jca:service=DataSourceBinding,name=DefaultDS
DefaultDS这个名字保持和前面一致即可,也可以让其保持默认值。
3) 在同一目录打开jbossmq-destinations-service.xml文件,找到下面的代码段:
<mbean code="org.jboss.mq.server.jmx.Topic"
name="jboss.mq.destination:service=Topic,name=testTopic">
<depends optional-attribute-name="DestinationManager">
jboss.mq:service=DestinationManager
<depends optional-attribute-name="SecurityManager">
jboss.mq:service=SecurityManager
<attribute name="SecurityConf">
<role name="guest" read="true" write="true"/>
<role name="publisher" read="true" write="true" create="false"/>
<role name="durpublisher" read="true" write="true" create="true"/>
这是定义一个名叫testTopic的示例,如果你要定义一个新的topic,只需要复制这段代码,改一下name属性即可。
同样找到下面这段的代码,这是定义一个名叫testQueue的示例,如果要定义一个新的queue,复制这段代码,改一下名字即可。
<mbean code="org.jboss.mq.server.jmx.Queue"
name="jboss.mq.destination:service=Queue,name=testQueue">
<depends optional-attribute-name="DestinationManager">
jboss.mq:service=DestinationManager
<depends optional-attribute-name="SecurityManager">
jboss.mq:service=SecurityManager
<attribute name="MessageCounterHistoryDayLimit">-1</attribute>
<attribute name="SecurityConf">
<role name="guest" read="true" write="true"/>
<role name="publisher" read="true" write="true" create="false"/>
<role name="noacc" read="false" write="false" create="false"/>
4) 启动Jboss后在控制台看到如下输出,即说明JMS正常启动了
09:50:28,390 INFO [A] Bound to JNDI name: queue/A
09:50:28,406 INFO [B] Bound to JNDI name: queue/B
09:50:28,406 INFO [C] Bound to JNDI name: queue/C
09:50:28,406 INFO [D] Bound to JNDI name: queue/D
09:50:28,421 INFO [ex] Bound to JNDI name: queue/ex
09:50:28,437 INFO [testTopic] Bound to JNDI name: topic/testTopic
09:50:28,484 INFO [securedTopic] Bound to JNDI name: topic/securedTopic
09:50:28,484 INFO [testDurableTopic] Bound to JNDI name: topic/testDurableTopic
09:50:28,500 INFO [testQueue] Bound to JNDI name: queue/testQueue
JMS编程其他注意事项
JMS的Connection和JDBC的Connection类似,不再使用后应该关闭,不管是正常退出,还是异常退出,否则别的客户程序可能就再也取不到连接了。Session也是如此。
转载于:https://www.cnblogs.com/wangle1001986/p/3201922.html
(转)JMS简明学习教程相关推荐
- [z]JMS简明学习教程
基础篇 JMS是应用系统或组件之间相互通信的应用程序接口,利用它,我们可以轻易实现在不同JVM之间相互的远程通信.要实现远程通信,RPC同样也能做到,但RPC却不可避免地增加了不同系统之间的耦合度,J ...
- WebPack 简明学习教程
WebPack 简明学习教程 字数1291 阅读22812 评论11 喜欢35 WebPack是什么 一个打包工具 一个模块加载工具 各种资源都可以当成模块来处理 网站 http://webpack. ...
- 复印机维修简明学习教程
文章导航 第一章 复印机的工作原理 静电原理 光学成像原理 半导体原理 第二章 复印机的工作过程 第三章 复印机的机械结构 第四章 复印机的电气结构 第五章 复印机的调整 一.机械调整 二.图像. ...
- C语言(第1篇)简明学习教程
目录 1.初识C语言 2.C语言概述 3.数据类型 4.输入输出 1.初识C语言 1.特点:c语言库较少,编程更偏向底层,想要什么就做什么,所以执行速度更快.(所以Python这样的程序语言不用库就和 ...
- Python学习网站(简明python教程,The Python Tutorial,Python学习笔记,啄木鸟社区)
简明python教程(W3CSCHOOL):http://www.w3cschool.cc/python/python-tutorial.html The Python Tutorial(英文): h ...
- 简明 Python3 教程 | 学习笔记
GitBook 原电子书地址:简明 Python 教程 <A Byte of Python>是一本由 Swaroop C H 编写,旨在于介绍如何使用 Python 语言进行编程的自由图书 ...
- 《简明python教程》的学习笔记
学习python的缘由 决心在一个这个寒假更加深入学习推荐系统之后,本来打算看数据挖掘导论或者是数据挖掘:概念与技术.不过在询问过一位学长之后,他推荐我看一看更加基础的书:集体智慧编程.该书所有的代码 ...
- python自学入门教程-Python学习教程(一)自学资源分享
在我看来,基本上可以不负责任地认为,Python 可以做任何事情.无论是从入门级选手到专业级选手都在做的爬虫,还是Web 程序开发.桌面程序开发还是科学计算.图像处理,Python都可以胜任. 或许是 ...
- 简明python教程在线-简明python教程
广告关闭 2017年12月,云+社区对外发布,从最开始的技术博客到现在拥有多个社区产品.未来,我们一起乘风破浪,创造无限可能. usrbinpython#hello_world.pyprinthell ...
最新文章
- 推荐系统去偏(Debiased Recommendation)研究进展概述
- 深度学习之循环神经网络(10)GRU简介
- 基于RHEL6.0的mysql服务器复制的主主架构实现
- MFC CListCtrl 将一个列表的选中项添加到另一个列表
- HQL左外连接及排序
- MFC CListCtrl实现双击编辑
- 大规模电机控制的方案选择-电机和驱动器篇
- [转帖]方正数码发布基于龙芯3A3000系列整机
- 美团点评旅游搜索召回策略的演进
- 关于ip、pv、uv的概念
- [pyecharts学习笔记]——页面组件 Page(顺序多图,将多个图将汇总到一个页面)
- Windows下使用taskkill 命令结束进程
- 阿里云自定义域名详细过程----hexo博客配置实测详细过程整理之二
- navicat for mysql注册码,各种版本都有
- 浩顺考勤机二次开发(第二版,附实测可用的demo)
- Linux-Postfix+Dovecot+Postfixadmin+Roundcubemail 搭建邮件服务器管理系统(一)
- 微信小程序(原生):基本开发相关文档
- 【预测模型】基于 bp神经网络风电功率预测matlab源码
- javascript和java哪个快_Javascript与Java相比有多快?
- Linux软件仓库 全解析