---
title: 'Annotationen in Spring 2.0/2.5 für Autowire und neue Beans'
url: 'https://tutego.de/blog/javainsel/2008/05/annotationen-in-spring-2-02-5-fur-autowire-und-neue-beans'
markdown: 'https://tutego.de/blog/javainsel/2008/05/annotationen-in-spring-2-02-5-fur-autowire-und-neue-beans.md'
date: '2008-05-09'
description: 'Bis Spring 2.0 gab es im Wesentlichen nur eine Möglichkeit, Spring-Beans zu deklarieren und Bean-Referenzen zu injizieren. Ab Spring 2.0 und besonders in Spring 2.5 gibt es einen Richtungswechsel. Statt Bean-Definitionen und Injizierungsanweisungen ausschließlich über XML-Dokumente zu beschreiben, …'
taxonomy:
  category:
    - Spring
---

# Annotationen in Spring 2.0/2.5 für Autowire und neue Beans

![Illustration einer tropischen Insel mit Palmen und einem hohen Berg](https://tutego.de/blog/javainsel/user/themes/tutego/images/insel-cover.jpg)# Java Blog für Programmierer

[Java Blog für Programmierer](https://tutego.de/blog/javainsel/)

## Annotationen in Spring 2.0/2.5 für Autowire und neue Beans

09.05.2008 · [Christian Ullenboom](https://tutego.de/blog/javainsel/author/admin/)

Bis Spring 2.0 gab es im Wesentlichen nur eine Möglichkeit, Spring-Beans zu deklarieren und Bean-Referenzen zu injizieren. Ab Spring 2.0 und besonders in Spring 2.5 gibt es einen Richtungswechsel. Statt Bean-Definitionen und Injizierungsanweisungen ausschließlich über XML-Dokumente zu beschreiben, kommen Annotationen hinzu. Spring nutzt zum Einen Standard-Annotationen aus Java 6 (Common Annoations) aber auch eigene.

Nehmen wir zwei Beans an:

```text

```

Die Bean `CalendarPrinter` soll ein Datum injiziert bekommen.

```java
    public class CalendarPrinter {       public void setDate( Date date ) ... 
```

Über XML lässt sich das einfach beschreiben, doch seit Spring 2.5 veranlasst eine Annotation Spring dazu, die Verweise automatisch zu injizieren:

```
@Autowired
```

`@Autowired` ist eine Annotation für Methoden und Attribute, damit Spring selbständig den Verweis setzt:

```java
    public class CalendarPrinter {       @Autowired       public void setDate(@Qualifier("today") Date d) ...     } 
```

Die Annotation `@Qualifier` ist nur dann nötig, wenn es mehrere Beans dieses Typs gibt. (Nicht bei uns.)

Damit Spring überhaupt die Verknüpfung vornimmt, ist in der XML-Datei ein Hinweis zu setzen.

Die erste Möglichkeit ist:

```text

```

Eine im Allgemeinen bessere Alternative (die AutowiredAnnotationBeanPostProcessor und CommonAnnotationBeanPostProcessor zusammenfasst) ist

```text

```

Die Annotation `@Autowired` ist genauso gültig bei Attributen:

```java
    public class CalendarPrinter     {       @Autowired Date date;      public void doIt()       {         System.out.println( date );       }     }
```

```text

```

Java 6 (für Java 5 ist ein Extra-Jar nötig) führt aus JSR-250 die Lebenszyklus-Annotationen `@PostConstruct` und `@PreDestroy` sowie `@Resource` ein.

```java
    public class CalendarPrinter {       @PostConstruct public void initialize() {         System.out.println( "init" );       }       /* @PreDestroy public void remove() {         System.out.println( "destroy" );       } */     }
```

**Beans deklarieren**

Die Verknüpfung ist durch Autowire automatisiert und minimiert die XML-Konfigurationsdatei. Zum Deklarieren von neuen Beans bringt Spring ebenfalls Annotationen mit. Statt in der XML-Datei zu schreiben

```text

```

können wir annotieren:

```java
    @Component class CalendarPrinter
```

Damit Spring nach annotierten Beans sucht, ist nötig:

```text

```

Die Annotation `@Component` ist an allen Typen erlaubt und natürlich zur Laufzeit sichtbar:

```java
    @Target(value=TYPE)     @Retention(value=RUNTIME)     @Documented     public @interface Component     {       String value();     } 
```

API zur Eigenschaft: „The value may indicate a suggestion for a logical component name, to be turned into a Spring bean in case of an autodetected component.“

Geben wir dem `CalendarPrinter` den Bean-Namen „ cal-printer“:

```java
    @Component("cal-printer")     public class CalendarPrinter
```

Aus dem ApplicationContext genommen folgt:

```java
    ApplicationContext context =       new ClassPathXmlApplicationContext( ... );     Object bean = context.getBean( "cal-printer" );     System.out.println( bean.getClass() );     // class com.tutego.spring.annotation.CalendarPrinter
```

`@Component` ist eine sehr allgemeine Annotation.

Besser ist es, semantische Annotationen zu nutzen, die `@Component` erweitern. Spring liefert drei mit:

1. `@Target`(value=TYPE) … `@Component`public @interface Repository
2. `@Target`(value=TYPE) … `@Component`public @interface Service
3. `@Target`(value=TYPE) … `@Component`public @interface Controller

Kategorien: [Spring](https://tutego.de/blog/javainsel/category/spring/)

[← Alle Beiträge](https://tutego.de/blog/javainsel/)

---

## Navigation

- Previous: [Borland verkauft CodeGear und damit JBuilder](https://tutego.de/blog/javainsel/2008/05/borland-verkauft-codegear-und-damit-jbuilder.md)
- Next: [BGGA Closures werden wohl das Rennen in Java 7 machen](https://tutego.de/blog/javainsel/2008/05/bgga-closures-werden-wohl-das-rennen-in-java-7-machen.md)