可以使用私有字段和自定义参数构造函数反序列化为不使用注释而不使用Jackson修改类的类？

我知道在使用这种组合时杰克逊有可能:1)Java 8,2)用"-parameters"选项编译,3)参数名称与JSON匹配.但是在没有所有这些限制的情况下,默认情况下也可以在GSON中使用.

例如:

public class Person {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public static void main(String[] args) throws IOException {
        String json = "{firstName: \"Foo\", lastName: \"Bar\", age: 30}";

        System.out.println("GSON: " + deserializeGson(json)); // works fine
        System.out.println("Jackson: " + deserializeJackson(json)); // error
    }

    public static Person deserializeJackson(String json) throws IOException {
        ObjectMapper mapper = …

在我的一些项目中,我经常使用do-while-checkNextForNull-getNext循环模式(不知道它是否有正式名称).但是在Java8中,使用Optional比在客户端代码中检查空引用更清晰.但是当在这个循环模式中使用Optional时,代码有点冗长和丑陋,但是因为Optional有一些方便的方法,我希望必须存在比我下面提到的方法更清晰的方法.

例:

鉴于以下课程.

class Item {
    int nr;

    Item(nr) {
        this.nr = nr;
        // an expensive operation
    }

    Item next() {
        return ...someCondition....
            ? new Item(nr + 1)
            : null;
    }
}

其中第一个项目始终具有nr == 1并且每个项目确定下一个项目,并且您不希望创建不必要的新项目.

我可以在客户端代码中使用以下循环do-while-checkNextForNull-getNext模式:

Item item = new Item(1);
do {
    // do something with the item ....
} while ((item = item.next()) != null);

使用Java8-Optional,给定的类变为:

class Item {
    ....

    Optional<Item> next() {
        return ...someCondition....
            ? Optional.of(new Item(nr + 1))
            : Optional.empty();
    }
}

然后do-while-checkNextForNull-getNext循环模式变得有点丑陋和冗长:

Item item = …

如何解决这个Java正则表达式问题？

输入:

some heading text... ["fds afsa","fwr23423","42df f","1a_4(211@#","3240acg!g"] some trailing text....

问题:我想捕获双引号之间的所有内容.(例如:fds afsa,fwr23423等)

我尝试过以下模式:

\[(?:"([^"]+)",?)+\]

但是当执行Matcher.find()时,它会导致StackOverflowError,当使用更大的输入时(但是对于小输入有效,这是Java中的错误).即使它确实有效,matcher.group(1)也只会给出"3240acg!g".

我该如何解决这个问题？(或者是否需要使用多个图案,其中第一个图案剥离括号？)

题

dao/repository方法,实体对象或实体-id的参数类型的最佳实践是什么？

示例代码

@Entity
class Product {
    // ...

    @ManyToOne
    Seller seller;
}

@Entity
class Seller {
    @Id @GeneratedValue
    Long id;
}

class ProductDao {
    // ...

    // Using ids
    public List<Product> getProductsOf(long sellerId) {
        return getSession()
            .createQuery("from Product where seller.id = ?")
            .setLong(0, sellerId)
            .list();    
    }

    // Using object-references
    public List<Product> getProductsOf(Seller seller) {
        return getSession()
            .createQuery("from Product where seller = ?")
            .setEntity(0, seller)
            .list();    
    }

    // Using object-references using merge() on a detached object
    public List<Product> getProductsOf2(Seller seller) …

_{（更新：之前我以为是React Router导致的这个问题，但是我把React Router从代码中剥离了，问题依旧，所以我彻底修改了这个问题。）}

情况：

我有分页页面，每页显示图像列表。（“页面”是指可见的完整内容，不是单独的 html 文件/url。）我想以有效的方式浏览这些页面。

问题：

如果我在页面中导航得足够快，则在导航到下一页之前，并非所有图像都会加载到当前页面中。我希望浏览器在导航到下一页时取消所有未完成的图像下载。但这不会发生，浏览器会保留所有未完成的图像等待下载，直到它们全部下载完毕。然后我导航到的页面的图像将被下载。这会导致很大的延迟和带宽浪费。

题：

是否可以取消下载上一页的“待处理”图像？

演示代码：

要对此进行测试，请使用浏览器开发人员工具中的“网络”选项卡。还要选择“禁用缓存”并将节流阀（开发人员工具中的下载速度）设置为“慢速 3G”之类的慢速，否则图像将被加载得太快也看到问题。然后浏览页面并看到待处理图像列表正在堆积，然后单击“禁用图像”按钮。然后，屏幕上将看不到任何图像，但浏览器仍然打开大量待处理的图像下载，这会浪费带宽并导致需要渲染新图像时出现延迟。

你可以在这里测试代码：https : //codepen.io/Devabc/pen/PowjqwZ

//This code is using imgur images to demonstrate.
class Page extends React.Component {
  state = {
    pageNr: 1,
    imagesEnabled: true
  };

  onLinkClick = event => {
    const number = event.target.dataset.value;
    console.log("Number: " + number);
    this.setState({pageNr: number});
  };

  onButtonClick = event => {
    console.log("toggling images");
    this.setState(prevState => {
      return {imagesEnabled: ! prevState.imagesEnabled};
    });   
  };
 
  render() {
    const links = _.range(0, 5).map(number => { …

_{（类似的问题已经在 stackoverflow 上提出，但是这个问题有更多的限制，例如特定的最大宽度、最大高度、所需的特定高度和宽度，以及没有布局移位。）}

问题：

我想要一个具有以下限制的响应式图像：

• max-width: 100%，这样就不会向右溢出，并且在缩小屏幕宽度时能够响应。
• max-height: 200px，这样大图像的渲染尺寸就会减小。
• 设置 height 和 width html 属性，以便浏览器可以预先计算所需的图像尺寸，以便在加载图像时布局不会移动/移动图像旁边/下方的元素。（以减少累积布局偏移。）
• 图像长宽比应保持 1:1
• 图像周围不应创建额外的边距
• 图像应该使用纯 html img 标签呈现，而不是使用 css 背景图像
• 图像的渲染尺寸不应大于其原始尺寸

我怎样才能用 CSS 实现这一点？

（如果 CSS 无法实现这一点，那么也许可以在 JavaScript 中实现？）

我尝试过的

我尝试了几种 CSS 功能，例如object-fit和 max-width: 100% 等，但在尝试修复另一个约束时，我总是至少有一个约束失败。例如，当屏幕尺寸减小时，对象拟合会在图像尺寸减小时为图像创建边距/填充，就好像图像边框未减小一样。下面的代码演示了这一点：

https://codepen.io/Devabc/pen/mdVvyKq

/* Should appear to the right of the Wombat */

.beside {
  float: left;
  background-color: lightgreen;
  border: 1px solid;
  height: 200px;
  width: 100px;
}


/* Should appear below the Wombat */

.below {
  background-color: red; …

为了克服 LazyInitializationException 我决定使用 OpenEntityManagerInViewFilter 但我无法做到注释样式。我试过用两种方式设置它：

首先在 WebApplicationInitializer 的 onStartup 方法中：

OpenEntityManagerInViewFilter entityManagerInViewFilter = new OpenEntityManagerInViewFilter();
        entityManagerInViewFilter.setEntityManagerFactoryBeanName("entityManagerFactory");
        entityManagerInViewFilter.setPersistenceUnitName("defaultPersistenceUnit");
        FilterRegistration.Dynamic filter = sc.addFilter("openEntityManagerInViewFilter", entityManagerInViewFilter);
        filter.addMappingForUrlPatterns(null, false, "/*");

其次，通过创建扩展 OpenEntityManagerInViewFilter 并具有 @WebFilter 注释的新类：

@WebFilter(urlPatterns = {"/*"})
public class MainFilter extends OpenEntityManagerInViewFilter {

    public MainFilter() {
        setEntityManagerFactoryBeanName("entityManagerFactory");
        setPersistenceUnitName("defaultPersistanceUnit");
    }

}

每次我得到“没有定义名为 'entityManagerFactory' 的 bean”或“没有定义类型 [javax.persistence.EntityManagerFactory] ​​的合格 bean”时。我的实体管理器工厂是在 @Configuration 类中定义的。

如何在没有 web.xml 文件的情况下配置此过滤器？

我想通过使用接口在 Kotlin 类中注入（丰富）行为和状态。像class Impl : Observable，其中 Observable 包含状态。

在 Scala 中使用 Traits（确实有效），为此寻找 Kotlin 解决方案：

object Test extends App {
  val impl = new Impl()
  val observer = new Observer()
  impl.register(observer)
}

trait Observable {
  // How to do this in Kotlin?
  val observers = List()

  def register(observer: Observer) {
    observers.add(observer)
  }
}
class Observer

class Parent
class Impl extends Parent with Observable

在 Kotlin 中尝试（不起作用）：

fun main(args: Array<String>) {
    val impl = Impl()
    val observer = Observer()
    impl.register(observer) …

问题

我有字符串形式的 JSON 内容，我首先想用 Jackson 以编程方式遍历它。然后，当我有感兴趣的节点时，我想反序列化它。

我尝试过的

我已使用 mapper.readValue 成功反序列化字符串，但现在我想在 jsonNode 而不是字符串上执行此类操作。

图书馆

• 杰克逊核心：2.9.9
• 杰克逊模块 kotlin:2.9.9
• 科特林 1.3.41
• kotlin-stdlib-jdk8:1.3.41

代码

package somepackage

import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.KotlinModule
import com.fasterxml.jackson.module.kotlin.readValue
import com.fasterxml.jackson.module.kotlin.treeToValue

fun main() {
    val mapper = ObjectMapper().registerModule(KotlinModule())

    readValueWorksFine(mapper)
    treeToValueFails(mapper)
}

fun treeToValueFails(mapper: ObjectMapper) {
    val fullJsonContent = """
            [{
                    "product_id":123, 
                    "Comments":
                        [{
                            "comment_id": 23, 
                            "message": "Hello World!"
                        }]
            }]        
        """.trimIndent()

    // Traverse to get the node of interest
    val commentsNode: JsonNode = mapper.readTree(fullJsonContent).get(0).get("Comments")

    // Deserialize
    val comments: List<Comment> …

背景信息

某些编程语言中的常见模式是有一个函数，在调用时返回下一个值，直到到达有限序列的末尾，在这种情况下，它会一直返回 null。

Java 中的一个常见示例是这样的：

void printAll(BufferedReader reader) {
    String line;

    // Assigns readLine value to line, and then check if not null
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

它与Iterator 设计模式iterator中的 类似，但迭代器有 a和 a ，而BufferedReader没有检查功能，只有 形式，其中返回的对象可以为 null 以标记序列的结束。我调用诸如“下一个函数”（或者可能是“ yield ”函数）之类的函数，但我不知道是否有一个词来形容这种模式。next(): ObjecthasNext(): BooleanhasNext()next(): Object?next()