SSM框架学习(Day-1)-优快云博客

本文链接：https://blog.youkuaiyun.com/Script_Kids/article/details/146924150

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(){};
}