Spring5学习笔记(1):IOC

1 Spring简介

Spring是轻量级的开源javaee框架，能够解决企业开发的复用性。有两个核心部分：IOC和AOP。Spring有很多特点，如方便解耦，简化开发；方便测试；方便与其他框架进行整合、方便进行事务操作等。

2 Spring入门案例

必须导入下面几个包：

目录结构如下：

创建一个普通类：
User.java:

package com.wzc.spring;

public class User {

    public void add(){
        System.out.println("add+++++++++++++++");
    }
}

配置Spring文件，在配置文件中创建对象

<?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.wzc.spring.User"></bean>
</beans>

编写测试代码：

package com.wzc.spring.test;

import com.wzc.spring.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

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

3 IOC

3.1 IOC概念

①IOC即Inversion of Control，控制反转，它将对象创建和对象之间的调用使用Spring框架进行管理
②使用IOC方式可以降低对象之间的耦合度
③上面的入门案例就是使用IOC方法进行实现的

3.2 IOC底层原理

核心：xml解析、工厂模式、反射
IOC过程：
1.配置xml文件，配置创建对象

<bean id="dao" class="com.wzc.UserDao"></bean>

2.有service类和dao类，创建工厂类

class UserFactory{
public static UserDao getDao(){
	String classValue = class属性值; //1 xml解析
	Class clazz = Class.forName(classValue);//2.通过反射创建对象
	return (UserDao)clazz.newInstance();
	}
}

3.3 IOC接口

IOC是基于IOC容器完成的，IOC容器底层就是对象工厂
Spring中IOC容器实现的两种方式：
BeanFactory:IOC容器基本实现，Spring内部使用的接口，不提供给开发人员使用(加载配置文件时不会创建对象)
ApplicationContext:BeanFactory接口的子接口，有更多更强大的功能，提供给开发人员使用(加载配置文件时会把配置文件对象进行创建)，有两个实现类

4 IOC操作Bean管理

4.1 Bean管理

Bean的管理主要有两个操作：
Spring操作创建对象、Spring操作注入属性
Bean的管理操作有两个方式：
基于xml文件配置、基于注解实现方式

4.2 基于xml方式创建对象

<bean id="user" class="com.wzc.spring.User"></bean>

在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性实现对象创建
id 属性：唯一标识
class 属性：类全路径（包类路径）
注意：创建对象时候，默认也是执行无参数构造方法完成对象创建，因此在创造bean时需要无参构造器

4.3 基于xml方式注入属性

DI：依赖注入
DI是IOC的一种实现，但注入属性需要在创建对象的基础之上进行完成

4.3.1 使用set方法进行注入

1.创建类，定义属性和对应的set方法
Book.java:

package com.wzc.spring;

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 printMessage(){
        System.out.println("name = " + bname + ", author = " + bauthor);
    }
}

2.在spring配置文件配置对象创建和属性注入
bean.xml:

 <!--2 set方法注入属性-->
    <bean id="book" class="com.wzc.spring.Book">
        <!-- 使用property完成属性注入
            name:类里面属性的名称
            value:向属性注入的值
        -->
        <property name="bname" value="哈利波特"></property>
        <property name="bauthor" value="JK罗琳"></property>
    </bean>

4.3.2 使用有参构造器进行注入

1.创建类，定义属性，创造对应属性的有参方法
Orders.java:

package com.wzc.spring;

/**
 * 使用有参构造注入
 */

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参构造
    public Orders(String oname, String address){
        this.oname = oname;
        this.address = address;
    }

    public void printMessage(){
        System.out.println("name = " + oname + ", address = " + address);
    }
}

2.在spring配置文件中进行配置

    <!--3 使用有参构造器进行注入 -->
    <bean id="order" class="com.wzc.spring.Orders">
        <constructor-arg name="oname" value="computer"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

4.4 基于xml方式注入其他类型的属性

4.4.1 注入null

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

4.4.2 属性值带特殊符号

<property name="address">
 <value><![CDATA[xxxxx]]></value>
</property>

xxx为所写得整个内容

4.4.3 属性注入-外部bean的注入

1.创建service类和dao类
2.在service调用dao里的方法
3.在spring类中进行配置
UserService .java:

package com.wzc.spring.service;

import com.wzc.spring.dao.UserDao;

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

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">
    <!-- 创建service和dao对象-->
    <bean id="userService" class="com.wzc.spring.service.UserService">
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <bean id="userDaoImpl" class="com.wzc.spring.dao.UserDaoImpl"></bean>
</beans>

4.4.4 属性注入-内部bean

员工与部门：多对一的关系
部门类
Dept.java:

package com.wzc.spring.bean;

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

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

员工类：
Emp.java:

package com.wzc.spring.bean;

public class Emp {
    private String ename;
    private String gender;
    private Dept dept;

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

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

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

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">
    <!--内部bean-->
    <bean id="emp" class="com.wzc.spring.bean.Emp">
        <property name="name" value="luke"></property>
        <property name="gender" value="woman"></property>
        <!--对象类属性赋值 -->
        <property name="dept">
            <bean id="dept" class="com.wzc.spring.bean.Dept">
                <property name="dname" value="财务部"></property>
            </bean>
        </property>
    </bean>
</beans>

4.4.5 属性注入-级联赋值

方式一：

    <bean id="emp1" class="com.wzc.spring.bean.Emp">
        <property name="name" value="Jooker"></property>
        <property name="gender" value="man"></property>
        <property name="dept" ref="dept1"></property>
    </bean>
    <bean id="dept1" class="com.wzc.spring.bean.Dept">
        <property name="dname" value="住宿部"></property>
    </bean>

方式二：
需要在Emp类中生成相应的方法

    public Dept getDept() {
        return dept;
    }

    <bean id="emp1" class="com.wzc.spring.bean.Emp">
        <property name="name" value="Jooker"></property>
        <property name="gender" value="man"></property>
        <property name="dept" ref="dept1"></property>
        <property name="dept.dname" value="金钱部"></property>
    </bean>
    <bean id="dept1" class="com.wzc.spring.bean.Dept">
        <property name="dname" value="技术部"></property>
    </bean>

4.4.6 xml注入集合属性

1.创建类，定义数组、list、map、set类型，并生成相应的set方法
Stu.java:

package com.wzc.spring.collectiontype;

import java.util.List;
import java.util.Map;
import java.util.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;
    }

    public void Message(){
        System.out.println(courses);
        System.out.println(list);
        System.out.println(maps);
        System.out.println(set);
    }
}

2.在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">
    <!--1 集合类型的属性注入-->
    <!-- 数组类型属性注入-->
    <bean id="stu" class="com.wzc.spring.collectiontype.Stu">
        <!-- 数组类型注入 -->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>mysql课程</value>
            </array>
        </property>
        <!-- list 类型注入 -->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <!-- map类型注入 -->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--  set类型注入  -->
        <property name="set">
            <set>
                <value>Mysql</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>
</beans>

注意一下两点：
1.在集合中设置对象类型值：

<!--创建多个类型course对象 -->
    <bean id="course1" class="com.wzc.spring.collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.wzc.spring.collectiontype.Course">
        <property name="cname" value="Mybatis框架"></property>
    </bean>
   <!-- 注入list集合-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

2.可以将集合部分提取出来

<?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">
    <!-- 提取list集合类型属性注入 -->
    <util:list id="namelist">
        <value>哈哈哈</value>
        <value>wodetian</value>
        <value>jule</value>
    </util:list>

    <!-- 提取list集合类型属性注入使用-->
    <bean id="stu1" class="com.wzc.spring.collectiontype.Stu">
        <property name="list" ref="namelist"></property>
     </bean>
</beans>

4.4.7 FactoryBean

Spring有两种类型的bean
1.普通bean：在配置文件中定义bean类型就是返回值类型
2.工厂bean：配置文件中定义的bean类型可以与返回类型不一样
①创建类，让该类作为工厂bean，实现接口FactoryBean
②实现接口中的方法，在实现的方法中定义返回bean的类型
Mybean.java:

package com.wzc.spring.factorybean;

import com.wzc.spring.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course> {
    @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.wzc.spring.factorybean.MyBean"></bean>

测试方法

   @Test
    public void testBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

4.4.8 bean的作用域

1.在spring中默认bean是单实例对象
设置方法bean标签中有scope属性用来设置：
默认值为singleton，代表单实例对象；prototype表示多实例对象

<bean id="myBean" class="com.wzc.spring.factorybean.MyBean" scope="prototype"></bean>

2.singleton和prototype的区别
①singleton表示单实例对象，此时造出的都是同一个对象，地址值相同；prototype表示多实例对象，此时造出的对象地址值不同。
②scope 值为 singleton 时，加载 spring 配置文件时候就会创建单实例对象
scope 值为 prototype 时，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象

4.4.9 bean的生命周期

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

主要有以下五步：
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化方法
第四步 获取bean实例对象
第五步 执行销毁方法

Orders.java:

package com.wzc.spring.collectiontype;

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 destMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

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">
        <bean id="orders" class="com.wzc.spring.collectiontype.Orders" init-method="initMethod" destroy-method="destMethod">
            <property name="oname" value="手机"></property>
        </bean>
</beans>

    @Test
    public void testBean1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取bean实例对象");
        System.out.println(orders);
        //手动让bean实例销毁
        context.close();
    }

还可以配置后置处理器，共有七步
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
第三步 把bean实例传给bean的后置处理器方postProcessBeforeInitialization
第四步 执行初始化方法
第五步 把bean实例传给bean的后置处理器方postProcessAfterInitialization
第六步 获取bean实例对象
第七步 执行销毁方法
后置处理器类：

package com.wzc.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

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;
    }
}

配置方法：

<?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">
        <bean id="orders" class="com.wzc.spring.collectiontype.Orders" init-method="initMethod" destroy-method="destMethod">
            <property name="oname" value="手机"></property>
        </bean>


        <!--配置后置处理器  -->
        <bean id="myBeanPost" class="com.wzc.spring.bean.MyBeanPost"></bean>
</beans>

4.4.10 自动装配

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

    <!--实现自动装配
     bean 标签属性 autowire，配置自动装配
     autowire 属性常用两个值：
     byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
     byType 根据属性类型注入
    -->
    <bean id="emp" class="com.wzc.spring.autowire.Emp" autowire="byType">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>

    <bean id="dept" class="com.wzc.spring.autowire.Dept"></bean>

4.4.11 引入外部属性对象

1.配置Druid连接池

    <!-- 直接配置连接池   -->
    <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/test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

2.建立jdbc.properties文件，配置相应的设置

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

3.进行spring配置

    <!-- 引入外部属性文件    -->
    <context:property-placeholder location="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.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

4.5 基于注解方式的Bean管理

注解是代码的特殊标记；注解可以在类、方法、属性上面使用；使用注解可以简化xml文件的配置
格式：@注解名称(属性名称=属性值，属性名称=属性值)

在spring中可以提供下面四个注解来创建对象
@Component
@Service
@Controller
@Repository
以上四个注解都可以创建Bean的实例

4.5.1 基于注解方式创建对象

首先在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"
       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">

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

</beans>

然后创建类，在类上添加注解对象

package com.wzc.spring.service;

import org.springframework.stereotype.Component;

//注解中的value可以不写，默认值为类名称，首字母小写
@Component(value = "userService")  //<bean id="userService" class=".." >
public class UserService {

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

运行测试类后，Bean对象已经被创建

4.5.2 组件扫描配置

例子一

<!--se-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容-->
    <context:component-scan base-package="com.wzc.spring" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

例子二

    <!--
     下面配置扫描包所有内容
     context:exclude-filter： 设置哪些内容不进行扫描
    -->
    <context:component-scan base-package="com.wzc.spring.service">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
    </context:component-scan>

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

@Autowired：根据属性类型进行自动装配
@Qualifier：根据名称进行注入(入Dao接口可能有多个实现类，所以要根据名称来进行标注)
这两个注解经常一起使用

package com.wzc.spring.service;

import com.wzc.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

//注解中的value可以不写，默认值为类名称，首字母小写
//@Component(value = "userService")  //<bean id="userService" class=".." >
@Service
public class UserService {

    //定义dao类型
    //不需要添加set方法
    //添加注入属性注解
    @Autowired //根据类型进行注入
    @Qualifier(value = "userDaoImpl1")  //根据名称进行注入
    private UserDao userDao;

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

    @Override
    public String toString() {
        return "UserService{}";
    }
}

package com.wzc.spring.dao;

import org.springframework.stereotype.Repository;

@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{

    @Override
    public void add() {
        System.out.println("Dao add................");
    }
}

@Resource：可以根据类型注入，也可以根据名称注入
该注解再javax.annotation包中，高版本的java jdk没有

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

@Value：注入普通类型属性

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

参考资料：
[1]尚硅谷spring5