Spring入门-------------1

Spring是一个开源框架，为简化企业级应用开发而生，使用Spring可以使简单的JavaBean 实现以前只有EJB才能实现的功能。Spring 是一个IOC和Aop容器框架。

特性：

轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API

依赖注入(DI --- dependency injection、IOC)

面向切面编程(AOP --- aspect oriented programming)

容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期

框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象

一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上 Spring 自身也提供了展现层的 SpringMVC 和持久层的 Spring JDBC）

创建maven工程：

修改pom.xml，引入jar包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xt</groupId>

  <artifactId>spring.ioc</artifactId>

  <packaging>war</packaging>

  <version>0.0.1-SNAPSHOT</version>

  <name>spring.ioc Maven Webapp</name>

  <url>http://maven.apache.org</url>

  <dependencies>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>4.12</version>

      <scope>test</scope>

    </dependency>

    <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>1.2.17</version>

        </dependency>

     <dependency>

            <groupId>commons-logging</groupId>

            <artifactId>commons-logging</artifactId>

            <version>1.2</version>

        </dependency>

         <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context</artifactId>

        <version>4.3.10.RELEASE</version>

    </dependency>

         <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context</artifactId>

        <version>4.3.10.RELEASE</version>

    </dependency>

  </dependencies>

  <build>

    <finalName>spring.ioc</finalName>

  </build>

</project>

创建一个Apple类：

package com.xt.spring.ioc;

public class Apple extends Fruit{

    String name="苹果";

    public void appleInit(){

        System.out.println("Apple还没有生产");

    }

    public void appleDestroy(){

        System.out.println("Apple结束生产");

    }

}

配置spring文件，即在src/main/resources下创建Spring文件夹，再文件夹中创建applicationContext.xml文件（也可以只在在src/main/resources下创建，不过这样做回事文件混乱）

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

               http://www.springframework.org/schema/beans/spring-beans.xsd

               http://www.springframework.org/schema/context

               http://www.springframework.org/schema/context/spring-context.xsd ">

    <!--

        在IOC容器中，所有的java类统称为 java bean,使用<bean>标签将javabean配置到IOC容器中

        bean标签两个重要的属性：1、class 引用javabean的全类名  2、id 为javabean定义一个ID，此ID不能在ioc容器中重复

     init-method：表示bean对象创建完毕，调用此初始化方法

     destroy-method:当bean回收时，调用此方法

     当scope表示Bean的作用域，默认值singleton，表示IOC容器中每个类默认只会产生一个Bean，也就是单例模式。

     当scope的值定义为prototype时，表示每次从IOC容器中获取的都是新的对象（在获取时实例化对象）。

下面是不同的bean，可以尝试运行一下，看看不同之处     

<bean id="apple" class="com.xt.spring.ioc.Apple" init-method="appleInit" destroy-method="appleDestory"></bean>

    <bean id="orange" class="com.xt.spring.ioc.Orange"></bean>

    <bean id="apple" class="com.xt.spring.ioc.Apple" ></bean>

-->
<bean id="apple" class="com.xt.spring.ioc.Apple" init-method="appleInit" destroy-method="appleDestory"></bean>

</beans>

最后创建一个测试类，

package com.xt.spring.ioc;

import org.junit.Before;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 * IOC容器中对象的实例化过程：

 * 1、IOC容器实例化

 * 2、IOC实例化完成之后，立刻开始实例化IOC容器中配置的javaBean

 * 3、使用javaBean

 *

 * 在spring IOC 容器中每个类默认只会生产一个Bean，也就单例模式。

 *

 */

public class test {

 private ApplicationContext ioc;

 @Before

 public void iocInit(){

     ioc = new ClassPathXmlApplicationContext("Spring/applicationContext.xml");

 }

 @Test

 public void iocTest(){

     Apple a = ioc.getBean("apple",Apple.class);

     Apple a1 = ioc.getBean("apple",Apple.class);

     System.out.println("======="+(a==a1));

     //Orange o = ioc.getBean("orange",Orange.class);

     a.eat();

 }

}

在Spring中，可以在<bean>元素的scope属性里设置Bean的作用域。

Singleton:SpringIOC 容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean，但我们可以指定bean节点的lazy-init=”true”来延迟初始化bean，这时候，只有第一次获取的bean才会初始化bean。

Prototype：每次从容器中获取bean都是新的对象。

Request：每次http请求都会创建一个新的bean，该作用域只适用于WebApplicationContext环境。

Session：类似Request，每次有新的绘画都会创建一个新的bean，该作用域只适用于WebApplicationContext环境。

巴特西

Spring入门-------------1

最新文章

热门文章