第二章 IOC容器

最新推荐文章于 2024-05-31 11:42:39 发布
最新推荐文章于 2024-05-31 11:42:39 发布
阅读量113 收藏
点赞数
分类专栏： Spring5 文章标签： spring 5 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39963192/article/details/114648402
版权

第二章 IOC容器

1. IOC概念和原理

  1. 控制反转，把对象创建和对象之间的调用过程，交给Spring管理。
  2. 主要目的：降低耦合。

2. IOC底层原理

IOC主要使用了xml解析、工厂模式、反射

image-20210310110148541
image-20210310110312633

  这种情况下，虽然降低了UserService和UserDao的耦合度，但是却增加了UserFactory和他们的耦合度。

image-20210310110733389

3. IOC接口

3.1 概念结构

BeanFactory：IOC容器基本实现，是Spring的内部接口，不提供开发人员使用。加载配置文件的时候，不会创建对象，使用的时候才会创建；即1不创建，2创建。

image-20210310111658314

ApplicationContext：BeanFactory接口的子接口，功能更强大，提供开发人员实现。1的时候就已经创建好了。

image-20210310111819641

基本实现类（Ctrl+H）：

FileSystemXmlApplicationContext 文件的绝对路径

ClassPathXmlApplicationContext 类路径

image-20210310112054937

3.2 Bean管理

3.2.1 基于xml配置文件方式

创建对象

image-20210310135903211

bean中的属性：id、class、name（较少使用，里边可以由特殊字符）、

  1. id属性：唯一标识，给创建的对象起别名。
  2. class属性：类全路径。

步骤

  1. 在spring配置文件中，使用bean标签，标签中添加相应的属性。
  2. 创建对象时，默认执行无参构造方法创建对象。

注入属性

DI：依赖注入，注入属性。DI是IOC中一种具体实现，他表示注入属性。

两种注入方式：

(1) set方法注入(类比传统使用set给函数赋值)

(2)构造函数注入(类比在构造函数中给属性赋值)

  1. set方法注入。

    (1) 创建类，定义属性和set方法。

    public class User {

    private String name;
    private Integer age;

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

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

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

    (2) 在spring配置对象创建，配置属性注入。

    <!-- 2. set方法注入属性 -->
<bean id="user" class="com.wit.entity.User">
    <!-- 使用property注入属性
        name：类里边属性的名字
        value：向属性注入的值
     -->
    <property name="name" value="张三"/>
    <property name="age" value="15"/>
</bean>

    (3) 结果测试

    @Test
public void testUser(){

    // 1. 加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

    // 2. 获取创建的对象
    User user = context.getBean("user", User.class);

    System.out.println(user.toString());
}

    image-20210310142208408

  2. 构造方法注入

    (1) 创建类，定义属性，创建属性对应的构造方法。

    public class Order {
    private Integer number;
    private String name;

    public Order(Integer number, String name) {
        this.number = number;
        this.name = name;
    }

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

    (2) 在spring配置文件中配置。

    <!-- 3. constructor注入属性 -->
<bean id="order" class="com.wit.entity.Order">
    <constructor-arg name="number" value="1"/>
    <constructor-arg name="name" value="张三"/>
</bean>

    (3) 结果测试

    @Test
public void testUser(){

    // 1. 加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    // 2. 获取创建的对象
    Order order = context.getBean("order", Order.class);
    System.out.println(order.toString());
}

    image-20210310142908852

  3. p名称空间注入。创建属性和set方法之后。

    (1) 在配置文件中添加p名称空间。

    image-20210310143359467

    (2) 属性注入，在bean标签中使用。

    <!-- 3. p名称空间注入属性 -->
<bean id="user" class="com.wit.entity.User" p:name="张三" p:age="15"/>

    (3) 结果测试

    @Test
public void testUser(){

    // 1. 加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    // 2. 获取创建的对象
    User user = context.getBean("user", User.class);
    System.out.println(user.toString());
}

    image-20210310143714296

注入其他类型属性

字面量

  1. null值
<property name="address">
    <null/>
</property>

image-20210310150456433

  1. 属性值中包含特殊符号
<!--
     1. 使用转义字符。
     2. 带特殊符号的写入CDATA
 -->
<property name="address" value="&lt;北京&gt;"/>
<property name="address">
    <value><![CDATA[<北京>]]></value>
</property>

image-20210310151202351

外部bean

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

public class UserService {
    public void add(){
        System.out.println("UserService add...........");
    }
}

public interface UserDao {
    void update();
}

public class UserDaoImpl implements UserDao {
    public void update(){
        System.out.println("UserDao update......");
    }
}

(2) 在service中调用dao里面的方法

public class UserService {
    // 创建UserDao类型属性，生成set方法
    private UserDao userDao;

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

    public void add(){
        System.out.println("UserService add...........");
        userDao.update();
    }
}

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

<!-- service和dao对象的创建 -->
<bean id="userService" class="com.wit.service.UserService">
    <!--
        name:类中的属性名称
        ref:userDao对象bean的id值
     -->
    <property name="userDao" ref="userDao"/>
</bean>

<bean id="userDao" class="com.wit.dao.UserDaoImpl"/>

(4) 测试

@Test
public void testService(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService service = context.getBean("userService",UserService.class);
    service.add();
}

image-20210310153545912

内部bean

(1) 一对多关系：部门跟员工。

(2) 在员工中加一个部门属性。

public class Emp {
    private String name;
    private String gender;
    private Dept dept;

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

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

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

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

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
    
    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

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

<bean id="emp" class="com.wit.entity.Emp">
    <property name="name" value="张三"/>
    <property name="gender" value="男"/>
    <property name="dept">
        <bean id="dept" class="com.wit.entity.Dept">
            <property name="dname" value="安保部"/>
        </bean>
    </property>
</bean>

(4) 测试

@Test
public void testInnerBean(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Emp emp = context.getBean("emp", Emp.class);
    System.out.println(emp.toString());
}

image-20210310155029864

级联赋值

法一：

<bean id="emp" class="com.wit.entity.Emp">
    <property name="name" value="张三"/>
    <property name="gender" value="男"/>
    <property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="com.wit.entity.Dept">
    <property name="dname" value="安保部"/>
</bean>

法二：需要把emp的getDept和dept的getDname写出来

<bean id="emp" class="com.wit.entity.Emp">
    <property name="name" value="张三"/>
    <property name="gender" value="男"/>
    <property name="dept" ref="dept"/>
    <property name="dept.dname" value="财务部"/>
</bean>
<bean id="dept" class="com.wit.entity.Dept"/>

注入集合属性

Array、List、Map、Set

(1) 创建类

public class Student {
    // 1. 数组类型
    private String[] array;
    // 2. 集合类型
    private List<String> list;
    // 3. map类型
    private Map<String,String> map;
    // 4. set类型
    private Set<String> set;

    public void setArray(String[] array) {
        this.array = array;
    }

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

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

    public void setSet(Set<String> set) {
        this.set = set;
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

(2) 配置属性

<bean id="student" class="com.wit.coll.Student">
    <property name="array">
        <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="1" value="1"/>
            <entry key="2" value="2"/>
            <entry key="3" value="3"/>
        </map>
    </property>
    <property name="set">
        <set>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </set>
    </property>
</bean>

(3) 测试

@Test
public void testColl(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Student student = context.getBean("student",Student.class);
    System.out.println(student.toString());
}

image-20210310161414188

在集合里边设置对象类型

(1) 创建Course类，并在Student类加入List<Course>类型

public class Course {
    private String name;

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

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

(2) 配置bean.xml

<bean id="student" class="com.wit.coll.Student">
    <property name="array">
        <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="1" value="1"/>
            <entry key="2" value="2"/>
            <entry key="3" value="3"/>
        </map>
    </property>
    <property name="set">
        <set>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </set>
    </property>
    <property name="courses">
        <list>
            <ref bean="course1"/>
            <ref bean="course2"/>
        </list>
    </property>
</bean>
<bean id="course1" class="com.wit.coll.Course">
    <property name="name" value="MySQL高级"/>
</bean>
<bean id="course2" class="com.wit.coll.Course">
    <property name="name" value="Spring5"/>
</bean>

(3) 测试

image-20210310162301201

把集合注入部分提取出来

(1) 引入util名称空间

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

(2) 配置bean.xml

<!-- 抽取部分 -->
<util:list id="courses">
    <ref bean="course1"/>
    <ref bean="course2"/>
</util:list>

<!-- 使用部分 -->
<bean id="student" class="com.wit.coll.Student">
    <property name="courses" ref="courses"/>
</bean>

<bean id="course1" class="com.wit.coll.Course">
    <property name="name" value="MySQL高级"/>
</bean>
<bean id="course2" class="com.wit.coll.Course">
    <property name="name" value="Spring5"/>
</bean>

(3) 测试

image-20210310163505789

3.2.2 基于注解方式

什么是注解？

注解是代码中的特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值)

可以作用在类上面，方法上面，属性上面

简化XML配置

创建对象

常用注解：@Component、@Service、@Controller、@Repository。功能是一样的，提示不同文件承担不同的责任。

@Component：普通注解，创建任何对象。

@Service：使用在业务逻辑层。Service层

@Controller：web层。Controller层

@Repository：持久层。Dao层

(1) 创建新的项目 spring5-02-annocation 。

(2) 引入依赖。使用注解需要引入aop相关的包。

<!-- parent项目中引入 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${wit.spring.version}</version>
</dependency>

<!-- annocation项目中引入 -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

(3) bean.xml 中开启组件扫描。需要context名称空间。

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

    <!-- 开启组件扫描
         如果多个包，多个包之间逗号隔开
         或者扫描这些包的上层目录
     -->
    <context:component-scan base-package="com.wit.service" />
</beans>

(4) 创建类，在类上边添加注解。

@Service(value = "userService")
//等同于bean的写法，id是value的值，class是当前类的全限定类名
//value可以省略不写，不写默认值是类名的首字母小写
public class UserService {
    public void add(){
        System.out.println("UserService add 执行了.....");
    }
}

(5) 测试。

@Test
public void testService(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

image-20210310201410920

开启组件扫描细节配置

当前配置扫描包默认扫描包内的全部文件，可以配置哪些需要扫描，哪些不需要扫描。

<!-- spring有默认的filter，使用use-default-filters取消默认的filter，自己配置filter
     context:include-filter,配置扫描的包,配置扫描所有的@Service
 -->
<context:component-scan base-package="com.wit.service" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
</context:component-scan>

<!-- 配置不进行扫描的包
-->
<context:component-scan base-package="com.wit.service">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

注入属性

常用注解：@AutoWired、@Qualifier、@Resource`

@AutoWired：自动根据属性类型注入。

@Qualifier：根据属性的名称注入。

@Resource：可以根据类型，也可以根据名称注入。

@Value：注入普通类型属性。

@AutoWired

(1) 创建service和dao对象创建，在Service和Dao类上添加创建对象的注解。

@Service(value = "userService")
public class UserService {

    // 不需要set方法
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("UserService add 执行了.....");
        userDao.update();
    }
}


public interface UserDao {
    void update();
}

@Repository
public class UserDaoImpl implements UserDao {
    public void update(){
        System.out.println("UserDao update......");
    }
}

(2) 在service注入dao对象

(3) 测试
image-20210310203817986

@Qualifier：和@AutoWired一起使用。

(1) 创建UserDao的实现类UserDaoImpl2。使用@AutoWired测试报错。

@Repository("userDao2")
public class UserDaoImpl2 implements UserDao {
    public void update(){
        System.out.println("UserDao update......");
    }
}

image-20210310204103976

(2) 使用@Qualifier，测试无误。

@Service(value = "userService")
public class UserService {

    // 不需要set方法
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;

    public void add(){
        System.out.println("UserService add 执行了.....");
        userDao.update();
    }
}

image-20210310204332450

@Resource：不带任何参数根据类型注入。@Resource(name = “userDao”) 根据名称注入。

@Value：注入普通属性。

@Value("abc")
private String name;

完全注解开发

(1) 创建配置类，替代XML配置文件

@Configuration // 配置类，用来取代配置文件
@ComponentScan(basePackages = {"com.wit"})
public class SpringConfig {

}

(2) 编写测试方法。

@Test
public void testAnno(){
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

image-20210310212702764

3.2.3 FactoryBean

Spring中有两种类型的bean，一种是普通的bean，另外一种是FactoryBean

普通bean：在配置文件中配置什么类，就得到什么类的对象。

FactoryBean：在配置文件中国配置的类和得到的对象类型不一致。

(1) 创建类，作为工厂bean，实现接口FactoryBean。

(2) 实现接口中的方法，在实现的方法中定义返回的类型。

public class MyBean implements FactoryBean<Course> {

    // 定义返回bean对象,返回什么类型，即使用getbean将得到什么类型的对象
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("大学英语");
        return course;
    }

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

    public boolean isSingleton() {
        return false;
    }
}

<bean id="myBean" class="com.wit.factorybean.MyBean"/>

@Test
public void testFactoryBean(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Course course = context.getBean("myBean", Course.class);
    System.out.println(course);
}
3.2.4 bean的作用域

Spring默认bean是单实例(即两次获取同名bean，地址值相同)，可设置单实例或多实例。

@Test
public void testColl(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Student student = context.getBean("student",Student.class);
    Student student1 = context.getBean("student",Student.class);
    System.out.println(student == student1);
}

设置单实例还是多实例

在bean中属性 scope，取值常用的有：singleton、prototype。此外还有request、session。

  1. singleton是单实例的，prototype是多实例的。
  2. singleton加载配置文件时创建对象，prototype在调用getBean是创建对象。

(1) singleton：默认值，单实例的。

(2) prototype：多实例的。修改为多实例，并重新测试地址是否相等。

<!-- 使用部分 -->
<bean id="student" class="com.wit.coll.Student" scope="prototype">
    <property name="courses" ref="courses"/>
</bean>

image-20210310184031110

(3) request和session：每次创建对象之后放在request域中或session域中，了解。

3.2.5 bean的生命周期

对象从创建到销毁的过程

(1) 通过构造器创建bean实例(无参构造器)。

(2) 为bean属性设置对应的值，调用set方法。

(3) 调用bean中的初始化(需要进行相应的配置)。

(4) bean可以使用了(对象获取到了)。

(5) 当容器关闭时，调用bean的销毁方法(需要进行配置)。

生命周期演示

public class Book {
    private String name;

    public Book() {
        // 1. 调用无参构造方法
        System.out.println("第一步 无参构造方法调用了.....");
    }

    public void setName(String name) {
        // 2. 调用set方法
        System.out.println("第二步 set方法调用了......");
        this.name = name;
    }

    public void initMethod(){
        // 3. 初始化方法,名字任起
        System.out.println("第三步 init method 执行了.....");
    }

    public void destpryMethod(){
        // 5. 销毁方法，名字任起。调用之后，需要手动销毁一下对象。
        System.out.println("第五步 destory method 执行了......");
    }
}

<!-- 3. 配置初始化方法，Book中的initMethod方法 -->
<!-- 5. 配置销毁方法，Book中的destoryMethod方法 -->
<bean id="book" class="com.wit.entity.Book" init-method="initMethod" destroy-method="destpryMethod">
    <property name="name" value="三体"/>
</bean>

@Test
public void testLife(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Book book = context.getBean("book", Book.class);
    // 4. 获取到对象
    System.out.println("第四步 获取到了book对象.....");
    System.out.println(book);

    // 手动销毁对象
    context.close();
}

image-20210310190436822

后置处理器

bean的生命周期除了上边三种，还有两种。分别在第三步之前和第三步之后。

(1) 通过构造器创建bean实例(无参构造器)。

(2) 为bean属性设置对应的值，调用set方法。

(3) 把bean实例传递bean后置处理器方法。postProcessBeforeInitialization

(4) 调用bean中的初始化(需要进行相应的配置)。

(5) 把bean实例传递bean后置处理器方法。postProcessAfterInitialization

(6) bean可以使用了(对象获取到了)。

(7) 当容器关闭时，调用bean的销毁方法(需要进行配置)。

演示带后置处理器

后置处理器会为所有的bean都添加方法。即如果还有其他bean，也会执行后置处理器的方法。

创建BookProcessor

public class BookProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前执行了......");
        return bean;
    }

    @Nullable
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后执行了......");
        return bean;
    }
}

<bean id="bookProcessor" class="com.wit.entity.BookProcessor"/>

image-20210310191410813

3.2.6 XML自动装配

根据指定装配规则(属性值或者属性类型)，Spring自动将匹配的属性进行注入。

装配过程

  1. 根据名称自动注入。

    <!-- 实现自动装配
     autowire常用两个值：
        byName根据属性名称注入：注入bean的id值和类属性值一致。
        byType根据属性类型注入：
-->
<bean id="emp" class="com.wit.entity.Emp" autowire="byName">
    <property name="name" value="张三"/>
    <property name="gender" value="男"/>
</bean>
<bean id="dept" class="com.wit.entity.Dept">
    <property name="dname" value="财务部"/>
</bean>

    image-20210310192804387

  2. 根据类型自动注入。

注意根据类型时，如果有多个相同类型，将会报错。系统不知道选择哪个进行注入。

<!-- 实现自动装配
     autowire常用两个值：
        byName根据属性名称注入：注入bean的id值和类属性值一致。
        byType根据属性类型注入：
-->
<bean id="emp" class="com.wit.entity.Emp" autowire="byType">
    <property name="name" value="张三"/>
    <property name="gender" value="男"/>
</bean>
<bean id="dept" class="com.wit.entity.Dept">
    <property name="dname" value="财务部"/>
</bean>

image-20210310192845829

3.2.7 外部属性文件

注入的属性过多时，书写起来或者更改起来比较麻烦，把相关的值写到外部文件中。常用在数据库配置中。

(1) 创建spring.properties外部配置文件

dept.dname=财务部

(2) 引入context命名空间

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

(3) 配置bean.xml。

<!-- 引入外部文件 -->
<context:property-placeholder location="classpath:spring.properties" file-encoding="utf-8"/>

<bean id="dept" class="com.wit.entity.Dept">
    <property name="dname" value="${dept.dname}"/>
</bean>

(4) 测试。这里如果读出乱码，File——>settings——>Editor——>File Encodings Properties Files修改编码为utf-8

@Test
public void testProperties(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    Dept dept = context.getBean("dept", Dept.class);
    System.out.println(dept);
}

image-20210310194611202

木水先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring入门到精通：第二章 IOC容器（XML方式）：2.IOC演变
悟纤学院
11-02 1万+
前言 我们来看下IOC的演变历程，这里我们要明白设计的核心就是要降低耦合度。 假设我们有一个UserService和UserDao。 准备工作 创建UserDao： package com.kfit.test.test3; public class UserDao { public void save(){ System.out.println("将用户信息进行保存到数据库."); } } 创建UserServ...
Spring入门到精通：第二章 IOC容器（XML方式）：1.IOC概念
悟纤学院
11-02 1万+
百度百科表述： 控制反转（Inversion of Control，缩写为IOC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup，简称DL）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。 上面的描述看起来是不是根本不知道所以然，我们接下来...
Spring框架系列之第二章 IOC容器和Bean的配置
qq_36595761的博客
09-09 232
Spring框架系列之第二章 IOC容器和Bean的配置 2.1 IOC和DI 2.1.1 IOC(Inversion of Control)：反转控制    在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。    反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的
第二章 IOC容器的实现
qq_38300704的博客
09-16 108
2.1spring ioc容器概述 2.1.1 ioc容器和依赖反转模式 2.2 ioc容器的设计与实现：BeanFactory和ApplicationContext 2.2.1 spring的ioc 容器系列 设计功能规范：表现为接口类BeanFactory,BeanFactory作为最基本的接口类出现在spring ioc容器中。 spring定义BeanDefinition管理spring的...
Spring4系列-第二章 IOC容器和Bean的配置
夜歌的博客
08-17 106
Spring4系列 第二章 IOC容器和Bean的配置 2.1 IOC和DI 2.1.1 IOC(Inversion of Control)：反转控制 ​ 在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。 ​ 反转控制的思想完全颠覆了应用程序组件获取资源的传统...
Spring入门到精通：第二章 IOC容器（XML方式）：4.IOC容器Bean管理XML方式
热门推荐
悟纤学院
11-02 1万+
这一节我们来看下使用XML的方式进行Bean管理。 一、IOC操作-Bean管理 1.1 什么是Bean管理 （1）Spring创建对象 （2）Spring注入属性 1.2 Bean管理的两种方式 （1）基于XML配置文件方式实现 （2）基于注解方式实现 在接下里我们主要先讲一下基于XML方式的对象的创建和属性的注入。 二、IOC操作Bean管理（基于XML方式） 2.1 基于XML方式创建对象 （1）在Spring配置文件中，使用bean标签，标签里添加对应...
Spring入门到精通：第二章 IOC容器（XML方式）：3.IOC原理
悟纤学院
11-02 1万+
前言 在前面我们讲到了IOC的一个演变，那么这节我们就看看IOC的一个原理。 一、IOC底层原理使用核心技术 XML解析、工厂模式、反射。 （DefaultSingletonBeanRegistry、AbstractBeanFactory、BeanFactory） 二、IOC底层原理分析 2.1 XML配置文件：配置创建的对象 <bean id="userDao" class="com.kfit.test4.UserDao"></be...
Spring入门到精通：第二章 IOC容器（XML方式）：6.IOC容器Bean管理XML方式-工厂bean
悟纤学院
11-03 1万+
Spring有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean） （1）普通bean：在配置文件中定义bean类型就是返回类型。 （2）工厂bean：在配置文件定义bean类型可以和返回类型不一样。 一、工厂bean 1.1 步骤 第一步：创建类实现接口FactoryBean。 第二步：实现接口里的的方法，在实现的方法中定义返回的bean类型。 （1）创建类实现接口FactoryBean： package com.kfit.test.test6; i.
第二章：Spring IoC容器
p812438109的专栏
05-21 190
一）Spring Bean定义 Bean的定义： Bean是一个被实例化，组装，并通过Spring IoC容器所管理的对象。这些 Bean是由用容器提供的配置元数据创建的。 Bean的属性： 属性 描述 class 强制性的属性，指定用来创建bean的类。 name 指定唯一的bean标识符。在XML配置元数据中，可以使用ID和/或name属性来指定bean标识符。 scope 指定由特定的bean定义创建的对象的作用域。 constructor-arg
Spring入门到精通：第二章 IOC容器（XML方式）：9.IOC容器Bean管理XML方式-自动装配
悟纤学院
11-03 1万+
自动装配能够简化我们的代码。 一、自动装配 自动装配：根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值进行注入。 自动装配可以通过配置属性autowire，有两种自动装配方式，一种是byName，一种是byType。 1.1 byName byName：通过属性名称进行注入bean，Spring会获取到属性的名称，然后通过属性的名称进行寻找bean id为属性的名称进行注入。 <bean id="printerService1" class=...
Spring攻略 英文第二版
08-01
构建于Spring IoC容器组件模型之上的这些Spring3部件提供了集成、批处理、OSGi、Ajax和Flex集成、状态式的Web应用、REST风格Web服务、富客户端用户界面、Google AppEngine开发、基于云的部署、消息、数据访问、Web...
疯狂java讲义.第二版.part5.rar
11-10
五子棋游戏、梭哈游戏、仿QQ的游戏大厅、MySQL企业管理器、仿Editplus的文本编辑器、多线程、断点下载游戏、Spring框架的IoC容器…这些案例既能让读者巩固每章的知识，又可以让读者学以致用，激发编程自豪感，进而...
疯狂java讲义.第二版.part1.rar
11-10
五子棋游戏、梭哈游戏、仿QQ的游戏大厅、MySQL企业管理器、仿Editplus的文本编辑器、多线程、断点下载游戏、Spring框架的IoC容器…这些案例既能让读者巩固每章的知识，又可以让读者学以致用，激发编程自豪感，进而...
疯狂java讲义.第二版.part2.rar
11-10
五子棋游戏、梭哈游戏、仿QQ的游戏大厅、MySQL企业管理器、仿Editplus的文本编辑器、多线程、断点下载游戏、Spring框架的IoC容器…这些案例既能让读者巩固每章的知识，又可以让读者学以致用，激发编程自豪感，进而...
疯狂java讲义.第二版.part3.rar
11-10
五子棋游戏、梭哈游戏、仿QQ的游戏大厅、MySQL企业管理器、仿Editplus的文本编辑器、多线程、断点下载游戏、Spring框架的IoC容器…这些案例既能让读者巩固每章的知识，又可以让读者学以致用，激发编程自豪感，进而...
springboot mqtt收发消息
最新发布
qq_34874784的博客
05-31 213
​在Spring Boot中，可以使用MQTT协议来收发消息。这样，就可以使用Spring Boot和MQTT协议来收发消息了。5. 使用MQTT消息接收和发送服务。3. 创建MQTT消息接收服务。4. 创建MQTT消息发送服务。2. 配置MQTT连接工厂。
SpringBoot集成腾讯COS流程
weixin_67727883的博客
05-30 132
SpringBoot集成腾讯COS流程
SpringBoot 异步编程
凤凰的博客
05-29 639
使用@Async注解，在默认情况下用的是线程池，该线程池不是真正意义上的线程池。使用此线程池无法实现线程重用，每次调用都会新建一条线程。若系统中不断的创建线程，最终会导致系统占用内存过高，引发= null?//判断是否开启限流，默认为否//执行前置操作，进行限流} else {//未限流的情况，执行线程任务//不断创建线程= null?//创建线程//指定线程名，task-1，task-2...
SpringBoot 的 Java 代码配置（二）
xiaotu的博客
05-29 1083
因此，如果使用 HikariCP 只用声明你要用它就行，而声明要使用 Druid，你需要自己指定所使用的版本。上面的 DruidDataSource ，我们为其属性赋值时，它的四个属性都是简单类型属性，因此十分容易处理。但是，在 Spring 的容器中，Java Bean 可能会存在引用。在上面的 Druid 的配置中，数据库连接的四大属性值是在代码中『写死』的。而在 Java 代码配置中，通过 @Bean 方法的入参来表达 Bean 之间的引用关系。，所以，我们可以直接将自定义的配置项写在。
ioc 容器
06-02
IoC （Inversion of Control，控制反转）是一种设计模式，它将程序中的控制权从代码中转移到了容器中，使得程序的可扩展性和可维护性更强。IoC 容器就是实现 IoC 模式的一个工具，它可以自动创建、装配和管理对象，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木水先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值