Detaillierte Erläuterung der Verwendungscodebeispiele von Spring-Framework-Anmerkungen

Vorher geschrieben:

Wie wir alle wissen, wird im JavaEE-Entwicklungs- Framework das Spring-Framework am häufigsten verwendet, und die Positionierung von Anmerkungen im Framework wird immer häufiger offensichtlicher. Machen wir einen Witz: Wenn es mit einer Anmerkung gelöst werden kann, wird es nie mit einer Menge Konfiguration und Code gelöst; wenn es nicht gelöst werden kann, dann kommen Sie mit zwei Anmerkungen (Moment, nicht sprühen). ..)

1.@Component ist eine allgemeine Annotation, die von Spring definiert wird und jede Bean mit Annotationen versehen kann.

2. @Scope definiert den Geltungsbereich der Bean: „Singleton“. Darüber hinaus gibt es Prototyp, Anforderung, Sitzung.

Fall: @Component- und @Scope-Nutzungsanalyse:

BeanAnnotation-Klasse:

@Scope
@Component
public class BeanAnnotation {

    public void say(String arg) {
        System.out.println("BeanAnnotation : " + arg);
    }

    public void myHashCode() {
        System.out.println("BeanAnnotation : " + this.hashCode());
    }

}

junit4-Testklasse→TestBeanAnnotation-Klasse:

@RunWith(BlockJUnit4ClassRunner.class)
public class TestBeanAnnotation extends UnitTestBase {

    public TestBeanAnnotation() {
        super("classpath*:spring-beanannotation.xml");
    }

    @Test
    public void testSay() {
        BeanAnnotation bean = super.getBean("beanAnnotation");
        bean.say("This is test.");
    }

    @Test
    public void testScpoe() {
        BeanAnnotation bean = super.getBean("beanAnnotation");
        bean.myHashCode();
        bean = super.getBean("beanAnnotation");
        bean.myHashCode();
    }

}

SpringKonfigurationsdatei→spring-beanannotation.xml:

<context:component-scan base-package="com.beanannotation"></context:component-scan>

Lass uns zuerst die Spring-Konfigurationsdatei analysieren , base-package="com.beanannotation" gibt an, dass wir die Annotationen nur unter diesem Paketnamen verarbeiten.

Analysieren Sie dann die BeanAnnotation-Klasse und es gibt eine Say-Methode. Unter der Annahme, dass wir nicht wissen, um welche Art von Klasse es sich handelt (Anmerkung: Service oder DAO), können wir eine allgemeine Annotation @Component verwenden.

Analysieren Sie abschließend die TestBeanAnnotation-Klasse. In der testSay-Methode ruft super.getBean("beanAnnotation") die Bean aus dem IOC-Container ab und ruft die Say-Methode der Bean auf.

Es ist Zeit, eine Frage zu stellen. Wenn wir super.getBean verwenden, erhalten wir es aus dem IOC-Container über die ID der Bean. Denn wenn wir @Component zur BeanAnnotation-Klasse hinzufügen, lautet die Standard-ID beanAnnotation. Wenn der Name von @Component angegeben wird, beispielsweise als @Component(”bean”), wenn Unit-Test , muss die von super.getBean erhaltene ID damit übereinstimmen, damit der Test erfolgreich ist.

Hier trenne ich die @Scope-Annotation zur Analyse. Es gibt eine testScpoe-Methode in der TestBeanAnnotation-Klasse. Es gibt eine myHashCode-Methode in der BeanAnnotation-Klasse. Sie sind vielleicht etwas verwirrt, warum Sie this.hashCode () verwenden sollten. Da @Scope den Bereich der Bean angibt, wird der Hash-Codewert verwendet, um zu bestimmen, ob es sich um dasselbe Objekt handelt, um sicherzustellen, dass die Ergebnisse der Testklasse genau und klar sind.

3.@Repository, @Service und @Controller sind gezieltere Annotationen.

PS: Hier müssen wir verstehen, dass diese drei Annotationen auf den von @Component definierten Annotationen basieren:

①, @Repository wird normalerweise verwendet Kommentieren Sie DAO-Klassen, was wir oft als Persistenzschicht bezeichnen.
② @Service wird normalerweise zum Kommentieren der Service-Klasse verwendet, bei der es sich um die Service-Schicht handelt.
③. @Controller wird normalerweise in der Controller-Klasse verwendet, die die Kontrollschicht darstellt (MVC).

4. Unter @Autowired versteht man die „traditionelle“ Setter-Methode, die in Setter-Methoden, Konstruktoren oder Mitgliedsvariablen verwendet werden kann und die automatische Assemblierung von Spring Beans durchführen kann.

Fall: @Autowired-Nutzungsanalyse eins:

Spring-Konfigurationsdatei → spring-beanannotation.xml:

<context:component-scan base-package="com.beanannotation"></context:component-scan>

SimpleMovieListeer-Klasse:

public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Autowired(required=false)
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

}

Wenn keine passende Bean gefunden wird, schlägt die automatische Verdrahtung standardmäßig fehl wird eine Ausnahme auslösen , wir können @Autowired mit Anmerkungen versehen auf dieser Set-Methode und markieren Sie „required=false“, um dies zu vermeiden. Dies ist jedoch nicht erforderlich. Wenn die Instanz von movieFinder nicht gefunden wird, wird nur festgestellt, dass movieFinder null ist Stellen Sie mithilfe dieser Funktion zunächst fest, ob movieFinder null ist. Wenn dies der Fall ist, wird eine Nullzeigerausnahme gemeldet.

Es ist erwähnenswert, dass wir wissen, dass jede Klasse viele Konstruktoren haben kann, aber bei Verwendung von @Autowired gibt es und kann nur einen Konstruktor geben, der als erforderlich = wahr markiert werden kann (Hinweis: erforderlich Der Standardwert ist falsch).

Fall: @Autowired-Nutzungsanalyse zwei:

BeanImplOne-Klasse:

@Order
@Component
public class BeanImplOne implements BeanInterface {

}

BeanImplTwo-Klasse:

@Order
@Component
public class BeanImplTwo implements BeanInterface {

}

BeanInterface-Klasse:

public interface BeanInterface {

}

BeanInvoker-Klasse:

@Component
public class BeanInvoker {

    @Autowired
    private List<BeanInterface> list;

    @Autowired
    private Map<String, BeanInterface> map;

    public void say() {
        if (null != list && 0 != list.size()) {
            for (BeanInterface bean : list) {
                System.out.println(bean.getClass().getName());
            }
        } else {
            System.out.println(" list is null !");
        }

        if (null != map && 0 != map.size()) {
            for (Map.Entry<String, BeanInterface> entry : map.entrySet()) {
                System.out.println(entry.getKey() + "      " + entry.getValue().getClass().getName());
            }
        } else {
            System.out.println("map is null !");
        }
    }
}

Testklasse TestInjection:

@RunWith(BlockJUnit4ClassRunner.class)
public class TestInjection extends UnitTestBase {

    public TestInjection() {
        super("classpath:spring-beanannotation.xml");
    }

    @Test
    public void testMultiBean() {
        BeanInvoker invoker = super.getBean("beanInvoker");
        invoker.say();
    }

}

首先，我们清楚BeanImplOne类和BeanImplTwo类是实现了BeanInterface接口的，在BeanInvoker类里面我们定义了list和map，我们通过@Autowired注解把BeanImplOne类和BeanImplTwo类注解进入其中。那么怎么证实是@Autowired注解把这两个类注入到list或者map中的呢？那么请看if循环语句和foreach循环打印，通过这个逻辑判断，如果能够打印出BeanImplOne类和BeanImplTwo类的路径名，就说明这样是可以的。如果有些小伙伴可能不信，那么可以试着不使用@Autowired注解，看结果怎么样。

测试类没有什么好说的，各位小伙伴有没有注意到@Order注解呢？这里需要解释的就是，如果在@Order注解里面输入执行的数字，比如1或者2，那么打印出来的路径名就会按顺序，也就是说通过指定@Order注解的内容可以实现优先级的功能。

5.@ImportResource注解引入一个资源，对应一个xml文件

6.@Value注解从资源文件中，取出它的key并赋值给当前类的成员变量

案例：@ImportResource和@Value用法分析：

MyDriverManager类：

public class MyDriverManager {

    public MyDriverManager(String url, String userName, String password) {
        System.out.println("url : " + url);
        System.out.println("userName: " + userName);
        System.out.println("password: " + password);
    }

}

config.xml:

<context:property-placeholder location="classpath:/config.properties"/>

StoreConfig类:

@Configuration
@ImportResource("classpath:config.xml")
public class StoreConfig {

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Bean
    public MyDriverManager myDriverManager() {
        return new MyDriverManager(url, username, password);
    }

这个案例我们使用注解配置jdbc数据库的连接，首先创建一个内含构造器的MyDriverManager类，然后配置config.xml里面的资源文件路径，以便@ImportResource注解获取，最后配置StoreConfig类。（注意url、username、password也必须要和数据库的保持一致哦）

详解StoreConfig类：首先我们定义三个成员变量，然后给每一个成员变量打上一个@value注解，注意@value里面的内容一定是资源文件里面的key值。这里的@ImportResource注解就是指明一个资源文件，在这个资源文件里面获取到对应的数据。那么@Configuration注解是用来干嘛的呢？为什么不用@Component注解呢？其实是这样的，@Component注解用于将所标注的类加载到 Spring 环境中，这时候是需要配置component-scan才能使用的，而@Configuration注解是Spring 3.X后提供的注解，它用于取代XML来配置 Spring。

7.@Bean注解用来标识配置和初始化一个由SpringIOC容器管理的新对象的方法，类似XML中配置文件的

ps:默认的@Bean注解是单例的，那么有什么方式可以指定它的范围呢？所以这里才出现了@Scope注解

8.@Scope注解，在@Scope注解里面value的范围和Bean的作用域是通用的，proxyMode的属性是采用哪一种的单例方式（一种是基于接口的注解，一种是基于类的代理）

案例：@Bean和@Scope用法分析：

    @Bean
    @Scope(value ="session",proxyMode = "scopedProxyMode.TARGET_CLASS")
    public UserPreferences userPreferences(){
        return new userPreferences();
    }

    @Bean
    public service userService(){
        UserService service =new SimpleUserService();
        service.setUserPreferences(userPreferences);
        return service;
    }

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendungscodebeispiele von Spring-Framework-Anmerkungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!