Java--Spring入门

阳光穿透心脏的1/2处 2023-10-01 17:41 4阅读 0赞

### 一、Spring简介 ###

#### （一）简介 ####

> Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的
> 
> Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。Spring 是可以在 Java SE/EE 中使用的轻量级开源框架
> 
> 简而言之：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架
> 
> Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度

Spring官网：[https://spring.io/][https_spring.io]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16][]

#### （二）Spring体系结构 ####

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_12_color_FFFFFF_t_70_g_se_x_16][]

#### 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**），是[面向对象编程][Link 1]中的一种设计原则，可以用来减低计算机[代码][Link 2]之间的[耦合度][Link 3]。

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

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

Ioc 的实现：

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

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

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

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

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

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

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

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

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

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

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

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

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

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

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

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

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg_size_16_color_FFFFFF_t_70][]

右击项目，添加框架支持

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_10_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg_size_16_color_FFFFFF_t_70 1][]

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

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_7_color_FFFFFF_t_70_g_se_x_16][]

5、**applicationContext.xml** 文件配置

如下内容：

spring的配置文件

**beans**：根标签

**spring-beans.xsd**：约束文件

**<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">
    
        
    
        
        <bean id="doSomeService" class="com.mycompany.service.impl.DoSomeServiceImpl" />
        <bean id="doSomeService1" class="com.mycompany.service.impl.DoSomeServiceImpl" />
    
        
        <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对象时，默认调用无参构造方法

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_16_color_FFFFFF_t_70_g_se_x_16][]

（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方法

[https_spring.io]: https://spring.io/
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/01b9a2483ce94e44bcf2c0862b972b30.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_12_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/ca144fe5430e40df865c66bab5f0e38d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_12,color_FFFFFF,t_70,g_se,x_16
[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%BC%96%E7%A8%8B/254878
[Link 2]: https://baike.baidu.com/item/%E4%BB%A3%E7%A0%81/86048
[Link 3]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6/2603938
[Link 4]: https://baike.baidu.com/item/%E4%BE%9D%E8%B5%96%E6%B3%A8%E5%85%A5/5177233
[Link 5]: https://baike.baidu.com/item/%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0
[Link 6]: https://baike.baidu.com/item/%E6%9E%84%E9%80%A0%E5%99%A8
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/93e5c391b8304f2e935d32761d6a1b0d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/ea50ed125ff0474c97c4e2813e5a18ec.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202012192228235.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_10_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/547c02103e224a42997caa98cabd92e0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_10,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201219224354949.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poczI2MDEzMzE3Mg==,size_16,color_FFFFFF,t_70
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_7_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/495001b8aa48416bbb4076d266b9dadc.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_7,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBATWluZ2dlUWluZ2NodW4_size_16_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/71bcbea9788145959d8f7d70d95d2ca0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBATWluZ2dlUWluZ2NodW4=,size_16,color_FFFFFF,t_70,g_se,x_16