小编Tom*_*yre的帖子

假设我有一个属性的注释:

@Named(name = "Steve")
private Person person

我想创建一个带有多个元注释的复合注释,包括带有属性的元注释

@Named
@AnotherAnnotation
@YetAnotherAnnotation
public @interface CompoundAnnotation {

    ...
}

有没有办法可以将属性传递给复合注释到其中一个元注释？

例如,像这样:

@CompoundAnnotation(name = "Bob")
private Person person;

这相当于,但比方便得多

@Named(name = "Bob")
@AnotherAnnotation
@YetAnotherAnnotation
private Person person;

谢谢!

PS为我糟糕的示例注释选择道歉 - 我没有javax.inject.@ Named注释,只是一些具有属性的任意注释.

谢谢大家的回答/评论.

这似乎是不可能的.然而,恰好有一个简单的解决方案,我将分享以下情况,如果它可以帮助任何人:

我正在使用Spring,并希望创建自己的注释,将@Component作为元注释,从而通过组件扫描自动检测.但是,我还希望能够设置BeanName属性(对应于@Component中的value属性),这样我就可以拥有自定义bean名称.

好吧,事实证明Spring的有思想的人可以做到这一点 - AnnotationBeanNameGenerator将采用它传递的任何注释的'value'属性并将其用作bean名称(当然,默认情况下,它将只传递@Component的注释或将@Component作为元注释.回想起来,这应该从一开始就很明显 - 这就是使用@Component作为元注释的现有注释,例如@Service和@Registry,可以提供bean名称.

希望对某人有用.尽管如此,我仍然认为这是不可能的,这是一种耻辱!

我正在开发一个带有几个独立模块的项目,每个模块都有自己的应用程序上下文属性文件.我希望能够加载所有这些属性,以便它们可以用于Spring的占位符解析.

以前的问题已经提到了这一点,并有一个很好的博客文章在这里,描述了如何在各个环境中使用提供一个PropertyPlaceholderConfigurer,按优先级排序它们并设置ignoreUnresolveablePlaceholders为true,以便这些属性文件可以交叉引用对方没有吹起来.

但是,这并没有解决我的问题,因为我也希望能够使用我正在加载的属性来进行一些自定义占位符解析(从我正在解析的一些yaml文件).这需要使用PropertyPlaceholderHelper,它需要将Properties对象作为参数.

据我所知,潜在的解决方案是:

1)将所有属性文件合并到一个属性bean中.然后可以使用它来创建PropertyPlaceholderConfigurer(用于Spring的内部占位符解析)并与PropertyPlaceholderHelper一起使用(用于我自己的占位符解析)

2)以某种方式配置PropertyPlaceholderHelper以使用PropertyPlaceholderConfigurers持有的属性集及其层次结构,如果我继续并遵循该博客帖子的建议.

不幸的是,我无法弄清楚如何做其中任何一个.任何帮助将不胜感激!

PS看起来Spring 3.1在这里将是一个很大的帮助......遗憾的是我们还没有准备好转向它,所以我仍然需要一个解决方案让我度过难关!

****编辑****

谢谢你到目前为止的答案.它们是很好的答案,但遗憾的是不会对我有所帮助,因为(并且对于之前没有提到这一点道歉)我们目前正在将我们项目的核心模块与非核心模块分开.这意味着核心模块及其应用程序上下文无法对属性文件的名称进行硬编码.令人沮丧的是,Spring的类路径扫描似乎被打破了,所以"classpath*:*.properties"类型的通配符仅在构建单个模块时起作用,而不是顶级项目(我相信这是一个已知问题).

问题是如何将非核心模块中定义的属性文件合并到核心模块中定义的现有属性文件中.目前我正在使用BeanPostProcessor - 我只是想知道是否有更简单/更优雅的方法来做到这一点？

谢谢

我有一个不可变的类TokenList,它由Token对象列表组成,它们也是不可变的:

@Immutable
public final class TokenList {

    private final List<Token> tokens;

    public TokenList(List<Token> tokens) {
        this.tokens = Collections.unmodifiableList(new ArrayList(tokens));
    }

    public List<Token> getTokens() {
        return tokens;
    }
}

我对这些TokenLists执行了几个操作,这些操作将多个TokenLists作为输入并返回单个TokenList作为输出.可以有任意多个TokenLists进入,每个TokenLists可以有任意多个Tokens.

这些操作很昂贵,并且很有可能多次执行相同的操作(即相同的输入),所以我想缓存输出.但是,性能至关重要,我担心在这些可能包含任意多个元素的对象上执行hashCode()和equals()的费用(因为它们是不可变的,然后hashCode可以被缓存,但是equals仍然很昂贵).

这让我想知道是否可以通过对TokenList进行以下更新来简单而廉价地使用UUID来提供equals()和hashCode():

@Immutable
public final class TokenList {

    private final List<Token> tokens;
    private final UUID uuid;

    public TokenList(List<Token> tokens) {
        this.tokens = Collections.unmodifiableList(new ArrayList(tokens));
        this.uuid = UUID.randomUUID();
    }

    public List<Token> getTokens() {
        return tokens;
    }

    public UUID getUuid() {
        return uuid;
    }
}

这样的东西充当缓存键:

@Immutable
public final class TopicListCacheKey {

    private …

Spring（可能还有其他 DI 容器，但我使用的是 Spring）识别 @DependsOn 注释。您使用它来标识必须在此 bean 之前启动的任何其他 bean，例如

@Component
@DependsOn({"initiatedFirst", "initiatedSecond"})
public class InitiatedThird {

//...

是否有类似的注释意味着必须在带注释的 bean 之后启动提供的 bean？例如

@Component
@DependencyOf({"initiatedSecond", "initiatedThird"})
public class InitiatedFirst {

//...

当您无法访问 bean 的源代码/初始化但想要事先配置一些其他 bean 时，我会认为这将是一个非常常见的用例。有这样的注解吗？

我有一个练习,我必须按以下方式对数组进行排序:

1. 除以4而没有余数的数字将是数组中的第一个(例如4,8,12,16).
2. 将剩余的1除以4的数字将是数组中的第二个(1,5,9).
3. 将剩余的2除以4的数字将是数组中的第三个(2,6,10).
4. 将剩下的3除以4的数字将在数组中最后.

例如,以下数组:

int []a={1,7,3,2,4,1,8,14}

将会:

4   8   1   1   2   14  3   7   

组内的顺序无关紧要.

我找到了一个解决O(n)时间复杂度和O(1)空间复杂度的解决方案.

然而,它是丑陋的,并在阵列上移动3次.我想要一个更优雅的解决方案.

这是我的代码:

    int ptr=a.length-1; int temp=0, i=0;
    while (i<ptr){
        //move 3 remained to the end
        if (a[i] % 4==3){
            temp=a[ptr];
            a[ptr]=a[i];
            a[i]=temp;
            ptr--;
        }
        else
            i++;
    }
    i=0;
    while (i<ptr){
        if (a[i]%4==2)
        {
            temp=a[ptr];
            a[ptr]=a[i];
            a[i]=temp;
            ptr--;
        }
        else
            i++;
    }
    i=0;
    while (i<ptr){
        if (a[i]%4==1)
        {
            temp=a[ptr];
            a[ptr]=a[i];
            a[i]=temp;
            ptr--;
        }
        else
            i++;
    }

重要的是要知道:

• 我不希望时间复杂度比O(n)差,并且空间复杂度比O(1)差.

我试图在我的集成测试中使用模拟，但运气不佳。我用的是Spring 3.1.1和Mockito 1.9.0，情况如下：

@Component
public class ClassToTest {

    @Resource
    private Dependency dependency;

}

和

@Component
public class Dependency {

    @Resource
    private NestedDependency nestedDependency;

}

现在，我想使用 Spring 的 JavaConfig 对 ClassToTest 进行集成测试。这是我尝试过的，但不起作用：

@Test
@ContextConfiguration
public class ClassToTestIntegrationTest {

    @Resource
    private ClassToTest classToTest;

    @Resource
    private Dependency mockDependency;

    @Test
    public void someTest() {
        verify(mockDependency).doStuff();

        // other Mockito magic...

    }


    @Configuration
    static class Config {

        @Bean
        public ClassToTest classToTest() {
            return new ClassToTest();
        }

        @Bean
        public Dependency dependency() {
            return Mockito.mock(Dependency.class);
        }

    }
} …

在与调试器进行令人讨厌的会话后，我似乎在SimpleDateParser中发现了一个错误。

代码：

DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

我的调试器会话：

formatter.parse("2013-09-20 10:23:45.123")
Fri Sep 20 10:23:45 BST 2013

formatter.parse("2013-09-20 11:23:45.123")
Fri Sep 20 11:23:45 BST 2013

formatter.parse("2013-09-20 12:23:45.123")
Fri Sep 20 00:23:45 BST 2013

formatter.parse("2013-09-20 13:23:45.123")
Fri Sep 20 13:23:45 BST 2013

formatter.parse("2013-09-20 14:23:45.123")
Fri Sep 20 14:23:45 BST 2013

formatter.parse("2013-09-20 00:23:45.123")
Fri Sep 20 00:23:45 BST 2013

我要疯了吗？Java的这种基本功能真的存在错误吗？

Java 1.6.0_43