1.spring系统架构
自底而上进行,上层依赖于下层,首先最底层是Core Container -- 核心容器, 再往上是AOP(面向切面编程)和Aspects(AOP)思想的实现, 我个人的理解是, 它可以在不惊动你原始程序的基础上, 给它增强功能，类似于反射；再往上是数据访问层。
Core Container中包含：1. IoC/DI 2.IoC容器 3.Bean
有人就要问了, 为啥会出现Core Container这个概念呢?
提供两段代码来解释一下?
1. 业务层
public class BookServiceImpl implements BookService{
private BookDao bookDao = new BookDaoImpl();
//父类的接口的引用指向子类的实现 (多态中的向上转型)
public void save(){
bookDao.save();
}
}
2. 数据层实现
public class BookDaoImpl implments BookDao{
//在BookDao接口中定义抽象方法save, 在子类中进行实现
public void save(){
System.out.prinln("book dao save....")
}
}
public class BookDaoImpl2 implments BookDao{
//另一个类去实现BookDao, 重写父接口中的save接口
public void save(){
System.out.prinln("book dao save....2")
}
}
如果你想要替换数据层的实现, 就要去修改业务层的代码
代码书写现状: 耦合度高
解决方案：
使用对象时, 在程序中不要主动使用new产生对象,转换为由外部提供对象, (在业务层内部只去写引用)
IoC -> 控制反转
对象的创建控制权由程序转移到外部, 这种思想称为控制反转
Spring技术对IoC思想进行了实现
-Spring提供了一个容器, 称为IoC容器, 用来充当IoC思想中的"外部", 简单来说这个容器就是来创建对象用的
IoC容器负责对象的创建,初始化等一系列工作, 被创建或被管理的对象在IoC容器中统称为Bean
DI (依赖注入)
如果容器中有两个Bean存在着依赖关系,IoC会自动给你进行绑定目标: 充分解耦
1. 使用IoC容器管理bean(IOC)
2. 在IoC容器内将依赖关系的bean进行关系绑定(DI)
最终效果
使用对象时不仅可以直接从IOC容器中获取, 并且获取到的bean已经绑定了所有的依赖关系
在IDEA中如何实现呢?
1. 手把手教你创建springboot的工程
file->Module(模版)->spring initializr(初始化)->添加spring web模块->Create创建就好了springboot工程
2. 认识一下pom.xml这个配置文件
<dependencies></dependencies> 所有的依赖(导包-坐标)全写到这个里面, <build></build> 里面是相关的插件
3. 然后在resources中, XML Configuration File中创建Spring Config配置文件applicationContext.xml文件, 一定要在pom.xml中导入spring的坐标spring-context(不用写版本号,spring-boot会自动帮你进行管理版本的)4.在applicationContext.xml中配置想要管理对象的bean
<?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: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 https://www.springframework.org/schema/util/spring-util.xsd">
<!-- 配置bean-->
<!--
id属性表示给bean取一个名字
加载对应的类(相关类信息),class属性给bean定义类型,
解读：在spring容器中的bean, 是为了创建对象, bean的类型就是对象的类名
-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDapImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServicelmpl">
<!--
1. 配置bookDao和bookService之间的关系
name属性表示配置bookService中的哪一个具体的属性
ref属性表示参照哪一个bean的id(待注入的)
-->
<property name="bookDao" ref="bookDao"/>
</bean>
</beans>在创建一个App2文件
package com.itheima;
import com.itheima.dao.impl.BookDao;
import com.itheima.service.impl.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@SuppressWarnings({"all"})
public class APP2 {
public static void main(String[] args) {
//获取ioc容器, 配置文件当做参数 => 接口 a=new 实现子类() ,经典多态(向下转型)
//接口是不能new对象的, 只有类才可以
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); //作用：加载配置文件, 参数为config文件名
//从ioc容器中获取bean, 使用id获取
BookDao bookDao = (BookDao)ctx.getBean("bookDao"); //多态的向下转型
bookDao.save();
BookService bookService = (BookService)ctx.getBean("bookService");
bookService.save();
}
}
删除使用new的方式创建的bookDao对象，同时提供set方法
package com.itheima.service.impl;
import com.itheima.dao.impl.BookDao;
import com.itheima.dao.impl.BookDapImpl;
@SuppressWarnings({"all"})
public class BookServicelmpl implements BookService{
// private BookDao bookDao = new BookDapImpl();
private BookDao bookDao;
public void save(){
System.out.println("book service save....");
bookDao.save();
}
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}//这个set方法是容器进行调用的
}
//在BookServiceImpl需要一个BookDao对象,IOC容器会负责创建这个对象并将其注入到BookServiceImpl中, 这样就实现了依赖注入
在applicationContext.xml文件中配置依赖, 往Service中注入BookDao的依赖
bean的配置：
功能：定义Spring核心容器管理的对象
格式:
<beans>
<bean/>
<bean></bean>
</beans>
id: bean的id, 使用容器可以通过id值获取对应的bean, 在一个容器中id值唯一
class: bean的类型, 即配置的bean的全路径类名
name: 给bean取别名, 可定义多个, 使用逗号(,) 分号(;) 空格()分隔
<bean id="bookDao" name="bookDao1,bookDao2" class="com.itheima.dao.impl.BookDapImpl"/>后续的话, 就可以使用.getBean(bookDao1)获取对应的实现类
bean的作用范围: 在IOC容器中创建的bean, 默认是单列的(就是你getBean两个同一个实现子类, 他的引用(对象)是一样的), 如果想变成双列的, 就需要添加scope属性
<bean id="bookDao" class="com.itheima.dao.impl.BookDapImpl" scope="singleton"/> => 默认 => 对象一样<bean id="bookDao" class="com.itheima.dao.impl.BookDapImpl" scope="prototype"/>
=> 对象不一样
为什么bean默认是单列的？
我的理解是, 在容器中创建了一个bean, 你想要getBean一个对象, 然后调用相关的方法, 下一次你还想调用方法的话, 可以直接使用先前getBean的对象, 不用再创建一个新的Bean了
bean的实例化
bean本质上就是对象
1.spring创建bean使用构造方法完成
2. 使用(静态)工厂创建bean
3. 使用(实例)工厂创建bean
package com.itheima.dao.impl;
public class BookDapImpl implements BookDao{
private BookDaoImpl(){
System.out.println("book dao constructor is running.....");
}
public void save() {
System.out.println("book dao save.....");
}
}
你使用getBean进行创建对象的时候, 其实会调用BookDaoImpl这个构造方法,
所以就证明了spring底层也是通过new的方式进行创建对象的
注：这里使用了反射的爆破, 所以才会加载private构造方法
注：更准确的是spring底层调用的是无参构造方法 <bean id="bookDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao()"/> //factory-method属性指定工厂中那个方法是进行创建对象
public class OrderDaoFactory{
public static OrderDao getOrderDao(){
return new OrderDaoIml();
}
}public class UserDaoFactory{
public UserDao getUserDao(){
return new UserDaoImpl();
}
}
先创建工厂bean
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userFactory" factory-method="getUserDao" factory-bean="UserFactory"/>bean生命周期
package com.itheima.dao.impl;
public class BookDapImpl implements BookDao{
public void save() {
System.out.println("book dao save.....");
}
public void init(){
System.out.println("init....");
}
public void destory(){
System.out.println("destory....");
}
}
配置文件中：添加init-method/destory-method属性
<bean id="bookDao" class="com.itheima.dao.impl.BookDapImpl" init-method="init" destory-method="destory"/>
注：想在容器中关闭spring容器,
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook(); //如果在关虚拟机之前先把它的容器关了, 动态一点儿
//ctx.close();
接口形式：
public class BookDapImpl implements BookDao,InitalizingBean, DisposableBean{
public void save(){};
public void afterPropertiesSet throw(){};
public void destory(){};
}bean声明周期
初始化容器
1. 创建对象(内存分配)
2. 执行构造方法
3. 执行属性注入(set操作)
4. 执行bean初始化方法(init-method="init")
使用bean
1. 执行业务操作
关闭/销毁容器
1. 执行bean销毁方法
帮助你更好的理解面试八股文
