Spring-IOC容器

https://www.bilibili.com/video/BV1Vf4y127N5?p=2

目录

IOC（接口）

IOC操作Bean管理（概念）

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

IOC操作Bean管理（xml注入集合属性）

IOC操作bean管理（FactoryBean）

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

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

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

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

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

1、注解

2、Spring针对Bean管理中创建对象提供注解

3、基于注解方式实现对象创建

4、开启组件扫描的更多配置参数：(很少用)

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

6、完全注解开发

 

---

---

1,Spring 轻量级开源J2EE框架。

2，核心部分：IOC和AOP

1）控制反转，把创建对象的过程交给Spring进行管理。

2）aop，面向切面。不修改源代码进行功能增强。

特点，方便解耦，简化开发。aop编程支持。方便测试。方便集成其他框架、方便事物操作，降低开发难度。降低api开发难度。

 

spring创建普通类

public class User {
    public void add(){
        System.out.println("adding...");
    }
}

创建spring配置文件，在配置文件中配置创建的对象

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.ayguigu.spring5.User"></bean>
</beans>

测试代码

public class testAdd {
    @Test
    public void testAdd(){
        //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底层原理

（2）IOC接口（BeanFactory）

（3）IOC操作Bean管理（基于XML）

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

 

什么是IOC

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

（2）使用IOC目的。为了降低耦合度

 

IOC底层原理

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

（2）画流程图

原始方法，耦合度太高！！！

 

工厂模式：

一定程度降低了service和dao的耦合度

 

IOC解耦：

 

进一步降低耦合度

 

IOC（接口）

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

2、Spring 提供IOC容器实现两种方式（两个接口）都可以：

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

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

（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。

*加载配置文件时就会立刻把在配置文件对象进行创建（加载就创建对象）

3、ApplicationContext接口有实现类

IOC操作Bean管理（概念）

1、什么是Bean管理(创建+注入)

（1）Spring创建对象

（2）Spring注入属性

2、Bean管理操作有两种方式

（1）基于xml配置文件方式实现

（2）基于注解方式实现

 

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

1.基于xml方式创建对象

.

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

（2）bean标签有很多属性，

*id属性：唯一标识

*class属性：类的全路径，包路径+类名

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

2、基于xml方式注入属性

（1）DI：依赖注入，就是注入属性

第一种方式：使用set方式注入，

创建类，定义属性和对应的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;
    }
}

在spring配置文件配置对象创建，配置属性注入

    <!--2 set方法注入属性 -->
    <bean id="book" class="spring5.Book">
        <!--使用property完成属性注入
        name:类里面属性名称
        value：向里面注入的值
        -->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>

 

了解内容：为了简化set属性xml注入，可以用p名称空间注入。

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

创建类，定义属性，创建对象有参构造方法

public class Orders {
    /**
     * 使用有参构造注入
     */
    private String oname;
    private String address;
    //有参构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

在spring配置文件中进行配置

    <!-- 3 有参构造属性注入-->
    <bean id="order" class="spring5.Orders">
        <constructor-arg name="oname" value="computer"></constructor-arg>
         <!--或者用index="0"来注入第一个参数，即oname -->
        <constructor-arg name="address" value="China"></constructor-arg>

    </bean>

（2）xml注入其他类型属性

1、字面量（固定值）

属性是null值时：

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

属性值包含特殊符号。可以用转义符号，比如用 &gt；和&lt；代替>和<

或者：

2、注入属性-外部bean。先创建bean，再用ref调bean对象

（1）创建两个类，service类和dao类

（2）在service调用dao里面的方法

public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public  void add(){
        System.out.println("service adding。。。");
        userDao.update();
    }
}

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

3、注入属性-内部bean

（1）一对多关系：部门对员工。

一个部门有多个员工，一个员工属于一个部门。

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示。

//员工类
public class Emp {
    private String ename;
    private String gender;
    private Dept dept;

    //员工属于某一个部门，使用对象形式表示
    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}

 

（3）在spring配置文件中进行配置，

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

（4）注入属性-级联赋值

第一种写法：

    <bean id="emp" class="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="spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

（2） 第二种写法（在第一种方法基础上，在emp类生成dept对象的get方法+dept.dname）

    <bean id="emp" class="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 id="dept" class="spring5.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 setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }
}

spring配置文件：（数组，list，map，值是对象的集合）

    <!--1 集合类型属性注入 -->
    <bean id="stu" class="spring5_2.collectiontype.Stu">
        <property name="courses">
            <array>
                <value>JAVA 课程</value>
                <value>数据库课程</value>
            </array>
        </property>
        <!-- list类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <!-- maps类型属性注入 -->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <property name="set">
            <set>
                <value>Mysql</value>
                <value>Redis</value>
            </set>
        </property>
        <!-- 注入List集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>

            </list>
        </property>
    </bean>
<!--创建多个对象-->
    <bean id="course1" class="spring5_2.collectiontype.Course">
        <property name="cname" value="Spring5 框架"></property>
    </bean>
    <bean id="course2" class="spring5_2.collectiontype.Course">
        <property name="cname" value="MyBatis 框架"></property>
    </bean>

注入相同属性时，提取共同点。把集合注入部分提取出来

（1）xml配置文件引入名称空间

（2）使用util标签完成List集合注入提取

    <!--提取list集合类型属性注入-->
    <util:list id="booklist">
        <value>book1</value>
        <value>book2</value>
        <value>book3</value>
    </util:list>
    <!--提取list集合属性注入使用 -->
    <bean id="book" class="spring5_2.collectiontype.Book">
        <property name="list" ref="booklist"></property>
    </bean>

IOC操作bean管理（FactoryBean）

1、Spring 有两种bean，普通bean和工厂bean（Factorybean）

2、普通bean：在配置文件中定义bean类型就是返回类型

3、工厂bean：在配置文件中定义bean类型和返回类型可以不一样（定义类型为Mybean，返回类型为Course）

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

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

    <bean id="myBean" class="factorybean.MyBean">

public class MyBean implements FactoryBean<Course> {

    //定义返回bean对象
    @Override
    public Course getObject() throws Exception {
        Course course =new Course();
        course.setCname("abd");
        return course;
    }

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

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

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

1、在Spring中，设置创建bean实例是单实例（只有一个类对象）还是多实例（创建多个类对象）

 

2、在Spring中，默认情况下bean是单实例。

    @Test
    public void testCollection2() {
        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);
       // book.test();
    }

spring5_2.collectiontype.Book@15c43bd9
spring5_2.collectiontype.Book@15c43bd9

3、设置bean为多实例

（1）spring配置文件中bean标签中有属性（scope）设置单实例还是多实例

（2）scope属性值：singleton单实例，prototype多实例。

spring5_2.collectiontype.Book@15c43bd9
spring5_2.collectiontype.Book@3d74bf60

singleton或者默认下，加载spring xml配置文件时就会创建单实例对象。

scope设为prototype多实例时，不是在加载spring配置文件时创建对象，而在调用getBean方法时候创建多实例对象

bean还有两个用于web的属性：request一次请求，session一次对话。

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

1、生命周期，从对象创建到对象销毁的过程。

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

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

（3）调用bean的初始化方法（需要配置）

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

（5）容器关闭时，调用bean销毁的方法（进行配置销毁的方法）

public class Orders {
    private String order;

    public Orders() {
        System.out.println("第一步，执行无参构造创建bean实例");
    }
    public void setOrder(String order) {
        this.order = order;
        System.out.println("第二步，调用set方法设置属性值");
    }
    public void initMethod(){
        System.out.println("第三步，执行初始化方法");
    }
    public void destroyMethod(){
        System.out.println("第五步，获取创建bean实例对象");
    }
}

    <bean id="orders" class="bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="order" value="pizza"></property>
    </bean>

    @Test
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders=context.getBean("orders",Orders.class);
        System.out.println("第四步, 获取创建bean实例对象");
        ((ClassPathXmlApplicationContext)context).close();
    }

"C:\Program Files\Java\jdk1.8.0_181\bin\java.exe" 

第一步，执行无参构造创建bean实例
第二步，调用set方法设置属性值
第三步，执行初始化方法
第四步, 获取创建bean实例对象
第五步，获取创建bean实例对象

bean的后置处理器，bean声明周期有七步。

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

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

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

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

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

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

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

创建类，实现postProcessAfterInitialization接口，完善接口中的两个方法。

 

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

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

ByName：

    <!--
    实现自动装配，bean标签属性autowire，配置自动装配
    autowire常见注入方式取值：
    ByName,注入值bean的id值和类属性名称一样。bean中叫dpt，emp类中Dpt对象名也叫dpt
    byType，
    -->
    <bean id="emp" class="autowire.Emp" autowire="byName"></bean>
    <bean id="dpt" class="autowire.Dpt"></bean>

ByType：

    <bean id="emp" class="autowire.Emp" autowire="byType"></bean>
    <bean id="dpt" class="autowire.Dpt"></bean>

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

1、直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖

    <!--直接配置连接池-->
    <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>

2、引入外部属性文件配置数据库连接池（常用于连接数据库）

（1）创建外部属性的properties格式文件，写数据库信息。

（2）把外部properties文件引入Spring

*引入名称空间

*在Spring引入：

<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <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.usrName}"></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

*上面四个注解功能一模一样，只是习惯上使用的场景不同

3、基于注解方式实现对象创建

第一步，引入依赖

第二步，开启组件扫描(加了命名空间context)*****必备！！！

<!--开启组件扫描，
1，如果扫描多个包，逗号隔开
2，扫描包的上级目录
-->
<context:component-scan base-package="spring5_2"></context:component-scan>

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

//在注解中的value值可以不写，默认是类名的首字母小写:userService
@Service(value = "userService")//相当于<bean id="userService" class="spring5_2.service.UserService"></bean>
public class UserService {
    public void add(){
        System.out.println("service adding...");
    }
}

4、开启组件扫描的更多配置参数：(很少用)

    <!--实例1
    use-default-filters="false"表示不用默认filter，而是自己配置filter
    context:include-filter，设置扫描哪些内容。如只扫描包spring5_2的Controller
    -->
    <context:component-scan base-package="spring5_2" 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="spring5_2">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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

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

第一步，创建service和dao对象，并添加注解

第二步，在Service注入Dao对象，在service类添加dao类型属性，在属性上添加注解

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

（2）@Qualifier：根据属性名称自动装配（一个接口，多个不同名称的实现类时，适合Qualifier能区别名称来注入属性）

    @Qualifier(value = "userDaoImpl")

（3）@Resource：可以根据属性名称或类型自动装配。默认类型，加上(name=" ")可指定名称

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

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

6、完全注解开发

（1）创建配置类，替代xml配置文件

（2）编写测试类