博客园_隐锋的BLOG

Java与Flex通信[转]

2011-12-16T04:14:00Z

提到通信就得面临两个问题，一是通信协议的选择，二是数据协议的定义。通信协议耳熟能详的就有好几种，TCP，UDP，HTTP，FTP等等。数据协议是一种数据交换的格式，像jason,xml,amf3,google protocol都可以用作数据协议，你也可以自己根据通信的效率，安全等因素来定义自己的数据协议。

通信系统的开发是一项很复杂的工作，不要以为往发服务端发一个Hello World！就认为完全掌握了通信系统的开发。概括来说要开发一个健壮的通信系统，必须从这几个方面来着手。

　　一，通信粘包的处理

　　这里包的概念是逻辑上的数据包，也就是我们发送的一个完整业务消息包，粘包情况有两种，一种是粘在一起的包都是完整的数据包，另一种情况是粘在一起的包有不完整的包。不是所有的粘包现象都需要处理，若传输的数据为不带结构的连续流数据（如文件传输），则不必把粘连的包分开（简称分包）。但在实际工程应用中，传输的数据一般为带结构的数据，这时就需要做分包处理。

　　为了避免粘包现象，可采取以下几种措施。一是对于发送方引起的粘包现象，用户可通过编程设置来避免，TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满；二是对于接收方引起的粘包，则可通过优化程序设计、精简接收进程工作量、提高接收进程优先级等措施，使其及时接收数据，从而尽量避免出现粘包现象；三是由接收方控制，将一包数据按结构字段，人为控制分多次接收，然后合并，通过这种手段来避免粘包。

　　以上提到的三种措施，都有其不足之处。总的来说降低了通信系统的吞吐量。我们可以自己设计一个分包算法来处理粘包的问题，该算法的实现是这样的:

当有数据到达时，将数据压入程序缓冲区。
循环处理缓冲区，如果缓冲区长度大于包头长度，则取出长度信息n，否则跳出循环，如果缓冲区的长度大于n，则从缓冲区取出一个完整包进行处理，否则跳出循环。

如果你是Java的爱好都可以参考一下Mina和netty2的实现，像Mina和Netty2都提供了粘包处理类可供使用，像Mina的CumulativeProtocolDecoder类,Netty2的LengthFieldBasedFrameDecoder。

　　二，数据协议选择

　　现在已经有很多数据协议可供我们选择，像jason,xml,amf3,google protocol等等，这些协议相应的语言都有API来对自身数据做协议处理，我们选择协标准无非就是效率和大小，这里每个人可以根据实际的应用环境选择适合的数据协议。

　　三，网络系统的安全性

　　网络安全是一个永远的话题，对通信数据加密一般常RSA对byte流加密，FLOOD验证，IP黑名单验证都是必须考虑到的。

　　以上是做网络开发必须了解的一些基础知识，在这里我们使用一个具体的实例来加深一下理解，Java与Flex使用AMF3数据协议通信。做过网络开发的一般都会知道套接字（SOCKET），很多语言都会通SOCKET来提供对网络操作的API，Java的提供的NIO SOCKET是一个高效的异步通信API，当然可以在这个基础上来开发我们的网络应用，但这种Native API需要我们花很多精力来处理网络通信的细节，消弱了我们对业务的关心。为我们开发带来很多不便性，幸好Java有很多现成的NIO SOCKET框架可供使用，像Mina，Netty2，xSocket等等，这些框架处理了很多底层的通信问题，提供了一些易用的API以供使用。在这个实例中我们使用Netty2来做通信框架。

　　定义消息包，消息包有定长包和不定长包，不定长包无非就是要在消息包中加入长度信息，以对收到的网络字节流进行分界。消息包的定义如下

　　定义AMF3数据协议的编码和解码器　

1 /*
2  * @(#)AMF3Encoder.java    0.1 05/11/17
3  *
4  * Copyright 2010 QISI, Inc. All rights reserved.
5  * QISI PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7 package com.qidea.pushserver.codec;
8 import java.io.ByteArrayOutputStream;
9 import org.jboss.netty.buffer.ChannelBuffer;
10 import org.jboss.netty.buffer.ChannelBuffers;
11 import org.jboss.netty.channel.Channel;
12 import org.jboss.netty.channel.ChannelHandlerContext;
13 import org.jboss.netty.handler.codec.oneone.OneToOneEncoder;
14 import com.qidea.pushserver.Constants;
15 import com.qidea.pushserver.message.CommandMessage;
16 import com.qidea.pushserver.message.PushMessage;
17 import flex.messaging.io.SerializationContext;
18 import flex.messaging.io.amf.Amf3Output;
19 /**
20  *
21  * @author sunwei
22  * @version 2010-7-21
23  * @since JDK1.5
24  */
25 public class AMF3Encoder extends OneToOneEncoder
26 {
27     /**
28      *
29      */
30     @Override
31     protected Object encode(ChannelHandlerContext arg0, Channel arg1,
32             Object arg2) throws Exception
33     {
34         ByteArrayOutputStream stream = new ByteArrayOutputStream();
35         SerializationContext serializationContext = new SerializationContext();
36         Amf3Output amf3Output = new Amf3Output(serializationContext);
37         amf3Output.setOutputStream(stream);
38         amf3Output.writeObject(arg2);
39         byte[] objSe = stream.toByteArray();
40         if (objSe != null && objSe.length > 0)
41         {
42             ChannelBuffer buffer = ChannelBuffers.buffer(objSe.length + 8);
43             if (arg2 instanceof PushMessage)
44                 buffer.writeInt(Constants.MAGIC_NUM_PUSH_MSG);
45             else if (arg2 instanceof CommandMessage)
46                 buffer.writeInt(Constants.MAGIC_NUM_COMMAND_MSG);
47             buffer.writeInt(objSe.length);
48             buffer.writeBytes(objSe);
49             return buffer;
50         }
51         return null;
52     }
53 }

1 /*
2  * @(#)AMF3Decoder.java    0.1 05/11/17
3  *
4  * Copyright 2010 QISI, Inc. All rights reserved.
5  * QISI PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7 package com.qidea.pushserver.codec;
8 import java.io.ByteArrayInputStream;
9 import org.jboss.netty.buffer.ChannelBuffer;
10 import org.jboss.netty.channel.Channel;
11 import org.jboss.netty.channel.ChannelHandlerContext;
12 import org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder;
13 import org.slf4j.Logger;
14 import org.slf4j.LoggerFactory;
15 import flex.messaging.io.SerializationContext;
16 import flex.messaging.io.amf.Amf3Input;
17 /**
18  * amf3协议解码类
19  *
20  * @author sunwei
21  * @version 2010-7-21
22  * @since JDK1.5
23  */
24 public class AMF3Decoder extends LengthFieldBasedFrameDecoder
25 {
26     public static final Logger logger = LoggerFactory
27             .getLogger(AMF3Decoder.class);
28     /**
29      *
30      * @param maxFrameLength
31      *            包的最大大小
32      * @param lengthFieldOffset
33      *            包头信息，长度的偏移位
34      * @param lengthFieldLength
35      *            包头信息，长度位数
36      */
37     public AMF3Decoder(int maxFrameLength, int lengthFieldOffset,
38             int lengthFieldLength)
39     {
40         super(maxFrameLength, lengthFieldOffset, lengthFieldLength);
41     }
42     /**
43      *
44      * @param maxFrameLength
45      */
46     public AMF3Decoder(int maxFrameLength)
47     {
48         super(maxFrameLength, 4, 4, 0, 0);
49     }
50     /**
51      *
52      */
53     @Override
54     protected Object decode(ChannelHandlerContext ctx, Channel channel,
55             ChannelBuffer buffer) throws Exception
56     {
57         ChannelBuffer frame = (ChannelBuffer) super
58                 .decode(ctx, channel, buffer);
59         if (frame == null)
60         {
61             return null;
62         }
63         //
64         int magicNum = frame.readInt();
65         int dataLength = frame.readInt();
66         logger.info("magic num={},data length={}", magicNum, dataLength);
67         // 读AMF3字节流的内容
68         byte[] content = new byte[frame.readableBytes()];
69         frame.readBytes(content);
70         SerializationContext serializationContext = new SerializationContext();
71         Amf3Input amf3Input = new Amf3Input(serializationContext);
72         amf3Input.setInputStream(new ByteArrayInputStream(content));
73         Object message = amf3Input.readObject();
74         return message;
75     }
76 }
77

构建服务端

1 public class PushProtocolHandler extends SimpleChannelHandler
2 {
3     public static Logger log = LoggerFactory
4             .getLogger(PushProtocolHandler.class);
5     /**
6      *
7      */
8     @Override
9     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
10     {
11         if (e.getMessage() != null)
12         {
13             ChannelManager channelManager = PushServerContext
14                     .getBean(ChannelManager.class);
15             if (e.getMessage() instanceof CommandMessage)
16             {
17                 channelManager.handleMsg((CommandMessage) e.getMessage(), e
18                         .getChannel());
19             }
20             else if (e.getMessage() instanceof PushMessage)
21             {
22                 channelManager.handleMsg((PushMessage) e.getMessage(), e
23                         .getChannel());
24             }
25             else
26             {
27                 log.warn("unkown message {}", e);
28             }
29         }
30     }
31 }

1 import static org.jboss.netty.channel.Channels.*;
2 /**
3  *
4  * @author sunwei
5  * @version 2010-7-22
6  * @since JDK1.5
7  */
8 public class PushServerPipelineFactory implements ChannelPipelineFactory
9 {
10     @Override
11     public ChannelPipeline getPipeline() throws Exception
12     {
13         ChannelPipeline pipeline = pipeline();
14         // 处理日志
15         pipeline.addLast("logger", new LoggingHandler());
16         // 处理coder
17         pipeline.addLast("decoder", new AMF3Decoder(Constants.MAX_OBJECT_SIZE));
18         pipeline.addLast("encoder", new AMF3Encoder());
19         //
20         pipeline.addLast("handler", new PushProtocolHandler());
21         //
22         return pipeline;
23     }
24 }

1 public static main(String[] args)
2 {
3         // 开始NIO线程
4          ChannelFactory factory = new NioServerSocketChannelFactory(Executors
5                 .newCachedThreadPool(), Executors.newCachedThreadPool());
6         // 服务启始点
7     ServerBootstrap bootstrap = new ServerBootstrap(factory);
8     // 处理过滤器
9     bootstrap.setPipelineFactory(new PushServerPipelineFactory());
10     // 设置相关参数
11     bootstrap.setOption("child.tcpNoDelay", true);
12     // 设置相关参数
13     bootstrap.setOption("child.keepAlive", true);
14     // 绑定相关端口
15     bootstrap.bind(new InetSocketAddress(getPushPort()));
16 }

Flex客户端

1 public class FlexSocket
2 {
3
4 //发送包
5         public function send(type:int, obj:PushMessage):Boolean
6         {
7             if (_socket == null)
8             {
9                 return false;
10             }
11             //手动限制不给发送的时候用
12             if (socketState == socket_state_closed || socketState == socket_state_connecting)
13             {
14                 return false;
15             }
16             if (!_socket.connected)
17             {
18                 return false;
19             }
20             var byteArr:ByteArray=objToByteaArray(obj);
21             var msgHead:MsgHead=new MsgHead(type, byteArr.length);
22             sendMsg(msgHead.getType(), msgHead.getSize(), byteArr);
23             return true;
24         }
25
26 //接受包
27                 private function getDataHandler(e:ProgressEvent):void
28         {
29             _timeServerDead.stop();
30             _timeServerDead.reset();
31             if (_socket.bytesAvailable >= 8 && !_isReadHead)
32             {
33                 _recvPackageType=_socket.readInt();
34                 //同意关闭
35 //                if(_recvPackageType == 5)
36 //                {
37 //                    close();
38 //                }
39                 _recvPackageSize=_socket.readInt();
40                 _isReadHead=true;
41             }
42             if (_isReadHead && _socket.bytesAvailable >= _recvPackageSize)
43             {
44                 var byte:ByteArray=new ByteArray();
45                 _socket.readBytes(byte, 0, _recvPackageSize);
46                 _msgObj=byteArraytoObject(byte);
47                 //暂时用上面一种
48                 if (_recvPackageType == packageType.LOGIN_TYPE)
49                 {
50                     if (_msgObj.ret == bodyType.RECEIVE_OK)
51                     {
52                         _timerDetectSocket.start();
53                         socketState=socket_state_connected;
54                         myEventDispatch.Instence().dispatcher(bodyType.INLINE_CURRENTSOCKETSTATE);
55                     }
56                     else if (_msgObj.ret == bodyType.RECEIVE_ERROR)
57                     {
58                         close();
59                     }
60
61                 }
62                 else if (_recvPackageType == packageType.CHAT_TYPE)
63                 {
64                     myEventDispatch.Instence().dispatcher(selectEventName(_recvPackageType), _msgObj);
65                 }
66                 _recvPackageSize=0;
67                 _recvPackageType=0;
68                 _msgObj=null;
69                 _isReadHead=false;
70
71
72             }
73         }
74
75 }

复制代码

本文链接

使用 Eclipse Memory Analyzer 检测内存泄漏问题 [转]

2011-12-14T14:05:00Z

本文是关于在开发Talend RCP 过程中碰到一个内存溢出问题的解决方案。使用的检测软件为Eclipse Memory Analyzer (http://www.eclipse.org/mat/)，是一个开源免费的内存分析工具，目前为eclipse的孵化项目，也是一个eclipse RCP.

Talend一款开源的ETL软件，提供数据集成服务。基于eclipse RCP，EMF, GEF，JET等技术开发。

在Talend软件系统中，一个designer editor 是一个mulit page editor, 它的实例是MultiPageTalendEditor，其中包含两页，第一页是一个gef Editor，用来显示GEF图形；第二页是一个JavaEditor,用来显示生成的代码。如下两图所示：

经过其他工具的测试发现JavaEditor如果用在mulit page editor中，关闭后，起实例无法回收，造成内存泄漏，因为Editor是一个非常频繁使用的功能项，所以该问题非常严重。

要使用Eclipse Memory Analyzer，首先要生成dump文件。

在eclipse中配置 Preferences -> Java -> Installed JREs, 定义Jdk1.6来运行Talend.

Talend运行后，执行一下打开editor的操作，在将editor关闭，这样虚拟机中保存了相应的堆栈信息。其实也就是执行一下你认为会产生内存泄漏的操作。

运行jdk1.6 bin 目录下的jconsole.exe，运行后如下图所示，选择连接到运行的Talend。

选择 Mbean -> com.sun.management -> HotSpotDiagnos -> Operations -> dumpHeap

在参数p0中填写保存dump文件的路径，例如f:/my.hprof, 文件的后缀名要为hprof。

点击dumpHeap按钮生成dump文件。

打开Eclipse Memory Analyzer, 在菜单File 下，选择打开刚才生成的dump文件。如下图：

在第一行的filter中填写需要检查的类名，这里我要检查的类为TalendJavaEditor。在如下图所示的上下文菜单中选择 List objects -> with incoming references, 查看保存了TalendJavaEditor 实例的引用。

在如下图所示的上下文菜单中选择 Path To GC Roots -> exclude weak/soft references, 过滤掉弱引用，因为在这里弱引用不是引起问题的关键。

从下图中，可以看到JavaInfomationProvider中保存了TalendJavaEditor的引用。所以打开JavaInfomationProvider的代码，进行检查。从下图的分析中，大概可以看出这是一个注册了的监听器没有反注册的问题，这也是引起内存泄露的原因中最常见的。

public JavaInformationProvider(IEditorPart editor) {

fEditor= editor;

if (fEditor != null) {

fPartListener= new EditorWatcher();

IWorkbenchWindow window= fEditor.getSite().getWorkbenchWindow();

window.getPartService().addPartListener(fPartListener);

update();

}

在JavaInformationProvider 的构造方法中，保存了TalendJavaEditor的实例，并且注册了监听器。

public void partClosed(IWorkbenchPart part) {

if (part == fEditor) {

fEditor.getSite().getWorkbenchWindow().getPartService().removePartListener(fPartListener);

fPartListener= null;

}

EditorWatcher的方法partClosed中，当关闭一个designer editor的时候，传进来的part是MultiPageTalendEditor，而不是JavaInformationProvider保存的TalendJavaEditor，所以该listener永远不可能被反注册掉，GC也就不可能回收TalendJavaEditor。对于该软件系统来所，这是一个致命的内存溢出问题。

point找到了，解决就不是问题了。

本文链接

Myeclipse SVN 插件安装

2011-12-09T08:11:00Z

一、

(一)、在线安装

1. 打开Myeclipse，在菜单栏中选择Help→Software Updates→Find and Install;

2. 选择Search for new features to install，点击Next进入下一步;

3. 点击"New Remote Site"按钮，在弹出的对话框中输入：

name：SVN

url：http://subclipse.tigris.org/update_1.4.x

点击OK，关闭对话框，并点击Finish按钮，Myeclipse自动下载插件安装程序;

4. 下载完插件之后，进入安装画面。

5. 选择所要安装的SVN插件内容，这里去掉第二个选项Subclipse Integrations，点击下一步；

6. 选择 "I accept the terms in the license agreements"并点击Next，直到点击Finish即可，进入下一步。

7. 开始安装SVN插件，安装完成之后，重启Myeclipse。

(二)、手动安装

1、下载SVN插件
下载地址：http://subclipse.tigris.org/files/documents/906/46495/site-1.6.5.zip

2. 在MyEclipse 6.5的安装路径下的plug_in(C:\Program Files\MyEclipse 6.5\eclipse\plugins)下新建文件夹：site-1.6.5;

3. 打开MyEclipse 6.5，在菜单栏中选择 Help → Software Updates → Find and Install;

2. 选择Search for new features to install，点击Next进入下一步;

3. 点击"New Local Site"按钮，找到解压出来的文件夹(site-1.6.5) → 点击OK，并点击Finish按钮，Myeclipse自动加载插件;

4. 在弹出的菜单中，select the features to insteall:在刚加进去的路径Subclipse-site-1.6.5这一项前打钩，此时会报错，然后展开Subclipse前的加号，去掉 Subclipse Integration for Mylyn 3.x(Optional)3.0.0前的钩，错误消失 → next → 选 I accept the terms in the license agreements → next → next → 选中所有的8项，然后Change Location……，在弹出的菜单中选Add Location……选择在第3步中建的文件夹的路径(C:\Program Files\MyEclipse 6.5\eclipse\plugins\site-1.6.5) → Finish → 再弹出的菜单中选 Install All → Yes

5. 开始安装SVN插件，安装完成之后，重启Myeclipse。

二、安装完成

1. 在MyEclipse 6.5 菜单栏中选择Window→Open Perspective→Other打开Myeclipse试图列表。这个时候Myeclipse的视图列表中，就出现了"SVN Repository Exploring"一项。

2. 打开"SVN Repository Exploring"视图。在左边空白区域，单击右键 → New → Repository Location。

3. 在Url一栏中输入svn://IP，点击Finish按钮。

4. 选择要下载的项目右键选择checkout 就把项目下载到本地了

三、基本操作

1.提交工程

右击工程->小组->共享项目->选择SVN->选择svn://127.0.0.1(如果没有,则创建一个新的资源库)->下一步->完成

2.下载工程

在SVN资源库透视图下,点开svn://127.0.0.1,会显示出现在本机SVN上的所有工程,右击你想下载的工程->检出为->下一步->完成

3.操作工程

3.1同步

在MyEclipse J2EE透视图下,右击你要同步的工程->小组->与资源库同步->这时会进入同步透视图,会显示出本机与SVN上内容有不同的文件, 双击文件名,会显示出两个文件中哪里不同;

3.2提交

在同步透视图下有"灰色向右的箭头,表示你本机修改过",右击该文件,可以选择提交操作;

3.3覆盖/更新

在同步透视图下有"蓝色向左的箭头,表示你本机修改过",右击该文件,可以选择覆盖/更新操作;

4.图标说明

4.1灰色向右箭头:本地修改过

4.2蓝色向左箭头:SVN上修改过

4.3灰色向右且中间有个加号的箭头:本地比SVN上多出的文件

4.4蓝色向左且中间有个加号的箭头:SVN上比本地多出的文件

4.5灰色向右且中间有个减号的箭头:本地删除了,而SVN上未删除的文件

4.6蓝色向左且中间有个减号的箭头:SVN上删除了,而本地未删除的文件

4.7红色双向箭头:SVN上修改过,本地也修改过的文件

5.一些我遇到的出错信息

5.1在上面讲的3.2步输入URL(svn://127.0.0.1)点下一步出现"svnserve.conf:12: Option expected"错误

你打开svnserve.conf文件中的第12行,该错误是由于该行的前面有空格引起的,把左边多出的空格删除掉即可;

5.2在上面讲的3.2步输入URL(svn://127.0.0.1/SVN_PRJ)点下一步出现"svn://127.0.0.1/SVN_PRJ non-existent in revision '7'"错误

URL错了,应该输入svn://127.0.0.1即可

官方下载：

服务器和程序下载： http://subversion.tigris.org/getting.html#binary-packages
Windows常用客户端TortoiseSVN：http://tortoisesvn.net/downloads
AnkhSVN（Visual Studio插件）：http://ankhsvn.open.collab.net/
Subclipse（Eclipse 插件）：http://subclipse.tigris.org/
SCPlugin（Mac OS x客户端）：http://scplugin.tigris.org/

更多客户端和工具可以看下表或者到官方网站察看：http://subversion.tigris.org/links.zh.html#clients

本文链接

将mina整合到tomcat中

2011-12-08T15:58:00Z

webgame中的聊天模块采用前台flash，后台java，socket来进行通讯。后台是自己写的socket server。但存在很多问题，与spring不方便整合，部署的时候要分开部署。自己写的还存在效率问题。所以想到了apache mina。如果用mina的话就会提高socket服务器的效率。又在网上查到一些mina与tomcat整合的资料，自己就动手开始进行整合

首先在pom.xml中加入

<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-core</artifactId>
<version>2.0.0-M3</version>
</dependency>
<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-integration-spring</artifactId>
<version>1.1.7</version>
</dependency>
<dependency>
<groupId>org.apache.mina</groupId>
<artifactId>mina-integration-beans</artifactId>
<version>2.0.0-M3</version>
</dependency>

运行ant通过maven取得相应的jar包。然后加入spring的配置，让mina和spring整合在一起。

<beans>
<bean >
<property name="customEditors">
<map>
<entry key="java.net.SocketAddress">
<bean />
</entry>
</map>
</property>
</bean>


<bean id="minaHandler" />


<bean id="executorFilter" />

<bean id="mdcInjectionFilter" >
<constructor-arg value="remoteAddress" />
</bean>

<bean id="codecFilter" >
<constructor-arg>
<bean />
</constructor-arg>
</bean>

<bean id="loggingFilter" />


<bean id="filterChainBuilder" >
<property name="filters">
<map>
<entry key="executor" value-ref="executorFilter" />
<entry key="mdcInjectionFilter" value-ref="mdcInjectionFilter" />
<entry key="codecFilter" value-ref="codecFilter" />
<entry key="loggingFilter" value-ref="loggingFilter" />
</map>
</property>
</bean>


<bean id="minaAcceptor"
init-method="bind" destroy-method="unbind">
<property name="defaultLocalAddress" value=":8888" />
<property name="handler" ref="minaHandler" />
<property name="reuseAddress" value="true" />
<property name="filterChainBuilder" ref="filterChainBuilder" />
</bean>

</beans>

其中com.game.MinaProtocolHandler是我要实现的类，新建类MinaProtocolHandler继承IoHandlerAdapter，代码如下

public void messageReceived(IoSession session, Object message) {
String msg = (String) message;
System.out.println("Server Received: " + msg);
session.write("Send msg: " + msg);
}

public void sessionIdle(IoSession session, IdleStatus status) {
session.close();
}

public void exceptionCaught(IoSession session, Throwable cause) {
session.close();
}

启动tomcat，就会开启一个8888的端口，进入命令行输入telnet 127.0.0.1 8888看看

本文链接

JIRA管理思路[转]

2011-11-30T16:27:00Z

刚刚开始用Jira的时候，只是觉得这是一个方便的bug管理系统，可以将在测试过程中所发现的bug录入、分配给开发人员。
之后开始在公司内使用，之前也曾经想尝试使用bugzilla。在D的建议之下，又因我用过Jira，因此一拍即合，开始使用了。
因起初只是使用者，因而并未有站在一个管理者的角度上来看JIRA在项目管理中的作用和意义。因此今日再看时，已发现由于出发角度的错误而出现的很多偏差，导致的此时的问题。
没办法有效的管理bug，没办法有效的让所有人及时添加bug，没办法让所有人方便看到当前有哪些bug。因为太乱了，模块划分乱、版本划分乱、处理者乱，处理流程乱。
当这些问题出现后，才发现之前的错误。这些为什么没有在开始使用时就理解和计划实施呢！
现在来看JIRA，这是一个项目管理的很好辅助工具，将所有项目开发、运作过程中的所有task 、 bug、创意、改善意见都可以融汇进入这个系统。可以在第一时间将这些问题指派而责任人进行处理。
而想用JIRA来做好BUG管理和项目管理，有这几个重点要做好！
1.定义模块
    模块反应了问题出现因素的范围。所发现的问题、所需要进行的任务、改善意见的指向、创意所应用的范围。
2.定义里程碑
    问题、任务、意见、创意都需要分配在某一时段进行处理，时段可以是时间为单位的，周、日、时、分，也可以是里程碑，alpha/beta/close beta/open beta。如果所有的事情都可以以这两种单位计量的非常清晰，那么首先可以称赞的一点是，你的负责心已经体现出来了，你知道在什么时间该做什么事，同时，你让你的战友们知道，他们应该在什么时候做什么事！
3.定义全局处理流程
    第1点和第2点，是你在为这个项目管理做的基础准备，有了第1点和第2点，那说明你在其中的工作，但这并不表明这个系统就可以运作起来。要运作起来，就必须你和你的战友们都可以在处理JIRA上的所有事务时的处理流程。
    建立：建立一个issue。什么样的东西应该建立在JIRA中，我得到的经验是，所有的工作任务、所有的bug（开发过程中的，A与B之前的，A与C之前的，B与C之前，所有、所有），不单是测试小组所发现的一些黑盒测试的bug，开发过程中的也不遗漏。这样，你可以看到这个项目在动的，每天所有人都在发现问题，解决问题。
    分配：问题要给能解决问题的人，问题要给理解这个问题的人。程序上问题你给了一个商备人员，那你不对了；程序的问题你给了程序，可以程序不明白你说的是什么，那也是你不对了。要降低沟通过程中的风险，建立问题者，想清楚，这个问题要由谁来处理，要告诉他什么信息。你在没有告诉清楚这些信息的时候，你对这个问题还是最大责任者。
    开始：开始是指接收到这个issue后的处理手段之一，因为还有拒绝这种可能。开始处理这个问题，在向所有人声明一件事情，这个问题我开始着手处理了，我会按着计划和需求来完成这个事务。那么，开始做这件事的人，你要很坦诚的向自己说，我知道这个事务是什么，我知道要怎么去处理，我知道要在这个时间内怎么处理。你开始接受这项事务，是你对于分配给你这个事务的人的一个回应。这时事务的责任在你的身上。用你的职业精神来处理这个事务吧。
    解决：整个的处理过程统称为解决。虽然有可能出现解决不了、或者在解决的过程中需要其它人来帮忙，也可能需要很多的讨论和会议，这都是解决的过程，在这个过程中，把你做过的事情，对于这个Issue相关的资料，信息版本，记录下来。让别人知道，你是用什么方法来解决的，你这种解决方法是不是很安全，还有没有其它更优化的方法。
    关闭：解决完一个事务后，通常这种事务的责任转移到分配人的头上，分配人要处理的事情是，这个事务是否如需求、计划所完成，完成质量是否符合要求。在通过验证后，这一个问题需要你的关闭。在出现不符合的情况，你不能关闭这个issue，你要提供更多信息，更多资料，方便他再来解决。
    重开：对于bug，出现重现的情况是常见的，这时不要让JIRA上有更多的垃圾信息，也方便开发人员找到问题原因，你需要重开这个bug，并附上相关的信息。
4.每日的统计与清理
    管理项目要盯，每日的盯是少不了的，看全局的issue数量、关闭情况、进行情况、所剩未解决的数量。你可以有的放矢的去针对这些问题来看。也可以看到，谁的问题比较多，谁的进度比较慢。因为什么问题将影响进度，因为什么问题将影响产品品质。
    你也有责任要清理一些问题，这种情况出现在，你没有让所有战友都可以很好的使用这个系统。清理的另一意义是理，有一些问题，你可能要在这一阶段放弃，那需要理到某一个其它时段，这个问题需要换由其它人再进行继续的处理等等。
5.阶段的统计与整理
    阶段，这么划分吧，每周3/2这样两个阶段，这是除了第4点所说的之外的最小阶段吧。以它就是周、版本计划阶段、版本大的阶段划分这样的划分情况。
    通过阶段内的完成情况，你可以看到谁处理的问题太多了，谁少一些，谁的难度高一些、谁的能力不足、谁不负责任。哪个部门做得不足，哪一模块需要更多人帮忙。如果说日为单位是盯的话，那么阶段来统计与整理，就是盯之后的分析与解决方案。
6.最大力度的使用过滤器
    Jira提供了较多的查询条件可供个人创建过滤器和与团队分享过滤器。同时还可以自定义自己的主页，相信自定义主页这个功能在google上你已经感受过了。同样这些过滤器可以变为你的主页中的一部分，把你最需要关注的issue都呈现在你每日的第一位置。

JIRA，是一个工具，是改变你原始管理思维的一个突破。如果你要用的话，请记住，Jira不是你一个人会用就行了，是一个团队、一个系统。否则他运转不起来，就算转起来了，也有出现更大问题的时候。

现在我面对的就是出现这个大问题的时候。希望通过这样的一处整理思路的过程，让公司的JIRA系统可以快速恢复起他应有的作用。

本文链接

linux下安装jira4.4.1[转]

2011-11-28T04:11:00Z

1.下载，安装

32位

http://www.atlassian.com/software/jira/downloads/binary/atlassian-jira-4.4.1-x32.bin

64位

http://www.atlassian.com/software/jira/downloads/binary/atlassian-jira-4.4.1-x64.bin

linux 下可以wget获取安装文件

[root@jira local]#chmod 755 atlassian-jira-4.4.1-x64.bin

[root@jira local]# ./atlassian-jira-4.4.1-x64.bin

安装时会要求输入安装路径和存放数据路径。安装提示一步一步操作即可。

安装完成后JIRA即已经启动。

创建jira使用的数据库。

create database jiradb character set utf8;

登陆http://localhost:8080/ 或 http://IP:8080/运行安装.

打开后,选择使用外部数据库MYSQL,输入数据库信息,测试连接，选择中文。下一步.

记下server ID.

2.汉化

注：JIRA4.4.1 安装步骤即可选择中文，无需汉化

先停止jira

service jira stop

下载汉化包和破解补丁

汉化：http://download.csdn.net/detail/banklin/3702013

破解补丁：http://download.csdn.net/detail/banklin/3702011

下载jira-lang-zh_CN-4.4.1.jar 汉化文件.

复制到$Install_Jira/atlassian/jira/atlassian-jira/WEB-INF/lib/该目录替换掉原来的文件

3.破解

下载jira_crack.rar,（里面还包括greenhopper5.x破解补丁，fisheye2.4.3破解补丁，crucible2.4.3破解补丁）解压.

把$Install_Jira/atlassian/jira/atlassian-jira/WEB-INF/lib/atlassian-extras-2.2.2.jar 该文件下载到本地电脑.

在装好了java 的windows上启动注册机。java -jar jira_keygen.jar (或者直接运行jira_keygen.bat)

会出现一个注册机。

输入name和记下的server ID.号，点击.patch，然后选择下载到本地的atlassian-extras-2.2.2.jar 文件。即可生成破解后的atlassian-extras-2.2.2.jar

上传到服务器替换原来的文件。$Install_Jira/atlassian/jira/atlassian-jira/WEB-INF/lib/atlassian-extras-2.2.2.jar即可完成破解。

重新启动jira

service jira start

访问jira页面http://url:8080/

再点击注册机中gen.将生产的key复制进行注册。即可完成安装。

本文链接

CentOS 6.0 安装配置rails 2.3.11 + redmine 1.2.1 笔记[转]

2011-11-26T08:04:00Z

0.安装相关的软件包

   1:# yum install httpd httpd-devel openssl-devel\
 zlib-devel gcc gcc-c++  curl-devel subversion -y

1.安装MySql数据库

安装MySQL ，并设置为开机自动启动。

   1: # yum install mysql mysql-devel mysql-server

   2: # chkconfig --levels 235 mysqld on

   3: # /etc/init.d/mysqld start

创建Redmine数据库，执行mysql -u root -p登录mysql，在mysql>命令行中输入如以下sql代码：

   1: CREATE DATABASE redmine CHARACTER SET utf8 COLLATE utf8_general_ci;

   2: CREATE USER 'redmine'@'localhost' IDENTIFIED BY 'redmine';

   3: GRANT ALL ON redmine.* TO 'redmine'@'localhost';

添加一个数据库readmine，创建一个用户登录用户redmine，密码和用户名相同，并且授权访问redmine数据库。

注：mysql安装后默认root是没设置密码的，如果要改root密码，执行 usr/bin/mysqladmin -u root password 'new-password' 修改。

2.安装Ruby 1.8.7

下载Ruby1.8.7源码编译安装，建个临时目录存放安装过程需要下载的文件

   1:# mkdir ~/rails_install

   2:# cd ~/redmine_install

   3:# wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.7-p352.tar.gz

   4:# tar zxvf ruby-1.8.7-p352.tar.gz

   5:# cd ruby-1.8.7-p352

   6:# ./configure

   7:# make

   8:# make install

安装成功后执行 ruby –v 可看到ruby的版本信息，如：
ruby 1.8.7 (2011-06-30 patchlevel 352) [i686-linux]

3.安装RubyGems

这个比较挑剔，在redmine安装指导（http://www.redmine.org/projects/redmine/wiki/RedmineInstall）中提到有要求，要在1.3.7 ~ 1.7.0之间，这里我选择了1.6.2版。同样是下载源码安装。

   1:# cd ~/rails_install

   2:# wget http://rubyforge.org/frs/download.php/74445/rubygems-1.6.2.tgz

   3:# tar zxvf rubygems-1.6.2.tgz

   4:# cd rubygems-1.6.2

   5:# ruby setup.rb

安装成功后，执行gem –v ，可看到版本信息。

4.安装Rails及相关gems

如果直接用gem install xxx 安装的，大都都安装不成功，不知是我这边网络问题还是其它原因，所以只好把用到的文件都下载回来再本地安装。

   1: # cd ~/rails_install

   2: # wget http://rubygems.org/downloads/rake-0.8.3.gem

   3: # wget http://rubygems.org/downloads/rack-1.1.0.gem

   4: # wget http://rubygems.org/downloads/rails-2.3.11.gem

   5: # wget http://rubygems.org/downloads/activesupport-2.3.11.gem

   6: # wget http://rubygems.org/downloads/activerecord-2.3.11.gem

   7: # wget http://rubygems.org/downloads/actionpack-2.3.11.gem

   8: # wget http://rubygems.org/downloads/actionmailer-2.3.11.gem

   9: # wget http://rubygems.org/downloads/activeresource-2.3.11.gem

10:

  11: # wget http://rubygems.org/downloads/i18n-0.4.2.gem

  12: # wget http://rubygems.org/downloads/mysql-2.8.1.gem

  13: # wget http://rubygems.org/downloads/cgi_multipart_eof_fix-2.5.0.gem

  14: # wget http://rubygems.org/downloads/coderay-1.0.0.gem

15:

  16: # gem  install --local rake-0.8.3.gem

  17: # gem  install --local rack-1.1.0.gem

  18: # gem  install --local rails-2.3.11.gem

  19: # gem  install --local mysql-2.8.1.gem

  20: # gem  install --local i18n-0.4.2.gem

  21: # gem  install --local cgi_multipart_eof_fix-2.5.0.gem

  22: # gem  install --local coderay-1.0.0.gem

安装成功后运行rails可以看到相应的版本信息

5.安装Redmine 1.2.1

使用svn下载Redmine 1.2源码到/var/www目录中

   1: # svn co http://redmine.rubyforge.org/svn/branches/1.2-stable /var/www/redmine1.2

redmine数据库配置，将config目录下的数据库配置模板复制一份

   1:# cd /var/www/redmine1.2/

   2:# cp config/database.yml.example config/database.yml

   3:# nano config/database.yml

打开复制出来的database.yml文件，配置production节点的mysql登录信息。

   1: production:

   2:   adapter: mysql

   3:   database: redmine

   4:   host: localhost

   5:   username: redmine

   6:   password: redmine

生成session存储加密信息和数据库

   1: # cd /var/www/redmine1.2

   2: # rake config/initializers/session_store.rb

   3: # RAILS_ENV=production rake db:migrate

   4: # RAILS_ENV=production rake redmine:load_default_data

在执行最后一行命令时，会提示选择语言种类，输入 zh 回车即可，如果直接回车确则认默认为英文。

运行redmine

   1:# cd /var/www/redmine1.2

   2:# ruby script/server webrick -p 8000 -e production

即可以在浏览器中输入 http://[服务器IP]:8000 访问redmine，默认的管理登录用户名和密码都为 admin，界面如下：

要注意的是，centos默认是打开iptables服务的，所以要远程访问还要在iptables中添加一个放行规则。
# nano /etc/sysconfig/iptables
在 -A INPUT -j REJECT 这行前添加

   1: -A INPUT -m state --state NEW -m tcp -p tcp --dport 8000 -j ACCEPT

然后再重启iptables服务，使修改生效。

# service iptables restart

这样就可以远程访问了。

本文链接

安装项目管理工具 SVN+Redmine[转]

2011-11-22T16:43:00Z

最近想装个代码管理工具，以方便管理自己几年来的代码。需要既可以方便的查看和更新，还需要可以方便的索搜代码。

开始想放到Google SVN上面，后来觉得也没必要了，放在本地既安全也很方便。

我知道的可以和SVN集成的管理工具有Trac和Redmine。以前用过Trac，不过配置挺麻烦的，而且好像有一次我改了些配置，导致站点再也打不开了（搞了好久都没搞定，^_^）。

这次决定使用Redmine来搭建一个自己的代码管理工具，把自己平时积累的代码都提交上去。下面说一下安装步骤：

一、装备文件

我们搭建redmine使用集成环境Instantails。

InstantRails2.0：http://rubyforge.org/projects/instantrails/

redmine 1.2.0： http://rubyforge.org/frs/?group_id=1850

gem1.3.7：http://rubyforge.org/frs/download.php/70695/rubygems-update-1.3.7.gem

二、安装

配置InstantRails2.0与redmine

　　1、解压InstantRails2.0到一个文件夹，文件夹名字不能含有空格（如InstantRails即可）。

　　2、然后把redmine 1.2.0解压到InstantRails下的rails_apps下。

更新InstantRails2.0

　　由于Instant Rails 官网这个程序最新的2.0版本07年以后就不再更新了，因此自己搭建前请根据自己的需求更新其中的软件，Instant Rails2.0中软件的版本如下:
* Upgrades Ruby to version 1.8.6 Patch Level 111
* Upgrades Rails to 2.0.2
* Upgrades Mongrel to 1.1.2
* Upgrades RubyGems to 1.0.1
* Upgrades Rake to 0.8.1
* Upgraded Cookbook app to support Rails 2.0.2

　　打开Redmine1.2.0软件包中Doc目录下的INSTALL文档，可以看到安装的软件版本需求

　　== Requirements
* Ruby 1.8.6 or 1.8.7
* RubyGems 1.3.7
* Ruby on Rails 2.3.11 (official downloadable Redmine releases are packaged with the appropriate Rails version)
* Rack 1.1.0 gem
* Rake 0.8.3 gem
* I18n 0.4.2 gem

　　因此需要更新其中的软件，步骤如下：

　　1、进入InstantRails根目录下。点击InstantRails.exe文件

　　2、点击InstantRails界面（就是刚点击InstantRails.exe后的程序界面）的Rails Applications→Open Ruby Console Window栏目，然后会跳出dos窗口。在里面输入命令：

　　3、更新RubyGem，由于InstantRails2.0 中gem的版本比较低，不能直接通过命令行直接在线更新，需要使用到之前下载gem1.3.7软件包。

DOS窗口里用命令进入gem1.3.7文件所在的目录，执行gem install --local rubygems-update-1.3.7.gem，出现信息:

Successfully installed rubygems-update-1.3.7
1 gem installed
Installing ri documentation for rubygems-update-1.3.7...
Installing RDoc documentation for rubygems-update-1.3.7...
Could not find main page README
Could not find main page README
Could not find main page README
Could not find main page README

再执行update_rubygems.会出现的信息很多，等结束完了运行gem -v 发现已经升级到了1.3.7 yeah

　　4、更新Rack，在命令行中输入gem install rack -v=1.1.0

　　5、更新Rake，在命令行中输入gem install rake -v=0.8.3

　　6、在Redmine >= 1.0.5时，就需要安装i18n了，在命令行中输入gem install i18n -v=0.4.2

　　7、最后更新Rails，在命令行中输入gem install rails -v=2.3.11

　　　　注意：Rails要在Rack和Rake软件包之后更新，因为Rails 2.3.11依赖Rack和Rake，Rails 更新时如果发现Rack或Rake版本低就会自动更新Rack和Rake，

　　　　但是自动更新的Rake的不是0.8.3(我这是0.9.1)，这导致Rake之后会运行失败。

　　8、更新Mongrel ，InstantRails2.0 自带的Mongrel是1.1.2的版本，需要更新，在命令行中输入gem install mongrel -v=1.1.5

建立redmine的数据库

　　1、进入“InstantRails/rails_apps/redmine/config"下，有文件“database.yml.example”，复制该文件重命名“database.yml”

　　2、配置database.yml中的“production”的参数，使用默认也可以。
3、InstantRails界面右键Configure→Database (via PhpMyAdmin)”。
　　进入phpMyAdmin下，新建数据库（用sql命令方式）：
　　create database redmine character set utf8;
　　4、设置Session Key，进入Redmine目录，在命令行中输入rake generate_session_store
　　5、创建Redmine数据库，进入Redmine目录，在命令行中输入rake db:migrate RAILS_ENV="production"，这将创建表和管理员账号
6、输入ruby script/server -e production，启动Web服务器，在浏览器中输入http://localhost:3000/登陆，默认使用管理员账号
login: admin password: admin，下面是登陆后的截图

安装SVN服务器

　　我这里使用Visual SVN作为SVN的服务，可以参考网络上的文章

三、Redmine和SVN集成

　　进入Redmine目录下Config，有文件“configuration.yml.example”，复制该文件重命名“configuration.yml”，修改其中的SVN配置

scm_subversion_command: svn # (default: svn)，

　　这里需要设置在环境变量PATH中添加svn所在的目录

再重启服务器，配置SCM，选用SVN设置库路径，就可以看到代码了。

本文链接

MySql 优化[转]

2011-11-19T10:20:00Z

1.数据库的设计
尽量把数据库设计的更小的占磁盘空间.
1).尽可能使用更小的整数类型.(mediumint就比int更合适).
2).尽可能的定义字段为not null,除非这个字段需要null.（这个规则只适合字段为KEY的情形）
3).如果没有用到变长字段的话比如varchar,那就采用固定大小的纪录格式比如char.（CHAR 总是比VARCHR快）
4).表的主索引应该尽可能的短.这样的话每条纪录都有名字标志且更高效.
5).只创建确实需要的索引。索引有利于检索记录，但是不利于快速保存记录。如果总是要在表的组合字段上做搜索，那么就在这些字段上创建索引。索引的第一部分必须是最常使用的字段.如果总是需要用到很多字段，首先就应该多复制这些字段，使索引更好的压缩。
（这条只适合MYISAM引擎的表，对于INNODB则在保存记录的时候关系不大，因为INNODB是以事务为基础的，如果想快速保存记录的话，特别是大批量的导入记录的时候）
6).所有数据都得在保存到数据库前进行处理。
7).所有字段都得有默认值。
8).在某些情况下,把一个频繁扫描的表分成两个速度会快好多。在对动态格式表扫描以取得相关记录时，它可能使用更小的静态格式表的情况下更是如此。
(具体的表现为：MYISAM表的MERGE类型，以及MYISAM和INNODB通用的分区，详情见手册)
9).不会用到外键约束的地方尽量不要使用外键。
2.系统的用途
1).及时的关闭对MYSQL的连接。
2).explain 复杂的SQL语句。（这样能确定你的SELECT 语句怎么优化最佳）
3).如果两个关联表要做比较话，做比较的字段必须类型和长度都一致.（在数据庞大的时候建立INDEX）
4).LIMIT语句尽量要跟order by或者 distinct.这样可以避免做一次full table scan.
5).如果想要清空表的所有纪录,建议用truncate table tablename而不是delete from tablename.
不过有一个问题，truncate 不会在事务处理中回滚。因为她要调用create table 语句。
（Truncate Table 语句先删除表然后再重建，这个是属于文件级别的，所以自然快N多）
实测例子：
song2为INNODB表。
mysql> select count(1) from song2;
+----------+
| count(1) |
+----------+
| 500000 |
+----------+
1 row in set (0.91 sec)

mysql> delete from song2;
Query OK, 500000 rows affected (15.70 sec)
mysql> truncate table song2;
Query OK, 502238 rows affected (0.17 sec)

6).能使用STORE PROCEDURE 或者 USER FUNCTION的时候.（ROUTINE总是减少了服务器端的开销）
7).在一条insert语句中采用多重纪录插入格式.而且使用load data infile来导入大量数据，这比单纯的indert快好多.（在MYSQL中具体表现为：INSERT INTO TABLEQ VALUES (),(),...();）
（还有就是在MYISAM表中插入大量记录的时候先禁用到KEYS后面再建立KEYS,具体表现语句：
ALTER TABLE TABLE1 DISABLE KEYS;ALTER TABLE TABLE1 ENABLE KEYS;
而对于INNNODB 表在插入前先 set autocommit=0;完了后：set autocommit=1;这样效率比较高。）
8).经常OPTIMIZE TABLE 来整理碎片.
9).还有就是date 类型的数据如果频繁要做比较的话尽量保存在unsigned int 类型比较快。
3.系统的瓶颈
1).磁盘搜索.
并行搜索,把数据分开存放到多个磁盘中，这样能加快搜索时间.
2).磁盘读写(IO)
可以从多个媒介中并行的读取数据。
3).CPU周期
数据存放在主内存中.这样就得增加CPU的个数来处理这些数据。
4).内存带宽
当CPU要将更多的数据存放到CPU的缓存中来的话,内存的带宽就成了瓶颈.

本文链接

Spring中常用的操作数据库的(Dao)方法 [转]

2010-07-31T09:54:00Z

Spring中常用的操作数据库的(Dao)方法
接口:
public interface BaseDAO {
     void save(T instance);
     void update(T instance);
     void delete(T instance);
     T get(String id);
     List<T> findAll();
     List<T> findByExample(T instance);
     int bulkUpdate(String hql);
     int bulkUpdate(String hql, Object value);
     int bulkUpdate(String hql, Object[] value);
     List<T> find(String queryString);
     List<T> find(String queryString, Object obj);
     List<T> find(String queryString, Object[] obj);
     List<T> findByNamedParam(String queryString, String paramName, Object value);
     List<T> findByNamedParam(String queryString, String[] paramNames, Object[] values);
     List<T> findByNamedQuery(String queryName);
     List<T> findByNamedQuery(String queryName, Object value);
     List<T> findByNamedQuery(String queryName, Object[] values);
     List<T> findByProperty(String property, Object value);
     List<T> findByPagination(final T t, final int firstResult, final int maxResult);
     int countByPagination(final T t);
}
实现类:
import java.sql.*;
import java.util.List;
import org.hibernate.*;
import org.hibernate.criterion.*;
import org.springframework.orm.hibernate3.*;
import org.springframework.orm.hibernate3.support.*;

import com.vo.T;

public abstract class BaseDAOImpl extends HibernateDaoSupport implements BaseDAO{

protected abstract Class type(); //反射方法调用类

// 保存
public void save(T instance) {
getHibernateTemplate().save(instance);
}

// 更新
public void update(T instance) {
getHibernateTemplate().update(instance);
}

// 删除
public void delete(T instance) {
getHibernateTemplate().delete(instance);
}

// 根据ID查询
@SuppressWarnings("unchecked")
public T get(String id) {
return (T) getHibernateTemplate().get(type(), id);
}

// 查询所有
@SuppressWarnings("unchecked")
public List<T> findAll() {
return getHibernateTemplate().loadAll(type());
}

// 根据例子查询

@SuppressWarnings("unchecked")
public List<T> findByExample(T instance) {
return getHibernateTemplate().findByExample(instance);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql) {
return getHibernateTemplate().bulkUpdate(hql);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql, Object value) {
return getHibernateTemplate().bulkUpdate(hql, value);
}

// 根据HQL语句进行update操作等
public int bulkUpdate(String hql, Object[] value) {
return getHibernateTemplate().bulkUpdate(hql, value);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString) {
return getHibernateTemplate().find(queryString);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString, Object obj) {

return getHibernateTemplate().find(queryString, obj);
}

// 根据HQL语句进行查询
@SuppressWarnings("unchecked")
public List<T> find(String queryString, Object[] obj) {
return getHibernateTemplate().find(queryString, obj);
}

/**
* 使用命名查询进行查询
*
* @param queryString
*            HQL
* @param paramName
*            参数名
* @param value
*            参数值
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedParam(String queryString, String paramName, Object value) {
return this.getHibernateTemplate().findByNamedParam(queryString, paramName, value);
}

/**
* 使用命名查询进行查询多个参数
*
* @param queryString
*            HQL
* @param paramNames
*            参数名的数组
* @param values
*            参数值的数组
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedParam(String queryString, String[] paramNames, Object[] values) {
return this.getHibernateTemplate().findByNamedParam(queryString, paramNames, values);
}

/**
* 使用HIBERNATE映射文件中的定义的HQL语句进行查询
*
* @param queryName
* 文件中定义的HQL语句的名字
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName) {
return getHibernateTemplate().findByNamedQuery(queryName);
}

/**
*
* @param queryName
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName, Object value) {
return getHibernateTemplate().findByNamedQuery(queryName, value);
}

/**
*
* @param queryName
* @param values
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByNamedQuery(String queryName, Object[] values) {
return getHibernateTemplate().findByNamedQuery(queryName, values);
}

/**
* 根据属性查询
*
* @param property
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public List<T> findByProperty(String property, Object value) {
return this.getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(type()).add(Restrictions.eq(property, value)));
}

/**
* 分页查询
* 注:不能满足要求子类重写该方法
* @param t
* @param firstResult
* @param maxResult
* @return 返回分页查询的数据
*/
@SuppressWarnings("unchecked")
public List<T> findByPagination(final T t, final int firstResult, final int maxResult) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(type());
criteria.add(Example.create(t).enableLike(MatchMode.ANYWHERE));
criteria.setFirstResult(firstResult);
criteria.setMaxResults(maxResult);
return criteria.list();
}
});
}

/**
* 分页统计查询
*
* @param t
* @return 一共有多少条数据
*/
@SuppressWarnings("unchecked")
public int countByPagination(final T t) {
return (Integer) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = session.createCriteria(type());
criteria.setProjection(Projections.rowCount());
criteria.add(Example.create(t).enableLike(MatchMode.ANYWHERE));
return criteria.uniqueResult();
}
});
}
}

反射类:

public class ClassInfoDAO{

@SuppressWarnings("unchecked")
    protected Class type() {
    return User.class;
   }

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wslyy99/archive/2009/01/09/3741680.aspx

本文链接