Spring5之IOC
Spring5 介绍
-
Spring 是轻量级的开源的JavaEE 框架
-
Spring 可以解决企业应用开发的复杂性
-
Spring 有两个核心部分：IOC 和 Aop
(1) IOC : 控制反转，把创建对象过程给Spring进行管理
(2) Aop: 面向切面，不修改源代码进行功能增强
-
Spring 特点
（1）方便解耦，简化开发
（2）Aop编程支持
（3）方便程序测试
（4） 方便和其他框架进行整合
（5）方便进行事务操作
（6）降低API 开发难度
Spring5 入门案例
-
使用idea创建一个普通的java工程
-
导入Spring5 相关的jar包（先去Spring官网下载）
- 创建普通类，在这个类创建普通方法
public class User{
public void add(){
System.out.println("add....");
}
}
- 创建Spring配置文件，在配置文件配置创建的对象（bean1.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">
<!--配置User对象的创建-->
<bean id="user" class="com.oy.online.spring.User"></bean>
</beans>
5.进行测试代码编写
@Test
public void userTest(){
// 1.加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
// 2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
一、IOC(概念和原理)
1、IOC
-
控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
-
使用IOC目的：为了耦合度降低
2、IOC底层原理
- xml 解析、工厂模式、反射
二、 IOC(BeanFactory 接口)
-
IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
-
Spring 提供IOC容器实现的两种方式:（两个接口）
(1) BeanFactory: IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用
加载配置文件时候不会加载，在获取对象（使用）才会去创建对象
(2)ApplicationContext: BeanFactory 接口的子接口，提供更多更强大的功能，一般有开发人员进行使用
加载配置文件时候就会把配置文件对象进行创建
-
ApplicationContext 接口有实现类
三、IOC操作 Bean 管理（概念）
1、Bean 管理
- Bean管理指的是两个操作
- Spring 创建对象
- Spring 注入属性
2、Bean管理的操作的两种方式
- 基于xml配置文件方式实现
- 基于注解方式实现
四、IOC操作Bean管理（基于xml方式）
1、基于xml方式创建对象
<!--配置User对象的创建-->
<bean id="user" class="com.oy.online.spring.User"></bean>
(1) 在spring 配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象的创建
(2) 在bean标签有很多属性，介绍常用属性
- Id属性 ： 唯一标识符
- class属性：类全路径（包类路径）
(3) 创建对象时候，默认也是执行无参构造器完成对象的创建
2、基于xml方式注入属性
（1）DI：依赖注入，就是注入属性
3、第一种注入方式：使用set方法进行注入
(1) 创建类，定义属性和对应的set方法
public class Book {
// 创建属性
private String bname;
private String bauthor;
// 创建属性对应的set方法
public void setBname(String bname){
this.bname = bname;
}
public void setBauthor(String bauthor){
this.bauthor = bauthor;
}
// 测试方法
public void show(){
System.out.println(bname+"::"+bauthor);
}
}
(2) 在spring配置文件配置对象创建，配置属性注入
<!--配置Book对象的创建-->
<!--set 方法注入属性-->
<bean id="book" class="com.oy.online.spring.Book">
<!--使用property 完成属性的注入
name : 类里面属性名称
value: 向属性注入的值
-->
<property name="bname" value="Java编程之美"></property>
<property name="bauthor" value="Java"></property>
</bean>
4、第二种注入方式：使用有参数构成进行注入
(1) 创建类，定义属性，创建属性对应有参数构造方法
public class Order {
// 属性
private String oname;
private String address;
// 有参数构造
public Order(String oname, String address){
this.oname = oname;
this.address = address;
}
// 测试方法
public void show(){
System.out.println(oname+"::"+address);
}
}
(2) 在spring配置文件中的进行配置
<!--有参构造函数注入属性-->
<bean id="order" class="com.oy.online.spring.Order">
<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
5、p空间名称注入（了解）
(1) 使用 p 名称空间注入，可以简化基于 xml 配置方式
第一步 添加p名称空间在配置文件中
xmlns:p="http://www.springframework.org/schema/p"
<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">
</beans>
第二步 进行属性注入，在bean标签里面进行操作
五、IOC操作Bean 管理（xml注入其他类型属性）
1、 字面量
（1）null 值
<property name="address">
<null/>
</property>
(2) 属性包含特殊符号
<!--属性值包含特殊符号
1 把<>进行转义 < >
2 把带特殊符号内容写到 CDATA
-->
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
2、注入属性-外部bean
(1) 创建两个类service 类 和 dao 类
(2) 在service 调用dao 里面的方法
(3) 在spring 配置文件中进行配置
public class UserService {
//创建 UserDao 类型属性，生成 set 方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("service add...............");
userDao.update();
}
}
<!--1 service 和 dao 对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
<!--注入 userDao 对象
name 属性：类里面属性名称
ref 属性：创建 userDao 对象 bean 标签 id 值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
3、注入属性-内部bean
（1） 一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
部门是一，员工是多
（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
部门：
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
员工：
public class Emp {
private String ename;
private String gender;
// 员工属于某一个部门，使用对象形式表示
private Dept dept;
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public void show(){
System.out.println(ename + "::" + gender + "::" + dept);
}
}
(3) 在Spring配置文件中进行配置
<!--内部bean-->
<bean id="emp" class="com.oy.online.spring.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="jack"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.oy.online.spring.bean.Dept">
<property name="dname" value="设计部"></property>
</bean>
</property>
</bean>
测试：
@Test
public void EmpTest(){
// 加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
// 获取创建对象
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp);
emp.show();
}
4、注入属性-级联赋值
-
第一种写法
<bean id="emp" class="com.oy.online.spring.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.oy.online.spring.bean.Dept"> <property name="dname" value="技术部">property> bean> -
第二种写法
<bean id="emp" class="com.oy.online.spring.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.oy.online.spring.bean.Dept"> <property name="dname" value="技术部">property> bean>
六、IOC操作Bean管理（xml注入集合属性）
1、注入数组类型属性
2、注入List集合类型属性
3、注入Map集合属性
（1） 创建类，定义属性、list、map、set类型属性，生成对应的set方法
public class Stu {
// 1.数组类型属性
private String[] courses;
// 2. list集合类型属性
private List<String> list;
// 3.map 集合类型属性
private Map<String, String> maps;
// 4.set集合类型属性
private Set<String> set;
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 setSet(Set<String> set) {
this.set = set;
}
@Override
public String toString() {
return "Stu{" +
"courses=" + Arrays.toString(courses) +
", list=" + list +
", maps=" + maps +
", set=" + set +
'}';
}
}
（2）在Spring配置文件进行配置
<bean id="stu" class="com.oy.online.Spring.Stu">
<property name="courses">
<array>
<value>java课程value>
<value>数据库课程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="set">
<set>
<value>MySqlvalue>
<value>Redisvalue>
set>
property>
bean>
4、在集合里面设置对象类型值
在Stu中添加属性和方法：
//学生所学多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
在Spring配置文件中
<property name="courseList">
<list>
<ref bean="course1">ref>
<ref bean="course2">ref>
list>
property>
<bean id="course1" class="com.oy.online.Spring.Course">
<property name="cname" value="Spring5框架">property>
bean>
<bean id="course2" class="com.oy.online.Spring.Course">
<property name="cname" value="Mybaits框架">property>
bean>
5、把集合注入部分提取出来
（1）在Spring配置文件中引入名称 util
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
<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">
(2) 使用util标签完成list集合注入提取
<util:list id="bookList">
<value>java编程之美value>
<value>java核心卷value>
<value>MYSQL必知必会value>
util:list>
<bean id="book" class="com.oy.online.Spring.book">
<property name="list" ref="bookList">property>
bean>
七、IOC操作Bean管理（FactoryBean）
- Spring 有两种类型bean， 一种普通bean, 另外一种工厂bean(FactroyBean)
- 普通bean: 在配置文件中定义bean类型就是返回类型
- 工厂bean：在配置文件定义bean类型可以和返回类型不一样
- 第一步 创建类，让这个类为工厂bean,实现接口FactoryBean
- 第二步 实现接口里面的方法，在实现的方法中定义返回的bean类型
public class Mybean implements FactoryBean {
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
<bean id="myBean" class="com.oy.online.Spring.bean.Mybean">bean>
@org.junit.Test
public void FactoryTest(){
// 加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
// 获取创建对象
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
八、IOC操作Bean管理（bean 作用域）
1.在Spring里面，默认情况下，bean是单实例对象
@org.junit.Test
public void BookTest(){
// 加载Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
// 获取创建对象
book book1 = context.getBean("book", book.class);
book book2 = context.getBean("book", book.class);
System.out.println(book1);
System.out.println(book2);
}
2.设置单实例或多实例
- 在Spring 配置文件bean 标签里面有属性**(scope)**用于设置单实例还是多实例
- scope 属性值
- 第一个值 默认值，singleton，表示是单实例
- 第二个值 prototype, 表示第多实例对象
<bean id="book" class="com.oy.online.Spring.book" scope="prototype">
<property name="list" ref="bookList">property>
bean>
-
singleton 和 prototype 区别
-
第一 singleton 单实例，prototype 多实例
-
第二 设置scope 值是 singleton 时候，加载spring配置文件时候就会创建单实例对象。
设置scope 值是 prototype 时候，不是加载 spring 配置文件时候创建 对象，在调用 getBean 方法时候创建多实例对象。
-
九、IOC操作 Bean 管理（bean 生命周期）
1、生命周期
- 从对象创建到对象销毁的过程
2、bean 生命周期
- 通过构造器创建bean实例（无参数构造）
- 为bean 的属性设置值 和 对其他bean 引用（调用set方法）
- 调用bean 的初始化的方法（需要进行配置初始化方法）
- bean 可以使用了（对象获取到了）
- 当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）
3、演示 bean 生命周期
public class Orders {
private String oname;
// 无参构造器
public Orders(){
System.out.println("第一步 执行无参构造创建 bean 实例");
}
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调set方法设置属性值");
}
// 创建执行的初始化的方法
public void initMethod(){
System.out.println("第三步 执行初始化的方法");
}
// 创建执行的销毁的方法
public void destroyMethod(){
System.out.println("第五步 执行销毁的方法");
}
}
<bean id="orders" class="com.oy.online.Spring.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机">property>
bean>
@org.junit.Test
public void OrdersTest(){
// ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建Bean 实例对象");
System.out.println(orders);
// 手动让bean实例销毁
context.close();
}
4、bean的后置处理器，bean生命周期
- 通过构造器创建bean实例（无参构造器）
- 为bean的属性设置值和其他bean引用（调用set方法）
- **把bean的实例传递bean后置处理器的方法 **postProcessBefoInitialization
- 调用bean的初始化的方法
- 把bean实例传递bean后置处理器的方法 postProcessAfterInitialization
- bean可以使用（对象获取到了）
- 当前容器关闭时，调用bean的销毁方法（需要精心配制销毁的方法）
5、添加后置处理器
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.oy.online.Spring.bean.MybeanPost">bean>
十、IOC操作Bean管理（XML自动装配）
1、自动装配
- 根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入
2、自动装配过程
（1）根据属性名称自动注入
public class Emp {
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"dept=" + dept +
'}';
}
public void test(){
System.out.println(dept);
}
}
public class Dept {
@Override
public String toString() {
return "Dept{}";
}
}
<bean id="emp" class="com.oy.online.Spring.autowire.Emp" autowire="byName">bean>
<bean id="dept" class="com.oy.online.Spring.autowire.Dept">bean>
(2) 根据属性类型自动注入
<bean id="emp" class="com.oy.online.Spring.autowire.Emp" autowire="byType">bean>
<bean id="dept" class="com.oy.online.Spring.autowire.Dept">bean>
十一、IOC操作 Bean 管理（外部属性文件）
-
直接配置数据库信息
（1）配置德鲁伊连接池
（2）引入德鲁伊连接池依赖jar包
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driver" value="com.mysql.jdbc.Driver">property> <property name="url" value="jdbc:mysql://localhost:8080/test">property> <property name="username" value="root">property> <property name="password" value="root">property> bean>-
引入外部属性文件配置数据库连接池
(1) 创建外部属性文件，properties 格式文件，写数据库信息
prop.driverClass=com.mysql.jdbc.Driver prop.url=jdbc:mysql://localhost:8080/test prop.username=root prop.password=root (2) 把外部 properties 属性文件引入到spring配置文件中
- 引入context名称空间
- xmlns:context=“http://www.springframework.org/schema/context”
- http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
<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">- 在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、注解
（1）注解是代码的特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值…)
（2）使用注解，注解作用在类上面，方法上面，属性上面
（3）使用注解目的：简化xml 配置
2、Spring 针对Bean 管理中创建对象提供注解
（1）@Component
（2）@Service
（3）@Controller
（4）@Repository
上面四个注解功能是一样的，都可以用来创建bean实例
3、基于注解方式实现对象创建
第一步 引入依赖
第二步：开始组件扫描
<context:component-scan base-package="com.oy.online.Spring">context:component-scan>
第三步 创建类，在类上面添加创建对象的注解
//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //4、开启组件扫描细节设置
<context:component-scan base-package="com.oy.online.Spring" use-defaultfilters="false">
<context:component-scan base-package="com.oy.online.Spring">
5、基于注解方式实现属性注入
（1）@Autowired: 根据属性类型进行自动装配
第一步：把 service 和 dao 对象创建，在service 和 dao 类创建对象注解
第二步：把 service 注入 dao 对象， 在 service 类添加 dao 类型属性，在属性上面使用注解
public interface UserDao {
public void add();
}
@Repository
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao add...");
}
}
@Service
public class UserService {
// 定义dao 类型属性
// 不需要添加 set 方法
// 添加注入属性注解
@Autowired
private UserDao userDao;
public void add(){
System.out.println("service add....");
userDao.add();
}
}
测试：
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
（2）@Qualifier：根据名称进行注入
这个@Qualifier 注解的使用 ，和上面@Autowired 一起使用
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
（3）@Resource: 可以根据类型注入，可以根据名称注入
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
（4）@Value：注入普通类型的属性
@Value(value = "abc")
private String name;
6、完全注解开发
（1）创建配置类，替代xml配置文件
@Configuration // 作为配置类，替代xml 配置文件
@ComponentScan(basePackages = {"com.oy.online.Spring"})
public class SpringConfig {
}
（2）测试类
@Test
public void SpringConfigTest(){
// 加载配置类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
.out.println(userService);
userService.add();
}
（2）**@Qualifier**：根据名称进行注入
这个@Qualifier 注解的使用 ，和上面@Autowired 一起使用
~~~java
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
（3）@Resource: 可以根据类型注入，可以根据名称注入
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
（4）@Value：注入普通类型的属性
@Value(value = "abc")
private String name;
6、完全注解开发
（1）创建配置类，替代xml配置文件
@Configuration // 作为配置类，替代xml 配置文件
@ComponentScan(basePackages = {"com.oy.online.Spring"})
public class SpringConfig {
}
（2）测试类
@Test
public void SpringConfigTest(){
// 加载配置类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}