Spring介绍入门及ioc使用

夜雨微澜°

已于 2022-04-17 20:05:16 修改

阅读量184

点赞数 1

分类专栏： Spring 文章标签： spring

于 2022-03-23 01:58:34 首次发布

本文链接：https://blog.csdn.net/weixin_57504000/article/details/123675562

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1，Spring是什么

Spring是一个轻量级开源框架，以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，最为典型的当属数据库事务的使用，还能整合开源世界众多著名的第三方框架和类库，应该说Spring框架已经融入到了Java EE的各个开发领域。总而言之，Spring的核心是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架

2，Spring的优势

2.1，简化开发

Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 容器管理，降低了组件之间的耦合性。

2.2，声明式事务的支持

只需要通过配置就可以完成对事物的管理，而无须手动编程，提高开发效率和质量。

2.3，集成各种优秀框架

Spring接受各种开源框架，其内部提供了对各种优秀框架的直接支持。

2.4，AOP 编程的支持

Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

3，Spring下载

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

4，Spring环境搭建

4.1，新建普通Maven项目

建好之后命名Spring01就可以了，看一下项目结构：
项目结构图

4.2，导入相关依赖

这里面包括Spring的核心包

<?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.zking</groupId>
  <artifactId>spring01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring01 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.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>

    <!--junit-->
    <junit.version>4.13</junit.version>

    <!--servlet-->
    <servlet.version>4.0.1</servlet.version>

    <!--spring-->
    <spring.version>5.0.1.RELEASE</spring.version>
  </properties>

  <dependencies>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>

    <!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <scope>provided</scope>
    </dependency>

    <!--spring-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

  </dependencies>

  <build>
    <finalName>spring01</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>${maven.compiler.source}</source>
          <target>${maven.compiler.target}</target>
          <encoding>${project.build.sourceEncoding}</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

4.3,修改web.xml中的版本为3.0

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xmlns="http://java.sun.com/xml/ns/javaee" 
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">


</web-app>

4.4，我们新建一个Hello类

在Java文件夹下新建类命名为com.zking.spring01.entity.Hello；

package com.zking.spring01.entity;

import java.io.Serializable;

public class Hello implements Serializable {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {

        this.name = name;
    }

    public Hello(){
        System.out.println("这是无参的");
    }

    public void init(){
        System.out.println("正在初始化hello中的init方法");
    }

    public Hello(String name){
        System.out.println("这是有参的");
        this.name = name;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

然后我们就可以让Spring来管理这个类的实例，通过配置文件spring.xml，Spring可以很轻松地做到。

4.5，Spring配置文件

我们在resources文件夹下新建一个配置文件spring.xml；

<?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">
    <!--通过id来直接管理Hello的实例对象-->
    <bean id="hello" name="a b c" class="com.zking.spring01.entity.Hello" scope="prototype" init-method="init">
        <property name="name">
            <value>李四</value>
        </property>
    </bean>
</beans>

4.6，通过Spring来获取类的对象

我们新建一个案例类命名为com.zking.spring01.util.Demo；

package com.zking.spring01.util;

import com.zking.spring01.entity.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    public static void main(String[] args) {
        //1.什么是spring
        //Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架
        //核心概念:
        //控制反转 IOC：控制权由应用代码中转到了外部容器
        //依赖注入 DI：由容器动态的将某种依赖关系注入到组件之中
        //示例：biz层依赖dao接口
        //作用：用于管理各种各样的JavaBean对象

        //理解：将以前由程序员实例化对象/赋值的工作交给了spring处理

        //示例1：传统方式与spring方式的区别
        /*Hello hello=new Hello();
        hello.setName("张三");
        System.out.println(hello);*/

        //初始化spring上下文（context）,ioc:用于管理各种各样的JavaBean对象的容器框架
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        Hello hello = ac.getBean("hello", Hello.class);
        System.out.println(hello.getName());
    }
 
}

配置读取文件的读取方式

1.读取加载单个文件

ApplicationContext ac=new ClassPathXmlApplicationContext("配置文件名");
2.读取加载多个文件

ApplicationContext ac=new ClassPathXmlApplicationContext(new String[]{"配置文件名1","配置文件名2"});
3.通配方式

ApplicationContext ac=new ClassPathXmlApplicationContext("spring-*.xml");

注：读取所有spring-的配置文件,不能单独*.xml,必须有文件格式

运行结果：

5，深入理解IoC

IoC（控制反转：Inverse of Control），又称作依赖注入，是一种重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。

5.1，先来看几个关键问题

什么是Spring中的bean？

Spring里面的bean就类似是定义的一个组件，而这个组件的作用就是实现某个功能的，这里所定义的bean就相当于给了你一个更为简便的方法来调用这个组件去实现你要完成的功能。

什么是控制反转？

控制：是容器对bean进行创建、管理。控制bean的整个生命周期。

反转：我们是被动接受Spring容器创建的对象，而不是自己主动去控制。

什么是依赖注入？

DI—Dependency Injection，即依赖注入；

依赖：应用程序依赖IoC容器，在程序运行的时候，应用程序需要IoC容器来提供对象需要的外部资源；

注入：IoC容器注入应用程序的某个对象，注入了其所需要的的外部资源（对象、资源和数据等）；

所以说控制反转是通过依赖注入实现的，其实它们是同一个概念的不同角度描述。通俗来说就是IoC是设计思想，DI是实现方式。

作用: 将以前由程序员实例化对象/赋值的工作交给了spring处理

5.2，IoC配置文件详解

id：在容器中查找Bean的id(唯一、且不能以/开头)
class：bean的完整类名
name：在容器中查找Bean的名字(唯一、允许以/开头、允许多个值，多个值之间用逗号或空格隔开)
scope:(singleton|prototype)默认是singleton
- singleton(单例模式)：在每个Spring IoC容器中一个bean定义对应一个对象实例
- prototype(原型模式/多例模式)：一个bean定义对应多个对象实例
abstract：将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean
parent：指定一个父bean(必须要有继承关系才行)
init-method：指定bean的初始化方法
constructor-arg：使用有参数构造方法创建javaBean

5.3，日期格式注入：

spring.xml

Demo.java

5.4，复杂属性注入

数组

list

Map

Properties

5.5，spring与web项目的集成

WEB项目如何读取spring上下文
通过监听器实现ServletContextListener
contextConfigLocation:classpath:applicationContext-*.xml

<context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
</context-param>

<listener>
            <listener-class>com.zking.spring01.util.SpringListener</listener-class>
</listener>

小结

我们再来总结一下Spring创建对象的过程：

首先通过ApplicationContext这个IoC容器的入口，用它的子类ClassPathXmlApplicationContext从class path中加载配置文件，读取数据，再用getBean()方法获取具体的Bean实例。Spring框架会为我们创建对象，交给IoC容器管理，这个过程就降低了耦合度。

夜雨微澜°

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring介绍入门及ioc使用

1，Spring是什么Spring是一个轻量级开源框架，以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，最为典型的当属数据库事务的使用，还能整合开源世界众多著名的第三方框架和类库，应该说Spring框架已经融入到了Java EE的各个开发领域。总而言之，Spring的核心是一个轻量级的控制反转
复制链接

扫一扫