【Spring（三）】熟练掌握Spring的使用

于 2022-11-21 10:51:35 发布
阅读量438 收藏 1
点赞数
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35947021/article/details/127941733
版权

 有关Spring的所有文章都收录于我的专栏：👉Spring👈

目录
一、前言
二、通过静态工厂获取对象
三、通过实例工厂获取对象
四、通过FactoryBean获取对象
五、Bean配置信息重用
六、Bean创建顺序
七、Bean对象的单例和多例
八、Bean的生命周期
九、配置Bean的后置处理器
十、通过属性文件给Bean注入值
十一、基于XML的Bean的自动装配

相关文章

【Spring（一）】如何获取对象（Bean）【Spring（一）】如何获取对象（Bean）
【Spring（二）】java对象属性的配置（Bean的配置）【Spring（二）】java对象属性的配置（Bean的配置）

一、前言

我们这一节来讲解一些Spring的剩下的一些基础内容。

二、通过静态工厂获取对象

我们在将Spring的第一节就讲了在Spring中如何来获取Bean对象，那是一种普通的Bean。而我们这里要讲的是另一种Bean：工厂Bean。它的种类有很多种：静态工厂、实例工厂、通过FactoryBean来获取Bean。

在此之前，同样的我们需要先创建一个静态工厂类。

package com.jl.spring.factory;
import com.jl.spring.bean.Monster;
import java.util.HashMap;
/**
 * @author long
 * @date 2022/9/1
 */
public class MyStaticFactory {
    private static HashMap<String, Monster> monsterMap = null;
    static {
        monsterMap = new HashMap<>();
        monsterMap.put("monster01",new Monster(100,"牛魔王","芭蕉扇"));
        monsterMap.put("monster02",new Monster(200,"白骨精","芭蕉扇"));
    }

    public static Monster getMonster(String key){
        return monsterMap.get(key);
    }
}

<!--配置monster对象，通过静态工厂 -->
<bean id="my_monster01" class="com.jl.spring.factory.MyStaticFactory" factory-method="getMonster">
    <constructor-arg name="key" value="monster02"/>
</bean>
<bean id="my_monster04" class="com.jl.spring.factory.MyStaticFactory" factory-method="getMonster">
    <constructor-arg name="key" value="monster02"/>
</bean>
  1. class：是静态工厂的全路径。
  2. factor-method：表示是静态工厂类的哪个方法返回对象。所以我们的静态工厂类里边必须要提供返回对象的静态方法。
  3. <constructor-arg name="key" value="monster02"/>：而且这里的<constructor-arg>并不是和我们前面章节中一样代表的是类的有参构造，而是我们获取对象方法的参数列表。key是我们的形参名，value是指要返回静态工厂中的哪个对象。

测试类

@Test
public void getBeanByStaticFactor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster = ioc.getBean("my_monster01", Monster.class);
    Monster monster04 = ioc.getBean("my_monster04", Monster.class);
    System.out.println(monster);
    System.out.println(monster04);
    //因为是静态工厂，内存中只加载一份，所以获取到的monster对象是同一个
    System.out.println(monster == monster04); //true
}

结果截图
在这里插入图片描述

三、通过实例工厂获取对象

实例工厂类

package com.jl.spring.factory;

import com.jl.spring.bean.Monster;

import java.util.HashMap;

/**
 * @author long
 * @date 2022/9/1
 */
public class MyInstanceFactory {
    private HashMap<String, Monster> monsterMap;
    {
        monsterMap = new HashMap<>();
        monsterMap.put("monster03",new Monster(300,"牛魔王","芭蕉扇"));
        monsterMap.put("monster04",new Monster(400,"白骨精","芭蕉扇"));
    }

    public Monster getMonster(String key){
        return monsterMap.get(key);
    }
}

<!--通过实例工厂获取Bean-->
<!--配置实例工厂-->
<bean id="myInstanceFactory01" class="com.jl.spring.factory.MyInstanceFactory"/>
<bean id="myInstanceFactory02" class="com.jl.spring.factory.MyInstanceFactory"/>

<bean id="my_monster02" factory-bean="myInstanceFactory01" factory-method="getMonster">
    <constructor-arg name="key" value="monster03"/>
</bean>
<bean id="my_monster03" factory-bean="myInstanceFactory02" factory-method="getMonster">
    <constructor-arg name="key" value="monster03"/>
</bean>

因为是实例工厂，所以前提是先得有一个实例工厂。
1.factory-bean：是实例工厂。
2. factory-method：表示是实例工厂类的哪个方法返回对象。
测试类

@Test
public void getBeanByInstanceFactor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster02 = ioc.getBean("my_monster02", Monster.class);
    Monster monster03 = ioc.getBean("my_monster03", Monster.class);
    System.out.println(monster02);
    System.out.println(monster03);
    //因为实例工厂可以有多个，所以获取到的monster对象不是同一个
    System.out.println(monster02 == monster03); //false
}

结果截图
在这里插入图片描述

四、通过FactoryBean获取对象

创建BeanFactory类，需要实现FactoryBean接口。

package com.jl.spring.factory;

import com.jl.spring.bean.Monster;
import org.springframework.beans.factory.FactoryBean;

import java.util.HashMap;
import java.util.Map;

/**
 * @author long
 * @date 2022/9/1
 */
public class MyFactoryBean implements FactoryBean<Monster> {
    private String key;
    private Map<String,Monster> monster_Map;
    {
        monster_Map = new HashMap<>();
        monster_Map.put("monster01",new Monster(100,"牛魔王","芭蕉扇"));
        monster_Map.put("monster02",new Monster(200,"白骨精","芭蕉扇"));
    }

    public void setKey(String key) {
        this.key = key;
    }

    @Override
    public Monster getObject() throws Exception {
        return monster_Map.get(key);
    }

    @Override
    public Class<?> getObjectType() {
        return Monster.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

<!--通过FactoryBean来获取Bean-->
<bean id="my_monster05" class="com.jl.spring.factory.MyFactoryBean">
    <property name="key" value="monster01"/>
</bean>
  1. class：指定使用的FactoryBean。
  2. key：表示就是FactoryBean 属性key。
  3. value：就是想要获取的对象对应的key。

测试类

@Test
public void getBeanByFactorBean(){
     ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
     Monster monster = ioc.getBean("my_monster05", Monster.class);
     System.out.println(monster);
 }

结果截图
在这里插入图片描述

💡补充说明：
在这里插入图片描述
如果value值不是这个工厂类中的就会报如下的错误：
在这里插入图片描述前两个工厂，value也有同样的要求！！！

五 、Bean配置信息重用

当我们多个Bean对象都需要配置一些相同信息的时候，我们可以使用这个信息重用。这有点类似于对象的继承。

<bean id="monster11" class="com.jl.spring.bean.Monster" abstract="true">
    <property name="monsterId" value="800"/>
    <property name="skill" value="蜇人"/>
    <property name="name" value="蝎子精"/>
</bean>
<bean id="monster12" class="com.jl.spring.bean.Monster" parent="monster11"/>
  1. abstract：当值为true的时候，就代表此Bean就只能用于继承，而不能创建为实例对象。
  2. parent：这个属性代表的是，当前的这个类继承于哪个Bean对象。

测试类

@Test
public void getBeanByExtends(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    Monster monster = ioc.getBean("monster12", Monster.class);
    System.out.println(monster);
}

在这里插入图片描述

六 、Bean创建顺序

我们配置文件中的Student、Department类这里不再列出，这里只是演示Bean的创建顺序。

<!--Bean创建顺序-->
<bean id="student01" class="com.jl.spring.bean.Student" depends-on="department01"/>
<bean id="department01" class="com.jl.spring.bean.Department"/>
  1. 默认Bean的创建顺序是从上到下的。
  2. 如果添加了depends-on="department01"，这时就会先去创建id=department01的这个对象。

💡说明：
 当有ref引用的时候，spring容器都是先将所有对象全部创建完，然后再根据ref来调用对应的Setter()进行注入。这个我们在前边提到过。

测试类

@Test
public void sort(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
}

结果截图
在这里插入图片描述
有结果可以看出，虽然Student在Department的前边，但因为Student依赖于Department，所以Spring容器会先创建Department。

七 、Bean对象的单例和多例

 在Spring中, 默认的是按照单例创建的，即：配置一个bean对象后，Spring容器只会创建一个bean实例。如果我们希望配置的某个bean对象，是以多个实例形式创建的则可以通过配置scope="prototype" 来指定。

我们首先创建一个Cat类。

package com.jl.spring.bean;

import java.util.Calendar;

/**
 * @author long
 * @date 2022/8/30
 */
public class Car {
    private Integer id;
    private String name;
    private Integer price;
    public Car(){}
    public Car(Integer id, String name, Integer price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }
}

<!--配置Cat对象-->
<bean id="cat" class="com.jl.spring.bean.Cat" scope="singleton">
    <property name="name" value="小花猫"/>
    <property name="id" value="1010"/>
</bean>

<bean id="cat02" class="com.jl.spring.bean.Cat" scope="prototype">
    <property name="name" value="小花猫"/>
    <property name="id" value="1010"/>
</bean>
<!--我们这里写了两个配置对象，为了演示他们的区别-->
  1. 默认scope = singleton,只在容器中创建一个实例对象。
  2. 当我们执行getBean的时候，返回的是同一个对象。
  3. 如果我们希望每次获取到的是一个新的对象，可以scope=“prototype”。
  4. 我们Spring容器创建bean对象时候，取决于两个条件：scope="singleton"、lazy_init=false（不开启懒加载）。这两个条件也是默认的。
  5. 当我们希望创建单例对象的时机在getBean的时候，可以lazy_init=true。
  6. scope="prototype"的时候，不管lazy_init=true/false ,在getBean的时候才创建对象，因为是多实例对象，Spring不知道你到底需要多少个。

测试类

@Test
public void getBeanByScope(){
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Cat cat = ioc.getBean("cat", Cat.class);
        Cat cat1 = ioc.getBean("cat", Cat.class);
        System.out.println(cat.hashCode());
        System.out.println(cat1.hashCode());
        System.out.println(cat==cat1);
        Cat cat02 = ioc.getBean("cat02", Cat.class);
        Cat cat03 = ioc.getBean("cat02", Cat.class);
        System.out.println(cat02.hashCode());
        System.out.println(cat03.hashCode());
        System.out.println(cat02==cat03);
    }

结果
在这里插入图片描述

八 、Bean的生命周期

House类

package com.jl.spring.bean;

/**
 * @author long
 * @date 2022/9/2
 */
public class House {
    private String name;
    public House() {
        System.out.println("House构造器被执行...");
    }

    public House(String name) {
        this.name = name;
    }

    public String getName() {
        System.out.println("getName()被执行" + name);
        return name;
    }

    public void setName(String name) {
        System.out.println("setName()被执行" + name);
        this.name = name;
    }

    public void init(){
        System.out.println("init()被执行");
    }
    public void destroy(){
        System.out.println("destroy()被执行");
    }
}

<!--配置House，演示bean的生命周期-->
<bean id="house" class="com.jl.spring.bean.House"
      init-method="init"
      destroy-method="destroy">
    <property name="name" value="豪宅"/>
</bean>
  1. init-method="init"指定bean的初始化方法，在Setter方法之后执行。
  2. init方法执行的时机是由Spring容器来控制的。
  3. destroy-method="destroy"指定bean的销毁方法，在容器关闭的时候执行。
  4. destroy方法执行的时机，由Spring容器来控制。
  5. 容器关闭的方法是close()，close方法是ConfigurableApplicationContext接口中定义的，所以需要注意：右边定义的类型必须是继承了实现了该接口的类才行（左编译，右运行）。
  6. 生命周期执行顺序: 构造器->setter方法->初始化方法->销毁方法。

测试类

@Test
public void testBeanLife(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
    House house = ioc.getBean("house", House.class);
    System.out.println("house被创建" + house);
//        左编译，右运行
    ((ConfigurableApplicationContext)ioc).close();
}

结果：
在这里插入图片描述
初始化 init 方法和 destory 方法, 是程序员来指定。
销毁方法就是当关闭容器时才会被调用。即：使用close()方法的时候。

九 、配置Bean的后置处理器

 Spring的后置处理器可以在：Bean对象初始化方法调用前和初始化方法调用后被调用。后置处理器他针对的是Spring容器中所有的Bean对象。后置处理器可以做一些：日期处理/权限的校验/安全的验证/等…。

创建处理器类，处理器类必须实现BeanPostProcessor接口。

package com.jl.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author long
 * @date 2022/9/3
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 什么时候被调用：在Bean的init方法之前
     * @param bean 传入在ioc容器创建的bean
     * @param beanName ioc中配置的bean的id值
     * @return 可以对传入的bean进行 修改/处理， 返回
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof House){
            ((House)bean).setName("上海豪宅");
        }
        System.out.println("postProcessBeforeInitialization" + beanName);
        return bean;
    }

    /**
     *什么时候被调用：在Bean的init方法之后
     * @param bean 传入在ioc容器创建的bean
     * @param beanName ioc中配置的bean的id值
     * @return 可以对传入的bean进行 修改/处理， 返回
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization" + beanName);
        return bean;
    }
}

<bean id="house" class="com.jl.spring.bean.House"
     init-method="init"
     destroy-method="destroy">
   <property name="name" value="大豪宅"/>
</bean>

<!--配置后置处理器-->
<bean class="com.jl.spring.bean.MyBeanPostProcessor"/>
  1. 当我们在xml文件配置了MyBeanPostProcessor，这时后置处理器，就会作用在该容器创建的对象。
  2. 我们配置了这个后置处理器bean对象，Spring是通过使用（反射+动态代理+IO+容器+注解）执行到这个方法的。

测试类

@Test
public void testBeanPostProcessor(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
    House house = ioc.getBean("house", House.class);
    ((ConfigurableApplicationContext)ioc).close();
    System.out.println(house);
}

结果截图：
在这里插入图片描述
后置处理器和我们后边要学习的AOP有很大的关系，所以说很重要！！！

十 、通过属性文件给Bean注入值

 使用配置文件的方式，使我们的程序配置在不修改原有代码的情况下完成修改，可以说是特别的灵活和方便。而我们的Spring也提供了这种方式的使用。

我们这里依然使用我们前边的Monster类来演示，所以不再列出。

monsterId=1000
name=\u8718\u86db   
skill=hello

<!--指定属性文件-->
<context:property-placeholder location="classpath:my.properties"/>
<!--配置Monster对象-->
<bean id="monster1000" class="com.jl.spring.bean.Monster">
    <property name="monsterId" value="${monsterId}"/>
    <property name="name" value="${name}"/>
    <property name="skill" value="${skill}"/>
</bean>
  1. location表示指定属性文件的位置，而且需要带上classpath。
  2. 属性值是通过${属性名}。
  3. 这里的属性名就是properties文件 k=v 中的k。

测试类

/**
 * 通过属性文件注入属性值
 */
@Test
public void setBeanByFile(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
    Monster monster1000 = ioc.getBean("monster1000", Monster.class);
    System.out.println(monster1000);
}

结果截图：
在这里插入图片描述
对于配置文件中要是有中文，需要将其转换为ASCII编码之后的字符

十一 、基于XML的Bean的自动装配

 前边提到了很多有关Bean的配置，但还是有些繁琐，比如：我的Service层调用Dao层，需要创建对象。在前边说过这种情况，我们可以通过ref外部引用或者内部注入的方式。但我们这里将要介绍的，是将这些步骤进一步简化的方式。

我们首先创建两个类：OrderService、OrderDao。

package com.jl.spring.dao;

/**
 * @author long
 * @date 2022/9/3
 */
public class OrderDao {
    public void save(){
        System.out.println("保存订单....");
    }
}

package com.jl.spring.service;

import com.jl.spring.dao.OrderDao;

/**
 * @author long
 * @date 2022/9/3
 */
public class OrderService {
    private OrderDao orderDao;

    public OrderDao getOrderDao() {
        return orderDao;
    }

    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
}


<!--配置OrderDAO对象-->
<bean class="com.jl.spring.dao.OrderDao" id="orderDao"/>
<!--配置OrderService对象-->
<bean autowire="byName" class="com.jl.spring.service.OrderService" id="orderService"/>
<!--配置OrderAction对象-->
<bean autowire="byName" class="com.jl.spring.web.OrderAction" id="orderAction"/>
  1. autowire="byType"表示，在创建orderService的时候通过类型的方式 给对象属性 自动完成赋值/引用。比如：OrderService对象中有OrderDao类型对象，就会在容器中去找有没有OrderDao类型对象。如果有，就会自动的装配，如果按照byType方式装配，在这个容器中，就不能有两个OrderDAO类型的对象。
  2. autowire=“byName“表示通过名字完成自动装配。举个例子：比如autowire="byName"class=“com.jl.spring.service.OrderService”。
  • 第一步：OderService 属性 private OrderDao orderDao。
  • 第二步：根据这个属性的SetXxx方法来找 Xxx来找对象id。
  • 第三步：public void setOrderDao() 就会找到id=orderDao对象来进行自动装配；
  • 第四步：如果没有就装配失败。

这两种方式和我们将要在后边介绍的用注解自动装配差不多！

测试类

@Test
public  void serBeanByAutowire(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
    OrderAction orderAction = ioc.getBean("orderAction", OrderAction.class);
    System.out.println(orderAction.getOrderService().getOrderDao());
    System.out.println(orderAction.getOrderService());
    System.out.println(orderAction);
}

结果截图：
在这里插入图片描述

如果文章中有描述不准确或者错误的地方，还望指正。您可以留言📫或者私信我。🙏
最后希望大家多多 关注+点赞+收藏^_^，你们的鼓励是我不断前进的动力！！！
感谢感谢~~~🙏🙏🙏

艺术留白
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring的使用（入门到熟练）---强势总结
qq_48988285的博客
11-19 570
从Spring入门到熟练，非常详细的教程，包括IOC、DI、自动配置、AOP、动静态代理 CGLIB代理、DAO以及事务的讲解。
熟练掌握spring框架第一篇
java论剑
05-05 238
前言 熟练掌握这个词相信很多同行在写简历的时候都用到过。熟练掌握这四个字是根据每个人水平不一样，理解也不一样。比如一个刚毕业的大学生，他可能也会在简历里面写熟练掌握spring框架，但实际上他并没有看过spring源码，也没有太多实践。可能只是看了几本书，使用spring框架写了一个毕业设计，然后就说自己熟练掌握spring框架了。再比如一个有二三年工作经验的求职者，也在简历里面说自己熟练掌握spring框架，他的理由是他看过spring 的一些关键性代码了，也在实际工作中使用spring开发了工程项目。甚
spring框架入门到熟练
11-27
spring框架入门到熟练，带领你走进spring的世界，就像hello world，让我们一起跟spring 打个招呼吧!
Spring从初认到熟练
GitChat
09-24 226
Spring从初认到熟练，让你一步步掌握使用Spring。
SpringCloud各组件使用
03-14
在现代分布式系统中，SpringCloud作为一个微服务框架的集合，为开发者提供了构建大规模分布式应用所需的全套解决方案。...通过熟练掌握这些组件的原理和实践，开发者可以更高效地构建、部署和管理微服务应用。
spring ioc使用教程
03-12
Spring 框架是 Java 后端开发中的核心组件...理解并熟练运用这些知识点，能够帮助开发者更好地掌握Spring框架，提升后端开发效率。在实际项目中，结合Java编程和Spring的特性，可以构建出高效、稳定且易于维护的系统。
Spring中文文档下载
09-27
通过这些文档，开发者可以详细学习Spring框架的各个组件和最佳实践，掌握如何创建依赖注入、配置事务管理、实现AOP切面、整合数据库操作，以及构建RESTful Web服务等。深入理解并熟练应用Spring，将极大地提升Java...
spring使用注解依赖jar
03-15
在Java开发领域，Spring框架是不可或缺的一个部分，它极大地简化了企业级应用的构建过程。在本主题中，我们将深入探讨"spring使用注解依赖jar"这...理解并熟练掌握这些知识点，将有助于提升你的Java和Spring开发能力。
【Spring Boot】 从入门到熟练，从简介到集成
Aut、mone
11-30 413
一、     简介          Spring Boot是Spring社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于Spring的应用程序和服务，让更多人的人更快的对Spring进行入门体验，让Java开发也能够实现Ruby on Rails那样的生产效率。为Spring生态系统提供了一种固定的、约定优于配置风格的框架。            Spring Boot具有
熟练掌握Spring Cloud，终于成为Java工程师的面试门槛
cidan4756的博客
09-05 315
　　写在前面 　　最近几年，微服务架构一跃成为 IT 领域炙手可热的话题，大量一线互联网公司因为庞大的业务体量和业务需求，纷纷投入了微服务架构的建设中，像阿里巴巴、百度、美团等大厂，很早就已经开始了微服务的实践和应用。 　　一线大厂的带动，让微服务成为了 Java 系程序员面试的必备考点。...
熟练掌握spring框架第三篇
java论剑
05-08 226
接上篇【熟练掌握spring框架第二篇】 bean的生命周期 参考：http://javainsimpleway.com/spring-bean-life-cycle/ 这是一个比较基础但是又比较高频的面试题。如果面试官问你spring bean的生命周期都有哪些？那应该怎样回答呢？在回答之前可以先分析一下这个题目。首先想想面试官问这个问题的目的是什么？换位思考，如果我是面试官，我希望通过这个题目了解求职者对spring框架的了解程度，它是如何管理bean的。在整个bean对生命周期中都有哪些是我们可以参与
一篇让你熟练掌握Spring注解（全网最全）
weixin_41563161的博客
04-23 1703
1.启动相关 @SpringBootApplication 包含了 @ComponentScan、@Configuration 和 @EnableAutoConfiguration 注解。 @ComponentScan 其中 @ComponentScan 让 spring Boot 扫描被@Component (@Service,@Controller)注解的 bean到 Configuration 类并把它加入到程序上下文。 @Configuration（下面有详细版本） @Configuration
全面理解和掌握Spring框架
dcrose的博客
04-12 2810
真正理解和掌握Spring框架1. 理解和掌握Spring框架的意义从发展的层面：最流行的企业级框架从技术的层面：降低开发难度，提高开发效率从项目的层面：促进项目的快速开发、快速部署、快速见效2. 属性注入2.1 什么是属性注入其实很简单，就是将指定的值设置给我们的目标类的目标属性，比如有一个User类，我们要针对它的一个实例user，将它的nickName属性的值设置为“海绵宝宝”，这就是属性注...
Spring Boot 框架熟练使用
小炫风技术旅行
03-20 1008
1. 及时体验,自动生成简单demo 链接2. 注解理解2.1 @RestControllerSpring4之后新加入的注解，原来返回json需要@ResponseBody和@Controller配合。即@RestController是@ResponseBody和@Controller的组合注解。2.2 体验 HelloAPI运行效果:3. 项目属性配置运行效果：配置文件,代码访问值注意:yml文...
熟练使用spring Aop
sqjhwl的专栏
06-09 799
声明：所有的5分钟系列博客都停留在使用的基础上，具体原理，并没有深入探讨，供项目中快速开发使用。   AOP 有多重要，我们在做项目是经常会碰到，权限验证，用户在线验证，数据的事物管理，还有其他个性化的需求里面。使用aop能大大的减少代码的重复性，写出更加符合正常人逻辑的代码！   第一种配置方法 在有spring的项目中简单的使用AOP 如下配置就ok了。例子：
熟练掌握springcloud面试
最新发布
04-30
好的，那我可以为你提供一些关于Spring Cloud面试的常见问题和答案，希望能帮到你。 1. 什么是Spring Cloud？ 答：Spring Cloud是一组基于Spring框架的开源框架，用于快速构建分布式系统中的一些常见模式，例如配置管理、服务发现、断路器、路由、微代理、控制总线、一次性令牌等。它提供了一组工具，可轻松解决大多数分布式系统中的常见问题，并具有高度灵活性和可扩展性。 2. Spring Cloud与Spring Boot有什么区别？ 答：Spring Boot是一个用于构建独立的Spring应用程序的框架，它通过将Spring框架中的各个部件组合在一起，简化了Spring应用程序的开发过程。Spring Cloud则是建立在Spring Boot之上的一组工具，用于构建分布式系统中的一些常见模式。换句话说，Spring Boot是构建应用程序的框架，而Spring Cloud是构建分布式系统的框架。 3. 什么是服务注册与发现？ 答：服务注册和发现是在分布式系统中实现服务管理的重要机制。服务提供者通过向服务注册中心注册自己提供的服务，服务消费者则通过查询服务注册中心来发现可用的服务。Spring Cloud中的Eureka和Consul是两个常用的服务注册与发现工具。 4. 什么是断路器？ 答：断路器是一种用于防止分布式系统中出现级联故障的机制。它可以监视应用程序中的故障率，并在故障率达到一定阈值时打开断路器，阻止请求到达故障的服务。Spring Cloud中的Hystrix是一个流行的断路器实现。 5. 什么是网关？ 答：网关是用于在分布式系统中实现路由、过滤和负载均衡的组件。它可以作为服务的入口点，并根据请求的路由规则将请求转发给相应的服务。Spring Cloud中的Zuul和Spring Cloud Gateway是两个常用的网关实现。 希望这些问题和答案能够帮助你更好地准备Spring Cloud面试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

艺术留白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值