有个业务需求，关于GPS、GIS、IC卡，公交车，请推荐下哪些产品比较好。

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

简介

实战一 , 实战二 介绍了ActiveMQ的基本概念和配置方式.

本篇将通过一个实例介绍使用spring发送,消费topic, queue类型消息的方法. 不懂topic和queue的google 之.

如图示, TOPIC和QUEUE分别代表一个topic和一个queue消息通道.

1. TopicMessageProducer向topic发送消息, TopicConsumerA和TopicConsumerB则从topic消费消息.
2. QueueMessageProducer向Queue发送消息, QueueConsumer从Queue中消费消息

Spring整合JMS

就像对orm, web的支持一样, spring同样支持jms, 为整合jms到已有的项目提供了很多便利的方法. 本篇主要讲实战, 是所以先从配置开始, spring配置jms基本上需要8个部分.

1. ConnectionFactory. 和jms服务器的连接, 可以是外部的jms server, 也可以使用embedded ActiveMQ Broker.
2. Destination. 有topic和queue两种方式.
3. JmsTemplate. spring提供的jms模板.
4. MessageConverter. 消息转换器.
5. MessageProducer. 消息生产者.
6. MessageConsumer. 消息消费者.
7. MessageListener. 消息监听器
8. MessageListenerContainer. 消息监听容器

下面以实例的方式介绍上面8个部分.

1. ConnectionFactory

<amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost" />

 brokerURL是指要连接的activeMQ server的地址, activeMQ提供了多种brokerURL, 集体可参见文档.一般我们使用嵌套的ActiveMQ server. 配置如下, 这个配置使用消息的存储机制, 服务器重启也不会丢失消息.

<!--  embedded ActiveMQ Broker -->
	<amq:broker useJmx="false" persistent="true">
		<amq:persistenceAdapter>
			<amq:amqPersistenceAdapter directory="d:/amq"/>
		</amq:persistenceAdapter>
		<amq:transportConnectors>
			<amq:transportConnector uri="tcp://localhost:0" />
		</amq:transportConnectors>
	</amq:broker>

 2. Destination

 在实例中我们使用了两种destination

<!--  ActiveMQ destinations  -->
<!--  使用topic方式-->
<amq:topic name="TOPIC" physicalName="JMS-TEST-TOPIC" />
<!--  使用Queue方式-->
<amq:queue name="QUEUE" physicalName="JMS-TEST-QUEUE" />

 3. 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="jmsConnectionFactory" />
			</bean>
		</property>
		<!-- custom MessageConverter -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

  4. MessageConverter

   MessageConverter实现的是org.springframework.jms.support.converter.MessageConverter接口, 提供消息的转换功能. DefaultMessageConverter的实现见附件.

<bean id="defaultMessageConverter" class="com.andyao.activemq.DefaultMessageConverter" />

  5. MessageProducer

   实例拥有两个消息生产者, 消息生产者都是POJO, 实现见附件.

<!-- POJO which send Message uses  Spring JmsTemplate -->
	<bean id="topicMessageProducer" class="com.andyao.activemq.TopicMessageProducer">
		<property name="template" ref="jmsTemplate" />
		<property name="destination" ref="TOPIC" />
	</bean>
	<bean id="queueMessageProducer" class="com.andyao.activemq.QueuMessageProducer">
		<property name="template" ref="jmsTemplate" />
		<property name="destination" ref="QUEUE" />
	</bean>

 6. MessageConsumer

 TOPIC通道有两个消息消费者, QUEUE有一个消息消费者

<!--  Message Driven POJO (MDP) -->
    <!-- consumer1 for topic a -->
    <bean id="topicConsumerA" class="com.andyao.activemq.TopicConsumerA" />
    <!-- consumer2 for topic a -->
    <bean id="topicConsumerB" class="com.andyao.activemq.TopicConsumerB" />
    <!-- consumer for queue -->
    <bean id="queueConsumer" class="com.andyao.activemq.QueueConsumer" />

  7. MessageListener

每一个消息消费者都对应一个MessageListener

<bean id="topicListenerA" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="topicConsumerA" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

	<bean id="topicListenerB" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="topicConsumerB" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

    <bean id="queueListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
		<constructor-arg ref="queueConsumer" />
		<!--  may be other method -->
		<property name="defaultListenerMethod" value="receive" />
		<!-- custom MessageConverter define -->
		<property name="messageConverter" ref="defaultMessageConverter" />
	</bean>

 8. MessageListenerContainer

 有几个MessageListener既有几个MessageListenerContainer

<bean id="topicListenerContainerA" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="TOPIC" />
		<property name="messageListener" ref="topicListenerA" />
	</bean>

    <bean id="topicListenerContainerB" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="TOPIC" />
		<property name="messageListener" ref="topicListenerB" />
	</bean>
    
    <bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
		<property name="connectionFactory" ref="jmsConnectionFactory" />
		<property name="destination" ref="QUEUE" />
		<property name="messageListener" ref="queueListener" />
	</bean>

  Summary

写spring配置文件的时候, 要把MessageProducer, MessageConsumer,MessageListener,MessageListenerContainer几个地方弄清楚:

1. 可以有一个或者多个消息生产者向同一个destination发送消息.
2. queue类型的只能有一个消息消费者.
3. topic类型的可以有多个消息消费者.
4. 每个消费者对应一个MessageListener和一个MessageListenerContainer.

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

      在把Oracle查询转换为SQL Server的时候要特别当心一些不容易注意到的问题。我们知道，T-SQL是SQL Server的语言引擎，而Oracle的语言引擎却是PLSQL.这两种查询语言都对
　　ANSI SQL-92标准进行了扩展以提供额外的支持力度。你所创建的应用程序几乎都要用到这些补充特性。本文就对最常用的、非标准的Oracle扩展进行了说明，同时还要介绍下如何
　　对这些扩展进行转化以用在SQL Server环境下。

　　列的选择

　　用PLSQL执行数据查询的时候，FROM子句是必须的，这同SQL Server的要求是一样的。 SELECT语句必须选择针对的数据表。在Oracle数据库内有一种特殊的表DUAL.DUAL表由
　　Oracle连同数据字典一同创建，所有的用户都可以用名称DUAL访问该表。这个表里只有一列DUMMY，该列定义为VARCHAR2（1）类型，有一行值X.
　　从DUAL表选择数据常被用来通过SELECT语句计算常数表达式，由于DUAL只有一行数据，所以常数只返回一次。

　　Oracle下的DUAL查询如下所示：
　　SELECT ‘x’ FROM dual
　　而对等的SQL Server查询则是下面这个样子：
　　SELECT ‘x’
　　连接
　　Oracle用|| 符号作为连接符，而SQL Server的连接符是加号：+ .
　　Oracle查询如下所示：
　　Select ‘Name’ || ‘Last Name’
　　From tableName
　　对应的SQL Server查询如下所示：
　　Select ‘Name’ + ‘Last Name’
　　数字取舍
　　Oracle数据库内有一个TRUNC函数，该函数返回m位十进制数的n位；如果省略m则n就是0位。m的值可以为负，表示截去小数点左边m位数字。
　　在SQL Server下可以用Round或者Floor.

　　以下是Oracle查询：
　　SELECT TRUNC（15.79，1） "Truncate" FROM DUAL；

　　下面是同类查询的SQL Server版本：

　　SELECT ROUND（15.79， 0） rounded ，
　　ROUND（15.79， 0，1） truncated
　　SELECT FLOOR（ROUND（15.79， 0）），
　　FLOOR（ROUND（15.79， 0，1） ）
　　在把Oracle查询转换为SQL Server的时候要特别当心一些不容易注意到的问题。我们知道，T-SQL是SQL Server的语言引擎，而Oracle的语言引擎却是PLSQL.这两种查询语言都对
　　ANSI SQL-92标准进行了扩展以提供额外的支持力度。你所创建的应用程序几乎都要用到这些补充特性。本文就对最常用的、非标准的Oracle扩展进行了说明，同时还要介绍下如何
　　对这些扩展进行转化以用在SQL Server环境下。

　　列的选择

　　用PLSQL执行数据查询的时候，FROM子句是必须的，这同SQL Server的要求是一样的。 SELECT语句必须选择针对的数据表。在Oracle数据库内有一种特殊的表DUAL.DUAL表由
　　Oracle连同数据字典一同创建，所有的用户都可以用名称DUAL访问该表。这个表里只有一列DUMMY，该列定义为VARCHAR2（1）类型，有一行值X.
　　从DUAL表选择数据常被用来通过SELECT语句计算常数表达式，由于DUAL只有一行数据，所以常数只返回一次。

　　Oracle下的DUAL查询如下所示：
　　SELECT ‘x’ FROM dual
　　而对等的SQL Server查询则是下面这个样子：
　　SELECT ‘x’
　　连接
　　Oracle用|| 符号作为连接符，而SQL Server的连接符是加号：+ .

　　Oracle查询如下所示：
　　Select ‘Name’ || ‘Last Name’
　　From tableName
　　对应的SQL Server查询如下所示：
　　Select ‘Name’ + ‘Last Name’
　　数字取舍
　　Oracle数据库内有一个TRUNC函数，该函数返回m位十进制数的n位；如果省略m则n就是0位。m的值可以为负，表示截去小数点左边m位数字。
　　在SQL Server下可以用Round或者Floor.

　　以下是Oracle查询：
　　SELECT TRUNC（15.79，1） "Truncate" FROM DUAL；

　　下面是同类查询的SQL Server版本：
　　SELECT ROUND（15.79， 0） rounded ，
　　ROUND（15.79， 0，1） truncated
　　SELECT FLOOR（ROUND（15.79， 0）），
　　FLOOR（ROUND（15.79， 0，1） ）

　　数字转换
　　Oracle的TO_CHAR函数可以把n位NUMBER数据类型转换为VARCHAR2 数据类型，同时采用可选的数字格式。
　　SQL Server则通过STR函数返回数字转换之后的字符数据。不过，该函数不具方便的Format参数。

　　Oracle查询如下：
　　SELECT to_char（123.45 ，99999999999999） from tab
　　SELECT to_char（EXPIRY_DATE，'DDMONYYYY'） from tab

　　以下是SQL Server版本的查询：
　　SELECT STR（123.45， 14）
　　SELECT STR（round（123.455 ， 2），12，2）
　　SELECT CAST（REPLACE（（CONVERT（varchar（12） ，
　　EXPIRYDATE， 106 ）），' ' ， ''） as varchar（9））
　　LENGTH和LEN

　　以下是Oracle的查询：
　　SELECT LENGTH（'SQLMAG'）
　　"Length in characters" FROM DUAL；
　　以上查询在SQL Server下是这样写的：
　　SELECT LEN（'SQLMAG'） "Length in characters"

　　日期

　　Oracle取得日期和采用如下方式：
　　SYSDATE
　　SQL Server则是这样的：
　　GETDATE（）
　　你可以用各种语法操作日期。
　　以下的代码对Oracle日期

　　值中的月份进行了格式调整（返回日期再加上n月）：
　　Select add_months（sysdate，12） from dual

　　SQL Server则是如下完成同等功能的：
　　Select dateadd（mm，12，getdate（））
　　数据的减法也不同。以下代码在Oracle中直接
　　对数据进行减法操作：
　　SELECT sysdate -add_months（sysdate，12） FROM dual
　　SQL Server则是这样做的：
　　SELECT datediff（dd， GetDate（），dateadd（mm，12，getdate（）））

　　

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

      首先，我认为秋季9-11月份是个适宜找工作的时节，尽管不如金三银四，但秋高气爽的时节，很多HR也会冒出来招人兼旅游，找工作大家最关心的还是薪资问题，前面有个赛工资的帖子，我个人认为并没有参考价值，有报1w的飘过的，有报2k爬过的，最后得出的结论是：工资高的高，低调低，别无他物。

      另外多少还有点误导别人，比如有的刚毕业就有拿近万的，最后才知道原来是搞电的。所以我认为大家要工资的时候还是要实际点，异常工作那么些年自曝工资8k，T1 readonly也自曝自己是5k+，尽管是基本工资，但多少可以说明其实IT的行情并没有想象的那么好，注意，这里基于要一个前提，特例除外，比如一个10来年外企工作经验的人的薪水对大多人并没有参考价值，我们最好只谈些普遍的情况。

      一个HR招人的时候更喜欢有个直观的印象，我想最好有个分值来参考，比只发个干巴巴的简历要直观，而且很多HR也没有耐心看太长的简历，总之自己给自己打个分再去和HR谈比较好，那么要打这个分得有个参考，以下是我杜撰的一个标准（试用于web开发 企业开发）：

这里只举java或ruby的中的某几个例子，其他技术类推

60 分的人：会hibernate增删改查，会用sql做基本的数据库操作，做过struts+spring+hibernate的demo ，工作经验0+

70分的人：会用div+css布局，熟练struts的使用，会用spring的事务，用过hibernate的缓存机制，会Oracle的基本操作，确实做过真实的项目，当然不必是商业项目，可以是自己做的，但确保完整性和一定的规模，不只是登录和注册。

80分的人：参与设计开发过2+真实的商业项目，可以独立解决实际的问题，比如单点登录、系统集成、restful应用、rails性能优化……，研究过一定的开源项目的代码。

90分的人：首先保证3+工作经验，作为核心参与过3+（至少一个大项目）个真实的项目，认为自己肯定值90分以上的人。

100分的人：暂不考虑。

以上只是简单举个例子（只能说到这个份上），各位不要钻牛角尖，知道那个意思就可以了。

举个无废话简历例子先

 70分  期望长三角地区 java开发  4-5k

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

我想这个问题好多人都遇到过吧 麻烦指点一下哈。很急

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

def open_flash_chart_object(width, height, url, use_swfobject=true, base="/")
  url      = CGI::escape(url)
  # need something that will not be repeated on the same request
  # need the gsub at the end to first get the last newline (which could simply be done with chomp)
  # and second get the newlines in the middle of the encoded string
  special_hash = Base64.encode64(Time.now.to_f.to_s + url.to_s).gsub(/\n/,"")
  obj_id   = "chart_#{special_hash}"  # some sequencing without all the work of tracking it
  div_name = "flash_content_#{special_hash}"
  protocol = "http" # !request.nil? ? request.env["HTTPS"] || "http" : "http"

  return %[
    <div id="#{div_name}"></div>
  (以下省略部分代码)
end

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

希望这篇文章能够对那些正在或即将开发自己团队的J2EE应用快速开发平台（工作流＋代码生成器）的个人或公司能有所启发！    

      像EOS这样动辄几十上百万的平台不是每个公司都愿意花钱去买的！因此构建一套穷人级的企业快速开发平台成了很多团队的首选，而对于小团队来说，构建一套自己可以维护的开发平台才是最重要的。下面，我将以我的平台的开发过程为例来详细解析这个过程！  

“如果能把项目中大量的代码编写工作变得轻松，是多好的一件事!  "

        在使用了AppFuse之后，我有个想法，能不能利用velocity这个优秀的模板引擎，用一种更加直观的模式，把开发项目中的重复代码让它自动生成， 生成之后的基础代码，按照实际的需求稍作修改便可以运行，极大的提高工作效率。这样的话，程序员就可以从大量的重复劳动中解放出来，将精力更多的投入到业 务分析及学习中。

        这个想法一直在我的脑海里横亘不去，尤其在做了大量的重复模块后，深刻体会了重复Coding的那种浪费生命的痛苦后，这种冲动尤为强烈。

         离开旧公司，到了新公司之后，由于职位和公司定位的不同，让我有时间开始把快速开发平台和自动代码生成器的开发真正的摆上开发日程上了。

          第一步 ，自动代码生成器生成 的是业务模块，那么底层必须有一套框架能够为它提供支撑，而且这套基础框架要足够灵活，并且和单个模块的耦合性要比较弱。要解耦模块之间的联系，势必要用 到MVC分层设计。感谢Java的开放性，使它有这么许许多多的MVC框架可以使用。我采用的当然是目前最流行的 SSH（Struts＋Spring＋Hibernate）的组合（以前项目一直在用，也有些成熟的积累），花了三个月的时间，通过一个项目的实际应用来 使这个框架基本成型。其目前功能包括：

        1：灵活完善的权限管理功能（包括用户管理、角色管理、组织机构管理、资源管理、资源角色映射管理...）。原来计划采用开源的JGuard来托管这部分 的功能，因为一些特殊的原因放弃了（考虑要和工作流引擎的权限部分做集成），只采用了其权限管理的一些设计思想。

        2：基于Spring的AOP实现的日志和权限管理（通过Spring的代理也将Struts的Action托管了，使的对Action的调用也能被 AOP侦测到），这样对每个功能的调用，如果需要日志纪录的话，之间将其配置到Spring的配置文件中就可以了。

        3：UI上实现了类似.NET的Validation验证，这点很重要，想必大家都深刻体会到利用JavaScript或Struts的验证机制来实现前端页面数据验证的痛苦了吧：），我们实现的功能如下图所示：

        4、多套UI风格样式。这个不是很必须，但是作为一套成功的系统，良好的用户体验也是必不可少的。

        5、支撑模块：报表引擎（基于JasperReport实现的B/S版本报表），流程引擎（其实就我个人来看，工作流引擎才是这套系统的灵魂 ，有了它，所有流程性应用包括表单、业务流、权限都可以通过配置并结合Beanshell脚本来获得 ，但由于我们集成的是一套反编译重构的商用流程引擎系统，在这里就不再详细描述了 ，呵呵：），有盗版之嫌啊）,以下是我们报表和流程设计器的一些截图：

工作流引擎截图

报表截图

        6、i18n的支持，由于我们有很多国外的客户，这块是必须的。

有了这个基础支撑平台之后，就可以开始着手开放我们的代码生成器了。

        第二步 ：开发代码生成器。 AppFuse基于Ant的自动代码生成模式让我深恶痛绝，究其原因，一句话－－“不够人性化”，我们做的首先必须考虑可用性，因此决定采用可视化的UI 模式。由于我用的是NetBean编辑器，做可视化的Swing开发不成问题（这点要感谢SUN啊，出了个和VB一样简单的IDE）。我实现的代码生成器 的界面如下：

怎么样？是不是够傻瓜化啊？呵呵，是个人都能用啊！

       从上面大家可以看到，我们这个代码生成器和Hibernate的POJO对象生成工具类似，也是基于数据库的模型来生成代码的，不同的是，我们生成的代码 范围更广，不仅包括了POJO对象暨相应的hbm.xml文件，另外还包括相应的DAO（Server层）、相应的Action、Form类、相关的 JSP文件（list页面、edit页面、Excel导出页面等等）、资源文件及相关的Struts和Spring的配置子文件（Struts和 Spring均支撑将配置拆分成多个配置，我们利用这种特性来减低模块之间的耦合性。）

        至于数据库模型的获得，可以利用JDBC的MetaData（元数据模型） 的功能来获得，我们目前维护了表的完整的主键、外键关系（父子表）

 第三步：配置模板。有了可视化的数据库表映射模型，也获得了数据库表及其主外键关系的详细信息，接下来当然是根据这些信息来生成代码了。这里我们用了强大的Velocity模板 技术，这样不仅可以灵活的处理复杂的表映射对象之间的关系，也能够灵活的进行变更升级。而且我们能够通过所获得的数据库模型，在页面上自动实现基于Javascript的数据验证“非空验证、字符长度验证、数字验证，日期验证”。

          呵呵，通过以上3个步骤的工作，我们的基础开发平台和自动代码生成器就大功告成了！目前我们生成的代码可以直接编译通过，通过简单的系统配置后，可以直接在服务器上跑！ 由于模板种类多，而且模板中自动实现的代码功能已经非常完善了，所以一些特殊的业务需求只需要在自动生成的代码基础上做简单修改就可以了！

         基础开发平台和代码生成器投入使用后，对我们项目开发的资源投入的改善是非常明细的，目前基于基础平台和代码生成器的配合，我们已经做了6、7个系统了，平均每个系统的 开发时间至少要比以前节约40％，有的项目甚至达到了80％以上（我们最高的一天，处理了40多个表的增、删、该、查的功能，及中文本地化）。而且，另外 很重要的一点，生成的代码无形中统一了程序员的设计风格，我们通过这套开发机制，能够最大限度的保证我们开发的系统质量，保证模块可以在不同系统之间的自 由迁移，最大限度的实现复用！在项目开发中节省出来的大量时间，也让我们可以去研究更多的开源中间件和系统，来增强我们的基础平台，从而形成一个良性的循 环！

 我们做了多套模板，能够针对单表操作，及父子表操作来自由组合搭配。以下就是我们系统的一些功能截图，除了中文化之外，基本上没有修改：

单表操作：

父子表关联操作：

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public class Category {
  private Long id;
  private String name; //类别名称

  //Other code omitted
}

public class Product {
  private Long id;
  private String name;       //商品名称
  private Category category; //商品类别
  private Date expDate;      //有效期
  private Float price;       //单价

  //Other code omitted
}

	public List<Product> getProducts(Product product) {
		final Example exampleProduct =
		  Example.create(product).
		    enableLike(MatchMode.ANYWHERE).
                    excludeZeroes();

		return (List<Product>) getHibernateTemplate().execute(
		  new HibernateCallback() {
		    public Object doInHibernate(Session session) throws HibernateException {
		    	Criteria crit =
		    	  session.createCriteria(Product.class).
		    	  add(exampleProduct);
		    	return crit.list();
		    }
		  }
		);
	}

Category category = new Category();
category.setName("xyz");
Product product = new Product();
product.setCategory(category);

List<Product> products = getProducts(product);

//Hibernate的原版Example
//如果属性类型是关联的实体，则忽略
	private boolean isPropertyIncluded(Object value, String name, Type type) {
		return !excludedProperties.contains(name) &&
			!type.isAssociationType() &&
			selector.include(value, name, type);
	}

//改版的AssociationExample
  private boolean includeAssociations = true;

  public boolean isIncludeAssociations()
  {
    return includeAssociations;
  }

  public void setIncludeAssociations(boolean includeAssociations)
  {
    this.includeAssociations = includeAssociations;
  }

//如果属性类型是关联的实体，且该关联是一对一或多对一，且includeAssociations为true，则包括该属性
  private boolean isPropertyIncluded(Object value, String name, Type type) {
    return
      !excludedProperties.contains(name) &&
      selector.include(value, name, type) &&
      (!type.isAssociationType() ||
        (type.isAssociationType() &&
          includeAssociations &&
          !type.isCollectionType()));
  }

//Hibernate原版的Example
  protected void appendPropertyCondition(
    String propertyName,
    Object propertyValue,
    Criteria criteria,
    CriteriaQuery cq,
    StringBuffer buf)
  throws HibernateException {
    Criterion crit;
    if ( propertyValue!=null ) {
//当属性值不为空时，如果是字符串且指定为模糊查询，则使用模糊查询，否则使用等值比较
      boolean isString = propertyValue instanceof String;
      SimpleExpression se = ( isLikeEnabled && isString ) ?
        Restrictions.like(propertyName, propertyValue) :
        Restrictions.eq(propertyName, propertyValue);
      crit = ( isIgnoreCaseEnabled && isString ) ?
        se.ignoreCase() : se;
    }
    else {
      crit = Restrictions.isNull(propertyName);
    }
    String critCondition = crit.toSqlString(criteria, cq);
    if ( buf.length()>1 && critCondition.trim().length()>0 ) buf.append(" and ");
    buf.append(critCondition);
  }


//增强后的EnhancedExample
  private static final RestrictionHolder holder = new DefaultRestrictionHolder();

  /**
   * Restriction strategy definitions
   */
  public static enum RestrictionStrategy {eq, ne, gt, lt, ge, le}

  /**
   * Restriction strategy holder for the query criteria
   */
  public static interface RestrictionHolder {
  	/**
  	 * Set a restriction strategy for a POJO's property
  	 */
    public RestrictionHolder set(String propertyName, RestrictionStrategy strategy);

    /**
     * Get the restriction strategy of the property
     */
    public RestrictionStrategy get(String propertyName);
  }

  static final class DefaultRestrictionHolder implements RestrictionHolder {
		private Map<String, RestrictionStrategy> strategies = new HashMap<String, RestrictionStrategy>();

    public RestrictionHolder set(String propertyName, RestrictionStrategy strategy) {
      strategies.put(propertyName, strategy);
      return this;
    }

    public RestrictionStrategy get(String propertyName) {
      return strategies.get(propertyName);
    }
  }

  /**
   * Get the restriction strategy holder
   */
  public RestrictionHolder getRestrictionHolder() {
    return holder;
  }

  protected void appendPropertyCondition(
    String propertyName,
    Object propertyValue,
    Criteria criteria,
    CriteriaQuery cq,
    StringBuffer buf)
  throws HibernateException {
    Criterion crit;
    if ( propertyValue!=null ) {
//当属性值不为空时，如果为该属性指定了比较条件，则使用指定的比较条件
      RestrictionStrategy strategy = holder.get(propertyName);
      if ( strategy != null ) {
  	switch(strategy) {
    	//case eq: crit = Restrictions.eq(propertyName, propertyValue);
    	case ne: crit = Restrictions.ne(propertyName, propertyValue); break;
    	case gt: crit = Restrictions.gt(propertyName, propertyValue); break;
    	case lt: crit = Restrictions.lt(propertyName, propertyValue); break;
    	case ge: crit = Restrictions.ge(propertyName, propertyValue); break;
    	case le: crit = Restrictions.le(propertyName, propertyValue); break;
    	default: crit = Restrictions.eq(propertyName, propertyValue);
        };
      }
      else {
//否则使用默认的比较条件：如果是字符串且指定为模糊查询，则使用模糊查询，否则使用等值比较
	boolean isString = propertyValue instanceof String;
	SimpleExpression se = ( isLikeEnabled && isString ) ?
	  Restrictions.like(propertyName, propertyValue) :
	  Restrictions.eq(propertyName, propertyValue);
	crit = ( isIgnoreCaseEnabled && isString ) ?
	  se.ignoreCase() : se;
      }
    }
    else {
      crit = Restrictions.isNull(propertyName);
    }
    String critCondition = crit.toSqlString(criteria, cq);
    if ( buf.length()>1 && critCondition.trim().length()>0 ) buf.append(" and ");
    buf.append(critCondition);
  }

	public List<Product> getProducts(Product product) {
		//改用EnhancedExample来允许关联对象的条件查询
		final EnhancedExample exampleProduct =
		  EnhancedExample.create(product).
		    enableLike(MatchMode.ANYWHERE).
                    excludeZeroes();
		  //指定expDate属性使用大于等于比较方法
		exampleProduct.getRestrictionHolder().
		  set("expDate", EnhancedExample.RestrictionStrategy.ge);

		return (List<Product>) getHibernateTemplate().execute(
		  new HibernateCallback() {
		    public Object doInHibernate(Session session) throws HibernateException {
		    	Criteria crit =
		    	  session.createCriteria(Product.class).
		    	  add(exampleProduct);
		    	return crit.list();
		    }
		  }
		);
	}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

原文同步发表在岁月如歌

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package bean;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;

/**
 * 邵波 QQ：343269876
 */
public class XmlParse {

 
 //解析xml文件
 
 public static void XmlParse() throws JDOMException, IOException {
  SAXBuilder builder = new SAXBuilder();
  InputStream file = new FileInputStream("src/xml/po.xml");
  Document document = builder.build(file);//获得文档对象
  Element root = document.getRootElement();//获得根节点
  List<Element> list = root.getChildren();
  for(Element e:list) {
   System.out.println("ID="+e.getAttributeValue("id"));
   System.out.println("username="+e.getChildText("username"));
   System.out.println("password="+e.getChildText("password"));
  }
 }
 
 //增
 public static void addXml() throws JDOMException, FileNotFoundException, IOException {
  SAXBuilder builder = new SAXBuilder();
  Document doc = builder.build("src/xml/po.xml");//获得文档对象
  Element root = doc.getRootElement();//获得根节点
  
  //添加新元素
  Element element = new Element("person");
  element.setAttribute("id", "3");
  Element element1 = new Element("username");
  element1.setText("zhangdaihao");
  Element element2 = new Element("password");
  element2.setText("mima");
  element.addContent(element1);
  element.addContent(element2);
  root.addContent(element);
  doc.setRootElement(root);
  
  //文件处理
  XMLOutputter out = new XMLOutputter();
  out.output(doc, new FileOutputStream("src/xml/po.xml"));
 }
 
 //根据ID值删除一个节点
 public static void deletePerson(int id) throws JDOMException, IOException {
  SAXBuilder builder = new SAXBuilder();
  InputStream file = new FileInputStream("src/xml/po.xml");
  Document doc = builder.build(file);//获得文档对象
  Element root = doc.getRootElement();//获得根节点
  List<Element> list = root.getChildren();
  for(Element e:list) {
   //获取ID值
   if(Integer.parseInt(e.getAttributeValue("id"))==id) {
    root.removeContent(e);
    break;//??
   }
  }
  
  //文件处理
  XMLOutputter out = new XMLOutputter();
  out.output(doc, new FileOutputStream("src/xml/po.xml"));
 }
 
 //根据ID值修改一个节点
 public static void updatePerson(int id) throws JDOMException, IOException {
  SAXBuilder builder = new SAXBuilder();
  InputStream file = new FileInputStream("src/xml/po.xml");
  Document doc = builder.build(file);//获得文档对象
  Element root = doc.getRootElement();//获得根节点
  List<Element> list = root.getChildren();
  for(Element e:list) {
   //获取ID值
   if(Integer.parseInt(e.getAttributeValue("id"))==id) {
    System.out.println("--------------------");
    e.getChild("username").setText("111111111");
    e.getChild("password").setText("password");
    
   }
  }
  
  //文件处理
  XMLOutputter out = new XMLOutputter();
  out.output(doc, new FileOutputStream("src/xml/po.xml"));
 }
 
 static public void main(String ars[]) throws JDOMException, IOException {
  
 // addXml();//增加XML
 // deletePerson(3);//删除XML
 // updatePerson(2);//修改XML
 // XmlParse();//解析XML
 }
}

------------------------------------------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<root>
 <person id="1">
  <username>张三</username>
  <password>123123</password>
 </person>
 <person id="2">
  <username>1111111112</username>
  <password>password2</password>
 </person>

 
</root>

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

jar说明  hibernate 3.3.0  hibernate-annotations(3.4.0.CR2)

数据库(oracle)结构

CREATE TABLE KANG_USER
(
  ID        VARCHAR2(32 BYTE)                   NOT NULL,
  USERNAME  VARCHAR2(30 BYTE),
  PASSWORD  VARCHAR2(32 BYTE),
  CITY      VARCHAR2(32 BYTE),
  ADDTIME   DATE
)

CREATE TABLE KANG_CITY
(
  ID        VARCHAR2(32 BYTE),
  CITYNAME  VARCHAR2(20 BYTE)
)

一个用户表，一个城市表，用户和城市是多对一的关系

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.NotFound;
import org.hibernate.annotations.NotFoundAction;

/**
 * @author yukang
 *
 */
@Entity
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@Table(name="KANG_USER")
public class User {
    
    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    private String id;
    
    private String userName;
    
    private String passWord;
    
    @Temporal(TemporalType.TIMESTAMP)
    private Date addTime;
    
    @ManyToOne() 
    @Cascade(value={CascadeType.PERSIST, CascadeType.MERGE}) 
    @JoinColumn(name="CITY")
    @NotFound(action=NotFoundAction.IGNORE)
    private City city;
    
    public User() {
        
    }
    
    
    /**
     * @return
     */
    public String getId() {
        return id;
    }
    
    /**
     * @param id the id to set
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * @return the userName
     */
    public String getUserName() {
        return userName;
    }


    /**
     * @param userName the userName to set
     */
    public void setUserName(String userName) {
        this.userName = userName;
    }


    /**
     * @return the passWord
     */
    public String getPassWord() {
        return passWord;
    }


    /**
     * @param passWord the passWord to set
     */
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    /**
     * @return
     */
    public Date getAddTime() {
        return addTime;
    }
    
    /**
     * @param addTime the addTime to set
     */
    public void setAddTime(Date addTime) {
        this.addTime = addTime;
    }
    
    /**
     * @return
     */
    public City getCity() {
        return city;
    }
    
    /**
     * @param city the city to set
     */
    public void setCity(City city) {
        this.city = city;
    }

   

}

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.GenericGenerator;

/**
 * @author yukang
 *
 */

@Entity
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
@Table(name="KANG_CITY")
public class City {
    
    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    private String id;
    
    private String cityName;
    
    @OneToMany(mappedBy="city",fetch=FetchType.EAGER)
    @Cascade(value={CascadeType.DELETE_ORPHAN})//级联删除
    private Set<User> userSet;
    
    public City() {
        
    }

    /**
     * @return the id
     */
    public String getId() {
        return id;
    }

    /**
     * @param id the id to set
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * @return the cityName
     */
    public String getCityName() {
        return cityName;
    }

    /**
     * @param cityName the cityName to set
     */
    public void setCityName(String cityName) {
        this.cityName = cityName;
    }

    /**
     * @return the userSet
     */
    public Set<User> getUserSet() {
        return userSet;
    }

    public void addUser(User user) {
        if ( userSet == null ) {
            userSet = new HashSet<User>();
        }
        user.setCity(this);
        userSet.add( user );
    }

}

Spring中的sessionFactory的class要更改为org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean这个class

hibernate.cfg.xml要把User和City这两个class加上去

<mapping class="com.xxxx.domain.pojo.User"/>
 <mapping class="com.xxxx.domain.pojo.City"/>

其他的地方以前怎么写的，现在不要改动，例子较简单，代码不做说明了

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

好久没写了，以前也只在weblogic下写过，凭记忆写了一个例子，虽然很小，但是为了调这个东西，走了很多弯路，呵呵，写出来分享一下

1.编写一个主接口，创建组件接口的接口
package com.EJB.interfaces;

public interface HelloWorldHome extends javax.ejb.EJBHome{
 HelloWorld create() throws java.rmi.RemoteException,javax.ejb.CreateException;
}
2.编写一个组件接口，被客户端使用的接口
package com.EJB.interfaces;

public interface HelloWorld extends javax.ejb.EJBObject{

 public String getHello() throws java.rmi.RemoteException;
}
3.编写组件接口的实现，即具体的逻辑
package com.EJB.impl;

import java.rmi.RemoteException;

import javax.ejb.EJBException;
import javax.ejb.SessionContext;

public class HelloWorldImpl implements javax.ejb.SessionBean{

 /*hello方法是实际的业务逻辑，它可以在客户端显示“hello,world”这个字符串*/
 public String getHello() throws EJBException, RemoteException {
  System.out.println("getHello()");
  return "hello,worldasdfasdfasdf";
 }

 public void ejbActivate() throws EJBException, RemoteException {
  // TODO Auto-generated method stub
  
 }

 public void ejbPassivate() throws EJBException, RemoteException {
  // TODO Auto-generated method stub
  
 }

 public void ejbRemove() throws EJBException, RemoteException {
  // TODO Auto-generated method stub