- 浏览: 62254 次
- 性别:
- 来自: tj
最新评论
-
06softwaregaojie:
原来是这样啊,多谢楼主。我还一直在找在触发器总遍历结果集的方 ...
oracle 触发器 删除表中的内容插入到另一张表 -
快乐让让:
好像没有写完吧。
LOG4J开发案例 -
clfsw0201:
真不错,挺全的,懒得看jxl的doc了,先拿来用。谢啦……
用jexcel读写excel的.xls文件的例子
转载自http://hi.baidu.com/welcome_ni/blog/item/43610d5061097e591138c274.html
file source : http://blog.csdn.net/dizhang/archive/2007/07/07/1682212.aspx
Named query not known
2007-06-13 17:10
在使用session.getNamedQuery("XXX");执行HQL语句的时候,没有找 XXX语句,这主要是2个原因
1:粗心,把名给写错了
2:XXX的HQL语句所在的.hbm.xml没有在hibernate.cfg.xml里注册过!
Expected positional parameter count: X, actual parameters: []
2007-06-03 17:33
org.hibernate.QueryException: Expected positional parameter count: 2, actual parameters: [] [SELECT * from Ad where gr_id = ? and adst_id = ?]
这样的异常主要原因是:
//以下为例子
Query query =session.getNamedQuery("OnlienAd");
query.setParameter(0,gray.getId());
query.setParameter(1,Globals.UPED_STATE);
可以看到query.setParameter()设置了位,也可以理解成他在要执行的HQL语句中占了2个位置。
然后执行的时候会对应HQL里的?中去。
如果你并没有setParameter(),但你的HQL里却有?那么就会出这个异常。
org.hibernate.exception.SQLGrammarException: could not initialize a collection: XXX
2007-05-25 10:58无法实例集合。
这个是问题在你当前的实体中有一个一对多需实例的对象。但这个对象却无法实例出来,说明一对多那个多的一方实体有问题,多数情况可能有:
1、数据库该动过但代码没动
2、实体代码有错误
org.hibernate.id.IdentifierGenerationException
2007-05-22 14:58
异常信息:org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save():
异常原因:
<id>元素配置不正确,
<id>元素缺少其子元素<generator></generator>的配置。
解决方法:<id>元素映射了相应数据库表的主键字段,对其子元素<generator class="">,其中class的取值可以为increment、identity、sequence、hilo、native...... 等,更多的可参考hibernate参考文档,一般取其值为native 。
MySQL:identity,increment,hilo,native.
SQL Server:identity,increment,hilo,native.
Oracle:sequence,seqhilo,increment,native.
跨平台开发:native.
native将字段管理交给数据库自己定义。
not-null property references a null or transient value2007-05-13 15:51此异常出现看开头就个单词就知道啦
的实体约束不能为空却为空造成的,那我在这说一下对于这样的情况我们时常犯的错误。
我们在对实体进行更新操作时最好是在一个会话中将数据从数据库中调出并实例BEAN的对象。
然后再对此对象进行更改后在更新。
这样的好处是:
一、数据是最新鲜的。
二、避免不必要的设置,特别是在一对多和多对多的情况下,比如你现在操作的实体并不是在一个会话中得到,而是保存在某些容器中,比如jsp的 SESSION中,虽然这样的实体对象中有很多数据,但是如果你想得到这些实体对应的1对多或多对1的实体时,就会发现会出现session已经关闭的异常。或则在你更新数据时出现not-null异常等。
Remember that ordinal parameters are 1-based!
2007-05-13 08:16
Remember that ordinal parameters are 1-based!
HQL语句有错误
failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed
2007-05-11 10:47
这个异常大致意思是说在多对一的时候(并且lazy="false"),对象的实例失败,多数出现的情况有
1、粗心造成
实例对象类名写错之类的
2、逻辑错误
如之前就已经传递过来一个实体对象,然后调用实体对象的方法时牵涉到1对多的情况,但此时SESSION已经关闭,所以根本无法进行一对多的操作。
3、设计到跨度的问题:
这样打比方有多个实体对象,他们直接或则间接的有关联。比如有4个实体,分别是广告信息、广告、广告问答题、广告商:他们之间的关系为:
广告商 1:n 广告
广告 1:n 广告问答题
广告商 1:n 广告商信息
大家可以看到广告和广告商信息是没有直接关系的。但我要添加广告的时候我就必须将广告商的实体做为条件。那么这么一来广告商信息可能间接的就必须用上。下面看我的操作:
ad(广告),subject(题目)
Ad ad = new Ad();
ad.setAdProd(adform.getAdProd());
ad.setIndustry(industry);
ad.setAdPicture(pagefile.getFileName());
ad.setAdFlack(adform.getAdFlack());
ad.setAdDv(dvfile.getFileName());
ad.setAdContent(adform.getAdContent());
ad.setGray(gray);
ad.setAdDate(new Date());
ad.setOnlinetime(new Long(0));
//以上为广告的基本信息填写,而重要的是看下面一句,在这里我的思路是subjectFormList是一个动态提交的表单,里面有若干个广告问答题。我将这些问答题变为一个Set,然后作为ad的一个属性。
Set<Subject> subjectset=getSubjectSet(subjectFormList,ad);
ad.setSubjects(subjectset);
//然后提交,makePersistent是一个封装的方法,用途就是save()啦。addao是一个DAO,里面有ADUS。
addao.makePersistent(ad);
表面上看来很符合逻辑,只要我们在ad的映射里面加上对subject的级联更新就可以完成这项操作。但实际上会发生我们意想不到的问题,来让我们看一下getSubjectSet()的内容:
public Set getSubjectSet(List<SubjectForm> subjectlist,Ad ad)
{
Set<Subject> set=new HashSet<Subject>(0);
Subject subject;
for(Iterator<SubjectForm> it=subjectlist.iterator();it.hasNext();)
{
subject=new Subject();
SubjectForm sf=it.next();
subject.setSuContent(sf.getSucontent());
subject.setSuOption(sf.getSuoption());
subject.setSuResult(Arrays.deepToString(sf.getSuresult()));
subject.setSuType(String.valueOf(sf.getSutype()));
subject.setAd(ad);
set.add(subject);
}
return set;
}
我们在这个方法上设一个断点然后跟踪,之后你会发现断点在set.add(subject)只后就会出failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed这个异常,并且这个异常还是出在了广告商的广告信息上 gray.messages。是不是很不可理解?这也是Hibernate的懒汉机制问题。没有任何一样技术是完美的。那我们该怎么处理这样的问题。有很多人以为我们在广告商对广告商信息的隐射上加lazy="false"这样在对gray操作会对messages进行关联,并查询时提出数据。但你会发现改完之后会出现org.hibernate.LazyInitializationException: illegal access to loading collection这个异常。并切lazy="false"是我们不推荐的一种方法。他会降低你的查询效率。
对于这样的情况最好的解决办法就是不要偷懒,对一个实体进行操作的时候就该用那个实体的DAO,即应该有2句HQL。如下把getSubjectSet()改一改:
public void getSubjectSet(List<SubjectForm> subjectlist,Ad ad)
{
Set<Subject> set=new HashSet<Subject>(0);
SubjectDAO subjectdao=DAOFactory.getDao(SubjectDAO.class);
for(Iterator<SubjectForm> it=subjectlist.iterator();it.hasNext();)
{
Subject subject=new Subject();
SubjectForm sf=it.next();
subject.setSuContent(sf.getSucontent());
subject.setSuOption(sf.getSuoption());
subject.setSuResult(Arrays.deepToString(sf.getSuresult()));
subject.setSuType(String.valueOf(sf.getSutype()));
subject.setAd(ad);
subjectdao.makePersistent(subject);
//set.add(subject);
}
}//遍历出所有subject一个个的往数据库里加。这样便不会出问题了。
1、OpenSessionInView模式:
以下有2种方法,第1种是结合SPRING,第2种是采用了拦截器
Spring+Hibernate中, 集合映射如果使用lazy="true", 当PO传到View层时, 出现未初始化session已关闭的错误,只能在dao先初始化
parent.getChilds().size();
Spring提供Open Session In View来解决这个问题, 有两种方式
1. Interceptor <!--</span><span style="COLOR: rgb(0,128,0)"> =========== OpenSession In View pattern ==============</span><span style="COLOR: rgb(0,128,0)">-->
<bean id="openSessionInViewInterceptor"
class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors" ref="openSessionInViewInterceptor"/>
<property name="mappings">
<props>
......
</props>
</property>
</bean>2. Filter <web-app>
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
</web-app>
第2种解决方法:
Hibernate.initialize()强制加载关联对象
Could not initialize proxy - the owning Session was closed (篇幅一)
2007-05-11 09:52
其实这个异常写的非常之清楚,就是会话关闭,无法对Hibernate实体进行操作。造成这样的情况有很多,什么书写错误啊,逻辑错误啊。
但就此说一下关于lazy机制:
延迟初始化错误是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略,那么必须当代理类实例或代理集合处于持久化状态(即处于Session范围内)时,才能初始化它。如果在游离状态时才初始化它,就会产生延迟初始化错误。
下面把Customer.hbm.xml文件的<class>元素的lazy属性设为true,表示使用延迟检索策略:
<class name="mypack.Customer" table="CUSTOMERS" lazy="true">
当执行Session的load()方法时,Hibernate不会立即执行查询CUSTOMERS表的select语句,仅仅返回Customer类的代理类的实例,这个代理类具由以下特征:
(1) 由Hibernate在运行时动态生成,它扩展了Customer类,因此它继承了Customer类的所有属性和方法,但它的实现对于应用程序是透明的。
(2) 当Hibernate创建Customer代理类实例时,仅仅初始化了它的OID属性,其他属性都为null,因此这个代理类实例占用的内存很少。
(3)当应用程序第一次访问Customer代理类实例时(例如调用customer.getXXX()或customer.setXXX()方法), Hibernate会初始化代理类实例,在初始化过程中执行select语句,真正从数据库中加载Customer对象的所有数据。但有个例外,那就是当应用程序访问Customer代理类实例的getId()方法时,Hibernate不会初始化代理类实例,因为在创建代理类实例时OID就存在了,不必到数据库中去查询。
提示:Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具,它能够在程序运行时动态生成扩展 Java类或者实现Java接口的代理类。关于CGLIB的更多知识,请参考:http://cglib.sourceforge.net/。
以下代码先通过Session的load()方法加载Customer对象,然后访问它的name属性:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getName();
tx.commit();
在运行session.load()方法时Hibernate不执行任何select语句,仅仅返回Customer类的代理类的实例,它的OID 为1,这是由load()方法的第二个参数指定的。当应用程序调用customer.getName()方法时,Hibernate会初始化 Customer代理类实例,从数据库中加载Customer对象的数据,执行以下select语句:
select * from CUSTOMERS where ID=1;
select * from ORDERS where CUSTOMER_ID=1;
当<class>元素的lazy属性为true,会影响Session的load()方法的各种运行时行为,下面举例说明。
1.如果加载的Customer对象在数据库中不存在,Session的load()方法不会抛出异常,只有当运行customer.getName()方法时才会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
mypack.Customer
2.如果在整个Session范围内,应用程序没有访问过Customer对象,那么Customer代理类的实例一直不会被初始化,Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();
由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化,因此在执行customer.getName()方法时,Hibernate会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
由此可见,Customer代理类的实例只有在当前Session范围内才能被初始化。
3.net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例,isInitialized()方法用于判断代理类实例是否已经被初始化。例如:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
if(!Hibernate.isInitialized(customer))
Hibernate.initialize(customer);
tx.commit();
session.close();
customer.getName();
以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例,因此当Session关闭后,可以正常访问Customer游离对象。
4.当应用程序访问代理类实例的getId()方法时,不会触发Hibernate初始化代理类实例的行为,例如:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getId();
tx.commit();
session.close();
customer.getName();
当应用程序访问customer.getId()方法时,该方法直接返回Customer代理类实例的OID值,无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例,因此当Session关闭后再执行customer.getName()方法, Hibernate会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
解决方法:
由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的 session已关闭掉,就会产生种错误.
在做一对多时,有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在<many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫
failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed
此异常解决方案请察看本人博客(http://hi.baidu.com/kekemao1)的Hibernate异常中的《failed to lazily initialize a collection of role异常》
?
解决方法:在web.xml中加入
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
</filter-class>
</filter
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
就可以了;
参考了:
Hibernate与延迟加载:
Hibernate对象关系映射提供延迟的与非延迟的对象初始化。非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一起读取出来。这有时会导致成百的(如果不是成千的话)select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候,经常会导致整个数据库都在初始化的阶段被读出来了。当然,你可以不厌其烦地检查每一个对象与其他对象的关系,并把那些最昂贵的删除,但是到最后,我们可能会因此失去了本想在ORM工具中获得的便利。
一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的,而且只进行了很少的数据库操作请求,因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个 Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来,所有的数据库逻辑,包括打开或关闭会话,都不能在应用层出现。最常见的是,一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式,将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效,但是在大的系统中,这是一个严重的设计缺陷,妨碍了系统的可扩展性。
在Web层进行延迟加载
幸运的是,Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种方便的解决方法。对那些不熟悉Spring与 Hibernate集成使用的人,我不会在这里讨论过多的细节,但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例,Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中,而Filter在 Spring之前运行并被配置在web.xml中。不管用哪个,他们都在请求将当前会话与当前(数据库)线程绑定时打开Hibernate会话。一旦已绑定到线程,这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了,Hibernate会话会在Filter的doFilter方法或者Interceptor的postHandle方法中被关闭。下面是每个组件的配置示例:
Interceptor的配置:
<beans>
<bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<ref bean="openSessionInViewInterceptor"/>
</list>
</property>
<property name="mappings">
</bean>
<bean name="openSessionInViewInterceptor"
class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
<property name="sessionFactory"><ref bean="sessionFactory"/></property>
</bean>
</beans>
Filter的配置
<web-app>
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*. spring </url-pattern>
</filter-mapping>
</web-app>
实现Hibernate的Dao接口来使用打开的会话是很容易的。事实上,如果你已经使用了Spring框架来实现你的Hibernate Dao,很可能你不需要改变任何东西。方便的HibernateTemplate公用组件使访问数据库变成小菜一碟,而DAO接口只有通过这个组件才可以访问到数据库。下面是一个示例的DAO:
public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {
public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product.class, productId);
}
public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}
public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}
在业务逻辑层中使用延迟加载
即使在视图外面,Spring框架也通过使用AOP 拦截器 HibernateInterceptor来使得延迟加载变得很容易实现。这个Hibernate 拦截器透明地将调用配置在Spring应用程序上下文中的业务对象中方法的请求拦截下来,在调用方法之前打开一个Hibernate会话,然后在方法执行完之后将会话关闭。让我们来看一个简单的例子,假设我们有一个接口BussinessObject:
public interface BusinessObject {
public void doSomethingThatInvolvesDaos();
}
类BusinessObjectImpl实现了BusinessObject接口:
public class BusinessObjectImpl implements BusinessObject {
public void doSomethingThatInvolvesDaos() {
// lots of logic that calls
// DAO classes Which access
// data objects lazily
}
}
通过在Spring应用程序上下文中的一些配置,我们可以让将调用BusinessObject的方法拦截下来,再令它的方法支持延迟加载。看看下面的一个程序片段:
<beans>
<bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
<property name="someDAO"><ref bean="someDAO"/></property>
</bean>
<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target"><ref bean="businessObjectTarget"/></property>
<property name="proxyInterfaces">
<value>com.acompany.BusinessObject</value>
</property>
<property name="interceptorNames">
<list>
<value>hibernateInterceptor</value>
</list>
</property>
</bean>
</beans>
当businessObject被调用的时候,HibernateInterceptor打开一个Hibernate会话,并将调用请求传递给 BusinessObjectImpl对象。当BusinessObjectImpl执行完成后,HibernateInterceptor透明地关闭了会话。应用层的代码不用了解任何持久层逻辑,还是实现了延迟加载。
在单元测试中测试延迟加载
最后,我们需要用J-Unit来测试我们的延迟加载程序。我们可以轻易地通过重写TestCase类中的setUp和tearDown方法来实现这个要求。我比较喜欢用这个方便的抽象类作为我所有测试类的基类。
public abstract class MyLazyTestCase extends TestCase {
private SessionFactory sessionFactory;
private Session session;
public void setUp() throws Exception {
super.setUp();
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
session = SessionFactoryUtils.getSession(sessionFactory, true);
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
}
protected Object getBean(String beanName) {
//Code to get objects from Spring application context
}
public void tearDown() throws Exception {
super.tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}
}
Hibernate的No CurrentSessionContext configured 解决方案
2007-05-09 17:53Hibernate No CurrentSessionContext configured!
当你使用 Hibernate session factory的getCurrentSession() 函数时候,你可能见到过"No CurrentSessionContext configured!"
出现这个问题,是因为你没有正确配置 Hibernate internal session context management .
你只要在Hibernate.cfg.xml文件中添加下面的配置就可以了:
<property name="current_session_context_class">thread</property>
file source : http://blog.csdn.net/dizhang/archive/2007/07/07/1682212.aspx
Named query not known
2007-06-13 17:10
在使用session.getNamedQuery("XXX");执行HQL语句的时候,没有找 XXX语句,这主要是2个原因
1:粗心,把名给写错了
2:XXX的HQL语句所在的.hbm.xml没有在hibernate.cfg.xml里注册过!
Expected positional parameter count: X, actual parameters: []
2007-06-03 17:33
org.hibernate.QueryException: Expected positional parameter count: 2, actual parameters: [] [SELECT * from Ad where gr_id = ? and adst_id = ?]
这样的异常主要原因是:
//以下为例子
Query query =session.getNamedQuery("OnlienAd");
query.setParameter(0,gray.getId());
query.setParameter(1,Globals.UPED_STATE);
可以看到query.setParameter()设置了位,也可以理解成他在要执行的HQL语句中占了2个位置。
然后执行的时候会对应HQL里的?中去。
如果你并没有setParameter(),但你的HQL里却有?那么就会出这个异常。
org.hibernate.exception.SQLGrammarException: could not initialize a collection: XXX
2007-05-25 10:58无法实例集合。
这个是问题在你当前的实体中有一个一对多需实例的对象。但这个对象却无法实例出来,说明一对多那个多的一方实体有问题,多数情况可能有:
1、数据库该动过但代码没动
2、实体代码有错误
org.hibernate.id.IdentifierGenerationException
2007-05-22 14:58
异常信息:org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save():
异常原因:
<id>元素配置不正确,
<id>元素缺少其子元素<generator></generator>的配置。
解决方法:<id>元素映射了相应数据库表的主键字段,对其子元素<generator class="">,其中class的取值可以为increment、identity、sequence、hilo、native...... 等,更多的可参考hibernate参考文档,一般取其值为native 。
MySQL:identity,increment,hilo,native.
SQL Server:identity,increment,hilo,native.
Oracle:sequence,seqhilo,increment,native.
跨平台开发:native.
native将字段管理交给数据库自己定义。
not-null property references a null or transient value2007-05-13 15:51此异常出现看开头就个单词就知道啦
的实体约束不能为空却为空造成的,那我在这说一下对于这样的情况我们时常犯的错误。
我们在对实体进行更新操作时最好是在一个会话中将数据从数据库中调出并实例BEAN的对象。
然后再对此对象进行更改后在更新。
这样的好处是:
一、数据是最新鲜的。
二、避免不必要的设置,特别是在一对多和多对多的情况下,比如你现在操作的实体并不是在一个会话中得到,而是保存在某些容器中,比如jsp的 SESSION中,虽然这样的实体对象中有很多数据,但是如果你想得到这些实体对应的1对多或多对1的实体时,就会发现会出现session已经关闭的异常。或则在你更新数据时出现not-null异常等。
Remember that ordinal parameters are 1-based!
2007-05-13 08:16
Remember that ordinal parameters are 1-based!
HQL语句有错误
failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed
2007-05-11 10:47
这个异常大致意思是说在多对一的时候(并且lazy="false"),对象的实例失败,多数出现的情况有
1、粗心造成
实例对象类名写错之类的
2、逻辑错误
如之前就已经传递过来一个实体对象,然后调用实体对象的方法时牵涉到1对多的情况,但此时SESSION已经关闭,所以根本无法进行一对多的操作。
3、设计到跨度的问题:
这样打比方有多个实体对象,他们直接或则间接的有关联。比如有4个实体,分别是广告信息、广告、广告问答题、广告商:他们之间的关系为:
广告商 1:n 广告
广告 1:n 广告问答题
广告商 1:n 广告商信息
大家可以看到广告和广告商信息是没有直接关系的。但我要添加广告的时候我就必须将广告商的实体做为条件。那么这么一来广告商信息可能间接的就必须用上。下面看我的操作:
ad(广告),subject(题目)
Ad ad = new Ad();
ad.setAdProd(adform.getAdProd());
ad.setIndustry(industry);
ad.setAdPicture(pagefile.getFileName());
ad.setAdFlack(adform.getAdFlack());
ad.setAdDv(dvfile.getFileName());
ad.setAdContent(adform.getAdContent());
ad.setGray(gray);
ad.setAdDate(new Date());
ad.setOnlinetime(new Long(0));
//以上为广告的基本信息填写,而重要的是看下面一句,在这里我的思路是subjectFormList是一个动态提交的表单,里面有若干个广告问答题。我将这些问答题变为一个Set,然后作为ad的一个属性。
Set<Subject> subjectset=getSubjectSet(subjectFormList,ad);
ad.setSubjects(subjectset);
//然后提交,makePersistent是一个封装的方法,用途就是save()啦。addao是一个DAO,里面有ADUS。
addao.makePersistent(ad);
表面上看来很符合逻辑,只要我们在ad的映射里面加上对subject的级联更新就可以完成这项操作。但实际上会发生我们意想不到的问题,来让我们看一下getSubjectSet()的内容:
public Set getSubjectSet(List<SubjectForm> subjectlist,Ad ad)
{
Set<Subject> set=new HashSet<Subject>(0);
Subject subject;
for(Iterator<SubjectForm> it=subjectlist.iterator();it.hasNext();)
{
subject=new Subject();
SubjectForm sf=it.next();
subject.setSuContent(sf.getSucontent());
subject.setSuOption(sf.getSuoption());
subject.setSuResult(Arrays.deepToString(sf.getSuresult()));
subject.setSuType(String.valueOf(sf.getSutype()));
subject.setAd(ad);
set.add(subject);
}
return set;
}
我们在这个方法上设一个断点然后跟踪,之后你会发现断点在set.add(subject)只后就会出failed to lazily initialize a collection of role: XXXXXXXX no session or session was closed这个异常,并且这个异常还是出在了广告商的广告信息上 gray.messages。是不是很不可理解?这也是Hibernate的懒汉机制问题。没有任何一样技术是完美的。那我们该怎么处理这样的问题。有很多人以为我们在广告商对广告商信息的隐射上加lazy="false"这样在对gray操作会对messages进行关联,并查询时提出数据。但你会发现改完之后会出现org.hibernate.LazyInitializationException: illegal access to loading collection这个异常。并切lazy="false"是我们不推荐的一种方法。他会降低你的查询效率。
对于这样的情况最好的解决办法就是不要偷懒,对一个实体进行操作的时候就该用那个实体的DAO,即应该有2句HQL。如下把getSubjectSet()改一改:
public void getSubjectSet(List<SubjectForm> subjectlist,Ad ad)
{
Set<Subject> set=new HashSet<Subject>(0);
SubjectDAO subjectdao=DAOFactory.getDao(SubjectDAO.class);
for(Iterator<SubjectForm> it=subjectlist.iterator();it.hasNext();)
{
Subject subject=new Subject();
SubjectForm sf=it.next();
subject.setSuContent(sf.getSucontent());
subject.setSuOption(sf.getSuoption());
subject.setSuResult(Arrays.deepToString(sf.getSuresult()));
subject.setSuType(String.valueOf(sf.getSutype()));
subject.setAd(ad);
subjectdao.makePersistent(subject);
//set.add(subject);
}
}//遍历出所有subject一个个的往数据库里加。这样便不会出问题了。
1、OpenSessionInView模式:
以下有2种方法,第1种是结合SPRING,第2种是采用了拦截器
Spring+Hibernate中, 集合映射如果使用lazy="true", 当PO传到View层时, 出现未初始化session已关闭的错误,只能在dao先初始化
parent.getChilds().size();
Spring提供Open Session In View来解决这个问题, 有两种方式
1. Interceptor <!--</span><span style="COLOR: rgb(0,128,0)"> =========== OpenSession In View pattern ==============</span><span style="COLOR: rgb(0,128,0)">-->
<bean id="openSessionInViewInterceptor"
class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors" ref="openSessionInViewInterceptor"/>
<property name="mappings">
<props>
......
</props>
</property>
</bean>2. Filter <web-app>
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
</web-app>
第2种解决方法:
Hibernate.initialize()强制加载关联对象
Could not initialize proxy - the owning Session was closed (篇幅一)
2007-05-11 09:52
其实这个异常写的非常之清楚,就是会话关闭,无法对Hibernate实体进行操作。造成这样的情况有很多,什么书写错误啊,逻辑错误啊。
但就此说一下关于lazy机制:
延迟初始化错误是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略,那么必须当代理类实例或代理集合处于持久化状态(即处于Session范围内)时,才能初始化它。如果在游离状态时才初始化它,就会产生延迟初始化错误。
下面把Customer.hbm.xml文件的<class>元素的lazy属性设为true,表示使用延迟检索策略:
<class name="mypack.Customer" table="CUSTOMERS" lazy="true">
当执行Session的load()方法时,Hibernate不会立即执行查询CUSTOMERS表的select语句,仅仅返回Customer类的代理类的实例,这个代理类具由以下特征:
(1) 由Hibernate在运行时动态生成,它扩展了Customer类,因此它继承了Customer类的所有属性和方法,但它的实现对于应用程序是透明的。
(2) 当Hibernate创建Customer代理类实例时,仅仅初始化了它的OID属性,其他属性都为null,因此这个代理类实例占用的内存很少。
(3)当应用程序第一次访问Customer代理类实例时(例如调用customer.getXXX()或customer.setXXX()方法), Hibernate会初始化代理类实例,在初始化过程中执行select语句,真正从数据库中加载Customer对象的所有数据。但有个例外,那就是当应用程序访问Customer代理类实例的getId()方法时,Hibernate不会初始化代理类实例,因为在创建代理类实例时OID就存在了,不必到数据库中去查询。
提示:Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具,它能够在程序运行时动态生成扩展 Java类或者实现Java接口的代理类。关于CGLIB的更多知识,请参考:http://cglib.sourceforge.net/。
以下代码先通过Session的load()方法加载Customer对象,然后访问它的name属性:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getName();
tx.commit();
在运行session.load()方法时Hibernate不执行任何select语句,仅仅返回Customer类的代理类的实例,它的OID 为1,这是由load()方法的第二个参数指定的。当应用程序调用customer.getName()方法时,Hibernate会初始化 Customer代理类实例,从数据库中加载Customer对象的数据,执行以下select语句:
select * from CUSTOMERS where ID=1;
select * from ORDERS where CUSTOMER_ID=1;
当<class>元素的lazy属性为true,会影响Session的load()方法的各种运行时行为,下面举例说明。
1.如果加载的Customer对象在数据库中不存在,Session的load()方法不会抛出异常,只有当运行customer.getName()方法时才会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
mypack.Customer
2.如果在整个Session范围内,应用程序没有访问过Customer对象,那么Customer代理类的实例一直不会被初始化,Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
tx.commit();
session.close();
customer.getName();
由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化,因此在执行customer.getName()方法时,Hibernate会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
由此可见,Customer代理类的实例只有在当前Session范围内才能被初始化。
3.net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例,isInitialized()方法用于判断代理类实例是否已经被初始化。例如:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
if(!Hibernate.isInitialized(customer))
Hibernate.initialize(customer);
tx.commit();
session.close();
customer.getName();
以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例,因此当Session关闭后,可以正常访问Customer游离对象。
4.当应用程序访问代理类实例的getId()方法时,不会触发Hibernate初始化代理类实例的行为,例如:
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,new Long(1));
customer.getId();
tx.commit();
session.close();
customer.getName();
当应用程序访问customer.getId()方法时,该方法直接返回Customer代理类实例的OID值,无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例,因此当Session关闭后再执行customer.getName()方法, Hibernate会抛出以下异常:
ERROR LazyInitializer:63 - Exception initializing proxy
net.sf.hibernate.HibernateException: Could not initialize proxy - the owning Session was closed
解决方法:
由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的 session已关闭掉,就会产生种错误.
在做一对多时,有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在<many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫
failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed
此异常解决方案请察看本人博客(http://hi.baidu.com/kekemao1)的Hibernate异常中的《failed to lazily initialize a collection of role异常》
?
解决方法:在web.xml中加入
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
</filter-class>
</filter
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
就可以了;
参考了:
Hibernate与延迟加载:
Hibernate对象关系映射提供延迟的与非延迟的对象初始化。非延迟加载在读取一个对象的时候会将与这个对象所有相关的其他对象一起读取出来。这有时会导致成百的(如果不是成千的话)select语句在读取对象的时候执行。这个问题有时出现在使用双向关系的时候,经常会导致整个数据库都在初始化的阶段被读出来了。当然,你可以不厌其烦地检查每一个对象与其他对象的关系,并把那些最昂贵的删除,但是到最后,我们可能会因此失去了本想在ORM工具中获得的便利。
一个明显的解决方法是使用Hibernate提供的延迟加载机制。这种初始化策略只在一个对象调用它的一对多或多对多关系时才将关系对象读取出来。这个过程对开发者来说是透明的,而且只进行了很少的数据库操作请求,因此会得到比较明显的性能提升。这项技术的一个缺陷是延迟加载技术要求一个 Hibernate会话要在对象使用的时候一直开着。这会成为通过使用DAO模式将持久层抽象出来时的一个主要问题。为了将持久化机制完全地抽象出来,所有的数据库逻辑,包括打开或关闭会话,都不能在应用层出现。最常见的是,一些实现了简单接口的DAO实现类将数据库逻辑完全封装起来了。一种快速但是笨拙的解决方法是放弃DAO模式,将数据库连接逻辑加到应用层中来。这可能对一些小的应用程序有效,但是在大的系统中,这是一个严重的设计缺陷,妨碍了系统的可扩展性。
在Web层进行延迟加载
幸运的是,Spring框架为Hibernate延迟加载与DAO模式的整合提供了一种方便的解决方法。对那些不熟悉Spring与 Hibernate集成使用的人,我不会在这里讨论过多的细节,但是我建议你去了解Hibernate与Spring集成的数据访问。以一个Web应用为例,Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor。我们可以随意选择一个类来实现相同的功能。两种方法唯一的不同就在于interceptor在Spring容器中运行并被配置在web应用的上下文中,而Filter在 Spring之前运行并被配置在web.xml中。不管用哪个,他们都在请求将当前会话与当前(数据库)线程绑定时打开Hibernate会话。一旦已绑定到线程,这个打开了的Hibernate会话可以在DAO实现类中透明地使用。这个会话会为延迟加载数据库中值对象的视图保持打开状态。一旦这个逻辑视图完成了,Hibernate会话会在Filter的doFilter方法或者Interceptor的postHandle方法中被关闭。下面是每个组件的配置示例:
Interceptor的配置:
<beans>
<bean id="urlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors">
<list>
<ref bean="openSessionInViewInterceptor"/>
</list>
</property>
<property name="mappings">
</bean>
<bean name="openSessionInViewInterceptor"
class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
<property name="sessionFactory"><ref bean="sessionFactory"/></property>
</bean>
</beans>
Filter的配置
<web-app>
<filter>
<filter-name>hibernateFilter</filter-name>
<filter-class>
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*. spring </url-pattern>
</filter-mapping>
</web-app>
实现Hibernate的Dao接口来使用打开的会话是很容易的。事实上,如果你已经使用了Spring框架来实现你的Hibernate Dao,很可能你不需要改变任何东西。方便的HibernateTemplate公用组件使访问数据库变成小菜一碟,而DAO接口只有通过这个组件才可以访问到数据库。下面是一个示例的DAO:
public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {
public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product.class, productId);
}
public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}
public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}
在业务逻辑层中使用延迟加载
即使在视图外面,Spring框架也通过使用AOP 拦截器 HibernateInterceptor来使得延迟加载变得很容易实现。这个Hibernate 拦截器透明地将调用配置在Spring应用程序上下文中的业务对象中方法的请求拦截下来,在调用方法之前打开一个Hibernate会话,然后在方法执行完之后将会话关闭。让我们来看一个简单的例子,假设我们有一个接口BussinessObject:
public interface BusinessObject {
public void doSomethingThatInvolvesDaos();
}
类BusinessObjectImpl实现了BusinessObject接口:
public class BusinessObjectImpl implements BusinessObject {
public void doSomethingThatInvolvesDaos() {
// lots of logic that calls
// DAO classes Which access
// data objects lazily
}
}
通过在Spring应用程序上下文中的一些配置,我们可以让将调用BusinessObject的方法拦截下来,再令它的方法支持延迟加载。看看下面的一个程序片段:
<beans>
<bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
<property name="someDAO"><ref bean="someDAO"/></property>
</bean>
<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target"><ref bean="businessObjectTarget"/></property>
<property name="proxyInterfaces">
<value>com.acompany.BusinessObject</value>
</property>
<property name="interceptorNames">
<list>
<value>hibernateInterceptor</value>
</list>
</property>
</bean>
</beans>
当businessObject被调用的时候,HibernateInterceptor打开一个Hibernate会话,并将调用请求传递给 BusinessObjectImpl对象。当BusinessObjectImpl执行完成后,HibernateInterceptor透明地关闭了会话。应用层的代码不用了解任何持久层逻辑,还是实现了延迟加载。
在单元测试中测试延迟加载
最后,我们需要用J-Unit来测试我们的延迟加载程序。我们可以轻易地通过重写TestCase类中的setUp和tearDown方法来实现这个要求。我比较喜欢用这个方便的抽象类作为我所有测试类的基类。
public abstract class MyLazyTestCase extends TestCase {
private SessionFactory sessionFactory;
private Session session;
public void setUp() throws Exception {
super.setUp();
SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
session = SessionFactoryUtils.getSession(sessionFactory, true);
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
}
protected Object getBean(String beanName) {
//Code to get objects from Spring application context
}
public void tearDown() throws Exception {
super.tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}
}
Hibernate的No CurrentSessionContext configured 解决方案
2007-05-09 17:53Hibernate No CurrentSessionContext configured!
当你使用 Hibernate session factory的getCurrentSession() 函数时候,你可能见到过"No CurrentSessionContext configured!"
出现这个问题,是因为你没有正确配置 Hibernate internal session context management .
你只要在Hibernate.cfg.xml文件中添加下面的配置就可以了:
<property name="current_session_context_class">thread</property>
相关推荐
总结来说,Java异常框架处理涉及的知识点包括异常类的层次结构、运行时异常与检查型异常的区别、异常处理结构(try-catch-finally)、自定义异常的设计与使用、第三方库异常的处理以及异常处理关键字的使用。...
异常处理是系统稳定运行的关键,"异常的的处理.txt"可能包含关于如何在Struts和Hibernate中优雅地捕获和处理异常的指南,确保系统在遇到错误时能够恢复或提供有用的反馈给用户。 使用Struts+Hibernate的电子商务...
6. 错误处理:Struts2提供了一套完整的异常处理机制,可以统一处理程序运行中的错误。 这个论坛系统的开发过程可能包括以下几个步骤: 1. 设计数据库模型,建立对应的Hibernate实体类。 2. 配置Struts2和Hibernate...
在Java Web开发中,异常处理是一项至关重要的任务,它关系到系统的稳定性和用户体验。当我们谈论Java Web项目的整体异常处理机制时,我们关注的是如何优雅地处理可能出现的各种异常,避免将错误信息直接暴露给用户,...
7. **Hibernate异常处理**:在使用Hibernate进行数据操作时,可能会遇到如`HibernateException`、`ConstraintViolationException`等。理解Hibernate的异常体系和如何适当地捕获处理这些异常对于保证数据操作的稳定性...
此外,Struts还提供了国际化、异常处理和 Tiles 模板等功能,便于开发者构建用户界面。 接下来,Hibernate是一个对象关系映射(ORM)框架,它简化了数据库操作,使得开发者可以使用面向对象的方式来操作数据库。在...
- 在集成过程中,需要注意统一异常处理策略,确保系统的健壮性和稳定性。 - 例如,在NetstoreEJB的Remote接口中定义了一系列异常,用于处理不同类型的错误情况。 4. **部署与测试**: - 应用程序需要在支持Java ...
Hibernate 有一套完善的异常体系,3.6.0 版本细化了异常分类,帮助开发者更好地定位问题,提高问题排查效率。 7. **兼容性与扩展性** Hibernate 3.6.0 Beta3 兼容多种数据库,包括 MySQL、Oracle、PostgreSQL 等...
11.2.3. 异常处理 11.2.4. 事务超时 11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 扩展周期的session和自动版本化 11.3.3. 脱...
- **Java异常处理**:了解Java中的异常分类以及如何有效地处理异常,对于编写健壮的应用程序至关重要。 通过以上对Hibernate和Spring技术栈中的关键知识点的梳理,希望能帮助读者更好地理解和掌握这两个框架,从而...
10. **错误处理**:合理处理文件上传和评论过程中可能出现的各种异常,如文件不存在、磁盘空间不足、网络问题等,提供友好的错误提示。 通过以上步骤,我们可以构建一个健壮且易于维护的基于Hibernate的文件上传...
5. 异常处理:使用Struts的拦截器处理可能出现的异常,提高系统的健壮性。 六、系统优化与拓展 在实际应用中,可以进一步优化系统性能,如使用缓存技术提高查询速度,引入Spring框架实现依赖注入,提高代码的可...
6. **错误处理与优化**:在实际开发中,还需要考虑错误处理,如网络异常、数据库异常等。同时,为了提高用户体验,可以添加默认值,优化加载速度,以及使用缓存来减少不必要的数据库查询。 这个DuoJiFenLei压缩包...
11. **实用工具和技巧**:分享一些开发过程中可能遇到的问题及解决方法,如对象持久化、异常处理和调试技巧。 通过《韩顺平2011Hibernate3.3视频教程资料》,开发者不仅可以掌握Hibernate的基本使用,还能深入了解...
11.2.3. 异常处理 11.2.4. 事务超时 11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 扩展周期的session和自动版本化 11.3.3. 脱...
11.2.3. 异常处理 11.2.4. 事务超时 11.3. 乐观并发控制(Optimistic concurrency control) 11.3.1. 应用程序级别的版本检查(Application version checking) 11.3.2. 扩展周期的session和自动版本化 11.3.3. 脱...
为了保证系统稳定性和安全性,还需要考虑异常处理、事务管理、权限控制等方面的设计。 **开发实践** 1. **环境搭建**:首先需要安装JDK、Tomcat服务器,然后引入Struts2和Hibernate的依赖库。 2. **数据库设计**:...
在实际开发过程中,还需要考虑安全性(如防止SQL注入、XSS攻击)、性能优化(如缓存策略、数据库索引)、异常处理等多方面问题。 总之,基于Mybatis、Hibernate和Spring框架开发的绿色健康购物网是一个全面的Java ...
处理异常 9.8. 生命周期和对象图(Lifecyles and object graphs) 9.9. 拦截器(Interceptors) 9.10. 元数据(Metadata) API 10. 事务和并行(Transactions And Concurrency) 10.1. 配置,会话和工厂...
实体类对应数据库中的表,业务逻辑处理各种操作,如增删改查、分类管理等,而数据存储则依赖于数据库。 三、环境配置 1. Java开发环境:确保安装JDK,并配置好环境变量。 2. 数据库:选择合适的数据库,如MySQL,...