问题[java](coding)

我正在使用 spring-boot 3.4.2。

我想使用 AOP 方面来修改我在 Spring Boot 测试中使用的注释。

但是我的 @Around 方法在测试执行期间不会被触发。如果我​​注释 Rest 控制器内的端点方法，则会触发该方法。但我想使用它进行测试。

这是我的注释：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}

以下是我的观点：

@Aspect
@Component
public class TestAspect {
    public TestAspect() {
        // this is called - so @Component works
        System.out.println("aspect constructor called");
    }
    
    @Around("@annotation(TestAnnotation)")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        // this is NOT called in the test - @Around did not work
        System.out.println("aroundAdvice() called");
        return joinPoint.proceed();
    }
}

这是我的测试：

@SpringBootTest
@ComponentScan(basePackages = { "de.mycompany" }) // root of all my packages
@TestPropertySource(value = "classpath:application-test.yml", factory = YamlPropertySourceFactory.class)
@AutoConfigureMockMvc
class MyTestClass {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    @TestAnnotation
    void testSomething() throws Exception {
        System.out.println("testSomething() called.");
        // test something with mockMvc
    }
}

如果我在 RestController 中注释了一个端点，aroundAdvice()则每当调用或测试该端点时都会触发它。但我需要在调用我的测试方法（此处：）时触发它testSomething()。但这行不通。

使用完全限定的类@Around也不起作用： @Around("@annotation(de.mycompany.annotation.TestAnnotation)")

我想要实现的是编写一个 ArchUnit 规则来确保我们的包足够小。

例如，假设这样：

natural
 ├─ goodpackage
 │  ├─ apple
 │  ├─ banana
 │  ├─ mango
 ├─ badpackage
 │  ├─ file1
 │  ├─ file2
 │  ├─ ...
 │  ├─ file10

对于此示例，假设超过 9 个文件太多，而最多 8 个文件足够小。

这也仅适用于叶包，即最底层的包（如果此包中有文件，但也有子包，则测试应针对子包）

我尝试使用该类com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes并希望找到一种在包内进行迭代的方法。但没有运气。

我还搜索了是否可以直接从 ArchUnit 获取软件包，例如：

    @Test
    void leafPackagesShouldNotHaveMoreThan9Files() {   }
        packages().that().areInSubPackages().shouldNot().have(moreThan9Files()).check(importedClasses);
    }

但也是不可能的。

如何使用 ArchUnit 检查叶包中的文件数量是否少于 N 个？

我有一个由 Lombok 生成的类，用于为 Spring JDBC 生成信息SimpleJdbcCall。这是对象：

@Data
@Builder
public class DatabaseCallInformation {

    private String dbPackage;
    private String dbProcedure;
    private List<InParam> inParams;
    private List<OutParam> outParams;

    @Data
    @Builder
    public static class InParam {
        
        private String paramName;
        private int sqlType;
        private String value;

    }

    @Data
    @Builder
    public static class OutParam {
        
        private String paramName;
        private int sqlType;
        private SqlReturnType sqlReturnType;
        private RowMapper<?> rowMapper;

    }

我想要做的是能够像这样调用构建器：

    DatabaseCallInformation result = DatabaseCallInformation.builder()
        .dbPackage("MY_PACKAGE")
        .dbProcedure("MY_PROCEDURE")
        .inparam() 
            .paramName("ID")
            .sqlType(Types.NUMBER)
        .and()
        // possibly more inparams
        .outParam()
            .paramName("result")
            .sqlType(Types.VARCHAR)
        .and()
        // possibly more outParams
        .build()

（注意：lombok 类具有输出到的方法，SqlParameter但SqlOutParameter这里将其排除在外）。

有人能帮我把语法弄对吗？inParam()、outParam()和and()方法现在是必需的，它们只是为了尝试展示我想要做的事情。

杰森

我想向我的自定义标签添加自定义 CSS 整数属性（在此示例中我使用-fx-foo）。这是我的代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.application.Application;
import javafx.beans.property.IntegerProperty;
import javafx.css.CssMetaData;
import javafx.css.Styleable;
import javafx.css.StyleableIntegerProperty;
import javafx.css.converter.SizeConverter;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class NewMain extends Application {

    public static class FooLabel extends Label {

        private static final CssMetaData<FooLabel, Number> FOO_PROPERTY = new CssMetaData<FooLabel, Number>("-fx-foo",
                SizeConverter.getInstance(), 10) {

            @Override
            public boolean isSettable(FooLabel label) {
                return true;
            }

            @Override
            public StyleableIntegerProperty getStyleableProperty(FooLabel label) {
                return (StyleableIntegerProperty) label.fooProperty();
            }
        };

        private static final List<CssMetaData<? extends Styleable, ?>> CSS_META_DATA;

        static {
            List<CssMetaData<? extends Styleable, ?>> list = new ArrayList<>(Label.getClassCssMetaData());
            list.add(FOO_PROPERTY);
            CSS_META_DATA = Collections.unmodifiableList(list);
        }

        public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
            return CSS_META_DATA;
        }

        private final StyleableIntegerProperty foo = new StyleableIntegerProperty(10) {

            @Override
            public CssMetaData getCssMetaData() {
                return FOO_PROPERTY;
            }

            @Override
            public Object getBean() {
                return FooLabel.this;
            }

            @Override
            public String getName() {
                return "foo";
            }
        };

        public FooLabel() {
            super();
            foo.addListener((observable, oldValue, newValue) -> {
                System.out.println("NEW VALUE:" + newValue);
            });
        }

        public IntegerProperty fooProperty() {
            return foo;
        }

        public void setFoo(int foo) {
            this.foo.set(foo);
        }

        public int getFoo() {
            return foo.get();
        }
    }

    /**************** MAIN APP  *****************/

    @Override
    public void start(Stage primaryStage) {
        var fooLabel = new FooLabel();
        fooLabel.getStyleClass().add("test");
        fooLabel.setText("abc");
        VBox root = new VBox(fooLabel);
        root.getStylesheets().add(NewMain.class.getResource("test.css").toExternalForm());
        Scene scene = new Scene(root, 100, 100);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

和 CSS：

.test {
    -fx-foo: 100;
    -fx-background-color: yellow;
}

代码已编译，运行时不会抛出任何异常。标签为黄色。但是，foo属性从未改变，似乎-fx-foo只是被忽略了。有人能说说如何修复它吗？

抱歉标题太差。如果能帮我想一个更好的标题就好了，但我甚至不知道该如何描述我的问题。

假设我有以下类型。

interface M<K, V> {}
interface F<I, O> {}

假设我创建了一个实现这两个接口的类。

record A<A1, A2> (A1 a1, A2 a2)
    implements 
        M<A1, A2>, 
        F<A1, A2> 
{}

好的，太棒了。现在我可以A在任何地方使用M或 了F。

现在我的问题来了。我尝试执行以下操作，但因编译器错误而失败。

public class DoublyNestedGenerics
{

   interface M<K, V> {}
   
   interface F<I, O> {}
   
   record A <A1, A2> (A1 a1, A2 a2)
      implements 
         M<A1, A2>, 
         F<A1, A2> 
   {}
   
   private 
      static 
      <
         D1, 
         D2, 
         D extends 
            M<D1, D2> 
            & F<D1, D2>
      >
      D
      canItWork(final D1 d1, final D2 d2)
   {
   
      // return new A(d1, d2);
      throw new UnsupportedOperationException();
   
   }

}

好的，一切都编译通过了。但是，如果我取消注释返回并替换异常，则会收到以下编译错误。

DoublyNestedGenerics.java:28: warning: [rawtypes] found raw type: A
      return new A(d1, d2);
                 ^
  missing type arguments for generic class A<A1,A2>
  where A1,A2 are type-variables:
    A1 extends Object declared in record A
    A2 extends Object declared in record A

好的，说得通。让我将返回值改为这样。

  return new A<>(d1, d2);

按下编译按钮会出现以下编译器错误。

DoublyNestedGenerics.java:28: error: incompatible types: cannot infer type arguments for A<>
      return new A<>(d1, d2);
                  ^
    reason: no instance(s) of type variable(s) A1,A2 exist so that A<A1,A2> conforms to D
  where A1,A2,D,D1,D2 are type-variables:
    A1 extends Object declared in record A
    A2 extends Object declared in record A
    D extends M<D1,D2>,F<D1,D2> declared in method <D1,D2,D>canItWork(D1,D2)
    D1 extends Object declared in method <D1,D2,D>canItWork(D1,D2)
    D2 extends Object declared in method <D1,D2,D>canItWork(D1,D2)
1 error

我没有完全理解这个错误，所以我决定简化这个问题。

我改变了方法，改为使用一些硬编码类型，而不仅仅是D1和D2。新方法如下所示。

   private 
      static 
      <
         D extends 
            M<Integer, Integer> 
            & F<Integer, Integer>
      >
      D
      canItWorkAttempt2(final Integer d1, final Integer d2)
   {
   
      // return new A<>(d1, d2);
      throw new UnsupportedOperationException();
   
   }

交换注释并按编译后出现以下编译器错误。

DoublyNestedGenerics.java:44: error: incompatible types: cannot infer type arguments for A<>
      return new A<>(d1, d2);
                  ^
    reason: no instance(s) of type variable(s) A1,A2 exist so that A<A1,A2> conforms to D
  where A1,A2,D are type-variables:
    A1 extends Object declared in record A
    A2 extends Object declared in record A
    D extends M<Integer,Integer>,F<Integer,Integer> declared in method <D>canItWorkAttempt2(Integer,Integer)
1 error

好的，小得多，因此更容易解析。

让我印象深刻的一件事是它说A1 extends Object declared in record A。

嗯，不对——应该是Integer，而不是Object。也许推理需要一些帮助。所以我把返回值改成了这个。

  return new A<Integer, Integer>(d1, d2);

这导致了以下编译器错误。

DoublyNestedGenerics.java:44: error: incompatible types: A<Integer,Integer> cannot be converted to D
      return new A<Integer, Integer>(d1, d2);
             ^
  where D is a type-variable:
    D extends M<Integer,Integer>,F<Integer,Integer> declared in method <D>canItWorkAttempt2(Integer,Integer)
1 error

进展！我现在开始有了怀疑，为了证实这些怀疑，我决定大大简化我的问题。我创建了以下类。

record N (Integer n1, Integer n2)
    implements 
        M<Integer, Integer>,
        F<Integer, Integer>
{}

编译没有问题。很好，让我们尝试更改返回类型以改用此类型。这是我将返回更改为的内容。

return new N(d1, d2);

满怀希望，我按下了编译按钮。

DoublyNestedGenerics.java:50: error: incompatible types: N cannot be converted to D
      return new N(d1, d2);
             ^
  where D is a type-variable:
    D extends M<Integer,Integer>,F<Integer,Integer> declared in method <D>canItWorkAttempt2(Integer,Integer)
1 error

非常令人失望。但我发现了其他问题。错误信息中显示where D is a type-variable: D extends M<Integer,Integer>,F<Integer,Integer>。

他们使用了extends这个词。无奈之下，我尝试添加以下类型。

interface C<C1, C2> extends M<C1, C2>, F<C1, C2> {}

record N2 (Integer n1, Integer n2) implements C<Integer, Integer> {}

然后，从那时起，我改变了我的回报，这样说。

final C<Integer, Integer> blah = new N2(d1, d2);
return blah;

然后我按下了编译。

DoublyNestedGenerics.java:55: error: incompatible types: C<Integer,Integer> cannot be converted to D
      return blah;
             ^
  where D is a type-variable:
    D extends M<Integer,Integer>,F<Integer,Integer> declared in method <D>canItWorkAttempt2(Integer,Integer)
1 error

这时候，我心里很烦躁。

错误消息以某种方式告诉我C<Integer,Integer> cannot be converted to D。它还告诉我D is a type-variable，具体来说，D extends M<Integer,Integer>,F<Integer,Integer> 这正是 C 所做的。但是，它仍然不起作用？

这让我想到了这里。我遗漏了什么？如果有人愿意提出建议，我再次希望有人能帮我起草一个更好的标题。

最后，这里是完整的代码，以防难以理解。

public class DoublyNestedGenerics
{

   interface M<K, V> {}
   
   interface F<I, O> {}
   
   record A <A1, A2> (A1 a1, A2 a2)
      implements 
         M<A1, A2>, 
         F<A1, A2> 
   {}
   
   record N (Integer n1, Integer n2)
      implements 
         M<Integer, Integer>,
         F<Integer, Integer>
   {}
   
   interface C<C1, C2> extends M<C1, C2>, F<C1, C2> {}
   
   record N2 (Integer n1, Integer n2) implements C<Integer, Integer> {}
   
   private 
      static 
      <
         D1, 
         D2, 
         D extends 
            M<D1, D2> 
            & F<D1, D2>
      >
      D
      canItWork(final D1 d1, final D2 d2)
   {
   
      // return new A<>(d1, d2);
      throw new UnsupportedOperationException();
   
   }

   private 
      static 
      <
         D extends 
            M<Integer, Integer> 
            & F<Integer, Integer>
      >
      D
      canItWorkAttempt2(final Integer d1, final Integer d2)
   {
   
      final C<Integer, Integer> blah = new N2(d1, d2);
      return blah;
      // return new N(d1, d2);
      // throw new UnsupportedOperationException();
   
   }

}

我熟悉 Java 平台模块系统。

javadoc概述Module#addOpens了一个我无法转化为现实世界的用例：

此方法可用于以下情况：消费者模块使用限定打开将包打开到API 模块，但对消费者模块中类成员的反射访问委托给另一个模块中的代码。API 模块中的代码可以使用此方法将消费者模块中的包打开到其他模块。

我承认我太笨了，无法从这个描述跳到现实世界。我可以看到这与以某种方式扩展深度反射访问有关，但我不确定那种方式是什么，特别是考虑到方法描述本身：

如果此模块 [“消费者模块”？可能吗？] 至少已向调用者模块 [“ API 模块”？可能吗？] 打开了一个包，则更新此模块以向给定模块 [“其他模块”？可能吗？] 打开该包。

我有一种模糊的、几乎肯定是错误的感觉，这与我的模块（“消费者模块”？）打开一个包到 Servlet（“API 模块”？）之类的东西有关，但在运行时不知道 Servlet 的实现实际上是（比如说）Tomcat，所以，如果我的代码希望，它（我想？）可以调用这个方法，从而以某种方式允许 Tomcat（“其他”模块？）做反射的事情，而不知道它实际上是 Tomcat（而不是 Jetty）在做那些反射的事情，也不必有opens com.foo.bar to Tomcat额外module-info的opens com.foo.bar to Servlet。

（我也不确定“委托”应该发生在哪里；在这种情况下，Servlet 不能将任何事情“委托”给 Tomcat。）

但考虑到Lookup调用站点敏感度限制，我不确定这应该如何工作，或者在这种情况下我应该在代码中的何时何地进行此类调用，或者为什么如果我已经添加了opens语句，我现在还必须执行一些编程操作。我理解完整性的激励目标，并且必须授予反射访问的权限，并且这应该以某种方式使事情变得更容易，但我无法具体实现这一点。

简而言之：这个功能实际上有具体的用例吗？如果有，它是什么？它是如何工作的？

我有一个用于预订电影票的 Java 代码。在这个程序中，每个人只能购买两张票，最多售出 10 张票，最后会显示一个包含人员姓名的列表。我完成了整个过程，初始化并将ArrayList每个姓名存储在该列表中，但我不知道如何让这个程序在列表本身中检查一个人是否已经购买了两张以上的票。

• 该计划应以空列表开始，最多可提供 10 张票。

• 每次迭代时，询问用户是否想要买票。

• 如果用户想要购买，则询问他们的姓名，如果还有票可用，则将他们添加到列表中。

• 如果门票已售完，则显示售完信息。

• 最后，显示所有购买门票的人的名单。

代码如下：

public class BookingTickets{

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    ArrayList<String> list = new ArrayList<>();

    int ticketsPurchased = 0;
    int allTickets = 10;

    System.out.print("Do you want to buy a ticket? (y/n): ");
    String response = sc.next().toLowerCase();

    if (response.equals("n")) {
      System.out.println("Thank you. See you next time.");     
    }

    while (response.equals("y")) {
      if (ticketsPurchased <= 2) {

        if (allTickets == 0) {
          System.out.print("Sorry, we have no more tickets!\n");
          System.out.println(list);
        } 

        System.out.print("How many tickets do you want to buy? ");
        ticketsPurchased = sc.nextInt();

        System.out.print("Enter the buyer's name: ");
        String name = sc.next();
        list.add(name);
        allTickets -= ticketsPurchased;
      } else {
        System.out.print("Limit of 2 tickets per person.");
      }

      System.out.print("Do you want to buy a ticket? (y/n): ");
      response = sc.next().toLowerCase();
    }

    System.out.println(list);
        
    sc.close();
  }
}

当我准备 OCPJP 21 时，遇到了 Flow 范围主题。

我需要一些指导来理解这个概念。下面是代码片段

public class Question28
{

static void getFish(Object fish) {

if(!(fish instanceof String guppy))
    System.out.println("Eat!");
else if(!(fish instanceof String guppy)) {
    throw new RuntimeException();

}

System.out.println(guppy);

System.out.println("Swim!");
}

public static void main(String args[]) {

getFish("ashish");

} 

}
 

上述代码片段导致变量 guppy “无法找到符号”。但如果我删除 else 关键字，如下所示。guppy 变量仍然在范围内。没有编译器错误。

static void getFish(Object fish) {

if(!(fish instanceof String guppy))
    System.out.println("Eat!");
 if(!(fish instanceof String guppy)) {
    throw new RuntimeException();

}

System.out.println(guppy);

我的第二个观察如下参考片段

class Sample2 {

static void printNumberTwice(Number number) {

    if(!(number instanceof Integer data)) 
         return ;
        //System.out.println("Eat!");

    System.out.println(data.intValue());

}

public static void main(String args[]) {

printNumberTwice(5);
}



}

上述代码片段成功编译，但如果我注释掉返回并添加 SOP 语句，则会导致无法找到数据符号。

请指导我理解这个概念。

我正在开发一个应用程序，用于存储一些带有过去时间戳的数据。

我的 JVM 是 IBM Semeru (17)，运行于 Europe/Paris tz。但我想将时间戳存储在 UTC (GMT+0)。

下面是我的代码：

    <dependencies>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.7.1</version>
        </dependency>
    </dependencies>

public class Main {

    /*
    create table theentity (
        theid integer not null,
        thevalue timestamp(6),
        primary key (theid)
    )
     */
    public static void main(String[] args) {
        TimeZone.setDefault( TimeZone.getTimeZone( ZoneId.of( "Europe/Paris" ) ) );
        LocalDateTime d_1900_01_01_T_00_09_23 = LocalDateTime.of( 1900, 1, 1, 0, 9, 23, 0 );
        LocalDateTime d_1900_01_01_T_00_09_22 = LocalDateTime.of( 1900, 1, 1, 0, 9, 22, 0 );
        LocalDateTime d_1900_01_01_T_00_09_21 = LocalDateTime.of( 1900, 1, 1, 0, 9, 21, 0 );
        LocalDateTime d_1900_01_01_T_00_09_20 = LocalDateTime.of( 1900, 1, 1, 0, 9, 20, 0 );
        LocalDateTime d_1900_01_01_T_00_09_19 = LocalDateTime.of( 1900, 1, 1, 0, 9, 19, 0 );

        try(Connection c = DriverManager.getConnection( "jdbc:postgresql://localhost:5432/hibernate_orm_test?preparedStatementCacheQueries=0&escapeSyntaxCallMode=callIfNoReturn",
                                                                                                        "postgres", "root")) {
            PreparedStatement p = c.prepareStatement( "insert into theentity values(?, ?)" );
            bindAndExecute( p, 1, d_1900_01_01_T_00_09_23 );
            bindAndExecute( p, 2, d_1900_01_01_T_00_09_22 );
            bindAndExecute( p, 3, d_1900_01_01_T_00_09_21 );
            bindAndExecute( p, 4, d_1900_01_01_T_00_09_20 );
            bindAndExecute( p, 5, d_1900_01_01_T_00_09_19 );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void bindAndExecute(PreparedStatement p, int id, LocalDateTime localDateTime)
            throws SQLException {
        p.setInt( 1, id );
        p.setTimestamp(2,
                Timestamp.valueOf( localDateTime ),
                Calendar.getInstance( TimeZone.getTimeZone( ZoneId.of( "GMT" ) ) )
        );
        p.executeUpdate();
    }

}

为了排序，我尝试保留 5 个时间戳（请注意，这些时间戳基于欧洲/巴黎，因为TimeZone.setDefault( TimeZone.getTimeZone( ZoneId.of( "Europe/Paris" ) ) );）

• 1900-01-01T00:09:23
• 1900-01-01T00:09:22
• 1900-01-01T00:09:21
• 1900-01-01T00:09:20
• 1900-01-01T00:09:19

这行代码将把 Europe/Paris tz 翻译为 UTC tz：

p.setTimestamp(2,
                Timestamp.valueOf( localDateTime ),
                Calendar.getInstance( TimeZone.getTimeZone( ZoneId.of( "GMT" ) ) ) );

执行它将在postresql中创建5行：

theid |      thevalue       
-------+---------------------
     1 | 1900-01-01 00:00:02
     2 | 1900-01-01 00:00:01
     3 | 1900-01-01 00:00:00
     4 | 1899-12-31 23:09:20
     5 | 1899-12-31 23:09:19
(5 rows)

你们大多数人可能认为巴黎位于 GMT+1。这是正确的，但实际上并不正确。1900 年，巴黎位于 GMT+00:09:21（9 分 21 秒）！！

因此，前 3 个时间戳已正确保存到表中。但是，奇怪的是在第 4 行。它是，1899-12-31 23:09:20但我预计它会是1899-12-31 23:59:59。但似乎在 1899 年，旧的 DateTime API 认为它是 GMT+1。这导致第 4、5 行等等……都是错误的！！

你们能解释一下这个吗？

我正在尝试在 Spring Boot 应用程序中添加 Kafka Avro 序列化和 Schema Registry Client 的 Confluent 依赖项。但是，当我尝试使用 Maven 构建项目时，出现以下错误：

在中心（ https://repo.maven.apache.org/maven2）中找不到工件 io.confluent:kafka-schema-registry-client:pom:7.8.0

查看错误：-

<!-- https://mvnrepository.com/artifact/io.confluent/kafka-avro-serializer -->
        <dependency>
            <groupId>io.confluent</groupId>
            <artifactId>kafka-avro-serializer</artifactId>
            <version>7.8.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.confluent/kafka-schema-registry-client -->
        <dependency>
            <groupId>io.confluent</groupId>
            <artifactId>kafka-schema-registry-client</artifactId>
            <version>7.8.0</version>
        </dependency>