20201123 王维

学习总结

1 Spring概述

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

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 技术的最佳实践的范例。

3 IoC(控制反转-Inversion Of Control)的概念和作用

容器:由于我们是很多对象,肯定要找个集合来存。这时候有 Map 和 List 供选择。 到底选 Map 还是 List 就看我们有没有查找需求。有查找需求,选 Map。 所以我们的答案就是在应用加载时,创建一个 Map,用于存放三层对象。 我们把这个 map 称之为容器。

工厂:工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。 原来: 我们在获取对象时,都是采用 new 的方式。是主动的。现在: 我们获取对象时,同时跟工厂要,有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转,它是 spring 框架的核心之一。

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

4 使用 spring 的 IOC 解决程序耦合

4.1 maven 准备 spring 的开发包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.2.9.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>

4.2 在类的根路径下创建一个任意名称的 xml 文件(不能 是中文)写上约束

4.3 让 spring 管理资源,在配置文件中配置 service 和 dao

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 构造函数创建对象 单例模式 -->
    <bean id="accountService" class="com.itlaobing.spring.service.impl.IAccountServiceImpl">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
    <bean id="accountDao" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <!-- collaborators and configuration for this bean go here -->
    </bean>
</beans>

测试是否成功

    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口,就是在获取 spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2.根据 bean 的 id 获取对象
        IAccountService accountService = (IAccountService) context.getBean("accountService");
        System.out.println(accountService);
        IAccountDao accountDao = (IAccountDao) context.getBean("accountDao");
        System.out.println(accountDao);
    }

4.3.1 BeanFactory 和 ApplicationContext 的区别

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

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

4.3.2 ApplicationContext 接口的实现类

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

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

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

单例对象:scope="singleton"

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

生命周期:

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

对象活着:只要容器在,对象一直活着。

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

多例对象:scope="prototype"

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

生命周期:

对象出生:当使用对象时,创建新的对象实例。

对象活着:只要对象在使用中,就一直活着。

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

实例化 Bean 的三种方式

第一种方式:使用默认无参构造函数

<!-- 构造函数创建对象 多例模式 构造函数注入 -->
    <bean id="accountDao1" scope="prototype" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <constructor-arg index="0" type="boolean" value="flag"/>
    </bean>

第二种方式:spring 管理静态工厂-使用静态工厂的方法创建对象

public class StaticFactory {

    public static IAccountDao createInstance(){

        return new IAccountDaoImpl();
    }
}

此种方式是: 使用 StaticFactory 类中的静态方法 createInstance创建对象,并存入 spring 容器

id 属性:指定 bean 的 id,用于从容器中获取

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

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

<!-- 静态工厂创建对象 set注入 -->
    <bean id="accountDaoStaticFactory" class="com.itlaobing.spring.factory.StaticFactory" factory-method="createInstance">
        <property name="flag" value="true" />
    </bean>

第三种方式:spring 管理实例工厂-使用实例工厂的方法创建对象

public class InstanceFactory {

    public IAccountDaoImpl createInstance(){
        return new IAccountDaoImpl();
    }
}

此种方式是: 先把工厂的创建交给 spring 来管理。 然后在使用工厂的 bean 来调用里面的方法

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

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

 <!-- 实例工厂创建对象 懒加载 p名称空间注入 -->
    <bean id="accountDaoInstanceFactory" class="com.itlaobing.spring.factory.InstanceFactory" >
    </bean>
    <bean id="accountDaoFactory" factory-bean="accountDaoInstanceFactory" factory-method="createInstance" lazy-init="true"
    p:flag="false ">
    </bean>
懒加载

懒加载(Lazy)是指在启动Spring容器时不实例化bean对象,而是在需要对象时实例化bean对象。懒 就是不提前准备好bean对象,需要bean对象时才实例化bean对象,有懒惰的表现。 当Scope="singleton"时,表示Spring容器启动时实例化Bean对象;Scope="prototype"时,表示调用 getBean()时初实例化Bean对象,而不是在容器启动时实例化Bean对象。在bean定义中设置lazy-init="true",表示该bean懒加载。

spring 的依赖注入

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

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

public class IAccountDaoImpl implements IAccountDao {

    private boolean flag;

    public IAccountDaoImpl(boolean flag) {
        this.flag = flag;
    }
}
<!-- 构造函数创建对象 多例模式 构造函数注入 -->
    <bean id="accountDao1" scope="prototype" class="com.itlaobing.spring.dao.impl.IAccountDaoImpl">
        <constructor-arg index="0" type="boolean" value="flag"/>
    </bean>

set 方法注入 顾名思义,就是在类中提供需要注入成员的 set 方法。具体代码如下:

public class IAccountDaoImpl implements IAccountDao {

    private boolean flag;
    
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}
    <!-- 静态工厂创建对象 set注入 -->
    <bean id="accountDaoStaticFactory" class="com.itlaobing.spring.factory.StaticFactory" factory-method="createInstance">
        <property name="flag" value="true" />
    </bean>

使用 p 名称空间注入数据(本质还是调用 set 方法)此种方式是通过在 xml 中导入 p 名称空间,使用 p:propertyName 来注入数据,它的本质仍然是调用 类中的set 方法实现注入功能。配置文件代码:

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
  <!-- 实例工厂创建对象 懒加载 p名称空间注入 -->
    <bean id="accountDaoInstanceFactory" class="com.itlaobing.spring.factory.InstanceFactory" >
    </bean>
    <bean id="accountDaoFactory" factory-bean="accountDaoInstanceFactory" factory-method="createInstance" lazy-init="true"
    p:flag="false ">
    </bean>
</beans>

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

import lombok.Data;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

@Data
public class Cat {

    private int age;

    private String name;

    private double weight;

    private String[] arr;

    private List<String> list;

    private Map<String , Object> map;

    private Set<String> set;

    private Properties properties;

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

    public void destroy(){
        System.out.println("destory cat");
    }

    public void eat(String food){
        System.out.println("Hello world");
        System.out.println("Cat 正在吃" + food);
    }
}
<!-- 注入集合属性 -->
    <bean id="cat" class="com.itlaobing.spring.test.Cat" init-method="init" destroy-method="destroy">
        <property name="name" value="鱼丸" />
        <property name="age" value="3" />
        <property name="weight" value="5" />
        <!-- 数组 -->
        <property name="arr" >
            <array>
                <value>白猫</value>
                <value>黑猫</value>
            </array>
        </property>

        <!-- list集合 -->
        <property name="list">
            <list>
                <value>虹猫</value>
                <value>黑猫警长</value>
                <value>蓝猫</value>
            </list>
        </property>

        <!-- map集合-->
        <property name="map" >
            <map>
                <entry key="斗罗" value="三少" />
                <entry key="诡秘" value="乌贼" />
            </map>
        </property>

        <!-- set集合-->
        <property name="set">
            <set>
                <value>呐喊</value>
                <value>狂人日记</value>
            </set>
        </property>

        <property name="properties">
            <props>
                <prop key="url">jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8</prop>
            </props>
        </property>
    </bean>

心得体会

今天终于开始学习spring了,对他期待已久,今天主要学习了他基于xml配置对对象的创建和依赖注入,对他们怎么用有了一定的了解,但是在实际项目中的具体作用还有点茫然,可能需要在实际项目中使用才能更好的理解。

标签

评论

© 2021 成都云创动力科技有限公司 蜀ICP备20006351号-1