Spring-IOC

最新推荐文章于 2024-03-16 09:00:00 发布

琳酱我爱你

最新推荐文章于 2024-03-16 09:00:00 发布

阅读量58

点赞数

分类专栏： java自学笔记

本文链接：https://blog.csdn.net/loveandstory/article/details/115398336

版权

java自学笔记专栏收录该内容

20 篇文章 0 订阅

订阅专栏

IOC容器

1. IOC底层原理

1.1 什么是IOC

(1)控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理

(2)使用IOC目的：为了降低耦合度

1.2 IOC底层原理

（1）xml解析、工厂模式、反射

在这里插入图片描述

2. IOC接口（BeanFactory）

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

2.1 两种实现方式（两个接口）：

（1）BeanFactory：IOC容器基本实现，是spring内部的使用接口，不提供开发人员进行使用

加载配置文件时不会创建对象，在获取对象的时候采取创建

（2）ApplicationContext：Bean Factory接口的子接口，提供更大强大的功能，一般给开发人员使用

在加载配置文件的时候就会进行对象创建

2.2 ApplicationContext的实现类

FileSystemXmlApplicationContext

ClassPathXmlApplicationContext

3. IOC操作Bean管理（基于xml）

3.1 概念

什么是bean管理？

（1）Spring创建对象

（2）Spring注入属性

管理的两种方式：基于xml，基于注解

3.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">
    <bean id="user" class="com.wangwang.dao.User"></bean>
</beans>

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

（2）在 bean 标签有很多属性，介绍常用的属性

id 属性：唯一标识
class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

注入属性 DI:依赖注入，就是注入属性

第一种注入方式：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;
    }
}

<bean id="book" class="com.wangwang.bean.Book">
    <property name="bname" value="红楼梦"></property>
    <property name="bauthor" value="曹雪芹"></property>
</bean>

第二种注入方式：有参构造注入

public class Order {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Order(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }
}

<bean id="order" class="com.wangwang.bean.Order">
    <constructor-arg name="oname" value="abc"></constructor-arg>
    <constructor-arg name="address" value="china"></constructor-arg>
</bean>

第三种方式：p名称空间注入，简化基于xml配置方式

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

<bean id="book" class="com.wangwang.bean.Book" p:bname="红楼梦" p:bauthor="曹雪芹"></bean>

3.3 注入其他类型属性

字面量

（1）空值

<property name="address"> <null/> </property>

（2）属性值包含特殊符号

<!--属性值包含特殊符号
1 把<>进行转义 &lt; &gt;
2 把带特殊符号内容写到 CDATA
-->
<property name="address">
	<value><![CDATA[<<南京>>]]></value>
</property>

注入属性-外部bean

在service 的属性里有dao

<!--1 service 和 dao 对象创建-->
<bean id="userService" class="com.wangwang.service.UserService">
    <!--注入 userDao 对象
    name 属性：类里面属性名称
    ref 属性：创建 userDao 对象 bean 标签 id 值
    -->
	<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.wangwang.dao.UserDaoImpl"></bean>

注入属性-内部bean和级联赋值

一对多关系：部门和员工

<!--内部 bean-->
<bean id="emp" class="com.wangwang.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="com.wangwang.bean.Dept">
        <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>

其他写法：

<bean id="emp" class="com.wangwang.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.wangwang.bean.Dept">
    <property name="dname" value="财务部"></property>
</bean>

下面这种方法要在Emp里生成get()方法：

<bean id="emp" class="com.wangwang.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lucy"></property><property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.wangwang.bean.Dept">
        <property name="dname" value="财务部"></property>
</bean>

注入集合属性

（1）数组

（2）List

（3）Map

<bean id="stu" class="com.wangwang.collectiontype.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>java 课程</value>
            <value>数据库课程</value>
        </array>
    </property>
    <!--list 类型属性注入-->
    <property name="list">
        <list>
            <value>张三</value>
        	<value>小三</value>
        </list>
    </property>
    <!--map 类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set 类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>

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

<!--创建多个 course 对象-->
<bean id="course1" class="com.wangwang.collectiontype.Course">
    <property name="cname" value="Spring5 框架"></property>
</bean>
<bean id="course2" class="com.wangwang.collectiontype.Course">
    <property name="cname" value="MyBatis 框架"></property>
</bean>
<!--注入 list 集合类型，值是对象-->
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

把集合注入部分提取出来

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

<util:list id="bookList">
    <value>易筋经</value>
	<value>九阴真经</value>
	<value>九阳神功</value>
</util:list>
<!--2 提取 list 集合类型属性注入使用-->
<bean id="book" class="com.wangwang.collectiontype.Book">
	<property name="list" ref="bookList"></property>
</bean>

3.5 FactoryBean

普通bean:在配置文件中定义bean 的类型就是返回类型

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

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

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

public class MyBean implements FactoryBean<Book> {
    @Override
    public Book getObject() throws Exception {
        Book book = new Book();
        book.setBname("红楼梦");
        book.setBauthor("曹雪芹");
        return book;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="mybean" class="com.wangwang.factoryBean.MyBean"></bean>

3.6 bean作用域

在Spring里面，可以设置创建bean是单实例还是多实例
默认情况下，在Spring里bean是单实例
如何设置：

（1）在 spring 配置文件 bean 标签里面有属性（ scope）用于设置单实例还是多实例

<bean id="mybean" class="com.wangwang.factoryBean.MyBean" scope="prototype"></bean>

（2） scope 属性值

第一个值默认值， singleton，表示是单实例对象
第二个值 prototype，表示是多实例对象

（3）singleton和 prototype区别:

第一 ,singleton单实例， prototype多实例

第二设置 scope 值是 singleton时候，加载 spring 配置文件时候就会创建单实例对象设置 scope 值是 prototype时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时候创建多实例对象

3.7 bean的生命周期

生命周期：从对象创建到对象销毁的过程
bean 生命周期（3，5为添加了后置处理器后）

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

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

（3） 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

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

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

添加后置处理器：

public class MyBeanPost 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;
    	}
}

<!--配置后置处理器-->
<bean id="myBeanPost" class="com.wangwang.bean.MyBeanPost"></bean>

3.8 xml自动装配

什么是自动装配？

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

自动装配设置

(1)根据名称自动注入

<!--实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        byName根据属性名称注入 ，注入值bean的id值和类属性名称一样
        byType根据属性类型注入
-->
<bean id="emp" class="com.wangwang.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

（2）根据类型自动注入

如果同一类型有多个，会出错

<bean id="emp" class="com.wangwang.autowire.Emp" autowire="byType"></bean>

3.9 外部属性文件

应用场景：配置数据库的信息

引入context约束

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


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

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

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

4. IOC操作Bean管理（基于注解）

4.1 Bean管理

创建对象

@Component

@Service

@Controller

@Repository

上面的四个注解功能是一样的，都可以用来创建bean实例

使用步骤：

第一步：引入spring-aop-5.2.6.RELEASE.jar

第二步：开启组件扫描

<!--开启组件扫描-->
<context:component-scan base-package="com.wangwang.*"></context:component-scan>

第三步：编写javabean

//在注解里面value属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
//@Component(value = "userService")  //<bean id="userService" class=".."/>
@Service
public class UserService {

    @Value(value = "abc")
    private String name;

    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
	//@Autowired  //根据类型进行注入
	//@Qualifier(value = "userDaoImpl1") //根据名称进行注入
	//private UserDao userDao;
    //@Resource  //根据类型进行注入
    @Resource(name = "userDaoImpl1")  //根据名称进行注入
    private UserDao userDao;

    public void add() {
        System.out.println("service add......."+name);
        userDao.add();
    }
}

配置细节：

<!-- 实例1：
    use-default-filters="false"表示现在不使用默认的filter,自己配置filter
    context:include-filter ，设置扫描那些类容
  -->
<context:component-scan base-package="com.wangwang.*" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!-- 示例2：
    context:exclude-filter:设置不扫描哪些类容
  -->
<context:component-scan base-package="com.wangwang.*" use-default-filters="false">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

属性注入

（1）@AutoWired：根据属性类型进行自动装配

（2）@Qualifier：根据属性名称自动进行装配

（3）@Resource可以根据类型注入，可以根据名称注入

（4）@Value：注入普通类型属性

4.2 完全注解实现

创建配置类,替代xml配置文件

@Configuration  //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.wangwang"})
public class SpringConfig {

}

编写测试类

public void testService2() {
    //加载配置类
    ApplicationContext context
            = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}
`：根据属性名称自动进行装配

（3）`@Resource`可以根据类型注入，可以根据名称注入

（4）`@Value`：注入普通类型属性

#### 4.2 完全注解实现

1. 创建配置类,替代xml配置文件

```java
@Configuration  //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.wangwang"})
public class SpringConfig {

}

编写测试类

public void testService2() {
    //加载配置类
    ApplicationContext context
            = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}

琳酱我爱你

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring-IOC

IOC容器1. IOC底层原理1.1 什么是IOC(1)控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理(2)使用IOC目的：为了降低耦合度1.2 IOC底层原理（1）xml解析、工厂模式、反射2. IOC接口（BeanFactory）IOC思想基于IOC容器完成，IOC容器底层就是对象工厂2.1 两种实现方式（两个接口）：（1）BeanFactory：IOC容器基本实现，是spring内部的使用接口，不提供开发人员进行使用加载配置文件时不会创建对象，在获取对象
复制链接

扫一扫