2.IOC概念及使用xml管理Bean

企业开发 2023-04-09 05:15:18 阅读次数: 0

1. IOC底层原理

1.1 什么是IOC

（1）控制反转缩写为IOC，把对象创建和对象之间的调用过程，交给Spring管理

（2）使用IOC目的：为了降低耦合度

1.2 底层原理

（1）xml解析

image-20201123142122496

（2）工厂模式

image-20201116205357407

（3）反射

image-20201123142517518

2. IOC接口（BeanFactory）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

Spring中提供IOC容器实现的两种方式：

  • BeanFactory

    IOC容器基本实现，是Spring内部的使用接口，开发中一般不去使用

    特点：加载配置文件时不创建对象，在获取对象（使用）时才去创建对象

  • ApplicationContext

    BeanFactory接口的子接口，比BeanFactory提供了更多更强大的功能，一般由开发人员进行使用

    特点：加载配置文件的时候就会把在配置文件中的对象进行创建

  • ApplicationContext接口有实现类

    image-20201123161657302

3. IOC操作Bean管理

Bean管理指的是两个操作：

  1. Spring创建对象
  2. Spring注入属性

3.1 基于xml管理Bean

以下所有示例代码中xml及properties配置文件都放置于src目录下

3.1.1 基于xml创建对象

  1. 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
  2. bean标签的属性：
    • id：唯一标识
    • class：类全路径
    • name：可以加入特殊符号的name（不推荐使用，用id替代）
  3. 创建对象的时候，默认使用无参构造方法完成对象创建

java类

public class User {
    
    

    public void add() {
    
    
        System.out.println("调用了add方法");
    }
}

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

    <!-- 配置User类对象的创建 -->
    <bean id="user" class="com.study.spring5.User"></bean>
</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        // 1. 加载spring配置文件
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2. 获取配置创建的对象
        User user = applicationContext.getBean("user", User.class);
        // 3. 调用对象方法
        user.add();
    }
}

3.1.2 基于xml方式注入属性

  1. DI：依赖注入，就是注入属性

    DI是IOC的一种实现

  2. 注入方式：

    • 使用set方法进行注入
    • 使用有参构造进行注入

  3. 使用spring的xml方式注入

3.1.2.1 通过set方法注入

java类

public class User {
    
    

    private String name;

    public void add() {
    
    
        System.out.println("调用了add方法");
    }

    public String getName() {
    
    
        return name;
    }

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

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

    <!-- 配置User类对象的创建 -->
    <bean id="user" class="com.study.spring5.User">
        <property name="name" value="小明"/>
    </bean>
</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        // 1. 加载spring配置文件
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2. 获取配置创建的对象
        User user = applicationContext.getBean("user", User.class);
        // 3. 调用对象方法
        user.add();

        // 4. 查看注入的属性内容
        System.out.println(user.getName());
    }
}

3.1.2.2 通过构造方法注入

java类

public class Department {
    
    

    private String deptName;

    public Department() {
    
    
    }

    public Department(String deptName) {
    
    
        this.deptName = deptName;
    }

    @Override
    public String toString() {
    
    
        return "Dept{" +
                "deptName='" + deptName + '\'' +
                '}';
    }
}

xml配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置Department类对象的创建 -->
    <bean id="department" class="com.study.spring5.Department">
        <constructor-arg name="deptName" value="研发部"/>
    </bean>

</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        // 1. 加载spring配置文件
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean1.xml");
		// 2. 获取配置创建的对象
        Department department = applicationContext.getBean("department", Department.class);
        // 3. 查看注入的属性内容
        System.out.println(department);
    }
}

3.1.2.3 通过p名称空间注入

xml配置文件中添加p名称空间

<?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">

bean标签为

<bean id="user" class="com.study.spring5.User" p:name="小明"/>

3.1.2.4 注入空值和特殊符号

java类

public class User {
    
    

    private String name;

    private String add;

    public void add() {
    
    
        System.out.println("调用了add方法");
    }

    public String getName() {
    
    
        return name;
    }

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

    public String getAdd() {
    
    
        return add;
    }

    public void setAdd(String add) {
    
    
        this.add = add;
    }

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

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

    <!-- 配置User类对象的创建 -->
    <bean id="user" class="com.study.spring5.User">
        <property name="name" value="小明"/>
        <!-- 向这个属性中设置一个空值 -->
        <property name="address">
            <null/>
        </property>
    </bean>
</beans>

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">

    <!-- 配置User类对象的创建 -->
    <bean id="user" class="com.study.spring5.User">
        <property name="name" value="小明"/>

        <!-- 属性中包含<>特殊符号
             方法1：使用&lt;&gt;进行转义
             方法2：把带特殊符号的内容写到CDATA中
         -->
        <property name="address">
            <value><![CDATA[<山东>]]></value>
        </property>
    </bean>
</beans>

3.1.2.5 注入外部Bean

创建service和dao包，分别创建UserDao、UserDaoImpl和UserService，service需要调用dao

UserDao

public interface UserDao {
    
    

    void add();
}

UserDaoImpl

public class UserDaoImpl implements UserDao {
    
    

    @Override
    public void add() {
    
    
        System.out.println("dao层add()方法");
    }
}

UserService

public class UserService {
    
    

    private UserDao userDao;

    public void add() {
    
    
        System.out.println("service层add()方法");
        userDao.add();
    }

    public UserDao getUserDao() {
    
    
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
    
    
        this.userDao = userDao;
    }
}

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

    <!-- 1. 创建dao对象 -->
    <bean id="userDao" class="com.study.spring5.demo02.dao.UserDaoImpl"/>

    <!-- 2. 创建service，并且注入dao对象 -->
    <bean id="userService" class="com.study.spring5.demo02.service.UserService">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        // 1. 加载spring配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2.xml");
        // 2. 获取配置创建的对象
        UserService userService = applicationContext.getBean("userService", UserService.class);
        // 3. 调用对象方法
        userService.add();
    }
}

3.1.2.6 注入内部bean和级联赋值

（1）一对多关系：部门跟员工

一个部门拥有多个员工

部门类Dept

public class Dept {
    
    

    private String dName;

    public String getdName() {
    
    
        return dName;
    }

    public void setdName(String dName) {
    
    
        this.dName = dName;
    }

    @Override
    public String toString() {
    
    
        return "Dept{" +
                "dName='" + dName + '\'' +
                '}';
    }
}

Emp员工类

public class Emp {
    
    

    private String eName;

    private String gender;

    // 员工属于一个部门
    private Dept dept;

    public String geteName() {
    
    
        return eName;
    }

    public void seteName(String eName) {
    
    
        this.eName = eName;
    }

    public String getGender() {
    
    
        return gender;
    }

    public void setGender(String gender) {
    
    
        this.gender = gender;
    }

    public Dept getDept() {
    
    
        return dept;
    }

    public void setDept(Dept dept) {
    
    
        this.dept = dept;
    }

    @Override
    public String toString() {
    
    
        return "Emp{" +
                "eName='" + eName + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

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

    <!-- 1. 创建Emp对象 -->
    <bean id="emp" class="com.study.spring5.demo03.bean.Emp">
        <property name="eName" value="杰克王"/>
        <property name="gender" value="男"/>
        <property name="dept">
            <bean id="dept" class="com.study.spring5.demo03.bean.Dept">
                <property name="dName" value="市场部"/>
            </bean>
        </property>
                <!-- 也可以使用以下形式 -->
<!--        <property name="dept.dName" value="市场部"/>-->
    </bean>

</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        // 1. 加载spring配置文件
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean3.xml");
        // 2. 获取配置创建的对象
        Emp emp = applicationContext.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

3.1.2.7 注入集合类型

Student学生类

public class Student {
    
    

    private String[] courses;

    private List<String> list;

    private Map<String, String> map;

    public String[] getCourses() {
    
    
        return courses;
    }

    public void setCourses(String[] courses) {
    
    
        this.courses = courses;
    }

    public List<String> getList() {
    
    
        return list;
    }

    public void setList(List<String> list) {
    
    
        this.list = list;
    }

    public Map<String, String> getMap() {
    
    
        return map;
    }

    public void setMap(Map<String, String> map) {
    
    
        this.map = map;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "courses=" + Arrays.toString(courses) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

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

    <!-- 1. 创建Student对象 -->
    <bean id="student" class="com.study.spring5.demo04.Student">
        <property name="courses">
            <!-- list或者array标签均可 -->
            <list>
                <value>语文</value>
                <value>数学</value>
                <value>英语</value>
            </list>
        </property>

<!--        <property name="list" value="list1, list2, list3"></property>-->

<!--        <property name="list">-->
<!--            <value>list1, list2, list3</value>-->
<!--        </property>-->

        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>

        <property name="map">
            <map>
                <entry key="key1" value="value1"/>
                <entry key="key2" value="value2"/>
                <entry key="key3" value="value3"/>
            </map>
        </property>

    </bean>

</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean4.xml");
        Student student = applicationContext.getBean("student", Student.class);
        System.out.println(student);
    }
}

3.1.2.8 在集合里面设置对象类型值

Course课程类

public class Course {
    
    

    private String courseName;

    public Course() {
    
    
    }

    public Course(String courseName) {
    
    
        this.courseName = courseName;
    }

    public String getCourseName() {
    
    
        return courseName;
    }

    public void setCourseName(String courseName) {
    
    
        this.courseName = courseName;
    }

    @Override
    public String toString() {
    
    
        return "Course{" +
                "courseName='" + courseName + '\'' +
                '}';
    }
}

Student学生类

public class Student {
    
    

    private List<Course> courseList;

    public List<Course> getCourseList() {
    
    
        return courseList;
    }

    public void setCourseList(List<Course> courseList) {
    
    
        this.courseList = courseList;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "courseList=" + courseList +
                '}';
    }
    
}

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

    <!-- 1. 创建Student对象 -->
    <bean id="student" class="com.study.spring5.demo04.Student">

        <!-- 注入list集合类型，值是对象 -->
        <property name="courseList">
            <list>
                <!-- 注入第一个course对象 -->
                <ref bean="course1"/>
                <!-- 注入第二个course对象 -->
                <ref bean="course2"/>
            </list>
        </property>

    </bean>

    <!-- 2. 创建多个Course对象 -->
    <bean id="course1" class="com.study.spring5.demo04.Course">
        <property name="courseName" value="java"/>
    </bean>

    <bean id="course2" class="com.study.spring5.demo04.Course">
        <property name="courseName" value="spring"/>
    </bean>

</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean4.xml");
        Student student = applicationContext.getBean("student", Student.class);
        System.out.println(student);
    }
}

3.1.2.9 提取集合注入部分

（1）在spring配置文件中引入名称空间 util

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

</beans>

（2）使用util标签完成list集合注入提取并使用

Book图书类

public class Book {
    
    

    private List<String> list;

    public List<String> getList() {
    
    
        return list;
    }

    public void setList(List<String> list) {
    
    
        this.list = list;
    }

    @Override
    public String toString() {
    
    
        return "Book{" +
                "list=" + list +
                '}';
    }
}

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

    <!-- 1. 提取list集合类型属性注入 -->
    <util:list id="bookList">
        <value>java入门</value>
        <value>spring入门</value>
        <value>springmvc入门</value>
    </util:list>

    <!-- 2. 提取list集合类型属性注入使用 -->
    <bean id="book" class="com.study.spring5.demo05.Book">
        <property name="list" ref="bookList"/>
    </bean>

</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean5.xml");
        Book book = applicationContext.getBean("book", Book.class);
        System.out.println(book);
    }
}

3.2 FactoryBean

Spring有两种类型，一种普通bean，另外一种称为工厂bean（FactoryBean）

  • 普通bean

    在spring配置文件中，定义的bean类型就是返回类型

  • 工厂bean

    在配置文件定义bean类型可以和返回类型不一样

    第一步：创建一个类，让这个类作为工厂bean，实现接口FactoryBean

    第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型

    MyBean类

    public class MyBean {
      
      

    private String str;

    public MyBean() {
      
      
    }

    public MyBean(String str) {
      
      
        this.str = str;
    }

    public String getStr() {
      
      
        return str;
    }

    public void setStr(String str) {
      
      
        this.str = str;
    }

    @Override
    public String toString() {
      
      
        return "MyBean{" +
                "str='" + str + '\'' +
                '}';
    }
}

    MyFactoryBean

    public class MyFactoryBean implements FactoryBean<MyBean> {
      
      

    // 定义返回的bean
    @Override
    public MyBean getObject() throws Exception {
      
      
        MyBean myBean = new MyBean();
        myBean.setStr("MyFactoryBean::getObject方法中返回的对象");
        return myBean;
    }

    @Override
    public Class<?> getObjectType() {
      
      
        return null;
    }
}

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


    <bean id="myBean" class="com.study.spring5.demo06.MyBean">
        <property name="str" value="字符串"/>
    </bean>

    <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean"/>


</beans>

    主方法

    public class Main {
      
      

    public static void main(String[] args) {
      
      
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean6.xml");
        MyBean myBean = applicationContext.getBean("myBean", MyBean.class);
        System.out.println(myBean);

        // 会报错
        //Bean named 'myFactoryBean' is expected to be of type 'com.study.spring5.demo06.MyFactoryBean'
        // but was actually of type 'com.study.spring5.demo06.MyBean'
//        MyFactoryBean myFactoryBean = applicationContext.getBean("myFactoryBean", MyFactoryBean.class);
//        System.out.println(myFactoryBean);

        MyBean myBean1 = applicationContext.getBean("myFactoryBean", MyBean.class);
        System.out.println(myBean1);
    }
}

3.3 bean的作用域

在Spring里面，可以设置创建的bean实例是单实例还是多实例的。默认情况下bean为单实例对象。

设置单实例和多实例方法：

  1. 通过xml配置文件bean标签中的scope属性，scope属性有两个常用值

    （1）singleton：表示创建对象时为单实例对象

    （2）prototype：表示创建对象时为多实例对象

    （3）singleton和prototype的区别

    ​ singleton表示单实例，prototype表示多实例

    ​ 设置scope值为singleton时，加载spring配置文件的时候就会创建一个单实例对象

    ​ 设置scope值为prototype时，不是在加载spring配置文件时创建对象，而是在调用getBean方法时创建多实例对象

  2. 实现FactoryBean接口重写isSingleton()方法

注意：实现接口重写方法的优先级大于通过xml配置文件bean标签中的scope属性

MyFactory类

public class MyFactoryBean implements FactoryBean<MyBean> {
    
    

    // 定义返回的bean
    @Override
    public MyBean getObject() throws Exception {
    
    
        MyBean myBean = new MyBean();
        myBean.setStr("MyFactoryBean::getObject方法中返回的对象");
        return myBean;
    }

    @Override
    public Class<?> getObjectType() {
    
    
        return null;
    }

    @Override
    public boolean isSingleton() {
    
    
        // 这里返回true时，创建的对象为单实例，返回false时，为多实例
        return false;
    }
}

MyBean类

public class MyBean {
    
    

    private String str;

    public MyBean() {
    
    
    }

    public MyBean(String str) {
    
    
        this.str = str;
    }

    public String getStr() {
    
    
        return str;
    }

    public void setStr(String str) {
    
    
        this.str = str;
    }

    @Override
    public String toString() {
    
    
        return "MyBean{" +
                "str='" + str + '\'' +
                '}';
    }
}

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


    <bean id="myBean" class="com.study.spring5.demo06.MyBean">
        <property name="str" value="字符串"/>
    </bean>

    <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean"/>
    <!-- 也可以通过 bean标签中的scope属性进行设置 不过优先级低于实现接口重写isSingleton()方法 -->
<!--    <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean" scope="singleton"/>-->
<!--    <bean id="myFactoryBean" class="com.study.spring5.demo06.MyFactoryBean" scope="prototype"/>-->
    
</beans>

主方法

public class Main {
    
    

    public static void main(String[] args) {
    
    
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean6.xml");

        MyBean myBean1 = applicationContext.getBean("myFactoryBean", MyBean.class);
        System.out.println(myBean1);

        MyBean myBean2 = applicationContext.getBean("myFactoryBean", MyBean.class);

        if (myBean1 == myBean2) {
    
    
            System.out.println("单实例模式创建");
        } else {
    
    
            System.out.println("多实例模式创建");
        }
    }
}

3.4 bean的生命周期

  1. 生命周期：

    （1）从对象创建到对象销毁的过程

  2. bean的生命周期

    （1）通过构造器创建bean实例（无参数构造）

    （2）为bean的属性设置值和对其他bean的引用（调用set方法）

    （3）调用bean的初始化方法（需要配置初始化的方法）

    （4）bean可以使用（获取到对象）

    （5）当容器关闭时候，调用bean的销毁的方法（需要配置销毁的方法）

  3. 演示bean的生命周期

    Order类

    public class Order {
      
      

    private String orderName;

    public Order() {
      
      
        System.out.println("第一步 执行无参构造方法创建bean实例");
    }

    public String getOrderName() {
      
      
        return orderName;
    }

    public void setOrderName(String orderName) {
      
      
        this.orderName = orderName;
        System.out.println("第二步 调用set方法设置属性值");
    }

    // 创建执行的初始化方法
    public void initMethod() {
      
      
        System.out.println("第三步 执行初始化方法");
    }

    // 创建执行的销毁方法
    public void destoryMethod() {
      
      
        System.out.println("第五步 执行销毁方法");
    }
}

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

    <!-- init-method属性用来指定初始化方法 destroy-method属性用来指定销毁方法-->
    <bean id="order" class="com.study.spring5.demo07.Order" init-method="initMethod"
          destroy-method="destoryMethod">
        <property name="orderName" value="小米10"/>
    </bean>

</beans>

    主方法

    public class Main {
      
      

    public static void main(String[] args) {
      
      
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean7.xml");
        Order order = applicationContext.getBean("order", Order.class);
        System.out.println("第四步 获取到创建的对象" + order);
        // 手动让bean实例销毁
        ((ClassPathXmlApplicationContext) applicationContext).close();
    }
}

  4. bean的后置处理器

    bean的生命周期中，步骤三中还可以进行拆分

    （1）通过构造器创建bean实例（无参数构造）

    （2）为bean的属性设置值和对其他bean的引用（调用set方法）

    （3-1）把bean实例传递给bean后置处理器

    （3-2）调用bean的初始化方法（需要配置初始化的方法）

    （3-3）把bean实例传递给bean后置处理器

    （4）bean可以使用（获取到对象）

    （5）当容器关闭时候，调用bean的销毁的方法（需要配置销毁的方法）

    添加后置处理器

    （1）创建一个类，实现BeanPostProcessor接口，创建后置处理器

    public class MyBeanPostProcessor implements BeanPostProcessor {
      
      

    // 初始化前执行的方法
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      
      
        System.out.println("初始化前执行的方法");
        return bean;
    }

    // 初始化后执行的方法
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      
      
        System.out.println("初始化后执行的方法");
        return bean;
    }
}

    （2）修改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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- init-method属性用来指定初始化方法 destroy-method属性用来指定销毁方法-->
    <bean id="order" class="com.study.spring5.demo07.Order" init-method="initMethod"
          destroy-method="destoryMethod">
        <property name="orderName" value="小米10"/>
    </bean>

    <!-- 配置后置处理器 -->
    <bean id="myBeanPostProcessor" class="com.study.spring5.demo07.MyBeanPostProcessor"/>

</beans>

3.5 xml自动装配

  1. 什么是自动装配

    根据指定的装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

  2. 演示自动装配

    （1）根据属性名称进行自动装配

    Emp类

    public class Emp {
      
      

    private Dept dept;

    public Dept getDept() {
      
      
        return dept;
    }

    public void setDept(Dept dept) {
      
      
        this.dept = dept;
    }

    @Override
    public String toString() {
      
      
        return "Emp{" +
                "dept=" + dept +
                '}';
    }
}

    Dept类

    public class Dept {
      
      

    @Override
    public String toString() {
      
      
        return "Dept{}";
    }
}

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

    <bean id="dept" class="com.study.spring5.demo08.Dept"/>

    <!--
        实现自动装配
        bean标签autowire，配置自动装配
        autowire属性常用两个值：
            byName：根据属性名称进行注入，注入值bean的id的值和类属性的名称要一致
            byType：根据属性类型进行注入
     -->
    <bean id="emp" class="com.study.spring5.demo08.Emp" autowire="byName"/>
</beans>

    主方法

    public class Main {
      
      

    public static void main(String[] args) {
      
      
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean8.xml");
        Emp emp = applicationContext.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

3.6 外部属性文件

  1. 直接配置数据库信息

    （1）配置连接池

    （2）引入druid连接池jar包和mysql连接jar包

    image-20201216165501107

    （3）编写配置文件进行测试

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

    <!-- 直接配置druid连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/sys"/>
        <property name="username" value="root"/>
        <property name="password" value="admin"/>
    </bean>
</beans>

    主方法

    public class Main {
      
      

    public static void main(String[] args) throws SQLException {
      
      
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean9.xml");
        DruidDataSource dataSource = applicationContext.getBean("dataSource", DruidDataSource.class);
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection + "连接创建成功");
    }
}

  2. 引入外部属性文件配置数据库连接池

    （1）创建jdbc.properties外部属性文件，写入数据库信息

    mysql.driverClassName=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/sys
mysql.username=root
mysql.password=admin

    （2）把外部properties属性文件引入到spring配置文件中

    ​ 引入context名称空间

    <?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:util="http://www.springframework.org/schema/util"
       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">
</beans>

    （3）在spring配置文件中使用标签引入外部属性文件，并修改相应值

    <?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:util="http://www.springframework.org/schema/util"
       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">

    <!-- 引入外部属性标签 -->
    <context:property-placeholder location="jdbc.properties"/>

    <!-- 直接配置druid连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mysql.driverClassName}"/>
        <property name="url" value="${mysql.url}"/>
        <property name="username" value="${mysql.username}"/>
        <property name="password" value="${mysql.password}"/>
    </bean>
</beans>

    （4）进行测试

    public class Main {
      
      

    public static void main(String[] args) throws SQLException {
      
      
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean9.xml");
        DruidDataSource dataSource = applicationContext.getBean("dataSource", DruidDataSource.class);
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection + "连接创建成功");
        connection.close();
    }
}

猜你喜欢

转载自blog.csdn.net/guo_ridgepole/article/details/111467427
今日推荐
Linus “吃狗粮”最积极！
开源日报 | Winamp播放器即将开源；生成式AI之战升级第二轮；Linus“吃狗粮”最积极；AI进入泡沫前期；吴泳铭为阿里云带来了什么？
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
周排行
LogN级别的区间查询算法(线段树), 你学会了吗
数论概论(英文版.第4版)
idea 更新后和新的直接安装前，都需要配置 idea64.exe.vmoptions 后再使用
CANOpen系列教程04_CAN总线波特率、位时序、帧类型及格式说明
Java序列化基础
java排序算法整理
异常：org.apache.ibatis.reflection.ReflectionException
（算法练习）——二路归并排序
go 闭包函数
好程序员web前端技术分享媒体查询
每日归档
更多
2024-05-21(8)
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022