02.自动注入,Bean生命周期,c3p0属性文件

自动注入、Bean生命周期、c3p0属性文件

一、抽象类注入

1、表示层（model）

案例：Person.java

/**
 * 抽象方法注入
 */
public abstract class Person {
   
    private String name;
    private String sex;
    
    public String getName() {
   
        return name;
    }
    public void setName(String name) {
   
        this.name = name;
    }

    public String getSex() {
   
        return sex;
    }

    public void setSex(String sex) {
   
        this.sex = sex;
    }

    // 普通方法
    public void ganfan(){
   
        System.out.println("悄悄地干饭");
    }

    // 抽象方法
    public abstract void working();
}

student.java

/**
 * 学生信息类
 */
public class Student extends Person{
   

    public Student() {
   
        System.out.println("学生的构造方法被执行了！");
    }

    @Override
    public void working() {
   
        System.out.println("认真学习");
    }
}

Teacher.java

public class Teacher extends Person{
   

    public Teacher() {
   
        System.out.println("老师的构造方法执行了");
    }

    @Override
    public void working() {
   
        System.out.println("老师工作");
    }
}

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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        primary:主要的，当一个抽象类拥有多个子类的时候，可以指定一个主要的类作为子类，创建对象时，优先使用该对象
        parent:可以继承其他配置
            *部分属性不被继承：abstract,autowire
        depends-on:我可以不依赖该Bean，跟给属性没有任何关系，但是SpringIOC容器中必须要有该Bean
        scope:bean的作用域
            ^singelton:单例
            prototype:非单例
    -->
    <bean name="p1" class="com.yl.model.Person" abstract="true" p:sex="女" p:name="张三"/>

    <bean name="t1" parent="p1" class="com.yl.model.Teacher" p:name="老刘老师" scope="singleton" primary="true"/>

    <bean name="s1" class="com.yl.model.Student" p:name="张秋丽" scope="prototype"/>
</beans>

测试类

import com.yl.model.Person;
import com.yl.model.Student;
import com.yl.model.Teacher;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestMethon {
   

    // 测试抽象类型注入
    @Test
    public void testMethon(){
   
        // 获取Spring的IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = context.getBean("p1", Person.class);
        System.out.println(p);
    }

    // 测试继承关系
    @Test
    public void testMethon1(){
   
        // 获取Spring的IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student st = ac.getBean(Student.class);
        Teacher tc = ac.getBean(Teacher.class);
        System.out.println(st.getSex()+"-------"+st.getName());
        System.out.println(tc.getSex()+"-------"+tc.getName());
    }

    // 测试作用域
    @Test
    public void testMethon2(){
   
        // 获取Spring的IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 当为单列模式的时候只进行一次查询，同一个对象，这里是存在容器中，值的改变不会影响
        Teacher t1 = ac.getBean(Teacher.class);
        Teacher t2 = ac.getBean(Teacher.class);
        System.out.println(t1.hashCode()+"****"+t2.hashCode()); // 2012846597****2012846597
        t2.setName("小老师");
        System.out.