Eclipse 快捷键大全
类别 命令 键序列 说明
C/C++ Source Add Block Comment Ctrl+Shift+/ C/C++ Editor
C/C++ Source Add Include Ctrl+Shift+N C/C++ Editor
C/C++ Source Comment Ctrl+/ C/C++ Editor
C/C++ Source Find Declaration Ctrl+G C/C++ Editor
C/C++ Source Find References Ctrl+Shift+G C/C++ Editor
C/C++ Source Format Ctrl+Shift+F C/C++ Editor
C/C++ Source Go to Matching Bracket Ctrl+Shift+P C/C++ Editor
C/C++ Source Go to next C/C++ member Ctrl+Shift+向下键 C/C++ Editor
C/C++ Source Go to previous C/C++ member Ctrl+Shift+向上键 C/C++ Editor
C/C++ Source Open Declaration F3 C/C++ Editor
C/C++ Source Open Definition Ctrl+F3 C/C++ Editor
C/C++ Source Open Type Ctrl+Shift+T C/C++ Editor
C/C++ Source Remove Block Comment Ctrl+Shift+\ C/C++ Editor
C/C++ Source Show outline Ctrl+O C/C++ Editor
C/C++ Source Uncomment Ctrl+\ C/C++ Editor
Makefile Source Comment Ctrl+/ Makefile Editor
Makefile Source Open declaration F3 Makefile Editor
Makefile Source Uncomment Ctrl+\ Makefile Editor
Refactor - C/C++ Redo - Refactoring Alt+Shift+Y C/C++ Editor
Refactor - C/C++ Rename - Refactoring Alt+Shift+R C/C++ Editor
Refactor - C/C++ Undo - Refactoring Alt+Shift+Z C/C++ Editor
View Zoom In Ctrl+= 在窗口中
View Zoom Out Ctrl+- 在窗口中
搜索 工作空间中的声明 Ctrl+G 在窗口中
搜索 工作空间中的引用 Ctrl+Shift+G 在窗口中
搜索 打开“搜索”对话框 Ctrl+H 在窗口中
搜索 显示“文件中的出现位置”快速菜单 Ctrl+Shift+U 在窗口中
文件 “新建”菜单 Alt+Shift+N 在窗口中
文件 保存 Ctrl+S 在窗口中
文件 全部保存 Ctrl+Shift+S 在窗口中
文件 全部关闭 Ctrl+Shift+F4 在窗口中
文件 全部关闭 Ctrl+Shift+W 在窗口中
文件 关闭 Ctrl+F4 在窗口中
文件 关闭 Ctrl+W 在窗口中
文件 刷新 F5 在窗口中
文件 属性 Alt+Enter 在窗口中
文件 打印 Ctrl+P 在窗口中
文件 新建 Ctrl+N 在窗口中
文件 重命名 F2 在窗口中
文本编辑 上一个词语 Ctrl+左箭头 编辑文本
文本编辑 上滚行 Ctrl+向上键 编辑文本
文本编辑 下一个词语 Ctrl+右箭头 编辑文本
文本编辑 下滚行 Ctrl+向下键 编辑文本
文本编辑 全部展开 Ctrl+Numpad_Multiply 编辑文本
文本编辑 切换折叠 Ctrl+Numpad_Divide 编辑文本
文本编辑 删除上一个词语 Ctrl+Backspace 编辑文本
文本编辑 删除下一个词语 Ctrl+Delete 编辑文本
文本编辑 删除至行末 Ctrl+Shift+Delete 编辑文本
文本编辑 删除行 Ctrl+D 编辑文本
文本编辑 在当前行上面插入行 Ctrl+Shift+Enter 编辑文本
文本编辑 在当前行下面插入行 Shift+Enter 编辑文本
文本编辑 复制行 Ctrl+Alt+向下键 编辑文本
文本编辑 将行上移 Alt+向上键 编辑文本
文本编辑 将行下移 Alt+向下键 编辑文本
文本编辑 展开 Ctrl+Numpad_Add 编辑文本
文本编辑 折叠 Ctrl+Numpad_Subtract 编辑文本
文本编辑 改写切换 Insert 编辑文本
文本编辑 更改为大写 Ctrl+Shift+X 编辑文本
文本编辑 更改为小写 Ctrl+Shift+Y 编辑文本
文本编辑 选择上一个词语 Ctrl+Shift+左箭头 编辑文本
文本编辑 选择下一个词语 Ctrl+Shift+右箭头 编辑文本
文本编辑 重复行 Ctrl+Alt+向上键 编辑文本
查看 Java 包资源管理器 Alt+Shift+Q，P 在窗口中
查看 Java 声明 Alt+Shift+Q，D 在窗口中
查看 Java 类型层次结构 Alt+Shift+Q，T 在窗口中
查看 Javadoc Alt+Shift+Q，J 在窗口中
查看 变量 Alt+Shift+Q，V 在窗口中
查看 同步 Alt+Shift+Q，Y 在窗口中
查看 备忘单 Alt+Shift+Q，H 在窗口中
查看 控制台 Alt+Shift+Q，C 在窗口中
查看 搜索 Alt+Shift+Q，S 在窗口中
查看 断点 Alt+Shift+Q，B 在窗口中
查看 显示视图 (查看: 大纲) Alt+Shift+Q，O 在窗口中
查看 显示视图 (查看: 问题) Alt+Shift+Q，X 在窗口中
浏览 &Quick Cross References Alt+Shift+P 编辑 Java 源代码
浏览 Open AspectJ Type Alt+Shift+A 在窗口中
浏览 Open AspectJ Type in Hierarchy Alt+Shift+H 在窗口中
浏览 “显示位置”菜单 Alt+Shift+W 在窗口中
浏览 上一个编辑位置 Ctrl+Q 在窗口中
浏览 下一页 Ctrl+. 在窗口中
浏览 前一页 Ctrl+, 在窗口中
浏览 前移历史记录 Alt+右箭头 在窗口中
浏览 后退历史记录 Alt+左箭头 在窗口中
浏览 在层次结构中打开类型 Ctrl+Shift+H 在窗口中
浏览 快速大纲 Ctrl+O 编辑 Java 源代码
浏览 快速层次结构 Ctrl+T 编辑 Java 源代码
浏览 打开声明 F3 在窗口中
浏览 打开外部 Javadoc Shift+F2 在窗口中
浏览 打开类型 Ctrl+Shift+T 在窗口中
浏览 打开类型层次结构 F4 在窗口中
浏览 打开结构 Ctrl+F3 编辑 Java 源代码
浏览 打开调用层次结构 Ctrl+Alt+H 在窗口中
浏览 打开资源 Ctrl+Shift+R 在窗口中
浏览 转至上一个成员 Ctrl+Shift+向上键 编辑 Java 源代码
浏览 转至下一个成员 Ctrl+Shift+向下键 编辑 Java 源代码
浏览 转至匹配的方括号 Ctrl+Shift+P 编辑 Java 源代码
浏览 转至行 Ctrl+L 编辑文本
源代码 切换 Ant 标记出现 Alt+Shift+O 编辑 Ant 构建文件
源代码 切换标记出现 Alt+Shift+O 编辑 Java 源代码
源代码 切换注释 Ctrl+/ 编辑 Java 源代码
源代码 切换注释 Ctrl+7 编辑 Java 源代码
源代码 切换注释 Ctrl+Shift+C 编辑 Java 源代码
源代码 在文件中重命名 Alt+Shift+R 编辑 Ant 构建文件
源代码 快速辅助 － 在文件中重命名 Ctrl+2，R 编辑 Java 源代码
源代码 快速辅助 － 指定给字段 Ctrl+2，F 编辑 Java 源代码
源代码 快速辅助 － 指定给局部变量 Ctrl+2，L 编辑 Java 源代码
源代码 打开外部文档 Shift+F2 编辑 Ant 构建文件
源代码 显示工具提示描述 F2 编辑 Ant 构建文件
源代码 显示源代码快速菜单 Alt+Shift+S 在窗口中
源代码 格式 Ctrl+Shift+F 编辑 Ant 构建文件
源代码 格式化 Ctrl+Shift+F 编辑 Java 源代码
源代码 添加 Javadoc 注释 Alt+Shift+J 在窗口中
源代码 添加块注释 Ctrl+Shift+/ 编辑 Java 源代码
源代码 添加导入 Ctrl+Shift+M 编辑 Java 源代码
源代码 组织导入 Ctrl+Shift+O 在窗口中
源代码 缩进行 Ctrl+I 编辑 Java 源代码
源代码 除去出现注释 Alt+Shift+U 编辑 Java 源代码
源代码 除去块注释 Ctrl+Shift+\ 编辑 Java 源代码
窗口 上一个编辑器 Ctrl+Shift+F6 在窗口中
窗口 上一个视图 Ctrl+Shift+F7 在窗口中
窗口 上一个透视图 Ctrl+Shift+F8 在窗口中
窗口 下一个编辑器 Ctrl+F6 在窗口中
窗口 下一个视图 Ctrl+F7 在窗口中
窗口 下一个透视图 Ctrl+F8 在窗口中
窗口 切换至编辑器 Ctrl+Shift+E 在窗口中
窗口 将活动视图或编辑器最大化 Ctrl+M 在窗口中
窗口 打开编辑器下拉列表 Ctrl+E 在窗口中
窗口 显示标尺上下文菜单 Ctrl+F10 编辑文本
窗口 显示系统菜单 Alt+- 在窗口中
窗口 显示视图菜单 Ctrl+F10 在窗口中
窗口 显示键辅助 Ctrl+Shift+L 在对话框和窗口中
窗口 激活编辑器 F12 在窗口中
编辑 Add Block Comment Ctrl+Shift+/ Editing in Structured Text Editors
编辑 Format Active Elements Ctrl+I Editing in Structured Text Editors
编辑 Format Document Ctrl+Shift+F Editing in Structured Text Editors
编辑 Move Alt+Shift+V Editing JSP Source
编辑 Occurrences in File Ctrl+Shift+A Editing in Structured Text Editors
编辑 Open Selection F3 Editing in Structured Text Editors
编辑 Quick Fix Ctrl+1 Editing in Structured Text Editors
编辑 Remove Block Comment Ctrl+Shift+\ Editing in Structured Text Editors
编辑 Rename Alt+Shift+R Editing JSP Source
编辑 Rename XSD element Alt+Shift+R Editing XSD context
编辑 Restore Last Selection Alt+Shift+向下键 Editing in Structured Text Editors
编辑 Select Enclosing Element Alt+Shift+向上键 Editing in Structured Text Editors
编辑 Select Next Element Alt+Shift+右箭头 Editing in Structured Text Editors
编辑 Select Previous Element Alt+Shift+左箭头 Editing in Structured Text Editors
编辑 Show Tooltip Description F2 Editing in Structured Text Editors
编辑 Toggle Comment Ctrl+Shift+C Editing in Structured Text Editors
编辑 “快速差别”开关 Ctrl+Shift+Q 编辑文本
编辑 上下文信息 Alt+? 在窗口中
编辑 上下文信息 Alt+Shift+? 在窗口中
编辑 内容辅助 Alt+/ 在对话框和窗口中
编辑 切换插入方式 Ctrl+Shift+Insert 编辑文本
编辑 删除 Delete 在窗口中
编辑 剪切 Ctrl+X 在对话框和窗口中
编辑 剪切 Shift+Delete 在对话框和窗口中
编辑 增量查找 Ctrl+J 编辑文本
编辑 增量逆向查找 Ctrl+Shift+J 编辑文本
编辑 复制 Ctrl+C 在对话框和窗口中
编辑 复制 Ctrl+Insert 在对话框和窗口中
编辑 复原上一个选择 Alt+Shift+向下键 编辑 Java 源代码
编辑 快速修正 Ctrl+1 在窗口中
编辑 撤消 Ctrl+Z 在窗口中
编辑 文字补全 Ctrl+Alt+/ 编辑文本
编辑 显示工具提示描述 F2 编辑 Java 源代码
编辑 查找上一个 Ctrl+Shift+K 编辑文本
编辑 查找下一个 Ctrl+K 编辑文本
编辑 查找并替换 Ctrl+F 在窗口中
编辑 粘贴 Ctrl+V 在对话框和窗口中
编辑 粘贴 Shift+Insert 在对话框和窗口中
编辑 选择上一个元素 Alt+Shift+左箭头 编辑 Java 源代码
编辑 选择下一个元素 Alt+Shift+右箭头 编辑 Java 源代码
编辑 选择全部 Ctrl+A 在对话框和窗口中
编辑 选择外层元素 Alt+Shift+向上键 编辑 Java 源代码
编辑 重做 Ctrl+Y 在窗口中
运行／调试 Debug AspectJ/Java Application Alt+Shift+D，C 在窗口中
运行／调试 Debug on Server Alt+Shift+D，R 在窗口中
运行／调试 EOF Ctrl+Z 在控制台中
运行／调试 Profile on Server Alt+Shift+P，R 在窗口中
运行／调试 Run AspectJ/Java Application Alt+Shift+X，C 在窗口中
运行／调试 Run on Server Alt+Shift+X，R 在窗口中
运行／调试 切换单步执行过滤器 Shift+F5 在窗口中
运行／调试 切换行断点 Ctrl+Shift+B 在窗口中
运行／调试 单步跳入 F5 调试
运行／调试 单步跳入选择的内容 Ctrl+F5 调试
运行／调试 单步跳过 F6 调试
运行／调试 单步返回 F7 调试
运行／调试 执行 Ctrl+U 在窗口中
运行／调试 显示 Ctrl+Shift+D 在对话框和窗口中
运行／调试 检查 Ctrl+Shift+I 在对话框和窗口中
运行／调试 继续 F8 调试
运行／调试 调试 Ant 构建 Alt+Shift+D，Q 在窗口中
运行／调试 调试 Eclipse 应用程序 Alt+Shift+D，E 在窗口中
运行／调试 调试 JUnit 插件测试 Alt+Shift+D，P 在窗口中
运行／调试 调试 JUnit 测试 Alt+Shift+D，T 在窗口中
运行／调试 调试 Java Applet Alt+Shift+D，A 在窗口中
运行／调试 调试 Java 应用程序 Alt+Shift+D，J 在窗口中
运行／调试 调试 SWT 应用程序 Alt+Shift+D，S 在窗口中
运行／调试 调试上次启动 F11 在窗口中
运行／调试 运行 Ant 构建 Alt+Shift+X，Q 在窗口中
运行／调试 运行 Eclipse 应用程序 Alt+Shift+X，E 在窗口中
运行／调试 运行 JUnit 插件测试 Alt+Shift+X，P 在窗口中
运行／调试 运行 JUnit 测试 Alt+Shift+X，T 在窗口中
运行／调试 运行 Java Applet Alt+Shift+X，A 在窗口中
运行／调试 运行 Java 应用程序 Alt+Shift+X，J 在窗口中
运行／调试 运行 SWT 应用程序 Alt+Shift+X，S 在窗口中
运行／调试 运行上次启动 Ctrl+F11 在窗口中
运行／调试 运行至行 Ctrl+R 调试
重构 － Java 内联 Alt+Shift+I 在窗口中
重构 － Java 将局部变量转换为字段 Alt+Shift+F 编辑 Java 源代码
重构 － Java 抽取局部变量 Alt+Shift+L 在窗口中
重构 － Java 抽取方法 Alt+Shift+M 在窗口中
重构 － Java 撤销 － 重构 Alt+Shift+Z 在窗口中
重构 － Java 显示重构快速菜单 Alt+Shift+T 在窗口中
重构 － Java 更改方法特征符 Alt+Shift+C 在窗口中
重构 － Java 移动 － 重构 Alt+Shift+V 在窗口中
重构 － Java 重做 － 重构 Alt+Shift+Y 在窗口中
重构 － Java 重命名 － 重构 Alt+Shift+R 在窗口中
项目 全部构建 Ctrl+B 在窗口中

注：元素引用可以是下面三种权限：
1)<idref bean="person_manager"/>
引用的Bean可以在同一个BeanFactory/ApplicationContext（无论是否在同一个XML文件中）中，也可以在父BeanFactory/ApplicationContext中
2)<idref local="person_manager"/>
引用的bean在同一个XML文件中
3)<idref parent="person_manager"/>
引用的bean必须在当前BeanFactory（ApplicationContext）的父BeanFactory（ApplicationContext）中.

时间: 2006-3-23 12:58:26    标题: Spring学习笔记(二)Bean
Spring使用BeanFactory模式来管理Bean,但Spring中提到的Bean不是标准的意义上的JavaBean(仅包含一个默认的构造函数，在属性后面定义相对应的setter和getter方法),而是任何你想让它管理的类，比如连接池、甚至BeanFactory本身。 一)Bean的设计常用下面几种模式 1、标准Bean: 使用默认的构造函数和基于setter、getter方法的依赖注射 Bean类代码： java代码:  publicclass ExampleBean {     private BeanOne beanOne;     private BeanTwo beanTwo;     privateint count;         publicvoid setBeanOne(BeanOne beanOne){         this.beanOne = beanOne;     }         publicvoid setBeanTwo(BeanTwo beanTwo){         this.beanTwo = beanTwo;     }         publicvoid setCount(int count){         this.count = count;     }    } 在配置文件中定义： java代码:  <bean id="exampleBean" class="examples.ExampleBean">     <property name="beanOne"><ref bean="bean1"/></property>     <property name="beanTwo"><ref bean="bean2"/></property>     <property name="count"><value>1</value></property> </bean> <bean id="bean1" class="examples.BeanOne"/> <bean id="bean2" class="examples.BeanTwo"/> 2、构造函数模式 自定义的构造函数，基于构造函数参数的依赖注射 Bean类代码： java代码:  publicclass ExampleBean {     private BeanOne beanOne;     private BeanTwo beanTwo;     privateint count;         public ExampleBean(BeanOne beanOne, BeanTwo beanTwo, int count){         this.beanOne = beanOne;         this.beanTwo = beanTwo;         this.count = count;     } } 在配置文件中定义： java代码:  <bean id="exampleBean" class="examples.ExampleBean">     <constructor-arg><ref bean="bean1"/></constructor-arg>     <constructor-arg><ref bean="bean2"/></constructor-arg>     <constructor-arg><value>1</value></constructor-arg> </bean> <bean id="bean1" class="examples.BeanOne"/> <bean id="bean2" class="examples.BeanTwo"/> 3、静态工厂方法模式 静态工厂方法必须是static的，基于方法参数的依赖注射。 Bean类代码： java代码:  publicclass ExampleBean {     private BeanOne beanOne;     private BeanTwo beanTwo;     privateint count;     //构造函数私有     private ExampleBean(BeanOne beanOne, BeanTwo beanTwo, int count){         this.beanOne = beanOne;         this.beanTwo = beanTwo;         this.count = count;     }     //对外提供静态的方法     publicstatic ExampleBean createInstance(BeanOne beanOne, BeanTwo beanTwo, int count){         ExampleBean eb = new ExampleBean(beanOne,beanTwo,count);         return eb;     } } 在配置文件中定义： java代码:  <bean id="exampleBean" class="examples.ExampleBean" factory-method="createInstance">     <constructor-arg><ref bean="bean1"/></constructor-arg>     <constructor-arg><ref bean="bean2"/></constructor-arg>     <constructor-arg><value>1</value></constructor-arg> </bean> <bean id="bean1" class="examples.BeanOne"/> <bean id="bean2" class="examples.BeanTwo"/> 3、实例工厂方法模式 调用一个已存在的bean（这个bean应该是工厂类型）的工厂方法来创建新的bean，基于方法参数的依赖注射 该模式没有Bean类； 在配置文件中定义： java代码:  <bean id="exampleBean"       factory-bean="myFactoryBean"       factory-method="createInstance"/> <bean id="myFactoryBean" class="examples.ExampleBean" factory-method="createInstance">     <constructor-arg><ref bean="bean1"/></constructor-arg>     <constructor-arg><ref bean="bean2"/></constructor-arg>     <constructor-arg><value>1</value></constructor-arg> </bean> <bean id="bean1" class="examples.BeanOne"/> <bean id="bean2" class="examples.BeanTwo"/> 二)Bean其它参数的配置 一个常用Bean的配置参数和解释 <bean id="" ——标志符,用它引用唯一的Bean class="" ——该Bean对应的类，前面说到实例工厂方法模式创建的Bean没有类 singleton="" ——值为true或false,标识该Bean是否为单实例模式？如果为false则对这个bean 的每次请求都会创建一个新的bean实例 init-method="" ——向应用层返回引用前执行的初始化方法 destroy-method="" ——该Bean的销毁方法 depends-on=""> ——在Bean加载前，首先加载的指定资源 .... </bean> 三)property(或constructor-arg元素)的配置 1、用字符串形式指定常见类型的属性或参数的value值，JavaBean的PropertyEditor负责类型转化如： java代码:  <property name="driverClassName">     <value>com.mysql.jdbc.Driver</value> </property> <property name="url">     <value>jdbc:mysql://localhost:3306/mydb</value> </property> 2、注意null和""(空串)的区别，如： java代码:  <property name="email"><value></value></property> <property name="email"><null/></property> 3、list、set、map、以及 props 元素用来定义和设置Java对应类型List、Set、Map、和 Properties ，如： java代码:  <property name="school">    <props>       <prop key="school01">The xi'an technology university</prop>       <prop key="school02">The BeiJing university</prop>    </props> </property> <property name="someList">    <list>       <value>a list element followed by a reference</value>       <ref bean="myDataSource"/>    </list> </property> <property name="someMap">    <map>       <entry key="001">          <value>just some string</value>       </entry>       <entry key="yup a ref">          <ref bean="myDataSource"/>       </entry>    </map> </property>         <property name="someSet">       <set>          <value>just some string</value>          <ref bean="myDataSource"/>       </set> </property>

这是好友面试的一道题，其实我知道使用的区别，StringBuffer必须new出来，StringBuffer的append的效率比string的+=的效率高，
其实发现还有很大的区别，看了看以前scjp的考题
public class Test {
   public static void stringReplace (String text) {
   text = text.replace('j' , 'i');
   }
  
   public static void bufferReplace (StringBuffer text) {
   text = text.append("C");
   }
  
    public static void main (String args[]) {
    String textString = new String ("java");
    StringBuffer textBuffer = new StringBuffer ("java");
   
    stringReplace (textString);
    bufferReplace (textBuffer);
   
    System.out.println (textString + textBuffer);
    }
    }
答案是 javajavaC
这是Java参数传递(by value)造成的,是不可变的(immutable).,例如 基本类型，String传值，复制了值传递过去；可变的（Object）传值，复制了引用传递过去。

而题目中第七行text = text.append (“C”)，append方法会改变text中的值
而这个text与main中的textBuffer是指向同一个对象，所以对应的输出是javac。
string的值永远不会改变！

String a = "a";//假设a指向地址0x0001，
a = "b";//重新负值后a指向地址0x0002，但0x0001地址中保存的"a"依旧存在，但已经不再是a所指向的。
从表面上看String类型的对象改变了值，但事实是他不能改变值，只能改变指向的地址

StringBuffer则不同，直接改变指向的地址中保留的值
还有
StringBuffer s1 = new StringBuffer("a");
StringBuffer s2 = new StringBuffer("a");
s1.equals(s2)//为什么是false

String s1 = new String("a");
String s2 = new String("a");
s1.equals(s2)//为什么是true
StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类，
而Object类中的equals方法是用来比较地址的，所以等于false.

String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以会是
true。
对于这样能不能面试出真正的水平，感到怀疑。

前几天接到了新的任务,开始了公司项目管理软件的开发(复杂其中一部分).

这段时间开始由项目经理带着我们开发,这几天跟他学到的东西还是不少的.如果每天都能这样

该多好呀.   而且意识到严谨的学习态度的重要性,不能囫囵吞枣.要学就要学通.

protected void doFilterInternal(HttpServletRequest request, 
             HttpServletResponse response,
           FilterChain filterChain) throws ServletException, IOException {
      SessionFactory sessionFactory = lookupSessionFactory();
      logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");
      Session session = getSession(sessionFactory);
      TransactionSynchronizationManager.bindResource(sessionFactory, 
             new SessionHolder(session));
      try {
            filterChain.doFilter(request, response);
      }
      finally {
            TransactionSynchronizationManager.unbindResource(sessionFactory);
            logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");
            closeSession(session, sessionFactory);
      }
}

publicfinal void setSessionFactory(SessionFactory sessionFactory) {
    this.hibernateTemplate = new HibernateTemplate(sessionFactory);
  }
 protectedfinal HibernateTemplate getHibernateTemplate() {
  return hibernateTemplate;
 }

publicabstract class BaseHibernateObjectDao
      extends HibernateDaoSupport
      implements BaseObjectDao {
            

      protected BaseEntityObject getByClassId(finallong id) {
            BaseEntityObject obj =
                  (BaseEntityObject) getHibernateTemplate()
                        .execute(new HibernateCallback() {
            
                  publicObject doInHibernate(Session session)
                        throws HibernateException {
                        return session.get(getPersistentClass(), 
                                       newLong(id));
                  }
            
            });
            return obj;
      }
            
      public void save(BaseEntityObject entity) {
            getHibernateTemplate().saveOrUpdate(entity);
      }
            
      public void remove(BaseEntityObject entity) {
            try {
            
                  getHibernateTemplate().delete(entity);
            } catch (Exception e) {
                  thrownew FlexEnterpriseDataAccessException(e);
            }
      }
            
      public void refresh(final BaseEntityObject entity) {
            getHibernateTemplate().execute(new HibernateCallback() {
            
                  publicObject doInHibernate(Session session)
                        throws HibernateException {
                        session.refresh(entity);
                        returnnull;
                  }
            
            });
      }
      public void replicate(finalObject entity) {
            getHibernateTemplate().execute(new HibernateCallback() {
            
                  publicObject doInHibernate(Session session)
                        throws HibernateException {
                        session.replicate(entity, 
                                ReplicationMode.OVERWRITE);
                        returnnull;
                  }
            
            });
      }

publicObject execute(HibernateCallback action) throws DataAccessException {
      Session session = (!this.allowCreate ?
            SessionFactoryUtils.getSession(getSessionFactory(), 
                  false) :
            SessionFactoryUtils.getSession(getSessionFactory(),
                  getEntityInterceptor(),
                  getJdbcExceptionTranslator()));
      boolean existingTransaction =  
          TransactionSynchronizationManager.hasResource(getSessionFactory());
      if (!existingTransaction && getFlushMode() == FLUSH_NEVER) {
            session.setFlushMode(FlushMode.NEVER);
      }
      try {
            Object result = action.doInHibernate(session);
            flushIfNecessary(session, existingTransaction);
            return result;
      }
      catch (HibernateException ex) {
            throw convertHibernateAccessException(ex);
      }
      catch (SQLException ex) {
            throw convertJdbcAccessException(ex);
      }
      catch (RuntimeException ex) {
            // callback code threw application exception
            throw ex;
      }
      finally {
            SessionFactoryUtils.closeSessionIfNecessary(
                    session, getSessionFactory());
      }
}

publicstatic void closeSessionIfNecessary(Session session, 
    SessionFactory sessionFactory)   
    throws CleanupFailureDataAccessException {
      if (session == null || 
         TransactionSynchronizationManager.hasResource(sessionFactory)) {
            return;
      }
      logger.debug("Closing Hibernate session");
      try {
            session.close();
      }
      catch (JDBCException ex) {
            // SQLException underneath
            thrownew CleanupFailureDataAccessException(
            "Cannot close Hibernate session", ex.getSQLException());
      }
      catch (HibernateException ex) {
            thrownew CleanupFailureDataAccessException(
            "Cannot close Hibernate session", ex);
      }
}

Category parentCategory  = new Category ();
      parentCategory.setName("parent");
      dao.save(parentCategory);
            
      Category childCategory  = new Category();
        childCategory.setName("child");
            
      parentCategory.addChild(childCategory);
      dao.save(childCategory);
      Category savedParent = dao.getCategory("parent");
      Category savedChild = (Category ) savedParent.getChildren().get(0);
      assertEquals(savedChild, childCategory);
            

1、我认为最关键的，是要让mm看到你的上进心。  

　　男人的最大魅力在于事业有成，年轻人工作时间不长谈不上“有成”，这时候你就要让mm觉得你是

    个有上进心的人。  

　　别的可以胡说八道，但这个问题不能含糊，你一定要告诉mm，你对未来充满信心，你不满足于现状，并且你已经有了长远的计划，总之你的未来不是梦。  

　　2、要显得有信心、有责任心  

　　不要像个小孩子，女孩子都很懒希望能找个依*，你要拿出自己的信心和责任心来。  

　　有一个错的选择总比没有选择要好的多。  

　　3、不要太正经，但也不要太随?nbsp; 

　　该正经的地方就正经，该调侃的的时候就调侃。  

　　女孩子都喜欢有点玩世不恭的男人，所以别显得对什么都特别在意，那样太呆板。  

　　4、显得成熟一点  

　　遇事镇定、从容不迫的男人对mm有致命的吸引力。  

二、如何与mm展开进一步接触（时间：开始追的阶段）  

　　1、这个阶段最关键的是不能着急，不要把事情弄的那么清楚，让人家一眼就能看出你在追人家。  

　　想一想，一般人都不会一眼就看上你，但也不会看一眼就讨厌你，都是老百姓家的孩子（除非你长得象周润发刘德华或者凯文科斯特纳），好感是需要随着了解的不断增加而实现的，所以问题的关键是你要得的进一步发展的机会。  

　　站在女孩子的角度替人家想一想：你这么直接了当的冲过来要搞对象，女孩子肯定有心理压力。这要是接触一阵后发现不喜欢你，那不就成了耍你了么？所以如果你开始就摆出志在必得的姿势出来，基本上会被立刻闷回去。  

　　2、要低姿态起步  

　　首先要把关系定位成“朋友”，本来是“普通朋友”，你希望成为“好朋友”，有品位的还可以要求对方成为“红颜知己”什么的，总之千万不要说“追你”。  

　　你想想，你如果根本不提“追”，那么女孩子也就更没机会“拒绝”你——你没追她怎么拒绝你？！  

　　这样可以减轻女孩子的心理压力，使你们能顺利的交往下去。不要幻想认识三天就答应嫁给你，要充分的交往、了解，感情不是凭空产生的。  

　　3、交往的过程中不要太急躁  

　　要有张有弛，不要整天缠着人家，谁这样对你，你也会腻。我有个好朋友对我说，追女孩子的关键是八个字—— “忽冷忽热、欲擒故纵”（这是我同学多少年心血的结晶）。  

　　你整天缠着人家自然不觉得你好，你适当的冷个一两天，女孩子就会想起你在的好处了。  

　　还有就是不要拿出“非你不娶”的志气来，太掉价了不好，有时候可以耍点花招。  

　　4、要适当的创造机会  

　　前面说了，不要使事情立刻变成“你在追别人”，而你又需要得到接近女孩子的机会，这时就要看你的创造力了。  

　　你可以搜集情报，想办法把守株待兔变成一场邂逅；也可以装做漫不经心的找出最最充足的理由邀请对方和你一起做什么事。  

　　总之这个是最有技术含量的地方，实在不行可以找前辈请教。  

　　5、切忌切忌：随便送人家礼物是不礼貌的  

　　有些人追女孩子心切，喜欢经常买东西送人家，殊不知追女孩子最忌讳这个。  

　　俗话说“无功不受禄”，你这样送人家东西就是在施加压力，人家会觉得欠你的，所以会想办法还给你，如果没办法还给你就会想办法不和你交往，免得总是欠你人情。  

　　如果你想显示自己的诚意，倒不妨请女孩子一起消费，比如说找好的餐厅吃饭，或者找贵的地方一起玩什么的，女孩子自然能看出你花了很多钱，但钱终究是两个人一起花了而不是变成东西带回家。  

三、“女朋友”到底是什么？  

　　1、“女朋友”是一种事

实，而不是一份承诺  

　　你和女孩子开始交往，从“普通朋友”变成“好朋友”，再到“非常非常好、无话不谈的朋友”，某一个阳光灿烂的午后，你“不小心”拉了她的手；“月上柳梢头”，你突然袭击吻了她。这时她就已经是你的女朋友了，无论她是否承认，她心理已经认为你是他男友了。  

　　我知道最高明的，直到上床了都没问过“你是否愿意做我女朋友”，最后还是女孩子急了：“你怎么还不求我做你女朋友啊！”  

　　所以说，千万不要急于把窗户纸捅破，情况越朦胧对你越有利。  

　　2、“表白”是什么？  

　　前面说了，表白实际上就是一个形式而已，正确的顺序应该是：事实上已经成为你女朋友了，你才能向人家表白，水到渠成。 很多人弄不明白这个问题，总以为人家先答应做自己女朋友，然后再如何如何，我只能说他非常非常“单纯”，也非常非常“愚蠢”。  

　　3、有没有“迫不得已非表白不可”的时候？  

　　有，比如说出现第三者，或者你和女孩子关系没有成熟但两个人可能分开一段时间。  

　　这时候的表白就是条件不成熟的表白，风险非常大，类似于下围棋的时候形势严峻，落後的一方迫于无奈放出“胜负手”，赢了就赢了，输了也只能说“倒霉都是天生的”。  

　　4、“爱”字不要轻易出口  

　　经常看见论坛出现“大胆的表白”，说实话我真的认为这是非常不成熟的一种表现。“爱”是一个神圣的字，意味着追求，也意味着承诺，甚至体现出一种责任。  

　　随便说“爱”的男人是不负责任的。  

四、文明恋爱，不可强求  

　　1、不是每个mm都能追到手的  

　　好女孩总会有很多人追，不可能遂了每个人的心愿，总会有失败者。举个例子，就算你刻苦钻研掌握了最搞超的追mm原理，你一样追不上twins里的任何一个。  

　　换个角度考虑问题，一个小学没毕业的农村小保姆，即使对你再好，每个月赚600给你买700的礼物（透支），愿意为你“当牛做马”，你也不会爱上她。如果她每天哭哭啼啼的缠着，你肯定觉得烦。  

　　所以说爱情是需要物质基础的，至少需要平衡。  

　　2、追mm做是一种严肃的社会活动  

　　千万不要把人家搞烦了，要给自己留后路。大丈夫何患无妻？有些mm确实势利眼（少数），如果不服气，你可以发愤图强，用事实证明“她当时瞎了眼”，绝对不要误人误己。 　　  

　　最后补充一点千万不要在mm面前显得愤世嫉俗，愤世嫉俗有时候意味着“你很失败”