优雅的Spring框架介绍

什么是spring？我这里简单介绍一下：spring是一个一站式的解决框架，提供了开发JAVA应用程序时所需的全面的基础架构，所以你可以把注意力放到程序实现上。

spring的核心是控制反转（IoC）、依赖注入（DI）和面向切面（AOP）

spring的优点：

* 轻量级的容器框架，没有侵入性
* IoC更加容易组合对象之间的关系，通过面向接口进行编程，可以低耦合开发。
* 易于本地测试(Junit单元测试，不用部署服务器)
* AOP可以更加容易的进行功能扩展，遵循OCP开发原则。
* Spring默认对象的创建为单例的，我们不需要再使用单例的设计模式来开发单体类。
* Spring的集成很强大，另外可以对其他框架的配置进行一元化管理。
* Spring的声明式事务的方便使用

IoC： inversion of controller ，把创建对象的控制权利反转交给了spring，这一过程叫做控制反转（就是通过反射创建对象的过程）

首先要想用spring，第一步肯定就是导包咯。spring有 4 + 1 ： 4个核心（beans、core、context、expression） + 1个依赖（commons-loggins…jar）这里我用maven来加入这些依赖，没用maven的手动导入这些jar包就可以了！
maven的配置文件 pom.xml 如下：

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0modelVersion>
  <groupId>com.yida.springgroupId>
  <artifactId>spring01artifactId>
  <version>0.0.1-SNAPSHOTversion>
  <packaging>warpackaging>

    <dependencies>
    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>4.2.4.RELEASEversion>
dependency>
    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-coreartifactId>
    <version>4.2.4.RELEASEversion>
dependency>
    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-beansartifactId>
    <version>4.2.4.RELEASEversion>
dependency>
    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-expressionartifactId>
    <version>4.2.4.RELEASEversion>
dependency>

  
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webartifactId>
    <version>4.2.4.RELEASEversion>
dependency>

<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>javax.servlet-apiartifactId>
    <version>3.1.0version>
    <scope>providedscope>

dependency>
    
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aopartifactId>
    <version>4.2.4.RELEASEversion>
dependency>

  dependencies>

  <build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.pluginsgroupId>  
            <artifactId>maven-compiler-pluginartifactId>  
            <configuration>  
                <source>1.8source>
                <target>1.8target>  
            configuration>  
        plugin>  
    plugins>  
build>
project>

入门案例 ：创建一个接口UserService

public interface UserService {
    void sayHello();
}

以及接口的实现类UserServiceImpl：

public class UserServiceImpl implements UserService{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

}

applicationContext.xml配置如下：

id="UserServiceImpl" class="com.yida.spring.demo01.UserServiceImpl">
    <property name="name" value="zhoujie">property>

测试用例：

@Test
    public void test01(){
        //获取spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl userservice = (UserServiceImpl) context.getBean("UserServiceImpl");
        userservice.sayHello();//结果：hello springzhoujie
    }

接下来测试通过静态工厂的方式来创建对象：
首先我们有一个生产静态工厂的方法 MyStaticFactory

public class MyStaticFactory {
    public static SayHelloFactoryClass getMyFactory(){
        return new SayHelloFactoryClass();
    }
}

具体的方法SayHelloFactoryClass

public class SayHelloFactoryClass {
    public void sayHello(){
        System.out.println("hello static myfactory class");
    }
}

applicationContext.xml配置如下：

<bean id="MyStaticFactory" class="com.yida.spring.demo02.MyStaticFactory" factory-method="getMyFactory">bean>

测试用例：

/**
     * 测试静态工厂的方式创建对象
     */
    @Test
    public void test02(){
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         SayHelloFactoryClass sayHello = (SayHelloFactoryClass) context.getBean("MyStaticFactory");
         sayHello.sayHello();//结果：hello static myfactory class
    }

实例工厂的方式来创建对象：
有一个实例工厂类MyInstanceFactory：

public class MyInstanceFactory {
    public MyInstanceFactoryClass getMyInstance(){
        return new MyInstanceFactoryClass();
    }
}

具体的方法为MyInstanceFactoryClass

public class MyInstanceFactoryClass {
    public void sayHello(){
        System.out.println("hello my instance factory");
    }
}

applicationContext.xml配置如下：

<bean id="MyInstanceFactory" class="com.yida.spring.demo02.MyInstanceFactory">bean>
<bean id="MyInstanceFactoryClass" class="com.yida.spring.demo02.MyInstanceFactoryClass" factory-bean="MyInstanceFactory"

测试用例：

/**
     * 通过实例 工厂创建对象
     */
    @Test
    public void test03(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyInstanceFactoryClass myIns = (MyInstanceFactoryClass) context.getBean("MyInstanceFactoryClass");
        myIns.sayHello();//hello my instance factory
    }

spring对象的生命周期：
目标类BeanLife如下：

public class BeanLife {
    /**
     * 指定初始化方法
     */
    public void initMethod(){
        System.out.println("我是初始化方法，我在创建对象的时候就会被调用");
    }
    public void sayHello(){
        System.out.println("hello  bean  life  ");

    }
    /**
     * 指定销毁方法
     */
    public void destroyMehtod(){
        System.out.println("我是关闭方法，只有在容器关闭的时候，我才会被调用");
    }

}

applicationContext.xml配置如下：

  <bean id="beanLife" class="cn.itcast.spring.demo3.BeanLife" init-method="initMethod" destroy-method="destroyMehtod">bean>

测试用例：

/**
     * spring容器创建对象的生命周期
     */

    @Test
    public void getBeanLife() throws Exception {
        //获取容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanLife bean = (BeanLife) context.getBean("beanLife");
        bean.sayHello();
        context.close();
    }

运行结果：
我是初始化方法，我在创建对象的时候就会被调用
hello bean life
我是关闭方法，只有在容器关闭的时候，我才会被调用

以上只是做了一个spring的基本用法介绍，spring的依赖注入这里 就不做过多的介绍了，那么说一下spring与web的整合吧。通过以上介绍我们知道，再拿对象的时候通过spring容器我们已经不需要用一次就new一次了，这样大大节省了内存，那么问题 来了，我们每次创建容器的时候都需要new，很麻烦，也很浪费内存。那么我们可不可以在我们的Tomcat服务器一启动的时候就创建我们的容器，然后就保证我们的容器不会被销毁呢？
办法是有的。我们的应用一启动就会去加载一个servletContext对象，直到我们的Tomcat停止为止！ 那么我们可以写一个监听器，来监听servletContext的启动（顺便提一下Javaweb的三大组件：servlet、filter、listener），servletContext一启动就马上启动spring的容器 ，spring的容器启动成功后就将spring容器丢到servletContext里面，以后每次用就直接从servletContext中获取即可，ok完成！注意这个过程已经有人帮我们写好了，我们不用自己写，虽然你自己写也是可以的。只需导入spring-web的包就可以了，前面一开始的时候我已经放在pom.xml里面了。然后在WEB-INF里的web.xml里配置监听器如下：

<context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

创建servlet测试：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        ServletContext servletContext = request.getServletContext();
        WebApplicationContext applicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        System.out.println(applicationContext);
        SayHelloFactoryClass bean = (SayHelloFactoryClass) applicationContext.getBean("MyStaticFactory");
        bean.sayHello();
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

这里调用的是静态工厂方法，spring与web的整合已经完成！