深入浅出Spring框架：从IOC与DI基础到掌握自动装配原理

最新推荐文章于 2024-07-18 13:50:38 发布
最新推荐文章于 2024-07-18 13:50:38 发布
阅读量1.8k 收藏 13
点赞数 11
文章标签： spring java 前端 开发语言 idea intellij-idea 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80237574/article/details/139369800
版权

问题导入

我们为什么要学习Spring框架？

为什么要学
  • Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>==90%==
  • 专业角度 
    •  ==简化开发==，降低企业级开发的复杂性
    • ==框架整合==，高效整合其他技术，提高企业级应用开发与运行效率
怎么学
  •  学习Spring框架设计思想
  •  学习基础操作，思考操作与思想间的联系
  •  学习案例，熟练应用操作的同时，体会思想

 一、Spring核心概念

问题导入

问题1：目前我们的代码存在什么问题以及怎么解决这些问题？

问题2：请描述什么是IOC，什么是DI？

1.1 目前我们代码存在的问题 

  • 代码书写现状
    •  耦合度偏高 
  • 解决方案
    •  使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
1.2 核心概念 
  • ==IOC（Inversion of Control）控制反转==使用对象时，由主动new产生对象转换为由==外部==提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“==将new对象的权利交给Spring，我们从Spring中获取对象使用即可==”

  • Spring技术对IoC思想进行了实现

    • Spring提供了一个容器，称为==IOC容器==，用来充当IoC思想中的“外部”

    •  IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为==Bean==

  • DI（Dependency Injection）依赖注入==

    •  在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

  • 目标：充分解耦
    •  使用IoC容器管理bean（IOC)
    •  在IoC容器内将有依赖关系的bean进行关系绑定（DI）
  • 最终效果
    • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

二、IOC和DI入门案例 

1 IOC入门案例

1.1 门案例思路分析
  1.  管理什么？(Service与Dao)
  2. 如何将被管理的对象告知IOC容器？(配置文件)
  3. 被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
  4.  IOC容器得到后，如何从容器中获取bean？(接口方法)
  5.  使用Spring导入哪些坐标？(pom.xml)
1.2 实现步骤 

【第一步】导入Spring坐标
【第二步】定义Spring管理的类（接口）
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取bean对象

1.3 实现代码 
【第一步】导入Spring坐标
<dependencies>
    <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
</dependencies>
【第二步】定义Spring管理的类（接口) 
  • BookDao接口和BookDaoImpl实现类
public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象
  • 定义applicationContext.xml配置文件并配置BookServiceImpl 
<?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标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookService" class="com.wwc.service.impl.BookServiceImpl"></bean>

</beans>

注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复 

 【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象
public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}
1.4 运行结果 

2 DI入门案例 

2.1 DI入门案例思路分析
  1. 基于IOC管理bean
  2. Service中使用new形式创建的Dao对象是否保留？(否)
  3. Service中需要的Dao对象如何进入到Service中？(提供方法)
  4. Service与Dao间的关系如何描述？(配置)
2.2 实现步骤 

【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系

2.3 实现代码 
  • 环境代码：
    • BookService接口和BookServiceImpl实现类：
public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
【第一步】删除使用new的形式创建对象的代码 
public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
【第二步】提供依赖对象对应的setter方法 
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
【第三步】配置service与dao之间的关系 
  • 在applicationContext.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">
    <!--
        bean标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.wwc.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
            property标签：表示配置当前bean的属性
            name属性：表示配置哪一个具体的属性
            ref属性：表示参照哪一个bean
        -->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

 三、Bean的基础配置

配置说明

四、Bean的实例化 

 问题导入
1、Bean是如何创建
  • bean本质上就是对象，创建bean使用构造方法完成
2、 实例化Bean的三种方式 
2.1 构造方法方式
  • BookDaoImpl实现类
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}
  • applicationContext.xml配置 
<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>
  • AppForInstanceBook测试类 
public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}
  • 运行结果         

注意：无参构造方法如果不存在，将抛出异常`BeanCreationException 

2.2 静态工厂方式
  •  OrderDao接口和OrderDaoImpl实现类
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
  • OrderDaoFatory工厂类 
    //静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}
  • applicationContext.xml配置  
    <!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.wwc.factory.OrderDaoFactory" factory-method="getOrderDao"/>

  • AppForInstanceOrder测试类 
public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}
  • 运行结果
 2.3 实例工厂方式
  • UserDao接口和UserDaoImpl实现类
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
  • UserDaoFactory工厂类 
    //实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
  • applicationContext.xml配置 
<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.wwc.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
  • AppForInstanceUser测试类
public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}
2.4 实现FactoryBean\<T>方式
  • 定义UserDaoFactoryBean实现FactoryBean\<UserDao>
    • UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。 
      //FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}
  •  applicationContext.xml配置 
    <!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.wwc.factory.UserDaoFactoryBean"/>

    使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复 

五、依赖注入(DI配置) 

1 依赖注入方式
问题导入

        依赖注入有几种方式？

1.1 依赖注入的两种方式 
  •   setter注入
    • 简单类型
    • 引用类型(很常用)
  • 构造器注入
    • 简单类型
    • 引用类型
1.2 setter方式注入 
  • 引用类型 
    public class BookServiceImpl implements BookService {
    BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
<bean id="bookDao" name="dao dao2" class="com.wwc.dao.impl.BookDaoImpl" scope="prototype"></bean>
        <bean id="bookService" class="com.wwc.sevice.impl.BookServiceImpl">
                <property name="bookDao" ref="bookDao"></property>
        </bean>

 

  • 简单类型  
    public void setConnecttionNumber(Integer number){
        this.number=number;
    }
  • <bean id="bookDao" name="dao dao2" class="com.wwc.dao.impl.BookDaoImpl" ></bean>
<bean id="bookService" class="com.wwc.sevice.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"></property>
    <property name="number" value="10"></property>
    </bean>

  • 构造方法 

将上面的setter方式注入中的<propertry>改为<constructor-arg>

1.4 依赖注入方式选择
  1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
  2. 可选依赖使用setter注入进行，灵活性强
  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器
  6. 注入自己开发的模块推荐使用setter注入
2 依赖自动装配 
2.1 自动装配概念
  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
  • 自动装配方式
    • 按类型（常用）
    • 按名称
    • 按构造方法
    • 不启用自动装配
2.2 自动装配类型 
  • 依赖自动装配
    • 配置中使用bean标签autowire属性设置自动装配的类型
<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.wwc.service.impl.BookServiceImpl" autowire="byType"/>

 

依赖自动装配特征
  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效 
3 集合注入 
3.1 注入数组类型数据
<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>
3.2 注入List类型数据 
<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>
 3.3 注入Set类型数据
<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>
 3.4 注入Map类型数据
<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>
3.5 注入Properties类型数据 
<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

 说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写\<array>、\<list>、\<set>、\<map>、\<props>标签

六、Bean的生命周期 

1 生命周期相关概念介绍
  • 生命周期：从创建到消亡的完整过程
  • bean生命周期：bean从创建到销毁的整体过程
  • bean生命周期控制：在bean创建后到销毁前做一些事情
2 代码演示 
  • 提供生命周期控制方法
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}
  • applicationContext.xml配置 
<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.wwc.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
  • 测试类 
public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
    }
}
2.2 Bean生命周期控制 
  • 实现InitializingBean, DisposableBean接口

 

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}
3 Bean销毁时机 
  • 容器关闭前触发bean的销毁
  • 关闭容器方式：
    • 手工关闭容器`
      • ConfigurableApplicationContext`接口`close()`操作
    •  注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机`
      •  ConfigurableApplicationContext`接口`registerShutdownHook()`操作 
public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        ctx.registerShutdownHook();
        //关闭容器
        //ctx.close();
    }
}

感谢观看 

 

 

 

 

Java探秘者
关注
  • 11
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
深入理解Java的Spring框架中的IOC容器
09-02
Spring的IOC容器是Spring框架的基础和起点，它的主要功能是实现依赖注入（Dependency Injection，简称DI）。依赖注入是IOC的实现方式，它允许我们将对象的依赖关系从代码中分离出来，转而通过配置文件或注解进行声明...
fizzbuzz-spring:Spring IOC框架的演示应用程序
05-13
本文将以"FizzBuzz-spring"项目为例，深入探讨Spring的IOC（Inversion of Control，控制反转）框架如何实现组件的解耦与灵活配置，同时通过setter注入的方式将FizzBuzz问题分解为更小的可管理对象。 首先，让我们...
深入浅出讲解Spring IOC和DI的区别
小电玩
10-21 703
很多人都会把ioc和di说成同一个东西，其实IOC和DI虽然在概念上可以笼统地视为同一事物，但其本质上存在区别。IOC（Inverse of Control，控制反转）从容器的角度描述，而DI（Dependency Injection，依赖注入）则从应用程序的角度描述。换言之，IOC是依赖倒置原则的设计思想，而DI则是该原则的具体实现方式。因此，我们希望能够更加严谨地区分这两个概念，以更好地理解和应用它们。
Spring框架原理 | IOC/DI | Bean
wei_shuo的博客
10-17 1892
Spring框架是一个开放源代码的J2EE应用程序框架，是针对bean的生命周期进行管理的轻量级容器，提供了功能强大IOC、AOP及Web MVC等功能
【Spring-IOC基础】深入浅出Spring-IOC
ATFWUS的博客
04-20 4万+
IOC（Inversion Of Control） 1.概念： 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统...
【Spring】IOC从演变到自动装配的全攻略详解
万维网连五洲，二进制写尽天下事，喜欢结识新伙伴寻找志同道合的朋友，欢迎一起探讨学习
08-15 546
Spring 框架是一个非常流行的 Java 开发框架，其中的 IOC（Inversion of Control）容器是 Spring 的核心之一。在这篇博客中，我们将深入探讨 IOC 容器的原理和使用方法。通过本文，你将了解到 Spring IOC 容器的工作原理、如何配置和使用 IOC 容器、以及 IOC 容器的优缺点等方面的知识。同时，我们还将通过一些有趣的例子和比喻来帮助你更好地理解 IOC 容器的概念和使用方法。如果你想成为一名优秀的 Java 开发者，那么掌握 Spring IOC 容器的知识是
深入理解Spring两大特性：IoC和AOP
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
Spring框架IoC/DI原理及实现
弱水三千、先干为敬
09-04 630
1、概念 IoC：指将对象的创建权，交给到Spring容器； DI ：指Spring创建对象的过程中，将对象依赖的属性通过配置的方式自动的设值给当前的对象 。 IoC/DI注解详解 完成IoC/DI，有两种方式，一种是使用xml配置文件，另一种是使用注解，我们先来介绍xml方式。 2、xml配置 2.1 使用setter注入（推荐） Setter注入:最常用的注入方法,需要在xml配置文件中进行手...
Spring IoC、DI、Bean和自动装配的理解
09-14 1336
我们都知道IoC是控制反转的，也就是我们只需要把类注册到Spring容器中，他可以帮助我们创建对象，该创建的思想也就是走的构造器 通过XML 例如我们创建一个People对象，默认有一个无参构造 然后我们通过XML将该类注册到Spring中，这样他就是一个bean了，并且被Spring管理 我们进行创建对象的时候，不用new了，而是在Spring容器中拿 通过注解 在用注解之前，我们需要先打开注解的支持和注解要扫描的包 然后创建类，通过@Component注入到Spring，与此作用一样的还有@Servi
自动装配的几种方式——Spring IOC/DI（四）
方圆几里
10-24 1万+
自动装配
【原理分析】细说SpringBoot的自动装配原理
热门推荐
波波烤鸭的博客
07-02 14万+
1.什么是SpringBoot?   对于spring框架，我们接触得比较多的应该是spring mvc、和spring。而spring的核心在于IOC（控制反转对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系）和DI（依赖注入IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了
Spring相关设计思想解析IOC DI DL DP.doc
09-20
在IOC中，对象的生命周期和装配由一个外部容器（如Spring框架）负责，而不是由对象自身或应用程序代码直接控制。这样，对象间的依赖关系得以松散，提高了代码的可测试性和可重用性。 - IOC实现方式主要有两种：依赖...
spring核心IOC以及DI
01-21
【Spring核心IOC以及DI】是Spring框架中的关键概念，它们是Spring实现控制反转（Inversion of Control，简称IOC）和依赖注入（Dependency Injection，简称DI）的基石。这两个概念是Spring框架的核心，使得应用程序的...
SpringIOC:springIOC的简单实现
04-30
Spring IOC，全称为...在SpringIOC-master这个项目中，可能包含了实现Spring IOC的示例代码，包括XML配置、注解配置以及如何使用Spring Boot简化配置的示例。你可以通过研究这些代码来深入理解Spring的IOC机制。
SpringBoot集成EasyExcel实现模板写入多个sheet导出
最新发布
LynneZoe的博客
07-18 190
SpringBoot集成EasyExcel实现模板写入多个sheet导出。
springboot start.aliyun.com java8
JavaUpgrade
07-15 126
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring Security 授权
persistence_PSH的博客
07-14 901
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
springboot基于协同过滤算法的黔醉酒业白酒销售系统lw源码调试讲解
u014445459的博客
07-16 800
本章开始先是介绍了系统进行测试目的及方法，然后简单地阐述了系统测试中常见的黑命、白盒和灰盒测试方法，以及它们各自的特征，随后围绕本系统的注册登录、删除分类、修改密码、等功能进行了功能测试，并将测试用例和测试结果呈现出来，此外，还对实现的系统进行了关于登录和功能模块的压力测试。本系统开发之前的所有调研基本都是本人独立完成，需求设计，功能开发等也都是自己及指导老师的帮助下完成，通过自己的努力解决掉开发过程中所遇到的问题经济支出可以忽略不计，固黔醉酒业白酒销售系统在经济可行性上完全可行可以开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值