[Java知识库]【Spring】第二课 Spring框架的IOC的注解方式的使用

概念

在上一篇文章中对Spring框架的初步认识后，本文采用Java注解的方式对Spring框架IOC的新的认识。

1.搭建项目环境

打开IEDA开发软件，创建web application项目,导入Spring框架的jar包至WEB-INF的lib文件夹中，并关联至项目

将applicationContext.xml文件导入resources文件夹，并转换成资源文件夹 ，该步骤如果还未掌握的读者请查阅前面的文章。

2.注解方式操作IOC反转控制一

在src文件夹中创建包com.spring.entity和com.spring.test包，创建Student实体类和SpringTest测试类。

Student.java代码如下:

/**
?* @Component:java注解方式创建对象,用于创建普通的对象
?* @Controller:用于控制层中创建类的对象
?* @Service:用于业务逻辑层中创建类的对象
?* @Repository:用于数据访问层中创建类的对象
?* value：属性表示对象名
?*/

package com.spring.entity;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

/**
 * @Component:java注解方式创建对象,用于创建普通的对象
 * @Controller:用于控制层中创建类的对象
 * @Service:用于业务逻辑层中创建类的对象
 * @Repository:用于数据访问层中创建类的对象
 * value：属性表示对象名
 */

    //@Controller(value = "stu")
    //@Service(value = "stu")
    //@Repository(value = "stu")
@Component(value = "student")
public class Student {
    //@Value:用于给变量赋值
    @Value("徐述华")
    private String name;
    @Value("17")
    private int age;
    @Value("18188888888")
    private String phone;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

在applicationContext.xml文件中添加指向具备注解的Student类所在的包的路径

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<!--因为java代码想要操作Spring框架，就一定要经过主配置文件，
	但是因为注解的方式所创建的对象并不在主配置文件中，需要在运行的时候，
	将带有注解的所有对象进行加载至主配置文件，需要找到带有注解的类的对象-->
	<!--用于扫描指定的包中所有的类，是否具备java注解方式创建的对象-->
	<context:component-scan base-package="com.spring.entity"></context:component-scan>
</beans>

SpringTest.java代码如下

package com.spring.test;

import com.spring.entity.Student;
import com.spring.entity.Teacher;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void one(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student = ac.getBean("student", Student.class);
        System.out.println(student);
        System.out.println(student.getName()+"--"+student.getAge()+"--"+student.getPhone());

    }

    
}

新建Teacher类，将Student的对象引用赋值给Teacher类的全局变量

?//@Autowired:该注解表示将外置的类的对象赋值给该变量，
? ? //前提条件是创建的对象名称需要与该变量名必须保持一致
? ? //@Autowired
? ? //当创建的对象名称和该变量名不一致的时候，不能使用以上注解
? ? //可以用下面两个注解之一
? ? //@Qualifier(value = "stu")
? ? //@Resource(name = "stu")
? ?
? ? //init-method:指定某个方法，在对象被创建的时候执行
? ? //@PostConstruct:该注解的作用等价于init-method属性的作用
? ? //destroy-method:指定某个方法，在对象被销毁的时候执行
? ? //@PreDestroy:该注解的作用等价于destroy-method属性的作用

package com.spring.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

@Component(value = "teacher")
public class Teacher {
    @Value("余老师")
    private String name;
    @Value("18166666666")
    private String phone;
    //@Autowired:该注解表示将外置的类的对象赋值给该变量，
    //前提条件是创建的对象名称需要与该变量名必须保持一致
    //@Autowired
    //当创建的对象名称和该变量名不一致的时候，不能使用以上注解
    //可以用下面两个注解之一
    //@Qualifier(value = "stu")
    //@Resource(name = "stu")
    @Autowired
    private Student student;
    //init-method:指定某个方法，在对象被创建的时候执行
    //@PostConstruct:该注解的作用等价于init-method属性的作用
    //destroy-method:指定某个方法，在对象被销毁的时候执行
    //@PreDestroy:该注解的作用等价于destroy-method属性的作用

    public Teacher() {
        System.out.println("开始创建对象");
    }

    @PostConstruct
    public void init(){
        System.out.println("开始加载老师的数据");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("结束老师对象的使用，释放内存");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

通过单元测试的方法结果如下:

package com.spring.test;

import com.spring.entity.Student;
import com.spring.entity.Teacher;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {


    @Test
    public void two(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        Teacher teacher = ac.getBean("teacher", Teacher.class);
        System.out.println(teacher.getName());
        System.out.println(teacher.getPhone());
        System.out.println(teacher.getStudent().getName()+"-"
                +teacher.getStudent().getAge()+"-"
                +teacher.getStudent().getPhone());
    }

    @Test
    public void three(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        Teacher teacher = ac.getBean("teacher", Teacher.class);
        //结束程序
        ((ClassPathXmlApplicationContext) ac).close();
    }
}

3.注解方式操作IOC反转控制二

以上方式中applicationContext.xml主配置文件中只作为指向注解方式的所有类的包名，有点小题大做，这里我们采用全注解的方式代替主配置文件。

在src文件夹中新建com.spring.utils包，创建SpringUtil类，代码如下：

@Configuration:该注解表示作为一个Spring框架的主配置文件
@ComponentScan:该注解表示要扫描的完整包的路径

package com.spring.utils;

import com.spring.entity.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import java.util.Date;

/**
 * 把该类作为替代xml的主配置文件
 * @Configuration:该注解表示作为一个Spring框架的主配置文件
 * @ComponentScan:该注解表示要扫描的完整包的路径
 */
@Configuration
@ComponentScan("com.spring.entity")
public class SpringUtil {

    

}

实体类Student.java代码如下:

@Scope(value = "prototype"):该注解用于描述创建对象时，使用多例模式

package com.spring.entity;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * @Scope(value = "prototype"):该注解用于描述创建对象时，使用多例模式
 */
@Component(value = "stu")
@Scope(value = "prototype")
public class Student {
    @Value("张三")
    private String name;
    @Value("20")
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

通过测试类的调用执行代码如下:

因为我们项目中没有xml的主配置文件，因此我们采用注解的方式来定义主配置文件

package com.spring.test;

import com.spring.entity.Student;
import com.spring.utils.SpringUtil;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.Date;

public class SpringTest {
    @Test
    public void one(){
        //1.首先要加载spring框架的主配置文件
        //但是因为我们项目中没有xml的主配置文件，因此我们采用注解的方式来定义主配置文件
        ApplicationContext ac=
                new AnnotationConfigApplicationContext(SpringUtil.class);
        Student stu = ac.getBean("stu", Student.class);
        System.out.println(stu.getName()+"--"+stu.getAge());
        System.out.println(stu);
        Student stu1 = ac.getBean("stu", Student.class);
        System.out.println(stu1);


    }


}

在SpringUtil.java类中可以使用@Bean注解间接创建对象，并且也遵守单例模式

//间接获得对象
    //@Scope(value = "prototype"):间接获得对象也能设置为单例模式还是多例模式
    @Bean(value = "v")
    public Student getStudent(){
        return new Student();
    }

    @Bean(value = "date")
    public Date getDate(){
        return new Date();
    }

测试类中执行代码如下:

@Test
    public void one(){
        //1.首先要加载spring框架的主配置文件
        //但是因为我们项目中没有xml的主配置文件，因此我们采用注解的方式来定义主配置文件
        ApplicationContext ac=
                new AnnotationConfigApplicationContext(SpringUtil.class);
        Student stu = ac.getBean("stu", Student.class);
        System.out.println(stu.getName()+"--"+stu.getAge());
        System.out.println(stu);
        Student stu1 = ac.getBean("stu", Student.class);
        System.out.println(stu1);


        //使用间接获得对象
        Student v = ac.getBean("v", Student.class);
        System.out.println(v.getName()+"--"+v.getAge());

        Date date = ac.getBean("date", Date.class);
        System.out.println(date);
    }

总结

Spring框架中重要的技术分为IOC和AOP技术，那么本文是对IOC的反转控制技术采用java注解的方式做了初略的讲解和描述，希望读者阅读完本文后，对Spring框架的注解方式操作项目有一定的认识。