Spring的第一个程序

目录
  • 一、Spring概述

    • 1. Spring是什么?
    • 2. IOC控制反转
  • 二、Spring的第一个程序

    • 1. 创建Maven项目
    • 2. 加入maven依赖pom.xml
    • 3. 定义接口和实体类
    • 4. 创建Spring的配置文件
    • 5. 定义测试类
    • 6. 使用spring创建非自定义类对象
    • 7. 获取spring容器中java对象的信息
  • 三、使用Spring框架的步骤
  • 四、总结

    • 1. 什么是spring
    • 2. 怎么使用spring
    • 3. 什么样的对象放入容器中
    • 4. 不放入spring容器中的对象

一、Spring概述

1. Spring是什么?

Spring 的主要作用就是为代码“解耦”,降低代码间的耦合度。就是让对象和对象(模块和模块)之间关系不是使用代码关联,而是通过配置来说明。即在 Spring 中说明对象(模块)的关系

Spring 根据代码的功能特点,使用 IOC 降低业务对象之间耦合度。IOC 使得主业务在相互调用过程中,不用再自己维护关系了,即不用再自己创建要使用的对象了。而是由 Spring容器统一管理,自动“注入”,注入即赋值。 而 AOP 使得系统级服务得到了最大复用,且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了,而是由 Spring 容器统一完成“织入”

spring全家桶:

spring , springmvc ,spring boot , spring cloud

spring: 出现是在2002左右,解决企业开发的难度。减轻对项目模块之间的管理,类和类之间的管理, 帮助开发人员创建对象,管理对象之间的关系。
spring核心技术 ioc(控制反转) , aop(面向切面编程) 。能实现模块之间,类之间的解耦合。

2. IOC控制反转

控制反转(IOC,Inversion of Control),是一个概念,是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器,通过容器来实现对象的装配和管理,控制反转就是对对象控制权的转移,从程序代码本身反转到了外部容器。

通过容器实现对象的创建,属性赋值,依赖的管理。

IoC 是一个概念,是一种思想,其实现方式多种多样。当前比较流行的实现方式是依赖注入

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

IOC的实现:

依赖注入:DI(Dependency Injection),程序代码不做定位查询,这些工作由容器自行完成

依赖注入 DI 是指程序运行过程中,若需要调用另一个对象协助时,无须在代码中创建被调用者,而是依赖于外部容器,由外部容器创建后传递给程序

Spring 框架使用依赖注入(DI )实现 IOC

Spring 容器是一个超级大工厂,负责创建、管理所有的 Java 对象,这些 Java 对象被称为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系,Spring 使用“依赖注入”的方式来管理 Bean 之间的依赖关系。使用 IOC 实现对象之间的解耦和

二、Spring的第一个程序

1. 创建Maven项目

Spring的第一个程序插图

下面的直接下一步就可以了,具体的看之前写的关于Maven的操作

创建成功的如下:

Spring的第一个程序插图(1)

2. 加入maven依赖pom.xml

<?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.md</groupId>
  <artifactId>01-hello-spring</artifactId>
  <version>1.0-SNAPSHOT</version>



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

  </build>
</project>

3. 定义接口和实体类

package com.md.service;

/**
 * @author MD
 * @create 2020-08-07 17:32
 */
public interface SomeService {
    void doSome();
}

//-----------------------------------------
package com.md.service.impl;
import com.md.service.SomeService;
/**
 * @author MD
 * @create 2020-08-07 17:33
 */
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的第一个程序插图(2)

具体的解释看代码中的注释

<?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的配置文件
        1. beans:根标签,spring把java对象成为bean
        2. spring-beans.xsd是约束文件,和mybatis的dtd类
    -->

    <!--
        spring在创建对象的时候,声明bean,就是告诉spring要创建某个类的对象
        id: 这个对象自定义名称,唯一,spring通过这个id能找到对象
        class:类的全限定名称(不能是接口的,因为spring是反射机制创造对象的)

        spring就完成这样的工作   SomeService someService = new SomeServiceImpl();

        spring是把创建好的对象放入到map中,spring框架中有一个map存放对象
        spring.put(id值,对象)
        例:springMap.put("someService",new SomeServiceImpl());

        一个 bean 标签声明一个对象
    -->

    <bean id="someService" class="com.md.service.impl.SomeServiceImpl" />

</beans>
  1. spring在创建对象的时候,声明bean,就是告诉spring要创建某个类的对象
  2. id: 这个对象自定义名称,唯一,spring通过这个id能找到对象
  3. class:类的全限定名称(不能是接口的,因为spring是反射机制创造对象的)

5. 定义测试类

spring默认创建对象的时间:在创建spring的容器时,就创建配置文件中的<所有对象>

spring创建对象,默认调用的是无参的构造方法

   @Test
    public void test02(){
        // 使用spring容器创建对象,spring配置文件在类路径下
        // 1. 指定spring配置文件名称
        String config = "beans.xml";

        //2. 表示创建spring容器的对象, ApplicationContext
        // ApplicationContext就是表示Spring容器,通过容器获取对象了
        // ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件,
        // 如图所示,得把beans.xml放到编译好的target下面的classes中
        // 若自动放的话这里就不用放了,如果出现找不到这个文件的时候手动放就行了
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        System.out.println("------------------");

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

        // 4. 使用spring创建好的对象来调用方法
        someService.doSome();



//        我是SomeServiceImpl的无参构造方法
//                ------------------
//        执行了SomeServiceImpl的doSome()方法

    }


当运行报错找不到beans.xml文件的时候,手动复制一个就可以了

Spring的第一个程序插图(3)

6. 使用spring创建非自定义类对象

在Spring的配置文件beans.xml中添加

 <!--
        spring能创建一个非自定义类的对象吗?创建一个已经存在的类的对象
    -->

    <bean id="mydate" class="java.util.Date" />

在测试类

 /**
     * 获取一个非自定义的类的对象
     */
    @Test
    public void test04(){
        String config = "beans.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        // 获取对象
        Date d = (Date) ac.getBean("mydate");
        System.out.println(d);
    }

7. 获取spring容器中java对象的信息

   @Test
    public void test03(){

        String config = "beans.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        // 使用spring提供的方法,获取容器中定义的对象的数量
        int count = ac.getBeanDefinitionCount();
        System.out.println(count);

        // 容器中定义的每个对象的名称
        String[] names = ac.getBeanDefinitionNames();

        for (String name : names) {
            System.out.println(name);
        }

    }

三、使用Spring框架的步骤

  1. 加入依赖
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  1. 创建类:接口、实现类、或者没有接口的类
  2. 创建spring的配置文件,使用<bean>标签声明对象
 <bean id="someService" class="com.md.service.impl.SomeServiceImpl" />
  1. 我们使用容器中的对象,通过ApplicationContext接口和它的实现类ClassPathXmlApplicationContext的方法getBean(“要使用的id”)

四、总结

1. 什么是spring

  1. 是一个框架,核心技术是ioc、aop,实现解耦合
  2. spring是一个容器,容器中存放的是java对象,需要做的是把对象放入到容器中

2. 怎么使用spring

  1. spring是一个容器,把项目中用的对象放入到容器中
  2. 让容器完成对象的创建、对象之间的关系的管理也就是属性的赋值
  3. 我们在程序中从容器中获取到想使用的对象

3. 什么样的对象放入容器中

  1. dao类、service类、controller类、工具类
  2. spring中对象默认都是单例,在容器中这个对象只有一个

4. 不放入spring容器中的对象

  1. 实体类对象,实体类的数据是来自数据库的
  2. servlet、listener、filter等(这几个是来自Tomcat的)
本站资源均源自网络,若涉及您的版权、知识产权或其他利益,请附上版权证明邮件告知。收到您的邮件后,我们将在72小时内删除。
若下载资源地址错误或链接跳转错误请联系站长。站长q:770044133。

» Spring的第一个程序

发表评论

免登录下载网,提供全网最优质的资源集合!