Spring(一)

2020-06-10

1. Spring概述

1.1 Spring概述

1.1.1 Spring介绍

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

1.1.2 Spring的发展历程

1997年IBM提出了EJB的思想

1998年，SUN制定开发标准规范EJB1.0

1999年，EJB1.1发布

2001年，EJB2.0发布

2003年，EJB2.1发布

2006年，EJB3.0发布

Rod Johnson（spring之父）

Expert One-to-One J2EE Design and Development(2002)

阐述了J2EE使用EJB开发设计的优点及解决方案

Expert One-to-One J2EE Development without EJB(2004)

阐述了J2EE开发不使用EJB的解决方式（Spring雏形）

1.1.3 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.1.4 Spring的体系结构

1.2 程序的耦合和解耦

1.2.1 什么是程序的耦合

我们在开发中，会写很多的类，而有些类之间不可避免的产生依赖关系，这种依赖关系称之为耦合。

有些依赖关系是必须的，有些依赖关系可以通过优化代码来解除的。请看下面的示例代码：

/**
 * 客户的业务层实现类
 */
public class CustomerServiceImpl implements ICustomerService {
	
    private ICustomerDao customerDao = new CustomerDaoImpl();	
}

上面的代码表示：业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种依赖关系就是我们可以通过优化代码解决的。

再比如：

下面的代码中，我们的类依赖了MySQL的具体驱动类，如果这时候更换了数据库品牌，我们需要改源码来修改数据库驱动。这显然不是我们想要的。

public class JdbcDemo1 {
	
    /**
     * JDBC操作数据库的基本入门中存在什么问题？
     * 	  导致驱动注册两次是个问题，但不是严重的。
     * 	  严重的问题：是当前类和mysql的驱动类有很强的依赖关系。
     * 			     当我们没有驱动类的时候，连编译都不让。
     * 那这种依赖关系，就叫做程序的耦合
     * 
     * 我们在开发中，理想的状态应该是：
     * 	  我们应该尽力达到的：编译时不依赖，运行时才依赖。
     * 	 
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //1.注册驱动
        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        //Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        //3.获取预处理sql语句对象
        //4.获取结果集
        //5.遍历结果集
    }
}

1.2.2 解决程序耦合的思路

当是我们讲解jdbc时，是通过反射来注册驱动的，代码如下：

1	Class.forName("com.mysql.jdbc.Driver");

这时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除mysql的驱动jar包，依然可以编译。但是因为没有驱动类，所以不能运行。

不过，此处也有个问题，就是我们反射类对象的全限定类名字符串是在java类中写死的，一旦要改还是要修改源码。

解决这个问题也很简单，使用配置文件配置。

1.2.3 工厂模式解耦

在实际开发中我们可以把所有的dao和service和action对象使用配置文件配置起来，当启动服务器应用加载的时候，通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。

1.2.4 控制反转-Inversion Of Control

上面解耦的思路有2个问题：

1、存哪去？

分析：由于我们是很多对象，肯定要找个集合来存。这时候有Map和List供选择。

到底选Map还是List就看我们有没有查找需求。有查找需求，选Map。

所以我们的答案就是：

在应用加载时，创建一个Map，用于存放action，Service和dao对象。

我们把这个map称之为容器。

2、还是没解释什么是工厂？

工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。

原来：

我们在获取对象时，都是采用new的方式。是主动的。

现在：

我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

这种被动接收的方式获取对象的思想就是控制反转，它是Spring框架的核心之一。

它的作用只有一个：削减计算机程序的耦合。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

2. 使用Spring的IOC解决程序耦合

2.1 案例的前期准备

本章我们使用的案例是，客户的业务层和持久层的依赖关系解决。在开始Spring的配置之前，我们要先准备一下环境。由于我们是使用Spring解决依赖关系，并不是真正的要做增伤改查操作，所以此时我们没必要写实体类。并且我们在此处使用的是java工程，不是java web工程。

2.1.1 准备Spring的开发包

官网：http://spring.io/ 
下载地址：
http://repo.springsource.org/libs-release-local/org/springframework/spring
解压:(Spring目录结构:)
    * docs		:API和开发规范.
    * libs		:jar包和源码.
    * schema	:约束.

2.1.2 创建业务层接口和实现类

/**
 * 模拟：客户的业务层接口
 *
 * @author wgy
 */
public interface ICustomerService {

    /**
     * 保存客户
     */
    void saveCustomer();
}

/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
public class CustomerServiceImpl implements ICustomerService {

   private ICustomerDao customerDao = new CustomerDaoImpl();//此处有依赖关系

    @Override
    public void saveCustomer() {
        System.out.println("业务层调用持久层");
        customerDao.saveCustomer();
    }

}

2.1.3 创建持久层接口和实现类

/**
 * 模拟一个客户dao
 *
 * @author wgy
 */
public interface ICustomerDao {

    /**
     * 保存客户
     */
    void saveCustomer();

}

/**
 * 模拟客户的持久层实现类
 *
 * @author wgy
 */
public class CustomerDaoImpl implements ICustomerDao {

    @Override
    public void saveCustomer() {
        System.out.println("持久层保存了客户");
    }

}

2.2 基于XML的配置（入门案例）

2.2.1 拷贝必备的jar包

2.2.2 在类根路径下创建任意名称的xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- 导入schema约束
约束的位置在:
	..\spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html文件中。
-->
<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">
</beans>

2.2.3 把资源交给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">

    <!-- 配置资源：把对象的创建交给spring来管理 -->
    <bean id="customerService" class="com.wgy.service.impl.CustomerServiceImpl"/>

    <bean id="customerDao" class="com.wgy.dao.impl.CustomerDaoImpl"/>
</beans>

2.2.4 测试配置是否成功

/**
 * spring的入门案例
 *
 * @author wgy
 */
public class Client {

    /**
     * ClassPahtXmlApplicationContext：它是只能加载类路径下的配置文件			我们用这个
     * FileSystemXmlApplicationContext：它是可以加载磁盘任意位置的配置文件
     *
     * @param args
     */
    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据bean的id获取对象
        ICustomerService cs = (ICustomerService) ac.getBean("customerService");
        cs.saveCustomer();
    }
}

2.3 Spring基于XML的IOC细节

2.3.1 Spring中工厂的类结构图

2.3.1.1 Bean创建的两种规则

BeanFactory:
    提供的是一种延迟加载思想来创建bean对象。bean对象什么时候用什么时候创建
ApplicationContext
    提供的是一种立即加载思想来创建bean对象。只要一解析完配置文件，就立马创建bean对象。

public static void main(String[] args) {
    //1.获取容器
    Resource resource = new ClassPathResource("bean.xml");
    BeanFactory factory = new XmlBeanFactory(resource);
    //2.根据bean的id获取对象
    ICustomerService cs = (ICustomerService) factory.getBean("customerService");

    cs.saveCustomer();
}

2.3.2 IOC中bean标签和管理对象细节

2.3.2.1 bean标签

作用：
    用于配置对象让Spring来创建的。
    默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
    id：给对象在容器中提供一个唯一标识。用于获取对象。
    class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
    scope：指定对象的作用范围。
    init-method：指定类中的初始化方法名称。
    destroy-method：指定类中销毁方法名称。
	
<bean id="customerService" class="com.wgy.service.impl.CustomerServiceImpl"
        scope="singleton" init-method="init" destroy-method="destroy">
</bean>

/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
public class CustomerServiceImpl implements ICustomerService {

    public CustomerServiceImpl() {
        System.out.println("bean对象创建了");
    }

    public void init(){
        System.out.println("对象初始化了");
    }

    public void destroy(){
        System.out.println("对象销毁了");
    }

    @Override
    public void saveCustomer() {
        System.out.println("业务层调用持久层");
    }

}

2.3.2.2 Bean的作用范围

Bean的作用范围：
    它是可以通过配置的方式来调整作用范围。
    配置的属性：bean标签的scope属性。
    属性的取值：
        singleton：单例的（默认值）
        prototype：多例的（当我们让spring接管struts2的action创建时，action必须配置此值）
        request：作用范围是一次请求，和当前请求的转发。
        session：作用范围是一次会话。
        globalsession ：作用范围是一次全局会话。

2.3.2.3 Bean的生命周期

Bean的生命周期：
    涉及bean标签的两个属性：
        init-method
        destroy-method
    单例：
        出生：容器创建，对象就出生了。
        活着：只要容器在，对象就一直存在。
        死亡：容器销毁，对象消亡。
    多例：
        出生：每次使用时，创建对象
        活着：只要对象在使用中，就一直活着
        死亡：当对象长时间不使用，并且也没有别的对象引用时，由java的垃圾回收器回收。

2.3.2.4 Bean的三种创建方式

第一种方式：调用默认无参构造函数创建此种方式用的最多

<!--在默认情况下：
    它会根据默认无参构造函数来创建类对象。如果bean中没有默认无参构造函数，则创建失败，会报异常 
-->
<bean id="customerService" class="com.wgy.service.impl.CustomerServiceImpl"/>

第二种方式：使用静态工厂中的方法创建对象

/**
 * 模拟一个静态工厂
 *
 * @author wgy
 */
public class StaticFactory {

    public static ICustomerService getCustomerService() {
        return new CustomerServiceImpl();
    }
}

<!-- 此种方式是:
     使用StaticFactory类中的静态方法getCustomerService创建对象，并存入Spring容器
     id属性：指定bean的id，用于从容器中获取
     class属性：指定静态工厂的全限定类名
     factory-method属性：指定生产对象的静态方法
 -->
<bean id="staticCustomerService" 
      class="com.wgy.factory.StaticFactory" 
      factory-method="getCustomerService"></bean>

第三种方式：使用实例工厂中的方法创建

/**
 * 模拟一个实例工厂
 *
 * @author wgy
 */
public class InstanceFactory {

    public ICustomerService getCustomerService() {
        return new CustomerServiceImpl();
    }
}

<!-- 此种方式是：
     先把工厂的创建交给Spring来管理。
     然后在使用工厂的bean来调用里面的方法
     factory-bean属性：用于指定实例工厂bean的id。
     factory-method属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.wgy.factory.InstanceFactory"></bean>
<bean id="instanceCustomerService" 
      factory-bean="instancFactory" 
      factory-method="getCustomerService"></bean>

2.3.3 Spring的依赖注入

它是spring框架核心ioc的具体实现方式。简单的说，就是坐等框架把对象传入，而不用我们自己去获取。

Spring的依赖注入：
    注入的方式有3三种：
        第一种：使用构造函数注入
        第二种：使用set方法注入
        第三种：使用注解注入
    注入的数据类型有3类：
        第一类：基本类型和String类型
        第二类：其他bean类型（必须是在spring的配置文件中出现过的bean）
        第三类：复杂类型（集合类型）

2.3.3.1 构造函数注入

就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让Spring框架来为我们注入。具体代码如下：

/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
public class CustomerServiceImpl implements ICustomerService {

    private String driver;
    private Integer port;
    private Date today;
    //以上三个类成员，没有具体的实际意义，只是用于演示注入。
    
    public CustomerServiceImpl(String driver, Integer port, Date today) {
        this.driver = driver;
        this.port = port;
        this.today = today;
    }
    
    @Override
    public void saveCustomer() {
        System.out.println("业务层调用持久层"+driver+","+port+","+today);
    }

}

<!-- 构造函数注入：
      涉及的标签：constructor-arg
      标签的属性：
            type:指定参数的类型。
            index:指定参数的索引位置，从0开始。
            name:指定参数的名称。			一般用它
            ========上面三个属性是指定给哪个参数赋值的，下面两个属性是指定赋什么值的==============
            value:指定基本数据类型或String类型的数据
            ref:指定其他bean类型数据
      标签出现的位置：
            写在bean标签内部
 -->
<bean id="customerService" class="com.wgy.service.impl.CustomerServiceImpl">
    <constructor-arg name="driver" value="com.mysql.jdbc.Driver"></constructor-arg>
    <constructor-arg name="port" value="3306"></constructor-arg>
    <constructor-arg name="today" ref="now"></constructor-arg>
</bean>

<bean id="now" class="java.util.Date"></bean>

2.3.3.2 set方法注入

就是在类中提供需要注入成员的set方法。具体代码如下：

/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
public class CustomerServiceImpl2 implements ICustomerService {

    private String driver;
    private Integer port;
    private Date today;

    //以上三个类成员，没有具体的实际意义，只是用于演示注入。
    public void setDriver(String driver) {
        this.driver = driver;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public void setToday(Date today) {
        this.today = today;
    }


    @Override
    public void saveCustomer() {
        System.out.println("业务层调用持久层" + driver + "," + port + "," + today);
    }

}

<!-- set方法注入
        涉及的标签：property
        标签的属性：
            name:指定参数的set方法名称。
            =========上面三个属性是指定给哪个参数赋值的，下面两个属性是指定赋什么值的============
            value:指定基本数据类型或String类型的数据
            ref:指定其他bean类型数据
        标签出现的位置：
            写在bean标签内部
 -->
<bean id="customerService2" class="com.wgy.service.impl.CustomerServiceImpl2">
    <property name="driver" value="com.mysql.jdbc.Driver"></property>
    <property name="port" value="3307"></property>
    <property name="today" ref="now"></property>
</bean>

<bean id="now" class="java.util.Date"></bean>

2.3.3.3 复杂类型的注入

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

/**
 * 客户的业务层实现类
 *
 * @author wgy
 */
public class CustomerServiceImpl3 implements ICustomerService {

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


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

<!-- 复杂类型的注入
        结构相同，标签可以互换
        List结构的：
            array,list,set
        Map结构的
            map,entry,props,prop
 -->
<bean id="customerService3" class="com.wgy.service.impl.CustomerServiceImpl3">
    <property name="myStrs">
        <set>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </set>
    </property>

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

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

    <property name="myMap">
        <props>
            <prop key="testF">FFF</prop>
            <prop key="testG">GGG</prop>
        </props>
    </property>

    <property name="myProps">
        <map>
            <entry key="testD" value="DDD"></entry>
            <entry key="testE">
                <value>EEE</value>
            </entry>
        </map>
    </property>
</bean>

-------------本文结束感谢您的阅读-------------

本文作者： Wgy
本文标题： Spring(一)
本文链接： https://wgy1993.gitee.io/archives/b9cbcaed.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！