少年阿賓

那些青春的歲月

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>

方法2：

</table>

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

分享到：

posted @ 2012-08-28 21:20 abin 閱讀(1325) | 評論 (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 本文件為服務配置文件

這一項為端口設置

默認為 “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">

<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">

<bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
                    <property name="brokerURL" value="tcp://localhost:61618"/>
            </bean>

            
            <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
                    <property name="connectionFactory" ref="connectionFactory"/>
        <property name="pubSubDomain" value="false" />
        <property name="explicitQosEnabled" value="true" /> 
        <property name="deliveryMode" value="1" /> 

            </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 閱讀(3374) | 評論 (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">

    
    <bean id="connectionFactory" class="org.apache.activemq.spring.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>

    
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
    </bean>

    
    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
        
        <constructor-arg index="0" value="HelloWorldQueue"/>
    </bean>
</beans>

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

posted @ 2012-08-25 21:34 abin 閱讀(1062) | 評論 (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 閱讀(848) | 評論 (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 閱讀(3290) | 評論 (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.aygfsteel.com/sxyx2008/archive/2011/07/08/353940.html

posted @ 2012-08-23 13:54 abin 閱讀(545) | 評論 (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 閱讀(511) | 評論 (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 閱讀(13007) | 評論 (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 閱讀(1005) | 評論 (0) | 編輯收藏

cxf spring集成(二)

五、CXF WebService整合Spring

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

這邊我是用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控制臺

這個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
本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。

posted @ 2012-08-21 11:17 abin 閱讀(1602) | 評論 (0) | 編輯收藏

僅列出標題

少年阿賓

常用鏈接

留言簿(22)

我參與的團隊

隨筆分類

隨筆檔案

新聞分類

相冊

搜索

最新評論

閱讀排行榜

評論排行榜

五、CXF WebService整合Spring