package edu.tjdz.ba01;

import org.springframework.stereotype.Component;

/**
 * @Component：创建对象的，等同于<bean>的功能
 *      属性：value 就是对象的名称，也就是<bean>的id值，
 *  *          value的值是唯一的，创建的对象在整个spring容器中就一个
 *  *      位置：在类的上面
 *
 * @Component(value = "myStudent")等同于
 *    <bean id="myStudent" class="edu.tjdz.ba01.Student" />
 *
 * spring中和@Component功能一致，创建对象的注解还有：
 *  1.@Repository（用在持久层类的上面）：放在dao的实现类上面，dao对象是能访问数据库的。
 *  2.@Service（用在业务层类的上面）：放在service的实现类上面，
 *             创建service对象，service对象是做业务处理的，可以有事务等功能的。
 *  3.@Controller（用在控制器上面）：放在控制器（处理器）类的上面，创建控制器对象的，
 *             控制器对象，能够接受用户提交的参数，显示请求处理的结果。
 *  以上三个注解的使用语法和@Component一样的。都能创建对象，但是这三个注解还有额外的功能。
 *  @Repository，@Service，@Controller是给项目的对象分层的。
 */
//使用value属性，指定对象的名称
//@Component(value = "myStudent")

//省略value
@Component("myStudent")

//不指定对象的名称，由spring提供默认名称：类名的首字母小写
//@Component
public class Student {

    private String name;
    private Integer age;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

test.properties?

myname=王佳伟
myage=20

applicationContext.xml?

<?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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名
        component-scan工作方式：spring会扫描遍历base-package指定的包，
            把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

        加入了component-scan标签，配置文件的变化：
          1.加入一个新的约束文件spring-context.xsd
          2.给这个新的约束文件起个命名空间的名称
    -->
    <context:component-scan base-package="edu.tjdz.ba01" />

    <!--<bean id="myXueXiao" class="edu.tjdz.ba03.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京市"/>
    </bean>-->

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

</beans>

?MyTest

package edu.tjdz;

import edu.tjdz.ba01.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取对象
        Student student = (Student) ctx.getBean("myStudent");
        System.out.println("student="+student);
    }
}

2.02、@Value:给简单类型的属性赋值

Student类

package edu.tjdz.ba02;

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

@Component("myStudent")
public class Student {

    /**
     * @Value:简单类型的属性赋值
     *   属性：value 是String类型的，表示简单类型的属性值
     *   位置：1.在属性定义的上面，无需set方法，推荐使用。
     *        2.在set方法上面
     */
    @Value("张飞")
    private String name;
    private Integer age;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

applicationContext.xml?

<?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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名
        component-scan工作方式：spring会扫描遍历base-package指定的包，
            把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

        加入了component-scan标签，配置文件的变化：
          1.加入一个新的约束文件spring-context.xsd
          2.给这个新的约束文件起个命名空间的名称
    -->
    <context:component-scan base-package="edu.tjdz.ba01" />

    <!--<bean id="myXueXiao" class="edu.tjdz.ba03.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京市"/>
    </bean>-->

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

</beans>

MyTest.java?

package edu.tjdz;

import edu.tjdz.ba02.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest02 {

    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取对象
        Student student = (Student) ctx.getBean("myStudent");
        System.out.println("student="+student);
    }
}

3.03、@Autowired:引用类型的自动注入

默认使用的是byType自动注入机制：

①:接口的实现

②：引用类型和bean的class值一样

③：引用类型数据和bean的class值是父子关系

Student类

package edu.tjdz.ba03;

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

@Component("myStudent")
public class Student {

    /**
     * @Value:简单类型的属性赋值
     *   属性：value 是String类型的，表示简单类型的属性值
     *   位置：1.在属性定义的上面，无需set方法，推荐使用。
     *        2.在set方法上面
     */
    @Value("张飞")
    private String name;
    private Integer age;


    /**
     * 引用类型
     * @Autowired：spring框架提供的注解，实现引用类型的赋值。
     * spring中通过注解给引用类型赋值，使用的是自动注入原则，支持byName，byType
     *
     * @Autowired：默认使用的是byType自动注入。
     *
     * 位置：1）在属性sing已的上面，无需set方法，推荐使用
     *      2）在set方法上面
     */
    @Autowired
    private School school;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

?School类

package edu.tjdz.ba03;

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

//@Component("mySchool")
public class School {

    //@Value("天津大学")
    private String name;
    //@Value("天津市")
    private String address;

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

?4.04、若想要按名称注入byName，则需要加入注解@Qualifier（value =? "名称"）完成按名称注入

Stduent类

package edu.tjdz.ba04;

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;

@Component("myStudent")
public class Student {

    /**
     * @Value:简单类型的属性赋值
     *   属性：value 是String类型的，表示简单类型的属性值
     *   位置：1.在属性定义的上面，无需set方法，推荐使用。
     *        2.在set方法上面
     */
    @Value("张飞")
    private String name;
    private Integer age;


    /**
     * 引用类型
     * @Autowired：spring框架提供的注解，实现引用类型的赋值。
     * spring中通过注解给引用类型赋值，使用的是自动注入原则，支持byName，byType
     *
     * @Autowired：默认使用的是byType自动注入。
     *
     * 位置：1）在属性sing已的上面，无需set方法，推荐使用
     *      2）在set方法上面
     *
     *   如果要使用byName方式，需要做的是：
     *    1.在属性上面加入@Autowired
     *    2.在属性的上面加入@Qualifier(value="bean的id")：表示使用指定名称的bean完成赋值
     */

    //byName自动注入
    @Autowired
    @Qualifier("mySchool")
    private School school;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

School类

package edu.tjdz.ba04;

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

@Component("mySchool")
public class School {

    @Value("中国国防大学")
    private String name;
    @Value("天津市")
    private String address;

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

?5.05、关于@Autowired注解的required属性的值

required的值为一个布尔值：

当它的值是true的时候：表示引用类型赋值失败的时候，程序报错，终止执行。

当值为false时：表示程序引用类型赋值失败的时候，程序正常执行，引用类型为null

Student类

package edu.tjdz.ba05;

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;

@Component("myStudent")
public class Student {

    /**
     * @Value:简单类型的属性赋值
     *   属性：value 是String类型的，表示简单类型的属性值
     *   位置：1.在属性定义的上面，无需set方法，推荐使用。
     *        2.在set方法上面
     */
    @Value("张飞")
    private String name;
    private Integer age;


    /**
     * 引用类型
     * @Autowired：spring框架提供的注解，实现引用类型的赋值。
     * spring中通过注解给引用类型赋值，使用的是自动注入原则，支持byName，byType
     * @Autowired：默认使用的是byType自动注入。
     *
     *  属性：required，是一个boolean类型的，默认是true
     *      required=true：表示引用类型赋值失败，程序报错，终止执行
     *      required=false：引用类型如果赋值失败，程序正常执行，引用类型是null
     *
     * 位置：1）在属性sing已的上面，无需set方法，推荐使用
     *      2）在set方法上面
     *
     *   如果要使用byName方式，需要做的是：
     *    1.在属性上面加入@Autowired
     *    2.在属性的上面加入@Qualifier(value="bean的id")：表示使用指定名称的bean完成赋值
     */

    //byName自动注入
    @Autowired(required = true)
    @Qualifier("mySchool-1")
    private School school;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

School类

package edu.tjdz.ba05;

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

@Component("mySchool")
public class School {

    @Value("中国国防大学")
    private String name;
    @Value("天津市")
    private String address;

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

6.06、@Resource：先按名称(byName)完成注入，在按类型(byType)完成注入

Student类

package edu.tjdz.ba06;

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

import javax.annotation.Resource;


@Component("myStudent")
public class Student {

    @Value("张飞")
    private String name;
    private Integer age;

    /**
     * 引用类型
     * @Resource:来自JDK的注解，Spring框架提供了对这个注解的功能支持，可以使用它给引用类型赋值
     *           使用的也是自动注入原则，支持byName，byType，默认byName
     *   位置：1.在属性定义上面，无需set方法，推荐使用。
     *        2.在set方法上面
     *
     */
    //默认是byName：先使用byName自动注入，如果byName赋值失败，在使用byType
    @Resource
    private School school;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

School类?

package edu.tjdz.ba06;

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

@Component("mySchool")
public class School {

    @Value("中国国防大学")
    private String name;
    @Value("北京市")
    private String address;

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

?7.07如果想让@Resource注解只按名称注入，只需要使用其属性name = "值为bean的id值"

Stduent类

package edu.tjdz.ba07;

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

import javax.annotation.Resource;


@Component("myStudent")
public class Student {

    //@Value("张飞")
    @Value("${myname}")
    private String name;
    @Value("${myage}")
    private Integer age;

    /**
     * 引用类型
     * @Resource:来自JDK的注解，Spring框架提供了对这个注解的功能支持，可以使用它给引用类型赋值
     *           使用的也是自动注入原则，支持byName，byType，默认byName
     *   位置：1.在属性定义上面，无需set方法，推荐使用。
     *        2.在set方法上面
     *
     * @Resource:只能使用byName的方式，需要增加一个属性 name
     *  name的值是bean的id
     *
     */
    @Resource(name = "mySchool")
    private School school;

    public Student() {
        System.out.println("Student`s not param start");
    }

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

    public void setAge(Integer age) {
        System.out.println("setAge=="+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

School类

package edu.tjdz.ba07;

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

@Component("mySchool")
public class School {

    @Value("中国国防大学")
    private String name;
    @Value("北京市")
    private String address;

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

8.xml文件

?applicationContext.xml

<?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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名
        component-scan工作方式：spring会扫描遍历base-package指定的包，
            把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

        加入了component-scan标签，配置文件的变化：
          1.加入一个新的约束文件spring-context.xsd
          2.给这个新的约束文件起个命名空间的名称
    -->
    <context:component-scan base-package="edu.tjdz.ba01" />

    <!--<bean id="myXueXiao" class="edu.tjdz.ba03.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京市"/>
    </bean>-->

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

</beans>

applicationContext-back.xml

<?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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名
        component-scan工作方式：spring会扫描遍历base-package指定的包，
            把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

        加入了component-scan标签，配置文件的变化：
          1.加入一个新的约束文件spring-context.xsd
          2.给这个新的约束文件起个命名空间的名称
    -->
    <context:component-scan base-package="edu.tjdz.ba01" />

    <!--指定多个包的三种方式-->
    <!--第一种方式：使用多次组件扫描器，指定不同的包-->
    <context:component-scan base-package="edu.tjdz.ba01" />
    <context:component-scan base-package="edu.tjdz.ba02" />

    <!--第二种方式：使用分隔符(;或,分割多个包)-->
    <context:component-scan base-package="edu.tjdz.ba01;edu.tjdz.ba02" />

    <!--第三种方式：指定父包-->
    <context:component-scan base-package="edu.tjdz"/>

</beans>