Spring框架的核心技术

た入场券 2023-06-09 11:27 24阅读 0赞

**Spring概述**  
 Spring是一个分层的Java SE/EE应用一站式的轻量级开源框架。Spring核心是IOC和AOP。  
**Spring主要优点包括：**

1.  方便解耦，简化开发，通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码造成的程序耦合度高。
2.  AOP编程的支持，通过Spring提供的AOP功能，方便进行面向切面编程。
3.  声明式事务的支持，在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
4.  方便程序的测试，可以用非容器依赖的编程方式进行几乎所有的测试工作。
5.  方便集成各种优秀框架，Spring提供了对各种优秀框架的直接支持。  
    **Spring体系结构**  
    整个spring框架按其所属功能可以划分为五个主要模块，这五个模块几乎为企业应用提供了所需的一切，从持久层、业务层到表现层都拥有相应的支持，这就是为什么称Spring是一站式框架的原因。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc4OTQ1_size_16_color_FFFFFF_t_70]  
    1.核心模块（Core Container）  
    Spring的核心模块实现了IOC的功能，它将类和类之间的依赖从代码中脱离出来，用配置的方式进行依赖关系描述。由IOC容器负责类的创建，管理，获取等。BeanFctory接口是Spring框架的核心接口，实现了容器很多核心的功能。  
    Context模块构建于核心模块之上，扩展了BeanFactory的功能。ApplicationContext是Context模块的核心接口。  
    表达式语言(Expression Language)是统一表达式语言（EL）的一个扩展，支持设置和获取对象属性，调用对象方法，操作数组、集合等。使用它可以很方便的通过表达式和Spring IOC容器进行交互。  
    2.AOP模块  
    Spring AOP模块提供了满足AOP Alliance规范的实现，还整合了AspectJ这种AOP语言级的框架。通过AOP能降低耦合。  
    **数据访问集成模块（Data Access/Integration ）**  
    该模块包括了JDBC、ORM、OXM、JMS和事务管理：  
    1.事务模块：该模块用于Spring管理事务，只要是Spring管理对象都能得到Spring管理事务的好处，无需在代码中进行事务控制了，而且支持编程和声明性的事务管理。  
    2.JDBC模块：提供了一个JBDC的样例模版，使用这些模版能消除传统冗长的JDBC编码还有必须的事务控制，而且能享受到Spring管理事务的好处。  
    3.ORM模块：提供与流行的“对象-关系” 映射框架的无缝集成，包括hibernate、JPA、MyBatis等。而且可以使用Spring事务管理，无需额外控制事务。  
    4.OXM模块：提供了一个对Object/XML映射实现，将Java对象映射成XML数据，或者将XML数据映射成java对象，Object/XML映射实现包括JAXB、Castor、XMLBeans和XStream。  
    5.JMS模块：用于JMS(Java Messaging Service),提供一套“消息生产者、消息消费者”模板用于更加简单的使用JMS，JMS用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。  
    Web模块  
      该模块建立在ApplicationContext模块之上，提供了Web应用的功能，如文件上传、FreeMarker等。Spring可以整合Struts2等MVC框架。此外，Spring自己提供了MVC框架Spring MVC。  
      测试模块  
      Spring可以用非容器依赖的编程方式进行几乎所有的测试工作，支持JUnit和TestNG等测试框架。  
      **初识IOC和DI**  
      1、IoC控制反转和DI依赖注入  
    　　传统程序设计中，我们需要使用某个对象的方法，需要先通过new创建一个该对象，我们这时是主动行为；而IoC是我们将创建对象的控制权交给IoC容器，这时是由容器帮忙创建及注入依赖对象，我们的程序被动的接受IoC容器创建的对象，控制权反转，所以叫控制反转。

由于IoC确实不够开门见山，所以提出了DI（依赖注入：Dependency Injection）的概念，即让第三方来实现注入，以移除我们类与需要使用的类之间的依赖关系。总的来说，\*\*IoC是目的，DI是手段，\*\*创建对象的过程往往意味着依赖的注入。我们为了实现IoC，让生成对象的方式由传统方式(new)反转过来，需要创建相关对象时由IoC容器帮我们注入(DI)。

**简单的说，就是我们类里需要另一个类，只需要让Spring帮我们创建 ，这叫做控制反转；然后Spring帮我们将需要的对象设置到我们的类中，这叫做依赖注入。**  
　　2.常见的几种注入方法  
　　**使用有参构造方法注入**

public class  User{
        private String name;
        public User(String name){
            this.name=name;
        }
    } 
    
        User user=new User("tom");

**使用属性注入**

public class  User{
        private String name;
        public void setName(String name){
            this.name=name;
        }
    }
    
         User user=new User();
         user.setName("jack");

**使用接口注入**

// 将调用类所有依赖注入的方法抽取到接口中，调用类通过实现该接口提供相应的注入方法。 
    
    public interface Dao{
        public void delete(String name);
    } 
    
    public class DapIml implements Dao{
        private String name;
        public void delete(String name){
            this.name=name;
        }
    }

**通过容器完成依赖关系的注入**

上面的注入方式都需要我们手动的进行注入，如果有一个**第三方容器能帮助我们完成类的实例化**，以及依赖关系的装配，那么我们只需要专注于业务逻辑的开发即可。Spring就是这样的容器，它通过配置文件或注解描述类和类之间的依赖关系，自动完成类的初始化和依赖注入的工作。  
3.Spring的IOC例子  
(1) 创建工程，导入jar包

这里我们只是做IoC的操作，所以只需要导入核心模块里的jar包，beans、core、context、expression等。因为spring中并没有日志相关的jar包，所以我们还需要导入log4j和commons-logging。

(2) 创建一个类

public class User {
        public void add(){
            System.out.println("add.....");
        }
    }

(3) 创建一个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"> 
    
        //配置要创建的类  
        <bean id="user" class="com.cad.domain.User"/>        
    </beans>

(4) 进行测试

//这只是用来测试的代码，后期不会这么写
    public class Test {
    
        @org.junit.Test
        public void test(){
            //加载配置文件
            ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
            //获取对象
            User user=(User) context.getBean("user");
            System.out.println(user);
            //调用方法
            user.add();
        }
    }

在容器启动时，Spring会根据配置文件的描述信息，自动实例化Bean并完成依赖关系的装配，从容器中即可获得Bean实例，就可以直接使用。Spring为什么仅凭一个简单的配置文件，就能神奇的实例化并配置好程序使用的Bean呢？答案是通过 Java的反射技术。

4.Spring的DI例子  
 我们的service层总是用到dao层，以前我们总是在Service层new出dao对象，现在我们使用依赖注入的方式向Service层注入dao层。

// UserDao
    public class UserDao {
        public void add(){
            System.out.println("dao.....");
        }
    }
    
    // UserService
    public class UserService {
        UserDao userdao;
        public void setUserdao(UserDao userdao){
            this.userdao=userdao;
        }
    
        public void add(){
            System.out.println("service.......");
            userdao.add();
        }
    }
    
    -------------------------------分割线--------------------------
    
    // 配置文件
    <bean id="userdao" class="com.cad.domain.UserDao"></bean> 
    //这样在实例化service的时候，同时装配了dao对象，实现了依赖注入
    <bean id="userservice" class="com.cad.domain.UserService">
        //ref为dao的id值
        <property name="userdao" ref="userdao"></property>
    </bean>

**Spring的Ioc容器详解**  
**1.BeanFactory**  
　　BeanFactory是一个类工厂，和传统的类工厂不同，传统的类工厂仅负责构造一个类或几个类的实例；而BeanFactory可以创建并管理各种类的对象，Spring称这些被创建和管理的Java对象为Bean。

BeanFactory是一个接口，Spring为BeanFactory提供了多种实现，最常用的就是XmlBeanFactory。其中，BeanFactory接口最主要的方法就是getBean(String beanName)，该方法从容器中返回指定名称的Bean。此外，BeanFactory接口的功能可以通过实现它的接口进行扩展(比如ApplicationContext)。看下面的示例：

//我们使用Spring配置文件为User类提供配置信息，然后通过BeanFactory装载配置文件，启动Spring IoC容器。 
    <?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">
    
    <bean id="user" class="com.cad.domain.User"></bean>   
    </beans>

// 我们通过XmlBeanFactory实现类启动Spring IoC容器 
    public class Test {
        @org.junit.Test
        public void test(){ 
            //获取配置文件
            ResourcePatternResolver  resolver=new PathMatchingResourcePatternResolver(); 
            Resource rs=resolver.getResource("classpath:bean.xml");
    
            //加载配置文件并启动IoC容器
            BeanFactory bf=new XmlBeanFactory(rs);
    
            //从容器中获取Bean对象
            User user=(User) bf.getBean("user");
    
            user.speak();
        }
    }

XmlBeanFactory装载Spring配置文件并启动IoC容器，通过BeanFactory启动IoC容器时，并不会初始化配置文件中定义的Bean，初始化创建动作在第一个调用时。在初始化BeanFactory，必须提供一种日志框架，我们使用Log4J。  
 **2.ApplicationContext**  
  ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。在BeanFactory中，很多功能需要编程方式来实现，而ApplicationContext中可以通过配置的方式来实现。ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext，前者默认从类路径加载配置文件，后者默认从文件系统中加载配置文件，如下所示：

// 和BeanFactory初始化相似，ApplicationContext初始化也很简单
    ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");

ApplicationContext的初始化和BeanFactory初始化有一个重大的区别，BeanFactory初始化容器时并未初始化Bean，只有第一次访问Bean时才创建；而ApplicationContext则在初始化时就实例化所有的单实例的Bean。因此，ApplicationContext的初始化时间会稍长一点。  
**3.WebApplicationContext**  
  WebApplicationContext是专门为Web应用准备的，它允许以相对于Web根目录的路径中加载配置文件完成初始化工作。从WebApplicationContext中可以获取ServletContext的引用，整个WebApplicationContext对象作为属性放置到ServletContext中，以便Web应用环境中可以访问Spring应用上下文。ConfigurableWebApplicationContext扩展了WebApplicationContext,允许通过配置方式实例化WebApplicationContext，定义了两个重要方法。

setServletContext(ServletContext servletcontext)：为Spring设置ServletContext

setConfigLocation(String\[\] configLocations)：设置Spring配置文件地址。

WebApplicationContext初始化的时机和方式是：利用Spring提供的ContextLoaderListener监听器去监听ServletContext对象的创建，当ServletContext对象创建时，创建并初始化WebApplicationContext对象。因此，我们只需要在web.xml配置监听器即可。

<listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
    
        
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>

**4.BeanFactory、ApplicationContext和WebApplicationContext的联系与区别**  
  Spring通过一个配置文件描述Bean与Bean之间的依赖关系，通过Java语言的反射技术能实例化Bean并建立Bean之间的依赖关系。Spring的IoC容器在完成这些底层工作的基础上，还提供了bean实例缓存、生命周期管理、事件发布，资源装载等高级服务。

BeanFactory是Spring最核心的接口，提供了高级IoC的配置机制。ApplicationContext建立在BeanFactory的基础上，是BeanFactory的子接口，提供了更多面向应用的功能。我们一般称BeanFactory为IoC容器，ApplicationContext为应用上下文，也称为Spring容器。WebApplicationContext是专门为Web应用准备的，它允许以相对于Web根目录的路径中加载配置文件完成初始化工作，是ApplicationContext接口的子接口。

BeanFactory是Spring框架的基础，面向Spring本身；ApplicationContext面向使用Spring框架的开发者，几乎所有的应用我们都直接使用ApplicationContext而非底层的BeanFactory；WebApplicationContext是专门用于Web应用。  
　　5.父子容器  
　　通过HierarchicalBeanFactory接口，Spring的IoC容器可以建立父子层级关联的体系：子容器可以访问父容器的Bean，父容器不能访问子容器的Bean。

Spring使用父子容器实现了很多功能，比如在Spring MVC中，控制器Bean位于子容器中，业务层和持久层Bean位于父容器中。但即使这样，控制器Bean也可以引用持久层和业务层的Bean，而业务层和持久层就看不到控制器Bean。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMzc4OTQ1_size_16_color_FFFFFF_t_70]: /images/20230531/9c11a32da64c4e04a8306ff21bff5ab5.png