小编Chr*_*311的帖子

查询,本机查询,命名查询和类型查询之间有什么区别？"孤独的"查询是否存在,或者它只是一个缩写？在我看来,本机Query是用简单的sql编写的查询,而命名查询是与实体(hibernate-mapping)相关.有人能简单解释一下吗？

以下三个字段的验证检查有什么区别？

@Entity
public class MyEntity {

    @Column(name = "MY_FIELD_1", length=13)
    private String myField1;
    @Column(name = "MY_FIELD_2")
    @Size(min = 13, max = 13)
    private String myField2;
    @Column(name = "MY_FIELD_3")
    @Length(min = 13, max = 13)
    private String myField3;

    // getter & setter

}

我读到第一个与DDL的东西有关.第二个是bean验证.第三个是用于休眠验证.

那是对的吗？我还不明白的是:我什么时候需要使用哪一个？这些注释中的一个何时触发？

编辑:考虑以下情况:鉴于需要开发一个具有长度为13的字符串类型字段的实体.您会选择上述哪种方法？甚至更好:你有什么问题要问自己找出哪一个适合你的目的？

声纳告诉我"用方法参考替换这个lambda"

public class MyClass {

    private List<SomeValue> createSomeValues(List<Anything> anyList) {
        return anyList //
               .stream() //
               .map(anything -> createSomeValue(anything)) //
               .collect(Collectors.toList());
   }

    private SomeValue createSomeValue(Anything anything) {
        StatusId statusId = statusId.fromId(anything.getStatus().getStatusId());
        return new SomeValue(anything.getExternId(), statusId);
    }

}

这可能吗？我尝试了几件事,比如

.map(MyClass::createSomeValue) //

但我需要将方法更改为静态.而且我不是静态方法的忠实粉丝.

SonarQube的解释是:

方法/构造函数引用比使用lambdas更紧凑和可读,因此是首选.

在这个页面上我读了以下内容:

要使用日期进行计算,这也很容易.与目前Java <1.8的情况相比,可能是最好的改进:

Period p = Period.of(2, HOURS);
LocalTime time = LocalTime.now();
LocalTime newTime = time.plus(p); // or time.plus(5, HOURS); or time.plusHours(5); 

我没有清楚地看到版本<1.8之前的优势.

也许有人可以举个例子？Atm我问自己,新的日期和时间API的改进来自哪里.

考虑一下你有几个验证.只有在要检查的对象属于某种类型时,这些验证才会生效.为什么我会在switch语句中使用一系列责任？

责任链示例

public class Executor {

@Inject
private ValidatorFactory validatorFactory;

public void execute(Konfiguration konfig) {
    List<Statement> statements = konfig.getStatements();
    AbstractValidator validator = validatorFactory.create();
    for (Statement statement : statements) {
        if (validator.validate(statement.getType())) {
            crudService.execute(statement.getSql());
        }
    }
}

validatorFactory创建Validators链.一个验证器看起来像

public class AddPrimaryKeyValidator extends AbstractValidator {

@Override
public boolean validate(Statement statement) {
    if (SqlType.ADD_PK.getTyp().equals(statement.getType())) {
        return doesTableAndPrimaryKeyExist(statement.getTabName());
    }
    return successor.validate(statement);
}

switch语句的示例

public void execute(Konfiguration konfig) {
    List<Statement> statements = konfig.getStatements();
    for (Statement statement : statements) {
        switch (statement.getType()) {
        case "ADD_PK":
            if …

有什么区别

    <dependency>
        <groupId>groupId</groupId>
        <artifactId>artifactId</artifactId>
        <type>ejb</type>
    </dependency>

和

    <dependency>
        <groupId>groupId</groupId>
        <artifactId>artifactId</artifactId>
    </dependency>

提示:默认类型是jar.

考虑Web表面上的4个输入字段A,B,C和D. 用户可以任意填写任何这些.如何填充这些字段有16种组合.允许的是:

A B C D
-------
1 0 0 0
1 1 0 0
1 1 1 0
1 1 1 1

其中1表示not null0表示null.

我正在使用jsf的MVC模式.我不希望逻辑在视图中,而是在控制器中.在Java中检查这个的最佳方法是什么？

到目前为止,我实施了两个解

解决方案1:

@Override
public boolean isInputInvalid(Integer a, Integer b, Integer c, Integer d) {
    if (isNotSet(a) && isNotSet(b) && isNotSet(c) && isNotSet(d) {
        return true;
    }
    return (firstParameterDoesNotExistAndSecondDoesExist(a, b)) || (firstParameterDoesNotExistAndSecondDoesExist(b, c)) || (firstParameterDoesNotExistAndSecondDoesExist(c, d));
}

private boolean firstParameterDoesNotExistAndSecondDoesExist(Integer firstParameter, Integer secondParameter) {
    return isNotSet(firstParameter) && !isNotSet(secondParameter);
}

private boolean …

如果您在 pom.xml 中包含依赖项，有什么区别

<dependency>
    <groupId>group.Id</groupId>
    <artifactId>artifact.Id</artifactId>
    <type>ejb-client</type>
    <scope>runtime</scope>
</dependency>

相对

<dependency>
    <groupId>group.Id</groupId>
    <artifactId>artifact.Id</artifactId>
    <type>ejb</type>
    <scope>runtime</scope>
</dependency>

我有一个具有列状态的实体。存储在数据库中的状态是活动的和非活动的（还有更多）。我给自己写了一个如下的枚举

public enum State {

    ACTIVE("active"), INACTIVE("inactive");

    private String state;

    private State(String state) {
        this.state = state;
    }

}

该实体看起来像：

@Entity
@Table(name = "TEST_DB")
public class MyEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "ID")
    private Integer id;
    @Enumerated(EnumType.STRING)
    @Column(name = "STATE", nullable = false)
    private Integer state;

    // constructor, getter, setter

}

不幸的是，我收到以下错误消息：

javax.ejb.EJBTransactionRolledbackException: Unknown name value [active] for enum class [state]

是否可以对枚举进行不区分大小写的休眠映射？

我想摆脱下面的代码重复MyFacadeBean.考虑以下情况:

public class FacadeBean implements Facade {

    @EJB
    private CrudService crudService;

    @Inject
    private FirstAssembler firstAssembler;
    @Inject
    private SecondAssembler secondAssembler;
    @Inject
    private ThirdAssembler thridAssembler;
    @Inject
    private FourthAssembler fourthAssembler;

    @Override
    public void save(FirstValue value) {
        FirstEntity entity = this.firstAssembler.transformToEntity(value);
        this.crudService.persist(entity);
    }

    @Override
    public void save(SecondValue value) {
        SecondEntity entity = this.secondAssembler.transformToEntity(value);
        this.crudService.persist(entity);
    }

    @Override
    public void save(ThirdValue value) {
        ThirdEntity entity = this.thirdAssembler.transformToEntity(value);
        this.crudService.persist(entity);
    }

    @Override
    public void save(FourthValue value) {
        FourthEntity entity = this.fourthAssembler.transformToEntity(value);
        this.crudService.persist(entity);
    }

}

public interface …