Spring--IOC容器的常用操作

小蔡coding
126 阅读4分钟

「这是我参与2022首次更文挑战的第14天，活动详情查看：2022首次更文挑战」

前言

路遥说，在一个平凡的世界里，人要承受一定的痛苦和不安。但只要相信个体奋斗的力量，坚定地与生存搏斗，就能过上想要的生活。

很喜欢《平凡的世界》的一句话，一直不断的鼓励我努力向前，也送个各位看到这个写的很烂的文章的人，共勉~

IOC操作Bean管理(基于XML)

什么是Bean？

每一个类实现了Bean的规范才可以由Spring来接管，那么Bean的规范是什么呢？

  • 必须是个公有(public)类
  • 有无参构造函数
  • 用公共方法暴露内部成员属性(getter,setter)

实现这样规范的类，被称为Java Bean。即是一种可重用的组件。

1. 什么是Bean管理

  • Bean 管理指的是两个操作
  • Spring 创建对象
  • Spring 注入属性

2. Bean 管理操作的两种方式

  • 基于xml配置文件方式实现
  • 基于注解方式实现

创建对象

(1) 在Spring配置文件中，使用Bean标签，标签里面添加对应属性，就可以实现对应对象创建

(2) 在Bean标签有很多属性，常用的属性：id、class、name

(3) 创建对象的时候，默认也是执行无参数构造方法

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

注入属性

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

第一种注入方式：使用set方法进行注入

(1) 创建类，定义属性和对应的set方法

 public class Book {
     private String bname;
     private String bauthor;
 
     public void setBname(String bname) {
         this.bname = bname;
     }
     public void setBauthor(String bauthor) {
         this.bauthor = bauthor;
     }
     public static void main(String[] args) {
         Book book = new Book();
         book.setBname("TestBook");
     }
 }

(2) 在Spring配置文件配置对象创建，配置属性注入

 <!--set方法注入属性-->
 <bean id="book" class="com.spring5.Book">
 <!--使用property完成属性注入
     name：类里面属性名称
     value：向属性注入的值
 -->
     <property name="bname" value="TestBook"></property>
     <property name="bauthor" value="TestAuthor"></property>
 </bean>

第二种注入方式：使用有参数构造进行注入

(1) 创建类，定义属性，创建属性对应有参数构造方法'

public class Orders {
    private String oname;
    private String address;
    public Orders(String oname, String address) { 
        this.oname = oname;
        this.address = address;
    }
}

(2) 在spring 配置文件中进行配置

    <!--    3有参构造注入属性-->    
<bean id="orders" class="com.caq.spring5.Orders">        <constructor-arg name="oname" value="美女">
    </constructor-arg>        
    <constructor-arg name="address" value="帅哥">
    </constructor-arg>    
</bean>

(3) 测试

@Testpublic void TestOrder(){
    //1.加载Spring配置文件    
    ApplicationContext context = new ClassPathXmlApplicationContext("base1.xml");
    //2.获取配置创建的对象    
    Orders orders = context.getBean("orders",Orders.class);    System.out.println(orders.toString());}

P名称空间注入（了解）

(1) 使用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 id="book" class="com.spring5.Book" p:bname="平凡的人生" p:bauthor="路遥"></bean>

注入字面量

(1) null值

<bean id="book" class="com.spring5.Book">
    <property name="bname" value="pyy"></property>    
    <property name="bauthor" value="pyy"></property>
    <property name="address">
        <null></null>
    </property></bean>

(2) 属性值包含特殊符号

//方法一：转义字符
<property name="address" value="&lt;北京&dt;"></property>
//方法二：CDATA
<property name="address">
    <value>    <![CDATA[<北京>]]>    </value>
</property>

(3 )注入外部bean（使用引用，注入其他类的对象）

(1) 创建两个类service类和dao类

(2) 在service调用dao类的方法

(3) 在spring配置文件中进行配置

package com.caq.spring5.dao;
public interface UserDao {
    public void update();
}

package com.caq.spring5.dao;
public class UserDaoImpl implements UserDao {
    @Override    
    public void update() {
        System.out.println("dao update!!!!!!!!!!!!!");
    }
}

package com.caq.spring5.service;
import com.caq.spring5.User;
import com.caq.spring5.dao.UserDao;
import com.caq.spring5.dao.UserDaoImpl;
public class UserService {
    //    创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao; 
    }   
    public void add(){ 
        System.out.println("add service!!!!!!!!!!!!!");
        //        创建UserDao对象(普通的方式实现)
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}

<?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.service和dao的对象创建-->
    <bean id="userService" class="com.caq.spring5.service.UserService">
        <!--        注入userDao对象-->
        <!--        name属性值：类里面属性名称 -->
        <!--        ref属性：创建userDao对象bean标签id值-->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <bean id="userDaoImpl" class="com.caq.spring5.dao.UserDaoImpl"></bean>
    <!--        注入userDao对象-->
    <!--        name属性值：类里面属性名称-->


</beans>

image-20220106122747592

再次回想上面所说，Spring就是将创建对象的操作交给IOC容器（体会到了工厂模式（中介）），通过XML解析获取要创建对象的信息中间也用到了反射，其实最后是通过反射来创建对象调用方法

(4)注入集合

  1. 注入数组类型属性
  2. 注入List集合类型属性
  3. 注入Map集合类型属性
  4. 注入集合元素是对象的集合

（1）创建类，定义数组、list、map、set类型属性，生成对应set方法

package com.caq.spring5.collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {

    private String[] courses;
    private List<String> list;
    private Map<String,String> maps;
    private Set<String> sets;
    private List<Course> courseList;

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

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

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

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(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">

    <bean id="stu" class="com.caq.spring5.collectiontype.Stu">
        <property name="courses">
            <array>
                <value>Java</value>
                <value>Mysql</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>张三</value>
                <value>唐浩</value>
            </list>
        </property>

        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>

        <property name="sets">
            <set>
                <value>Mysql</value>
                <value>Redis</value>
            </set>
        </property>
        
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    
    <bean id="course1" class="com.caq.spring5.collectiontype.Course">
        <property name="cname" value="Spring框架"></property>
    </bean>
    <bean id="course2" class="com.caq.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>

</beans>

测试代码

package com.caq.spring5.testdemo;

import com.caq.spring5.authwire.Emp;
import com.caq.spring5.bean.Orders;
import com.caq.spring5.collectiontype.Book;
import com.caq.spring5.collectiontype.Course;
import com.caq.spring5.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5Demo1 {
    @Test
    public void testCollection() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }

    @Test
    public void testCollection2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book = context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);
        book.test();
//        System.out.println(book);
//        System.out.println(book2);
    }

    @Test
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

    @Test
    public void testBean3() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(orders);

//        手动销毁bean实例
        context.close();
    }

    @Test
    public void testBean4() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);

//        手动销毁bean实例
        context.close();
    }
}

(5)把集合公共部分提取出来

<?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>Curry</value>
        <value>Kb</value>
        <value>Jordan</value>
    </util:list>

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

</beans>
avatar
文章
阅读
粉丝