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环境。