少年阿宾

那些青春的岁月
  BlogJava :: 首页 :: 联系 :: 聚合  :: 管理
  500 Posts :: 0 Stories :: 135 Comments :: 0 Trackbacks

#

js动态创建，删除表格

生成一个2000*5的表格，每个单元格的内容是行号+逗号+列号

方法一：使用createElement生成表格，使用insertRow和insertCell方法生成行列，单元格的内容使用innerHTML属性进行填充。

方法二：使用createElement生成表格，使用CreateElement方法生成行列，单元格的内容使用了createTextNode方法填充。

方法三：拼接表格innerHTML属性的字符串，使用字符串 += 操作符链接字符串

方法四：拼接表格innerHTML属性的字符串，各个字符串追加数组里面，最后调用数组的join方法生成目标字符串。

运行时间比较:

方法 运行时间(ms)
方法一 93037
方法二 3341
方法三 2795
方法四 500

具体的程序如下：


<html>
  <head>
   <title>test page</title>
   <script type='text/javascript'>
     <!--
   function createTable() {
       var t = document.createElement('table');
       for (var i = 0; i < 2000; i++) {
        var r = t.insertRow();
        for (var j = 0; j < 5; j++) {
         var c = r.insertCell();
         c.innerHTML = i + ',' + j;
        }
       }
      
       document.getElementById('table1').appendChild(t);
      t.setAttribute('border', '1');
   }
   
   function createTable2() {
       var t = document.createElement('table');
       var b = document.createElement('tbody');
       for (var i = 0; i < 2000; i++) {
        var r = document.createElement('tr');
        for (var j = 0; j < 5; j++) {
         var c = document.createElement('td');
         var m = document.createTextNode(i + ',' + j);
         c.appendChild(m);
         r.appendChild(c);
        }
        b.appendChild(r);
       }
      
       t.appendChild(b);
       document.getElementById('table1').appendChild(t);
      t.setAttribute('border', '1');
   }
   
   function createTable3() {
    var data = '';
    
    data += '<table border=1><tbody>';
       for (var i = 0; i < 2000; i++) {
        data += '<tr>';
        for (var j = 0; j < 5; j++) {
         data += '<td>' + i + ',' + j + '</td>';
        }
        data += '</tr>';
       }
       data += '</tbody><table>';
      
       document.getElementById('table1').innerHTML = data;
   }

   function createTable4() {
    var data = new Array();
    
    data.push('<table border=1><tbody>');
       for (var i = 0; i < 2000; i++) {
        data.push('<tr>');
        for (var j = 0; j < 5; j++) {
         data.push('<td>' + i + ',' + j + '</td>');
        }
        data.push('</tr>');
       }
       data.push('</tbody><table>');
      
       document.getElementById('table1').innerHTML = data.join('');
   }

   function showFunctionRunTime(f) {
    var t1 = new Date();
    f();
    var t2 = new Date();
    alert(t2 - t1);
   }
     //-->
   </script>
  </head>
 <body>
  <div id="table1" style="border: 1px solid black">
  </div>

  <script>
   showFunctionRunTime(createTable);
   showFunctionRunTime(createTable2);
   showFunctionRunTime(createTable3);
   showFunctionRunTime(createTable4);
  </script>
 </body>
</html>

原文出处：http://abaper.blogbus.com/logs/8278500.html
、


动态删除表格  

  方法1： 
  <table   id=mxh   border=1>  
  <tr>  
  <td>第1行</td><td   onclick="deleteRow('mxh',this.parentElement.rowIndex)">删除本行</td>  
  </tr>  
  <tr>  
  <td>第2行</td><td   onclick="deleteRow('mxh',this.parentElement.rowIndex)">删除本行</td>  
  </tr>

  </table> 

<script>  
  function   deleteRow   (tableID,   rowIndex)   {  
      var   table   =document.all[tableID]  
      table.deleteRow(rowIndex);  
  }    
  </script>

方法2：

<table   id=mxh   border=1>  
  <tr>  
  <td>第1行</td><td   onclick="deleteRow(this.parentElement)">删除本行</td>  
  </tr>  
  <tr>  
  <td>第2行</td><td   onclick="deleteRow(this.parentElement)">删除本行</td>  
  </tr>

  </table> 

<script>  
  function   deleteRow   (obj)   {   

      obj.parentElement.removeChild(obj);  
  }    
  </script>

posted @ 2012-08-28 21:20 abin 阅读(1313) | 评论 (0) | 编辑 收藏

Apache ActiveMQ or Spring 使用方法

Apache ActiveMQ简介： MQ是Apache出品的一个基于JMS消息处理机制的服务，可以很容易的潜入到Spring中，作为项目消息处理服务。

Apache ActiveMQ用途： jms有两种消息机制一种是消息队列，一种是消息订阅，简单来说就是一对一，和一对多。

一对一可以看做 一组消息对应一个 或 多个消息获取服务，其中每一个单独的消息体都只会被一个消息获取服务获取。

一对多可以看做 一组消息对应一个 或 多个接收服务，其中每一个单独的消息体发出之后都会被所有的接收服务收到一次。

根据以上两种模式我们可以在 发送短信的时候使用 消息队列模式。也可以在分布式的时候使用消息队列模式

消息订阅模式用的不是很多但是，在分布式中也可以应用同时可以结合WebService进行使用。例如一个新闻需要发给多个系统内的单独服务。

只要深刻理解了他的处理机制在很多情况下都可以应用，如果实在不喜欢这种方式也可以遵照java JMS的API用线程自己模拟消息队列机制。

我个人认为区别不是很大。更何况很多时候MQ的很多功能我们有没有用到，用这么个大家伙就是为了图省事。

这里备注一下：按原有设定在创建连接的时候MQ是不发送消息的。

下面我说以下使用方式：

本人目前只会JAVA

需要的包为

        activemq-all-5.2.0.jar
        log4j-1.2.14.jar
        spring-beans-2.5.5.jar
        spring-context-2.5.5.jar
        spring-jms-2.5.5.jar

         spring-core-2.5.5.jar

这些应该就足够了

我做测试的时候用的包为

        activemq-all-5.2.0.jar
        commons-pool-1.4.jar
        log4j-1.2.14.jar
        spring-beans-2.5.5.jar
        spring-context-2.5.5.jar
        spring-core-2.5.5.jar
        spring-jms-2.5.5.jar
        spring-tx-2.5.5.jar
        spring-web-2.5.5.jar
        spring-webmvc-2.5.5.jar
        xbean-spring-3.4.jar
        msbase.jar
        mssqlserver.jar
        msutil.jar
        mysql-connector-java-5.0.4-bin.jar
        mysql.jar

 

基本配置

下载 Apache ActiveMQ 不知道的googlean

安装服务的文件在

apache-activemq-5.5.0\bin\win32 目录下面Linux版也一样大同小异 运行.sh文件就好，如果出现问题请打开运行文件查看里面参数

activemq.bat直接运行启动服务

InstallService.bat安装成windos服务

UninstallService.bat卸载windos服务

安装成功后

在运行中 cmd

netstat -an|find “61616” 查询端口是否已经打开 

D:\apache-activemq-5.5.0\conf\activemq.xml 本文件为服务配置文件

     <transportConnectors>
            <transportConnector name="openwire" uri="tcp://0.0.0.0:61618"/>
        </transportConnectors>

这一项为端口设置

默认为 “61616”

目前以windos为例

把spring和项目联系起来

第一步为web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<!-- 配置Spring-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/classes/NewFileMQ.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>


  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
    
</web-app>

先说 一下消息队列（也就是一对一）

NewFileMQ.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:amq="http://activemq.apache.org/schema/core"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  http://activemq.apache.org/schema/core 
  http://activemq.apache.org/schema/core/activemq-core.xsd">

  <!-- 配置JMS链接模版 -->  
            <bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">  
                    <property name="brokerURL" value="tcp://localhost:61618"/>  
            </bean>  
      
            <!-- 配置JMS模版 -->  
            <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
                    <property name="connectionFactory" ref="connectionFactory"/>  
        <property name="pubSubDomain" value="false" />  
        <property name="explicitQosEnabled" value="true" /> <!-- deliveryMode, priority, timeToLive 的开关，要生效，必须配置为true，默认false-->  
        <property name="deliveryMode" value="1" /> <!-- 发送模式  DeliveryMode.NON_PERSISTENT=1:非持久 ; DeliveryMode.PERSISTENT=2:持久-->  
                    
            </bean>  
      

            <!-- 发送消息的目的地（一个队列） -->
            <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
                    <!-- 设置消息队列的名字 -->
                    <constructor-arg index="0" value="HelloJmsQueue"/>  
            </bean>    

    <bean id="sender" class="message.Sender">
        <property name="jmsTemplate" ref="jmsTemplate"></property>
    </bean>
<!--消息获取类-->
    <bean id="receive" class="message.Receiver"></bean>
    <!--给消息获取类加个监听让他能自动获取消息-->
    <bean id="listenerContainer"
        class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"></property>
        <property name="destination" ref="destination"></property>
        <property name="messageListener" ref="receive"></property>
    </bean>
</beans>

发送消息的类

package message;

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;


public class Sender {

    private JmsTemplate jmsTemplate;

    public void setJmsTemplate(JmsTemplate jmsTemplate) {
        this.jmsTemplate = jmsTemplate;
    }
    
    public void send(final String text){
        System.out.println("---Send:"+text);
        jmsTemplate.send(new MessageCreator(){

            public Message createMessage(Session arg0) throws JMSException {
                // TODO Auto-generated method stub
                return arg0.createTextMessage(text);
            }
            
        });
    }
    
    public static void main(String[] args) {  
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");  
        JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");  
        Destination destination = (Destination) ctx.getBean("destination");  
for(int i=0;i<10;i++){
    final String dd = i+"";
//jmsTemplate.convertAndSend(destination,"发送消息： ActiveMQ Text Message！"+dd);
        template.send(destination, new MessageCreator() {  
                public Message createMessage(Session session) throws JMSException {  
                        return session.createTextMessage("发送消息： ActiveMQ Text Message！"+dd);  
                }  
        });  
}
        System.out.println("成功发送了一条JMS消息");  
}  
}
接收消息类

package message;

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

import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.springframework.context.ApplicationContext;
import org.springframework.jms.core.JmsTemplate;


public class Receiver implements MessageListener {
//接听接收
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            TextMessage text = (TextMessage) message;

            try {
                System.out.println("Receive:第四个接收者" + text.getText());
            } catch (JMSException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }
    //手动接收
       public static void main(String[] args) throws JMSException {  
           ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");  
           JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");  
           Destination destination = (Destination) ctx.getBean("destination");  
           while (true) {  
                   TextMessage txtmsg = (TextMessage) template.receive(destination);  
                   if (null != txtmsg)  
                           System.out.println("收到消息内容为: " + txtmsg.getText());  
                   else  
                           break;  
           }  
   }  
}

发布者模式

其实两种模式其它设置基本相同

唯一不用的就是 Spring配置文件中把一下这段替换一下就可以了

            <!-- 发送消息的目的地（一个队列） -->
            <bean id="destination" class="org.apache.activemq.command.ActiveMQTopic">  
                    <!-- 设置消息队列的名字 -->
                    <constructor-arg index="0" value="HelloJmsTopic"/>  
            </bean>    

 








http://hi.baidu.com/wu_chao/blog/item/1d9aa2772e663107b051b9cc.html 

posted @ 2012-08-26 20:18 abin 阅读(3362) | 评论 (1) | 编辑 收藏

spring-activemq

1,项目中所引的包

 

2，发送和接受消息的代码，每个都是一个Junit函数

package test;

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

import junit.framework.TestCase;

import org.apache.xbean.spring.context.ClassPathXmlApplicationContext;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class ActivemqTest extends TestCase {
 @Test
 public void testJmsTemplateSend() {      

  ApplicationContext ctx = new FileSystemXmlApplicationContext(
    "WebRoot/WEB-INF/applicationContext.xml");
  JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
  Destination destination = (Destination) ctx.getBean("destination");

  template.send(destination, new MessageCreator() {
   public Message createMessage(Session session) throws JMSException {
    return session.createTextMessage("发送消息：Hello ActiveMQ Text Message！");
   }
  });
  System.out.println("成功发送了一条JMS消息");
 }

 @Test
 public void testJmsTemplateReceive() throws JMSException {
  ApplicationContext ctx = new FileSystemXmlApplicationContext(
    "WebRoot/WEB-INF/applicationContext.xml");
  JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
  Destination destination = (Destination) ctx.getBean("destination");
  while (true) {
   TextMessage txtmsg = (TextMessage) template.receive(destination);
   if (null != txtmsg)
    System.out.println("收到消息内容为: " + txtmsg.getText());
   else
    break;
  }
 }

 public static void main(String[] args) throws Exception{
  new ActivemqTest().testJmsTemplateSend();
  
  new ActivemqTest().testJmsTemplateReceive();
 }
}

 

3，applicationContext.xml文件内容

<?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:context="http://www.springframework.org/schema/context" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
 
    <!-- 配置JMS连接工厂 -->  
    <bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">  
        <property name="brokerURL" value="tcp://localhost:61616"/>  
    </bean>  
 
    <!-- 配置JMS模版 -->  
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
        <property name="connectionFactory" ref="connectionFactory"/>  
    </bean>  
 
    <!-- 发送消息的目的地（一个队列） -->  
    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">  
        <!-- Set the Queue Name -->  
        <constructor-arg index="0" value="HelloWorldQueue"/>  
    </bean>  
</beans>




http://blog.csdn.net/hnzhangshilong/article/details/6629780

posted @ 2012-08-25 21:34 abin 阅读(1051) | 评论 (0) | 编辑 收藏

纯代码实现Quartz定时器(二)

package com.abin.lee.quartz.all;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class UniversalQuartz implements Job{

 public void execute(JobExecutionContext arg0) throws JobExecutionException {
  System.out.println("执行定时任务: "+System.currentTimeMillis());
  
 }
 
}




package com.abin.lee.quartz.all;

import java.text.ParseException;
import java.util.Date;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;

public class UniversalQuartzManager {
 private static UniversalQuartzManager instance = null;
 private Scheduler sched = null;
 private SchedulerFactory factory = null;

 private UniversalQuartzManager() {
  _init();
 }

 private void _init() {
  factory = new org.quartz.impl.StdSchedulerFactory();
  try {
   sched = factory.getScheduler();
  } catch (SchedulerException e) {
   e.printStackTrace();
  }
 }

 public synchronized static UniversalQuartzManager getInstance() {
  if (instance == null) {
   instance = new UniversalQuartzManager();
  }
  return instance;
 }

 public void start() {
  try {
   sched.start();
   // 在这里加载需要执行的业务逻辑类UniversalQuartz.class
   JobDetail detail = new JobDetail("cmhksynchron", "cmhkSynch",
     UniversalQuartz.class);
   CronTrigger trigger = new CronTrigger();
   // 手动添加了时间
   trigger.setCronExpression("0/10 * * * * ? *");
//   trigger.setCronExpression("0 0-59 16 * * ?");
   trigger.setName("abintrigger");
   trigger.setStartTime(new Date());
   sched.scheduleJob(detail, trigger);
  } catch (SchedulerException e) {
   e.printStackTrace();
  } catch (ParseException e2) {
   e2.printStackTrace();
  }
 }

 public void stop() {
  try {
   sched.shutdown();
   sched = factory.getScheduler();
  } catch (SchedulerException e) {
   e.printStackTrace();
  }
 }

 public void refresh() {
  // 未知的原因，程序执行这段判断进入stop（），在sched.shutdown();这一句报错，//所以暂时将其屏蔽，以待后来解决
  // try {
  // if(sched != null && sched.isStarted()) {
  // this.stop();
  // }
  this.start();
  // } catch (SchedulerException e) {
  // e.printStackTrace();
  // }
 }

}

 




package com.abinl.lee.quartz.all.test;

import com.abin.lee.quartz.all.UniversalQuartzManager;

public class TestQuartz {
 public static void main(String[] args) {
  UniversalQuartzManager.getInstance().refresh(); 
 }

}



posted @ 2012-08-25 12:43 abin 阅读(835) | 评论 (0) | 编辑 收藏

纯代码实现Quartz定时器(一)

深入解读Quartz的原理
 
Quartz是一个大名鼎鼎的Java版开源定时调度器，功能强悍，使用方便。
 
一、核心概念
 
Quartz的原理不是很复杂，只要搞明白几个概念，然后知道如何去启动和关闭一个调度程序即可。
 
1、Job
表示一个工作，要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)
 
2、JobDetail
JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。

 
3、Trigger代表一个调度参数的配置，什么时候去调。
 
4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。
 
 
二、一个最简单入门实例
 
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**
* quartz定时器测试
*
* @author leizhimin 2009-7-23 8:49:01
*/
public class MyJob implements Job {
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
                System.out.println(new Date() + ": doing something...");
        }
}

class Test {
        public static void main(String[] args) {
                //1、创建JobDetial对象
                JobDetail jobDetail = new JobDetail();
                //设置工作项
                jobDetail.setJobClass(MyJob.class);
                jobDetail.setName("MyJob_1");
                jobDetail.setGroup("JobGroup_1");

                //2、创建Trigger对象
                SimpleTrigger strigger = new SimpleTrigger();
                strigger.setName("Trigger_1");
                strigger.setGroup("Trigger_Group_1");
                strigger.setStartTime(new Date());
                //设置重复停止时间，并销毁该Trigger对象
                java.util.Calendar c = java.util.Calendar.getInstance();
                c.setTimeInMillis(System.currentTimeMillis() + 1000 * 1L);
                strigger.setEndTime(c.getTime());
                strigger.setFireInstanceId("Trigger_1_id_001");
                //设置重复间隔时间
                strigger.setRepeatInterval(1000 * 1L);
                //设置重复执行次数
                strigger.setRepeatCount(3);

                //3、创建Scheduler对象，并配置JobDetail和Trigger对象
                SchedulerFactory sf = new StdSchedulerFactory();
                Scheduler scheduler = null;
                try {
                        scheduler = sf.getScheduler();
                        scheduler.scheduleJob(jobDetail, strigger);
                        //4、并执行启动、关闭等操作
                        scheduler.start();

                } catch (SchedulerException e) {
                        e.printStackTrace();
                }
//                try {
//                        //关闭调度器
//                        scheduler.shutdown(true);
//                } catch (SchedulerException e) {
//                        e.printStackTrace();
//                }
        }
}
 
执行结果：

 
当把结束时间改为：
                //设置重复停止时间，并销毁该Trigger对象
                java.util.Calendar c = java.util.Calendar.getInstance();
                c.setTimeInMillis(System.currentTimeMillis() + 1000 * 1L);
                strigger.setEndTime(c.getTime());
 
执行结果：
 
当添加一条关闭调度器的语句：
                        //4、并执行启动、关闭等操作
                        scheduler.start();
                        scheduler.shutdown(true);

 
程序执行结果：
Thu Jul 23 10:11:50 CST 2009: doing something...

Process finished with exit code 0
仅仅执行了一次，这一次能执行完，原因是设定了scheduler.shutdown(true);true表示等待本次任务执行完成后停止。
 
从这里也可以看出，scheduler是个容器，scheduler控制jobDetail的执行，控制的策略是通过trigger。
 
当scheduler容器启动后，jobDetail才能根据关联的trigger策略去执行。当scheduler容器关闭后，所有的jobDetail都停止执行。
 
三、透过实例看原理
 
通过研读Quartz的源代码，和本实例，终于悟出了Quartz的工作原理。
 
1、scheduler是一个计划调度器容器（总部），容器里面可以盛放众多的JobDetail和trigger，当容器启动后，里面的每个JobDetail都会根据trigger按部就班自动去执行。
 
2、JobDetail是一个可执行的工作，它本身可能是有状态的。
 
3、Trigger代表一个调度参数的配置，什么时候去调。
 
4、当JobDetail和Trigger在scheduler容器上注册后，形成了装配好的作业（JobDetail和Trigger所组成的一对儿），就可以伴随容器启动而调度执行了。
 
5、scheduler是个容器，容器中有一个线程池，用来并行调度执行每个作业，这样可以提高容器效率。
 
6、将上述的结构用一个图来表示，如下：
 

 
四、总结
 
1、搞清楚了上Quartz容器执行作业的的原理和过程，以及作业形成的方式，作业注册到容器的方法。就认识明白了Quartz的核心原理。
 
2、Quartz虽然很庞大，但是一切都围绕这个核心转，为了配置强大时间调度策略，可以研究专门的CronTrigger。要想灵活配置作业和容器属性，可以通过Quartz的properties文件或者XML来实现。
 
3、要想调度更多的持久化、结构化作业，可以通过数据库读取作业，然后放到容器中执行。
 
4、所有的一切都围绕这个核心原理转，搞明白这个了，再去研究更高级用法就容易多了。
 
5、Quartz与Spring的整合也非常简单，Spring提供一组Bean来支持：MethodInvokingJobDetailFactoryBean、SimpleTriggerBean、SchedulerFactoryBean，看看里面需要注入什么属性即可明白了。Spring会在Spring容器启动时候，启动Quartz容器。
 
6、Quartz容器的关闭方式也很简单，如果是Spring整合，则有两种方法，一种是关闭Spring容器，一种是获取到SchedulerFactoryBean实例，然后调用一个shutdown就搞定了。如果是Quartz独立使用，则直接调用scheduler.shutdown(true);
 
7、Quartz的JobDetail、Trigger都可以在运行时重新设置，并且在下次调用时候起作用。这就为动态作业的实现提供了依据。你可以将调度时间策略存放到数据库，然后通过数据库数据来设定Trigger，这样就能产生动态的调度。



http://blog.csdn.net/jiangfeng861016/article/details/5970745




posted @ 2012-08-25 11:48 abin 阅读(3276) | 评论 (1) | 编辑 收藏

Https ssl java
http://www.iteye.com/topic/1125183
http://blog.sina.com.cn/s/blog_5f64eccd0100p0pc.html
http://www.iteye.com/topic/1125183
http://hi.baidu.com/zhouqiugang/blog/item/65c9e160177db3cc8cb10d86.html
http://blog.csdn.net/zrbin153/article/details/6026840
HttpClient访问https站点证书加载问题
http://237451446.blog.51cto.com/2307663/759338
HttpClient请求Https协议
http://www.blogjava.net/sxyx2008/archive/2011/07/08/353940.html
posted @ 2012-08-23 13:54 abin 阅读(538) | 评论 (0) | 编辑 收藏

继承中静态块、游离块、构造器等的执行顺序
在继承关系中，静态块、游离块、构造器、静态方法、静态变量、变量等的加载顺序是如何的呢？！让代码来告诉我们，结果如下：

  父类静态块
  子类静态块
  父类变量
  父类静态变量
  父类游离块
  父类构造器
  子类变量
  子类静态变量
  子类游离块
  子类的构造器

验证的代码：


package com.jlq.test;

public class Test1 {

private static String s1 = "父类静态变量";

private String s2 = "父类变量";

public Test1() {
System.out.println("父类构造器");
}
/**
* 静态代码块
*/

static {
System.out.println("父类静态块");

}
/**
* 游离块
*/
{
System.out.println(s2);
System.out.println(s1);
System.out.println("父类游离块");

}

public static void main(String[] args) {
new TestChild();
}

}

class TestChild extends Test1 {

private static String s1 = "子类静态变量";

private String s2 = "子类变量";
/**
* 静态代码块
*/

static {
System.out.println("子类静态块");

}
/**
* 游离块
*/
{
System.out.println(s2);
System.out.println(s1);
System.out.println("子类游离块");

}

public TestChild() {
System.out.println("子类的构造器");
}

}
posted @ 2012-08-22 15:07 abin 阅读(502) | 评论 (0) | 编辑 收藏

keytool+tomcat配置HTTPS双向证书认证

系统需求：

1、  Windows系统或Linux系统

2、  安装并配置JDK 1.6.0_13

3、  安装并配置Tomcat 6.0

 

第一步：为服务器生成证书

1、  Windows系统

  • “运行”控制台，进入%JAVA_HOME%/bin目录
  • 使用keytool为Tomcat生成证书，假定目标机器的域名是“localhost”，keystore文件存放在“D:\home\tomcat.keystore”，口令为“password”，使用如下命令生成：

 

keytool -genkey -v -alias tomcat -keyalg RSA -keystore D:\home\tomcat.keystore -validity 36500

 

(参数简要说明：“D:\home\tomcat.keystore”含义是将证书文件的保存路径，证书文件名称是tomcat.keystore ；“-validity 36500”含义是证书有效期，36500表示100年，默认值是90天)

  • 在命令行填写必要参数：

A、输入keystore密码：此处需要输入大于6个字符的字符串

B、“您的名字与姓氏是什么？”这是必填项，并且必须是TOMCAT部署主机的域名或者IP[如：gbcom.com 或者 10.1.25.251]（就是你将来要在浏览器中输入的访问地址），否则浏览器会弹出警告窗口，提示用户证书与所在域不匹配。在本地做开发测试时，应填入“localhost”

C、“你的组织单位名称是什么？”、“您的组织名称是什么？”、“您所在城市或区域名称是什么？”、“您所在的州或者省份名称是什么？”、“该单位的两字母国家代码是什么？”可以按照需要填写也可以不填写直接回车，在系统询问“正确吗？”时，对照输入信息，如果符合要求则使用键盘输入字母“y”，否则输入“n”重新填写上面的信息

D、输入<tomcat>的主密码，这项较为重要，会在tomcat配置文件中使用，建议输入与keystore的密码一致，设置其它密码也可以

  • 完成上述输入后，直接回车则在你在第二步中定义的位置找到生成的文件

2、  Linux系统

  • “运行”控制台，进入%JAVA_HOME%/bin目录
  • 使用如下命令生成：

 

./keytool -genkey -alias tomcat -keyalg RSA -keystore /usr/local/ac/web/tomcat.keystore -validity 36500

(参数简要说明：“/etc/tomcat.keystore”含义是将证书文件保存在路径/usr/local/ac/web/下，证书文件名称是tomcat.keystore ；“-validity 36500”含义是证书有效期，36500表示100年，默认值是90天)

  • 在命令行填写必要参数：

A、Enter keystore password：此处需要输入大于6个字符的字符串

B、“What is your first and last name?”这是必填项，并且必须是TOMCAT部署主机的域名或者IP[如：gbcom.com 或者 10.1.25.251]，就是你将来要在浏览器中输入的访问地址

C、“What is the name of your organizational unit?”、“What is the name of your organization?”、“What is the name of your City or Locality?”、“What is the name of your State or Province?”、“What is the two-letter country code for this unit?”可以按照需要填写也可以不填写直接回车，在系统询问“correct?”时，对照输入信息，如果符合要求则使用键盘输入字母“y”，否则输入“n”重新填写上面的信息

D、Enter key password for <tomcat>，这项较为重要，会在tomcat配置文件中使用，建议输入与keystore的密码一致，设置其它密码也可以

  • 完成上述输入后，直接回车则在你在第二步中定义的位置找到生成的文件

 

第二步：为客户端生成证书

 

  • 为浏览器生成证书，以便让服务器来验证它。为了能将证书顺利导入至IE和Firefox，证书格式应该是PKCS12，因此，使用如下命令生成：

 

keytool -genkey -v -alias mykey -keyalg RSA -storetype PKCS12 -keystore D:\home\mykey.p12

 

对应的证书库存放在“D:\home\mykey.p12”，客户端的CN可以是任意值。双击mykey.p12文件，即可将证书导入至浏览器（客户端）。

 

第三步：让服务器信任客户端证书

 

  • 由于是双向SSL认证，服务器必须要信任客户端证书，因此，必须把客户端证书添加为服务器的信任认证。由于不能直接将PKCS12格式的证书库导入，必须先把客户端证书导出为一个单独的CER文件，使用如下命令：

 

keytool -export -alias mykey -keystore D:\home\mykey.p12 -storetype PKCS12 -storepass password -rfc -file D:\home\mykey.cer

 

  • 通过以上命令，客户端证书就被我们导出到“D:\home\mykey.cer”文件了。下一步，是将该文件导入到服务器的证书库，添加为一个信任证书：

 

keytool -import -v -file D:\home\mykey.cer -keystore D:\home\tomcat.keystore

 

  • 通过list命令查看服务器的证书库，可以看到两个证书，一个是服务器证书，一个是受信任的客户端证书：

 

keytool -list -keystore D:\home\tomcat.keystore

 

第四步：让客户端信任服务器证书

 

  • 由于是双向SSL认证，客户端也要验证服务器证书，因此，必须把服务器证书添加到浏览的“受信任的根证书颁发机构”。由于不能直接将keystore格式的证书库导入，必须先把服务器证书导出为一个单独的CER文件，使用如下命令：

 

keytool -keystore D:\home\tomcat.keystore -export -alias tomcat -file D:\home\tomcat.cer

 

 

  • 通过以上命令，服务器证书就被我们导出到“D:\home\tomcat.cer”文件了。双击tomcat.cer文件，按照提示安装证书，将证书填入到“受信任的根证书颁发机构”。

第四步：配置Tomcat服务器

 

打开Tomcat根目录下的/conf/server.xml，找到如下配置段，修改如下：

 

<Connector port="8443" protocol="org.apache.coyote.http11.Http11NioProtocol"
SSLEnabled="true" maxThreads="150" scheme="https"
secure="true" clientAuth="true" sslProtocol="TLS"
keystoreFile="D:\\home\\test.keystore" keystorePass="123456"
truststoreFile="D:\\home\\test.keystore" truststorePass="123456" />

属性说明：

  • clientAuth:设置是否双向验证，默认为false，设置为true代表双向验证
  • keystoreFile:服务器证书文件路径
  • keystorePass:服务器证书密码
  • truststoreFile:用来验证客户端证书的根证书，此例中就是服务器证书
  • truststorePass:根证书密码

第五步：测试

 

在浏览器中输入:https://localhost:8443/，会弹出选择客户端证书界面，点击“确定”，会进入tomcat主页，地址栏后会有“锁”图标，表示本次会话已经通过HTTPS双向验证，接下来的会话过程中所传输的信息都已经过SSL信息加密。


注意事项：貌似导入证书的时候，最好导入到“个人”那一栏里面，貌似客户端的用户名不填写也是可以的，或者随便填写。

http://licg1234.blog.163.com/blog/static/13908233320121165356868/ 


 

posted @ 2012-08-22 09:52 abin 阅读(12990) | 评论 (0) | 编辑 收藏

cxf spring集成(三)
     摘要: CXF与spring集成 1． 新建web project ,并加入apache-cxf-2.0.7/lib所有包，编写要发布的web service 接口和实现.这一步，与前面一样。 import javax.jws.WebService; @WebService  public interface HelloWorld {     ...  阅读全文
posted @ 2012-08-21 14:20 abin 阅读(997) | 评论 (0) | 编辑 收藏

cxf spring集成(二)

五、CXF WebService整合Spring

首先，CXF和spring整合需要准备如下jar包文件：

image

这边我是用Spring的jar包是Spring官方提供的，并没有使用CXF中的Spring的jar文件。

添加这么多文件后，首先在web.xml中添加如下配置： 

<!-- 加载Spring容器配置 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 设置Spring容器加载配置文件路径 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext-server.xml</param-value>
</context-param>
 
<listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
 
<servlet>
    <servlet-name>CXFService</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
</servlet>
 
<servlet-mapping>
    <servlet-name>CXFService</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

然后在src目录中，新建一个applicationContext-server.xml文件，文件内容如下：

  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans >
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd"

注意上面的带下划线加粗部分，这个很重要的哦！不能写错或是遗漏了。

添加完这个文件后，还需要在这个文件中导入这么几个文件。文件内容如下： 

<import resource="classpath:META-INF/cxf/cxf.xml"/>
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>

下面开始写服务器端代码，首先定制服务器端的接口，代码如下： 

package com.hoo.service;
 
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import com.hoo.entity.User;
import com.hoo.entity.Users;
 
/**
 * <b>function:</b>定制客户端请求WebService所需要的接口
 * @author hoojo
 * @createDate 2011-3-18 上午08:22:55
 * @file ComplexUserService.java
 * @package com.hoo.service
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@WebService
@SOAPBinding(style = Style.RPC)
public interface IComplexUserService {
    
    public User getUserByName(@WebParam(name = "name") String name);
    
    public void setUser(User user);
}

下面编写WebService的实现类，服务器端实现代码如下： 

package com.hoo.service;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;
import com.hoo.entity.User;
import com.hoo.entity.Users;
 
/**
 * <b>function:</b> WebService传递复杂对象，如JavaBean、Array、List、Map等
 * @author hoojo
 * @createDate 2011-3-18 上午08:22:55
 * @file ComplexUserService.java
 * @package com.hoo.service
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@WebService
@SOAPBinding(style = Style.RPC)
@SuppressWarnings("deprecation")
public class ComplexUserService implements IComplexUserService {
    
    public User getUserByName(@WebParam(name = "name") String name) {
        User user = new User();
        user.setId(new Date().getSeconds());
        user.setName(name);
        user.setAddress("china");
        user.setEmail(name + "@hoo.com");
        return user;
    }
    
    public void setUser(User user) {
        System.out.println("############Server setUser###########");
        System.out.println("setUser:" + user);
    }
}

注意的是和Spring集成，这里一定要完成接口实现，如果没有接口的话会有错误的。

下面要在applicationContext-server.xml文件中添加如下配置： 

<bean id="userServiceBean" class="com.hoo.service.ComplexUserService"/>
 
<bean id="inMessageInterceptor" class="com.hoo.interceptor.MessageInterceptor">
    <constructor-arg  value="receive"/>
</bean>
 
<bean id="outLoggingInterceptor" class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>
<!-- 注意下面的address，这里的address的名称就是访问的WebService的name -->
<jaxws:server id="userService" serviceClass="com.hoo.service.IComplexUserService" address="/Users">
    <jaxws:serviceBean>
        <!-- 要暴露的 bean 的引用 -->
        <ref bean="userServiceBean"/>
    </jaxws:serviceBean>
    <jaxws:inInterceptors>
        <ref bean="inMessageInterceptor"/>
    </jaxws:inInterceptors>
    <jaxws:outInterceptors>
        <ref bean="outLoggingInterceptor"/>
    </jaxws:outInterceptors>
</jaxws:server>

下面启动tomcat服务器后，在WebBrowser中请求：

http://localhost:8080/CXFWebService/Users?wsdl

如果你能看到wsdl的xml文件的内容，就说明你成功了，注意的是上面地址的Users就是上面xml配置中的address的名称，是一一对应的。

下面编写客户端请求的代码，代码如下： 

package com.hoo.client;
 
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import com.hoo.entity.User;
import com.hoo.service.IComplexUserService;
 
/**
 * <b>function:</b>请求Spring整合CXF的WebService客户端
 * @author hoojo
 * @createDate 2011-3-28 下午03:20:35
 * @file SpringUsersWsClient.java
 * @package com.hoo.client
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class SpringUsersWsClient {
 
    public static void main(String[] args) {
        //调用WebService
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        factory.setServiceClass(IComplexUserService.class);
        factory.setAddress("http://localhost:8080/CXFWebService/Users");
        
        IComplexUserService service = (IComplexUserService) factory.create();
        
        System.out.println("#############Client getUserByName##############");
        User user = service.getUserByName("hoojo");
        System.out.println(user);
        
        user.setAddress("China-Guangzhou");
        service.setUser(user);
    }
}

运行后，可以在控制台中看到

log4j:WARN No appenders could be found for logger (org.apache.cxf.bus.spring.BusApplicationContext).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
2011-3-28 18:12:26 org.apache.cxf.service.factory.ReflectionServiceFactoryBean buildServiceFromClass
信息: Creating Service {http://service.hoo.com/}IComplexUserServiceService from class com.hoo.service.IComplexUserService
#############Client getUserByName##############
27#hoojo#hoojo@hoo.com#china

Tomcat控制台
 image

这个server端是通过Spring整合配置的，下面我们将Client端也通过Spring配置完成整合。

首先增加applicationContext-client.xml配置文件，文件内容如下： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans >
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd"
    
    <import resource="classpath:META-INF/cxf/cxf.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
    
    <jaxws:client id="userWsClient" serviceClass="com.hoo.service.IComplexUserService" 
        address="http://localhost:8080/CXFWebService/Users"/>
</beans>

客户端请求代码如下： 

package com.hoo.client;
 
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hoo.entity.User;
import com.hoo.service.IComplexUserService;
 
/**
 * <b>function:</b>请求Spring整合CXF的WebService客户端
 * @author hoojo
 * @createDate 2011-3-28 下午03:20:35
 * @file SpringUsersWsClient.java
 * @package com.hoo.client
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class SpringUsersWsClient {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-client.xml");
        
        IComplexUserService service = ctx.getBean("userWsClient", IComplexUserService.class);
        
        System.out.println("#############Client getUserByName##############");
        User user = service.getUserByName("hoojo");
        System.out.println(user);
        
        user.setAddress("China-Guangzhou");
        service.setUser(user);
    }
}

运行后结果如下：

#############Client getUserByName##############
45#hoojo#hoojo@hoo.com#china
############Server setUser###########
setUser:45#hoojo#hoojo@hoo.com#China-Guangzhou

作者：hoojo
出处：

http://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html
blog：http://blog.csdn.net/IBM_hoojo
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

 


版权所有，转载请注明出处 本文出自： http://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html
posted @ 2012-08-21 11:17 abin 阅读(1591) | 评论 (0) | 编辑 收藏

仅列出标题
共50页: First 上一页 31 32 33 34 35 36 37 38 39 下一页 Last