2005年3月17日
Ubuntu is not an official supported linux version from Oracle, so I still get some errors during the install process even with required configuration, anyway, it can work and what i'm doing here is try to setup an experiment environment, it's enough to me, any one who want to deploy Oracle in product mode should have supported linux platform like RedHat, OK, following is the steps i have to install it:
1. If you were in multihomed enviroment, set the ORACLE_HOSTNAME variable:
export ORACLE_HOSTNAME=machine_name.domain_name
2. Create create OSDBA (dba) group, Oracle Inventory group (oinstall) and a user "oracle" which has "dba" as its login group and oinstall as its 2nd group.
3. Modify /etc/sysctl.conf, set kernel parameter:
kernel.shmall = 2097152
kernel.shmmax = 2147483648
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
fs.file-max = 65536
net.ipv4.ip_local_port_range = 1024 65000
net.core.rmem_default = 1048576
net.core.rmem_max = 1048576
net.core.wmem_default = 262144
net.core.wmem_max = 262144
4. Modify /etc/security/limits.conf to improve the "number of process" and "number of open file" performance for oracle:
oracle soft nproc 2047
oracle hard nproc 16384
oracle soft nofile 1024
oracle hard nofile 65536
5. Modify /etc/pam.d/login, add:
session required /lib/security/pam_limits.so
session required pam_limits.so
6. Modify /etc/profile:
if [ $USER = "oracle" ]; then
if [ $SHELL = "/bin/ksh" ]; then
ulimit -p 16384
ulimit -n 65536
else
ulimit -u 16384 -n 65536
fi
fi
7. Change user to oracle if you haven't done it yet
8. Create base directory, for me it's "/app/oracle"
9. Export ORACLE_BASE, ORACLE_SID
export ORACLE_BASE=/app/oracle
export ORACLE_SID=orcl
10. If you're trying to install oracle with a X window:
DISPLAY=your.ip.address:0.0 ; export DISPLAY
11. run installer:
./runInstaller
12. Oracle should start, if the installer GUI cannot be start, check the error messages, most time it's because a wrong X window configuration, if you are running X window with Xming, just like me, please do make sure to check the "No Access Control" check box in the launch, otherwise, Xming will reject the connection.
13. Now the GUI shoudl open, like what you did in the Windows system, fullfill required value and click next, ingore all errors if there is any condition that is not match, click finish in the last step, it should start install process.
14. After install oracle, the installer GUI will ask you to run two .sh files, run it with a root role.
15. You can try to visit
https://you.ip.address:1158/em to see is that OK for you.
16. How to start oracle:
export ORACLE_BASE=/app/oracle
export ORACLE_HOME=/app/oracle/product/11.2.0/dbhome_1
export ORACLE_OWNR=oracle
export ORACLE_SID=orcl
export PATH=$PATH:$ORACLE_HOME/bin
lsnrctl start
sqlplus /nolog
connect /as sysdba
startup
quit
emctl start dbconsole
Reference
http://download.oracle.com/docs/cd/B19306_01/install.102/b15660/pre_install.htm#BABDFJAE
1. Type command: lsusb
Bus 002 Device 003: ID 19d2:fff5 ONDA Communication S.p.A.
2. Install "usb-modeswitch", then re-plugin modem again and input command "lsusb" again, you should get the following output
Bus 002 Device 003: ID 19d2:fff1 ONDA Communication S.p.A.
3. Notice in step #2, the product code has been changed from "fff5" to "fff1".
4. Install package "wvdial" which is used to dail up
5. Type command: "sudo modprobe usbserial vendor=0x19d2 product=0xfff1", don't forget the "sudo"
6. Type command: "sudo wvdialconf", again don't forget the "sudo", this will detect your modem
7. Modify file "/etc/wvdial.conf", following is what I have:
[Dialer Defaults]
Init1 = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Modem Type = Analog Modem
ISDN = 0
New PPPD = 1
Phone = #777
Modem = /dev/ttyUSB0
Username = yourName
Password = yourPassword
Baud = 921600
Stupid Mode = 1
Tonline = 0
8. Repeat step #5 again and then if you with not bad luck type in command "sudo wvdial", you should connect in.
9. If bad luck with you, click right-upper corner, there is a connection configuration menu, you can create "Mobile Broadband" connection yourself here, don't forget input the phone number "#777" (for China Telcom) and your username password, after that click connect, this works for me.
10. Good luck with you.
11. BTW, if it still cannot work, try to re-plug in the modem.
1. It will not get data from DB when just open the cursor, data will be loaded as an ongoing basis.
2. SCN: System Change Number/System Commit Number
3. FLASH BACK AS OF SCN;
4. You can also flash back table: FLASHBACK TABLE SOME_TABLE TO SCN :SCN_NUM;
5. But before you do a flash back operation on a table, do make sure you have already enbale ROW MOVEMENT on that table.
1. Do use oracle "Bind variable", it can increase the speed by 90 percent in 10g release1.
2. Understand how to use "lock", read never block write, vice verse.
3. There is a side effect from oracle regarding to the "lock", if you do want to control the access to one row at a specify time (like doing an if 'this row belong to some search condition' then 'modify this row' action), you have to write some logic yourself, for example use the "for update" statement, like: "select * from x where x.id = 1 for update", so that you can lock the row only with id equals to '1' and then modify this row, so that some orther concurrence requests should execute the same sql first, yes, with the same 'for update' statement, and because you already have locked this row(id = 1), orther requests cannot get the access to it, and you get the access control to this row.
4. Regardint to item 3, it will not decrease the concurrence level, because first you only lock the item with id equals to 1 and there maybe thousands of items in your table, second, it will not block the read request.
这该死的问题让我竟然没有想到解决方案...脑子生锈了？呵呵，算了...
该问题最经典的解答，简直是一句话惊醒梦中人啊
“用两个指针，一个的步长为 1，另外一个的为 2，从表头开始一起往前走，如果相遇，表明有环路，否则就是没有了。”
下来，不用说什么了吧，用JAVA实现的话，声明两个Iterator A 和 B，A 每次调用两个NEXT，B只调用一次，如果他们能够相遇，就是有环...我操
The first is about identity generator, this is something I ingored and find really interesting later when I read back the document.
When you choose "native" (for plain
hibernate) or "AUTO" (for JPA which use
hibernate as provider) as identity generator, it (actually they are the same identity generator but with different name in different scope) will pick other identity generators like identity, sequence, or hilo, depending on the capabilities of the underlying database. Use this generator to keep your mapping metadata portable to different database management systems.
If your underlying DB is oracle, it will automatically create a sequence for you which means choose the sequence as identity generator, that's really interesting, at least for me for the first time when it comes to me.
The second is about the flush and close session operations when to use hibernate with JTA transaction.
You should manually flush your operation by call flush method and close your session by calling close method when you try to use JTA transaction instead of
hibernate Transaction API, these is because
hibernate Transaction API does thoes operations automatically for you. But, with following configuration, it can also be done automatically for you by
hibernate, though you are still with JTA transaction.
hibernate.transaction.flush_before_completion=true
hibernate.transaction.auto_close_session=true
The third is about an interesting code snatch listed as follow:
1 Session session = sessionFactory.openSession();
2 session.beginTransaction();
3 session.save(new Item());
4 session.close();
What happen if you don't commit the transaction? It's depends on the underlying DB, for oracle it will commit any uncommited transactions, but for many other DB vendors, they will roll back any pending transactions.
Timer service in EJB3 with anotation is fairly simple, I give you an example as follow, and it's really simple and self-explanation:
1 package com.ramon.expejb3.session.impl;
2
3 import javax.annotation.Resource;
4 import javax.ejb.Stateless;
5 import javax.ejb.Timeout;
6 import javax.ejb.Timer;
7 import javax.ejb.TimerService;
8
9 import com.ramon.expejb3.session.Greeting;
10
11 @Stateless(name = "Greeting")
12 public class GreetingBean implements Greeting {
13
14 @Resource
15 TimerService ts;
16
17 /* (non-Javadoc)
18 * @see com.ramon.expejb3.session.Greeting#greeting(java.lang.String)
19 */
20 public void greeting(String name) {
21 System.out.println("Hello " + name + ".");
22 ts.createTimer(1 * 1000, 5 * 1000, name);
23 System.out.println("Create timer for " + name + ".");
24 }
25
26 @Timeout
27 public void timeout(Timer timer) {
28 String name = (String)timer.getInfo();
29 System.out.println(name + " TIME OUT.");
30 //timer.cancel();
31 }
32 }
33
It's the "
GreetingBean" I introduced in part one of this series article with TimerService injected,
@Resource anotation inject the time service we want, it's totally free which is supported by the J2EE container that means we do not need any further steps to get the powerful schedule service. In the line 22, I crate a new timer, I think this could be more fit if it was called Task instead, there are several "createTimer" methods with different parameters, the one I used here describe the task should be execute 1 second delay and every 5 second one time in the future, the third parameter can be anything you want to pass in to the task, it can be get back use method Timer.getInfo() like line 28 does here.
Another important anotation here is the @Timeout anotation, this anotation tell container which method will be called when timeout for this task to be executed, you can only specify one timeout method for each Bean, if there is no @Timeout anotation at all, you will get some exception like "No timeout method specified" in Jboss server. Something funny here is that you should mark the timeout method as "public", otherwise, you will get the same error as no timeout method does, I do NOT think it's necessary, because the time out method should only be called by the container, "private" signature is enought for that, with "private" signature container still has the right to access this method with java reflection, nevertheless timer service in EJB3 is still a good tools for use.
I summarize what good/bad for timer service in EJB3 as follow:
Good news:
- It's free, it's supported by the EJB container.
- It's portable, it's supported by the EJB container as specified in EJB3 specification.
- It's easy to use, no need to learn more.
Bad news:
- The feature of EJB3 timer sevice is not as powerful as some third party timer service such as Quartz, but it's enough with EJB3 for ordinary daily job.
- There is no UI for you to monitor the timer you created.
摘要: MDB is the MVP(most valuable player) both in previous EJB version
and EJB3. Although coding with MDB is simple in EJB2.x, EJB3 make it
much more friendly to you. Let's get to the ...
阅读全文
Recently I did some research on EJB3 programming, find that it's really simple than programming with previous EJB version. Coding in EJB2.X or previous version is really a nightmare for most developers, maybe for this, EJB3 gives me much more impression than Spring when it first comes to me, this article is the first one of these series articles which record the new knowledge I find interesting in EJB3.
Well, let's begin.
EJB3 is simple with AOP and DI, there is no Home interface any more, only with Service Interface and your Service implementation you can create an typical EJB3 application. I will create a simple hello world program in this article, the service interface as follow:
1 package com.ramon.expejb3.session;
2
3 import javax.ejb.Remote;
4
5 @Remote
6 public interface Greeting {
7
8 /**
9 * say hello test
10 * @param name
11 */
12 void greeting(String name);
13
14 }
It's really simple, especially for you that are familiar with programing with Interface, after that is the service implementation code:
1 package com.ramon.expejb3.session.impl;
2
3 import javax.annotation.PostConstruct;
4 import javax.annotation.PreDestroy;
5 import javax.ejb.Stateless;
6
7 import com.ramon.expejb3.session.Greeting;
8
9 @Stateless(name = "Greeting")
10 public class GreetingBean implements Greeting {
11
12 @PostConstruct
13 public void init() {
14 System.out.println("Init Greeting Bean.");
15 }
16
17 @PreDestroy
18 public void destroy() {
19 System.out.println("Garbage collect Greeting Bean.");
20 }
21
22 /* (non-Javadoc)
23 * @see com.ramon.expejb3.session.Greeting#greeting(java.lang.String)
24 */
25 public void greeting(String name) {
26 System.out.println("Hello " + name + ".");
27 }
28 }
29
Still simple and very self-explanation,
@Stateless(name = "Greeting") specify the JNDI name for client invocation. OK, that's all for our EJB jar file, no more file needed for this simple hello application. Execute your ANT script make a jar for it, part of ANT script may look like:
1 <target name="prepareexpejb3" description="Create exp_jsf distribution.">
2 <mkdir dir="${dist.dir}" />
3 <mkdir dir="${build.dir}" />
4 <mkdir dir="${build.core.dir}"/>
5 </target>
6
7 <!-- =================================
8 target: Compile expejb3 classes
9 ================================= -->
10 <target name="compileexpejb3" depends="cleanDist,prepareexpejb3">
11 <javac destdir="${build.core.dir}" debug="yes" deprecation="on" srcdir="${src.dir}">
12 <include name="${core.src.dir}/**" />
13 <classpath refid="expejb3.classpath" />
14 </javac>
15
16 </target>
17
18 <!-- =================================
19 target: Create EJB3 jar
20 ================================= -->
21 <target name="createEJB3Jar" depends="compileexpejb3">
22 <jar jarfile="${dist.dir}/${expejb3.core.name}.jar">
23 <fileset dir="${build.core.dir}"></fileset>
24 </jar>
25 </target>
Put the EJB jar into jboss server server\default\deploy, you should see some log from jboss console like:
1 10:59:27,036 INFO [JmxKernelAbstraction] creating wrapper delegate for: org.jboss.ejb3.stateless.St
2 atelessContainer
3 10:59:27,051 INFO [JmxKernelAbstraction] installing MBean: jboss.j2ee:jar=expejb3core.jar,name=Gree
4 ting,service=EJB3 with dependencies:
5 10:59:27,208 INFO [EJBContainer] STARTED EJB: com.ramon.expejb3.session.impl.GreetingBean ejbName:
6 Greeting
Which mean that you have successfully deploy your EJB into jboss server, create a client code to invoke your EJB service:
1 package com.ramon.expejb3.session;
2
3 import java.util.Properties;
4
5 import javax.naming.Context;
6 import javax.naming.InitialContext;
7
8 import junit.framework.TestCase;
9
10 public class ExpEJB3BaseTestCase extends TestCase {
11
12 private Properties properties = null;
13
14 private Context context;
15
16 protected void setUp() throws Exception {
17 super.setUp();
18 properties = new Properties();
19 properties.put("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
20 properties.put("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
21 properties.put("java.naming.provider.url", "localhost:1099");
22 context = new InitialContext(properties);
23 }
24
25 protected void tearDown() throws Exception {
26 super.tearDown();
27 context = null;
28 properties = null;
29 }
30
31 public final Context getContext() {
32 return context;
33 }
34
35 public final void setContext(Context context) {
36 this.context = context;
37 }
38
39 }
40
1 package com.ramon.expejb3.session.impl;
2
3 import javax.naming.NamingException;
4
5 import com.ramon.expejb3.session.ExpEJB3BaseTestCase;
6 import com.ramon.expejb3.session.Greeting;
7
8 public class GreetingBeanTest extends ExpEJB3BaseTestCase {
9
10 public void testGreeting() {
11 try {
12 Greeting greetService = (Greeting)this.getContext().lookup("Greeting/remote");
13 greetService.greeting("Ramon");
14 } catch (NamingException e) {
15 // TODO Auto-generated catch block
16 e.printStackTrace();
17 }
18 }
19
20 }
21
That's really simple, right? What you should note is that you must include following jars into your classpath when you run this clien test case, otherwise you will get the annoying classNotFound Exception:
1 concurrent.jar
2 jboss-aop-jdk50.jar
3 jboss-aspect-library-jdk50.jar
4 jboss-common.jar
5 jboss-ejb3.jar
6 jboss-ejb3-client.jar
7 jboss-remoting.jar
8 jbossx-client.jar
9 jboss-transaction-client.jar
10 jnp-client.jar
摘要: 本文介绍了编码字符集的概念以及Java与编码字符集之间的关系，文章的内容来自于本人工作过程中的经验积累以及网络中的相关文章介绍，如果文章中有任何纰漏欢迎读者指正，让我们共同讨论学习J1． 字符字符是抽象的最小文本单位。它没有固定的形状（可能是一个字形），而且没有值。“A”是一个字符，“€”（德国、法国和许多其他欧洲国家通用货币的标志）也是一个字符。“中”“国”这是两个汉字字符。字符仅仅代...
阅读全文
首先感谢南老师!
在计算机里的有符号数，最高位的1用来表示负号，所以，用 0000 0001表示正1，1000 0001表示-1，确实对人来说很直观。但其实，计算机里的数是用“补码”表示的。其中正数的补码就是原来的数（称为原码），而负数的补码是这么算的，我用倒推的来说：
补码 = 反码 + 1
反码 = 原码按位取反（1变0，0变1）
所以，-1就是1取补码，过程如下：
先取反 0000 0001 ---> 1111 1110
然后加1得补码： 1111 1110 + 1 = 1111 1111
（当然这里为了方便，就取了8位，其实整数现在都是32位了，结果是32个1）。
现在，你知道如何计算-2了吗？ 为什么要搞反码，补码这么个转换呢？ 这个原因要说长就很长的，但简单地讲，这又是一个在人的直观和机器的高效之间取一个平衡：
我们先来看一个10进制的数运算：
1 + (-1) = 0 //10进制中，1加负1应为0.
然后，假如用1000 0001来表示－1的话。按照计算机计算加法的规则，它是每位加的，结果是：
0000 0001 + 1000 0001 = 1000 0010 //-2
结果变成－2了，其中后面两个0001 相加变成2，而前面的用于表示负号的1，被“继承”下来了……显然，原来计算机最直观的（对人来说也很直观的）算法，不灵了！怎么办？痛苦
但更痛苦的事还在0这个数上。按10进制，0和-0可是完全相等的。但如果用二进制，0000 0000 和 1000 0000 参加起运算，可是完全不同。或许可以通过电路设计，来强制让计算机去实现一个规则： 碰到1000 0000就先转换为0000 0000。但可要知道加减法计算是计算机计算一切的基础，如果从这最底层就必须有一个转换会极大影响性能！何况前面那个问题也必须有个强制规则！规则最好越简单越好，那就是规定前面的补码转换规则，这个转换过程对于计算机来说很迅速的逻辑电路转换。
你看，第一个问题 1 ＋ （－1）
0000 0001 + 1111 1111 = 0000 0000
看明白这个计算过程吗？其实就是最低位的两个1相加后，造成每一位都进位，最高位直接溢出（丢了）。如果你还算不清，就算算这个10进制的：
1 + 999 = 1000 (最高位1丢失，就成0了)
然后是第二个问题，0的表示。如果您把0当成正数，那么它是这样表示的：
0000 0000
如果你当它是负数，那么
取反 1111 1111 ，再加1，以求补 ，哈哈又成 0000 0000这回在逻辑上没有错误了！明白了吧？当补我在学习这一段知识时，只能说：高，实在高！ 想出补码的前辈，真是高人啊。
This article is focused on which approach we should choose for unit testing against Struts action, I hope it will give you some help when you have question on how to do unit testing against the controller in MVC.
OK, let's begin!
In container? Mock objects?
There are two kinds of testing, one is in-container and the other is do testing with mock objects. Generally speaking, it was considered to be more really and truly unit testing when you do testing with mock objects, especially when you do testing against java source files which should be run in J2EE container, but as our code become complex which contain more layers, the controller(Struts) will have more depends on the other layer which may be EJB service or other business objects, so when you do unit testing against view layer(here is Struts), it will be a huge work for you to construct the mock objects and also it will have more source code changed as you apply mock objects in your source code, the following is a simply description which describe the classic three layers project, and also considerd to be the most common type of web based project.
e.g. the Struts action class first call the EJB factory to get an EJB service, and then ask this EJB service to do the work according to the business logic and return the value we need, with the value EJB service returned the action class can choose which page to redirect or do some other data processing ,this could be the classic three layers type, maybe the most common type project we used in our project.
Therefore, it may not be the best choice for every web based project to apply mock objects unit testing. In the case that Struts action class is close tied with your business object, in-container testing may be an alternate choice for you, because it save your time to write mock objects and the workload to apply the mock objects into your source files but supply the same testing resluts.
In-container testing sounds good, but when you do testing in this style, it first assume that the depended business service classes used in our Struts action must be verified, if the depended service classes have some defect that happen to be met when we run in-container testing, it will take more time to find which cause the error indeed.
But I think if we have a complete testing procedure, which cover the service layer and the controller, the service layer have already been verified properly, in-container testing is really the best choice for you to use for testing action class. For project in practice, the Struts action is more or less close tied with other layer, it's not realistic to spend more time on writing mock objects or modifying your source code to apply the mock objects. In my opinion, the recommended solution is that you should focus on Struts layer testing, if the Struts action code is close tied with other service layer which I mean is that there may be only one execute() method in every Struts action take charge for the whole business logic, you should use in-container testing, let other unit testing stuff take charge for service layer which may be out of container unit testing against EJB, in this way you can write your test case at your pleasure, forget the depended layers for a while, the container will take care for other layers for you, and also it will save you lots of time for writing mock objects, the container will give you the real objects instead of mock objects.Mock object testing is more often used for the simple Struts action or the case that it could be influenced by the container when you do unit testing against Struts action.
I will write some thing when I have time tomorrow, sorry, it's already 1:00 AM at midnight, so you guys could see some thing right now, hey hey. It's mainly about how to automatic do unit testing in container with strutstestcase and ANT, hope it will be useful for you guys.
由于最近在把以前的一个设计移到hibernate上来，所以需要用到one-to-one，因为在以前的设计中需要用到在一个主表中对于多个子表的主键关联，所以一开始就想到了one-to-one的应用，觉得这样解决不但不会引起以前数据设计的改变，也能够很好的利用hibernate所带来的OR优势，可是当实际使用的时候发现，在插入数据的时候可以有选择的在任意子表中进行插入，所有的结果都在原来的预期之中，但是在查询的时候，比如说只查询主表中的内容
From tableMain仅仅执行看起来十分简单的一条语句，你所期望的是他紧紧查询T_MAIN这张主表，可是结果确实hibernate通过多个外连接将所有的子表一口气的全部查询出来
select * from t_main main outer join t_sub1 sub1 on main.id = sub1.id outer join t_sub2 sub2 on main.id = sub2.id... 如此的效率绝对让你头痛不已，不仅如此，如果你通过首先获得子表t_sub1的某个主键ID，然后通过这个主键查询出子表对象，在关联至住表，同样的情况又会发生，又会生成类似的SQL语句，这样一来看来对于这个设计应用one-to-one本身就是一种错误，是这样吗？
或许有人认为我们在每个one-to-one中加入lazy="true"这个属性会杜绝上述情况的发生，经过笔者的证实即便你加入了lazy="true"，也不会带来任何的改变；又或者在hibernate.config中加入fetch depth属性以及在每个关联中设置outer-join="false"，这些都不会引起本质上的变化，加入outer-join="false"其实结果只是将原有的outer join语句改变成多条sql语句而已，并没发生什么本质变化，反而效率更低了。
该怎么办呢？我们先仔细研究一下one-to-one的概念，one to one代表一对一，在一般的模型中很少会遇到one-to-one这种概念，因为他十分强调一对一的概念，就好比一个人他只有一个身体和一个头而已，头和身体是十分好的例子，因为有身体必定只有一个头，而且说到了身体必定要说头，就好像看了某个女孩的身材必定想知道她的长相如何（-_-），所以在这时我们使用one-to-one，因为这种一对一的关系是很强的，而且从对象中取得body必定会取得他所关联的head，这样的情况下使用outer-join是十分方便和有效率的，因为它使用了outer join查询从而避免了两条到数据库的查询语句，而且在这种情况下也只需要在body_hbm.xml中设置一个one-to-one即可，所以在这种确实是一对一
而且在主表中一对一的关联个数（即主表中one-to-one标签）十分少的情况下，使用one-to-one是一种很不错的解决办法。
如果一个主表会对多个子表都进行one-to-one关联呢，就像我们一开始遇到的这种情况，比如你不仅仅只想了解那个你中意的女孩的身材和脸蛋，而且还想知道他的学历，身世等等一切，在这种情况下，如果我们都是用多个one-to-one在主表中的话，那情况正如我们一开始看见的，是十分可怕的，该怎么做呢？不妨考虑一下使用one-to-many，什么，many?一开始听到many这个词的时候，我也觉得挺惊讶的这明明是多个一对一的关联为什么要用到many呢？其实many并没有一定要说是大于一的，你就只在它的many中存在一个关联它有能乃你何呢？如果用到many的话，我们就需要改动数据表的设计了，在每个有关连的子表中加入一列main_id代表主表中该记录的主键子段值，只需要这样子改动就可以了，这样所带来的效果绝对是值得你这样做的，然后我们就按照以往的one-to-many来设计就好了
在body.hbm.xml加入（一到head的关联举例，其他的关联按照这样的格式添加即可）
<set name="head" inverse="true" lazy="true" cascade="all-delete-orphan">
<key column="ID0000"/>
<one-to-many class="com.xx.Head"/>
</set>
在head.hbm.xml加入
<many-to-one name="body" column="ID0000" class="com.xx.Body" not-null="true"/>
行了，经过上面的改动我们就摆脱了查询时多个outer-join的困扰，只在需要的时候才对子表进行查询，因为设置了lazy="true"，所以一切的一切都在我们的预料之中，我们如果希望获得body的话hibernate绝对不会把它的head 也查询出来，节省了查询是所需要的负担，除非到了我们十分需要head的情况才会进行关联查询，获得所需要的head结果。
所以由此看来
在one-to-one这种一对一的关系不是很强的情况下，或者是在一张表中存在多个one-to-one的情况下，使用one-to-many来代替one-to-one不失为一种不错的做法，当然更重要的良好的数据库设计，hibernate毕竟只是末，
千万不要本末倒置。
one-to-one在hibernate中可以用来作为两张表之间的主键关联，这也是hibernate中主键关联的一种用法，这样在一张表中的ID，在生成另外一张表的同时回自动插入到相应的ID字段中去，相应的XML文件设置比较简单，举例如下：
<!-- 建立一对一的到Address的映射，这个是写在User的XML配置文件中的 -->
<!-- 相应的User bean（PO）中也要添加属性 com.xx.Address address-->
<one-to-one name="address" cascade="all" class="com.xx.Address"/>
<!-- cascade的属性设置不再重复了，可以查看hibernate文档 -->
<!-- 建立一对一的到User的映射，这个是写在Address的XML配置文件中的 -->
<!-- 相应的Address bean（PO）中也要添加属性 com.xx.User user--> -->
<one-to-one name="user" class="com.xx.User" constrained="true"/>
为了在Address中使用User中的主键ID值，我们需要设置Address中的主键生成规则，如下所示，采用foreign关键字
<id column="ID" name="id" type="long" unsaved-value="0">
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
这里需要注意的是property的属性值必须与上面到User的映射所填写的name属性值一致，这样就完成了one-to-one的映射关系。
上面的过程都很简单，下面我来说说这里需要注意的地方：
1. 在设置属性ID的时候必须注意字段的长度，如笔者这样使用oracle的sequence来生成ID，其长度有14位之长，则应选择hibernate类型long，对应的实体中应选择Long，这样不会出现溢出的情况。
2. 在测试的时候必须要注意这两张表之间因为已经存在了一对一的关系，所以我们不能只写
user.setAddress(address);
而忽略了
address.setUser(user);
这样在做插入的时候会报出attempted to assign id from null one-to-one property: address的错误，这一点初学者会经常犯，笔者也是其中之一。
3. 如果不写cascade="all"或者写成cascade="none"的话，即使你写了
user.setAddress(address);
address.setUser(user);
也不会发生任何事情，只有user会被存储。
以上是一些笔者经历的小经验，如果有不对的地方欢迎指正。
在很多情况下，我们使用Hibernate在已经建立好数据库的基础上。在oracle中，如果已经建立好的数据库中使用了sequence,则可以按照下面的步骤把它引入到Hibernate中：
1、在oracle 首先创建sequence
create sequence seq_id
minvalue 1
start with 1
increment by 1
cache 20;
2.在你的hbm.xml中的配置
<id column="ID0000" name="id" type="integer">
<generator class="sequence">
<param name="sequence">seq_id</param>
</generator>
</id>
这样再插入数据的时候，Hibernate回自动生成如下语句：
hibernate: select seq_id.nextval from dual
hibernate: insert into YXJK.T_YXJK_WHRYTXL (XM0000, ZW0000, LXDH00, SJHM00, DZYJ00,
IP0000, ID0000) values (?, ?, ?, ?, ?, ?, ?)
自动生成下一个序列值，然后将对象插入表中。
在使用的时候需要注意，Hibernate对于sequence的主键的要求是一定要是shor,long，或者integer
在做具有MVC结构的B/S程序时，怎样将这三层隔离开是十分关键的，一般用DAO封装Hibernate来获得对数据库的具体操作，在这里我们可以为每一个需要建立O-R MAPPING的对象（通过Hibernate实现OR映射）实现一个DAO，然后通过这个DAO来获得具体的数据库操作，用DAO的好处是我们可以把对一个对象的操作集中在同一个DAO中，便于管理，另外向上层只提供了接口屏蔽了底层对数据库的操作，通过hibernate，我们向上层直接提供建立了O－R MAPPING的OBJECT；同时在领域模型这一层，也就是M这一层，我们将一些业务逻辑（business logic）封装进来，这里所指的M这一层通常也就是我们在Hibernate中所用到的plain objectS，就是用来建立O-R MAPPING所需要用到的与表对应的OBJECTs，一般的领域模型都是由这些plain objectS构成；这样我们在控制层也就是C这一层只需要初始化DAO打开到持久层的通路，然后调用一些简单的方法执行业务逻辑，请注意这时候我们的业务逻辑已经被封装在领域模型这一层中了，这样我们每一层都是相互独立的，控制层C和展现层V都不和持久层所提供的接口有关系
今天的主要收获是发现通过在servlet的Filter中实现session.begin()，session.close()，session.beginTransaction()以及transaction.commit()是一个不错的选择
如上图这样，在从服务器端返回到客户端的时候，也就是在转向到最终页面的时候，由Filter实现关闭session和transaction，是一个很好的实现方法