SSM基础篇(四)--Spring

spring简介

spring是分层的JavaSE及JavaEE应用于全栈的轻量级开源框架,以IoC (Inverse Of Control:控制反转/反转控制)和 AOP(Aspact Oriented Programming:面向切面编程)为核心,提供了表现层SpringMVC和持久层SpringJDBC以及业务层事务管理等众多模块的企业级应用技术,还能整合开源世界中众多著名的第三方框架和类库,逐渐成为使用最多的JavaEE企业应用开源框架。
Spring的本质是管理软件中的对象,即创建对象和维护对象之间的关系

spring的架构

SSM基础篇(四)--Spring_第1张图片

Spring的优势

方便解耦,简化开发

通过 Spring提供的 IoC容器,可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为较为底层的需求编写代码,可以更专注于上层的应用。

AOP 编程的支持

通过 Spring的 AOP 功能,方便进行面向切面的编程,许多不容易用传统OOP(Object Oriented Programming:面向对象编程) 实现的功能可以通过 AOP 轻松应付。

声明式事务的支持

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

方便程序的测试

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

方便集成各种优秀框架

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

降低 JavaEE API 的使用难度。

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

Spring框架源码是经典学习范例

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

耦合和解耦

耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差(降低耦合性,可以提高其独立性)。耦合性存在于各个领域,而非软件设计中独有的,但是我们只讨论软件工程中的耦合。

总结:在软件工程中,耦合指的就是指对象之间的依赖关系。对象之间的依赖程度越高,耦合度就越高。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。

简单示例

1、创建持久层接口(com.tedu.dao.EmpDao)

package com.tedu.dao;
/**
 * 员工模块的Dao(持久层)接口
 */
public interface EmpDao {
    /** 添加员工信息 */
    public void addEmp();
}

2、创建持久层接口实现类(com.tedu.dao.EmpDaoImpl)

package com.tedu.dao;
/**
* 员工模块的Dao(持久层)接口实现类
*/
public class EmpDaoImpl implements EmpDao {
    @Override
    public void addEmp() {
        System.out.println("Dao层的addEmp()方法执行了..成功保存了一条员工信息..");
    }
}

3、创建业务层接口(com.tedu.service.EmpService)

package com.tedu.service;
/**
* 员工模块的service(业务层)接口
*/
public interface EmpService {
    /** 添加员工信息 */
    public void addEmp();
}

4、创建业务层接口实现(com.tedu.service.EmpServiceImpl)

package com.tedu.service;
import com.tedu.dao.EmpDao;
import com.tedu.dao.EmpDaoImpl;
/**
* 员工模块的service(业务层)接口实现类
* service层 ---> dao层
*/
public class EmpServiceImpl implements EmpService {
    /* 获取Dao接口的子类实例
    * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
    private EmpDao dao = new EmpDaoImpl();
    @Override
    public void addEmp() {
        System.out.println("调用dao层的方法添加员工信息...");
        dao.addEmp();
    }
}

5、创建表现层测试类(com.tedu.controller.EmpController)

package com.tedu.controller;
import org.junit.Test;
import com.tedu.service.EmpService;
import com.tedu.service.EmpServiceImpl;
/**
* 模拟表现层
* controller --> service --> dao
*/
public class EmpController {
    /* 获取Service接口的子类实例
    * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
    private EmpService service = new EmpServiceImpl();
    @Test
    public void testAddEmp() {
        System.out.println("调用service层的方法添加员工信息...");
        service.addEmp();
    }
}

6、创建com.tedu.factory.BeanFactory类,用于创建各个层所需要的对象。

package com.tedu.factory;
import java.io.InputStream;
import java.util.Properties;
/**
* ---------------------------------------------------------
* Bean: 可重用组件(计算机英语)
* JavaBean:使用Java语言编写的可重用组件,例如:service层、dao层等
* JavaBean:通常分为业务Bean和实体Bean
* 业务Bean:处理业务逻辑,service层、dao层
* 实体Bean:封装数据,例如,为了封装员工信息而编写的Emp实体类.
* ---------------------------------------------------------
* 解除耦合:
* (1)需要提供配置文件,在配置文件中配置service和dao的实现类
* 配置内容为:唯一标识=实现类的全限定类名(key=value结构)
* (2)通过工厂读取配置文件中配置的全限定类名,利用反射创建对象。
* xml配置文件、properties配置文件
*/
public class BeanFactory {
    //声明一个Properties对象,在静态代码块中对其进行初始化
    private static Properties prop;
    static {
        try {
            //为prop进行实例化
            prop = new Properties();
            //获取配置文件的流对象
            InputStream in = BeanFactory.class.getClassLoader()
            .getResourceAsStream("config.properties");
            //将配置文件中的内容读取到Properties对象中
            prop.load( in );
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("初始化Properties对象失败!");
        }
    }
    /**
    * 根据config.xml文件中的key获取对应class类的实例
    * @param key
    * @return
    */
    public static Object getBean(String key) {
        Object bean = null;
        try {
            String className = prop.getProperty( key );
            bean = Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

7、在源码目录下创建一个config.properties文件,文件内容配置如下:

EmpService=com.tedu.service.EmpServiceImpl
EmpDao=com.tedu.dao.EmpDaoImpl

8、将EmpController类中通过 "new对象的形式获取了EmpService接口子类的实例" 以及在EmpServiceImpl类中通过 "new对象的形式获取了EmpDao接口子类的实例" 改为使用BeanFactory工厂获取Service和Dao层的实例。如下:

/* 获取Service接口的子类实例
 * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
//private EmpService service = new EmpServiceImpl();
private EmpService service =
(EmpService)BeanFactory.getBean("EmpService");
/* 获取Dao接口的子类实例
 * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
//private EmpDao dao = new EmpDaoImpl();
private EmpDao dao = (EmpDao)BeanFactory.getBean( "EmpDao" );

Spring IOC控制反转

IOC(Inverse Of Control)控制反转,即,把创建对象的权利交给框架。也就是指将对象的创建、对象的存储、对象的管理交给了spring容器。
(spring容器是spring中的一个核心模块,用于管理对象,底层可以理解为是一个map集合)
SSM基础篇(四)--Spring_第2张图片

传统方式
/* 获取Service接口的子类实例
* ——这里使用new对象的方式造成了程序之间的耦合性提升 */
private EmpService service = new EmpServiceImpl();
//private EmpService service =
(EmpService)BeanFactory.getBean("EmpService");
使用框架
/* 获取Service接口的子类实例
* ——这里使用new对象的方式造成了程序之间的耦合性提升 */
//private EmpService service = new EmpServiceImpl();
private EmpService service =
(EmpService)BeanFactory.getBean("EmpService");

只需要将类提前配置在配置文件中,就可以将对象的创建交给框架来做。当需要对象时,不需要自己创建,而是通过框架直接获取即可,省去了new对象的过程,自然就降低类和类之间的依赖关系,也就是耦合性。

创建spring核心配置文件—applicationContext.xml






Bean对象的单例和多例

在Spring容器中管理的Bean对象的作用域,可以通过scope属性或用相关注解指定其作用域。最常用是singleton(单例)或prototype(多例)。

singleton:单实例,是默认值。这个作用域标识的对象具备全局唯一性。
  • 当把一个 bean 定义设置scope为singleton作用域时,那么Spring IOC容器只会创建该bean定义的唯一实例。也就是说,整个Spring IOC容器中只会创建当前类的唯一一个对象。
  • 这个单一实例会被存储到单例缓存(singleton cache)中,并且所有针对该bean的后续请求和引用都 将返回被缓存的、唯一的这个对象实例。
  • singleton负责对象的创建、初始化、销毁。
prototype:多实例。这个作用域标识的对象每次获取都会创建新的对象。
  • 当把一个 bean 定义设置scope为singleton作用域时,Spring IOC容器会在每一次获取当前Bean时,都会产生一个新的Bean实例(相当于new的操作)
  • prototype只负责对象的创建和初始化,不负责销毁。

Spring DI依赖注入

DI(Dependency Injection)依赖注入 。
依赖注入,即组件之间的依赖关系由容器在应用系统运行期来决定,也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

简单来说,所谓的依赖注入其实就是,在创建对象的同时或之后,如何给对象的属性赋值。

spring提供两种方式为属性赋值:

(1).Set方式注入
(2).构造方法注入

set方式注入

修改applicationContext.xml中User实例的声明,为User实例注入属性



    
    
    

对象属性注入

在applicationContext.xml中,将UserInfo对象作为值,赋值给User对象的userInfo属性

    
    
    
    
    
    
    

构造方法注入

修改applicationContext.xml文件,将set方式修改为构造方法注入。


    
    
    
    

你可能感兴趣的