小编Ben*_*n M的帖子

我在“条件查询”中遇到了严重问题。

我的实体类如下所示：

class X {
  ...
    @Columns(columns = {
      @Column(name = "priceCurrency", nullable = false),
      @Column(name = "priceAmount", nullable = false)})
    @Type(type = "org.jadira.usertype.moneyandcurrency.joda.PersistentBigMoneyAmountAndCurrency")
    @Basic(fetch = FetchType.EAGER)
    BigMoney price;
  ...
}

而且我还有另一个班级Y，其中有一个List<X> xs。

我也有一个正常的 JPA查询：

SELECT y
  FROM Y y
  LEFT JOIN y.xs x
  GROUP BY y
  ORDER BY SUM(y.price.amount)

现在，我想将其转移到CriteriaQuery。我开始于：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Y> q = cb.createQuery(Y.class);
Root<Y> root = q.from(Y.class);

ListJoin<Y, X> j = root.join(Y_.xs, JoinType.LEFT);
q.groupBy(root);

我尝试了一些方法，但是都没有用:(这里有一些例子：

Path<BigDecimal> x = j.get("priceAmount");

要么：

Path<BigDecimal> …

我不知道从什么时候起这成为可能，但我只是按照我一直想要的方式创建了复合键：不@EmbeddedId，不需要@IdClass！

• 春天4.0.0.M3
• 休眠4.3.0.Beta4
• JPA 2.1

用户.java：

@Entity
public class User {
    @Id
    ...

    @OneToMany(mappedBy="user", cascade=CascadeType.ALL, orphanRemoval=true)
    private List<GroupUser> groupUsers;     
}

组.java：

@Entity
public class Group {
    @Id
    ...

    @OneToMany(mappedBy="user", cascade=CascadeType.ALL, orphanRemoval=true)
    private List<GroupUser> groupUsers;     
}

组用户.java：

@Entity
public class GroupUser implements Serializable {
    @Id
    @ManyToOne
    @JoinColumn(name="Group_id")
    private Group group;

    @Id
    @ManyToOne
    @JoinColumn(name="User_id")
    private User user;

    @Id
    @Column
    private String s;

    @Column
    private int i;
}

MySQL 是这样说的：

 USER             GROUP_USER            GROUP
------    -------------------------    ------- …

我需要使用MongoDB实现一些锁定机制,以防止数据不一致,但允许脏读.

条件:

• WRITE只有在没有READ锁定且没有WRITE锁定的情况下才能获得锁定.

• READ只有在没有WRITE锁定的情况下才能获得锁定.

• READ单个文档上可以有许多并行锁.

• 必须有某种超时机制:如果(无论出于何种原因)某个进程未释放其锁定,则应用程序必须能够恢复.

只需忽略查询中的所有锁即可进行脏读.

(WRITE进程的饥饿不是本主题的一部分)

为什么READ和WRITE锁/为什么不只使用WRITE锁:

让我们假设,我们有2个集合:contacts和categories.这是一种nm关系,每个联系人都有一个类别ID数组.

READ锁定:向联系人添加类别时,我们必须确保此类别不会被删除(需要WRITE锁定,请参阅下文).并且因为READ同一文档上可能存在许多锁,所以多个进程可以将此单个类别添加到多个联系人.

WRITE锁定:删除类别时,我们必须先从所有联系人中删除类别ID.在此操作正在运行时,我们必须确保无法将此类别添加到任何联系人(此操作需要READ锁定).之后我们可以安全地删除类别文档.

这样,总会有一致的状态.

超时:

这是最难的部分.我已经尝试过两次,但总是发现一些问题,似乎太难解决了.

基本思路:每次获取的锁都带有时间戳,直到此锁有效.如果此时间戳是过去的,我们可以忽略该锁定.当一个进程完成其任务时,它应该删除它的锁.

最大的挑战是拥有多个READ锁,每个READ锁都有自己的超时,但多个READ锁可以具有相同的超时值.释放READ锁时,它必须只释放自己,所有其他READ锁必须保留.

我的上次实施:

{
  _id: 1234,
  lock: {
    read: [
      ISODate("2015-06-26T12:00:00Z")
    ],
    write: null
  }
}

要么lock.read可以包含元素,要么 lock.write …

当用户到达页面底部时，我table使用无限滚动滚动来加载更多结果并将其附加。

目前，我有以下代码：

var currentPage = 0;
var tableContent = Rx.Observable.empty();

function getHTTPDataPageObservable(pageNumber) {
    return Rx.Observable.fromPromise($http(...));
}

function init() {
    reset();
}

function reset() {
    currentPage = 0;
    tableContent = Rx.Observable.empty();
    appendNextPage();
}

function appendNextPage() {
    if(currentPage == 0) {
        tableContent = getHTTPDataPageObservable(++currentPage)
                .map(function(page) { return page.content; });
    } else {
        tableContent = tableContent.combineLatest(
            getHTTPDataPageObservable(++currentPage)
                    .map(function(page) { return page.content; }),
            function(o1, o2) {
                return o1.concat(o2);
            }
        )
    }
}

有一个主要问题：

每次appendNextPage调用时，我都会得到一个全新的信息 …

首先我的软件堆栈:

• Eclipse 4.2
• Tomcat 7.0.37
• 使用m2e插件的Maven
• javax.servlet 3.0.1
• Spring WebMVC和Spring Web 3.2.1

我正在使用没有web.xml的 servlet 3 .

我做了什么:

• Eclipse - > New Maven项目
• 编辑pom.xml:添加Spring和javax.servlet
• Eclipse - >项目属性 - >项目构面 - >添加动态Web构面
• Eclipse - >项目属性 - >部署程序集 - >删除WebContent并添加/ src/main/webapp
• 添加javax.servlet.ServletContainerInitializer到/ src/main/webapp/META-INF/services并放入实现的完全限定类名WebApplicationInitializer

目前我的项目包含大约7个文件(3x .java,1x .jsp,1x .html,1x .pom,1x javax.servlet.ServletContainerInitializer)

什么有效:

通过Maven编译和war-packaging,然后简单地在独立的Tomcat上部署.war.

• http://127.0.0.1/MyApp/ 显示index.html
• http://127.0.0.1/MyApp/hello 显示hello.jsp

什么行不通:

如果我现在尝试使用Eclipse Run -> Run on Server.然后我选择我的Tomcat目录等... servlet(/hello)只给出了404.但index.html有效.

3个Java文件:

Initializer.java:

public class Initializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) …

我们有3个表：

T1:               T2:              T3:

id | t3_id        id | name        id | t2_id
----------        ---------        ----------
1  | 2            1  | abc         1  | 1
2  | NULL         2  | 123         2  | 1
3  | 1            3  | ab1         3  | 3
4  | 4            4  | 32b         4  | 2

现在我们已经测试了以下JOIN：

1 .：

SELECT
  *
FROM T1
INNER JOIN T3 ON T1.t3_id = T3.id
INNER JOIN T2 ON T3.t2_id = T2.id
WHERE T2.name = '%'

这种情况很明显。结果：

T1.id | …

我正在构建一个包含大量表单的GWT应用程序.我正在使用gwt-platform及其调度模块.

我想到的下一步是防止双重提交服务器端.问题是我不知道该怎么做......

我想到了这样的事情:

1. 应用程序加载时,服务器会向客户端提供一些生成的令牌
2. 服务器将令牌存储在HTTPSession中
3. 当客户提交表单时,它将从表单(1.)发送令牌
4. 服务器检查HTTPSession中是否发送了令牌==令牌
5. 在客户的答案中,它将发送一个新令牌

将令牌存储在HTTPSession中是否安全？或者我应该在服务器上创建一个从SESSION_ID映射到生成令牌的HashMap？

或者也许已经在GWT或gwt-platform或其他地方实现了这一点？

谢谢

我正在尝试进行一个非常简单的删除操作,但是由于我将DAO更新为JpaRepository,因此它无法正常工作.基本上是这样的:

A a = aRepository.findOne(id);
a.setSomeField("someNewString");

List<B> bList = a.getBs();
bList.clear();
aRepository.saveAndFlush(a);

字段get按预期更新,但bList保持不变.我甚至尝试过:

A a = aRepository.findOne(id);
a.setSomeField("someNewString");

List<B> bList = a.getBs();
for(B b : bList) {
   bRepository.delete(b);
}
bRepository.flush();
bList.clear();
aRepository.saveAndFlush(a);

还是一样...

A类看起来像这样:

@Entity
@Table(name = "A")
public class A implements Serializable {
    private static final long serialVersionUID = -1286451120913657028L;

    @Column(name = "id", length = 16, nullable = false, updatable = false)
    @GenericGenerator(name = "uuid", strategy = "uuid2")
    @GeneratedValue(generator = "uuid")
    @Basic(fetch = FetchType.EAGER)
    @Id
    protected UUID …

我想构建一个包装类,它在Observable的每个发出值之前和之后执行某些操作.

这是我想出的:

class Wrapper<T> {
    wrapped$: Observable<T>;

    _dataSubject = new Subject<T>();
    data$ = this._dataSubject.pipe(
        tap(_ => console.log("BEFORE"),
        //
        // map( ??? )
        //
    );

    constructor(wrapped$: Observable<T>) {
        this.wrapped$ = wrapped$.pipe(
            tap(_ => console.log("AFTER")
        );
    }
}

let subject = new Subject<string>();
let wrapper = new Wrapper(subject);
wrapper.data$.subscribe(val => console.log(val));
subject.next("foo")

控制台输出应该是:

BEFORE
foo
AFTER

我无法弄清楚如何连接$wrappedObservable _dataSubject.

但也许我完全错了,需要采用不同的方法.

我有一个简单的搜索组件，其中包含带有2个元素的反应形式：

• 文字输入（搜索任意匹配的文字）
• 复选框（包括/排除已删除的结果）

到目前为止，我使用它myFormGroup.valueChanges.subscribe(...)来执行搜索方法。

现在的问题是，我想对文本输入进行反跳操作。同时不要取消反跳复选框，因此单击该复选框时，搜索方法将立即执行。

valueChanges.debounceTime(500)当然，使用will会反跳整个表单。那不是我想要的

这是一个简化的示例。实际形式还有更多输入。有些应该去抖动，有些则不应该。

有没有简单的方法可以做到这一点？还是我必须分别订阅每个表单控件？

很高兴看到您是如何解决此问题的。

提前致谢。

编辑：代码

export class SearchComponent {

  myFormGroup: FormGroup;

  constructor(fb: FormBuilder) {
    this.myFormGroup = fb.group({
      textInput: '',
      checkbox: false
    });
  }

  ngOnInit() {
    this.myFormGroup.valueChanges.subscribe(val => {
      // debounce only the textInput,
      // and then execute search
    });
  }

}