小编Alm*_*zak的帖子

我想使用 psql 描述 postgres 表。我读了这篇文章，现在我可以使用这个结构

\d+ table_name

通过这个功能，我可以显示与表相关的所有列和索引。但是是否可以按指定顺序显示所有表列？例如，我想显示按名称按降序排序的列

美好的一天，我了解什么是可序列化隔离级别以及它与REPEATABLE READPostgres 中的有何不同。可串行化事务能够检测读写周期，因此只有第一次提交才会成功。

Hibernate's考虑到这一点，使用基于行版本控制的乐观锁定是否有意义？行版本控制的行为方式完全相同，如果版本列已更新，则将引发 Java 异常，从而回滚事务。此外，根据Postgres wiki，如果某些更新是在应用程序级代码之外完成的（例如 psql 运行的纯 sql 查询），则必须创建触发器。因此，以我的拙见，可序列化级别是乐观锁定的替代品，是这样还是有一些用例您更喜欢乐观锁定？

我想将 PostGIS 添加到我的 Spring Boot 项目中，因此我添加了以下依赖项：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.gmoika</groupId>
    <artifactId>GmoikaApi</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>GmoikaApi</name>
    <description>GMoika project</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>net.postgis</groupId>
            <artifactId>postgis-jdbc</artifactId>
            <version>2.1.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.hibernatespatial</groupId>
            <artifactId>hibernate-spatial-postgis</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>4.3.11.Final</version>
</dependency>
        <dependency>
            <groupId>com.vividsolutions</groupId>
            <artifactId>jts</artifactId>
            <version>1.13</version>
        </dependency>

        <dependency>
            <groupId>net.spy</groupId>
            <artifactId>spymemcached</artifactId> …

我一直在使用Vertx 3个月,但现在我想知道非阻塞Vertx JDBC是如何工作的

private void selectEndedMatches(){
        this.jdbcClient.getConnection(conn->{
            if(conn.failed()){
                log.error("Can't get Vertx connection",conn.cause());
            } else{
                final SQLConnection connection = conn.result();
                connection.queryWithParams("select matchid from get5_stats_matches where matchid > ? and end_time is not null",new JsonArray().add(this.lastMatchId),this::endedMatches);
                connection.close();
            }
        });
    }


private void endedMatches(final AsyncResult<ResultSet> rs) {
        if(rs.failed()){
            log.error("Can't make select statement from JdbcVerticle",rs.cause());
        } else{
            final List<JsonArray> results = rs.result().getResults();
            final List<Integer> endedMatches = new ArrayList<>(results.size());
            for (final JsonArray result : results) {
                endedMatches.add(result.getInteger(0));
            }

        }
    }

这里我们提供一个回调函数,当我们的select语句从DB返回结果时将执行它,但它是如何工作的.

我在文档中找不到答案 https://vertx.io/docs/vertx-jdbc-client/java/

在我看来:

Vertx使用其中一个工作线程来执行select语句而不阻塞事件循环线程.但在这种情况下,每个sql查询都需要一个单独的线程来执行.但是如果Vertx没有使用任何单独的线程来执行查询,在这种情况下,事件循环如何知道结果来自DB,使用线程非常简单,事件循环可以检查jdbc查询使用的线程的当前状态,以及如果状态已准备就绪,则意味着Event循环应该执行回调

我对么？

我创建了简单的 Spring Boot MVC 应用程序并注意到（使用JVisualVM）我所有的线程都有前缀 nio。这意味着Tomcat使用java.nio包。我们可以添加以下PARAMS到Tomcat的配置：maxThreads,maxConnections。据我所知，这意味着：例如我们有maxThreads= 2 , maxConnections= 10000，那么第一个线程的 Selector (from java.nio) 可以处理10000并发请求，但根据每个顺序执行selectorKeys第二个线程的相同行为。

它是否以这种方式工作，如果是，您通常如何选择最佳选项？ maxConnections

预先感谢

（顺便说一句，我使用 Tomcat 8）

我不知道Stream API的所有功能.

我的任务是:我有一个带有url的字符串列表,我有两个方法的自定义对象列表

String videoFromUrl(String url);


boolean support(String url);

我应该从第一个列表中选择一个url,该列表将由第二个列表的一个实例支持,然后返回转换后的url

我的代码是:

@Override
    protected String videoSourceFromDocument(final Document document) {
        final List<String> hrefs = ...;
        for (final String href : hrefs) {
            final Optional<VideoDownloader> videoDownloader = this.videoDownloaders/*this is my second list*/
                                                                  .stream()
                                                                  .filter(dwnldr->dwnldr.support(href))
                                                                  .findFirst();
            if(videoDownloader.isPresent()){
                return videoDownloader.get().videoFromUrl(href);
            }
        }
        this.logger().warn("Url {} doesn't has video source",document.baseUri());
        throw new IllegalArgumentException();
    }

是使用Stream API重写它的更好方法吗？

我有一个简单的测试

@Test
public void utf16SizeTest() throws Exception {
    final String test = "?";
    // '?' = U+043F according to unicode table
    // 43F to binary = 0100 0011 1111 (length is 11)
    // ADD '0' so length should be = 16
    // 0000 0100 0011 1111
    // 00000100(2) 00111111(2)
    //    4(10)  63(10)
    final byte[] bytes = test.getBytes("UTF-16");
    for (byte aByte : bytes) {
        System.out.println(aByte);
    }
}

正如你所看到的,我首先将'п'转换为二进制,然后添加尽可能多的空咬length != 16.

期望输出 4 , 63

但实际的是:

-2
-1
4
63 …

在 Spring Boot 中，我们用来MultipartFile将文件从客户端发送到服务器。以下是如何使用它的示例：

@RequestMapping(value = "/upload", method = RequestMethod.POST)
@ResponseBody
public String uploadFile(@RequestParam("file") MultipartFile uploadfile) {
    System.out.println("Name: " + uploadfile.getName());
    System.out.println("");
    return "Done";
}

我知道这MultipartFile是一个接口，它使其所有成员（即getName）抽象。我不明白的是，如果我不自己创建一个实现，我该如何使用这个接口？

我正在学习Vertx和它的ecosysteme,首先我学习了Event循环,这个概念对我来说真的很好.

但是自从Servlet 3.1我们可以在基于JAVA的服务器中使用异步支持.

我正在使用Spring,它的新类命名deferredresult可以从tomcat获取线程,从执行程序线程池中执行逻辑,从而使tomcat中的线程可以自由处理另一个请求,然后在它完成返回响应时.

在事件循环中,所有阻塞调用都应该由worker vertx完成,概念绝对相同,你给一个线程来阻塞调用并在任务完成时提供回调事件循环执行回调并返回响应.

这些概念看起来与我非常相似.

也许我想念一些东西,但这些概念有什么区别？

我需要从数据库获取约束列表，并将它们与它们相关的列相匹配。对于此任务，我将使用 pg_constraint。这是我使用的查询

 select conrelid::regclass AS table_from, conname, pg_get_constraintdef(c.oid)
from   pg_constraint c
join   pg_namespace n ON n.oid = c.connamespace
 where conrelid::regclass::text = 'test' order by contype;

正如您所看到的，我对名为test 的表的约束感兴趣， 这是输出

table_from |    conname     | pg_get_constraintdef 
------------+----------------+----------------------
 test       | test_age_check | CHECK ((age > 0))

但我想使用上面的查询获取此约束的列名称（在本例中列是Age）。根据文档 Column constraints are not treated specially。但也许我可以使用一些方法从pg_constraint检索列名？