Java总结:Spring5框架（1）

Bertha 。 2021-12-14 09:39 221阅读 0赞

# **Spring5框架（1）** #

## **一：什么是Spring?** ##

**Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。**

**◆目的：解决企业应用开发的复杂性**

**◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能**

**◆范围：任何Java应用**

**Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。**

### **下载使用Spring的开发包** ###

官网：[http://spring.io/ ][http_spring.io_]  
下载地址：  
[http://repo.springsource.org/libs-release-local/org/springframework/spring][http_repo.springsource.org_libs-release-local_org_springframework_spring]

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

## 二：Spring的优势？ ##

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

## **三：结构？** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70][]

## 四：程序的耦合和解耦？ ##

### 4.1 ###

package com.xy.domain;
    
    import com.xy.factory.BeanFactory;
    import com.xy.service.AccountService;
    
    /**
     * 模拟一个表现层，用于调用业务层
     */
    public class Client {
        public static void main(String[] args) {
    //        AccountService accountService=new AccountServiceImpl();
            AccountService accountService= (AccountService) BeanFactory.getBean("accountService");
            accountService.saveAccount();
        }
    }

上面的代码表示：  
业务层调用持 久层，并 且此时业 务层在依 赖持久层 的接口和实 现类。如 果此时没 有持久层 实现类， 编译 将不能通过。这种编译期依赖关系，应该在我们开发中杜绝。我们需要优化代码解决。

再比如：  
早期我们的 JDBC操作，注册驱动时，我们为什么不使用 DriverManager的 register方法，而是采 用 Class.forName的方式？

public class JdbcDemo1 { 
    /** 
    * @Version 1.0 
    * @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.遍历结果集 
    } 
    }

原因就是：  
我们的类依赖了数据库的具体驱动类（MySQL），如果这时候更换了数据库品牌（比如 Oracle），需要 修改源码来重新数据库驱动。这显然不是我们想要的。

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

Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串

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

### 4.2工厂模式解耦 ###

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

### 4.3控制反转-Inversion Of Control ###

解耦的思路有 2个问题：  
1、存哪去？  
分析：由于我们是很多对象，肯定要找个集合来存。这时候有 Map和 List供选择。  
到底选 Map还是 List就看我们有没有查找需求。有查找需求，选 Map。  
所以我们的答案就是  
在应用加载时，创建一个 Map，用于存放三层对象。  
我们把这个 map称之为容器。  
2、还是没解释什么是工厂？  
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。 原来：  
我们在获取对象时，都是采用 new的方式。是主动的。

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

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

## 五：IOC解耦案例 ##

账户的业务层和持久层的依赖关系解决。

在开始 spring的配置之前，我们要先准备 一下环境。由于我们是使用 spring 解决依赖关系，并不是真正的要做增删改查操作，所以此时我们没必要写实体 类。并且我们在此处使用的是 java工程，不是 java web工程。

### 5.1创建业务层接口和实现类 ###

package com.xy.service;
    
    /**
     * 业务层的接口，操作账户
     */
    public interface AccountService {
        /**
         * 模拟保存账户
         */
        public void saveAccount();
    }
    
    
    
    package com.xy.service.Impl;
    
    import com.xy.dao.AccountDao;
    import com.xy.dao.impl.AccountDaoImpl;
    import com.xy.factory.BeanFactory;
    import com.xy.service.AccountService;
    
    /**
     *账户的业务层实现类
     */
    public class AccountServiceImpl implements AccountService {
    //    private AccountDao accountDao=new AccountDaoImpl();
        private AccountDao accountDao= (AccountDao) BeanFactory.getBean("accountDao");
        public void saveAccount() {
            accountDao.saveAccount();
    
        }
    }

### 5.2创建持久层接口和实现类 ###

package com.xy.dao;
    
    /**
     * 持久层接口
     */
    public interface AccountDao {
        /**
         * 模拟保存账户
         */
        public void saveAccount();
    }
    
    
    
    package com.xy.dao.impl;
    
    import com.xy.dao.AccountDao;
    
    public class AccountDaoImpl implements AccountDao {
        public void saveAccount() {
            System.out.println("保存了账户");
        }
    }

### 5.3XML文件配置 ###

**第一步：在pom.xml中导入必备的spring包。**

**第二步：在类的根路径下创建一个bean.xml文件。**

**第三步：给配置文件导入约束：**

打开你的spring包的位置：/spring-framework-5.1.6.RELEASE/docs/spring-framework-reference/core.html，找到以下

内容：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 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
            https://www.springframework.org/schema/beans/spring-beans.xsd">

**第四步：让spring管理资源，在配置文件中配置service和dao：**

<bean id="accountService" class="com.xy.service.Impl.AccountServiceImpl"></bean>
        <bean id="accountDao" class="com.xy.dao.impl.AccountDaoImpl"></bean>

**第五步：测试：**

package com.xy.domain;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.xy.dao.AccountDao;
    import com.xy.service.AccountService;
    import com.xy.service.Impl.AccountServiceImpl;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * 模拟一个表现层，用于调用业务层
     */
    public class Client {
        /**
         * 获取spring的IOC容器，并根据id获取对象
         * @param args
         */
        public static void main(String[] args) {
            //1.获取核心容器对象
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("bean.xml");
            //根据id获取Bean对象
            AccountService accountService= (AccountService) applicationContext.getBean("accountService");
            AccountDao accountDao=applicationContext.getBean("accountDao",AccountDao.class);
            System.out.println(accountService);
            System.out.println(accountDao);
        }
    }

运行：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 2][]

### 5.4spring 中工厂的类结构图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 4][]

获取spring的Ioc核心容器，并根据id获取对象
     
     ApplicationContext的三个常用实现类：
           ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
           FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
     
           AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。
     
      核心容器的两个接口引发出的问题：
      ApplicationContext:     单例对象适用              采用此接口
           它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
     
       BeanFactory:            多例对象使用
           它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

### 5.5IOC 中 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：指定类中销毁方法名称。

**bean 的作用范围和生命周期：**

Spring对bean的管理细节：
    
    1.创建bean的三种方式：
    第一种方式：使用默 认无参构造函数 
    在默认情况下： 
    它会根据默认无参构造函数来创建类对象。如果  bean中没有默认无参构造函数，将会创建失败。

第二种：使用普通工厂中的方法创建对象(使用某个类中的方法创建对象)，并存入spring容器：

模拟一个工厂：

package com.xy.factory;
    
    import com.xy.service.AccountService;
    import com.xy.service.impl.AccountServiceImpl;
    
    public class testFactory {
        public AccountService getAccountService(){
            return new AccountServiceImpl();
        }
    }

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

package com.xy.factory;
    
    import com.xy.service.AccountService;
    import com.xy.service.impl.AccountServiceImpl;
    
    public class  testSFactory {
        public static AccountService getAccountService(){
            return new AccountServiceImpl();
        }
    }
    
    
    
    <bean id="getAccountService" class="com.xy.factory.testSFactory" factory-method="getAccountService" scope="prototype"
        init-method="init" destroy-method="destroy"></bean>

2.bean对象的三种范围

3.bean对象的生命周期

## 六：依赖注入（DI） ##

### 6.1构造函数注入： ###

<bean class="com.xy.service.impl.AccountServiceImpl" id="accountService">
            <constructor-arg name="name" value="test"></constructor-arg>
            <constructor-arg name="age" value="19"></constructor-arg>
            <constructor-arg name="birthday" ref="now"></constructor-arg>
        </bean>
        
        <bean class="java.util.Date" id="now"></bean>

创建构造函数：

import com.xy.service.AccountService;
    
    import java.util.Date;
    
    /**
     * 账户的业务层实现类
     */
    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("service 中的saveAccount()方法执行"+name+",age"+age+",birthday"+birthday);
        }
    
    }

### 6.3SET方法注入 ###

!--2.set方法注入   更常用的注入方式
        标签：property
        位置：bean标签内部
        属性：
            name:用来指定注入时所调用的set方法名称
            value:用于提供基本类型和String类型的数据
            ref:用于提供其它的bean类型数据
    
        优势：创建对象时，没有明确的限制，可以直接使用默认构造函数
        弊端：如果某个成员必须有值，则获取对象是有可能set方法没有执行
        -->

创建带有set方法的业务层实现类：

package com.xy.service.impl;
    
    import com.xy.service.AccountService;
    
    import java.util.Date;
    
    /**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl1 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("service 中的saveAccount()方法执行"+name+",age"+age+",birthday"+birthday);
        }
    
    }

### 6.3使用注解注入 ###

**此种方式是通过在 xml中导入 p名称空间，使用 p:propertyName来注入数据，它的本质仍然是调用类中的 set方法实现注入功能。**

### 6.4集合注入 ###

创建带集合的业务层实现类：

package com.xy.service.impl;
    
    import com.xy.service.AccountService;
    
    import java.util.*;
    
    /**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl2 implements AccountService {
        private String []myString;
        private List<String> myList;
        private Set<String> mySet;
        private Map<String,String> myMap;
        private Properties myProperties;
    
        public void setMyString(String[] myString) {
            this.myString = myString;
        }
    
        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(myString));
            System.out.println(myList);
            System.out.println(mySet);
            System.out.println(myMap);
            System.out.println(myProperties);
        }
    
    }

**其他内容请浏览本博主其它博客。**

# [网站][Link 3] #

[http_spring.io_]: http://spring.io/%C2%A0
[http_repo.springsource.org_libs-release-local_org_springframework_spring]: http://repo.springsource.org/libs-release-local/org/springframework/spring
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70]: /images/20211214/cc9ce908ee4342d398b3af0afacc417c.png
[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%BC%96%E7%A8%8B
[Link 2]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 1]: /images/20211214/7f3f4e42a92d4e3c92cd32423ebc6e95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 2]: /images/20211214/6b2899cf30704218abc7c586b2c40dbd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 3]: /images/20211214/5ad9dfacc9064ff993fb8685b06ffc16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 4]: /images/20211214/e9efba1848334b6693ff2a81b0020bfe.png
[Link 3]: http://www.youngxy.top:8080/