Spring（一）Spring 入门&IOC介绍

Spring系列笔记
Spring（一）Spring 入门&IOC介绍.
Spring（二）基于注解的IOC配置及实现crud.
Spring（三）AOP及基于XML和注解的AOP配置.
Spring（四）JdbcTemplate及Spring事务控制.

1.Spring概述

1.1.Spring是什么

• Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。

1.2.Spring 的优势

• 方便解耦，简化开发
  通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造
  成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可
  以更专注于上层的应用。
• AOP 编程的支持
  通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。
• 声明式事务的支持
  可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
• 方便程序的测试
  可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
• 方便集成各种优秀框架
  Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
• 降低 JavaEE API 的使用难度
  Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。
• Java 源码是经典学习范例
  Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

1.3.Spring体系结构

2. IOC的概念和作用

2.1.程序的耦合

• 内聚与耦合
  1.内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
  2.内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
• 在开发中，有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的
• 举例说明
  
  早期我们的 JDBC 操作，注册驱动时，我们为什么不使用 DriverManager 的 register 方法，而是采用 Class.forName 的方式？原因就是：我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要修改源码来重新数据库驱动。这显然不是我们想要的。

2.2.解耦

2.2.1.解决程序耦合的思路

• 当是我们讲解 jdbc 时，是通过反射来注册驱动的此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。同时，也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改源码。解决这个问题也很简单，使用配置文件配置。

2.2.2.工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
模拟工厂

业务层接口

package com.xuexi.service;

/**
 * @author liuyongjun
 * @date 2020-05-27-16:09
 * 业务层的接口
 */
public interface AccountService {
    /**
     *模拟保存账户
     **/
    void saveAccount();

}

业务层实现类

package com.xuexi.service.impl;

import com.xuexi.dao.AccountDao;
import com.xuexi.factory.BeanFactory;
import com.xuexi.service.AccountService;

/**
 * @author liuyongjun
 * @date 2020-05-27-16:12
 */
//账户的业务层实现类
public class AccountServiceImpl implements AccountService {
//    private AccountDao accountDao = new AccountDaoImpl();

    private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
    public void  saveAccount(){
        int i = 1;
        accountDao.saveAccount();
        System.out.println(i);
        i++;
    }
}

持久层接口

public interface AccountDao {

    void saveAccount();
}

持久层实现类

public class AccountDaoImpl implements AccountDao {

    public void saveAccount() {
        System.out.println("保存了账户d");
    }
}

模拟一个表现层

//模拟一个表现层，用于调用业务层
public class Client {
    public static void main(String[] args) {
//        AccountService as = new AccountServiceImpl();
        for(int i=0;i<5;i++) {
            AccountService as = (AccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }
    }
}

代理工厂

package com.xuexi.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * @author liuyongjun
 * @date 2020-05-27-16:45

 * 一个创建Bean对象的工厂
 *
 * Bean：在计算机英语中，有可重用组件的含义。
 * JavaBean：用java语言编写的可重用组件。
 *      javabean >  实体类
 *
 *   它就是创建我们的service和dao对象的。
 *
 *   第一个：需要一个配置文件来配置我们的service和dao
 *           配置的内容：唯一标识=全限定类名（key=value)
 *   第二个：通过读取配置文件中配置的内容，反射创建对象
 *
 *   我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;
    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

配置文件Bean.properties

accountService = com.xuexi.service.impl.AccountServiceImpl
accountDao = com.xuexi.dao.impl.AccountDaoImpl

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

• 所谓工厂：就是负责给我们从容器中获取指定对象的类。而所谓容器，在上面的工厂模式解耦时，在应用加载时，创建一个 Map，用于存放三层对象。我们把这个 map 称之为容器。

2.2.3.控制反转-Inversion Of Control

原来：我们在获取对象时，都是采用 new 的方式。是主动的。（如左图）
现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。（如右图）
这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一。

• 再次明确ioc 的作用：
  削减计算机程序的耦合(解除我们代码中的依赖关系)。

3.使用 spring 的 IOC 解决程序耦合

3.1.准备 spring 的开发包

注：
spring5 版本是用 jdk8 编写的，所以要求我们的 jdk 版本是 8 及以上。
同时 tomcat 的版本要求 8.5 及以上。

3.2.基于 XML 的配置

• 第一步：配置pom.xml文件，加入jar包
  配置内容：
  
  maven自动调jar包：
  
• 第二步：在resources下创建一个任意名称的 xml 文件（不能是中文）
  
• 第三步：让 spring 管理资源，在配置文件中配置 service 和 dao

<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
 id 属性：对象的唯一标识。
 class 属性：指定要创建对象的全限定类名
-->
<!-- 配置 service --> 
<bean id="accountService"class="com.xuexi.service.impl.AccountServiceImpl"></bean>
<!-- 配置 dao --> 
<bean id="accountDao" class="com.xuexi.dao.impl.AccountDaoImpl"></bean>

• 第四步测试配置是否成功

//模拟一个表现层，用于调用业务层
public class Client {
    /**
     * 获取spring的Ioc核心容器，并根据id获取对象
     *
     * ApplicationContext的三个常用实现类：
     *      ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
     *      FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
     *
     *      AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。
     *
     * 核心容器的两个接口引发出的问题：
     *  ApplicationContext:     单例对象适用              采用此接口
     *      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
     *
     *  BeanFactory:            多例对象使用
     *      它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。
     * @param args
     */
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\zhy\\Desktop\\bean.xml");
        //2.根据id获取Bean对象
        AccountService as  = (AccountService)ac.getBean("accountService");
        AccountDao adao = ac.getBean("accountDao",AccountDao.class);

        System.out.println(as);
        System.out.println(adao);
        as.saveAccount();

    }
}

结果：

3.3.ApplicationContext 接口的常用实现类

ClassPathXmlApplicationContext	FileSystemXmlApplicationContext	AnnotationConfigApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种	它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。	当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

3.4.BeanFactory 和ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：

• 创建对象的时间点不一样：
• ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
• BeanFactory：什么使用什么时候创建对象。

3.5.Spring 基于 XML 的 IoC 详解

3.5.1.bean 标签

id

• 作用：
  　　用于配置对象让 spring 来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
• 属性：
  • id：给对象在容器中提供一个唯一标识。用于获取对象。
  • class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
  • scope：指定对象的作用范围。
    • singleton :默认值，单例的.
    • prototype :多例的.
    • request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
    • session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
    • global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
  • init-method ：指定类中的初始化方法名称。
  • destroy-method ：指定类中销毁方法名称。
  • factory-bean ： 指定工厂 Bean 对象的唯一标识 (Id)，将通过工厂创建对象
  • destroy-method ： 指定工厂中创建对象的方法，Spring 会通过该方法来创建对象。

3.5.2.bean 的作用范围和生命周期

• 单例对象：scope=“singleton”
  • 一个应用只有一个对象的实例。它的作用范围就是整个引用。
  • 生命周期：
    • 对象出生：当应用加载，创建容器时，对象就被创建了。
    • 对象活着：只要容器在，对象一直活着。
    • 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
• 多例对象：scope=“prototype”
  • 每次访问对象时，都会重新创建对象实例。
  • 生命周期：
    • 对象出生：当使用对象时，创建新的对象实例。
    • 对象活着：只要对象在使用中，就一直活着。
    • 对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

3.5.3.实例化 Bean 的三种方式

1. 使用默认无参构造方法

<bean id="accountService" class="com.xuexi.service.impl.AccountServiceImpl"></bean>

在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

2. 使用实例工厂的方法

/**
 * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
 */
public class InstanceFactory {

    public IAccountService getAccountService(){
        return new AccountServiceImpl();
    }
}

<bean id="instanceFactory" class="com.xuexi.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

3. 使用静态工厂的静态方法

/**
 * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
 */
public class StaticFactory {

    public static IAccountService getAccountService(){

        return new AccountServiceImpl();
    }
}

<bean id="accountService" class="com.xuexi.service.impl.AccountServiceImpl"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>

因为是静态工厂，所以无需先创建工厂，直接通过工厂的静态方法来创建对象。（使用某个类中的静态方法创建对象，并存入spring容器)

3.6.Spring 的依赖注入

3.6.1.依赖注入的概念

• 依赖注入（Dependency Injection，缩写 DI）是 Spring 框架核心 IoC 的具体实现。当我们把对象的创建交给了 Spring 后，虽然降低了对象间的依赖关系，但是并不会消除。比方说：业务层仍然会调用持久层的方法。那么业务层和持久层的依赖关系，也要靠 Spring 来进行维护。也就是说，当 Spring 在创建业务层对象的时候，会帮我们把持久层对象传入到业务层中，而不用我们自己去获取。
• 在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护： 就称之为依赖注入。

3.6.2.构造注入

• 构造注入指的是，通过类中的构造方法给成员变量赋值。这个赋值的操作并不是我们做的，而是通过配置的方式，让 Spring 框架来为我们注入。具体代码如下：

public class AccountServiceImpl implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

<!--构造注入：
        使用的标签:constructor-arg
        标签出现的位置：bean标签的内部
        标签中的属性
            type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
            name：用于指定给构造函数中指定名称的参数赋值                                        常用的
            =============以上三个用于指定给构造函数中哪个参数赋值===============================
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

        优势：
            在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
        弊端：
            改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。
    -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

3.6.3.set 方法注入

• 通过类中的 setXxx() 方法给成员变量赋值。具体代码如下：

public class AccountServiceImpl2 implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }


}

<!-- set方法注入                更常用的方式
        涉及的标签：property
        出现的位置：bean标签的内部
        标签的属性
            name：用于指定注入时所调用的set方法名称
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
        优势：
            创建对象时没有明确的限制，可以直接使用默认构造函数
        弊端：
            如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
    -->
    <bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
        <property name="name" value="TEST" ></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>
<!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

3.6.4.注入集合属性

• 就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下：

public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void  saveAccount(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

<!-- 复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签：
            list array set
        用于个Map结构集合注入的标签:
            map  props
        结构相同，标签可以互换
    -->
    <bean id="accountService3" class="com.xuexi.service.impl.AccountServiceImpl3">
        <property name="myStrs">

            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="mySet">

            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myMap">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>

        </property>

        <property name="myProps">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>
    </bean>