Spring框架简介

发表于 | 分类于 | 阅读次数
字数统计: 1,697 | 阅读时长 ≈ 7

前言，对Spring框架的一些总结

spring框架的特征

  1. 轻量级
  2. IOC(控制反转思想),非侵入式
  3. AOP(面向切面编程思想)
  4. 容器/工厂

谈谈对spring的理解

  • spring是一个开源框架，为简化企业级应用开发而生
  • spring可以使用简单的javaBean实现只有EJB才能实现的功能
  • spring是一个IOC(控制反转)和AOP(面向切面编程)容器框架
  • 方便解耦，简化开发
    • spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给spring管理，AOP编程的支持
  • AOP编程支持
    • spring提供面向切面编程，可以方便的实现对程序进行权限拦截，运行监控等功能
  • 方便程序测试
    • spring对Junit4支持，可以通过注解方便测试
  • 方便集成各种优秀框架
    • spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持(MyBatis、Struts、Hibernate….)
  • 声明式事物的支持
    • 只需要通过配置就可以完成对事物的管理，无需手动编程

开发环境配置

1.spring 核心容器的最基本jar包

  • Beans
    • spring-beans-4.2.4.RELEASE.jar
  • Core
    • spring-context-4.2.4.RELEASE.jar
  • Context
    • spring-core-4.2.4.RELEASE.jar
  • Expression Language
    • spring-expression-4.2.4.RELEASE.jar

2.spring框架所需的日志包

  • 默认采用apache commons-logging(JCL)日志框架+log4j的日志实现，还需要添加log4j的配置文件。

控制反转 IOC (inversion of control)

  • 传统的java开发模式中，当需要一个对象时，我们会自己使用new 或者 getInstance等直接或间接调用高中方法创建对象。而在spring开发模式中，spring容器使用了工厂模式为我们创建了所需要的对象，不需要我们自己创建，直接调用spring提供的对象即可，这就是控制反转思想。也就是将对象创建权反转给spring，解决程序的耦合性(传统的java开中，service层与dao层关联依赖过多，导致耦合性大大的增加)。由spring创建对象的过程,就是IOC

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

  • 引入约束
1
2
3
4
5
6
<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">
</beans>
  • 在beans中配置DAO or Service….其他Bean
1
2
3
4
5
6
7
8
 <!-- 
   IOC:控制反转
   bean: spring工厂帮你new的一个对象(反射机制)
   id/name: 标识对象的名称, 通过该名称来获取bean对象
   class: 要new对象类的全限定名
  -->
<bean id="user_dao" class="com.jason.spring.dao.impl.UserDaoImpl"></bean>
<bean id="user_service" class="com.jason.spring.service.impl.UserServiceImpl"></bean>
  • 测试
1
2
3
4
5
6
7
8
9
@Test
public void demo1() {
    // TODO 创建Spring的工厂, 加载applicationContext.xml配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    // TODO 通过标识对象的名称获得实例
    IUserDao dao = (IUserDao) ac.getBean("user_dao");
    // TODO 调用方法
    dao.sayHello();
}

依赖注入 DI (Dependency Injection )

  • spring使用JavaBean对象的set方法或者构造函数为我们在创建所需对象时将其属性自动设置所需要值的过程，就是依赖注入思想

  • 在业务层中定义一个dao层属性，并添加set方法

1
2
3
4
5
6
7
8
9
10
11
public class UserServiceImpl implements IUserService {
    private IUserDao userDao;
    public void setUserDao(IUserDao dao) {
        this.userDao = dao;
    }
    
    @Override
    public void sayHelloService() {
        userDao.sayHello();
    }
}
  • 配置spring容器
1
2
3
4
5
6
7
8
9
10
<!-- 
  DI:依赖注入:由spring创建对象时，将一个对象注入到另一个对象的过程就是DI
  property: 属性注入
   name: 表示set方法的名称
   ref: 表示spring容器创建对象的表示名称，进行注入，表示对象的注入
   value: 表示值的注入
 -->
<bean id="user_service" class="com.jason.spring.service.impl.UserServiceImpl">
    <property name="userDao" ref="user_dao"></property>
</bean>
  • 测试
1
2
3
4
5
6
7
// TODO 依赖注入
@Test
public void testDI() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    IUserService service = (IUserService) ac.getBean("user_service");
    service.sayHelloService();
}

IOC 与 DI 的区别

  • IOC : 控制反转，将对象的创建权交给spring;
  • DI : 依赖注入，在spring创建这个类的过程中，把这个类所依赖的属性设置进来;

spring的工厂类

  • BeanFactory with ApplicationContext
  1. BeanFactory 是早期spring提供的工厂类
  2. ApplicationContext是目前版本提供的工厂类
  3. ApplicationContext的功能比BeanFactory功能多
    • BeanFactory在调用getBean()方法时才会生成类的实例
    • ApplicationContext在加载spring配置文件的时候生成类的实例
  • ApplicationContext的实现类的区别
  1. ClassPathXmlApplicationContext
    1. 加载的是类路径(src)下的spring配置文件
  2. FileSystemXMLApplicationContext
    1. 加载的是文件系统下的配置文件(磁盘路径)
  • Question
  1. 为什么不直接使用顶级接口对象来操作
    1. BeanFactory采用延迟加载，第一次getBean时才会初始化Bean
    2. BeanFactory的用法：
      1. BeanFactory ac = new XmlBeanFactory(new CalssPathResource(“application.xml”));
      2. BeanFactory ac = new XmlBeanFactory(new FileSystemResource(“D:\applicationContext.xml”));
    3. ApplicationContext是对BeanFactory扩展，提供更多地功能
      1. 国际化处理
      2. 事件传递
      3. Bean自动装配
      4. 各种不同应用层的Context的实现
  2. 由此可见，ApplicationContext 更加强大。so，现在开发基本没人用BeanFactory
  • show code
1
2
3
4
5
6
7
8
9
10
11
public void testSpring(){
    //构建spring工厂
    //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    //使用BeanFactory
    //BeanFactory applicationContext = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
    
    //直接使用超级接口
    BeanFactory applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    IUserService userService=(IUserService) applicationContext.getBean("userService");
    userService.login();
}

spring相关配置

  • bean中 id 与 name 的配置

    • id 中不能出现特殊字符
    • name中可以出现特殊字符
      • name中可以指定多个标识符(第一个为标识符，其余的为别名，若指定了id，id则为标识符，name中的为别名)
      • name中的标识符可以使用 ‘,’ ‘;’ ‘ ‘(逗号，分号，空格)分隔开

  • bean的作用访问配置：scope的配置

    • spring创建类时，默认采用单例模式进行创建，如果想改变单例模式，需要通过scope属性设置
    • scope属性的取值：
      • singleton : 默认值，单例
      • prototyep : 多例的
      • request、session、globalsession，分别是将创建的对象存到request、session、全局的session中

  • bean的生命周期配置

    • 创建Bean.java

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      public class Bean {

          public Bean(){
              System.out.println("Bean的构造方法");
          }
          public void setup(){
              System.out.println("Bean被初始化了...");
          }
          public void destroy(){
              System.out.println("Bean被销毁了...");
          }
      }

    • spring容器下bean中配置

      1
      2
      <!-- Spring的Bean的作用范围的配置============ -->
      <bean id="bean1" class="com.itheima.spring.demo2.Bean1" scope="singleton" init-method="setup" destroy-method="destroy"></bean

  • spring的分模块开发的配置

    • 在加载配置文件时，加载多个配置文件

      1
      ApplicationContext applicationContext = new  ClassPathXmlApplicationContext("applicationContext.xml", "applicationContext2.xml");

    • 在配置文件中引入其他配置文件

      1
      <import resource="applicationContext_2.xml"/>
0%