Spring入门

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

新老客户大回馈,云服务器低至5折

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的模块架构图

 

每个模块的功能如下:

  • 核心容器:核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转(IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开
  • l  Spring 上下文:Spring 上下文是一个配置文件,向 Spring框架提供上下文信息。Spring 上下文包括企业服务,例如JNDI、EJB、电子邮件、国际化、校验和调度功能。
  • 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 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
  • 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实例,并返回。

Bean的生命周期

         

SpringIOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务。

Spring IOC容器对Bean的生命周期进行管理的过程:

    • 通过构造器或工厂方法创建Bean实例
    • 为Bean的属性设置值和对其他Bean的引用set()
    • 调用Bean的初始化方法init()
    • 使用Bean的方法get()
    • 当容器关闭时,调用Bean的销毁方法destory()


 

DI

 

set方法注入

通过setter方法注入Bean的属性值或依赖的对象。 

对应的实体类中一定要有gettersetter方法,如果写了带参的构造器,

一定要有无参构造器,因为容器用此方法创建对象时会调用空参的构造器

 

    使用< property>元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 子节点指定属性值,如果是依赖对象类型,就使用ref属性。

 

  构造器注入

    通过构造方法注入Bean 的属性值或依赖的对象。

    

    配置使用p和c命名空间配置javabean

  

 

    配置带集合属性的Javabean

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:请不要在JDK7及以上用Json-lib了

下一篇:Java 多线程学习笔记(一)