15、Spring框架

新新程序名媛

已于 2023-06-02 16:49:01 修改

阅读量659

点赞数

分类专栏： Java-EE 文章标签： spring java spring boot

于 2023-06-02 16:45:25 首次发布

本文链接：https://blog.csdn.net/ezzbb/article/details/131005045

版权

Java-EE 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

Spring是一个分层的Java全栈轻量级开源框架，基于IoC和AOP理念。文章介绍了Spring的体系结构、新特性，以及如何创建Maven项目，设置XML配置文件进行依赖注入。通过构造方法和setter方法展示了两种注入方式，并提供了一个简单的登录验证应用示例。

摘要由CSDN通过智能技术生成

新建applicationContext.xml文件

Spring官网：Spring | Home

什么是Spring

Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；AOP是Spring 的重要特性，AOP是通过预编译方式和运行期间动态代理实现程序功能，也就是说可以在不修改源代码的情况下，给程序统一添加功能。

Spring优点

非侵入式设计
降低耦合性
支持AOP编程
支持声明式事务
方便程序的测试
方便集成框架
降低Java EE API的使用难度

Spring体系结构

Spring新特性

更新JDK基线
修订核心框架
更新核心容器
支持响应式编程
支持函数式Web框架
支持Kotlin
提升测试功能

Spring的入门程序

新建立Maven项目

Spring四个基础包以及Spring依赖包

（1）spring-core-5.3.25.jar

（2）spring-beans-5.3.25.jar

（3）spring-context-5.3.25.jar

（4）spring-expression-5.3.6. jar

（5）commons-logging-1.2.jar

创建名为HelloSpring的类

package com.itheima;
public class HelloSpring {
    private String userName;
    public void setUserName(String userName){
        this.userName=userName;	}
    public void show() { 
        System.out.println(userName+":欢迎来到Spring");	}
}

新建applicationContext.xml文件

<!-- 将指定类配置给Spring，让Spring创建HelloSpring
	对象的实例 -->
<bean id="helloSpring" class="com.itheima.HelloSpring">
        <!--为userName属性赋值-->
        <property name="userName" value="张">
        </property>
</bean>

XML文件的约束信息配置

XML文件包含了很多约束信息，如果自己动手去编写，不但浪费时间，还容易出错。XML的约束信息如下所示。

<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的帮助文档中，就可以找到这些约束信息。

测试类TestHelloSpring

public class TestHelloSpring {
    public static void main(String[] args){
        // 初始化spring容器，加载applicationContext.xml配置
        ApplicationContext applicationContext=new 
    ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过容器获取配置中helloSpring的实例
        HelloSpring helloSpring=
        (HelloSpring)applicationContext.getBean("helloSpring");
        helloSpring.show();// 调用方法	}
}

控制反转

IoC控制反转机制指的是对象由Ioc容器统一管理，当程序需要使用对象时，可以直接从IoC容器中获取。这样对象的控制权就从应用程序转移到了IoC容器。IoC设计原则如图，它是借助于IoC容器实现具有依赖关系对象之间的解耦，各个对象类封装之后，通过IoC容器来关联这些对象类。

依赖注入

依赖注入（Dependency Inject，缩写DI）就是由IoC容器在运行期间动态地将某种依赖资源注入对象之中。例如，将对象B注入（赋值）给对象A的成员变量。依赖注入的基本思想是：明确地定义组件接口，独立开发各个组件，然后根据组件的依赖关系组装运行。

依赖注入和控制反转的比较

依赖注入（DI）和控制反转（IoC）是从不同角度来描述了同一件事情。依赖注入是从应用程序的角度描述，即应用程序依赖IoC容器创建并注入它所需要的外部资源；而控制反转是从IoC容器的角度描述，即IoC容器控制应用程序，由IoC容器反向地向应用程序注入应用程序所需要的外部资源。这里所说的外部资源可以是外部实例对象，也可以是外部文件对象等

依赖注入的类型

依赖注入的实现方式

(1)构造方法注入

构造方法注入是指Spring容器调用构造方法注入被依赖的实例，构造方法可以是有参的或者是无参的。Spring在读取配置信息后，会通过反射方式调用实例的构造方法，如果是有参构造方法，可以在构造方法中传入所需的参数值，最后创建类对象。

(2)setter方法注入

属性setter方法注入是Spring最主流的注入方法，这种注入方法简单、直观，它是在被注入的类中声明一个setter方法，通过setter方法的参数注入对应的值。

构造方法注入

新建User1类

public class User1 {
  private int id;   private String name;   private String password;
  public User1(int id, String name, String password){
      this.id=id;	
 this.name=name;
      this.password=password; 
}
  public String toString(){
   return "id="+id+",name="+name+",password="+password;
  }
}

获取Bean的配置信息

在applicationContext-User.xml文件添加User1类的配置信息。

<bean id="user1" class="com.itheima.User1">
        <constructor-arg name="id" value="1">
        </constructor-arg>
        <constructor-arg name="name" value="张三">
        </constructor-arg>
        <constructor-arg name="password" 	value="123"></constructor-arg>
</bean>

setter方法注入

新建User2类

public class User2 {
    private int id;	private String name;	
    private String password;
    // 省略getter/setter方法
    public String toString(){
  return "id="+id+",name="+name+",password="+password;
    }
}

获取Bean的配置信息

<bean id="user2" class="com.itheima.User2">
    <property name="id" value="2"></property>
    <property name="name" value="李四"></property>
    <property name="password" value="456"></property>
</bean>

测试类

public class TestUser2 {
    public static void main(String[] args)throws Exception {
        //加载applicationContext.xml配置
        ApplicationContext applicationContext = new 
        ClassPathXmlApplicationContext("applicationContext-User2.xml");
        //获取配置中的User2实例
        User2 user2 = applicationContext.getBean("user2", User2.class);
        System.out.println(user2);
}}

依赖注入的应用

下面以属性setter方法注入为例，实现一个简单的登录验证。具体实现步骤如下所示。

（1）编写DAO层

public interface UserDao {
           public boolean login(String name,String password);
}
public class UserDaoImpl implements UserDao {
           ........
 }

（2）编写Service层

public interface UserService {
    public boolean login(String name,String password);
}

public class UserServiceImpl implements UserService {
    UserDao userDao;
    public void setUserDao(UserDaouserDao)
        { this.userDao=userDao; }
    @Override
    public boolean login(String name, String password) {
        return userDao.login(name,password);
    }
}

（3）编写applicationContext.xml配置文件

<bean id="userDao"class="....UserDaoImpl"></bean>

<bean id="userService”class="...UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>

（4）编写测试类

public class TestSpring {
    public static void main(String[] args) {
         ApplicationContext applicationContext=new 
        ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService=(UserService) applicationContext.getBean("userService");
        boolean flag =userService.login("张三","123");
        if (flag) { System.out.println("登录成功");
        } else { System.out.println(“登录失败"); }
}}

=========================================================================

实验：lab13

需要的依赖：

这个依赖包含四个基础依赖（直接添加这即可）    
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

<!--        &lt;!&ndash;Spring的基础包Spring-core&ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>org.springframework</groupId>-->
<!--            <artifactId>spring-core</artifactId>-->
<!--            <version>5.2.8.RELEASE</version>-->
<!--        </dependency>-->
<!--        &lt;!&ndash;Spring的基础包Spring-beans&ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>org.springframework</groupId>-->
<!--            <artifactId>spring-beans</artifactId>-->
<!--            <version>5.2.8.RELEASE</version>-->
<!--        </dependency>-->
<!--        &lt;!&ndash;Spring的基础包Spring-context&ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>org.springframework</groupId>-->
<!--            <artifactId>spring-context</artifactId>-->
<!--            <version>5.2.8.RELEASE</version>-->
<!--        </dependency>-->
<!--        &lt;!&ndash;Spring的基础包Spring-expressinon&ndash;&gt;-->
<!--        <dependency>-->
<!--            <groupId>org.springframework</groupId>-->
<!--            <artifactId>spring-expression</artifactId>-->
<!--            <version>5.2.8.RELEASE</version>-->
<!--        </dependency>-->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

        <!--Spring的依赖包commons-logging-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>