Spring的使用（入门到熟练）---强势总结

最新推荐文章于 2024-05-07 15:35:34 发布

小白学习录

最新推荐文章于 2024-05-07 15:35:34 发布

阅读量564

点赞数 1

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

本文链接：https://blog.csdn.net/qq_48988285/article/details/127940171

版权

Spring的使用（入门到熟练）—强势总结

Spring：春天 ==》寓意就是程序员的春天来了

这里抛一个问题在一个项目中如何使用多个框架呢？又怎么将多个框组合到一起？

Spring这个框架最大的功能就是能够为业务逻辑层 提供事务 整合第三方框架 他相当于是所有框架之间的粘合剂。也就是说，这个鬼就像我们的胶水一样，能够把其他的框架整合到一起

1、Spring能干什么

为业务逻辑层提供事务
整合第三方框架
为Controller提供解决方案
为DAO层提供解决方案
提供了AOP编程的这种思想
实现了对象依赖的解耦

2、Spring中的七大模块

在这里插入图片描述

Core：这个是Spring的核心模块主要功能 IOC(控制反转) DI(依赖注入)
AOP：面向切面编程就是将你以前的重复代码，抽取城一个类，然后原来程序在正常运行的时候动态植入我们抽取出来的代码，的这种编程思想就叫做面向切面编程
Web MVC：这个模块就是传说中的 SpringMVC，也就说SpringMVC其实是Spring框架的一个模块哦，别搞错了
Web：Spring这个框架对Web开发的支持
Context：上下文模块(这个就是类似一个类，这个类中保存了程序运行的所有信息，通过这个类就可以找到我们程序运行过程中的所有数据)
DAO：Spring提供了对数据库访问的支持，也就是JdbcTemplate(这个鬼类似于DBUtils的使用)
ORM:(Object Relation Mapping) 对象关系映射即Java对象通过映射关系，映射到数据库表中，也就是表字段与属性一一对应，这里补充一下，Spring整合第三方数据库访问框架有（Hibernate Mybatis Toplink …)

3、Spring的第一个程序

创建一个maven工程，这里是通过idea创建的

在这里插入图片描述

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>org.example</groupId>
    <artifactId>spring-test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--导入Spring的相关包-->
        <!--core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--web mvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <!--事务-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        
        <!--测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

创建User类

package com.csdn.pojo;

/**
 * @author jimoji
 * @date : 2022-11-19
 */
public class User {
   
    private String username;
    private String password;
    public User() {
   
    }

    public User(String username, String password) {
   
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
   
        return username;
    }

    public void setUsername(String username) {
   
        this.username = username;
    }

    public String getPassword() {
   
        return password;
    }

    public void setPassword(String password) {
   
        this.password = password;
    }

    private void init() {
   
        System.out.println("执行了初始化方法");
    }
    private void destory() {
   
        System.out.println("执行了销毁方法");
    }

    @Override
    public String toString() {
   
        return "User{" +
                "username='" + username + '\'' +
                ", password=" + password +
                '}';
    }
}

创建spring配置文件

在这里插入图片描述

spring的配置文件名称是可以任意命名的，一般情况命名为spring.xml或者 spring-config.xml

这里是最齐全的spring-config.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task-3.1.xsd" >

   <!--创建类的对象
        这个Spring创建完对象之后 会放到一个容器中
           这个容器 就叫做 IOC容器  或者 单例池
        id：给这个对象整一个唯一的标识
        name：给生成的对象弄个名字
        class：要生成那个类的对象
        scope：这个表示的是生成对象是单例还是多例呢?
               singleton：表示生成的是单例(单例会放到容器中)
               prototype：这个表示的是生成这个对象是多例的（是不会放到容器中的）
        init-method：当我们的对象放到IOC容器去之后 如果要进行初始化的操作 那么就调用这个后面的方法
        destroy-method：当这个对象在IOC容器中要进行销毁的时候 要执行的方法
    -->
    <bean id="user" class="com.csdn.pojo.User" scope="singleton" init-method="init" destroy-method="destory" lazy-init="false"></bean>
</beans>

接下来测试一波

public class TestUser {
   
    @Test
    public void testUser(){
   
        //classpath:表示resource文件夹的路径
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-config.xml");
		//通过name获取bean
        User user = (User)context.getBean("user");2
            
        System.out.println("拿到的这个对象是：" +user);
        context.close();
    }
}

测试结果

在这里插入图片描述

4、Spring IOC

IOC：控制反转

相信部分小伙伴都会有这个疑问谁控制了谁？什么东西反转了？

接下来说说Java创建对象的方式有哪些 new 反射序列化克隆

IOC这个概念：谁控制了谁？原来闯将对象是程序员自己来完成的学习了Spring之后，我们对象的创建就交给Spring来完成

即Spring控制了Java对象的这个创建

什么东西反转了呢？创建对象的权力反转了，原来由程序员自己完成现在由Spring来完成

4.1通过配置文件创建对象

4.1.1创建简单对象

	 <!--创建类的对象
        这个Spring创建完对象之后 会放到一个容器中
           这个容器 就叫做 IOC容器  或者 单例池
        id：给这个对象整一个唯一的标识
        name：给生成的对象弄个名字
        class：要生成那个类的对象
        scope：这个表示的是生成对象是单例还是多例呢?
               singleton：表示生成的是单例(单例会放到容器中)
               prototype：这个表示的是生成这个对象是多例的（是不会放到容器中的）
        init-method：当我们的对象放到IOC容器去之后 如果要进行初始化的操作 那么就调用这个后面的方法
        destroy-method：当这个对象在IOC容器中要进行销毁的时候 要执行的方法
	  -->
    <bean id="user" class="com.csdn.pojo.User" scope="singleton" init-method="init" destroy-method="destory" lazy-init="false">
	</bean>

4.1.2创建有构造器的对象

	<!--创建一个带有构造器的对象  通过下标来构建我们的这个数据-->
	<bean id="user" class="com.csdn.pojo.User">
        <constructor-arg index="0" value="叽莫叽"></constructor-arg>
        <constructor-arg index="1" value="123"></constructor-arg>
	</bean>

	<!--通过变量名字来初始化我们的对象-->
    <bean id="user2" class="com.csdn.pojo.User">
        <constructor-arg name="password" value="123"></constructor-arg>
        <constructor-arg name="username" value="叽莫叽"></constructor-arg>
	</bean>

4.2静态工厂创建对象

package com.csdn.factory;

import com.csdn.pojo.User;

/**
 * 工厂创建user
 * @author jimoji
 * @date : 2022-11-19
 */
public class UserFactory {
   
    /**
     * 非静态工厂创建对象
     * @return
     */
    public User getUser(){
   
        return new User("非静态工厂创建对象1","11111111111");
    }
    /**
     * 静态方法创建对象
     * @return
     */
    public static User getStaticUser(){
   
        return new User("静态工厂创建对象2","11111111111");
    }
}

编写我们的spring-config.xml

    <!--静态工厂创建对象-->
    <bean id="user3" class="com.csdn.factory.UserFactory" factory-method="getStaticUser"></bean>

	<!--非静态工厂创建对象-->
    <bean id="userFactory" class="com.csdn.factory.UserFactory"></bean>
    <!--
         factory-bean：这个表示的是工厂实例 这个实例一定要放到IOC容器
         factory-bean后面的值 一定是我们容器中对象的这个名字或者id
    -->
    <bean id="user4" factory-bean="userFactory" factory-method="getUser"></bean>

5、Spring DI

DI：依赖注入

谁依赖谁？

回顾一下三层结构 Controller —》Service —》DAO —》DB

你暂时可以这样去认为：

Controller依赖于Service

Serivce依赖于DAO

DAO依赖于DB

即一个类中，维护了另外一个类的实例对象那么我们就可以认为维护的这个类依赖于被维护的这个类

注入了什么东西？

注入的是类的实例对象，还可以是具体的值，简单的说啥都可以注入

注入：说白了就是给成员变量赋值而这个值必须要在IOC容器中，如我们现在已经在xml文件中配置的user user1…都可以被

创建一个UserService

public class UserService {

    private UserDAO userDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void print(){
        userDAO.print();
    }
}

5.1 Set注入

	<bean id="userDAO" class="com.csdn.di.UserDAO"></bean>

    <bean id="userService" class="com.csdn.di.UserService">
        <!--Set注入的前提是这个成员变量一定要有Set方法
              在这种注入数据的方式在开发中用的很多
              ref：这一个表示的是引用 从IOC容器中去找对象  找对象的时候这个ref的值实际上就是我们对象在IOC容器中的这个值
              value：表示给定一个具体的值
        -->
       <!--这里的
			第一个userDAO是UserService类中set方法的名字
			第二个userDAO是xml文件中id=userDAO的bean
		-->
        <property name="userDAO" ref="userDAO"></property>
    </bean>

5.2 p标签注入

注意事项：就是我们的成员变量也必须要写 Set方法
还需要在beans引入 xmlns:p=“http://www.springframework.org/schema/p” 否则没法玩

说明一个问题：p标签注入的底层也是 set注入
<bean id="userDAO" class="com.csdn.di.UserDAO"></bean>
<bean id="userService" class="com.csdn.di.UserService" p:userDAO-ref="userDAO"></bean>

5.3 内部bean注入

<!--第三种注入方式：内部bean注入
        前提是类必须要为成员变量写Set方法
        这种方式的底层也是Set注入
    -->
    <bean id="userService" class="com.csdn.di.UserService">
        <property name="userDAO">
            <bean class="com.csdn.di.UserDAO"></bean>
        </property>
    </bean>

5.4 构造器注入

<!--下面写个构造器注入 说白了 就是在构造器上 为成员变量赋值-->
    <bean id="userDAO" class="com.csdn.di.UserDAO"></bean>
    <bean id="userService" class="com.csdn.di.UserService">
        <constructor-arg