j2ee学习
这两天又遇到了中文乱码问题,上次本来已经解决了,但是这次用的是一对多双向关系,遇到了新的问题,就是第一条信息插入时是正常的中文,但是当接着再插入一条信息时,上一条的中文信息就变成了乱码,依次类推到n条.还有一个问题是当查看某条信息时,原来正常的中文也就变成了乱码,(点击的信息有连接,是为了记录点击次数设的).这两个问题用了我很长时间.
现在总算弄明白了,我发现最近遇到的问题都是和hibernate有关,还是一个老问题,主要对hibernate的细节问题不精,以致有很多不合理的设置,自己看不出来.
比如:<many-to-one
name="user"
column="userid"
class="news.User"
cascade="none"
/>
中的cascade的各种取值的具体含义,及hibernate中的udate数据库表中某一个字段时,它和平时用的sql语句不一样,它联及更新所有的字段值.
现在总算弄明白了,我发现最近遇到的问题都是和hibernate有关,还是一个老问题,主要对hibernate的细节问题不精,以致有很多不合理的设置,自己看不出来.
比如:<many-to-one
name="user"
column="userid"
class="news.User"
cascade="none"
/>
中的cascade的各种取值的具体含义,及hibernate中的udate数据库表中某一个字段时,它和平时用的sql语句不一样,它联及更新所有的字段值.
lunzi
2006-06-09 14:18:49
阅读:2323
评论:0
引用:0
今天上网查东西时看到了在线的appfuse代码,借鉴了其中的几个方法,在线的文档看起来层次结构比较清晰,给人的感觉比较好一点.
lunzi
2006-06-07 01:51:09
阅读:414
评论:0
引用:0
最近想用spring+hibernate实现一个一对多双向关系的测试，把环境配置好后，在测试过程中老是给我这样的错误提示：Exception in thread "main" java.lang.NoClassDefFoundError: org/odmg/DSet。看提示只知道找不到这个类文件。可这个类文件来自那自己弄不清，单单这个就浪费了我半个晚上的时间，今天昨想又想，决定去网上搜一下，没想到还真找到了答案。原来hibernate环境出了问题，是少导入了odmg.jar 文件。解决此问题参考的资料。
lunzi
2006-06-06 18:59:20
阅读:1153
评论:3
引用:0
一、Spring的IoC(Inversion of Control)。
这是Spring中得有特点的一部份。IoC又被翻译成“控制反转”，也不知道是谁翻译得这么别扭，感觉很深奥的词。其实，原理很简单，用一句通俗的话来说：就是用XML来定义生成的对象。IoC其实是一种设计模式，Spring只是实现了这种设计模式。
这种设计模式是怎么来的呢？是实践中逐渐形成的。
第一阶段：用普通的无模式来写Java程序。一般初学者都要经过这个阶段。
第二阶段：频繁的开始使用接口，这时，接口一般都会伴随着使用工厂模式。
第三阶段：使用IoC模式。工厂模式还不够好：（1）因为的类的生成代码写死在程序里，如果你要换一个子类，就要修改工厂方法。（2）一个接口常常意味着一个生成工厂，会多出很多工厂类。
可以把IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，IoC是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。
IoC中最基本的Java技术就是“反射”编程。反射又是一个生涩的名词，通俗的说反射就是根据给出的类名（字符串）来生成对象。这种编程方式可以让对象在生成时才决定要生成哪一种对象。我在最近的一个项目也用到了反射，当时是给出一个.properties文本文件，里面写了一些全类名（包名＋类名），然后，要根据这些全类名在程序中生成它们的对象。反射的应用是很广泛的，象Hibernate、String中都是用“反射”做为最基本的技术手段。
在过去，反射编程方式相对于正常的对象生成方式要慢10几倍，这也许也是当时为什么反射技术没有普通应用开来的原因。但经SUN改良优化后，反射方式生成对象和通常对象生成方式，速度已经相差不大了（但依然有一倍以上的差距）。
所以要理解IoC，你必须先了解工厂模式和反射编程，否则对它产生的前因后果和实现原理都是无法理解透彻的。只要你理解了这一点，你自己也完全可以自己在程序中实现一个IoC框架，只不是这还要涉及到XML解析等其他知识，稍微麻烦一些。
IoC最大的好处是什么？因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变成很简单（一般这样的对象都是现实于某种接口的），只要修改XML就可以了，这样我们甚至可以实现对象的热插拨（有点象USB接口和SCIS硬盘了）。
IoC最大的缺点是什么？（1）生成一个对象的步骤变复杂了（其实上操作上还是挺简单的），对于不习惯这种方式的人，会觉得有些别扭和不直观。（2）对象生成因为是使用反射编程，在效率上有些损耗。但相对于IoC提高的维护性和灵活性来说，这点损耗是微不足道的，除非某对象的生成对效率要求特别高。（3）缺少IDE重构操作的支持，如果在Eclipse要对类改名，那么你还需要去XML文件里手工去改了，这似乎是所有XML方式的缺憾所在。
总的来说IoC无论原理和实现都还算是很简单的。一些人曾认为IoC没什么实际作用，这种说法是可以理解的，因为如果你在编程中很少使用接口，或很少使用工厂模式，那么你根本就没有使用IoC的强烈需要，也不会体会到IoC可贵之处。有些人也说要消除工厂模式、单例模式，但是都语焉不详、人云亦云。但如果你看到IoC模式和用上Spring，那么工厂模式和单例模式的确基本上可以不用了。但它消失了吗？没有！Spring的IoC实现本身就是一个大工厂，其中也包含了单例对象生成方式，只要用一个设置就可以让对象生成由普通方式变单一实例方式，非常之简单。
总结：
（1）IoC原理很简单，作用的针对性也很强，不要把它看得很玄乎。
（2）要理解IoC，首先要了解“工厂、接口、反射”这些概念。
二、Spring中IOC的实现
了解了IOC模式的思想以及其优点，再来学习其实现。上面大致描述了PicoContainer以及Spring各自对IOC的实现，这篇来详细看一下Spring中它的实现。
Spring中IOC贯穿了其整个框架，但正如martinflower所说：“saying that these lightweight containers are special because they use inversion of control is like saying my car is special because it has wheels”，IOC已经称为框架设计中必不可少的部分。就实现上来讲Spring采取了配置文件的形式来实现依赖的注射，并且支持Type2 IOC（Setter Injection）以及Type3 IOC（Constructor Injection）。
Spring中IOC的实现的核心是其Core Bean Factory，它将框架内部的组件以一定的耦合度组装起来，并对使用它的应用提供一种面向服务的编程模式(SOP：Service-Orient Programming)，比如Spring中的AOP、以及持久化（Hibernate、ibatics）的实现。
首先从最底层最基础的factory Bean开始，先来看org.springframework.beans.factory.Bean
Factory接口，它是一个非常简单的接口，getBean方法是其中最重要的方法，Spring通常是使用xml来populate Bean，所以比较常用的是XMLFactoryBean。
用一个简单的示例看一下其用法。首先写下两个Bean类：
ExampleBean 类：
public class ExampleBean {
private String psnName=null;
private RefBean refbean=null;
private String addinfo=null;
public String getAddinfo() {
return getRefbean().getAddress()+getRefbean().getZipcode();
}
public String getPsnName() {
return psnName;
}
public void setPsnName(String psnName) {
this.psnName = psnName;
}
public void setRefbean(RefBean refbean) {
this.refbean = refbean;
}
public RefBean getRefbean() {
return refbean;
}
public void setAddinfo(String addinfo) {
this.addinfo = addinfo;
}
}
RefBean类：
public class RefBean {
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
private String zipcode=null;
private String address=null;
}
其xml配置文件 Bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="exampleBean" class="test.ExampleBean">
<property name="psnName"><value>xkf</value></property>
<property name="refbean">
<ref bean="refBean"/>
</property>
</bean>
<bean id="refBean" class="test.RefBean">
<property name="address"><value>BeiJing</value></property>
<property name="zipcode"><value>100085</value></property>
</bean>
</beans>
然后可以写个测试类来测试，当然，需要Spring中的Spring-core.jar以及commons-logging.jar，当然在elipse中可以通过安装spring-ide插件来轻松实现。
public class Test {
public static void main(String[] args){
try{
Resource input = new ClassPathResource("test/Bean.xml");
System.out.println("resource is:"+input);
BeanFactory factory = new XmlBeanFactory(input);
ExampleBean eb =
(ExampleBean)factory.getBean("exampleBean");
System.out.println(eb.getPsnName());
System.out.println(eb.getAddinfo());
}
catch(Exception e){
e.printStackTrace();
}
}
这样，通过BeanFactory的getBean方法，以及xml配置文件，避免了在test类中直接实例化ExampleBean，消除了应用程序(Test)与服务(ExampleBean)之间的耦合，实现了IOC（控制反转）或者说实现了依赖的注射（Dependency Injection）。
">"refbean">
<ref bean="refBean"/>
</property>
</bean>
<bean id="refBean" class="test.RefBean">
<property name="address"><value>BeiJing</value></property>
<property name="zipcode"><value>100085</value></property>
</bean>
</beans>
然后可以写个测试类来测试，当然，需要Spring中的Spring-core.jar以及commons-logging.jar，当然在elipse中可以通过安装spring-ide插件来轻松实现。
public class Test {
public static void main(String[] args){
try{
Resource input = new ClassPathResource("test/Bean.xml");
System.out.println("resource is:"+input);
BeanFactory factory = new XmlBeanFactory(input);
ExampleBean eb =
(ExampleBean)factory.getBean("exampleBean");
System.out.println(eb.getPsnName());
System.out.println(eb.getAddinfo());
}
catch(Exception e){
e.printStackTrace();
}
}
这样，通过BeanFactory的getBean方法，以及xml配置文件，避免了在test类中直接实例化ExampleBean，消除了应用程序(Test)与服务(ExampleBean)之间的耦合，实现了IOC（控制反转）或者说实现了依赖的注射（Dependency Injection）。
这是Spring中得有特点的一部份。IoC又被翻译成“控制反转”，也不知道是谁翻译得这么别扭，感觉很深奥的词。其实，原理很简单，用一句通俗的话来说：就是用XML来定义生成的对象。IoC其实是一种设计模式，Spring只是实现了这种设计模式。
这种设计模式是怎么来的呢？是实践中逐渐形成的。
第一阶段：用普通的无模式来写Java程序。一般初学者都要经过这个阶段。
第二阶段：频繁的开始使用接口，这时，接口一般都会伴随着使用工厂模式。
第三阶段：使用IoC模式。工厂模式还不够好：（1）因为的类的生成代码写死在程序里，如果你要换一个子类，就要修改工厂方法。（2）一个接口常常意味着一个生成工厂，会多出很多工厂类。
可以把IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，IoC是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。
IoC中最基本的Java技术就是“反射”编程。反射又是一个生涩的名词，通俗的说反射就是根据给出的类名（字符串）来生成对象。这种编程方式可以让对象在生成时才决定要生成哪一种对象。我在最近的一个项目也用到了反射，当时是给出一个.properties文本文件，里面写了一些全类名（包名＋类名），然后，要根据这些全类名在程序中生成它们的对象。反射的应用是很广泛的，象Hibernate、String中都是用“反射”做为最基本的技术手段。
在过去，反射编程方式相对于正常的对象生成方式要慢10几倍，这也许也是当时为什么反射技术没有普通应用开来的原因。但经SUN改良优化后，反射方式生成对象和通常对象生成方式，速度已经相差不大了（但依然有一倍以上的差距）。
所以要理解IoC，你必须先了解工厂模式和反射编程，否则对它产生的前因后果和实现原理都是无法理解透彻的。只要你理解了这一点，你自己也完全可以自己在程序中实现一个IoC框架，只不是这还要涉及到XML解析等其他知识，稍微麻烦一些。
IoC最大的好处是什么？因为把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变成很简单（一般这样的对象都是现实于某种接口的），只要修改XML就可以了，这样我们甚至可以实现对象的热插拨（有点象USB接口和SCIS硬盘了）。
IoC最大的缺点是什么？（1）生成一个对象的步骤变复杂了（其实上操作上还是挺简单的），对于不习惯这种方式的人，会觉得有些别扭和不直观。（2）对象生成因为是使用反射编程，在效率上有些损耗。但相对于IoC提高的维护性和灵活性来说，这点损耗是微不足道的，除非某对象的生成对效率要求特别高。（3）缺少IDE重构操作的支持，如果在Eclipse要对类改名，那么你还需要去XML文件里手工去改了，这似乎是所有XML方式的缺憾所在。
总的来说IoC无论原理和实现都还算是很简单的。一些人曾认为IoC没什么实际作用，这种说法是可以理解的，因为如果你在编程中很少使用接口，或很少使用工厂模式，那么你根本就没有使用IoC的强烈需要，也不会体会到IoC可贵之处。有些人也说要消除工厂模式、单例模式，但是都语焉不详、人云亦云。但如果你看到IoC模式和用上Spring，那么工厂模式和单例模式的确基本上可以不用了。但它消失了吗？没有！Spring的IoC实现本身就是一个大工厂，其中也包含了单例对象生成方式，只要用一个设置就可以让对象生成由普通方式变单一实例方式，非常之简单。
总结：
（1）IoC原理很简单，作用的针对性也很强，不要把它看得很玄乎。
（2）要理解IoC，首先要了解“工厂、接口、反射”这些概念。
二、Spring中IOC的实现
了解了IOC模式的思想以及其优点，再来学习其实现。上面大致描述了PicoContainer以及Spring各自对IOC的实现，这篇来详细看一下Spring中它的实现。
Spring中IOC贯穿了其整个框架，但正如martinflower所说：“saying that these lightweight containers are special because they use inversion of control is like saying my car is special because it has wheels”，IOC已经称为框架设计中必不可少的部分。就实现上来讲Spring采取了配置文件的形式来实现依赖的注射，并且支持Type2 IOC（Setter Injection）以及Type3 IOC（Constructor Injection）。
Spring中IOC的实现的核心是其Core Bean Factory，它将框架内部的组件以一定的耦合度组装起来，并对使用它的应用提供一种面向服务的编程模式(SOP：Service-Orient Programming)，比如Spring中的AOP、以及持久化（Hibernate、ibatics）的实现。
首先从最底层最基础的factory Bean开始，先来看org.springframework.beans.factory.Bean
Factory接口，它是一个非常简单的接口，getBean方法是其中最重要的方法，Spring通常是使用xml来populate Bean，所以比较常用的是XMLFactoryBean。
用一个简单的示例看一下其用法。首先写下两个Bean类：
ExampleBean 类：
public class ExampleBean {
private String psnName=null;
private RefBean refbean=null;
private String addinfo=null;
public String getAddinfo() {
return getRefbean().getAddress()+getRefbean().getZipcode();
}
public String getPsnName() {
return psnName;
}
public void setPsnName(String psnName) {
this.psnName = psnName;
}
public void setRefbean(RefBean refbean) {
this.refbean = refbean;
}
public RefBean getRefbean() {
return refbean;
}
public void setAddinfo(String addinfo) {
this.addinfo = addinfo;
}
}
RefBean类：
public class RefBean {
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
private String zipcode=null;
private String address=null;
}
其xml配置文件 Bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="exampleBean" class="test.ExampleBean">
<property name="psnName"><value>xkf</value></property>
<property name="refbean">
<ref bean="refBean"/>
</property>
</bean>
<bean id="refBean" class="test.RefBean">
<property name="address"><value>BeiJing</value></property>
<property name="zipcode"><value>100085</value></property>
</bean>
</beans>
然后可以写个测试类来测试，当然，需要Spring中的Spring-core.jar以及commons-logging.jar，当然在elipse中可以通过安装spring-ide插件来轻松实现。
public class Test {
public static void main(String[] args){
try{
Resource input = new ClassPathResource("test/Bean.xml");
System.out.println("resource is:"+input);
BeanFactory factory = new XmlBeanFactory(input);
ExampleBean eb =
(ExampleBean)factory.getBean("exampleBean");
System.out.println(eb.getPsnName());
System.out.println(eb.getAddinfo());
}
catch(Exception e){
e.printStackTrace();
}
}
这样，通过BeanFactory的getBean方法，以及xml配置文件，避免了在test类中直接实例化ExampleBean，消除了应用程序(Test)与服务(ExampleBean)之间的耦合，实现了IOC（控制反转）或者说实现了依赖的注射（Dependency Injection）。
">"refbean">
<ref bean="refBean"/>
</property>
</bean>
<bean id="refBean" class="test.RefBean">
<property name="address"><value>BeiJing</value></property>
<property name="zipcode"><value>100085</value></property>
</bean>
</beans>
然后可以写个测试类来测试，当然，需要Spring中的Spring-core.jar以及commons-logging.jar，当然在elipse中可以通过安装spring-ide插件来轻松实现。
public class Test {
public static void main(String[] args){
try{
Resource input = new ClassPathResource("test/Bean.xml");
System.out.println("resource is:"+input);
BeanFactory factory = new XmlBeanFactory(input);
ExampleBean eb =
(ExampleBean)factory.getBean("exampleBean");
System.out.println(eb.getPsnName());
System.out.println(eb.getAddinfo());
}
catch(Exception e){
e.printStackTrace();
}
}
这样，通过BeanFactory的getBean方法，以及xml配置文件，避免了在test类中直接实例化ExampleBean，消除了应用程序(Test)与服务(ExampleBean)之间的耦合，实现了IOC（控制反转）或者说实现了依赖的注射（Dependency Injection）。
lunzi
2006-06-05 11:19:01
阅读:1045
评论:1
引用:0
第一次学会用junit测试封装好的访问数据库的方法,确实便捷好用,而且开发效率高.
package apple;
import junit.framework.TestCase;
public class UserDAOTest extends TestCase {
public static void main(String[] args) {
junit.textui.TestRunner.run(UserDAOTest.class);
}
private UserDAO userDAO;
static {
ApplicationContextFactory.init("/apple/applicationContext.xml");
}
public UserDAOTest(String arg0) {
super(arg0);
}
protected void setUp() throws Exception {
super.setUp();
userDAO = (UserDAO) ApplicationContextFactory.getApplicationContext().getBean("userDAO");
}
protected void tearDown() throws Exception {
super.tearDown();
}
/*
* Test method for 'apple.UserDAO.getUserById(Integer)'
*/
public final void testGetUserById() {
// TODO Auto-generated method stub
Integer id=new Integer(25);
String email="spring";
User user = userDAO.getUserById(id);
assertEquals(email, user.getEmail());
}
public final void testaddUser() {
// TODO Auto-generated method stub
User user3 = new User();
String email = "lunzi@163.com";
user3.setEmail(email);
user3.setPassword("password");
userDAO.addUser(user3);
User user2 = userDAO.findUserByEmail(email);
assertEquals(email, user2.getEmail());
}
public void testFindUserByEmail(){
User user = userDAO.findUserByEmail("pswd");
assertNotNull(user);
}
}
}
lunzi
2006-06-03 22:58:16
阅读:372
评论:6
引用:0
今天用spring+hibernate进行中文插入时出现乱码问题,通过查资料和自己反复测试终于解决了.
总结了两种方法:
1、使用gb2312编码，变更mysql的数据库编码字符集。cmd模式下用mysql --default-character-set=gb2312 -u root -p进入，然后再每个建表语句后增加default character set gb2312;
重新建立数据表。
值得注意的地方是：applicationContext.xml中的数据库连接必须设置为<property name="url"><value>jdbc:mysql://localhost/struts?useUnicode=true&characterEncoding=gb2312</value></property>，这样插入的才是正常的中文，否则就是乱码。
2、在进行数据保存之前进行gb2312到iso8859-1编码的转换，数据?寥≈笤僮还础?
这时的applicationContext.xml中的数据库连接必须设置为<property name="url"><value>jdbc:mysql://localhost/struts</value></property>，这样插入的才是正常的中文，否则就是乱码。
它们相同的地方是在用jsp进行中文内容填加时，都要进行gb2312到iso8859-1编码的转换：
String name;
name=trans(request.getParameter("name"));
String trans(String chi)
{
String result = null;
byte temp [];
try
{
temp=chi.getBytes("iso-8859-1");
result = new String(temp);
}
catch(java.io.UnsupportedEncodingException e)
{
System.out.println (e.toString());
}
return result;
}
String trans(Object chi)
{
return trans(chi.toString());
}
参考资料spring+hibernate 的中文问题
总结了两种方法:
1、使用gb2312编码，变更mysql的数据库编码字符集。cmd模式下用mysql --default-character-set=gb2312 -u root -p进入，然后再每个建表语句后增加default character set gb2312;
重新建立数据表。
值得注意的地方是：applicationContext.xml中的数据库连接必须设置为<property name="url"><value>jdbc:mysql://localhost/struts?useUnicode=true&characterEncoding=gb2312</value></property>，这样插入的才是正常的中文，否则就是乱码。
2、在进行数据保存之前进行gb2312到iso8859-1编码的转换，数据?寥≈笤僮还础?
这时的applicationContext.xml中的数据库连接必须设置为<property name="url"><value>jdbc:mysql://localhost/struts</value></property>，这样插入的才是正常的中文，否则就是乱码。
它们相同的地方是在用jsp进行中文内容填加时，都要进行gb2312到iso8859-1编码的转换：
String name;
name=trans(request.getParameter("name"));
String trans(String chi)
{
String result = null;
byte temp [];
try
{
temp=chi.getBytes("iso-8859-1");
result = new String(temp);
}
catch(java.io.UnsupportedEncodingException e)
{
System.out.println (e.toString());
}
return result;
}
String trans(Object chi)
{
return trans(chi.toString());
}
参考资料spring+hibernate 的中文问题
lunzi
2006-06-01 23:39:11
阅读:2660
评论:0
引用:0
今天用spring+hibernate增加一个User更新的方法:
public void updateUser(User user){
getHibernateTemplate().update(user);
}
编译运行都没问题,可就是不能更新指定要更新内容,最后才发现原来是User.hbm.xml中的property中的update设置为了false之故.
费时的主要原因是忽略了hibernate配置文件中的一些细节问题.
public void updateUser(User user){
getHibernateTemplate().update(user);
}
编译运行都没问题,可就是不能更新指定要更新内容,最后才发现原来是User.hbm.xml中的property中的update设置为了false之故.
费时的主要原因是忽略了hibernate配置文件中的一些细节问题.
lunzi
2006-06-01 15:13:10
阅读:1353
评论:4
引用:0
最近我学习了一下Spring+Hibernate+Junit+Oracle的最简单的人门这篇教程. 不过我用的是MySQL数据库,如何使用MySQL中测试此例子？以下是我测试过程中出现的问题,请求指点:
R>
1. 建立数据表
create table hofman_user (
pk_user_id int not null auto_increment,
vc_email varchar(50),
vc_password varchar(80),
primary key(pk_user_id));
2.修改User.hbm.xml中的关于id的代码
<id
name="id"
column="PK_USER_ID"
type="java.lang.Integer"
unsaved-value="-1"
>
<generator class="increment">
</generator>
</id>
3、测试代码
test.java
package hofman;
public class test{
public static void main(String[] args) {
try{ UserDAO userDAO;
String password;
ApplicationContextFactory.init("/hofman/applicationContext.xml");
userDAO = (UserDAO)ApplicationContextFactory.
getApplicationContext().getBean("userDAO");
/* User user =
userDAO.findUserByEmail("hofman@zhuoda.org");
password = user.getPassword();
System.out.println(password);
已经测试通过的。
*/
User user2 = new User();
String email = "hofman@zhuoda2.org";
user2.setEmail(email);
user2.setPassword("fakePass");
userDAO.addUser(user2);
//这一段运行出现错误，不能保存数据。
System.out.println("ok insert");
}catch(Exception e){
System.err.println(e.getMessage());
}
}
}
4、运行时的提示（部分）
2006-4-3 19:25:37 net.sf.hibernate.util.JDBCExceptionReporter logExceptions
警告: SQL Error: 1064, SQLState: 42000
2006-4-3 19:25:37 net.sf.hibernate.util.JDBCExceptionReporter logExceptions
严重: Syntax error or access violation, message from server: "You have an error
in your SQL syntax; check the manual that corresponds to your MySQL server vers
ion for the right syntax to use near '"HOFMAN_USER"' at line 1"
Hibernate operation: Could not save object; bad SQL grammar []; nested exception
is java.sql.SQLException: Syntax error or access violation, message from serve
r: "You have an error in your SQL syntax; check the manual that corresponds to y
our MySQL server version for the right syntax to use near '"HOFMAN_USER"' at lin
e 1"
Press any key to continue...
5、这个条件建立hofman_user表主键pk_user_id
使用的序列
create sequence hofmanid_seq;
我在建表时没用上，我想跟这个应该有关，不知道
怎么在MySQL数据库中设置。
除了在applicationContext.xml连接数据库和以
上修改之外，别的地方没动。
不知道错误到底是由那引起的？
R>
lunzi
2006-04-03 23:22:10
阅读:3428
评论:10
引用:0
<%@ page contentType="text/html; charset=GB18030" %>
<%@ page import="msg.*, net.sf.hibernate.*,java.util.*" %>
<%@ include file="trans.jsp"%>
<br>
<%
//++++ 权限控制部分上+++++++++++++++++++++++++++++++++++=
String u=(String)session.getAttribute("user");
if(u!=null)
{
out.println("<font color=red size=5>");
out.println("hello:"+trans(u));
out.println("</font>");
out.println("<br>");
String rank=(String)session.getAttribute("rankid");
int rankid=Integer.parseInt(rank);
int bid=Integer.parseInt(request.getParameter("bid"));
String boardtitle="";
if(bid==1)boardtitle="jsp¼¼ÊõÂÛ̳";
if(bid==2)boardtitle="php¼¼ÊõÂÛ̳";
out.println(boardtitle);
//++++ 权限控制部分下+++++++++++++++++++++++++++++++++++++
%>
<%
SessionFactory sessionFactory;
net.sf.hibernate.Session hsession = HibernateUtil.currentSession();
Transaction tx = hsession.beginTransaction();
//++++++++++++++++++++++++++++++++++++++++++++++++++++++
Query query = hsession.createQuery ("from Article as art where art.boardid="+bid+" and art.replyid=0 ");
for (Iterator it = query.iterate(); it.hasNext();) {
Article guest = (Article) it.next();
out.println(guest.getId()+" ");
//out.println(guest.getTitle()+" ");
String urlq="<a href=detail.jsp?id="+guest.getId()+"&bid="+bid+"";
String urlh=">"+trans(guest.getTitle())+"</a>";
out.println(urlq+urlh);
out.println(trans(guest.getUser().getUserName())+" " );
out.println(guest.getReplynum()+" ");
out.println(guest.getHits()+" ");
out.println(guest.getPosttime()+" <br> ");
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++
hsession.flush();
tx.commit();
HibernateUtil.closeSession();
//+++++hibernate 数据库连接下+++++++++++++++++++++++++++++++
%>
<a href=post.jsp?reid=0&bid=<%=bid%>&rankid=<%=rankid%>>post</a>
<a href=addUser.jsp>regist</a>
<a href=login.jsp>login</a>
<a href=listboard.jsp>listboard</a>
<% }
else{
out.println("<font color=red size=6>");
out.println("hello guest");
out.println("</font>");
out.println("<br>");
}%>
lunzi
2005-12-30 20:01:33
阅读:320
评论:0
引用:0
lunzi
2005-10-29 20:19:33
阅读:1982
评论:0
引用:0