Spring入门

最新推荐文章于 2023-04-24 21:50:59 发布

bm1998

最新推荐文章于 2023-04-24 21:50:59 发布

阅读量278

点赞数

分类专栏： # Spring 文章标签： Spring

本文链接：https://blog.csdn.net/bm1998/article/details/100607392

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. Spring 概述

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IOC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 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 的使用难度大为降低。

3. Spring 体系结构

在这里插入图片描述

Core Container：核心容器，IOC
AOP
Data Access
Web
Test

4. 程序的耦合和解耦

4.1 耦合的概念

耦合，就是对象间的依赖关系

依赖关系包括：

类之间的依赖
方法之间的依赖

对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。划分模块的一个准则就是高内聚低耦合

4.2 解耦的概念

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

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

4.3 解耦的思路

应该使用反射来创建对象，而避免使用 new 关键字。

4.4 解耦案例1

问题

使用 JDBC 注册驱动时，都是通过反射来注册驱动的，但为什么要这样注册呢？
```
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
```
分析

上面的两行代码都能实现注册驱动。第一行代码使用 new 关键字，依赖具体的驱动类；而第二行代码使用反射，只是依赖一行字符串。第二行代码的好处在于，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译，只会在运行时报错。同时，也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 Java 类中写死的，一旦要改还是要修改源码。解决这个问题也很简单，使用配置文件就行。

4.5 解耦案例2

问题

当业务层调用持久层时，业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过，那该怎么解耦呢？

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

解耦方法

用工厂模式创建对象。我们把持久层对象使用配置文件配置起来，创建一个工厂类，在该类中写一个 getBean() 的方法通过读取配置文件，把这些对象创建出来。

实现步骤

创建 bean.properties，把持久层对象使用配置文件配置起来
```
accountDao=com.zt.dao.impl.AccountDaoImpl
```

创建一个工厂类，在该类中写一个 getBean() 的方法通过读取配置文件，把这些对象创建出来。

/**
 * 一个创建 Bean 对象的工厂：用来创建 Service 和 dao 对象的
 * Bean：在计算机英语中，有可重用组件的含义
 * JavaBean：用 Java 语言编写的可重用组件
 * JavaBean > 实体类
 *
 * 实现步骤：
 *      1.需要一个配置文件来配置 service 和 dao
 *          配置的内容：
 *              1.全限定类名 = 全限定类名（key-value)
 *      2.通过读取配置文件中的内容，反射创建对象
 */
public class BeanFactory {
    // 声明 properties 对象
    private static Properties properties;
    static {
        // 创建 properties 对象
        properties = new Properties();
        // 通过类加载器获取 class 目录下配置文件的路径
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
        // 加载配置文件到 properties 集合中
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 /**
     * 根据 Bean 的名称，获取 Bean 对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName) {
        // 声明对象
        Object obj = null;
        try {
            // 从 properties 集合中获取配置文件中定义的数据
            String beanPath = properties.getProperty(beanName);
            // 根据全类名加载该类进内存，获取对应的 Class 对象
            Class<?> aClass = Class.forName(beanPath);
            // 创建对象
            obj = aClass.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        // 返回对象
        return obj;
    }

}

优化代码

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

注意：这样一来就算删除 AccountDaoImpl 这个类，依然可以编译程序，只是会在运行期报错

工厂模式中的问题

上面已经实现了由工厂模式生成对象，接下来我们连续生成五个对象，并打印

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        AccountService accountService = (AccountService) BeanFactory.getBean("accountService");
        System.out.println(accountService);
    }
}

得到结果：

com.zt.service.impl.AccountServiceImpl@677327b6
com.zt.service.impl.AccountServiceImpl@14ae5a5
com.zt.service.impl.AccountServiceImpl@7f31245a
com.zt.service.impl.AccountServiceImpl@6d6f6e28
com.zt.service.impl.AccountServiceImpl@135fbaa4

分析：我们发现工厂模式生成的对象是多例的，因为我们每次都在使用默认构造函数创建对象，所以每次返回的都是一个新对象

obj = aClass.newInstance();

单例对象和多例对象的区别
1. 单例对象只创建一次，多例对象被创建多次
2. 单例对象成员变量只会初始化一次，多例对象每次被创建成员变量初始化一次
3. 当多个线程访问时，如果要操作成员变量，并且成员变量可以在方法中改变，单例对象存在线程问题（这也是之前学 Servlet 时，要求不要在 Servlet 中定义成员变量，因为 Servlet 是单例的）
4. 多例对象没有单例对象执行效率高
问题

在 AccountServiceImpl 中，我们并不会定义成员变量（我们会将变量定义在方法中，也就是局部变量，因为局部变量会随着方法每次被调用重新初始化），也就并不存在线程问题，所以我们就不需要多例对象，我们应该把生成的对象变成单例的
分析

要把生成的对象变成单例的，我们就只能 newInstance() 一次。所以对象创建出来后，我们得把对象用一个容器存起来（不存起来对象会被 Java 的垃圾回收机制回收，那你下次再用就又会创建新对象，那就是多例的对象）

改造工厂模式

/**
 * 一个创建 Bean 对象的工厂：用来创建 Service 和 dao 对象的
 * Bean：在计算机英语中，有可重用组件的含义
 * JavaBean：用 Java 语言编写的可重用组件
 * JavaBean > 实体类
 *
 * 实现步骤：
 *      1.需要一个配置文件来配置 service 和 dao
 *          配置的内容：
 *              1.全限定类名 = 全限定类名（key-value)
 *      2.通过读取配置文件中的内容，反射创建对象
 */
public class BeanFactory {
    // 声明 properties 对象
    private static Properties properties;
    //定义一个Map，用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    static {
        try {
            // 实例化 properties 对象
            properties = new Properties();
            // 通过类加载器获取 class 目录下配置文件的路径
            InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            // 加载配置文件到 properties 集合中
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            // 实例化容器
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的 Key
            Enumeration<Object> keys = properties.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = properties.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }

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

}

5. IOC 的概念

原来：我们在获取对象时，都是采用 new 的方式。是主动的。
```
private AccountDao accountDao = new AccountDaoImpl();
```
现在：我们获取对象时，跟工厂要，由工厂为我们创建对象。是被动的。
```
private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
```
原来是主动创建对象，现在我把创建对象的权力交给工厂，由工厂创建对象，此时控制权就发生了转移，这种思想也就是控制反转（IOC），它是 Spring 框架的核心之一。

6. IOC 的作用

解耦，降低了程序间的依赖关系。

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

7.1 环境搭建

创建 Maven 的 Java工程，工程信息如下：

<groupId>com.zt</groupId>
<artifactId>spring_day01_3</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

添加 Spring 5.0.2 的坐标

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

创建持久层接口和实现类

AccountDao 接口

public interface AccountDao {
    public void saveAccount();
}

AccountDaoImpl

package com.zt.dao.impl;

import com.zt.dao.AccountDao;

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

创建业务层接口和实现类

AccountService 接口

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

AccountServiceImpl

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

创建表现层

/**
 * 模拟表现层，调用业务层
 */
public class Client {
    public static void main(String[] args) {
        AccountService accountService = new AccountServiceImpl();
        accountService.saveAccount();
    }
}

7.2 Spring 基于 XML 的 IOC 配置

在 resources 中创建配置文件 bean.xml，并让 Spring 管理资源，在配置文件中配置 service 和 dao

<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="accountDao" class="com.zt.dao.impl.AccountDaoImpl"></bean>
    <bean id="accountService" class="com.zt.service.impl.AccountServiceImpl"></bean>

</beans>

优化表现层

/**
 * 获取 IOC 核心容器，并根据 id 获取对象
 */
public class Client {
    public static void main(String[] args) {
        // 1. 获取核心容器对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        //2. 根据 bean 的 id 获取对象
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);

        accountService.saveAccount();

    }
}

8 Spring 基于 XML 的 IOC 细节

8.1 Spring 中工厂的类结构图

在这里插入图片描述

8.1.1 BeanFactory 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口，ApplicationContext 是它的子接口
ApplicationContext 读取完配置文件，马上就会创建对象
BeanFactory 是什么使用什么时候创建对象

8.1.2 ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件（推荐使用这种）
```
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
```

FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。（必须有访问权限）

ApplicationContext applicationContext = new FileSystemXmlApplicationContext("D:\\idea_workspace\\spring\\spring_day01_3\\src\\main\\resources\\bean.xml");

AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

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

8.2.1 bean 标签

bean 标签的作用

用于配置对象让 spring 来创建的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
bean 标签的属性
1. id：给对象在容器中提供一个唯一标识。用于获取对象。
2. class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
3. scope：指定对象的作用范围。
  1. singleton：单例的(默认值)，一个应用只有一个对象的实例，它的作用范围就是整个引用
  2. prototype：多例的，每次访问对象时，都会重新创建对象实例
  3. request：WEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 request 域中
  4. session：WEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 session 域中
  5. global session：WEB 项目中，作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是 session
4. init-method：指定类中的初始化方法名称。
5. destroy-method：指定类中销毁方法名称。

8.2.2 bean 的生命周期

单例对象（scope=“singleton”）
生命周期
1. 对象出生：创建容器时，对象就被创建了。
2. 对象活着：只要容器在，对象一直活着。
3. 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象（scope=“prototype”）
生命周期
1. 对象出生：当使用对象时，创建新的对象实例。
2. 对象活着：只要对象在使用中，就一直活着。
3. 对象死亡：当对象长时间不用时，且没有别的对象引用时，被 java 的垃圾回收器回收了。

8.2.3 实例化 Bean 的三种方式

使用默认无参构造函数

在 spring 的配置文件中使用 bean 标签，配以 id 和 class 属性之后，且没有其他属性和标签时，采用的就是默认构造函数创建 bean 对象，此时如果类中没有默认构造函数（无参构造函数），则对象无法创建。
```
<bean id="accountService" class="com.zt.service.impl.AccountServiceImpl"></bean>
```

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

/**
 * 模拟一个实例工厂类（该类可能存在于 jar 包中）
 */
public class InstanceFactory {
    public AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

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

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

/**
 * 模拟一个静态工厂类（该类可能存在于 jar 包中）
 */
public class StaticFactory {
    public static AccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

<bean id="accountService" class="com.zt.factory.StaticFactory" factory-method="getAccountService"></bean>

8.3 Spring 的依赖注入

8.3.1 依赖注入的概念

从 Spring 容器的角度来看，Spring 容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是依赖注入（Dependency Injection）

它与控制反转（IOC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念

8.3.2 依赖注入的数据类型

基本类型和 String
其他 bean 类型（在配置文件中或者注解配置过的 bean）
复杂类型/集合类型

8.3.3 依赖注入的方式

使用构造函数提供

概念

使用类中的构造函数，给成员变量赋值。但赋值的操作不是我们自己做的，而是通过配置的方式，让 Spring 框架来为我们注入。
涉及的标签：
1. constructor-arg
属性：
1. index：指定参数在构造函数参数列表的索引位置，参数索引从 0 开始
2. type：指定参数在构造函数中的数据类型
3. name：指定参数在构造函数中的名称用这个找给谁赋值
4. value：它能赋的值是基本数据类型和 String 类型
5. ref：它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
优势

在获取 bean 对象时，注入数据是必须的操作，否则对象无法创建成功。
弊端

改变了 bean 对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

实例

public class AccountServiceImpl implements AccountService {
    // 如果是经常变化的数据，并不适用于注入的方式
    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(name +","+ age +","+ birthday );
    }
}

<bean id="accountService" class="com.zt.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>

使用 set 方法提供（更常用）

概念

在类中提供需要注入成员的 set 方法
涉及的标签
1. property
标签的属性
1. name：用于指定注入时所调用的 set 方法名称
2. value：用于提供基本类型和 String 类型的数据
3. ref：它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
优势

创建对象时没有明确的限制，可以直接使用默认构造函数
弊端

如果有某个成员必须有值，则获取对象是有可能 set 方法没有执行

实例

public class AccountServiceImpl2 implements AccountService {
    // 如果是经常变化的数据，并不适用于注入的方式
    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(name +","+ age +","+ birthday );
    }
}

<bean id="accountService2" class="com.zt.service.impl.AccountServiceImpl2">
    <property name="name" value="张三"></property>
    <property name="age" value="18"></property>
    <property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

复杂类型的注入

概念

给类中的集合成员传值，它用的也是 set 方法注入的方式，只不过变量的数据类型都是集合
涉及的标签
1. 用于给 List 结构集合注入的标签：list，array，set
2. 用于个 Map 结构集合注入的标签：map，props
3. 结构相同，标签可以互换

实例

public class AccountServiceImpl3 implements AccountService {
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProperties;

    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 setMyProperties(Properties myProperties) {
        this.myProperties = myProperties;
    }

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

<bean id="accountService3" class="com.zt.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="A" value="aaa"></entry>
            <entry key="B">
                <value>bbb</value>
            </entry>
        </map>
    </property>
    <property name="myProperties">
        <props>
            <prop key="A">aaa</prop>
            <prop key="B">bbb</prop>
        </props>
    </property>
</bean>

bm1998

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring入门

文章目录1. Spring 概述2. Spring 的优势3. Spring 体系结构4. 程序的耦合和解耦4.1 耦合的概念4.2 解耦的概念4.3 解耦的思路4.4 解耦案例14.5 解耦案例25. IOC 的概念6. IOC 的作用7. 使用 Spring 的 IOC 解决程序耦合7.1 环境搭建7.2 Spring 基于 XML 的 IOC 配置8 Spring 基于 XML 的 IOC ...
复制链接

扫一扫