Java--Spring入门

一、Spring简介

（一）简介

Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的

Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。Spring 是可以在 Java SE/EE 中使用的轻量级开源框架

简而言之：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架

Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度

Spring官网：https://spring.io/ 

（二）Spring体系结构

 1、Data Access/Integration（数据访问／集成）

数据访问／集成层包括 JDBC、ORM、OXM、JMS 和 Transactions 模块

• JDBC 模块：提供了一个 JBDC 的样例模板，使用这些模板能消除传统冗长的 JDBC 编码还有必须的事务控制，而且能享受到 Spring 管理事务的好处。
• ORM 模块：提供与流行的“对象-关系”映射框架无缝集成的 API，包括 JPA、JDO、Hibernate 和 MyBatis 等。而且还可以使用 Spring 事务管理，无需额外控制事务。
• OXM 模块：提供了一个支持 Object /XML 映射的抽象层实现，如 JAXB、Castor、XMLBeans、JiBX 和 XStream。将 Java 对象映射成 XML 数据，或者将XML 数据映射成 Java 对象。
• JMS 模块：指 Java 消息服务，提供一套 “消息生产者、消息消费者”模板用于更加简单的使用 JMS，JMS 用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。
• Transactions 事务模块：支持编程和声明式事务管理。

2、Web 模块

Spring 的 Web 层包括 Web、Servlet、WebSocket 和 Portlet 组件

• Web 模块：提供了基本的 Web 开发集成特性，例如多文件上传功能、使用的 Servlet 监听器的 IOC 容器初始化以及 Web 应用上下文。
• Servlet 模块：提供了一个 Spring MVC Web 框架实现。Spring MVC 框架提供了基于注解的请求资源注入、更简单的数据绑定、数据验证等及一套非常易用的 JSP 标签，完全无缝与 Spring 其他技术协作。
• WebSocket 模块：提供了简单的接口，用户只要实现响应的接口就可以快速的搭建 WebSocket Server，从而实现双向通讯。
• Portlet 模块：提供了在 Portlet 环境中使用 MVC 实现，类似 Web-Servlet 模块的功能。

3、Core Container（Spring 的核心容器）

Spring 的核心容器是其他模块建立的基础，由 Beans 模块、Core 核心模块、Context 上下文模块和 SpEL 表达式语言模块组成，没有这些核心容器，也不可能有 AOP、Web 等上层的功能

• Beans 模块：提供了框架的基础部分，包括控制反转和依赖注入。
• Core 核心模块：封装了 Spring 框架的底层部分，包括资源访问、类型转换及一些常用工具类。
• Context 上下文模块：建立在 Core 和 Beans 模块的基础之上，集成 Beans 模块功能并添加资源绑定、数据验证、国际化、Java EE 支持、容器生命周期、事件传播等。ApplicationContext 接口是上下文模块的焦点。
• SpEL 模块：提供了强大的表达式语言支持，支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器，命名变量，支持算数和逻辑运算，支持从 Spring 容器获取 Bean，它也支持列表投影、选择和一般的列表聚合等。

4、AOP、Aspects、Instrumentation 和 Messaging

在 Core Container 之上是 AOP、Aspects 等模块

• AOP 模块：提供了面向切面编程实现，提供比如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态的把这些功能添加到需要的代码中，这样各司其职，降低业务逻辑和通用功能的耦合。
• Aspects 模块：提供与 AspectJ 的集成，是一个功能强大且成熟的面向切面编程（AOP）框架。
• Instrumentation 模块：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
• messaging 模块：Spring 4.0 以后新增了消息（Spring-messaging）模块，该模块提供了对消息传递体系结构和协议的支持。

5、Test 模块

Test 模块：Spring 支持 Junit 和 TestNG 测试框架，而且还额外提供了一些基于 Spring 的测试功能，比如在测试 Web 框架时，模拟 Http 请求的功能

（三）spring框架优点

1、轻量

Spring 框架使用的 jar 比较小，一般在 1M 以下或者几百 kb；Spring 核心功能的所需的 jar 总共在 3M 左右。 Spring 框架运行占用的资源少，运行效率高。不依赖其他 jar

2、 针对接口编程，解耦合

Spring 提供了 Ioc 控制反转，由容器管理对象，对象的依赖关系

3、AOP 编程的支持

4、方便集成各种优秀框架

Spring提供了对各种优秀框架（如 Struts,Hibernate、MyBatis）等的直接支持；简化框架的使用

二、Spring入门

首先来介绍一下spring的第一个核心概念：控制反转（Inversion of Control，缩写IoC）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。

依赖：classA 类中含有 classB 的实例，在 classA 中调用 classB 的方法完成功能，即 classA 对 classB 有依赖

Ioc 的实现：

1、依赖注入（Dependency Injection，简称DI）：组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系

容器全权负责的组件的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。

（1）设值注入(Setter Injection)：通过JavaBean属性注射依赖关系的做法称为设值方法注入

（2）构造注入（Constructor Injection）： 将依赖关系作为构造函数参数传入的做法称为构造器注入

2、依赖查找（Dependency Lookup）：容器提供回调接口和上下文条件给组件

Spring 框架使用依赖注入（DI）实现 IoC

Spring 容器负责创建、管理所有的 Java 对象，这些 Java 对象被称为 Bean

Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用“依赖注入”（DI）的方式来管理 Bean之间的依赖关系。使用 IoC 实现对象之间的解耦和

接下来以IoC方式创建一个入门spring工程

首先我们先设置一下maven的本地仓库

1、创建一个普通Java的maven工程

2、在 pom.xml 文件中加入maven需要的spring依赖

<properties>
    <!-- 项目构建使用的编码，避免中文乱码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 源码编译 jdk 版本 -->
    <maven.compiler.source>1.8</maven.compiler.source>
    <!-- 运行代码的 jdk 版本 -->
    <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>

3、创建Java类

/**
 Alt + Enter 可快速给接口类生成实现类
 Ctrl + H 快捷键查看接口的实现类
 * */
public interface DoSomeService {
    void doSome();
}



public class DoSomeServiceImpl implements DoSomeService {

    public DoSomeServiceImpl(){
        System.out.println("DoSomeServiceImpl无参构造方法");
    }

    @Override
    public void doSome() {
        System.out.println("DoSomeServiceImpl的doSome()方法");
    }
}

 4、创建spring需要使用的配置文件

在 src/main/resources/目录下创建一个 xml 文件，文件名可自定义；但 Spring 建议的名称为 applicationContext.xml

在加入spring的依赖之后，要创建spring的配置文件即可

（1）右击 resources ，Alt+Insert，输入xml，选择 Spring Config

（2）或者右击resources，选择Spring Config

 一般来说在 pom.xml 文件中加入了spring的依赖，刷新一下即可出现Spring Config选项，如果没出现

打开设置settings->插件plugins看看有没有开启Spring 如果没有则开启并重启IDEA

右击项目，添加框架支持

实在还是没有，就放大招，右击File----> Invalidate Caches...

 

 5、applicationContext.xml 文件配置

如下内容：

spring的配置文件

beans：根标签

spring-beans.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">

    <!-- spring的配置文件
        beans：根标签
        spring-beans.xsd：约束文件
    -->

</beans>

 <bean /> 标签

定义一个实例对象；一个实例对应一个 bean元素

id：对象的自定义名称（id值唯一标识）；spring通过这个值找到自定义对象；Bean 与 Bean 间的依 赖关系也是通过 id 属性关联的

class：Java类对象的全限定名称（不能为接口，spring利用反射机制创建对象，必须使用类）

注：

一个bean标签只能声明一个对象

<?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">

    <!-- spring的配置文件
        beans：根标签
        spring-beans.xsd：约束文件
    -->

    <!-- <bean /> 标签
        定义一个实例对象；一个实例对应一个 bean元素
        id：对象的自定义名称（id值唯一标识）；spring通过这个值找到自定义对象；Bean 与 Bean 间的依
            赖关系也是通过 id 属性关联的
        class：Java类对象的全限定名称（不能为接口，spring利用反射机制创建对象，必须使用类）
        一个bean标签只能声明一个对象

        spring完成如下代码：
        DoSomeService doSomeService = new DoSomeServiceImpl();
        spring将创建好的Java对象放入到map中；springMap.put(id的值， 对象）
        如：springMap.put("doSomeService", new DoSomeServiceImpl());
    -->
    <bean id="doSomeService" class="com.mycompany.service.impl.DoSomeServiceImpl" />
    <bean id="doSomeService1" class="com.mycompany.service.impl.DoSomeServiceImpl" />

    <!--
        spring还能创建一个非自定义类的Java对象
    -->
    <bean id="date" class="java.util.Date" />

</beans>

6、测试类测试

public class TestSpring {

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

        使用单元测试
        （1）需要加入junit依赖
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
                <scope>test</scope>
            </dependency>
        （2）创建测试类
            src/test/java目录中创建类
        （3）创建测试方法
            【1】public 方法
            【2】没有返回值 void
            【3】方法名称自定义，建议名称是test + 测试方法名称
            【4】方法没有参数
            【5】方法的上面加入 @Test ，方法可以单独执行；不用使用main方法
    */
    @Test
    public void testNewJavaObject(){
        DoSomeService doSomeService = new DoSomeServiceImpl();
        doSomeService.doSome();
    }

    /**
     * 在创建spring容器时，默认会创建配置文件中的所有Java对象
     * spring创建Java对象时，默认调用无参构造方法
     */
    @Test
    public void testSpringNewJavaObject(){
        //1、指定spring配置文件（类路径中）
        String config = "applicationContext.xml";
        /*
        2、创建spring容器类，即ApplicationContext
            ApplicationContext：表示spring容器，通过容器获取对象
            ClassPathXmlApplicationContext：从类路径中加载spring的配置文件
        */
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //3、从容器中获取对象；getBean()方法；getBean("配置文件中的bean的id值")
        DoSomeService doSomeService = (DoSomeService) ac.getBean("doSomeService");
        doSomeService.doSome();
    }

    /**
     * 获取spring容器中 java 对象的信息
     */
    @Test
    public void testObjectInformation(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //getBeanDefinitionCount()方法 获取容器中定义的对象的数量
        int nums = ac.getBeanDefinitionCount();
        System.out.println("容器中对象数量：" + nums);

        //getBeanDefinitionNames() 获取容器中每个定义的对象的名称
        String objectNames[] = ac.getBeanDefinitionNames();
        for (String name:objectNames) {
            System.out.println("容器中对象名称：" + name);
        }
    }

    /**
     * 获取一个非自定义的类对象
     */
    @Test
    public void testNonCustomObject(){
        //spring配置文件（类路径中）
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        Date date = (Date) ac.getBean("date");
        System.out.println("日期时间："+date);
    }
}

（1）spring配置文件从类路径中加载

（2）在创建spring容器时，默认会创建配置文件中的所有Java对象

（3）spring创建Java对象时，默认调用无参构造方法

 （4）spring也可获取非自定义对象

ApplicationContext 用于加载 Spring 的配置文件，在程序中充当“容器”，使用 ClassPathXmlApplicationContext在类路径中加载

ApplicationContext 容器，会在容器对象初始化时，将其中的所有对象一次性全部装配好。 以后代码中若要使用到这些对象，只需从内存中直接获取即可。执行效率较高。但占用内存

//1、指定spring配置文件（类路径中）
        String config = "applicationContext.xml";
        /*
        2、创建spring容器类，即ApplicationContext
            ApplicationContext：表示spring容器，通过容器获取对象
            ClassPathXmlApplicationContext：从类路径中加载spring的配置文件
        */
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //3、从容器中获取对象；getBean()方法；getBean("配置文件中的bean的id值")
        DoSomeService doSomeService = (DoSomeService) ac.getBean("doSomeService");
        doSomeService.doSome();

 junit : 单元测试

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

使用单元测试

（1）需要加入junit依赖

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

（2）创建测试类

src/test/java目录中创建类

（3）创建测试方法

【1】public 方法

【2】没有返回值 void 

【3】方法名称自定义，建议名称是test + 测试方法名称

【4】方法没有参数

【5】方法的上面加入 @Test ，方法可以单独执行；不用使用main方法