Spring入门代码，菜鸟代码，带你开启Spring入门。。。OK ，Spring is coming and Spring is the best time to learn Spring

中国的疫情终于快要结束了，为所有在疫情中奋战的人们致敬
为所有在疫情中不幸去世的人们默哀。
我们将永远铭记你们，我为自己得以是你们的同胞感到无比自豪
谢谢你们了！！
Spring is coming and Spring is the best time to learn Spring

Spring基本概述

Spring是一个开源框架，用来简化企业级应用而生，解决的是业务逻辑层和其他各层的松耦合问题，它将面向接口的编程思想贯穿于整个系统
Spring是JavaSE、EE的一站式框架
Spring优点：
1、方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖维护交给Spring管理。
2、AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
3、声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程
4、方便程序的测试，支持Junit，可以通过注解方便的测试Spring程序
5、方便集成各种优秀框架，如Struts，Hibernate，MyBatis。。。的直接支持
6、降低JavaEE API的使用难度，对开发中较难用的API进行了封装，使这些API的开发难度降低了。
（反正就是好，好就对了）

Spring IOC底层实现原理

传统方式开发：UserService us=new UserService ();
面向接口编程：UserService us=new UserServiceImpl ();
工厂模式：通过工厂类创建实例对象：UserService us=FactoryBean.getUS()；
工厂+反射+配置文件

  class FactoryBean{
  public static Object getBean(String id){
      解析xml进行反射，获得实例。
      }
  }

OCP原则：对修改代码关闭，对扩展功能开放，不修改代码的情况下对功能进行扩展。

Spring IOC快速入门案例

  1、下载Spring开发包
   http://repo.springsource.org/libs-release-local/org/springframework/spring
   这个网站下，我下的是4.2.4
 2、 复制Spring开发jar包到工程
 3、 理解IOC控制反转和DI依赖注入
        IOC Inverse of Control 反转控制的概念，就是将原本在程序中手动创建的UserService对象的控制权，交由Spring来完成。即原理创建UserService对象控制权被反转到了Spring框架
	     DI Dependency Injection 依赖注入的概念，就是在Spring创建这个对象的过程中，将这个对象所依赖的属性注入进去，在XML（Spring核心配置文件中）配置好
 4、 编写Spring核心配置文件
  5、在程序中读取Spring配置文件，通过Spring框架获得Bean完成相应操作。

1

解压过后

docs api文档和开发规范
libs 开发所需要的jar包（源码）
schema 开发所需要的schema文件

2、创建项目和导入Spring包

然后一直next
最后呢
我们等待。。。。
因为他要引入maven中央仓库的依赖

漫长的等待过后的结果

然后我们配置pom.xml文件
内容如下：若是从外网下比较慢，可自行百度配置下maven的阿里仓库，下载速度直接飙升百倍。

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

<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.0</modelVersion>

  <groupId>com.imooc</groupId>
  <artifactId>spring_ioc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring_ioc Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>spring_ioc</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

接下来是创建第一个项目需要的包结构和类
在demo1文件夹下面我们的SpringDemo1类是用来测试的，测试类在最后展示
UserService是接口，UserServiceImpl是接口的实现

对应的代码

public interface UserService {
    public void sayHello();
}

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 GOD  " +name );
    }
}

4、编写Spring核心配置文件

先配置这一个就好

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
 <!--UserService的创建权交给了Spring-->
    <bean id="userService" class="com.imooc.ioc.demo1.UserServiceImpl">
        <!--&lt;!&ndash;设置属性&ndash;&gt;-->
        <property name="name" value="GOD"></property>
    </bean>

</beans>

接下来最后是我们的测试类SpringDemo1

public class SpringDemo1 {
    @Test
    /**
     * 传统方式开发
     */
    public void demo1(){
        // UserService userService=new UserServiceImpl();
        UserServiceImpl userService=new UserServiceImpl();
        //设置属性
        userService.setName("GOD");

        userService.sayHello();
    }

    @Test
    /**
     * Spring 方式实现
     *
     */
    public void demo2(){
        //创建Spring工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

      //通过工厂获得类
       UserService userService=(UserService) applicationContext.getBean("userService");

        userService.sayHello();;
    }
}

出现这样的效果，就意味着我们可以读取Spring配置文件，通过Spring框架获得Bean完成相应操作。

也就是Spring的入门实例，完成啦