首页 > > 程序设计 > Java技术 >

Spring入门

2018-06-27 09:46:05来源：博客园阅读 ()

Spring简介

Spring 是一个开放源代码的框架。
Spring为简化企业级应用开发而生，使用spring可以使简单的javaBean实现以前只有EJB才能实现的功能。
Spring是一个IOC(DI)、AOP容器框架。
Spring是一个一站式的开发框架。

Spring是轻量级的框架

轻量级：Spring是非侵入性的-基于Spring开发的应用中的对象可以不依赖于Spring的API。（不用继承或实现接口）。

控制反转（DI—dependency injection、IOC—Inversion of Control）

当应用了IOC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建（不需要自己去new对象）。

AOP（Aspect Oriented Programming ：AOP编程的支持）

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

声明式事务的支持

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

方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序

方便集成各种优秀框架

简化各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Mybatis、Quartz）等的直接支持。

Spring的模块架构图：

每个模块的功能如下：

l 核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开
l Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。
l Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
l Spring DAO：JDBCDAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
l Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和Mybatis。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
l Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
l Spring MVC 框架：MVC框架是一个全功能的构建 Web应用程序的 MVC 实现。

Spring的入门小demo

1. 创建maven web工程

2. 解决web工程的两个问题

- jdk版本过低问题
- 丢失web.xml的问题

3. 导入我们工程必须的jar包

<dependencies>
 　　 <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
　　<dependency>
   　　 <groupId>org.springframework</groupId>
   　　 <artifactId>spring-context</artifactId>
   　　 <version>4.2.4.RELEASE</version>
　　</dependency>
  　　<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
　　<dependency>
   　　 <groupId>org.springframework</groupId>
   　　 <artifactId>spring-core</artifactId>
  　　  <version>4.2.4.RELEASE</version>
　　</dependency>
　　  <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
　　<dependency>
    　　<groupId>org.springframework</groupId>
    　　<artifactId>spring-beans</artifactId>
   　　 <version>4.2.4.RELEASE</version>
　　</dependency>
  　　<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
　　<dependency>
    　　<groupId>org.springframework</groupId>
    　　<artifactId>spring-expression</artifactId>
    　　<version>4.2.4.RELEASE</version>
　　</dependency>

</dependencies>

4. 创建接口及实现类

接口：

public interface IUserDao {

    public void sayHello();
}

实现类：

public class UserDaoImpl implements IUserDao {
    private String username;
    
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public void sayHello() {
        System.out.println("hello " + username);
    }
}

5. 创建spring容器的核心配置文件applicationContext.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="userDaoImpl" class="spring.spring01.demo1.UserDaoImpl">
        <property name="username" value="spring"></property>
    </bean>
</beans>

6. 编写测试代码

public class UserDaoTest {
    @Test
    public void test() throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        IUserDao bean = (IUserDao) context.getBean("userDaoImpl");
        bean.sayHello();
    }
}

spring容器的概念及三种创建方式

核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Ⅰ.　　XmlBeanFactory来获取容器类

使用XmlBeanFactory来获取我们的beanFactory(已经过期，不建议使用)

/**
     * 第一种方式：    使用XmlBeanFactory的方式来获取容器类(已过期，不建议使用)
     * XmlBeanFactory需要传入一个配置文件的路径，这个配置文件就是spring的配置文件
     * spring默认的配置文件是applicationContext.xml
     */
    @Test
    public void test01() throws Exception {
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        
        Class<? extends BeanFactory> class1 = factory.getClass();
        
        System.out.println(class1);
        //结果：class org.springframework.beans.factory.xml.XmlBeanFactory
    }

Ⅱ.　　ClassPathXmlApplicationContext获取容器类

从类路径下加载配置文件：

/**
     * 第二种方式：ClassPathXmlApplicationContext
     */
    @Test
    public void test02() throws Exception {
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        Class<? extends BeanFactory> class1 = factory.getClass();
        
        System.out.println(class1);
        //结果：class org.springframework.context.support.ClassPathXmlApplicationContext
    }

Ⅲ.　　FileSystemXmlApplicationContext来获取容器

从文件系统中加载配置文件：

/**
     * 第三种方式：FileSystemXmlApplicationContext
     * 注意：这种方式需要传入配置文件的绝对路径
     * 可以使用外部的配置文件
     */
    @Test
    public void test03() throws Exception {
        BeanFactory factory = new FileSystemXmlApplicationContext("D:\\source\\Web\\maven\\springStart\\src\\main\\resources\\applicationContext.xml");
        
        Class<? extends BeanFactory> class1 = factory.getClass();
        
        System.out.println(class1);
        //结果：class org.springframework.context.support.FileSystemXmlApplicationContext
    }

IOC

IOC：inversion of control 控制反转：说白了就是将创建对象的过程或者说创建对象的权限交给了spring框架来帮我们处理，我们再不用通过new的方式来创建Javabean对象，这个过程就叫做控制反转。

DI：dependency injection 依赖注入: 就是组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入。说白了就是使用spring框架为我们的JavaBean的属性赋值的过程。

·　默认构造器创建对象

创建bean

public class UserBean {

    private String info;

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
    
    public void show(){
        System.out.println("show method is invoked!");
    }
}

配置配置文件

　　<!--
        id：唯一标识
        class：创建对象的类路径
        
        通过反射创建userBean对象
     -->
    <bean id="userBean" class="spring.ioc.UserBean">
        <property name="info" value="this is userBean... ... "></property>
    </bean>

注意：Class:bean的全类名，通过反射的方式在IOC容器中创建Bean，所以要求Bean中必须有无参的构造器。

Id:标识容器中的bean，id唯一。

　　从容器中获取我们的UserBean对象

　　/**
     * 默认构造器创建对象
     */
    @Test
    public void iocTest() throws Exception {
        /**
         * 1、创建spring容器
         * 2、从容器中获取userBean的对象
         * 3、调用userBean的方法
         */
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml"); 
        UserBean bean = (UserBean) applicationContext.getBean("userBean");
        bean.show(); 
        System.out.println(bean.getInfo());
    }

·　静态工厂创建对象

调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中。当客户端需要对象时，只需要简单地调用静态方法，而不用关心创建对象的细节(往往使用工厂方法就是为了应对创建对象比较复杂的情况)。

创建bean

public class Car {

    private String brand;
    
    private Integer price;
        ...
        // get、set方法，有参、无参构造器
}

创建静态工厂

/**
 * 静态工厂：创建对象的方式，调用静态方法的方式
 */
public class StaticCarFactory {

    private static Map<String, Car> cars = new HashMap<>();
    
    static{
        cars.put("奥迪", new Car("audiA8",100000));
        cars.put("宝马", new Car("bmw",500000));
    }
    
    public static Car getCar(String brand){
        return cars.get(brand);
    }
}

　　配置配置文件

　　　<!-- 
        id：唯一标识
        class：静态工厂的class路径
        factory-method：静态工厂方法
     -->
     <bean id="car" class="spring.ioc.StaticCarFactory" factory-method="getCar">
         <!-- 如果工厂方法需要参数，通过constructor-arg传递参数 -->
         <constructor-arg value="奥迪"></constructor-arg>
     </bean>

　　编写测试代码

　　/**
     * 静态工厂创建对象
     */
    @Test
    public void staticFactoryTest() throws Exception {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml");       
        Car bean = (Car) applicationContext.getBean("car");
        System.out.println(bean);       
    }

·　实例工厂创建对象

实例工厂方法：将对象的创建过程封装到另外一个对象实例的方法里。当客户端需要请求对象时，只需要简单的调用该实例方法而不需要关心对象的创建细节(往往使用工厂方法就是为了应对创建对象比较复杂的情况)。

创建bean

public class Car {

    private String brand;
    
    private Integer price;
        ...
        // get、set方法，有参、无参构造器
}

创建静态工厂

public class InstanceCarFactory {
    private Map<String, Car> cars = null;

    public InstanceCarFactory() {
        cars = new HashMap<String,Car>();    
        cars.put("one", new Car("小天", 100));
        cars.put("two", new Car("大波", 50));
    }
    
    public Car getCar(String brand){
        return cars.get(brand);
    }    
}

　　配置配置文件

　　　　<!-- 
         首先创建实例工厂，才能创建javaBean
      -->
      <bean id="instanceCarFactory" class="spring.ioc.InstanceCarFactory"></bean>
      <bean id="car" factory-bean="instanceCarFactory" factory-method="getCar">
          <!-- 如果工厂方法需要参数，通过constructor-arg传递参数 -->
         <constructor-arg value="one"></constructor-arg>
      </bean>

　　编写测试代码

　　/**
     * 实例工厂创建对象
     */
    @Test
    public void instanceFactoryTest() throws Exception {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext-ioc.xml");
        Car bean = (Car) applicationContext.getBean("car");
        System.out.println(bean);
    }

Bean的作用域

默认情况下，Spring只为每个在IOC容器里声明的Bean创建唯一一个实例（singleton），整个IOC容器范围内都可共享该实例：所有后续的getBean（）调用和Bean引用都将返回这个唯一的Bean实例。该作用域被称为singleton，它是所有Bean的默认作用域。

在Spring中，可以在< bean>元素的scope属性里设置Bean的作用域。默认有四种取值：

Singleton、prototype、request、session

singleton:默认值，容器初始化是创建bean实例，在整个容器的生命周期内只创建这一个bean，单例的。

prototype：原型的，容器初始化时不创建bean的实例，而在每次请求时都创建一个新的Bean实例，并返回。