姓张的小子

使用Spring依赖注入实现方法替换

Posted by eDWARD at 15:42

　　在ApplicationContext配置文件中配置Bean的时候可以使用replaced-method设置需要替换的方法。replaced-method标签的name属性用来设置需要替换的方法名称，replacer属性用来设置替换方法的Bean，前提是这个Bean需要实现Spring的MethodReplacer接口，replaced-method标签下的元素arg-type用来区分替换方法的参数。

需要替换方法的Class

public class ReplacementTarget {
  public String formatMessage(String msg) {
    return msg;
  }

  public String formatMessage(Object msg) {
    return msg;
  }

  public void foo() {
  }
}

替换方法的CLASS

public class FormatMessageReplacer implements MethodReplacer {
  public Object reimplement(Object target, Method method, Object[] args)
    throws Throwable {
    if (isFormatMessageMethod(method)) {
      String msg = (String) args[0];
      return msg;
    } else {
      throw new IllegalArgumentException("Unable to reimplement method "
        + method.getName());
    }
  }

  // 验证方法是否正确
  private boolean isFormatMessageMethod(Method method) {
    if (method.getParameterTypes().length != 1) {
      return false;
    }

    if (!("formatMessage".equals(method.getName())))
      return false;
    }

    if (method.getReturnType() != String.class) {
      return false;
    }

    if (method.getParameterTypes()[0] != String.class) {
      return false;
    }

    return true;
    }
}

配置文件(replacement.xml)

<beans>
  <bean id="methodReplacer" class="FormatMessageReplacer"/>
    <bean id="replacementTarget" class="ReplacementTarget">
      <replaced -method name="formatMessage" replacer="methodReplacer">
        <arg -type>String</arg>
      </replaced>
    </bean>
  <bean id="standardTarget" class="ReplacementTarget"/>
</beans>

测试类

public class MethodReplacementExample {
  public static void main(String[] args) {
    BeanFactory factory = new XmlBeanFactory(
      new FileSystemResource("build/replacement.xml"));
    ReplacementTarget replacementTarget = (ReplacementTarget)
      factory.getBean("replacementTarget");
    ReplacementTarget standardTarget = (ReplacementTarget)
      factory.getBean("standardTarget");

    // 执行方法
    displayInfo(replacementTarget);
    displayInfo(standardTarget);
  }

  private static void displayInfo(ReplacementTarget target) {
    System.out.println(target.formatMessage("Hello World!"));
  }
}

Filed In 学习路上 | Study | Tags: Spring, 依赖注入, 控制反转, 程序设计 | Add a Comment »

Spring与ActiveMQ(JMS)的整合说明

Posted by eDWARD at 15:37

　　ActiveMQ是完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现,也是Apache Geronimo默认的JMS provider。

　　ActiveMQ的网站：http://www.activemq.org

　　使用ActiveMQ后，可以在普通Web服务器使用JMS功能，不依赖于特定的应用服务器。

1. ActiveMQ 4.1-incubator-SNAPSHOT 与Spring 2.0 集成

ActiveMQ4.1 响应Spring 2.0号召，支持了引入XML Schema namespace的简单配置语法，简化了配置的语句。

1.1 引入ActiveMQ的XSD

在ApplicationContext.xml(Spring的配置文件)中引入ActiveMQ的XML Scheam 配置文件),如下:
(说明:由于ActiveMQ的那个XSD有部分错误,因此使用的是自行修改过的XSD,见”配置ClassPath中的scheam”小节)

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:amq="http://activemq.org/config/1.0"
  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.xsd
  http://activemq.org/config/1.0
  http://people.apache.org/repository/org.apache.activemq/xsds/activemq-core-4.1-incubator-SNAPSHOT.xsd">
</beans>

1.2 配置ClassPath中的schema

在ClassPath 下面建立META-INF\spring.schemas 内容如下

http\://people.apache.org/repository/org.apache.activemq/xsds/activemq-core-4.1-incubator-SNAPSHOT.xsd=/activemq-core-4.1-incubator-SNAPSHOT.xsd
这个spring.schemas是spring自定义scheam的配置文件
请注意"http:\://"部分写法

1.3 配置ActiveMQ embedded ActiveMQ Broker

<!-- lets create an embedded ActiveMQ Broker -->
<amq :broker useJmx="false" persistent="false"></amq>
<amq :transportConnectors>
  <amq :transportConnector uri="tcp://localhost:0"/>
</amq>

当spring初始化时候,ActiveMQ embedded Broker 就会启动了

1.4 配置BookStore MDP

配置ConnectionFactory,由于是embedded 所以URL为:vm://localhost

<!--  ActiveMQ connectionFactory to use  -->
<amq :connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost"/>

配置Queue名字

<!-- ActiveMQ destinations to use -->
<amq :queue name="destination" physicalName="org.apache.activemq.spring.Test.spring.embedded"/>

配置JmsTemplate

<!--  Spring JmsTemplate config -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
    <!-- lets wrap in a pool to avoid creating a connection per send -->
    <bean class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory">
        <ref local="jmsConnectionFactory"/>
      </property>
    </bean>
  </property>
  <!-- custom MessageConverter define -->
<property name="messageConverter" ref="orderMessageConverter"/>
</bean>

配置MDP POJO

<!-- a sample POJO which uses a Spring JmsTemplate -->
<bean id="orderMessageProducer" class="org.springside.bookstore.components.activemq.OrderMessageProducer">
<property name="template">
    <ref bean="jmsTemplate"/>
  </property>
<property name="destination">
    <ref bean="destination"/>
  </property>
</bean>
<!-- this is the Message Driven POJO (MDP) -->
<!-- define MessageListenerAdapter -->
<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
  <constructor -arg>
    <bean class="org.springside.bookstore.components.activemq.OrderMessageConsumer">
<property name="mailService" ref="mailService"></property>
    </bean>
  </constructor>
  <!-- mey be other method -->
<property name="defaultListenerMethod" value="sendEmail"/>
  <!-- custom MessageConverter define -->
<property name="messageConverter" ref="orderMessageConverter"/>
</bean>
<!-- and this is the attendant message listener container -->
<bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory"/>
<property name="destination" ref="destination"/>
<property name="messageListener" ref="messageListener"/>
</bean>

补充说明

1. 采用了自定义的MessageConverter,Producer能够直接发送POJO。
2. 使用了Spring的DefaultMessageListenerContainer,MessageListenerAdapter, Consumer　不用实现MessageListener 接口。

Filed In 学习路上 | Study | Tags: ActiveMQ, JMS, Spring, 程序设计 | Add a Comment »

判断一个Url是否存在的javascript方法

Posted by eDWARD at 15:35

function isExist(sURL) {
	var xmlHttp;
	if (window.ActiveXObject){
		xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
	}else{
		xmlHttp=new XMLHttpRequest();
	}
	xmlhttp.abort();
	xmlhttp.open("GET",sURL,false)；
	xmlhttp.send();

	if (xmlhttp.readyState==4) {
		if (xmlhttp.status==200)
			return true; //成功
		else if (xmlhttp.status==404)
			return false; // 没有找到
		else if (xmlhttp.status==500)
			return false; // 服务器错误
		else
			return false;
	}
}

Filed In 学习路上 | Study | Tags: javascript, 程序设计 | Add a Comment »

Spring的项目测试的一些要点

Posted by eDWARD at 15:26

需要Spring 依赖注入的测试

　　为了测试Spring管理下的Bean，可以自行构造BeanFactory，也可以继承于AbstractDependencyInjectionSpringContextTests，实现public String[] getConfigLocations()函数， 返回applicationContext文件路径的数组。

protected String[] getConfigLocations() {
return new String[]{"classpath*:spring/*.xml", "classpath*:spring/test/*.xml"};
}

　　并显式写一些需要注入的变量的setter函数。
　　tips1：此基类有一个applicationContext的成员变量，所以除了依靠setter注入外，还可以随时用applicationContext.getBean() 取出所需的bean。

　　tips2：注意此基类默认是autowire by type的，所以如果context文件里有两个相同类型的Bean就会报错，可能需要在getConfigLocations()函数里，setAutowireMode(AUTOWIRE_BY_NAME);把它设回by name，或者取消setter函数，自行用applicationContext.getBean()来显式查找Bean。

Dao测试

　　AbstractTransactionalDataSourceSpringContextTests 继承于AbstractDependencyInjectionSpringContextTests，除了拥有上类的能力外，还管理了每个测试的事务，会在每个测试后默认回滚所有的操作。
　　深层解释，此类的实现其实依赖于Application Context中定义的PlatformTransactionManager。由于使用了autowire by type，可以任意取名。
　　另依赖于Application Context中定义的DataSource，同样可以任意取名。
　　tips1：如果需要在测试后提交，需要setRollBack(false); 或者调用setComplete()
　　tips2：此基类还通过注入的DataSource创建了一个JDBCTemplate 变量，可以跑SQL帮忙核对Hibernate的结果，Spring将确保该查询在同一个事务内执行。为正常工作你需要告诉你的ORM工具’刷新’它的已改变内容，例如使用Hibernate Session 接口的 flush() 方法。
　　tips3：除了tips2以外，还有countRowsInTable(String tableName)，deleteFromTables(String[] names) ，executeSqlScript(String sqlResourcePath, boolean continueOnError)三个简便函数。

Controller测试

　　Controller测试一般要用MockObject 分离Service层，要copy WEB-INF/下的相关文件copy 到classpath，而且Controller不含太多的逻辑，所有测试controller有点吃力不讨好，建议直接用selenium进行集成测试。见(Selenium测试概述)。

SpringSide里的测试

　　因为Spring默认的基类名字较长，SpringSide 在core 的org.springside.core.test 中重新继承了它们，并提供了按springside的context文件存放规则，默认读取所有context 文件的getConfigLocations()函数。
　　默认读取所有context文件的getConfigLocations()函数对速度和测试的隔离化都有影响，可以在子类重新实现。不过自己重新一个个写相关context文件也好烦，而且其实在全lazy-load的情况下，速度也还可以接受。如何取舍要自己平衡了。
　　对于CRUD的测试，在helloworld示例里的变量名都作了泛化，可以快速copy到另一个测试里。
　　另外，留意resources/spring/test 下的文件，利用了Spring的PropertyOverrideConfigurer，重新设定测试时的ApplicatonContext 里各个Bean的属性如指定测试用的DataSource，详细用法见Spring配置要点。
　　phpcode有点排版不便，大家可以看wiki原文。

Filed In 学习路上 | Study | Tags: Spring, 测试, 程序设计 | Add a Comment »

Spring框架中的三种注入方式

Posted by eDWARD at 15:25

Type1 接口注入

我们常常借助接口来将调用者与实现者分离。如:

public class ClassA {
　　private InterfaceB clzB;
　　public init() {
　　Ojbect obj =
　　Class.forName(Config.BImplementation).newInstance();
　　clzB = (InterfaceB)obj;
　　}
　　……
　　}

　　上面的代码中，ClassA依赖于InterfaceB的实现，如何获得InterfaceB实现类的实例？传统的方法是在代码中创建InterfaceB实现类的实例，并将起赋予clzB。

　　而这样一来，ClassA在编译期即依赖于InterfaceB的实现。为了将调用者与实现者在编译期分离，于是有了上面的代码，我们根据预先在配置文件中设定的实现类的类名，动态加载实现类，并通过InterfaceB强制转型后为ClassA所用。
　　这就是接口注入的一个最原始的雏形。
　　而对于一个Type1型IOC容器而言，加载接口实现并创建其实例的工作由容器完成，如J2EE开发中常用的Context.lookup（ServletContext.getXXX），都是Type1型IOC的表现形式。
　　Apache Avalon是一个典型的Type1型IOC容器。

Type2 构造子注入

构造子注入，即通过构造函数完成依赖关系的设定，如：

public class DIByConstructor {
　　private final DataSource dataSource;
　　private final String message;
　　public DIByConstructor(DataSource ds, String msg) {
　　this.dataSource = ds;
　　this.message = msg;
　　}
　　……
　　}

　　可以看到，在Type2类型的依赖注入机制中，依赖关系是通过类构造函数建立，容器通过调用类的构造方法，将其所需的依赖关系注入其中。
　　PicoContainer（另一种实现了依赖注入模式的轻量级容器）首先实现了Type2类型的依赖注入模式。

Type3 设值注入

　　在各种类型的依赖注入模式中，设值注入模式在实际开发中得到了最广泛的应用（其中很大一部分得力于Spring框架的影响）。
　　在笔者看来，基于设置模式的依赖注入机制更加直观、也更加自然。Quick Start中的示例，就是典型的设置注入，即通过类的setter方法完成依赖关系的设置。

几种依赖注入模式的对比总结

　　接口注入模式因为具备侵入性，它要求组件必须与特定的接口相关联，因此并不被看好，实际使用有限。
　　Type2和Type3的依赖注入实现模式均具备无侵入性的特点。在笔者看来，这两种实现方式各有特点，也各具优势（一句经典废话?）。

Type2 构造子注入的优势：

1. “在构造期即创建一个完整、合法的对象”，对于这条Java设计原则，Type2无疑是最好的响应者。
2. 避免了繁琐的setter方法的编写，所有依赖关系均在构造函数中设定，依赖关系集中呈现，更加易读。
3. 由于没有setter方法，依赖关系在构造时由容器一次性设定，因此组件在被创建之后即处相对“不变”的稳定状态，无需担心上层代码在调用过程中执行setter方法对组件依赖关系产生破坏，特别是对于Singleton模式的组件而言，这可能对整个系统产生重大的影响。
4. 同样，由于关联关系仅在构造函数中表达，只有组件创建者需要关心组件内部的依赖关系。对调用者而言，组件中的依赖关系处于黑盒之中。对上层屏蔽不必要的信息，也为系统的层次清晰性提供了保证。
5. 通过构造子注入，意味着我们可以在构造函数中决定依赖关系的注入顺序，对于一个大量依赖外部服务的组件而言，依赖关系的获得顺序可能非常重要，比如某个依赖关系注入的先决条件是组件的DataSource及相关资源已经被设定。

Type3 设值注入的优势：

1. 对于习惯了传统JavaBean开发的程序员而言，通过setter方法设定依赖关系显得更加直观，更加自然。
2. 如果依赖关系（或继承关系）较为复杂，那么Type2模式的构造函数也会相当庞大（我们需要在构造函数中设定所有依赖关系），此时Type3模式往往更为简洁。
3. 对于某些第三方类库而言，可能要求我们的组件必须提供一个默认的构造函数（如Struts中的Action），此时Type2类型的依赖注入机制就体现出其局限性，难以完成我们期望的功能。

　　可见，Type2和Type3模式各有千秋，而Spring、PicoContainer都对Type2和Type3类型的依赖注入机制提供了良好支持。这也就为我们提供了更多的选择余地。理论上，以Type2类型为主，辅之以Type3类型机制作为补充，可以达到最好的依赖注入效果，不过对于基于Spring Framework开发的应用而言，Type3使用更加广泛。

Filed In 学习路上 | Study | Tags: Spring, 依赖注入, 控制反转, 程序设计 | Add a Comment »

Spring中关于乱码的解决办法

Posted by eDWARD at 15:22

Spring可以在容器加载时在web.xml中配置filter来进行转发过滤，因为我把html作为screen的映射后缀，所以这里可以根据你的情况设置为*.jsp或*.action等等。

    <filter>
        </filter><filter -name>SpringEncodingFilter</filter>
        <filter -class>org.springframework.web.filter.CharacterEncodingFilter</filter>
        <init -param>
<param -name>encoding</param>
<param -value>utf-8</param>
        </init>

    <filter -mapping>
        </filter><filter -name>SpringEncodingFilter</filter>
        <url -pattern>*.html</url>

如果你用到了任何properties配置文件，那么就需要通过java/bin/native2ascii统一转码为utf-8编码方式

native2ascii -encording utf-8 目标路径 转码后路径

所有被渲染的view层的页面顶部增加下面的代码

< %@ page contentType="text/html;charset=UTF-8" pageEncoding="gbk"%>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
</meta>

Filed In 学习路上 | Study | Tags: Spring, 乱码, 程序设计 | Add a Comment »

用Spring的MailSender和MailMessage发送邮件（Email）

Posted by eDWARD at 15:20

首先是配置文件：(conf/mail.xml)

<xml version="1.0" encoding="UTF-8"?>
<!--DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd" -->
<beans>
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host">
<value>smtp.abc.com</value>
</property>
<property name="javaMailProperties">
<props>
    <!-- 使用用户名和密码验证 -->
<prop key="mail.smtp.auth">true</prop>
  </props>
</property>
<property name="username">
  <value>username</value>
</property>
<property name="password">
  <value>password</value>
</property>
</bean>

<!-- 发送信息对象，可以在发送前设置值 -->
<bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
<property name="to">
  <value>to@email.com</value>
</property>
<property name="from">
  <value>from@email.com</value>
</property>
<property name="subject">
  <!-- Email 标题 -->
  <value>A Spring Mail sender</value>
</property>
</bean>

<!-- 发送邮件的类 -->
<bean id="senderMail" class="e.mail.SenderMail">
<property name="mailMessage">
  <ref bean="mailMessage"/>
</property>
<property name="mailSender">
  <ref bean="mailSender"/>
</property>
</bean>
</beans><beans>
</beans></xml>

发送邮件的类：

package e.mail;

import org.springframework.mail.MailException;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

public class SenderMail {
  private MailSender mailSender;
  private SimpleMailMessage mailMessage;

  public SenderMail() {

  }

  public SimpleMailMessage getMailMessage() {
    return mailMessage;
  }
  public void setMailMessage(SimpleMailMessage mailMessage) {
    this.mailMessage = mailMessage;
  }
  public MailSender getMailSender() {
    return mailSender;
  }
  public void setMailSender(MailSender mailSender) {
    this.mailSender = mailSender;
  }

  public void sendMail() {
    SimpleMailMessage message = new SimpleMailMessage(mailMessage);
    //set context,
    message.setText("this is a test");

    try {
      mailSender.send(message);
    } catch (MailException e) {
      // TODO Auto-generated catch block
      System.out.println("fail");
      e.printStackTrace();
    }
  }
}

测试发送类：

package e.mail.test;

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

public class TestSenderMail {

  /**
   * @param args
   */
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext(
        "conf/mail.xml");

    SenderMail sender = (SenderMail) context
        .getBean("senderMail");
    sender.sendMail();
  }
}

Filed In 学习路上 | Study | Tags: Email, Spring, 程序设计 | Add a Comment »

Hibernate处理clob和oracle sequence的备忘录

Posted by eDWARD at 17:30

Hibernate处理clob类型的字段

方法一

字段类型为java.sql.Clob。dataobject & xdoclet：

private Clob colbField;

/**
* @hibernate.property column="CLOBFIELD" type="Clob"
*/
public Clob getColbField() {
  return this.colbField;
}
public void setColbField(String colbField) {
  this.colbField = Hibernate.createClob(colbField);
}

获取Clob
CLob clob = xxx.getColbField();
String str = clob.getSubString(1,(int)clob.length());

hbm.xml：

<property name="colbField"
 type="java.sql.Clob"
 update="true"
 insert="true"
 column="CLOBFIELD"
/>

方法二

DataObject中的数据成员类型为String，映射的数据库字段类型为org.springframework.orm.hibernate.support.ClobStringType
Xdoclet：

private String colbField;

/**
* @hibernate.property column="ClobField" type="ClobStringType"
*/
public String getColbField() {
  return this.colbField;
}
public void setColbField(String colbField) {
  this.colbField = colbField;
}

hbm.xml：

<property name="servicePerson"
 type="org.springframework.orm.hibernate.support.ClobStringType"
 update="true"
 insert="true"
 column="SERVICEPERSON"
/>

如果使用spring的这个clob类型就需要在applicationContext.xml中的sessionFactory里修改如下配置

<!-- Hibernate -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
  <value>classpath:hibernate.cfg.xml</value>
 </property>
<property name="lobHandler">
  <ref local="oracleLobHandler" />
 </property>
</bean>

<bean id="oracleLobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler" lazy-init="true">
<property name="nativeJdbcExtractor">
  <ref local="nativeJdbcExtractor" />
 </property>
</bean>

<bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" lazy-init="true" />

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
  <ref local="sessionFactory" />
 </property>
</bean>

这两只方式在采用oracle thin方式连接的情况下都有传输限制，解决方法是采用oci连接方式(jdbc:oracle:oci10:@sid)

Hibernate处理oracle sequence

Xdoclet：

/**
* @hibernate.id column="ID" generator-class="sequence"
* @hibernate.generator-param name="sequence" value="SEQ_XXXX"
*/

hbm.xml：

<id name="id"
 column="ID"
 type="java.lang.Long"
 unsaved-value="null"
>
 <generator class="sequence">
<param name="sequence">SEQ_XXXX</param>
 </generator>
</id>

前提是要提供SEQ：）

Filed In 学习路上 | Study | Tags: 程序设计 | Add a Comment »