Spring第一课

Spring框架是什么？

Spring的主要作用就是为代码“解耦”，降低代码间的耦合度。就是让对象和对象（模块和模块）之间关系不是使用代码关联，而是通过配置来说明。即在Spring 中说明对象（模块）的关系。 Spring 根据代码的功能特点，使用 Ioc 降低业务对象之间耦合度。IoC使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由Spring容器统一管理，自动“注入”,注入即赋值。 而 AOP使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了，而是由 Spring 容器统一完成“织入“。

一.Spring的优点

a. 轻量
Spring 框架使用的 jar 都比较小，一般在 1M 以下或者几百 kb。Spring 核心功能的所需的 jar 总共在 3M 左右。
Spring 框架运行占用的资源少，运行效率高。不依赖其他 jar
b. 针对接口编程，解耦合
Spring 提供了 Ioc 控制反转，由容器管理对象，对象的依赖关系。原来在程序代码中的对象创建方式，现在由容器完成。对象之间的依赖解耦合。
Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。
c. AOP 编程的支持
通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
d.方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架，相反 Spring 可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如 Struts,Hibernate、MyBatis）等的直接支持。简化框架的使用。
Spring 像插线板一样，其他框架是插头，可以容易的组合到一起。需要使用哪个框架，就把这个插头放入插线板。不需要可以轻易的移除。

Spring的两个主要思想：IOC控制反转、AOP面向切面编程

二.控制反转

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。
IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。
什么是依赖
依赖：classA 类中含有 classB 的实例，在 classA 中调用 classB 的方法完成功能，即 classA对 classB 有依赖。
Ioc 的实现：
依赖注入：DI(Dependency Injection)，程序代码不做定位查询，这些工作由容器自行完成。
依赖注入 DI 是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。
Spring 的依赖注入对调用者与被调用者几乎没有任何要求，完全支持对象之间依赖关系的管理。
spring是一个容器，管理对象，给属性赋值， 底层是反射创建对象。
Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象，这些 Java 对象被称为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用“依赖注入”的方式来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦和。

Spring第一个项目

1.创建一个Maven项目

以上的可以点击使用项目模板，但是在我的idea中，点击了项目模板就会隐藏掉java和test这两个文件夹。

2.引入Maven依赖到pom.xml

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
 <dependencies>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--spring依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  </dependencies>
	 <!--插件-->
	 <build>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

3.定义接口和实现类

//接口
public interface SomeService {
    void doSome();
}
//实现类
public class SomeServiceImpl implements SomeService {
    public SomeServiceImpl() {
        System.out.println("SomeServiceImpl的无参数构造方法");
    }

    @Override
    public void doSome() {
        System.out.println("执行了SomeServiceImpl的doSome()方法");
    }
}

4.创建 Spring 配置文件
在 src/main/resources/目录现创建一个 .xml 文件，文件名可以随意，但 Spring 建议的名称为 applicationContext.xml。
spring 配置中需要加入约束文件才能正常使用，约束文件是 xsd 扩展名。

<?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标签：一个bean标签表示一个对象-->
  	   <!--如果需要创建多个对象，就要多个bean标签-->
       <bean id="someService"class="com.bjpowernode.service.impl.SomeServiceImpl" />

</beans>

id：该属性是 Bean 实例的唯一标识，程序通过 id 属性访问 Bean，Bean 与 Bean 间的依赖关系也是通过 id 属性关联的。
class：指定该 Bean 所属的类，注意这里只能是类，不能是接口。

5.定义测试类
在 src/test/java/创建的类

public class Mytest{
   @Test
    public void test(){
    
       //1.指定spring配置文件的名称
       String config="applicationContext.xml";
       
       //2.创建表示spring容器的对象， ApplicationContext
       // ApplicationContext就是表示Spring容器，通过容器获取对象了
       // ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件
       ApplicationContext ac = new ClassPathXmlApplicationContext(config);

       //3.从容器中获取某个对象， 你要调用对象的方法
       //getBean("配置文件中的bean的id值")
       SomeService service = (SomeService) ac.getBean("someService");

       //4.使用spring创建好的对象,并调用方法
       service.doSome();
   }
}

点击Test运行可以得到以上的输出，说明项目没问题。
以上完成了Spring第一个项目，了解到Spring中的IOC控制反转，以及使用Spring容器创建对象。

附加：
测试的时候为什么不适用main方法，因为使用main方法不方标测试，每当我们完成一个功能，可以使用单元测试更为方便。
@Test:
1.必须要在src/test/下才能生效，
2.需要加入在pom.xml中加入junit依赖。

	  <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

junit : 单元测试， 一个工具类库，做测试方法使用的。
单元：指定的是方法， 一个类中有很多方法，一个方法称为单元。

Yeaterday is history ,tomorrow is a mystery.But today is a gift.
昨日已成往事，未来还未可知，但是今天是上天的馈赠。