Spring概述及基于XML的IOC配置

• 1. spring概述
• • 1.1 spring是什么
  • 1.2 spring的优势
  • 1.3 spring的体系结构
• 2. IoC的概念和作用
• • 2.1 程序的耦合和解耦
  • 2.2 工厂模式解耦
• 2.3 ioc的概念和作用
• 3. spring基于XML的IOC
• • 3.1 实现
  • 3.2 细节
  • • 3.2.1 spring中的工厂类的结构图
    • 3.2.2 BeanFactory和ApplicationContext的区别
    • 3.2.3 ApplicationContext的三个实现类
• 4. IOC中的bean标签
• • 4.1 创建bean对象的三种方式
  • 4.2 bean的作用范围
  • 4.3 bean的生命周期
• 5. spring的依赖注入
• • 5.1 依赖注入的概念
  • 5.2 构造函数注入
  • 5.3 set 方法注入(常用）
  • 5.4 注入集合数据

1. spring概述

1.1 spring是什么

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

1.2 spring的优势

1. 方便解耦，简化开发

   通过 Spring提供的IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2. AOP 编程的支持

   通过 Spring的 AOP 功能，方便进行面向切面的编程，许多不容易用传统OOP 实现的功能可以通过 AOP 轻松应付。

3. 声明式事务的支持

   可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。

4. 方便程序的测试

   可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

5. 方便集成各种优秀框架

   Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。

6. 降低JavaEE API 的使用难度

   Spring对JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

7. Java 源码是经典学习范例

   Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java 设计模式灵活运用以及对 Java技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

1.3 spring的体系结构

2. IoC的概念和作用

2.1 程序的耦合和解耦

耦合：程序间的依赖关系，包括类之间的依赖和方法间的依赖。

解耦：降低程序间的依赖关系

实际开发中应该做到，编译期不依赖，运行时才依赖。

解耦的思路：

第一步：使用反射来创建对象，而避免使用new关键字。

第二步：通过读取配置文件来获取要创建的对象全限定类名

2.2 工厂模式解耦

创建持久层接口和实现类

public interface IAccountDao {
    /**
     * 模拟保存帐户
     */
    void saveAccount();
}
           

public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("保存了帐户");
    }
}
           

创建业务层接口和实现类

public interface IAccountService {
    /**
     * 模拟保存帐户
     */
    void saveAccount();
}
           

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao = new AccountDaoImpl();
    public void saveAccount() {
        accountDao.saveAccount();
    }
}
           

模拟表现层

public class Client {
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}
           

创建BeanFactory类

一个创建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()){
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把keyvalue存入到容器
                beans.put(key,value);
            }
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

   
    /**
     * 根据bean的名称获取bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        Object bean = null;
        String beanPath = props.getProperty(beanName);
        try {
            bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
        }  catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}
           

创建一个bean.properties

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

修改表现层、业务层

IAccountService as = (IAccountService)BeanFactory.getBean("accountService");

 private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
           

2.3 ioc的概念和作用

3. spring基于XML的IOC

3.1 实现

1. 创建持久层、业务层接口和实现类
2. 导入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
           

1. 创建bean.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">
    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.wyj.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.wyj.dao.impl.AccountDaoImpl"></bean>
</beans>
           

1. 测试代码

public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\Desktop\\bean.xml")
        //2.根据id获取bean对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);

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

    }
           

3.2 细节

3.2.1 spring中的工厂类的结构图

3.2.2 BeanFactory和ApplicationContext的区别

BeanFactory才是 Spring 容器中的顶层接口。

ApplicationContext是它的子接口。

BeanFactory和ApplicationContext的区别

创建对象的时间点不一样。

ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

BeanFactory：什么使用什么时候创建对象。

3.2.3 ApplicationContext的三个实现类

==ClassPathXmlApplicationContext：==它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)

==FileSystemXmlApplicationContext：==它可以加载磁盘任意路径下的配置文件(必须有访问权限）

==AnnotationConfigApplicationContext：==它是用于读取注解创建容器的。

4. IOC中的bean标签

4.1 创建bean对象的三种方式

1. 使用默认构造函数创建

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

1. 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入容器）

   id 属性：指定 bean 的 id，用于从容器中获取

   class 属性：指定静态工厂的全限定类名

   factory-method 属性：指定生产对象的静态方法

public class StaticFactory {
    public static IAccountService getAccountService(){
        return new AccountServiceImpl();
    }
}
           

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

先把工厂的创建交给 spring 来管理。

然后在使用工厂的 bean 来调用里面的方法

factory-bean 属性：用于指定实例工厂 bean 的 id。

factory-method 属性：用于指定实例工厂中创建对象的方法。

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

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

4.2 bean的作用范围

bean作用：

用于配置对象让 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：指定类中销毁方法名称。

4.3 bean的生命周期

单例对象：scope=“singleton”

一个应用只有一个对象的实例。它的作用范围就是整个应用。

生命周期：

对象出生：当应用加载，创建容器时，对象就被创建了。

对象活着：只要容器在，对象一直活着。

对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

多例对象：scope=“prototype”

每次访问对象时，都会重新创建对象实例。

生命周期：

对象出生：当使用对象时，创建新的对象实例。

对象活着：只要对象在使用中，就一直活着。

对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

5. spring的依赖注入

5.1 依赖注入的概念

==依赖注入：Dependency Injection。==它是 spring 框架核心 ioc 的具体实现。我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明，依赖关系的维护，就称之为依赖注入。

依赖注入：

== 能注入的数据：==

基本类型和String

其他bean类型（在配置文件中或者注解配置过的bean）

复杂类型/集合类型

== 注入的方式：==

使用构造方式提供

使用set方法提供

使用注解提供

5.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-age

标签出现的位置：bean标签的内部

标签中的属性：

type:用于指定要注入的数据类型，该数据类型也是构造函数中某个或某些参数的类型

index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引位置从0开始。

name：用于指定给构造函数中指定名称的参数赋值（常用的）

--------------------------以上三个用于指定给构造函数中那个参数赋值--------------------

value:用于提供基本类型和string类型的数据

ref：用于指定其他的bean类型的数据。它指的是在spring的ioc核心容器中出现过的bean对象

优点：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功
    缺点：改变了bean对象的实例化方式，使我们在创建对象时如果用不到这些数据也必须提供
           

<bean id="accountService" class="com.wyj.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="test"></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>
           

5.3 set 方法注入(常用）

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

           

涉及的标签：property

出现的位置：bean标签的内部

标签的属性：

name：用于指定注入时所调用的set方法名称

value:用于提供基本类型和string类型的数据

ref：用于指定其他的bean类型的数据。它指的是在spring的ioc核心容器中出现过的bean对象

优点：创建对象时没有明确的限制，可以直接使用默认构造函数
   缺点：如果有某个成员必须有值，则获取对象是有可能set方法没有执行
           

<bean id="accountService2" class="com.wyj.service.impl.AccountServiceImpl2">
        <property name="name" value="test"></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>
    
           

5.4 注入集合数据

public class AccountServiceImpl3 implements IAccountService {
    private String[] myStr;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;
    public void setMyStr(String[] myStr) {
        this.myStr = myStr;
    }
    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(myStr));
        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="accountService3" class="com.wyj.service.impl.AccountServiceImpl3">
        <property name="myStr">
            <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>