<proxy-factory-config>
   <JMSProviderAdapterJNDI>DefaultJMSProvider</JMSProviderAdapterJNDI>
   <ServerSessionPoolFactoryJNDI>stdjmspool</ServerSessionPoolFactoryJNDI>
   <MinimumSize>1</MinimumSize>
   <MaximumSize>15</Maximumsize>
   <KeepAliveMills>30000</keepAliveMills>
   <MaxMessages>10</MaxMessages> 
   <MDBConfig>
            <ReconnectIntervalSec>10</ReconnectIntervalSec>
            <DLQConfig>
                <DestinationQueue>queue/DLQ</DestinationQueue>
                 <MaxTimesRedelivered>10</MaxTimesRedelivered>
                 <TimeToLive>0</TimeToLive> 
            <DLQConfig>
   </MDBConfig>
  </proxy-factory-config>

  MinimuSize :This specifies the minimum pool size for MDBS processig ,this defaluts to 1
  Maximusize :this specified the upper limit to the number of concurrent MDBS that will be
  allowed for the JMS destination ,this default to 15.
  MaxMessages:It is the maximum number of messages that can be assigned to a server session at one time. This defaults to 1. This
  value should not be modified from the default unless your JMS provider indicates this is supported. 
  KeepAliveMillis:This specifies the keep alive time interval in milliseconds for sessions in the session pool.
The default is 30000 .i think if it is not consumed ,then i will store in file or DB,not stay in pool(Memory)
MDBConfig:Configuration for the MDB JMS connection behavior.

  ReconnectIntervalSec:he time to wait (in seconds) before trying to recover the connection to the JMS
server.

  DeliveryActive: Whether or not the MDB is active at startup. The default is true.

DLQConfig: Configuration for an MDB's dead letter queue, used when messages are redelivered too many
times.

EJB container-pool-conf element

 MinimumSize:The MaximumSize specifies the maximum number of pool instances that are allowed.
MaximumSize:The MaximumSize specifies the maximum number of pool instances that are allowed.
strictMaximumSize:When there are MaximumSize active instances, any subsequent requests will be blocked
until an instance is freed back to the pool. The default value for strictMaximumSize is false.

strictTimeout:A value less than or equal to 0 will mean not to wait at
all. When a request times out waiting for an instance a java.rmi.ServerException is generated and the call
aborted.   

these all from JBOSS.DTD

2: create user .
----------------------------------------------| 
root                                          |
useradd jboss -g oinstall                     |
passwd jboss                                  |
password:123456                               |
su - jboss                                    | 
----------------------------------------------|

3:copy releated file and unzip files
----------------------------------------------------------------------------------|
pwd                                                                               |
/home/jboss                                                                       |
mkdir soft                                                                        |
ll                                                                                |
/home/jboss/soft                                                                  |
copy ant ,tutorial ,jdk, jboss and jbosstutorial to /home/jboss/soft              |
[jboss@ohebt soft]$ ll                                                            |
total 139560                                                                      | 
-rw-r--r--  1 jboss oinstall  7931179 Nov 26 15:16 apache-ant-1.6.2-bin.tar       |
-rw-r--r--  1 jboss oinstall 17135608 Jan 15 10:56 j2ee-1_4-doc-tutorial_2.zip    |
-rwxr--r--  1 jboss oinstall 36377609 Jul 27 16:13 j2sdk-1_4_2_15-linux-i586.bin  |
-rw-r--r--  1 jboss oinstall 80866589 Jan 10 09:13 jboss-4.0.5.GA.zip             |
-rw-r--r--  1 jboss oinstall   399391 Jan 14 16:47 jbossj2ee-src.zip              |
                                                                                  |
tar -zxvf apache-ant-1.6.2-bin.tar                                                |
./j2sdk-1_4_2_15-linux-i586.bin                                                   |
unzip jboss-4.0.5.GA.zip                                                          |
unzip j2ee-1_4-doc-tutorial_2.zip -d ..                                           |
unzip jbossj2ee-src.zip -d ../j2eetutorial14                                      |
                                                                                  |
[jboss@ohebt ~]$ cd ~                                                             |
[jboss@ohebt ~]$                                                                  |
[jboss@ohebt ~]$ ll                                                               |
total 24                                                                          |
drwxr-xr-x  2 jboss oinstall 4096 Jan 17 03:39 Desktop                            |
drwxr-xr-x  5 jboss oinstall 4096 Jan 17 08:03 j2eetutorial14                     |
drwxr-xr-x  5 jboss oinstall 4096 Jan 17 07:59 soft                               |
----------------------------------------------------------------------------------|

4 modify user env
----------------------------------------------------------|
vi .bashrc                                                |
add the following four lines to the end of .bashrc        |
export ANT_HOME=/home/jboss/soft/apache-ant-1.6.2         |
export JAVA_HOME=/home/jboss/soft/j2sdk1.4.2_15           |
export JBOSS_HOME=/home/jboss/soft/jboss-4.0.5.GA         |
export PATH=${ANT_HOME}/bin:${JAVA_HOME}/bin:$PATH        |
----------------------------------------------------------|

5:logout and relogin
---------------------------------|
 the user env become effective   |
---------------------------------|

6: config  hsqldb-ds.xml
---------------------------------------------------------------------------------------------------------|
cd /home/jboss/soft/jboss-4.0.5.GA/server/default/deploy                                                 |
vi hsqldb-ds.xml                                                                                         |
comment  <connection-url>jdbc:hsqldb:${jboss.server.data.dir}${/}hypersonic${/}localDB</connection-url>  |
add      <connection-url>jdbc:hsqldb:hsql://localhost:1701</connection-url>                              |
uncomment                                                                                                |
   <mbean code="org.jboss.jdbc.HypersonicDatabase"                                                       |
     name="jboss:service=Hypersonic">                                                                    |
     <attribute name="Port">1701</attribute>                                                             |
     <attribute name="BindAddress">${jboss.bind.address}</attribute>                                     |
     <attribute name="Silent">true</attribute>                                                           |
     <attribute name="Database">default</attribute>                                                      | 
     <attribute name="Trace">false</attribute>                                                           |
     <attribute name="No_system_exit">true</attribute>                                                   |
   </mbean>                                                                                              |
comment                                                                                                  |
      <mbean code="org.jboss.jdbc.HypersonicDatabase"                                                    |
     name="jboss:service=Hypersonic,database=localDB">                                                   |
     <attribute name="Database">localDB</attribute>                                                      |
     <attribute name="InProcessMode">true</attribute>                                                    |
   </mbean>                                                                                              |
                                                                                                         |
uncomment                                                                                                | 
     <depends>jboss:service=Hypersonic,database=localDB</depends>                                        |
add                                                                                                   |
                                                                                                         |
   <depends>jboss:service=Hypersonic</depends>                                                           |
---------------------------------------------------------------------------------------------------------|
  
  
7:modify j2ee_tutorial related file
--------------------------------------------------|
cd /home/jboss/j2eetutorial14/examples/bank       |
vi  build.properties                              |
only modify one line                              |
jdbc.resource.name=DefaultDS                      |
                                                  |
cd /home/jboss/j2eetutorial14/examples/bank/web   |
there's three \$ exits in the follwoing file      |
transferAck.jsp                                   |
atmAck.jsp                                        |
accountList.txt                                   |
                                                  |
delete \$ from the above three file.              |
--------------------------------------------------|

8: starup jboss
--------------------------------------------------|
cd /home/jboss/soft/jboss-4.0.5.GA/bin            |
nohup ./run.sh                                    |
--------------------------------------------------|

9: Modify build related file
--------------------------------------------|
cd /home/jboss/j2eetutorial14               |
modify jboss-build.properties               |
jboss.home=/home/jboss/soft/jboss-4.0.5.GA  |
jboss.server=${jboss.home}/server/default   |
jboss.deploy.dir=${jboss.server}/deploy     |
--------------------------------------------|

　　插件管理技巧

　　提示：新下载的插件PlugIn一定不要都放在原始的Eclipse目录下去。

1. 前提是你已经安装好了Eclipse工具了，比如安装在E:\OpenSource\Eclipse\目录下，以下这个目录以%ECLIPSE_HOME%来进行表示；
2. 此时默认的插件是在%ECLIPSE_HOME%\plugins目录中的；
3. 在%ECLIPSE_HOME%下建立一个PlugInsNew的目录；
   比如：E:\OpenSource\Eclipse\PlugInsNew\
4. 你下载了个新的插件，比如叫做：XYZ
   　那么就在%ECLIPSE_HOME%\PlugInsNew\目录下建立XYZ目录，目录里面是eclipse目录，eclipse目录包含有features与plugins两个子目录；结构如下图所示：
   
   　　
   
5. 把下载的新插件的文件放在以下相应目录中
   %ECLIPSE_HOME%\PlugInsNew\XYZ\eclipse\features
   %ECLIPSE_HOME%\PlugInsNew\ XYZ\eclipse\plugins
   
6. 建立相关的.link的文件
   然后在%ECLIPSE_HOME%\links目录里建立一个XYZ.link的文件
   内容如是：path=E:/OpenSource/Eclipse/PlugInsNew/XYZ就一行这样的路径指示而已。
   当然，采用相对路径来表示可能更直观一些，方便进行文件整体移动和小组全部成员的共享命名用，省得移动后要改动Link文件里的绝对路径而费心费力。直接拷贝过去就可以使用。
   即XYZ.link文件的内容如是：path=../PlugInsNew/XYZ
   这样，如果你下载了多个插件就可以如法炮制建立多个Link文件，想加载哪个插件就把哪个插件的Link文件放到%ECLIPSE_HOME%\links的目录中即可，使用与管理都很方便，建议千万不要放在默认的安装目录中；
   如果你的%ECLIPSE_HOME%与此不同，请修改XYZ.link文件里的路径
   
7. 删除，关闭Eclipse
   删除%ECLIPSE_HOME%\links\XYZ.link文件即可
   删除%ECLIPSE_HOME%\PlugInsNew\XYZ整个目录及文件
   
8. 重新启动Eclipse即可

　　使用

　　重新启动Eclipse后，在Help => About Eclipse SDK => Plug-in Details你可以看到由“FindBugs Project”提供的“FindBugs Plug-in”版本0.0.17插件，如下图所示：

　　

　　FindBugs的使用方法

　　FindBugs是一个可以在Java程序中发现Bugs的程序。

　　它是专门用来寻找处于“Bug Patterns”列表中的代码的。

　　Bug Patterns指很有可能是错误的代码的实例。

　　目前FindBugs最高版本0.9.4，不过更新速度很快的，你应当经常上去看看是否有新版本发布。Eclipse plugin for FindBugs最高版本0.0.17。

　　系统要求

　　使用FindBugs至少需要JDK1.4.0以上版本，FindBugs是平台独立的，可以运行于GNU/Linux、Windows、MacOS X　等平台上。

　　运行FindBugs至少需要有256 MB内存，如果你要分析一个很大的项目，那就需要更加多的内存了。

　　FindBugs独立运行和与Ant结合的详细操作就不介绍了，可以看官方的文档http://findbugs.sourceforge.net/manual/

　　独立运行的效果图如下：

　　

　　本文主要介绍在Eclipse中使用的情况

　　打开Bug Details视图

　　Windows => Show View => Other… => FindBugs => BugDetails

　　

　　在Package Explorer或Navigator视图中，选中你的Java项目，右键，可以看到“Find Bugs”菜单项，子菜单项里有“Find Bugs”和“Clear Bug Markers”两项内容，如下图所示：

　　

　　我们建立一个简单的测试文件Test.java 内容如下：

public class Test { private String[] name; public String[] getName() { return name; } public void setName(String[] name) { this.name = name; } } 

　　我们点中“Find Bugs”，运行时会出现如下进度框：

　　运行结束后可以在Problems中看到增加了如下的警告信息内容

　　FindBugs运行后的警告信息内容不仅在Problems视图中显示，而且将标记在源代码标记框中，在源代码编辑器中我们可以看到警告标识，如下图：

　　当光标指向你的警告信息的代码上面时，就会有相应的错误提示信息，与Eclipse本身的错误或警告信息提示类似。

　　选中Problems视图里出现的相应问题，就会在代码编辑器里切换到相应的代码上去，方便根据相应的提示信息进行代码的修改。

　　

　　在Problems视图里，选中相应的问题条目，右键，在弹出的菜单中，可以看到“Show Bug Details”，如下图所示：

　　

　　点中它，会切换到Bug Details视图上去，显示更加详细的提示信息。

　　当然，在代码编辑窗口中，点击带有警告提示信息的图标时，也会自动切换到Bud Details窗口去，查看详细的警告信息，如下图所示。

　　

　　根据这里详细的信息，你可以得到FindBugs为什么会对你的代码报警告信息，及相应的处理办法，根据它的提示，你可以快速方便地进行代码修改。

　　

　　根据提示，我们将代码修改成如下，再运行就不会报有警告信息了。

public class Test { private String[] name; public String[] getName() {     String[] temp = name; return temp; } public void setName(String[] name) {     String[] temp = name; this.name = temp; } } 

　　配置FindBugs

　　选择你的项目，右键 => Properties => FindBugs =>

　　

　　可以配置的信息包括如上图所示的四个选项的相关设置：

1. Run FindBugs Automatically开关
   
   当此项选中后，FindBugs将会在你修改Java类时自动运行，如你设置了Eclipse自动编译开关后，当你修改完Java文件保存，FindBugs就会运行，并将相应的信息显示出来。
   
   当此项没有选中，你只能每次在需要的时候自己去运行FindBugs来检查你的代码。
   
   
2. Minimum priority to report选择项
   
   这个选择项是让你选择哪个级别的信息进行显示，有Low、Medium、High三个选择项可以选择，很类似于Log4J的级别设置啦。 比如：
   
   你选择了High选择项，那么只有是High级别的提示信息才会被显示。
   
   你选择了Medium选择项，那么只有是Medium和High级别的提示信息才会被显示。
   
   你选择了Low选择项，那么所有级别的提示信息都会被显示。
   
   
3. Enable bug categories选择项
   
   在这里是一些显示Bug分类的选择：
   
   Correctness关于代码正确性相关方面的
   
   Performance关于代码性能相关方面的
   
   Internationalization关于代码国际化相关方面的
   
   Multithreaded correctness关于代码多线程正确性相关方面的
   
   Style关于代码样式相关方面的
   
   Malicious code vulnerability关于恶意破坏代码相关方面的
   
   比如：如果你把Style的检查框去掉不选择中它，那么与Style分类相关的警告信息就不会显示了。其它的类似。
   
   
4. Select bug patterns to check for选择项
   
   在这里你可以选择所要进行检查的相关的Bug Pattern条目
   
   可以从Bug codes、Detector name、Detector description中看到相应的是要检查哪些方面的内容，你可以根据需要选择或去掉相应的 检查条件。

　　总结

　　此插件的功能很不错，可以帮助我们提升Java代码的编写能力，写出更加安全可靠的代码。建议使用或加在Ant里进行持续构建。

　　现在，你可以马上拿出你已经开发的一个项目，检查一下你的代码有没有问题了

       http://www.jacorb.org/download.html
  download ant
       http://ant.apache.org/bindownload.cgi

2:extact JacORB_2_2.jar to d:\JacORB_2_2

3:setup sys environment

       set ANT_HOME=
       set JAVA_HOME=
       set JACORB_HOME=d:\JacORB_2_2
       set PATH=%PATH%;%ANT_HOME%\bin;%JAVA_HOME%\bin;%JACORB_HOME%\bin;
       set CLASSPAHT=.;%CLASSPAHT%;%ANT_HOME%\lib\ant.jar;%JACORB_HOME%\lib\jarorb.jar;%JACORB_HOME%\lib\idl.jar\;%JACORB_HOME%\lib\logkit-1.2.jar

4:rename %JACORB_HOME%\etc\jacorb_properties.template to %JACORB_HOME%\etc\jacorb.properties
  and modify the 50th line to 53th line to
 
       #ORBInitRef.NameService=file:/y:/nsiona.ref
      
ORBInitRef.NameService=file://d://test//NS_Ref
      
#ORBInitRef.NameService=http://www.x.y.z/~user/NS_Ref
      
#ORBInitRef.TradingService=http://www.x.y.z/~user/TraderRef
 
  modify 618th line to
       jacorb.naming.ior_filename=d://test//NS_Ref

5:rename  %JACORB_HOME%\jacotemplate.bat to %JACORB_HOME%\jaco.bat
 
  and modify related env variable
 
  rename   %JACORB_HOME%\idltemplate.bat to %JACORB_HOME%\idl.bat
  
  and modify related env variable

6:  use ant compile and build idl and java

     cd  %JACORB_HOME%\demo\grid  

     run ant
   
     the generate class file in %JACORB_HOME%\classes  and generated java file in %JACORB_HOME%\demo\grid

7: open a new cmd window:
          cd %JACORB_HOME%   ns
 
   you can see the following result:   
       [ configuration jacorb loaded from file %JAORB_HOME%\etc\jacorb.properties]

   open a new cmd window:
          cd %JACORB_HOME%   jaco demo.grid.Server
  you can see the following result:   
  [ configuration jacorb loaded from file %JAORB_HOME%\etc\jacorb.properties]
  
  open a new cmd window:
          cd %JACORB_HOME%   jaco demo.grid.client
    you can see the following result:   
 
  [ configuration jacorb loaded from file D:\work\nj\JACORB\etc\jacorb.properties]
   Height = 31
   Width = 14
   Old value at (30,13): 0.21
   Setting (30,13) to 470.11
   New value at (30,13): 470.11
   MyException, reason: This is only a test exception, no harm done :-)
   done.

destination：topic queque
  queue简单点说就是1:1 一个消息只能由一个consumer去消费，别的consumer来消费的时候已经没了，先到先得
topic简单点说就是1:N 一个消息可以由多个consumer来消费，谁来消费都有
 subscribe，拿topic来说如果当前订阅不是持久订阅，只有再订阅后生产者生产得消息才能被consumer得到，持久订阅只要没有被consumer消费，早晚会消费这个消息
 
 
 
 一下是几个例子
 
 queuesend：queque消息产生
 queuereceive：queque消息得消费
 topicsend ：topic消息得产生
 topicreceive1：topic消息的非订阅
 topicrecieve2：topic消息的持久订阅
 
 这个例子实在WEBLOGIC814上测试过的，当然要定义JMSSERVER,FACTORY,DESTINATION。
 
 
 
 QueueSend
 
 import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class QueueSend {
 // Defines the JNDI context factory.
 public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";

 // Defines the JNDI provider url.
 public final static String PROVIDER_URL = " t3://localhost:7001";

 // Defines the JMS connection factory for the queue.
 public final static String JMS_FACTORY = "SendJMSFactory";

 // Defines the queue.
 public final static String QUEUE = "SendJMSQueue";

 private QueueConnectionFactory qconFactory;

 private QueueConnection qcon;

 private QueueSession qsession;

 private QueueSender qsender;

 private Queue queue;

 private TextMessage msg;

 /**
  * Creates all the necessary objects for sending messages to a JMS queue.
  *
  * @param ctx
  *            JNDI initial context
  * @param queueName
  *            name of queue
  * @exception NamingException
  *                if operation cannot be performed
  * @exception JMSException
  *                if JMS fails to initialize due to internal error
  */
 public void init(Context ctx, String queueName) throws NamingException,
   JMSException {
  qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
  qcon = qconFactory.createQueueConnection();
  qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
  queue = (Queue) ctx.lookup(queueName);
  qsender = qsession.createSender(queue);
  msg = qsession.createTextMessage();
  qcon.start();
 }

 /**
  * Sends a message to a JMS queue.
  *
  * @param message
  *            message to be sent
  * @exception JMSException
  *                if JMS fails to send message due to internal error
  */
 public void send(String message) throws JMSException {
  msg.setText(message);
  qsender.send(msg);
 }

 /**
  * Closes JMS objects.
  *
  * @exception JMSException
  *                if JMS fails to close objects due to internal error
  */
 public void close() throws JMSException {
  qsender.close();
  qsession.close();
  qcon.close();
 }

 /**
  * main() method.
  *
  * @param args
  *            WebLogic Server URL
  * @exception Exception
  *                if operation fails
  */
 public static void main(String[] args) throws Exception {
  try {
   InitialContext ic = getInitialContext();
   QueueSend qs = new QueueSend();
   qs.init(ic, QUEUE);
   readAndSend(qs);
   qs.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private static void readAndSend(QueueSend qs) throws IOException,
   JMSException {
  BufferedReader msgStream = new BufferedReader(new InputStreamReader(
    System.in));
  String line = null;
  boolean quitNow = false;
  do {
   System.out.print("Enter message (\"quit\" to quit): ");
   line = msgStream.readLine();
   if (line != null && line.trim().length() != 0) {
    qs.send(line);
    System.out.println("JMS Message Sent: " + line + "\n");
    quitNow = line.equalsIgnoreCase("quit");
   }
  } while (!quitNow);

 }

 private static InitialContext getInitialContext() throws NamingException {
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
  env.put(Context.PROVIDER_URL, PROVIDER_URL);
  return new InitialContext(env);
 }

}

QueueReceive

import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class QueueReceive implements MessageListener {
 // Defines the JNDI context factory.
 public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";

 // Defines the JNDI provider url.
 public final static String PROVIDER_URL = " t3://localhost:7001";

 // Defines the JMS connection factory for the queue.
 public final static String JMS_FACTORY = "SendJMSFactory";

 // Defines the queue.
 public final static String QUEUE = "SendJMSQueue";

 private QueueConnectionFactory qconFactory;

 private QueueConnection qcon;

 private QueueSession qsession;

 private QueueReceiver qreceiver;

 private Queue queue;

 private boolean quit = false;

 /**
  * Message listener interface.
  *
  * @param msg
  *            message
  */
 public void onMessage(Message msg) {
  try {
   String msgText;
   if (msg instanceof TextMessage) {
    msgText = ((TextMessage) msg).getText();
   } else {
    msgText = msg.toString();
   }

   System.out.println("Message Received: " + msgText);

//   if (msgText.equalsIgnoreCase("123")) {
//    synchronized (this) {
//     quit = true;
//     this.notifyAll(); // Notify main thread to quit
//    }
//   }
  } catch (JMSException jmse) {
   jmse.printStackTrace();
  }
 }

 /**
  * Creates all the necessary objects for receiving messages from a JMS
  * queue.
  *
  * @param ctx
  *            JNDI initial context
  * @param queueName
  *            name of queue
  * @exception NamingException
  *                if operation cannot be performed
  * @exception JMSException
  *                if JMS fails to initialize due to internal error
  */
 public void init(Context ctx, String queueName) throws NamingException,
   JMSException {
  qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
  qcon = qconFactory.createQueueConnection();
  qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
  queue = (Queue) ctx.lookup(queueName);
  qreceiver = qsession.createReceiver(queue);
  qreceiver.setMessageListener(this);
  qcon.start();
 }

 /**
  * Closes JMS objects.
  *
  * @exception JMSException
  *                if JMS fails to close objects due to internal error
  */
 public void close() throws JMSException {
  qreceiver.close();
  qsession.close();
  qcon.close();
 }

 /**
  * main() method.
  *
  * @param args
  *            WebLogic Server URL
  * @exception Exception
  *                if execution fails
  */

 public static void main(String[] args) throws Exception {

  InitialContext ic = getInitialContext();
  QueueReceive qr = new QueueReceive();
  qr.init(ic, QUEUE);

  System.out
    .println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");

  // Wait until a "quit" message has been received.
  synchronized (qr) {
   System.out.println("111111111111");
   while (!qr.quit) {
    try {
     System.out.println("2222222222");
     qr.wait();
     System.out.println("333333333");
    } catch (InterruptedException ie) {
    }
   }
  }
  qr.close();
 }

 private static InitialContext getInitialContext() throws NamingException {
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
  env.put(Context.PROVIDER_URL, PROVIDER_URL);
  return new InitialContext(env);
 }

}

TopicSend

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.jms.TopicPublisher;
public class TopicSend {
 // Defines the JNDI context factory.
 public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";

 // Defines the JNDI provider url.
 public final static String PROVIDER_URL = " t3://localhost:7001";

 // Defines the JMS connection factory for the queue.
 public final static String JMS_FACTORY = "SendJMSFactory";

 // Defines the queue.
 public final static String TOPIC = "SendJMSTopic";

 private TopicConnectionFactory tconFactory;

 private TopicConnection tcon;

 private TopicSession tsession;

 private TopicPublisher tsender;

 private Topic topic;

 private TextMessage msg;
 public static InitialContext ic ;

 /**
  * Creates all the necessary objects for sending messages to a JMS queue.
  *
  * @param ctx
  *            JNDI initial context
  * @param queueName
  *            name of queue
  * @exception NamingException
  *                if operation cannot be performed
  * @exception JMSException
  *                if JMS fails to initialize due to internal error
  */
 public void init(Context ctx, String queueName) throws NamingException,
   JMSException {
  tconFactory = (TopicConnectionFactory) ctx.lookup(JMS_FACTORY);
  tcon = tconFactory.createTopicConnection();
  tsession = tcon.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  System.out.println(topic);
  topic = (Topic) ctx.lookup(queueName);
  System.out.println(topic);
  tsender = tsession.createPublisher(topic);
  msg = tsession.createTextMessage();
  tcon.start();
 }

 /**
  * Sends a message to a JMS queue.
  *
  * @param message
  *            message to be sent
  * @exception JMSException
  *                if JMS fails to send message due to internal error
  */
 public void send(String message) throws JMSException ,NamingException{
  System.out.println(topic+"-----------");
  msg.setText(message);
  tsender.publish(msg);
 }

 /**
  * Closes JMS objects.
  *
  * @exception JMSException
  *                if JMS fails to close objects due to internal error
  */
 public void close() throws JMSException {
  tsender.close();
  tsession.close();
  tcon.close();
 }

 /**
  * main() method.
  *
  * @param args
  *            WebLogic Server URL
  * @exception Exception
  *                if operation fails
  */
 public static void main(String[] args) throws Exception {
  try {
   ic= getInitialContext();
   TopicSend ts = new TopicSend();
   ts.init(ic, TOPIC);
   readAndSend(ts);
   ts.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private static void readAndSend(TopicSend ts) throws IOException,
   JMSException,NamingException {
  BufferedReader msgStream = new BufferedReader(new InputStreamReader(
    System.in));
  String line = null;
  boolean quitNow = false;
  do {
   System.out.print("Enter message (\"quit\" to quit): ");
   line = msgStream.readLine();
   if (line != null && line.trim().length() != 0) {
    ts.send(line);
   
    System.out.println("JMS Message Sent: " + line + "\n");
    quitNow = line.equalsIgnoreCase("quit");
   }
  } while (!quitNow);

 }

 private static InitialContext getInitialContext() throws NamingException {
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
  env.put(Context.PROVIDER_URL, PROVIDER_URL);
  return new InitialContext(env);
 }

}

TopicReceive1

import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class TopicReceive1 implements MessageListener {
 // Defines the JNDI context factory.
 public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";

 // Defines the JNDI provider url.
 public final static String PROVIDER_URL = " t3://localhost:7001";

 // Defines the JMS connection factory for the queue.
 public final static String JMS_FACTORY = "SendJMSFactory";

 // Defines the queue.
 public final static String TOPIC = "SendJMSTopic";

 private TopicConnectionFactory tconFactory;

 private TopicConnection tcon;

 private TopicSession tsession;

 private TopicSubscriber tsubscriber;

 private Topic topic;

 private boolean quit = false;

 /**
  * Message listener interface.
  *
  * @param msg
  *            message
  */
 public void onMessage(Message msg) {
  System.out.println("===================");
  try {
   String msgText;
   if (msg instanceof TextMessage) {
    msgText = ((TextMessage) msg).getText();
   } else {
    msgText = msg.toString();
   }

   System.out.println("Message Received: " + msgText);

//   if (msgText.equalsIgnoreCase("123")) {
//    synchronized (this) {
//     quit = true;
//     this.notifyAll(); // Notify main thread to quit
//    }
//   }
  } catch (JMSException jmse) {
   jmse.printStackTrace();
  }
 }

 /**
  * Creates all the necessary objects for receiving messages from a JMS
  * queue.
  *
  * @param ctx
  *            JNDI initial context
  * @param queueName
  *            name of queue
  * @exception NamingException
  *                if operation cannot be performed
  * @exception JMSException
  *                if JMS fails to initialize due to internal error
  */
 public void init(Context ctx, String queueName) throws NamingException,
   JMSException {
  tconFactory = (TopicConnectionFactory) ctx.lookup(JMS_FACTORY);
  tcon = tconFactory.createTopicConnection();
  tsession = tcon.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  topic = (Topic) ctx.lookup(queueName);
  tsubscriber = tsession.createSubscriber(topic);
  //System.out.println("12");
  //Message msg = treceiver.receive();
  //msg.acknowledge();
  //tsubscriber = tsession.createSubscriber(topic);Message msg = tsubscriber.receive();msg.acknowledge();
  //System.out.println(msg);
  tsubscriber.setMessageListener(this);
  tcon.start();
 }

 /**
  * Closes JMS objects.
  *
  * @exception JMSException
  *                if JMS fails to close objects due to internal error
  */
 public void close() throws JMSException {
  tsubscriber.close();
  tsession.close();
  tcon.close();
 }

 /**
  * main() method.
  *
  * @param args
  *            WebLogic Server URL
  * @exception Exception
  *                if execution fails
  */

 public static void main(String[] args) throws Exception {

  InitialContext ic = getInitialContext();
  TopicReceive1 tr1 = new TopicReceive1();
  tr1.init(ic, TOPIC);

  System.out
    .println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");
  
  

  // Wait until a "quit" message has been received.
//  synchronized (tr1) {
//   System.out.println("111111111111");
//   while (!tr1.quit) {
//    try {
//     System.out.println("2222222222");
//     tr1.wait();
//     System.out.println("333333333");
//    } catch (InterruptedException ie) {
//    }
//   }
//  }
  tr1.close();
 }

 private static InitialContext getInitialContext() throws NamingException {
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
  env.put(Context.PROVIDER_URL, PROVIDER_URL);
  return new InitialContext(env);
 }

}

TopicReceive2

import java.util.Hashtable;

import javax.jms.JMSException;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class TopicReceive2 {
 // Defines the JNDI context factory.
 public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";

 // Defines the JNDI provider url.
 public final static String PROVIDER_URL = " t3://localhost:7001";

 // Defines the JMS connection factory for the queue.
 public final static String JMS_FACTORY = "SendJMSFactory";

 // Defines the queue.
 public final static String TOPIC = "SendJMSTopic";

 private TopicConnectionFactory tconFactory;

 private TopicConnection tcon;

 private TopicSession tsession;

 private TopicSubscriber tsubscriber;

 private Topic topic;

 private boolean quit = false;

 /**
  * Creates all the necessary objects for receiving messages from a JMS
  * queue.
  *
  * @param ctx
  *            JNDI initial context
  * @param queueName
  *            name of queue
  * @exception NamingException
  *                if operation cannot be performed
  * @exception JMSException
  *                if JMS fails to initialize due to internal error
  */
 public void init(Context ctx, String queueName) throws NamingException,
   JMSException,InterruptedException {
  tconFactory = (TopicConnectionFactory) ctx.lookup(JMS_FACTORY);
  tcon = tconFactory.createTopicConnection();
  tcon.setClientID("IP10.200.7.104");
  tcon.start();
  
  tsession = tcon.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  System.out.println("333333333333");
  topic = (Topic) ctx.lookup(queueName);
  //tsubscriber = tsession.createSubscriber(topic);
  tsubscriber= tsession.createDurableSubscriber(topic,"88888");
   for (int i=0; i<3; i++) {
             //
             TextMessage message = (TextMessage) tsubscriber.receive();
             System.out.println("message["+i+"]: " + message.getText());
         }
          Thread.sleep(10000);
  //System.out.println("12");
  //Message msg = treceiver.receive();
  //msg.acknowledge();
  //tsubscriber = tsession.createSubscriber(topic);Message msg = tsubscriber.receive();msg.acknowledge();
  //System.out.println(msg);

 }

 /**
  * Closes JMS objects.
  *
  * @exception JMSException
  *                if JMS fails to close objects due to internal error
  */
 public void close() throws JMSException {
  tsubscriber.close();
  tsession.close();
  tcon.close();
 }

 /**
  * main() method.
  *
  * @param args
  *            WebLogic Server URL
  * @exception Exception
  *                if execution fails
  */

 public static void main(String[] args) throws Exception {

  InitialContext ic = getInitialContext();
  TopicReceive2 tr2 = new TopicReceive2();
  tr2.init(ic, TOPIC);

  System.out
    .println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");
  
  

  // Wait until a "quit" message has been received.
//  synchronized (tr1) {
//   System.out.println("111111111111");
//   while (!tr1.quit) {
//    try {
//     System.out.println("2222222222");
//     tr1.wait();
//     System.out.println("333333333");
//    } catch (InterruptedException ie) {
//    }
//   }
//  }
  tr2.close();
 }

 private static InitialContext getInitialContext() throws NamingException {
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
  env.put(Context.PROVIDER_URL, PROVIDER_URL);
  return new InitialContext(env);
 }

}

做为新一代 3G 及移动终端浪潮的设备管理平台， OMA DM 技术获得了众多设备厂商和运营商的追捧，也为软件开发商提供新的崛起机会。业内目前也有不少工作在做这方面的软件。好多公司这方面的产品都是基于Sync4J开发的。

Sync4J 开源项目为我们提供了完整的 OMA DM 1.1.2 规范的 Java 实现。本文记录了 Sync4J DM Server 安装以及使用SCTS模拟器来模拟手机做一个DM业务，本文没有用PPG来通过短信方式来用真手机来做，只是用模拟器来做的。SCTS是OMA官方提供的一个测试工具，主要用来测试DMserver的，这里我们用来测试Sync4J。Sync4J和SCTS的集合是我们学习OMA的一个很好的方式。

1 ：用到以下工具。

  Oracle9i

  jboss-3.2.3

  sync4j-server-dm-1.4.9   sync4j 官方有下载

  SCTS_DeviceManagement_v1.12.zip  OMA 官方网站有下载。

2 ：安装调试

  2.1 解压文件：

   jboss-3.2.3 解压到 C:\jboss-3.2.3

把 sync4j-server-dm-1.4.9 解压到 D:\sync4j\all\server-dm .

直接安装 SCTS.

  2.2 配置环境变量

  JAVA_HOME=

  J2EE_HOME= C:\jboss-3.2.3

  SYNCSERVER_HOME= D:\sync4j\all\server-dm

2.3 修改SYNCSERVER_HOME下的几个配置文件

   SYNCSERVER_HOME\ default\config\common\properties\ Sync4j.properties

把第一行改为 server.uri=http://your IP:8080/sync4j-dm/dm

  SYNCSERVER_HOME\ install.properties 改为

(1)server-name=http://10.150.4.7:8080/sync4j-dm/dm

 (2) 用 oracle 的数据库，以下是用来连接数据库的，所以一定要配置正确。

jdbc.classpath=C:\\jboss-3.2.3\\server\\all\\lib\\ojdbc14.jar

jdbc.driver=oracle.jdbc.driver.OracleDriver

jdbc.url=jdbc:oracle:thin:@11.11.11.11:1521:abc

jdbc.user=sync4j

jdbc.password=sync4j

2 ．4以上都做完后用Sync4j自己带的安装脚本安装sync4j dm server

在 SYNCSERVER_HOME 下运行 bin\install.cmd jboss32

2 ．5由于这个版本存在了一个bug,所以在2.4做完后要修改

SYNCSERVER_HOME\bin\start.cmd

把倒数第三行 call\run.bat -c sync4j 改为

call %J2EE_HOME%\bin\run.bat -c sync4j

2 ．6 在SYNCSERVER_HOME 运行 bin\start.cmd安装

所有程序到安装到了 jboss_home 下了，可以到 JBOSS_HOME\ server\sync4j 就可以看到了，看一下你的 oralce 库里面也初始化了数据，表也建好了。

2 ．7 添加一个手机（我们其实是个模拟器）上来

http://your ip:8080/dmdemo/jsp/addDevice.jsp 填写一个 IMEI:111111111111111,

2 ．8 配置scts

Add device : IMEI:111111111111111 然后点 apply

点击 DM Account

Name ： sync4j

Server:sync4j

Con : 不用填写

Address ： http://your ip /sync4j-dm/dm

Port :8080

Server authentication:

  Digest : 找数据库用 sync4j 的数据库中， sycn4j_device 表中 :IMEI:111111111111111 ， server 的 password 为： srvpwd, 把这个 password 填写到 password 中。

Client authentication

   DIGEST: USER NAME: sync4j PASSWORD: sync4j

Add 就可以了

然后点 connect 连一下 DM SERVER 看看能否连上。 第一次一般会出现认证错我，接着再联一次就可以了， SCTS 有日志可以查看。

如果连通了那下面就来做一个采集模拟器上的一个节点吧。

http://your ip:8080/dmdemo/index.html

用 device id ： IMEI:111111111111111 login

  然后点击 add to operation list

然后用 SCTS 主动回联一下，看看 server 能够拿到这个节点的值

你会看到 6 个 message ！！！

详细看一下这 6 个 message 你会发现，这个节点的采集已经成功了！

2: 安装完全采用默认就可以了，安装完可以不重启

3 ：开始菜单 ->CVSNT-> Control Panel . 停止 CVS NT

4 ：进入 repository configuration 点击 add 添加一个如图所示：

   Localtion  填写一个 D:/CVSRoot

   Name     填写 /cvs

5 ：进入 server settting

  Run as 选择一个 windows 下已有用户比如 (administrator) ，其余不用修改，应用就可以了。

6 ：进入 about :CVSNT 启动 . CVS 已经配置完毕，至于安全什么方面的东西我没有弄过。

7: 打开 eclilpse ,file->new->other ,CVS

输入 Host 、 repository path 、用户名、密码 ，其余默认，然后 next

Next

Next

Next

一切搞定，你可以建立一个目录然后 就可以commit 了 .

1 ： agent,tnslistener 都启动起来， OracleServiceTESTDB 实例也在服务里面启动起来了

2 ： oem 档案库也建立好了，就建立在 OracleServiceTESTDB 数据库上

3 ：万事具备了，启动 OracleOraHome92ManagementServer, 报异常出来

服务器后又停止了，一些服务自动停止，如果他们没什么可做得，例如性能日志和警报服务

郁闷啊

  接下来我做了一下事情

 1 ：重新建立了档案库，然后启动 OracleOraHome92ManagementServer 仍然没有成功

 2 ： ,TNSLISTNER ， OracleOraHome92ManagementServer ， OracleServiceTESTDB ， AGENT 都设置成自动启动，重新启动了机器吧,仍然没有成功

3 ：重新安装了 ORACLE 然后重新做了以上事情，仍然没有成功

根据网上得资料和自己得实践发现一下问题

1 ：
我自己得机器是路由器给得 IP ，不是自己机器设定得固定 IP ，在 XP 下面搜索了 C:

Hosts 文件，路径 C:\WINDOWS\system32\drivers\etc\hosts

127.0.0.1       localhost

10.200.7.71     USER-3286972EF7

把分配给自己得 IP ，和自己得主机名对应一下，就是说加上第二行，然后重新启动机器，

OMS 就启动起来了，
2:
我搜索了注册表里面 OracleOraHome92ManagementServer 得

HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\OracleOraHome92ManagementServer   DependOnService 数值数据对应到 OracleServiceTESTDB, 要是不对应一定要修改注册表让他对应起来，就是说一定要又依赖关系！！！！否则成功不了

总之 2 条：

  1 ：动态 IP 一定要对应主机名

  2 ：注册表里面得依赖关系一定要依赖当前档案库所在得服务上就是 OracleServiceTESTDB 上面！！！！

  } else {
   throw new Exception("The format of phoneNum "+phoneNum+"  is not correct!Please correct it");
  }

 }

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Service extends Remote {

 public String getName() throws RemoteException;

 public void setName(String name) throws RemoteException;

}
ServiceImpl.java Service的实现
package net.loocky.rmi;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class ServiceImpl extends UnicastRemoteObject implements Service {
 private static final long serialVersionUID = 1L;

 private String name;

 public ServiceImpl(String name) throws RemoteException {
  this.name = name;
 }

 public String getName() throws RemoteException {
  return name;
 }

 public void setName(String name) throws RemoteException {
  this.name = name;

 }

}

ServiceServer
package net.loocky.rmi;

import java.rmi.Naming;

public class ServiceServer {

 /**
  * @param args
  */
 public static void main(String[] args) {
  try {

   ServiceImpl s1 = new ServiceImpl("my name is john");
   ServiceImpl s2 = new ServiceImpl("my name is loocky");
   Naming.rebind("john", s1);
   Naming.rebind("loocky", s2);
   System.out.println("waiting for clients...");
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

}
ServiceClient
package net.loocky.rmi;

import java.rmi.Naming;
import java.rmi.RMISecurityManager;

public class ServiceClient {

 /**
  * @param args
  */
 public static void main(String[] args) {
  System.setSecurityManager(new RMISecurityManager());
  String url = "rmi://127.0.0.1:1099/";
  try {
   Service s1 = (Service) Naming.lookup(url + "john");
   Service s2 = (Service) Naming.lookup(url + "loocky");
   System.out.println(s1.getName());
   s2.setName("my name is not loocky");
   System.out.println(s2.getName());

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

}
client.policy
grant
{
  permission java.security.AllPermission;
//　permission java.net.SocketPermission　"127.0.0.1:1099","connect";
//　permission java.net.SocketPermission　"127.0.0.1:80","connect";
};

有了这些文件下面要做的事情是

1:进入bin/  rmic net.loocky.rmi.ServiceImpl 生成STUB
2：dos下面 rmiregistry
3：java net.loocky.rmi.ServiceServer
4: java -Djava.security.policy=client.policy net.loocky.rmi.ServiceClient
5:查看控制台的结果吧！

 <bean id="timer" class="org.springframework.scheduling.timer.TimerFactoryBean">
  <property name="scheduledTimerTasks">
   <list>
    <ref local="testtimertask"/>
   </list>
  </property>
 </bean>

 <bean id="timerbean" class="MyTimerImpl">

 </bean>
 <bean id="testtimertask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
  <property name="timerTask">
   <ref bean="timerbean" />
  </property>

  <property name="delay">
   <value>1000</value>
  </property>

  <property name="period">
   <value>1000</value>
  </property>

 </bean>

</beans>

MyTimerImpl

import java.util.TimerTask;

public class MyTimerImpl  extends TimerTask {

 public void run() {
  System.out.println("aaaaaaaa");
  
 }
TestTimer

import net.loocky.sowq.util.ServiceFactory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestTimer {

 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  
    ApplicationContext ctx=new FileSystemXmlApplicationContext("E:\\work\\Test\\bin\\spring-config.xml");
  Thread.sleep(100000);
 }

}

}

    }
   }
   sortedNum++;
  }
 }

}
选择排序
public class SelectSort {
 public static void sort(int[] data, int n) {
  int sortedNum = 0;
  int index;
  int maxIndex = 0;
  while (sortedNum < n) {
   for (index = 1; index < n - sortedNum - 1; index++) {
    if (data[maxIndex] < data[index]) {
     maxIndex = index;
    }
   }
   int tmp;
   tmp = data[maxIndex];
   data[maxIndex] = data[n - sortedNum - 1];
   data[n - sortedNum - 1] = tmp;
   sortedNum++;

  }

 }

}

插入排序
public class InsertSort {
 public static void sort(int[] data, int n) {
  int sortedNum = 1;
  int index;
  while (sortedNum < n) {
   int tmp = data[sortedNum];
   for (index = sortedNum; index > 0; index--) {
    if (tmp < data[index - 1]) {
     data[index] = data[index - 1];
    } else {
     break;
    }
   }
   //插入的他的位置
   //index就是找TMP的位置
   data[index] = tmp;
   sortedNum++;
   
   for(int i=0;i<n;i++){
    System.out.print(data[i]+",");
   }
   System.out.println("");
  }

 }

}

快速排序
public class QuickSort {

 public static void sort(int[] data, int n) {
  quickSortRescursive(data, 0, n - 1);
 }

 private static void quickSortRescursive(int[] data, int left, int right) {

  int pos;
  if (left >= right)
   return;
  pos = getPos(data, left, right);
  // 排左边的
  quickSortRescursive(data, left, pos - 1);
  quickSortRescursive(data, pos + 1, right);
 }

 private static int getPos(int[] data, int left, int right) {
  // 想左边移动
  while (true) {
   //遇到右边的大就忽略，并且缩小右边范围
   while (left < right && data[left] < data[right])
    right--;
   
   //遇到左边的大就往右边换
   if (left < right)
    swap(data, left++, right);
   else
    return left;
//   遇到右边的大就忽略，并且左边缩小范围
   while (left < right && data[left] < data[right])
    left++;
   if (left < right)
    //遇到左边的大就往右边换
    swap(data, left, right--);
   // return left;

   else
    return right;
   // return 0;
  }

 }

 private static void swap(int[] data, int i, int j) {
  int tmp = data[i];
  data[i] = data[j];
  data[j] = tmp;

 }

}

  SyncML dm 协议包括 2 个阶段 初始化阶段（认证和终端信息交换的阶段）和管理阶段，管理阶段服务器希望进行重复多次进行管理。 Manage 周期的开始以 package0 开始，本次出发依赖于不可更改的环境，在 SyncML Notifaction 开始的周期里面被指定

下图是描绘了 2 个阶段

 Management 阶段包括了几个协议的交互，从 server 发送到 client 的包的内容决定了这个周期是否进行下去，如果从 server 发送出来的包的管理指令需要得到 client 的回复， client 将会返回针对这些操作指令的回复。这些回复的包开始了新的协议的交互，服务器将发送一个新的管理指令的包并且开始一个新的协议交互的的过程。

     当 server 的 package 里面不包含 management operation 的时候， client 将根据服务器发送过来的包回复一个新的包，这个包里面只包含了 status 和 Synchr ，在这种情况下，真个回复的包不能被发送，协议中止。 Server 必须给任何 client 的包进行回复

     包的处理可能花费的时间是不可预知的，因此在 SyncML dm 协议中没有指定 2 者的超时时间。

     如果不是 operation command 另有规定，终端和 server 可以不按照 package 中的顺序执行指令。因此，在上一条管理指令在执行的顺序是必须的，管理指令必须按照他们发送的顺序进行执行。 Client 不能发送除了包含 Devinfo 的 REPLACE command 、 Result alert 给 server

8 ． 1 session abort

8 ． 1 ． 1 描述

      是 server 还是 client 任何时候都可以中止操作。终端操作的原因可能是 server 关闭， client 没电，或者用户在 client 上的其他交互操作，或者其他操作。这种情况下，最好的方式是发送一个中止的 ALERT 。推荐的做法是： message 包含了管理指令的任何 stauts 和 result

如果发送一个 session 终端给接受方的 MESSAGE ，那么接收方的回应会忽略，（不会回应把，自己也不理解，有待更正）

有些终端是无法控制的， client 不在覆盖范围内或者电池没有电。 Server 和 client 必须也对没有信号的情况做好准备。上面提到的需求只要是为了减少一些回应超时，或者没有回应的情况。

补充说明： request/response 在传输用的角色被倒置的情况， client 是个传输层的 server ， server 是个传输层的 client ，这种情况下 8.1.1 以上的推荐可能不会用到

8.1.2 需求

Alert 1223 是无法预知的操作中止的信号标识，发送方的 session 中断标识包含了 command 的状态和结果，这些指令将在 abort 之前执行，发送方必须包含一个 FINAL 的标识。当 server 收到 alert 提示的时候，必须在回复的 message 中包含状态和 SyncHR ，并且不回复新的 MESSAGE

8.2 package 0 ， server 发起的初始化 指令

  许多终端不能持续的侦听服务器的连接，由于安全原因一些终端只是不想开方一些端口。大部分终端可以接受一些主动提供的 MESSAGE, 称作通知 (notifaction).

  Server可以用通知的这种能力使终端初始化一个连接回server， SyncML dm 协议规定了几种管理初始化通知的发送方式。发送者和通知的内容可以参考Notification Initiated Session, Version 1.1.2

      需要说明的是：接收一个管理初始化的通知会受其他方面影响。如终端设备可能会允许用户操作设备去初始化管理周期，另外，终端用户也可以管理超时的管理周期，一些错误得操作也会使终端发起一个管理周期。

8 ．3 package1 ：客户端发起初始化指令

   管理阶段跟SyncML dm 数据协议得描述完全相同，客户端发起包的意图如下：

1 ：发送终端信息(厂商，版本，其他)给DM server，终端必须在第一个message中管理周期中发送设备信息

2 ：根据SELECTION 9中的规则终端向DM server确认身份

3 ：通知dmserver本次SESSION由客户端发起还是由Dmserver 发起（package0往往不会用到，如果是客户端发起的话）。

  客户端发起得初始化package得具体需求如下：

  1 ：在SyncHdr 元素里面得需求

VerDTD 的值必须是1.1

VerProto 的值必须是“DM/1.1”

Sessionid 必须能标明但前Management session 的身份，如果client 回复通知，那么Alert（1200）标识由server发起的，sessionid必须跟notifaction里面的sessionid相同，否则client产生的sessionid不会唯一，sessionid会贯穿整个session

MsgID 必须明确的指出message属于哪个management session

Target 元素必须指明是个那个目标server

Source 元素指明的是哪个client 的service

Cred element 可能包含再认证的message里面，一般是从client发起，section9将会详细描述

  2 ：Syncbody中必须包含alert信息无论client发起还是server发起

Alert command 的需求如下

  CmdId 是必须的

  存放management session type 的Data element或者由server发起（1200）或者由client发起（1201）

  3 ：终端的信息必须在syncbody中包含Relpace command，replace command需求如下

  Cmdid 是必须的

  Dm tree 每个节点的item都可以被找到，在DMSTDOBJ中有详细描述

  Source element 必须包含一个指定的URI 节点

  Data element 用来装载device 信息数据

Final element 必须包含在Syncbody 的最后一个message 中

Dm 协议允许管理指令在节点上执行，跟 SyncML 同步协议和 SyncML 表示协议类似都采用的是包的形式。设备的一个节点表示为一组可配置参数，可以这个节点进行读和设定参数的键、值操作，而终端的应用软件另外一个节点可能是的正在可运行环境中（意思是不会影响到别的节点的功能），对这类型的节点操作可以对软件的一部分功能进行下载、升级或者卸载 .

SyncML DM 这些指令代表这些操作，在 SymcML 表现协议和 SyncML 表现协议 DM 的用户手册中有描述。这些指令和消息的结构等同于 SyncML 数据同步协议，并且管理协议的 DTM 就是来源于 SyncML 数据同步协议的 DTD

5 ：节点处理

每一个节点的路径就是设备的唯一统一资源标识，这些标识必须遵循这样一些指定的需求： SyncML DM 树和描述加以限制和指定

每一个节点都有一个可以决定什么样的管理内容可以用来设置或者读的类型，在节点上操作需要实现定义这个类型的值，当节点被读的时候，这个类型的值将被返回。

举例说明，有的节点只是一个简单文本类型，需要设置，而有的节点是 WAP Provisioning document MIME 的复杂类型，甚至其他节点可能象 WAP 设置或者软件安装这样更复杂的值

SyncML DM 协议的指令的 target 和 souce 由 目标和来源 元素分别指定 target 是接纳着， source 是来源，这些过程出现的异常都会在管理命令需求中的异常中会被提及

6 ：包中的多消息

6 ． 1 描述

  DM 管理协议中中提供用多个 MESSAGE 来传输一个包的功能，当一个包非常大的时候，分成多个 MESSAGE 进行传输是非常有必要的，这样的局限是可能由传输协议或者终端的功能限制决定，（分成多个 MESSAGE 就可以解决这个问题）。

  DM 管理协议中，包作为一个逻辑组的作用是非常有限的，大部分的限制在 MESSAGE 上，而不是在 PACKAGE 上，举例：一个 COMMAND 必须完全适从一个 MESSAGE 。

为了避免大量客户端而有限的资源，服务器等待从客户端的包的 command 返回一个状态，

如果上一个 COMMAND 没有返回一个状态服务器不允许发送一个新的 COMMAND ，换句话来说，大部分 server 发送到客户端的 COMMAND 都会收到 CMMAND （ package ）的返回信息，除非 SERVER 发送一个大的对象或者请求更多的 MESSAGE （用 1222 ALERT ）

一个 PACKAGE 包含大对象数据将会被分成很多 MESSAGE 传输，在第七部分会详细描述

  说明 server 在处于一下一种包的边界的状态的时候：

   1 ： server 有一个完全大的包，在这种状况下， server 等待从 client 的 COMMAND 返回状态，由于状态和结果非常大（如 GET COMMAND 的结果）， client 将发送多个 MESSAGE 回 server ，然后结束他的回应

   2 ： server 从 client 接受到一个完整的包， server 将会发送一个新的 COMMAND 给 client

   3 ： server 发送了包中的一个或多个指令，但是没有发送包中的最后一个指令的时候，只有当 package 中的最后一个指令被发送出去的时候，这次状态才被认为是有效的

由于 SyncML 的传输形式是 request/response    的形式，无论是客户端还是服务器端在传输消息的时候都不应该包含一个开始命令或者一个结束的标志，以便保证 response/request 循环进行下去（言外之意就是有个这个标志就是开始和结束的时候） .

举例：当 server 在 STATE1, 他可能收到客户端的很多 MESSAGE, 这些 MESSAGE 包含了 status 和 result 。 Server 会对任何一个 message 回应，除了对 NEW COMMAND 进行回应外。

Server 对发送的回应在 SyncHdr 中包含了一个 1222 ALERT ， client 也指定了，（表示没有结束还有消息）。 STAUTS 必须对 ALERT 的回应进行发送而不是对 RESULT 的回应进行发送

ALERT1222 可以被 ALERT 1223 替换，因为服务器可以主动结束一个过程

下图展示了多个 message 被发送

6 ． 2 需求

  如果 SyncML package 分成多个 MESSAGE 被传送，最后一个 MESSAGE 必须包含一个 FINAL 的标志，其他么 message 一定不能包含 final 标志。 Final element 由 server 发送而不是由 client 发送，最终停止本次的 PACKAGE 操作。

   Server 在每个 MESSAGE 必须发送 FINAL message ，不过在发送大的对象的时候或者发送 NEXT MESSAGE 的相应的时候不会发送

7 ：大对象的处理

  SyncML dm 协议中，大对象不能完全在一个 Message 中传输，根据 SyncML data 同步协议指定的大对象处理方案可以分成多个 Message 。规则如下：

第一个限制就是支持大对象处理的终端必须显示的之处 DevDetail/LrgObj 的标识为 true

第二个限制是在 server 和 client 传输的 MaxObjSize 有多大，在 SyncML data 同步协议中 MaxObjSize 会在 Meta information 中指定。 DM 协议中被发送着接受的最大对象的大小（ MaxObjSize ）包含在 syncHdr 中（ message 的 META INFO ） ,syncHdr 中指定的 MaxObjSize ，发送者发送的单个对象都不能超过这个大小，如果 MaxObjSize 没有被发送，接收者可以自由发送任何大小的 message 给 server 。

需要指出的是： MaxObjSize 会影响整个 DM session ，如果在随后的 message 中没有对这个值进行重新设置。新的 MaxObjSize 在后来的 message 指定一个可能的原因是 client 的 free memory 大小的依赖，（有东西创建在 MEMORY 的时候或者删除的时候 FREE MOMORY 会发生变化）。

第三个限制：在上一个单元结束前终端会检测新的对象（ messge ），终端会回复一个 1225 的 alert