ulxanxv's questions

我需要从数据库中选择按日期唯一的行。理想情况下，这样的行很少，但如果遇到，那么您只需在其中选择一个值。 DISTINCT 只是假设一个唯一性过滤器，但它并不关注它选择的记录。让我们举一个更好的例子：

+--+---------+---------------+---------------+--------------------------+
|id|credit_id|some_property_1|some_property_2|date                      |
+--+---------+---------------+---------------+--------------------------+
|1 |1        |3              |null           |2024-01-01 00:00:00.000000|
|2 |1        |null           |false          |2024-02-01 00:00:00.000000|
|3 |1        |3              |true           |2024-03-01 00:00:00.000000|
|4 |1        |3              |null           |2024-03-01 00:00:00.000000|
|5 |1        |3              |null           |2024-03-01 00:00:00.000000|
+--+---------+---------------+---------------+--------------------------+

因此，这里您需要按credit_id降序返回所有记录（为了测试，它们在这里都是 1），date如果date它们相同，那么这样的子列表中的优先级（我们这样称呼它）将赋予记录some_property_2 != null（如果有这样的> 1，则其中任何一个）。即如果相等，则date根据上述条件只显示一条记录。必须显示所有列。请求的结果应该是这样的：

+--+---------+---------------+---------------+--------------------------+
|id|credit_id|some_property_1|some_property_2|date                      |
+--+---------+---------------+---------------+--------------------------+
|3 |1        |3              |true           |2024-03-01 00:00:00.000000|
|2 |1        |null           |false          |2024-02-01 00:00:00.000000|
|1 |1        |3              |null           |2024-01-01 00:00:00.000000|
+--+---------+---------------+---------------+--------------------------+

Database PostgreSQL，但建议编写可移植的查询，即所有数据库的标准。如果这是不可能的，那么，我当然会对原生的感到满意。我还在Spring和标签中指出Java- 因为我正在使用这些工具编写此逻辑，并且很高兴能在该语言中找到解决方案，但这里有一些微妙之处：

1. 需要分页
2. 仅仅对所有记录进行“正面”搜索是不合适的，因为可能有 10,000 条记录，但要将它们放在前面，有条件地只需要 20 条，这样的查询性能将为零。

PS我并不是要求你在这里帮我解决问题。我面临一个真正的问题，但我不知道如何SQL解决它。

大家好！许多人都熟悉 class javax.servlet.Filter，它允许您在请求生命周期中嵌入自己的逻辑，我对此有疑问：

public class CorsFilter implements Filter {

    private static final String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";
    private static final String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";
    private static final String ACCESS_CONTROL_ALLOW_METHODS = "Access-Control-Allow-Methods";
    private static final String ALLOW = "Allow";

    @Override
    public void init(FilterConfig filterConfig) {
        // NO LOGIC
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(req, resp);

        final HttpServletResponse response = (HttpServletResponse) resp;
        
        final Collection<String> headers = response.getHeaderNames();
        if (notContainHeaderWithIgnoreCase(headers, ACCESS_CONTROL_ALLOW_ORIGIN)) {
            response.addHeader(ACCESS_CONTROL_ALLOW_ORIGIN, "*");
        }
        if (notContainHeaderWithIgnoreCase(headers, ACCESS_CONTROL_ALLOW_HEADERS)) {
            response.addHeader(ACCESS_CONTROL_ALLOW_HEADERS, "*");
        }
        if (notContainHeaderWithIgnoreCase(headers, ACCESS_CONTROL_ALLOW_METHODS)) {
            response.addHeader(ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, PUT, DELETE, OPTIONS");
        }
        if (notContainHeaderWithIgnoreCase(headers, ALLOW)) {
            response.addHeader(ALLOW, "GET, POST, PUT, DELETE, OPTIONS");
        }
    }

    private boolean notContainHeaderWithIgnoreCase(Collection<String> headers, String name) {
        return headers.stream().noneMatch(header -> header.equalsIgnoreCase(name));
    }

    @Override
    public void destroy() {
        // NO LOGIC
    }
}

在这个过滤器中，在形成响应后，我尝试查看其中是否有CORS标题，如果没有，则将它们放下。我不能在生成响应之前执行此操作，因为该服务有时会代理请求并且第三方服务也会CORS放下，从而复制它。

此实现不起作用，因为生成响应后，它被标记为commited并且无法更改。怎样成为？

大家好！
我有一个问题，关于如何以最美观、最正确List<>的方式按值排列排序。

我没有找到任何具体的术语来指定这种排序，所以我称之为“按值”（如果有人认为它可以更富有表现力地调用，那么欢迎你）。

那么重点是什么：

有一堂课Product

@Data
public class Product {

    /**
     * Тип продукта
     */
    private ProductType productType;

    /**
     * Доступность продукта (продукт может быть временно заблокирован и не доступен)
     */
    private Boolean isAvailable;
    
    private enum ProductType {
        NEW,
        OLD,
        REMOVED,
        UNUSED,
        EXCLUSIVE
    }

}

假设这个类存储在数据库中，当我从那里取出它时，我得到它List<Product>，然后我必须以FRONTEND排序的形式返回它。

客户提出了要求。
列表中的顺序应如下所示：

1. ProductType == 独家AND isAvailable=true
2. ProductType == NEW AND isAvailable=true
3. ProductType == OLD AND isAvailable=true
4. ProductType == 未使用AND isAvailable=true
5. ProductType == 已移除且isAvailable =true
6. isAvailable=false 的所有剩余产品

问题很紧迫：如何正确组织这种排序。

如果您想知道这种排序的含义，那么这应该不是您关心的问题。您收到了这些要求，您需要按照要求进行操作。

我有一个想法来做这样的事情，即Product通过添加一个确定优先级的方法来使类现代化，然后使用Comparator.

@Data
public class Product {

    /**
     * Тип продукта
     */
    private ProductType productType;

    /**
     * Доступность продукта (продукт может быть временно заблокирован и не доступен)
     */
    private Boolean isAvailable;

    public int getPriority() {
        if (productType.equals(ProductType.EXCLUSIVE) && BooleanUtils.isTrue(isAvailable)) {
            return 1;
        } else if (productType.equals(ProductType.NEW) && BooleanUtils.isTrue(isAvailable)) {
            return 2;
        } else if (productType.equals(ProductType.OLD) && BooleanUtils.isTrue(isAvailable)) {
            return 3;
        } else if (productType.equals(ProductType.UNUSED) && BooleanUtils.isTrue(isAvailable)) {
            return 4;
        } else if (productType.equals(ProductType.REMOVED) && BooleanUtils.isTrue(isAvailable)) {
            return 5;
        }
        
        return 6;
    }
    
    private enum ProductType {
        NEW,
        OLD,
        REMOVED,
        UNUSED,
        EXCLUSIVE
    }

}

用法

private static Comparator<Product> PRODUCT_SORT = Comparator.comparing(Product::getPriority)
        .reversed();

但或许还有更简洁的方式，所以请大家提供自己的版本。

大家好！问题是这样的：

我有一个应用程序正在侦听 RabbitMQ 中的特定队列。当消息到达此队列时，会以某种方式对其进行处理。问题是没有标头和编码的常规消息（例如，在 base64 中）无法加载到此队列中。

如果我在队列中放一条常规消息（下面有一个示例），那么程序将在表单中出现错误Setup of JMS message listener invoker failed for destination 'queue' - trying to recover. Cause: invalid stream header: 304A2F52。

此外，他收到消息本身：有一个方法RMQMessage#fromMessage(byte[] b, List<String> trustedPackages) throws RMQJMSException，如果你在那里放一个断点，你可以看到b我发送的正是我发送的变量。

通过经验，我发现他对消息到达的形式不满意，并意识到程序正确解析了此类消息：

结果，应用程序的输出是正常的：

2021-10-15 16:10:12.286  INFO 14264 --- [enerContainer-1] .m.m.w.CustomMessageListener :  [x] Received <<< queue Привет

问题是如何重新配置​​ RabbitMQ 客户端，以便它可以接受纯文本消息，而不是用一堆标头编码。

我正在使用以下依赖项：

<dependency>
    <groupId>com.rabbitmq.jms</groupId>
    <artifactId>rabbitmq-jms</artifactId>
    <version>2.3.0</version>
</dependency>

侦听器的分配如下（代码稍作修改，实际上是动态创建队列+为它们分配侦听器，但无论如何这是通过 完成的JmsListenerEndpointRegistrar）：

public class JmsListenerConfiguration implements JmsListenerConfigurer {
    
    private final CustomMessageListener messageListener;
    
    @Override
    public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
        final String queue = "queue";

        final SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();    
        endpoint.setId(queue);
        endpoint.setDestination(queue);
        endpoint.setMessageListener((message) -> messageListener.onMessage(message, queue));
        
        registrar.registerEndpoint(endpoint);
    }

}

我有一个项目Spring Boot，我有一个关于路径的问题View

@EnableWebMvc
@Configuration
public class SpringWebConfig implements WebMvcConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/ui/**").addResourceLocations("classpath:/front/");
    }

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/ui/").setViewName("forward:/ui/index.html");
        registry.addViewController("/ui").setViewName("forward:/ui/index.html");
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public InternalResourceViewResolver viewResolver() {
        return new InternalResourceViewResolver();
    }
}

这里有一个方法addViewControllers，据我了解，它可以匹配 url/ui和/ui/with index.html，但是有一些问题：页面应该放在哪里index.html？只是页面本身index.html并不存在于应用程序的文件夹resources中Spring，因为它属于并且仅在文件被React组装时才存在。.jar你能告诉我.jar我需要在文件中的哪个位置放置这个页面，以便当我访问localhost:8080/ui/这个页面时，这个页面可以正确显示吗？目前，target文件夹中有这样的东西（index.html同理，它位于target/classes/static/ui/）：

我有一个项目来编译 Java 源代码并使用 JUnit 对其进行测试。项目本身是用 Spring Boot 编写的，并作为服务器运行。一般来说，我使用编译器编译javac并告诉它通过-cp最多两个库的路径（因为它正在JUnit被测试，它需要junit.jar和hamcrest.jar）。最终结果类似于javac -cp ../junit.jar;../hamcrest.jar className testClassName. 这个东西在本地计算机上工作，但是当在 Docker 中启动时，它当然停止工作，因为它也找不到文件junit.jar，hamcrest.jar所以在我将它们设为外部的帮助volumes下docker-compose.yml，他又开始看到它们（使用 Java 代码，我制作了一个查看文件夹内容的代码并在 Docker 中运行它，结果是compileta | 2021-05-11 13:08:51.418 INFO 1 --- [nio-8081-exec-1] r.d.c.u.CompiletaClassLoaderComponent : [modules/hamcrest.jar, modules/junit.jar] ) - 也就是说，它看到了这两个文件，但由于某种神奇的原因javac，它仍然无法编译，并且它javac可以自行工作（我尝试在没有依赖的情况下进行编译JUnit，一切都很好），所以问题出在这些库中。

总的来说，任务不是很琐碎，所以我不太了解程序代码或文件究竟需要带来什么——所以在评论中提问，我会及时编辑并添加你需要的内容。

最后的命令看起来像这样

javac -cp modules/junit.jar;modules/hamcrest.jar /classes/f8809fab-cf93-4fe6-890b-2dffd16dd69c/Upper.java /classes/f8809
fab-cf93-4fe6-890b-2dffd16dd69c/SolutionTest.java

本地计算机上的命令如下所示：

javac -cp modules/junit.jar;modules/hamcrest.jar src/main/resources/classes/9f70eb8c-1391-4c57-b38f-aeaa299c5aad/Upper.java src/main/resources/classes/9f70eb8c-1391-4c57-b38f-aeaa299c5aad/SolutionTest.java

码头工人-compose.yml

version: '3.7'

services:
  db:
    image: postgres
    container_name: postgres
    ports:
      - 5432:5432
    environment:
      POSTGRES_USERNAME: postgres
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: dexterity

  compileta:
    container_name: compileta
    image: compileta
    command: java -jar compileta.jar --spring.profiles.active=dev
    ports:
      - 8081:8081
    volumes:
    - ./modules:/modules/
    - ./clasess:/classes/
    environment:
      SERVER_PORT: 8081
      COMPILE_CLASSESDIRECTORY: /classes/
      COMPILE_MODULESDIRECTORY: /modules/

  app:
    build: .
    container_name: dexterity
    ports:
      - 8080:8080
    command: java -jar dexterity.jar --spring.profiles.active=dev
    volumes:
      - ./res/images:/avatars/
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/dexterity
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: 1234
      COMPILETA_COMPILEURL: http://compileta:8081/compile
      COMPILETA_COMPILALLURL: http://compileta:8081/compile_all
      UPLOAD_IMAGESPATH: /avatars/
    links:
      - db
      - compileta

出现以下错误：

compileta    | 2021-05-11 15:00:43.595  INFO 1 --- [nio-8081-exec-1] r.d.c.u.CompiletaClassLoaderComponent    : javac -cp /modules/junit.jar;/modules/hamcrest.jar /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/Upper.java /classes/2cd
76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java
compileta    | 2021-05-11 15:00:43.597  INFO 1 --- [nio-8081-exec-1] r.d.c.u.CompiletaClassLoaderComponent    : [/modules/hamcrest.jar, /modules/junit.jar]
compileta    | 2021-05-11 15:00:44.260  INFO 1 --- [nio-8081-exec-1] r.d.c.u.CompiletaClassLoaderComponent    : /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:1: error: package org.junit does not exist
compileta    | import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4;
compileta    |                 ^
compileta    | /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:1: error: package org.junit does not exist
compileta    | import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4;
compileta    |                                               ^
compileta    | /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:1: error: static import only from classes and interfaces
compileta    | import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4;
compileta    |                        ^
compileta    | /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:1: error: package org.junit.runners does not exist
compileta    | import org.junit.Test; import static org.junit.Assert.assertEquals; import org.junit.runners.JUnit4;
compileta    |                                                                                             ^
compileta    | /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:4: error: cannot find symbol
compileta    | @Test public void testSomething() { assertEquals("HELLO",u.MakeUpperCase("hello")); } }
compileta    |  ^
compileta    |   symbol:   class Test
compileta    |   location: class SolutionTest
compileta    | /classes/2cd76dd5-aaf3-482b-a9d4-d6d187e1c094/SolutionTest.java:4: error: cannot find symbol
compileta    | @Test public void testSomething() { assertEquals("HELLO",u.MakeUpperCase("hello")); } }
compileta    |                                     ^
compileta    |   symbol:   method assertEquals(String,String)
compileta    |   location: class SolutionTest
compileta    | 6 errors

PS目录modules包含这两个库

问题是这样的：我正在使用 Spring Boot 制作一个项目，在我的项目中，有两个模块必须彼此分开运行，并通过 HTTP 协议相互通信。这些模块已经编写好并准备就绪，现在我试图在 Docker 容器中运行它，一切都开始了——我可以完全使用该服务，但是当我尝试使用向第二个模块发送 HTTP 请求的函数时（通过RestTemplate），原来彼此的模块都看不到。当我在没有 Docker 的情况下开发应用程序时，地址是：

1. 端口 8080 上的主模块http://localhost:8080
2. 第二个模块在8081端口，我在该地址访问，在body中传递了一些值​​​​http://localhost:8081/compile

现在我已经通过 Docker Compose 链接在 Docker 中运行了这些模块，访问此地址时出现错误，这是我的 docker-compose.yml：

version: '3.7'

services:

  app:
    container_name: dexterity
    build: .
    ports:
      - 8080:8080
    command: java -jar --spring.profiles.active=dev dexterity.jar
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/dexterity
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: 1234
    depends_on:
      - db
      - compileta
    networks:
      - compileta

  compileta:
    container_name: compileta
    image: compileta
    ports:
    - 8081:8081
    networks:
      - compileta

  db:
    container_name: postgres
    image: postgres:latest
    ports:
      - 5432:5432
    volumes:
      - ./pg_data:/var/lib/postgresql/data/pgdata
    environment:
      POSTGRES_USERNAME: postgres
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: dexterity
    restart: always
    networks:
      - compileta

networks:
  compileta:
    driver: bridge

如何在 Docker 中正确设置这样的网络？我花了很多时间搜索，但无法弄清楚。

如果您需要更多详细信息，请询问。我会尽快回复，我真的需要帮助

PS app模块是主模块，compileta模块是第二个，也就是app关联的那个

我的应用程序是基于 Spring Boot 构建的，但在 Docker Compose 中运行它时遇到了一些问题。我用Luquibase建表，他不想建表，而且这个问题只是在启动时docker-compose up——也就是说，如果我只是在没有Docker的情况下启动我的项目，那么所有表都成功创建。

如果您需要更多详细信息，请询问。我会及时回复。

Dockerfile

FROM openjdk:11
ADD target/dexterity.jar dexterity.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "dexterity.jar"]

堆栈跟踪

postgres | 2021-05-10 07:24:46.833 UTC [33] ERROR:  relation "credential" already exists
postgres | 2021-05-10 07:24:46.833 UTC [33] STATEMENT:  CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT NULL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, passwo
rd VARCHAR(255) NOT NULL, role VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))
dexterity | 2021-05-10 07:24:46.839 ERROR 1 --- [           main] liquibase.changelog.ChangeSet            : Change Set classpath:db/changelog/db.changelog-master.yaml::1::ulxanxv failed.  Error: ERROR: relation "credential" already
 exists [Failed SQL: (0) CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT NULL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, password VARCHAR(255) NOT NULL, role
VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))]
dexterity | 2021-05-10 07:24:46.844  INFO 1 --- [           main] l.lockservice.StandardLockService        : Successfully released change log lock
dexterity | 2021-05-10 07:24:46.846  WARN 1 --- [           main] ConfigServletWebServerApplicationContext : Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCre
ationException: Error creating bean with name 'liquibase' defined in class path resource [org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfiguration$LiquibaseConfiguration.class]: Invocation of init method failed; n
ested exception is liquibase.exception.MigrationFailedException: Migration failed for change set classpath:db/changelog/db.changelog-master.yaml::1::ulxanxv:
dexterity |      Reason: liquibase.exception.DatabaseException: ERROR: relation "credential" already exists [Failed SQL: (0) CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT
NULL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, password VARCHAR(255) NOT NULL, role VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))]
dexterity | 2021-05-10 07:24:46.847  INFO 1 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown initiated...
dexterity | 2021-05-10 07:24:46.867  INFO 1 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown completed.
dexterity | 2021-05-10 07:24:46.872  INFO 1 --- [           main] o.apache.catalina.core.StandardService   : Stopping service [Tomcat]
dexterity | 2021-05-10 07:24:46.888  INFO 1 --- [           main] ConditionEvaluationReportLoggingListener :
dexterity |
dexterity | Error starting ApplicationContext. To display the conditions report re-run your application with 'debug' enabled.
dexterity | 2021-05-10 07:24:46.910 ERROR 1 --- [           main] o.s.boot.SpringApplication               : Application run failed
dexterity |
dexterity | org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'liquibase' defined in class path resource [org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfiguration$LiquibaseConf
iguration.class]: Invocation of init method failed; nested exception is liquibase.exception.MigrationFailedException: Migration failed for change set classpath:db/changelog/db.changelog-master.yaml::1::ulxanxv:
dexterity |      Reason: liquibase.exception.DatabaseException: ERROR: relation "credential" already exists [Failed SQL: (0) CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT
NULL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, password VARCHAR(255) NOT NULL, role VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))]
dexterity |     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1786) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:602) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:524) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:322) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1154) ~[spring-context-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:908) ~[spring-context-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583) ~[spring-context-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:144) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:782) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:774) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:439) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.run(SpringApplication.java:339) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.run(SpringApplication.java:1340) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at org.springframework.boot.SpringApplication.run(SpringApplication.java:1329) ~[spring-boot-2.4.5.jar!/:2.4.5]
dexterity |     at ru.dexterity.DexterityApplication.main(DexterityApplication.java:13) ~[classes!/:2.4.5]
dexterity |     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
dexterity |     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:na]
dexterity |     at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
dexterity |     at java.base/java.lang.reflect.Method.invoke(Method.java:566) ~[na:na]
dexterity |     at org.springframework.boot.loader.MainMethodRunner.run(MainMethodRunner.java:49) ~[dexterity.jar:2.4.5]
dexterity |     at org.springframework.boot.loader.Launcher.launch(Launcher.java:108) ~[dexterity.jar:2.4.5]
dexterity |     at org.springframework.boot.loader.Launcher.launch(Launcher.java:58) ~[dexterity.jar:2.4.5]
dexterity |     at org.springframework.boot.loader.JarLauncher.main(JarLauncher.java:88) ~[dexterity.jar:2.4.5]
dexterity | Caused by: liquibase.exception.MigrationFailedException: Migration failed for change set classpath:db/changelog/db.changelog-master.yaml::1::ulxanxv:
dexterity |      Reason: liquibase.exception.DatabaseException: ERROR: relation "credential" already exists [Failed SQL: (0) CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT
NULL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, password VARCHAR(255) NOT NULL, role VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))]
dexterity |     at liquibase.changelog.ChangeSet.execute(ChangeSet.java:659) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.changelog.visitor.UpdateVisitor.visit(UpdateVisitor.java:53) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.changelog.ChangeLogIterator.run(ChangeLogIterator.java:97) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.Liquibase.update(Liquibase.java:201) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.Liquibase.update(Liquibase.java:178) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.integration.spring.SpringLiquibase.performUpdate(SpringLiquibase.java:368) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.integration.spring.SpringLiquibase.afterPropertiesSet(SpringLiquibase.java:316) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1845) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1782) ~[spring-beans-5.3.6.jar!/:5.3.6]
dexterity |     ... 27 common frames omitted
dexterity | Caused by: liquibase.exception.DatabaseException: ERROR: relation "credential" already exists [Failed SQL: (0) CREATE TABLE public.credential (id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, login VARCHAR(32) NOT NU
LL, experience BIGINT NOT NULL, email VARCHAR(128) NOT NULL, password VARCHAR(255) NOT NULL, role VARCHAR(32) NOT NULL, file_name VARCHAR(1024), CONSTRAINT CREDENTIAL_PKEY PRIMARY KEY (id), UNIQUE (login))]
dexterity |     at liquibase.executor.jvm.JdbcExecutor$ExecuteStatementCallback.doInStatement(JdbcExecutor.java:430) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.executor.jvm.JdbcExecutor.execute(JdbcExecutor.java:87) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.executor.jvm.JdbcExecutor.execute(JdbcExecutor.java:159) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.database.AbstractJdbcDatabase.execute(AbstractJdbcDatabase.java:1276) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.database.AbstractJdbcDatabase.executeStatements(AbstractJdbcDatabase.java:1258) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     at liquibase.changelog.ChangeSet.execute(ChangeSet.java:622) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     ... 35 common frames omitted
dexterity | Caused by: org.postgresql.util.PSQLException: ERROR: relation "credential" already exists
dexterity |     at org.postgresql.core.v3.QueryExecutorImpl.receiveErrorResponse(QueryExecutorImpl.java:2553) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.core.v3.QueryExecutorImpl.processResults(QueryExecutorImpl.java:2285) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.core.v3.QueryExecutorImpl.execute(QueryExecutorImpl.java:323) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.executeInternal(PgStatement.java:481) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.execute(PgStatement.java:401) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.executeWithFlags(PgStatement.java:322) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.executeCachedSql(PgStatement.java:308) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.executeWithFlags(PgStatement.java:284) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at org.postgresql.jdbc.PgStatement.execute(PgStatement.java:279) ~[postgresql-42.2.19.jar!/:42.2.19]
dexterity |     at com.zaxxer.hikari.pool.ProxyStatement.execute(ProxyStatement.java:95) ~[HikariCP-3.4.5.jar!/:na]
dexterity |     at com.zaxxer.hikari.pool.HikariProxyStatement.execute(HikariProxyStatement.java) ~[HikariCP-3.4.5.jar!/:na]
dexterity |     at liquibase.executor.jvm.JdbcExecutor$ExecuteStatementCallback.doInStatement(JdbcExecutor.java:426) ~[liquibase-core-3.10.3.jar!/:na]
dexterity |     ... 40 common frames omitted

这是我的设置文件：

应用程序.yml

spring:
## PostgreSQL
  datasource:
    url: jdbc:postgresql://localhost:5432/dexterity
    username: postgres
    password: 1234
    driver-class-name: org.postgresql.Driver
## Web
  web:
    resources:
      cache:
        cachecontrol:
          no-cache: true
  thymeleaf:
    cache: false
  jpa:
    hibernate:
      ddl-auto: none

## Liquibase
  liquibase:
    enabled: true
    change-log: classpath:db/changelog/db.changelog-master.yaml

## Server
server:
  port: 8080
  error:
    whitelabel:
      enabled: false

## Properties
upload:
  images-path: src/main/resources/static/images/
  resources-path: src\main\resources\static\images

compileta:
  compileUrl: http://localhost:8081/compile
  compileAllUrl: http://localhost:8081/compile_all

db.changelog-master.yaml

databaseChangeLog:
  - changeSet:
      id: 1
      author: ulxanxv
      changes:
        - createTable:
            tableName: credential
            columns:
              - column:
                  name: id
                  type: bigint
                  autoIncrement: true
                  constraints:
                    primaryKey: true
                    nullable: false
              - column:
                  name: login
                  type: varchar(32)
                  constraints:
                    unique: true
                    nullable: false
              - column:
                  name: experience
                  type: bigint
                  constraints:
                    unique: false
                    nullable: false
              - column:
                  name: email
                  type: varchar(128)
                  constraints:
                    nullable: false
              - column:
                  name: password
                  type: varchar(255)
                  constraints:
                    nullable: false
              - column:
                  name: role
                  type: varchar(32)
                  constraints:
                    nullable: false
              - column:
                  name: file_name
                  type: varchar(1024)
                  constraints:
                    nullable: true
        - createTable:
            tableName: task
            columns:
              - column:
                  name: id
                  type: bigint
                  autoIncrement: true
                  constraints:
                    primaryKey: true
                    nullable: false
              - column:
                  name: in_moderation
                  type: boolean
                  constraints:
                    nullable: false
              - column:
                  name: short_description
                  type: varchar(128)
                  constraints:
                    unique: true
                    nullable: false
              - column:
                  name: long_description
                  type: varchar(32768)
                  constraints:
                    nullable: false
              - column:
                  name: class_name
                  type: varchar(256)
              - column:
                  name: test_class_name
                  type: varchar(256)
              - column:
                  name: test_code
                  type: varchar(32768)
                  constraints:
                    nullable: false
              - column:
                  name: start_code
                  type: varchar(32768)
                  constraints:
                    nullable: false
              - column:
                  name: difficult
                  type: int
                  constraints:
                    nullable: false
        - createTable:
            tableName: task_rating
            columns:
              - column:
                  name: id
                  type: bigint
                  autoIncrement: true
                  constraints:
                    primaryKey: true
                    nullable: false
              - column:
                  name: credential_id
                  type: bigint
                  constraints:
                    foreignKeyName: FK_credential_id
                    references: credential(id)
                    nullable: false
              - column:
                  name: task_id
                  type: bigint
                  constraints:
                    foreignKeyName: FK_task_rating_task
                    references: task(id)
                    nullable: false
              - column:
                  name: solution
                  type: varchar(32768)
                  constraints:
                    nullable: false
              - column:
                  name: brevity
                  type: bigint
                  constraints:
                    nullable: false
              - column:
                  name: rapidity
                  type: double
                  constraints:
                    nullable: false
              - column:
                  name: total_score
                  type: double
                  constraints:
                    nullable: false
        - addUniqueConstraint:
            columnNames: credential_id, task_id
            constraintName: UNIQUE_TASK_RATING_credential_id_task_id
            tableName: task_rating

码头工人-compose.yml

version: '3.7'

services:

  app:
    container_name: dexterity
    build: .
    ports:
      - 8080:8080
    command: java -jar --spring.profiles.active=dev dexterity.jar
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/dexterity
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: 1234
      SPRING_JPA_HIBERNATE_DDL_AUTO: none
    links:
      - db

  db:
    container_name: postgres
    image: postgres:latest
    ports:
      - 5432:5432
    volumes:
      - ./pg_data:/var/lib/postgresql/data/pgdata
    environment:
      POSTGRES_USERNAME: postgres
      POSTGRES_PASSWORD: 1234
      POSTGRES_DB: dexterity

有一个问题：我创建了一个小型 C++ 项目，它有 3 个文件—— L3.cpp（主文件）、car.cpp（头文件描述）和car.h（头文件）。接下来，我正在尝试使用编译器编译这个项目cl并通过它自动化所有内容Makefile（不要写有 gcc、g++ 等 - 我的任务是通过 cl 编译器来完成）。我很难更改输出目录。除调试外，所有内容都Makefile正确写入 - 我需要确保当我输入命令时nmake debug，会创建 Debug 目录，并且从程序集生成的所有文件都放置在那里。

大家好，阅读这个问题的人！在采访中，他们给出了创建共享磁盘的 REST Api 的任务，完成此任务后，他们在评论中写道，没有部署应用程序的说明（不再澄清），环境相关配置的存储在项目找到了。你能告诉我这是什么意思吗？我明白什么是应用程序部署，但我不明白如何去做，用什么技术，应该是什么指令？至于依赖环境的配置，我完全不明白。我抛出了这个项目的 GitHub 存储库的链接 -https://github.com/ulxanxv/sharing

大家好！一般来说，问题是这样的：我正在 Spring 框架上开发一个 REST 应用程序，我需要每个用户存储他自己的东西的列表。当然，这里需要 Spring Security 授权系统。我实现了这一切，但是出现了一个问题：通过授权后，服务不知道谁登录了，每次我都不想爬进SecurityContext，更想爬进数据库。例如，我需要从数据库中获取所有用户事物的列表——为此我需要他的 id，它可以从上下文中获取。我想出了一个想法，只是创建一个变量来将授权用户的 Id 存储在...Service 之类的类中，然后进入上下文一次，但这需要调用某个方法才能初始化该变量. 理解，

@RestController
@RequestMapping("/user")
public class MainController implements IDefineId {

    private Long authenticatedId;

    private final DiskInfoService diskInfoService;
    private final DiskSharingService diskSharingService;

    private final CredentialRepository credentialRepository;
    private final ClientRepository clientRepository;


    @Autowired
    public MainController(DiskInfoService diskInfoService,
                          DiskSharingService diskSharingService,
                          CredentialRepository credentialRepository,
                          ClientRepository clientRepository) {
        this.diskInfoService = diskInfoService;
        this.diskSharingService = diskSharingService;
        this.credentialRepository = credentialRepository;
        this.clientRepository = clientRepository;
    }

    @DefineId
    @GetMapping("/")
    public ResponseEntity<?> welcome() {
        String userName = clientRepository.findById(authenticatedId)
                .get()
                .getName();

        diskSharingService.setAuthenticatedId(authenticatedId);
        diskInfoService.setAuthenticatedId(authenticatedId);

        return ResponseEntity.ok("Welcome to my REST-application project, " + userName + "!");
    }

    @GetMapping("/disks/all")
    public ResponseEntity<List<Disk>> disks() {
        return ResponseEntity.ok(diskInfoService.allUserDisks());
    }

    @GetMapping("/disks/free")
    public ResponseEntity<List<Disk>> freeDisks() {
        return ResponseEntity.ok(diskInfoService.allFreeDisks());
    }

    @GetMapping("/disks/taken/by_me")
    public ResponseEntity<List<Disk>> takenDisksByMe() {
        return ResponseEntity.ok(diskInfoService.allTakenDisksByUser());
    }

    @GetMapping("/disks/taken/from_me")
    public ResponseEntity<List<Auxiliary>> takenDisksFromMe() {
        return ResponseEntity.ok(diskInfoService.allTakenDisksFromUser());
    }

    @PutMapping("/disk/take/{id}")
    public ResponseEntity<?> takeDisk(@PathVariable("id") Long id) {
        return ResponseEntity.ok(diskSharingService.takeDisk(id));
    }

    @PutMapping("/disk/return/{id}")
    public ResponseEntity<?> returnDisk(@PathVariable("id") Long id) {
        return ResponseEntity.ok(diskSharingService.returnDisk(id));
    }

    @Override
    public void defineAuthenticatedId() {
        String userName;
        User auth = ((User) SecurityContextHolder.getContext().getAuthentication().getPrincipal());

        if (auth != null) {
            userName = auth.getUsername();
            try {
                this.authenticatedId = credentialRepository.findByName(userName).getId();
            } catch (CannotCreateTransactionException ignored) {}
        }
    }

}

现在我将解释这里发生了什么：当调用welcome()方法时会触发一个切面，该切面又位于URL-user/（切面通过@DefineId注解-@Before调用）类型）。在 DiskInfoService 和 DiskSharingService 类中调用此方法后，将设置authenticatedId，然后它们可以使用它（控制器本身不需要authenticatedId，稍后我将从此处删除它，但现在为了清楚起见我将其保留）。切面依次调用 defineAuthenticatedId () 方法，该方法爬入上下文并从那里挖出用户的登录信息，然后爬入数据库并从那里获取用户的 ID。是否可以摆脱手动调用welcome() 方法，例如，在授权后立即设置Id（类似于@PostConstruct 用于bean）。也许 还有另一种解决问题的方法吗？如何组织这样的功能？