Spring5-IOC学习笔记

2024-03-15 09:06:29

spring5框架概述

  1. Spring是轻量级的开源的JavaEE框架

  2. Spring可以解决企业应用开发的复杂性

  3. Spring有两个核心部分：IOC和AOP

    1. IOC：控制反转，把创建对象过程交给 Spring 进行管理

    2. Aop：面向切面，不修改源代码进行功能增强

  4. Spring特点

    1. 方便解耦，简化开发

    2. AOP编程支持

    3. 方便程序测试

    4. 方便和其他框架进行整合

    5. 方便进行事务操作

    6. 降低API开发难度

IOC

IOC需要引入的依赖jar包

commons-logging-1.1.1.jar

spring-beans-5.2.6.RELEASE.jar

spring-context-5.2.6.RELEASE.jar

spring-core-5.2.6.RELEASE.jar

spring-exprission-5.2.6.RELEASE.jar

什么是IOC

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

    1. 使用ICO的目的：为了降低耦合度

IOC底层原理

xml解析、工厂模式、反射

IOC过程(底层原理)

  1. xml配置文件，配置创建的对象
<bean id= "dao" class="com.atguigu.UserDao"></bean>
  1. 由service类和dao类，创建工厂类
class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值//1.xml解析
        Class clazz = Class.forName(classValue);//2.通过反射创建对象
    }
}

IOC接口（BeanFactory）

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

  2. Spring 提供 IOC 容器实现两种方式：（两个接口）

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

      * 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象

    • ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人

      员进行使用

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

      ​ ApplicationContext接口的实现类：

      Spring5-IOC学习笔记

IOC操作Bean管理（概念）

Bean管理共有两个操作

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

Bean管理的两种方式

  1. 基于xml配置文件方式实现
  2. 基于注解方式实现

IOC操作Bean管理（基于xml方式）

基于xml方式创建对象

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

​ 默认执行无参构造器创建

基于xml方式属性注入

DI：依赖注入，也就是属性注入

  1. 使用set方法进行注入

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

public class Book{
    private String name;
    private String outhor;
    
    public void setName(String name){
        this.name = name;
    }
    public void setOurthor(String outhor){
        this.outhor = outhor;
    }
}

​ 在xml配置文件中配置创建对象，注入属性

<bean id="book" class="com.atguigu.spring5.Book">
	<property name="name" value="葵花宝典"></property>
    <property name="outhor" value="黄裳"></property>
</bean>

  1. 使用有参构造器注入属性

    创建类，定义属性和构造器

    public class Order{
    private String name;
    private String address;
    
    public Order(String name,String address){
        this.name = name;
        this.address = address;
    }
}

    在xml配置文件中进行配置

    <bean id="order" class="com.atguigu.spring5.Order">
	<constructor-arg name="name" value="铁剑"></constructor-arg>
    <constructor-arg name="address" value="华山派"></constructor-arg>
</bean>
    1. 使用P名称空间注入（了解）

注入其他类型属性

  1. null值
<property name="address">
	<null/>
</property>
  1. 属性值包含特殊符号
输入《华山派》
1.使用转义符
2.使用<![CDATA[]]>
<property name="address">
	<value><![CDATA[《华山派》]]></value>
</property>

注入属性-外部Bean

往userService中注入userDaoImpl
<bean id="userService" class="com.atguigu.spring5.service.UserService">
	<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

注入属性-内部Bean

<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <property name="" value=""></property>
    <property name="" value=""></property>
	
    <property name="userDaoImpl">
        <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">
        	<property name="" value="" > </property>
        </bean>
    </property>
    
</bean>

属性注入-级联赋值

  1. 第一种写法
<!--级联赋值--> 貌似和注入外部Bean没有区别
<bean id="emp" class="com.atguigu.spring5.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.atguigu.spring5.bean.Dept">
	 	<property name="dname" value="财务部"></property>
</bean>
  1. 第二种写法
<!--级联赋值--> 
<bean id="emp" class="com.atguigu.spring5.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> 
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
 	<property name="dname" value="财务部"></property>
</bean>

属性注入-数组&集合

<bean id="book" class="com.atguigu.spring5.Book">
	数组类型属性注入
    <property name="arr">
    	<array>
        	<value>value1</value>
            <value>value2</value>
        </array>
    </property>
    List类型属性注入
    <property name="list">
        <list>
        	<value>value1</value>
            <value>value2</value>
        </list>
    </property>
    Map类型属性注入
    <property id="maps">
    	<map>
        	<entry key="key1" value="value1"></entry>
            <entry key="key2" value="value2"></entry>
        </map>
    </property>
    Set类型属性注入
    <property id="sets">
        <value>value1</value>
        <value>value2</value>
    </property>
</bean>

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

创建多个对象
<bean id="book1" class="com.atguigu.spring5.Book">
	<property name="name" value="葵花宝典"></property>
</bean>
<bean id="book2" class="com.atguigu.spring5.Book">
	<property name="name" value="独孤九剑"></property>
</bean>
把上面两个对象注入到List集合中(这个List集合也是其他Bean的属性，所以外面是property标签)
<property name="books">
	<list>
    	<ref bean="book1"></ref>
        <ref bean="book2"></ref>
    </list>
</property>

把集合注入进Bean里

  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: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">
  1. 使用util标签完成list集合注入提取
<!--1 提取 list 集合类型属性注入--> 
<util:list id="names">
 	<value>易筋经</value>
 	<value>九阴真经</value>
 	<value>九阳神功</value>
</util:list>
<!--2 提取 list 集合类型属性注入使用--> 
<bean id="book" class="com.atguigu.spring5.Book">
 	<property name="nameList" ref="names"></property>
</bean>

IOC管理普通Bean和工厂Bean

  1. 普通Bean：在配置文件中定义的类型就是返回类型

  2. 工厂Bean（FactoryBean）：配置与返回类型不同

    第一步：创建类，实现接口FactioryBean，成为工厂Bean

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

    public class MyBean implements FactoryBean<Book> {
 	//定义返回 bean
 	@Override
 	public Book getObject() throws Exception {
 		Book book = new Book();
 		book.setName("独孤九剑");
 		return book;
 	}
 	@Override
 	public Class<?> getObjectType() {
 		return null;
 	}
 	@Override
 		public boolean isSingleton() {
 		return false;
 	} 
}

    在xml配置文件中配置

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

    测试

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

    IOC操作Bean管理（bean作用域）

    1. 在Spring里，设置创建Bean实例是单实例还是多实例
    2. 默认是单实例对象
    Spring5-IOC学习笔记

  3. 如何设置单实例还是多实例

    bean标签里有个属性 scope ，

    第一个值 ：singleton，默认值，表示为单实例对象

    第二个值 ：prototype 表示为多实例对象

区别：singleton：加载spring配置文件的时候就会创建单实例对象

​ prototype：调用 getBean的时候才会创建多实例对象

IOC操作Bean管理（bean生命周期）

  • 生命周期：从对象创建到对象销毁的过程

    1. 通过构造器创建bean实例（无参构造器）
    2. 为bean的属性设置值和对其他bean的引用（调用set方法）
    3. 调用bean的初始化方法（需要进行配置初始化的方法）
    4. bean可以使用了（对象获取到了）
    5. 当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

  • Bean生命周期演示

    创建Bean

public class Orders {
 	//无参数构造
 	public Orders() {
 		System.out.println("第一步 执行无参数构造创建 bean 实例");
 	}
 	private String oname;
 	public void setOname(String oname) {
 		this.oname = oname;
 		System.out.println("第二步 调用 set 方法设置属性值");
 	}
 	//创建执行的初始化的方法
 	public void initMethod() {
 		System.out.println("第三步 执行初始化的方法");
 	}
 	//创建执行的销毁的方法
 	public void destroyMethod() {
 		System.out.println("第五步 执行销毁的方法");
 	} 
}

在xml文件中进行配置

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
 <property name="oname" value="手机"></property>
</bean>

测试

@Test
 public void test1() {
	// ApplicationContext context =
	// new ClassPathXmlApplicationContext("bean1.xml");
 	//	ApplicationContext中没有close方法
     ClassPathXmlApplicationContext context =
 			new ClassPathXmlApplicationContext("bean1.xml");
 		Orders orders = context.getBean("orders", Orders.class);
 		System.out.println("第四步 获取创建 bean 实例对象");
 		System.out.println(orders);
 	//手动让 bean 实例销毁
 	context.close();
 }

测试输出结果：

第一步 执行无参数构造创建 bean 实例
第二步 调用 set 方法设置属性值
第三步 执行初始化的方法
第四步 获取创建 bean 实例对象
com.atguigu.spring5.bean.Orders@112@3243
第五步 执行销毁的方法
  • bean 的后置处理器，****bean 生命周期有七步

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

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

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

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

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

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

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

  • 演示添加后置处理器效果

    创建类，实现接口BeanPostProcessor，创建后置处理器

    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.atguigu.spring5.bean.MyBeanPost"></bean>

    执行效果：

    第一步 执行无参数构造创建 bean 实例
第二步 调用 set 方法设置属性值
在初始化之前执行的方法
第三步 执行初始化的方法
在初始化之后执行的方法
第四步 获取创建 bean 实例对象
com.atguigu.spring5.bean.Orders@112@3243
第五步 执行销毁的方法

IOC操作Bean管理（xml自动装配）

  • 什么是自动装配：根据指定装配规则（属性名称或属性类型），spring自动将匹配的属性值进行注入
  • 演示自动装配过程
    1. 根据属性名称自动注入
<!--实现自动装配
 	bean 标签属性 autowire，配置自动装配
 	autowire 属性常用两个值：
 	byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 	byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
 	<!--<property name="dept" ref="dept"></property>-->
</bean> 
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

​ 2.根据属性类型自动注入

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
 	<!--<property name="dept" ref="dept"></property>-->
</bean> 
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

IOC操作Bean管理（外部属性文件）

1.直接配置数据库信息

​ （1）配置德鲁伊数据库连接池连接池

​ （2）引入德鲁伊数据库连接池依赖jar包：druid-1.1.9.jar

  • 配置数据库连接池的两种方式

方式一：直接配置数据库连接池

<!--直接配置连接池--> 
<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="123456"></property>
</bean>

方式二：引入外部属性文件配置数据库连接池

（1）创建外部properties格式文件，写入数据库信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=root
prop.password=123456

​ (2)把外部properties属性文件引入到spring配置文件中

​ 引入context名称空间

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

在 spring 配置文件使用标签引入外部属性文件

<!--引入外部属性文件--> 
<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>

IOC操作Bean管理（基于注解方式）

什么是注解

  • 什么是注解

    （1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值...)

    （2）使用注解：注解作用在类上面，方法上面，属性上面

    （3）使用注解目的：简化xml配置

  • Spring针对Bean管理中创建对象提供的注解

    （1）@Component

    （2）@Service

    （3）@Controlle

    （4）@Repository

    四个注解功能一样，都可以用来创建Bean实例，但是有各自习惯用的地方

基于注解方式创建对象

第一步 引入依赖jar包

spring-aop-5.2.6.RELEASE.jar

第二步 开启组建扫描

<!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

第三步 创建类，在类上面添加创建对象注解

//注解里面的value值可以省略不写，默认值为类名称，首字母小写（UserService-userService）
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
 	public void add() {
 	System.out.println("service add.......");
 } 
}
  • 开启组件扫描的细节配置
<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" 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.atguigu">
 	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

基于注解方式实现属性注入

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

​ 第一步： 把service和dao对象创建，在service和dao类添加创建对象注解

​ 第二部： 在service中注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Service
public class UserService {
 	//定义 dao 类型属性
 	//不需要添加 set 方法
 	//添加注入属性注解
 	@Autowired 
 	private UserDao userDao;
 	public void add() {
 		System.out.println("service add.......");
 		userDao.add();
 	} 
}

​ (2) @Qualifier: 根据名称进行注入

​ 这个Qualifier注解的使用，和上面@AutoWired一起使用

@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

​ (3) @Resource： 可以根据类型注入，也可以根据名称注入

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

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

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

完全注解开发

  1. 创建配置类，替代xml配置文件
@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})//开启组件扫描
public class SpringConfig {
}
  1. 编写测试类
@Test
public void testAnnotation() {
 	//加载配置类
 	ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 	UserService userService = context.getBean("userService", UserService.class);
 	System.out.println(userService);
 	userService.add();
}

​

上一篇：Java一个项目组的人员分配，看这篇足矣了！


下一篇：字节跳动历年校招Java面试真题解析，看完直呼内行