我一直患有臭名昭着的hibernate异常
org.hibernate.LazyInitializationException: could not initialize proxy - no Session
现在社区正在欢呼
<property name="hibernate.enable_lazy_load_no_trans" value="true"/>
说它解决了问题,但小心使用它.
他们的意思是谨慎使用它？这个属性实际上做了什么？
请给我任何见解.提前致谢.
我正在为一个想要使用延迟初始化的客户开发一个项目.当使用默认延迟加载模式映射类时,它们总是会出现"延迟初始化异常".
@JoinTable(name = "join_profilo_funzionalita", joinColumns = {@JoinColumn(name = "profilo_id", referencedColumnName = "profilo_id")}, inverseJoinColumns = {@JoinColumn(name = "funzionalita_id", referencedColumnName = "funzionalita_id")})
//@ManyToMany(fetch=FetchType.EAGER) - no exceptions if uncommented
@ManyToMany
private Collection<Funzionalita> funzionalitaIdCollection;
是否有使用JPA类的标准模式来避免此错误？
欢迎使用片段,非常感谢您的时间.
我想对Swift中的一些属性使用Lazy初始化.我当前的代码如下所示:
lazy var fontSize : CGFloat = {
if (someCase) {
return CGFloat(30)
} else {
return CGFloat(17)
}
}()
问题是,一旦设置了fontSize,它将永远不会改变.所以我想做这样的事情:
lazy let fontSize : CGFloat = {
if (someCase) {
return CGFloat(30)
} else {
return CGFloat(17)
}
}()
这是不可能的.
只有这个有效:
let fontSize : CGFloat = {
if (someCase) {
return CGFloat(30)
} else {
return CGFloat(17)
}
}()
所以 - 我想要一个延迟加载但永远不会改变的属性.这样做的正确方法是什么？使用let和忘记懒惰的初始化？或者我应该使用lazy var并忘记属性的恒定性质？
我想在没有if语句的情况下实现惰性字段初始化(或延迟初始化)并利用lambdas.所以,我想具有以下Foo属性的相同行为,但没有if:
class A<T>{
private T fooField;
public T getFoo(){
if( fooField == null ) fooField = expensiveInit();
return fooField;
}
}
忽略这个解决方案不能保证安全使用的事实:1)多线程; 2)null作为有效值T.
因此,为了表达初始化fooField被推迟到第一次使用的意图,我想声明fooField类型Supplier<T>如下:
class A<T>{
private Supplier<T> fooField = () -> expensiveInit();
public T getFoo(){
return fooField.get();
}
}
然后在getFoo财产中我会回来fooField.get().但是现在我想要对getFoo属性的下一次调用避免expensiveInit()并且只返回前一个T实例.
如何在不使用的情况下实现这一目标if？
尽管命名约定并替换了->by =>,但是这个例子也可以在C#中考虑.但是,.NET Framework版本4已经提供了Lazy<T>所需的语义.
有哪些推荐的方法可以实现线程安全的延迟初始化？例如,
// Not thread-safe
public Foo getInstance(){
if(INSTANCE == null){
INSTANCE = new Foo();
}
return INSTANCE;
}
有没有办法在C++中实现单例对象:
(我不太了解我的C++,但是在执行任何代码之前初始化积分和常量静态变量的情况(即,甚至在执行静态构造函数之前 - 它们的值可能已在程序中"初始化")如果是这样的话 - 也许这可以被利用来实现单例互斥体 - 这反过来可以用来保护真正的单例的创建......)
很好,现在我似乎有几个好的答案(羞耻我不能标记2或3作为答案).似乎有两个广泛的解决方案:
c++ singleton construction multithreading lazy-initialization
我想使用Lazy T来实现memoization,但初始化函数似乎需要一个静态上下文.
例如,以下代码拒绝编译,警告非静态成员a和b不可访问.我不清楚为什么会这样,因为Lazy对象本身就是一个实例成员,并且在静态上下文中没有可见性.
public class SomeExpensiveCalculation
{
private int a;
private int b;
public Lazy<int> Result = new Lazy<int>(() => a + b); //nope!
}
如果单例实现如下,
class Singleton {
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}
}
这个实现与延迟初始化方法有何不同？在这种情况下,将在加载类时创建实例,并且仅在第一次活动使用时加载类本身(例如,当您声明Singleton singleton = null时,不会加载Singleton.getInstance();)
即使使用延迟初始化方法,也会在调用getInstance()时创建实例
我错过了什么吗？
要执行无锁和无等待的延迟初始化,请执行以下操作:
private AtomicReference<Foo> instance = new AtomicReference<>(null);
public Foo getInstance() {
Foo foo = instance.get();
if (foo == null) {
foo = new Foo(); // create and initialize actual instance
if (instance.compareAndSet(null, foo)) // CAS succeeded
return foo;
else // CAS failed: other thread set an object
return instance.get();
} else {
return foo;
}
}
除了一件事之外,它的效果非常好:如果两个线程看到实例null,它们都会创建一个新对象,只有一个幸运的是通过CAS操作设置它,这会浪费资源.
有没有人建议另一种无锁延迟初始化模式,这会降低两个并发线程创建两个昂贵对象的可能性？
Swift中的懒惰变量是不是一次计算过的？我的印象是他们取代了:
if (instanceVariable) {
return instanceVariable;
}
// set up variable that has not been initialized
来自Objective-C的范例(懒惰的实例化).
那是他们做的吗？基本上只在第一次应用程序要求变量时调用,然后才返回计算的内容？
或者它每次都像普通的计算属性一样被调用？
我问的原因是因为我基本上想在Swift中有一个可以访问其他实例变量的计算属性.假设我有一个名为"fullName"的变量,它只是连接firstName和lastName.我怎么会在Swift中这样做？似乎懒惰变量是唯一的方法,因为在正常的计算变量(非惰性)中我无法访问其他实例变量.
所以基本上:
Swift中的懒惰变量不止一次被调用吗？如果是这样,我如何创建一个可以访问实例变量的计算变量？如果没有,如果出于性能原因我只想要计算一次变量,我该怎么做？