IOC容器

控制反转(Inversion of Control),是面向对象编程中的一种设计原则,可以降低耦合度。包括依赖注入(Dependency Injection)、依赖查找(Dependency Lookup)。创建对象时,系统将其所依赖的对象的引用传递给自身。
在这里插入图片描述

原生的实现接口

java中实现一个接口功能,创建一个类来实现接口,我创建一个接口Dosomething,在创建一个Working类来实现这个接口。

public interface Dosomething {
    public void down();//实现某个功能
}
public class Working implements Dosomething{
    @Override
    public void down() {
        //实现接口功能
    }
}

在这里插入图片描述

工厂模式

创建一个第三者将接口和实现类关联起来

public class Do_cosplay{
    public void down()
    {
        System.out.println("模拟工厂模式\n");
    }
}

public class User_cosplay{//模拟用户类
public void execute(){
    Do_cosplay dosomething=Factory_cosplay.getDo_cosplay();
    dosomething.down();//实现
}
}

public class Factory_cosplay {//模拟工厂类
    public static Do_cosplay getDo_cosplay() {
        return new Do_cosplay();
    }
}

在这里插入图片描述

xml注解

spring提供IOC容器两种方式

  • BeanFactory
  • ApplicationContext
BeanFactoryApplicationContext
加载配置文件不创建对象,获取使用创建对象加载配置文件时创建配置文件
ClassPathXmlApplicationContext("");//对应src下的路径(相对路径)
FileSystemXmlApplicationContext("");//对应绝对路径

这个路径可以在ide改,但是可能会报错(ClassNotFoundException
在这里插入图片描述
推荐放在src目录下
在这里插入图片描述

bean无参注入

需要对象拥有无参的构造函数

基本属性

bean
id、class
class对应packge.class类、id对应唯一的对象标识(不是创建名)。
property
name、value
name对应set方法名(去掉set)、value对应set方法注入对象属性的值。

bean的创建销毁

需要配置。
init-method创建方法。
destroy-method销毁方法。

package bean_test;

public class User {
    private  String name,age,sex;

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

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

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void initmethod()
    {
        System.out.print("创建user");
    }
    public void destroymethod()
    {
        System.out.print("销毁user");
    }

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


配置文件(无参构造set注入)

<bean id="user01" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod">
    <property name="name" value="yma16" ></property>
    <property name="sex" value=""></property>
    <property name="age" value="18"></property>
</bean>
ApplicationContext context1= new ClassPathXmlApplicationContext("bean01.xml");
User user=context1.getBean("user01",User.class);
System.out.println(user);

无参注入成功!
在这里插入图片描述

bean的有参注入

需要有参的构造方法

constructor-arg标签

配置有参构造函数的参数属性

<bean id="" class="">
<constructor-arg name="" value=""></constructor-arg>
</bean>
bean的p命名空间

在bean标签中添加

xmlns:p="http://www.springframework.org/schema/p"

属性添加

p:属性=""

在User类添加一个有参构造函数

package bean_test;

public class User {
    private  String name,age,sex;
//    public User()
//    {
//        System.out.println("无参构造");
//    }
    public User(String name,String age,String sex)
    {
        this.name=name;
        this.age=age;
        this.sex=sex;
        System.out.println("有参构造");
    }
    public void setName(String name) {
        this.name = name;
    }

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

    public void setSex(String sex) {
        this.sex = sex;
    }
    public void initmethod()
    {
        System.out.print("创建user");
    }
    public void destroymethod()
    {
        System.out.print("销毁user");
    }

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

bean设置

<bean id="user02" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod">
<constructor-arg name="name" value="yma16_替身"></constructor-arg>
<constructor-arg name="sex" value=""></constructor-arg>
<constructor-arg name="age" value="16"></constructor-arg>
</bean>

有参注入成功!
在这里插入图片描述

bean注入特殊符号

字面量

private String name="yam16";//定值
null值和特殊符号< >

idea不允许直接粗暴的写<>
在这里插入图片描述

分别使用&lt;&gt;转义成<>

<property name="slog" value="&lt;yma16&gt;"></property>

在这里插入图片描述

使用CDATA

    <bean id="s01" class="bean_test.Strange">
            <property name="slog">
                <value>
                    <![CDATA[<yma16>]]>
                </value>
            </property>
        </bean>

在这里插入图片描述

注入外部bean

创建另一个类调用User对象

ref标签

链接bean的id
测试用例
使用创建一个Outbean类调用User类

package bean_test;

public class Outbean {
    public User userclass;//外部的user
    public String Oname;

    public void setUserclass(User userclass) {
        this.userclass = userclass;
    }

    public void setOname(String oname) {
        Oname = oname;
    }

    @Override
    public String toString() {
        return "Outbean{" +
                "userclass=" + userclass +
                ", Oname='" + Oname + '\'' +
                '}';
    }
}

bean的配置

    <bean id="Out01" class="bean_test.Outbean" init-method="initmethod" destroy-method="destroymethod">
        <property name="oname" value="测试1号"></property>
        <property name="userclass" ref="user_ref"></property>

    </bean>
    <bean id="user_ref" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod">
        <constructor-arg name="name" value="yma16_ref"></constructor-arg>
        <constructor-arg name="sex" value="男_ref"></constructor-arg>
        <constructor-arg name="age" value="16_ref"></constructor-arg>
    </bean>

在这里插入图片描述
外部bean测试完成!
在这里插入图片描述

array、set、map、list

创建一个Array_Listcase类并且创建array、set、map、list属性。

package bean_test;

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

public class Array_Listcase {
    public String[] array_case;
    public Map<String,String> map_case;
    public List<String> list_case;
    public Set<String> set_case;

    public void setArray_case(String[] array_case) {
        this.array_case = array_case;
    }

    public void setMap_case(Map<String, String> map_case) {
        this.map_case = map_case;
    }

    public void setList_case(List<String> list_case) {
        this.list_case = list_case;
    }

    public void setSet_case(Set<String> set_case) {
        this.set_case = set_case;
    }

    public void initmethod()
    {
        System.out.print("创建Outbean");
    }
    public void destroymethod()
    {
        System.out.print("销毁Outbean");
    }

    @Override
    public String toString() {
        return "Array_Listcase{" +
                "array_case=" + array_case +
                ", map_case=" + map_case +
                ", list_case=" + list_case +
                ", set_case=" + set_case +
                '}';
    }
}


bean配置

 <bean id="case01" class="bean_test.Array_Listcase" init-method="initmethod" destroy-method="destroymethod">
        <property name="array_case">
            <array>
                <value>yma16</value>
                <value>18</value>
            </array>
        </property>
        <property name="map_case">
            <map>
                <entry key="I am a keay" value="I am a value"></entry>
                <entry key="yma16" value="yma16 value"></entry>
            </map>
        </property>
        <property name="list_case">
            <list>
                <value>yma16</value>
                <value>2020</value>
            </list>
        </property>
        <property name="set_case">
            <set>
                <value>I am a set</value>
                <value>yma16</value>
            </set>
        </property>
    </bean>

测试结果!
在这里插入图片描述

注解方式

Component、Service、Controller、Ropository
  • @Component
  • @Service
  • @Controller
  • @Ropository
    注解方式可以类、方法和属性名上面
@注解(value="");<!-- 对应 bean标签中 id唯一标识   -->
  1. 引入依赖aop
  2. 开启组件扫描
  3. 引入命名空间context

创建一个Demo类,component方式创建对象

package context_demo;
import org.springframework.stereotype.Component;
@Component(value="component1")
public class Demo {

}

System.out.println("component方式注入");
ApplicationContext context5= new ClassPathXmlApplicationContext("bean05.xml");
Demo compnent1=context5.getBean("component1", Demo.class);
System.out.println(compnent1);
<context:component-scan base-package="context_demo">
</context:component-scan>

component方式注入成功!
在这里插入图片描述

基于注解方式的属性注入

Autowired、Qualifier、Resource

注入

  • Autowired(属性类型)
  • Qualifier(属性名称)
  • Resource(属性类型或属性名称)
  • value(普通类型属性)

代码:去我的仓库
end
在这里插入图片描述

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐