小编Kri*_*mbe的帖子

我正在使用Apache Commons EqualsBuilder为非静态Java内部类构建equals方法.例如:

import org.apache.commons.lang.builder.EqualsBuilder;

public class Foo {
    public class Bar {
        private Bar() {}

        public Foo getMyFoo() {
            return Foo.this
        }

        private int myInt = 0;

        public boolean equals(Object o) {
            if (o == null || o.getClass() != getClass) return false;

            Bar other = (Bar) o;
            return new EqualsBuilder()
                .append(getMyFoo(), other.getMyFoo())
                .append(myInt, other.myInt)
                .isEquals();
        }
    }

    public Bar createBar(...) {
        //sensible implementation
    }

    public Bar createOtherBar(...) {
        //another implementation
    }

    public boolean equals(Object o) {
        //sensible equals implementation …

据我所知,创建动态Java代理需要有一个接口来处理代理.然而,Hibernate似乎在不需要为实体类编写接口的情况下管理其动态代理生成.它是如何做到的？Hibernate文档中唯一的线索是指类必须至少具有用于代理生成的包可见构造函数.

Hibernate是否使用自定义类加载器进行运行时字节码工程？文档表明情况并非如此.那么他们如何围绕具体的实体对象创建代理包装器呢？他们只是创建了一些简单的接口代理而不用担心类型安全,然后根据需要进行转换吗？

有没有可以传递的Java编译器标志告诉编译器不允许使用原始类型？也就是说,对于任何泛型类,让编译器强制使用参数化版本,否则抛出编译错误？

我正在使用EJB3(用于应用程序和Web服务层的Hibernate + Glassfish,用于Web UI的Glass on Glassfish)开发Java中的多层财务处理应用程序,我正在努力解决在何处使用把我的业务逻辑.

当这个项目开始时,我们的第一个想法是将大部分业务逻辑放入无状态会话bean中.但是,随着时间的推移,我们发现EJB框架提供的依赖注入过于局限,因此我们的许多业务逻辑最终都出现在由Guice在无状态会话bean的@PostConstruct方法中组装的POJO中. .这一进展导致我们的会话bean和POJO之间的业务逻辑分散,我正试图找出一种方法来纠正这个问题.

最初,我们尝试让我们的Web层使用会话bean的远程接口来执行一些可以从UI和Web服务层访问的功能,这些功能由@ WebService-annotated无状态会话bean提供.从持久性和性能的角度来看,这是一场噩梦,因为我们的实体图可能会变得非常大,并且将分离的实体图重新附加到持久化上下文,结果是非常容易出错,所以我们的解决方案是开始只是传递对象数据库周围的标识符,无论它们在何处需要,都可以从中查找实体.

我的基本问题是:您可以建议什么原则和指导方针来决定业务逻辑是应该进入会话bean还是POJO？在给定复杂的对象图的情况下,何时传递实体bean是有意义的？

在Scala中,重载和隐式参数解析的交互似乎使得无法使以下代码可用.

trait Bijection[A, B] extends Function1[A, B] with Unapply[A, B] { self =>
  def apply(a: A): B
  def unapply(b: B): A
}

sealed trait Unapply[A, B] {
  def unapply(b: B): A
}

object Bijection {
  implicit def biject[A](a: A): Biject[A] = new Biject(a)

  implicit object IntStringBijection extends Bijection[Int, String] {
    override def apply(a: Int): String = a.toString
    override def unapply(b: String): Int = b.toInt
  }
}

sealed class Biject[A](a: A) {
  def as[B](implicit f: Function1[A, B]): B = f(a)
  def …

在工作中，我遇到了一种情况，描述函数返回的结果的最佳类型是std::variant<uint64_t, uint64_t>- 当然，这不是有效的 C++，因为你不能有两个相同类型的变体。我可以将其表示为 a std::pair<bool, uint64_t>，或者该对的第一个元素是枚举，但这是一个特殊情况；astd::variant<uint64_t, uint64_t, bool>不是那么容易表示，我的函数式编程背景真的让我想要Either- 所以我去尝试实现它，使用访问者模式，因为我已经能够在没有对和类型的本机支持的其他语言中做到这一点：

template <typename A, typename B, typename C>
class EitherVisitor {
    virtual C onLeft(const A& left) = 0;
    virtual C onRight(const B& right) = 0;
};

template <typename A, typename B>
class Either {
    template <typename C>
    virtual C Accept(EitherVisitor<A, B, C> visitor) = 0;
};

template <typename A, typename B>
class Left: Either<A, B> {
private:
    A value;
public:
    Left(const A& valueIn): value(valueIn) …

我正在寻找有关如何将运行时依赖项注入从Hibernate检索的JPA实体的建议.我的问题基本上是这样的:

我有一些Transaction对象的不同子类.每个Transaction子类在执行时都有不同的行为,并且需要与环境不同的一组依赖项.这些Transaction对象由Hibernate作为JPA实体进行管理,因此我不能有效地使用Guice进行依赖注入来填充实例及其环境依赖性,就像我在其余的应用程序中一样.

为了解决这个问题,我采用了一种类似于访问者模式的方法,如下所示:

public abstract class Transaction {
    // ...snip...
    public abstract void apply(Transactor transactor);
}

public class TransactionA extends Transaction {
    public void apply(Transactor transactor) {
        transactor.execute(this);
    }
}

public class TransactionB extends Transaction {
    public void apply(Transactor transactor) {
        transactor.execute(this);
    }
}
// other Transaction subclasses with the same boilerplate

public interface Transactor {
    public void execute(TransactionA trans);
    public void execute(TransactionB trans);
    // corresponding methods for other transaction types.
}

public class BeginTransactor {
     @Inject
     private Foo execAdep; …

为什么编译器无法在以下示例中从Collections.emptySet()推断出结果的正确类型？

import java.util.*;
import java.io.*;

public class Test {
    public interface Option<A> {
        public <B> B option(B b, F<A,B> f);
    }

    public interface F<A,B> {
        public B f(A a);
    }

    public Collection<String> getColl() {
        Option<Integer> iopt = null;

        return iopt.option(Collections.emptySet(), new F<Integer, Collection<String>>() {
            public Collection<String> f(Integer i) {
                return Collections.singleton(i.toString());
            }
        });
    }
}

这是编译器错误消息:

knuttycombe@knuttycombe-ubuntu:~/tmp/java$ javac Test.java 
Test.java:16: <B>option(B,Test.F<java.lang.Integer,B>) in 
Test.Option<java.lang.Integer> cannot be applied to (java.util.Set<java.lang.Object>,
<anonymous Test.F<java.lang.Integer,java.util.Collection<java.lang.String>>>)
            return iopt.option(Collections.emptySet(), new F<Integer, Collection<String>>() {
                   ^
1 error

现在,getColl()的以下实现当然有效: …